xref: /aosp_15_r20/system/libvintf/FQName.cpp (revision 70a7ec852fcefd15a4fb57f8f183a8b1c3aacb08)

/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <vintf/FQName.h>

#include <android-base/logging.h>
#include <android-base/parseint.h>
#include <android-base/strings.h>
#include <iostream>
#include <sstream>

namespace android::vintf::details {

FQName::FQName() : mIsIdentifier(false) {}

bool FQName::parse(const std::string& s, FQName* into) {
    return into->setTo(s);
}

FQName::FQName(const std::string& package, const std::string& version, const std::string& name) {
    size_t majorVer, minorVer;
    CHECK(parseVersion(version, &majorVer, &minorVer));
    CHECK(setTo(package, majorVer, minorVer, name)) << string();
}

bool FQName::setTo(const std::string& package, size_t majorVer, size_t minorVer,
                   const std::string& name) {
    mPackage = package;
    mMajor = majorVer;
    mMinor = minorVer;
    mName = name;

    FQName other;
    if (!parse(string(), &other)) return false;
    if ((*this) != other) return false;
    mIsIdentifier = other.isIdentifier();
    return true;
}

bool FQName::isIdentifier() const {
    return mIsIdentifier;
}

bool FQName::isInterfaceName() const {
    return !mName.empty() && mName[0] == 'I' && mName.find('.') == std::string::npos;
}

static inline bool isIdentStart(char a) {
    return ('a' <= a && a <= 'z') || ('A' <= a && a <= 'Z') || a == '_';
}
static inline bool isLeadingDigit(char a) {
    return '1' <= a && a <= '9';
}
static inline bool isDigit(char a) {
    return '0' <= a && a <= '9';
}
static inline bool isIdentBody(char a) {
    return isIdentStart(a) || isDigit(a);
}

// returns pointer to end of [a-zA-Z_][a-zA-Z0-9_]*
static const char* eatIdent(const char* l, const char* end) {
    if (!(l < end && isIdentStart(*l++))) return nullptr;
    while (l < end && isIdentBody(*l)) l++;
    return l;
}

// returns pointer to end of <ident>(\.<ident>)*
static const char* eatPackage(const char* l, const char* end) {
    if ((l = eatIdent(l, end)) == nullptr) return nullptr;

    while (l < end && *l == '.') {
        l++;
        if ((l = eatIdent(l, end)) == nullptr) return nullptr;
    }
    return l;
}

// returns pointer to end of [1-9][0-9]*|0
static const char* eatNumber(const char* l, const char* end) {
    if (!(l < end)) return nullptr;
    if (*l == '0') return l + 1;
    if (!isLeadingDigit(*l++)) return nullptr;
    while (l < end && isDigit(*l)) l++;
    return l;
}

bool FQName::setTo(const std::string& s) {
    clear();

    if (s.empty()) return false;

    const char* l = s.c_str();
    const char* end = l + s.size();
    // [email protected]::IFoo.Type
    // S                   ES ES E S        E
    //
    // S - start pointer
    // E - end pointer

    struct StartEnd {
        const char* start = nullptr;
        const char* end = nullptr;

        std::string string() {
            if (start == nullptr) return std::string();
            return std::string(start, end - start);
        }
    };
    StartEnd package, major, minor, name;

    if (l < end && isIdentStart(*l)) {
        package.start = l;
        if ((package.end = l = eatPackage(l, end)) == nullptr) return false;
    }
    if (l < end && *l == '@') {
        l++;

        major.start = l;
        if ((major.end = l = eatNumber(l, end)) == nullptr) return false;

        if (!(l < end && *l++ == '.')) return false;

        minor.start = l;
        if ((minor.end = l = eatNumber(l, end)) == nullptr) return false;
    }
    if (l < end && *l == ':') {
        l++;
        if (l < end && *l == ':') {
            l++;
            name.start = l;
            if ((name.end = l = eatPackage(l, end)) == nullptr) return false;
        } else {
            return false;
        }
    }

    if (l < end) return false;

    CHECK((major.start == nullptr) == (minor.start == nullptr));

    // if we only parse a package, consider this to be a name
    if (name.start == nullptr && major.start == nullptr) {
        name.start = package.start;
        name.end = package.end;
        package.start = package.end = nullptr;
    }

    // failures after this goto fail to clear
    mName = name.string();
    mPackage = package.string();

    if (major.start != nullptr) {
        if (!parseVersion(major.string(), minor.string(), &mMajor, &mMinor)) goto fail;
    } else if (mPackage.empty() && name.end == eatIdent(name.start, name.end)) {
        // major.start == nullptr
        mIsIdentifier = true;
    }

    if (!mPackage.empty() && version().empty()) goto fail;

    return true;
fail:
    clear();
    return false;
}

const std::string& FQName::package() const {
    return mPackage;
}

std::string FQName::version() const {
    if (!hasVersion()) {
        return "";
    }
    return std::to_string(mMajor) + "." + std::to_string(mMinor);
}

std::string FQName::atVersion() const {
    std::string v = version();
    return v.empty() ? "" : ("@" + v);
}

void FQName::clear() {
    mIsIdentifier = false;
    mPackage.clear();
    clearVersion();
    mName.clear();
}

void FQName::clearVersion(size_t* majorVer, size_t* minorVer) {
    *majorVer = *minorVer = 0;
}

bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr,
                          size_t* majorVer, size_t* minorVer) {
    bool versionParseSuccess = ::android::base::ParseUint(majorStr, majorVer) &&
                               ::android::base::ParseUint(minorStr, minorVer);
    if (!versionParseSuccess) {
        LOG(ERROR) << "numbers in " << majorStr << "." << minorStr << " are out of range.";
    }
    return versionParseSuccess;
}

bool FQName::parseVersion(const std::string& v, size_t* majorVer, size_t* minorVer) {
    if (v.empty()) {
        clearVersion(majorVer, minorVer);
        return true;
    }

    std::vector<std::string> vs = base::Split(v, ".");
    if (vs.size() != 2) return false;
    return parseVersion(vs[0], vs[1], majorVer, minorVer);
}

bool FQName::setVersion(const std::string& v) {
    return parseVersion(v, &mMajor, &mMinor);
}

void FQName::clearVersion() {
    clearVersion(&mMajor, &mMinor);
}

bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr) {
    return parseVersion(majorStr, minorStr, &mMajor, &mMinor);
}

const std::string& FQName::name() const {
    return mName;
}

std::string FQName::string() const {
    std::string out;
    out.append(mPackage);
    out.append(atVersion());
    if (!mName.empty()) {
        if (!mPackage.empty() || !version().empty()) {
            out.append("::");
        }
        out.append(mName);
    }

    return out;
}

bool FQName::operator<(const FQName& other) const {
    return string() < other.string();
}

bool FQName::operator==(const FQName& other) const {
    return string() == other.string();
}

bool FQName::operator!=(const FQName& other) const {
    return !(*this == other);
}

const std::string& FQName::getInterfaceName() const {
    CHECK(isInterfaceName()) << mName;

    return mName;
}

FQName FQName::getPackageAndVersion() const {
    return FQName(package(), version(), "");
}

std::vector<std::string> FQName::getPackageComponents() const {
    return base::Split(package(), ".");
}

bool FQName::hasVersion() const {
    return mMajor > 0;
}

std::pair<size_t, size_t> FQName::getVersion() const {
    return {mMajor, mMinor};
}

size_t FQName::getPackageMajorVersion() const {
    CHECK(hasVersion()) << "FQName: No version exists at getPackageMajorVersion(). "
                        << "Did you check hasVersion()?";
    return mMajor;
}

size_t FQName::getPackageMinorVersion() const {
    CHECK(hasVersion()) << "FQName: No version exists at getPackageMinorVersion(). "
                        << "Did you check hasVersion()?";
    return mMinor;
}

bool FQName::inPackage(const std::string& package) const {
    std::vector<std::string> components = getPackageComponents();
    std::vector<std::string> inComponents = base::Split(package, ".");

    if (inComponents.size() > components.size()) {
        return false;
    }

    for (size_t i = 0; i < inComponents.size(); i++) {
        if (inComponents[i] != components[i]) {
            return false;
        }
    }

    return true;
}

}  // namespace android::vintf::details