/src/CMake/Source/cmPkgConfigParser.cxx

Source
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmPkgConfigParser.h"

#include <algorithm>
#include <cctype>
#include <cstddef>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include <cm/string_view>

#include <cmllpkgc/llpkgc.h>

namespace {

cmPkgConfigDependencyOperation LookupDependencyOperation(cm::string_view op)
{
  if (op == "<") {
    return cmPkgConfigDependencyOperation::LessThan;
  }
  if (op == "<=") {
    return cmPkgConfigDependencyOperation::LessThanEqual;
  }
  if (op == "=") {
    return cmPkgConfigDependencyOperation::Equal;
  }
  if (op == "!=") {
    return cmPkgConfigDependencyOperation::NotEqual;
  }
  if (op == ">") {
    return cmPkgConfigDependencyOperation::GreaterThan;
  }
  if (op == ">=") {
    return cmPkgConfigDependencyOperation::GreaterThanEqual;
  }
  return cmPkgConfigDependencyOperation::None;
}

} // namespace

cmPkgConfigValueItem::cmPkgConfigValueItem(std::string text,
                                           bool isSubstitution)
  : Text{ std::move(text) }
  , IsSubstitution{ isSubstitution }
{
}

cmPkgConfigEntry::cmPkgConfigEntry(std::vector<cmPkgConfigValueItem> value,
                                   std::string ident,
                                   cmPkgConfigEntryKind kind)
  : Value{ std::move(value) }
  , Ident{ std::move(ident) }
  , Kind{ kind }
{
}

cmPkgConfigFileParser::cmPkgConfigFileParser()
{
  llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
}

cmPkgConfigFileParser::cmPkgConfigFileParser(
  cmPkgConfigFileParser const& other)
  : cmPkgConfigFileParser()
{
  *this = other;
}

cmPkgConfigFileParser::cmPkgConfigFileParser(
  cmPkgConfigFileParser&& other) noexcept
  : cmPkgConfigFileParser()
{
  *this = std::move(other);
}

cmPkgConfigFileParser& cmPkgConfigFileParser::operator=(
  cmPkgConfigFileParser const& other)
{
  if (this != &other) {
    this->ResetCallbacks();
    llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
    Ptr_ = nullptr;
    Len_ = 0;
    Ident_ = other.Ident_;
    Data_ = other.Data_;
  }
  return *this;
}

cmPkgConfigFileParser& cmPkgConfigFileParser::operator=(
  cmPkgConfigFileParser&& other) noexcept
{
  if (this != &other) {
    this->ResetCallbacks();
    llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
    Ptr_ = nullptr;
    Len_ = 0;
    Ident_ = std::move(other.Ident_);
    Data_ = std::move(other.Data_);
  }
  return *this;
}

void cmPkgConfigFileParser::ResetCallbacks()
{
  Settings_.on_ident = OnIdentTr;
  Settings_.on_value_literal = OnValueLiteralTr;
  Settings_.on_value_substitution = OnValueSubstitutionTr;
  Settings_.on_line_begin = nullptr;
  Settings_.on_property_complete = OnPropertyCompleteTr;
  Settings_.on_variable_complete = OnVariableCompleteTr;
  Settings_.on_barewords_complete = OnBarewordsCompleteTr;
  Settings_.on_value_literal_complete = OnValueLiteralCompleteTr;
  Settings_.on_value_substitution_complete = OnValueSubstitutionCompleteTr;
  Settings_.on_value_complete = OnValueCompleteTr;
  Settings_.on_pkgc_complete = nullptr;
}

llpkgc_file_errno_t cmPkgConfigFileParser::Parse(char const* input,
                                                 std::size_t len)
{
  return llpkgc_file_execute(static_cast<llpkgc_file_t*>(this), input, len);
}

llpkgc_file_errno_t cmPkgConfigFileParser::Finish()
{
  return llpkgc_file_finish(static_cast<llpkgc_file_t*>(this));
}

void cmPkgConfigFileParser::Resume()
{
  llpkgc_file_resume(static_cast<llpkgc_file_t*>(this));
}

llpkgc_file_errno_t cmPkgConfigFileParser::GetErrno() const
{
  return llpkgc_file_get_errno(static_cast<llpkgc_file_t const*>(this));
}

char const* cmPkgConfigFileParser::ErrorReason() const
{
  return llpkgc_file_get_error_reason(static_cast<llpkgc_file_t const*>(this));
}

std::ptrdiff_t cmPkgConfigFileParser::ErrorOffset(char const* base) const
{
  char const* pos =
    llpkgc_file_get_error_pos(static_cast<llpkgc_file_t const*>(this));
  if (pos == nullptr) {
    return -1;
  }
  return pos - base;
}

int cmPkgConfigFileParser::OnIdentNext(char const* at, std::size_t len)
{
  Ident_.append(at, len);
  return 0;
}

int cmPkgConfigFileParser::OnIdentNextTr(llpkgc_file_t* parser, char const* at,
                                         std::size_t len)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnIdentNext(at, len);
}

void cmPkgConfigFileParser::AppendValue(std::string text, bool isSubstitution)
{
  if (!isSubstitution && !Data_.empty() && !Data_.back().Value.empty() &&
      !Data_.back().Value.back().IsSubstitution) {
    Data_.back().Value.back().Text += text;
    return;
  }

  Data_.back().Value.emplace_back(std::move(text), isSubstitution);
}

int cmPkgConfigFileParser::OnSpanNext(char const*, std::size_t len)
{
  Len_ += len;
  return 0;
}

int cmPkgConfigFileParser::OnSpanNextTr(llpkgc_file_t* parser, char const* at,
                                        std::size_t len)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnSpanNext(at, len);
}

int cmPkgConfigFileParser::OnIdent(char const* at, std::size_t len)
{
  Ident_.assign(at, len);
  Settings_.on_ident = OnIdentNextTr;
  return 0;
}

int cmPkgConfigFileParser::OnIdentTr(llpkgc_file_t* parser, char const* at,
                                     std::size_t len)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnIdent(at, len);
}

int cmPkgConfigFileParser::OnPropertyComplete()
{
  Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
                     cmPkgConfigEntryKind::Property);
  Settings_.on_ident = OnIdentTr;
  return 0;
}

int cmPkgConfigFileParser::OnPropertyCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnPropertyComplete();
}

int cmPkgConfigFileParser::OnVariableComplete()
{
  Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
                     cmPkgConfigEntryKind::Variable);
  Settings_.on_ident = OnIdentTr;
  return 0;
}

int cmPkgConfigFileParser::OnVariableCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnVariableComplete();
}

int cmPkgConfigFileParser::OnBarewordsComplete()
{
  Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
                     cmPkgConfigEntryKind::Barewords);
  Settings_.on_ident = OnIdentTr;
  return 0;
}

int cmPkgConfigFileParser::OnBarewordsCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnBarewordsComplete();
}

int cmPkgConfigFileParser::OnValueLiteral(char const* at, std::size_t len)
{
  Ptr_ = at;
  Len_ = len;
  Settings_.on_value_literal = OnSpanNextTr;
  return 0;
}

int cmPkgConfigFileParser::OnValueLiteralTr(llpkgc_file_t* parser,
                                            char const* at, std::size_t len)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnValueLiteral(at, len);
}

int cmPkgConfigFileParser::OnValueLiteralComplete()
{
  Settings_.on_value_literal = OnValueLiteralTr;
  AppendValue(std::string{ Ptr_, Len_ }, false);
  return 0;
}

int cmPkgConfigFileParser::OnValueLiteralCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnValueLiteralComplete();
}

int cmPkgConfigFileParser::OnValueSubstitution(char const* at, std::size_t len)
{
  Ptr_ = at;
  Len_ = len;
  Settings_.on_value_substitution = OnSpanNextTr;
  return 0;
}

int cmPkgConfigFileParser::OnValueSubstitutionTr(llpkgc_file_t* parser,
                                                 char const* at,
                                                 std::size_t len)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnValueSubstitution(at,
                                                                          len);
}

int cmPkgConfigFileParser::OnValueSubstitutionComplete()
{
  Settings_.on_value_substitution = OnValueSubstitutionTr;
  AppendValue(std::string{ Ptr_, Len_ }, true);
  return 0;
}

int cmPkgConfigFileParser::OnValueSubstitutionCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)
    ->OnValueSubstitutionComplete();
}

int cmPkgConfigFileParser::OnValueComplete()
{
  return 0;
}

int cmPkgConfigFileParser::OnValueCompleteTr(llpkgc_file_t* parser)
{
  return static_cast<cmPkgConfigFileParser*>(parser)->OnValueComplete();
}

cmPkgConfigFragmentParser::cmPkgConfigFragmentParser()
{
  llpkgc_frag_init(static_cast<llpkgc_frag_t*>(this), &Settings_);
}

llpkgc_frag_errno_t cmPkgConfigFragmentParser::Parse(char const* input,
                                                     std::size_t len)
{
  return llpkgc_frag_execute(static_cast<llpkgc_frag_t*>(this), input, len);
}

llpkgc_frag_errno_t cmPkgConfigFragmentParser::Finish()
{
  return llpkgc_frag_finish(static_cast<llpkgc_frag_t*>(this));
}

llpkgc_frag_errno_t cmPkgConfigFragmentParser::GetErrno() const
{
  return llpkgc_frag_get_errno(static_cast<llpkgc_frag_t const*>(this));
}

char const* cmPkgConfigFragmentParser::ErrorReason() const
{
  return llpkgc_frag_get_error_reason(static_cast<llpkgc_frag_t const*>(this));
}

int cmPkgConfigFragmentParser::OnFragmentText(char const* at, std::size_t len)
{
  CurrentFragment_.append(at, len);
  return 0;
}

int cmPkgConfigFragmentParser::OnFragmentTextTr(llpkgc_frag_t* parser,
                                                char const* at,
                                                std::size_t len)
{
  return static_cast<cmPkgConfigFragmentParser*>(parser)->OnFragmentText(at,
                                                                         len);
}

int cmPkgConfigFragmentParser::OnFragmentComplete()
{
  Fragments_.push_back(std::move(CurrentFragment_));
  CurrentFragment_.clear();
  return 0;
}

int cmPkgConfigFragmentParser::OnFragmentCompleteTr(llpkgc_frag_t* parser)
{
  return static_cast<cmPkgConfigFragmentParser*>(parser)->OnFragmentComplete();
}

cmPkgConfigDependencyParser::cmPkgConfigDependencyParser()
{
  llpkgc_dep_init(static_cast<llpkgc_dep_t*>(this), &Settings_);
}

llpkgc_dep_errno_t cmPkgConfigDependencyParser::Parse(char const* input,
                                                      std::size_t len)
{
  return llpkgc_dep_execute(static_cast<llpkgc_dep_t*>(this), input, len);
}

llpkgc_dep_errno_t cmPkgConfigDependencyParser::Finish()
{
  return llpkgc_dep_finish(static_cast<llpkgc_dep_t*>(this));
}

llpkgc_dep_errno_t cmPkgConfigDependencyParser::GetErrno() const
{
  return llpkgc_dep_get_errno(static_cast<llpkgc_dep_t const*>(this));
}

char const* cmPkgConfigDependencyParser::ErrorReason() const
{
  return llpkgc_dep_get_error_reason(static_cast<llpkgc_dep_t const*>(this));
}

int cmPkgConfigDependencyParser::OnDependencyName(char const* at,
                                                  std::size_t len)
{
  Current_.Name.assign(at, len);
  return 0;
}

int cmPkgConfigDependencyParser::OnDependencyNameTr(llpkgc_dep_t* parser,
                                                    char const* at,
                                                    std::size_t len)
{
  return static_cast<cmPkgConfigDependencyParser*>(parser)->OnDependencyName(
    at, len);
}

int cmPkgConfigDependencyParser::OnDependencyOperator(char const* at,
                                                      std::size_t len)
{
  Current_.Operation = LookupDependencyOperation(cm::string_view{ at, len });
  return 0;
}

int cmPkgConfigDependencyParser::OnDependencyOperatorTr(llpkgc_dep_t* parser,
                                                        char const* at,
                                                        std::size_t len)
{
  return static_cast<cmPkgConfigDependencyParser*>(parser)
    ->OnDependencyOperator(at, len);
}

int cmPkgConfigDependencyParser::OnDependencyVersion(char const* at,
                                                     std::size_t len)
{
  Current_.Version.assign(at, len);
  return 0;
}

int cmPkgConfigDependencyParser::OnDependencyVersionTr(llpkgc_dep_t* parser,
                                                       char const* at,
                                                       std::size_t len)
{
  return static_cast<cmPkgConfigDependencyParser*>(parser)
    ->OnDependencyVersion(at, len);
}

int cmPkgConfigDependencyParser::OnDependencyComplete()
{
  Dependencies_.push_back(std::move(Current_));
  Current_ = cmPkgConfigDependencySpec{};
  return 0;
}

int cmPkgConfigDependencyParser::OnDependencyCompleteTr(llpkgc_dep_t* parser)
{
  return static_cast<cmPkgConfigDependencyParser*>(parser)
    ->OnDependencyComplete();
}

llpkgc_file_errno_t cmPkgConfigParser::Parse(char const* input,
                                             std::size_t len)
{
  return File_.Parse(input, len);
}

llpkgc_file_errno_t cmPkgConfigParser::Finish()
{
  return File_.Finish();
}

llpkgc_file_errno_t cmPkgConfigParser::Finish(char const* input,
                                              std::size_t len)
{
  auto err = Parse(input, len);
  if (err != PFCE_OK) {
    return err;
  }
  return Finish();
}

llpkgc_file_errno_t cmPkgConfigParser::GetErrno() const
{
  return File_.GetErrno();
}

char const* cmPkgConfigParser::ErrorReason() const
{
  return File_.ErrorReason();
}

std::ptrdiff_t cmPkgConfigParser::ErrorOffset(char const* base) const
{
  return File_.ErrorOffset(base);
}

void cmPkgConfigParser::SetVariable(std::string name, std::string value)
{
  ValueItems variable;
  variable.emplace_back(std::move(value), false);
  StoredVariables_[std::move(name)] = std::move(variable);
  Cache_.clear();
}

std::string cmPkgConfigParser::GetVariable(std::string const& name)
{
  return ResolveValue(StoredVariables_[name]);
}

bool cmPkgConfigParser::HasProperty(std::string const& name) const
{
  return std::any_of(StoredProperties_.begin(), StoredProperties_.end(),
                     [&name](cmPkgConfigEntry const& entry) -> bool {
                       return entry.Ident == name;
                     });
}

std::vector<std::string> cmPkgConfigParser::GetFragments(
  std::string const& name)
{
  auto it = Cache_.find(name);
  if (it != Cache_.end()) {
    return it->second.Fragments;
  }

  cmPkgConfigResolvedValue cache;
  if (!ResolveAndParse(name, cache)) {
    return {};
  }
  return cache.Fragments;
}

std::vector<cmPkgConfigDependencySpec> cmPkgConfigParser::GetDependencies(
  std::string const& name)
{
  auto it = Cache_.find(name);
  if (it != Cache_.end()) {
    return it->second.Dependencies;
  }

  cmPkgConfigResolvedValue cache;
  if (!ResolveAndParse(name, cache)) {
    return {};
  }
  return cache.Dependencies;
}

std::string cmPkgConfigParser::GetLiteral(std::string const& name)
{
  auto it = Cache_.find(name);
  if (it != Cache_.end()) {
    return it->second.Literal;
  }

  cmPkgConfigResolvedValue cache;
  if (!ResolveAndParse(name, cache)) {
    return {};
  }
  return cache.Literal;
}

void cmPkgConfigParser::ParseComplete()
{
  StoredVariables_.clear();
  StoredProperties_.clear();
  Cache_.clear();

  for (auto const& entry : File_.Data_) {
    switch (entry.Kind) {
      case cmPkgConfigEntryKind::Variable:
        StoredVariables_[entry.Ident] = entry.Value;
        break;
      case cmPkgConfigEntryKind::Property:
        StoredProperties_.push_back(entry);
        break;
      default:
        break;
    }
  }
}

std::string cmPkgConfigParser::ResolveValue(ValueItems const& items)
{
  return ResolveValueImpl(items, {});
}

std::string cmPkgConfigParser::ResolveValueImpl(
  ValueItems const& items, std::set<std::string> resolving)
{
  std::string result;
  if (items.empty()) {
    return result;
  }

  for (auto const& item : items) {
    if (item.IsSubstitution) {
      if (resolving.count(item.Text)) {
        result += "${";
        result += item.Text;
        result += "}";
        continue;
      }
      auto it = StoredVariables_.find(item.Text);
      if (it != StoredVariables_.end()) {
        resolving.insert(item.Text);
        result += ResolveValueImpl(it->second, resolving);
      }
    } else {
      result += item.Text;
    }
  }

  return result;
}

bool cmPkgConfigParser::ResolveAndParse(std::string const& name,
                                        cmPkgConfigResolvedValue& cache)
{
  cmPkgConfigEntry const* entry = nullptr;
  for (auto const& candidate : StoredProperties_) {
    if (candidate.Ident == name) {
      entry = &candidate;
      break;
    }
  }
  if (entry == nullptr) {
    return false;
  }

  std::string resolved = ResolveValue(entry->Value);
  auto start = resolved.find_first_not_of(" \t");
  if (start != std::string::npos) {
    resolved.erase(0, start);
  }
  cache.Literal = resolved;

  std::string lower = name;
  for (auto& c : lower) {
    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
  }

  if (IsFragmentProperty(lower)) {
    cmPkgConfigFragmentParser fragmentParser;
    auto err = fragmentParser.Parse(resolved.data(), resolved.size());
    if (err == PFFE_OK && fragmentParser.Finish() == PFFE_OK) {
      cache.Fragments = fragmentParser.Fragments();
    }
  } else if (IsDependencyProperty(lower)) {
    cmPkgConfigDependencyParser dependencyParser;
    auto err = dependencyParser.Parse(resolved.data(), resolved.size());
    if (err == PDEP_OK && dependencyParser.Finish() == PDEP_OK) {
      cache.Dependencies = dependencyParser.Dependencies();
    }
  }

  Cache_[name] = cache;
  return true;
}

bool cmPkgConfigParser::IsFragmentProperty(std::string const& lower)
{
  return lower == "cflags" || lower == "cflags.private" ||
    lower == "cflags.shared" || lower == "libs" || lower == "libs.private" ||
    lower == "libs.shared";
}

bool cmPkgConfigParser::IsDependencyProperty(std::string const& lower)
{
  return lower == "conflicts" || lower == "provides" || lower == "requires" ||
    lower == "requires.private" || lower == "requires.internal" ||
    lower == "requires.shared";
}

Coverage Report

Created: 2026-07-30 06:52

Line	Count	Source
1		/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2		file LICENSE.rst or https://cmake.org/licensing for details. */
3
4		#include "cmPkgConfigParser.h"
5
6		#include <algorithm>
7		#include <cctype>
8		#include <cstddef>
9		#include <set>
10		#include <string>
11		#include <unordered_map>
12		#include <utility>
13		#include <vector>
14
15		#include <cm/string_view>
16
17		#include <cmllpkgc/llpkgc.h>
18
19		namespace {
20
21		cmPkgConfigDependencyOperation LookupDependencyOperation(cm::string_view op)
22	0	{
23	0	if (op == "<") {
24	0	return cmPkgConfigDependencyOperation::LessThan;
25	0	}
26	0	if (op == "<=") {
27	0	return cmPkgConfigDependencyOperation::LessThanEqual;
28	0	}
29	0	if (op == "=") {
30	0	return cmPkgConfigDependencyOperation::Equal;
31	0	}
32	0	if (op == "!=") {
33	0	return cmPkgConfigDependencyOperation::NotEqual;
34	0	}
35	0	if (op == ">") {
36	0	return cmPkgConfigDependencyOperation::GreaterThan;
37	0	}
38	0	if (op == ">=") {
39	0	return cmPkgConfigDependencyOperation::GreaterThanEqual;
40	0	}
41	0	return cmPkgConfigDependencyOperation::None;
42	0	}
43
44		} // namespace
45
46		cmPkgConfigValueItem::cmPkgConfigValueItem(std::string text,
47		bool isSubstitution)
48	4	: Text{ std::move(text) }
49	4	, IsSubstitution{ isSubstitution }
50	4	{
51	4	}
52
53		cmPkgConfigEntry::cmPkgConfigEntry(std::vector<cmPkgConfigValueItem> value,
54		std::string ident,
55		cmPkgConfigEntryKind kind)
56	1.77k	: Value{ std::move(value) }
57	1.77k	, Ident{ std::move(ident) }
58	1.77k	, Kind{ kind }
59	1.77k	{
60	1.77k	}
61
62		cmPkgConfigFileParser::cmPkgConfigFileParser()
63	1	{
64	1	llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
65	1	}
66
67		cmPkgConfigFileParser::cmPkgConfigFileParser(
68		cmPkgConfigFileParser const& other)
69	0	: cmPkgConfigFileParser()
70	0	{
71	0	*this = other;
72	0	}
73
74		cmPkgConfigFileParser::cmPkgConfigFileParser(
75		cmPkgConfigFileParser&& other) noexcept
76	0	: cmPkgConfigFileParser()
77	0	{
78	0	*this = std::move(other);
79	0	}
80
81		cmPkgConfigFileParser& cmPkgConfigFileParser::operator=(
82		cmPkgConfigFileParser const& other)
83	0	{
84	0	if (this != &other) {
85	0	this->ResetCallbacks();
86	0	llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
87	0	Ptr_ = nullptr;
88	0	Len_ = 0;
89	0	Ident_ = other.Ident_;
90	0	Data_ = other.Data_;
91	0	}
92	0	return *this;
93	0	}
94
95		cmPkgConfigFileParser& cmPkgConfigFileParser::operator=(
96		cmPkgConfigFileParser&& other) noexcept
97	0	{
98	0	if (this != &other) {
99	0	this->ResetCallbacks();
100	0	llpkgc_file_init(static_cast<llpkgc_file_t*>(this), &Settings_);
101	0	Ptr_ = nullptr;
102	0	Len_ = 0;
103	0	Ident_ = std::move(other.Ident_);
104	0	Data_ = std::move(other.Data_);
105	0	}
106	0	return *this;
107	0	}
108
109		void cmPkgConfigFileParser::ResetCallbacks()
110	0	{
111	0	Settings_.on_ident = OnIdentTr;
112	0	Settings_.on_value_literal = OnValueLiteralTr;
113	0	Settings_.on_value_substitution = OnValueSubstitutionTr;
114	0	Settings_.on_line_begin = nullptr;
115	0	Settings_.on_property_complete = OnPropertyCompleteTr;
116	0	Settings_.on_variable_complete = OnVariableCompleteTr;
117	0	Settings_.on_barewords_complete = OnBarewordsCompleteTr;
118	0	Settings_.on_value_literal_complete = OnValueLiteralCompleteTr;
119	0	Settings_.on_value_substitution_complete = OnValueSubstitutionCompleteTr;
120	0	Settings_.on_value_complete = OnValueCompleteTr;
121	0	Settings_.on_pkgc_complete = nullptr;
122	0	}
123
124		llpkgc_file_errno_t cmPkgConfigFileParser::Parse(char const* input,
125		std::size_t len)
126	1	{
127	1	return llpkgc_file_execute(static_cast<llpkgc_file_t*>(this), input, len);
128	1	}
129
130		llpkgc_file_errno_t cmPkgConfigFileParser::Finish()
131	1	{
132	1	return llpkgc_file_finish(static_cast<llpkgc_file_t*>(this));
133	1	}
134
135		void cmPkgConfigFileParser::Resume()
136	0	{
137	0	llpkgc_file_resume(static_cast<llpkgc_file_t*>(this));
138	0	}
139
140		llpkgc_file_errno_t cmPkgConfigFileParser::GetErrno() const
141	0	{
142	0	return llpkgc_file_get_errno(static_cast<llpkgc_file_t const*>(this));
143	0	}
144
145		char const* cmPkgConfigFileParser::ErrorReason() const
146	0	{
147	0	return llpkgc_file_get_error_reason(static_cast<llpkgc_file_t const*>(this));
148	0	}
149
150		std::ptrdiff_t cmPkgConfigFileParser::ErrorOffset(char const* base) const
151	0	{
152	0	char const* pos =
153	0	llpkgc_file_get_error_pos(static_cast<llpkgc_file_t const*>(this));
154	0	if (pos == nullptr) {
155	0	return -1;
156	0	}
157	0	return pos - base;
158	0	}
159
160		int cmPkgConfigFileParser::OnIdentNext(char const* at, std::size_t len)
161	0	{
162	0	Ident_.append(at, len);
163	0	return 0;
164	0	}
165
166		int cmPkgConfigFileParser::OnIdentNextTr(llpkgc_file_t* parser, char const* at,
167		std::size_t len)
168	0	{
169	0	return static_cast<cmPkgConfigFileParser*>(parser)->OnIdentNext(at, len);
170	0	}
171
172		void cmPkgConfigFileParser::AppendValue(std::string text, bool isSubstitution)
173	6	{
174	6	if (!isSubstitution && !Data_.empty() && !Data_.back().Value.empty() &&
175	2	!Data_.back().Value.back().IsSubstitution) {
176	2	Data_.back().Value.back().Text += text;
177	2	return;
178	2	}
179
180	4	Data_.back().Value.emplace_back(std::move(text), isSubstitution);
181	4	}
182
183		int cmPkgConfigFileParser::OnSpanNext(char const*, std::size_t len)
184	0	{
185	0	Len_ += len;
186	0	return 0;
187	0	}
188
189		int cmPkgConfigFileParser::OnSpanNextTr(llpkgc_file_t* parser, char const* at,
190		std::size_t len)
191	0	{
192	0	return static_cast<cmPkgConfigFileParser*>(parser)->OnSpanNext(at, len);
193	0	}
194
195		int cmPkgConfigFileParser::OnIdent(char const* at, std::size_t len)
196	1.77k	{
197	1.77k	Ident_.assign(at, len);
198	1.77k	Settings_.on_ident = OnIdentNextTr;
199	1.77k	return 0;
200	1.77k	}
201
202		int cmPkgConfigFileParser::OnIdentTr(llpkgc_file_t* parser, char const* at,
203		std::size_t len)
204	1.77k	{
205	1.77k	return static_cast<cmPkgConfigFileParser*>(parser)->OnIdent(at, len);
206	1.77k	}
207
208		int cmPkgConfigFileParser::OnPropertyComplete()
209	4	{
210	4	Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
211	4	cmPkgConfigEntryKind::Property);
212	4	Settings_.on_ident = OnIdentTr;
213	4	return 0;
214	4	}
215
216		int cmPkgConfigFileParser::OnPropertyCompleteTr(llpkgc_file_t* parser)
217	4	{
218	4	return static_cast<cmPkgConfigFileParser*>(parser)->OnPropertyComplete();
219	4	}
220
221		int cmPkgConfigFileParser::OnVariableComplete()
222	0	{
223	0	Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
224	0	cmPkgConfigEntryKind::Variable);
225	0	Settings_.on_ident = OnIdentTr;
226	0	return 0;
227	0	}
228
229		int cmPkgConfigFileParser::OnVariableCompleteTr(llpkgc_file_t* parser)
230	0	{
231	0	return static_cast<cmPkgConfigFileParser*>(parser)->OnVariableComplete();
232	0	}
233
234		int cmPkgConfigFileParser::OnBarewordsComplete()
235	1.77k	{
236	1.77k	Data_.emplace_back(std::vector<cmPkgConfigValueItem>{}, Ident_,
237	1.77k	cmPkgConfigEntryKind::Barewords);
238	1.77k	Settings_.on_ident = OnIdentTr;
239	1.77k	return 0;
240	1.77k	}
241
242		int cmPkgConfigFileParser::OnBarewordsCompleteTr(llpkgc_file_t* parser)
243	1.77k	{
244	1.77k	return static_cast<cmPkgConfigFileParser*>(parser)->OnBarewordsComplete();
245	1.77k	}
246
247		int cmPkgConfigFileParser::OnValueLiteral(char const* at, std::size_t len)
248	6	{
249	6	Ptr_ = at;
250	6	Len_ = len;
251	6	Settings_.on_value_literal = OnSpanNextTr;
252	6	return 0;
253	6	}
254
255		int cmPkgConfigFileParser::OnValueLiteralTr(llpkgc_file_t* parser,
256		char const* at, std::size_t len)
257	6	{
258	6	return static_cast<cmPkgConfigFileParser*>(parser)->OnValueLiteral(at, len);
259	6	}
260
261		int cmPkgConfigFileParser::OnValueLiteralComplete()
262	6	{
263	6	Settings_.on_value_literal = OnValueLiteralTr;
264	6	AppendValue(std::string{ Ptr_, Len_ }, false);
265	6	return 0;
266	6	}
267
268		int cmPkgConfigFileParser::OnValueLiteralCompleteTr(llpkgc_file_t* parser)
269	6	{
270	6	return static_cast<cmPkgConfigFileParser*>(parser)->OnValueLiteralComplete();
271	6	}
272
273		int cmPkgConfigFileParser::OnValueSubstitution(char const* at, std::size_t len)
274	0	{
275	0	Ptr_ = at;
276	0	Len_ = len;
277	0	Settings_.on_value_substitution = OnSpanNextTr;
278	0	return 0;
279	0	}
280
281		int cmPkgConfigFileParser::OnValueSubstitutionTr(llpkgc_file_t* parser,
282		char const* at,
283		std::size_t len)
284	0	{
285	0	return static_cast<cmPkgConfigFileParser*>(parser)->OnValueSubstitution(at,
286	0	len);
287	0	}
288
289		int cmPkgConfigFileParser::OnValueSubstitutionComplete()
290	0	{
291	0	Settings_.on_value_substitution = OnValueSubstitutionTr;
292	0	AppendValue(std::string{ Ptr_, Len_ }, true);
293	0	return 0;
294	0	}
295
296		int cmPkgConfigFileParser::OnValueSubstitutionCompleteTr(llpkgc_file_t* parser)
297	0	{
298	0	return static_cast<cmPkgConfigFileParser*>(parser)
299	0	->OnValueSubstitutionComplete();
300	0	}
301
302		int cmPkgConfigFileParser::OnValueComplete()
303	1.77k	{
304	1.77k	return 0;
305	1.77k	}
306
307		int cmPkgConfigFileParser::OnValueCompleteTr(llpkgc_file_t* parser)
308	1.77k	{
309	1.77k	return static_cast<cmPkgConfigFileParser*>(parser)->OnValueComplete();
310	1.77k	}
311
312		cmPkgConfigFragmentParser::cmPkgConfigFragmentParser()
313	0	{
314	0	llpkgc_frag_init(static_cast<llpkgc_frag_t*>(this), &Settings_);
315	0	}
316
317		llpkgc_frag_errno_t cmPkgConfigFragmentParser::Parse(char const* input,
318		std::size_t len)
319	0	{
320	0	return llpkgc_frag_execute(static_cast<llpkgc_frag_t*>(this), input, len);
321	0	}
322
323		llpkgc_frag_errno_t cmPkgConfigFragmentParser::Finish()
324	0	{
325	0	return llpkgc_frag_finish(static_cast<llpkgc_frag_t*>(this));
326	0	}
327
328		llpkgc_frag_errno_t cmPkgConfigFragmentParser::GetErrno() const
329	0	{
330	0	return llpkgc_frag_get_errno(static_cast<llpkgc_frag_t const*>(this));
331	0	}
332
333		char const* cmPkgConfigFragmentParser::ErrorReason() const
334	0	{
335	0	return llpkgc_frag_get_error_reason(static_cast<llpkgc_frag_t const*>(this));
336	0	}
337
338		int cmPkgConfigFragmentParser::OnFragmentText(char const* at, std::size_t len)
339	0	{
340	0	CurrentFragment_.append(at, len);
341	0	return 0;
342	0	}
343
344		int cmPkgConfigFragmentParser::OnFragmentTextTr(llpkgc_frag_t* parser,
345		char const* at,
346		std::size_t len)
347	0	{
348	0	return static_cast<cmPkgConfigFragmentParser*>(parser)->OnFragmentText(at,
349	0	len);
350	0	}
351
352		int cmPkgConfigFragmentParser::OnFragmentComplete()
353	0	{
354	0	Fragments_.push_back(std::move(CurrentFragment_));
355	0	CurrentFragment_.clear();
356	0	return 0;
357	0	}
358
359		int cmPkgConfigFragmentParser::OnFragmentCompleteTr(llpkgc_frag_t* parser)
360	0	{
361	0	return static_cast<cmPkgConfigFragmentParser*>(parser)->OnFragmentComplete();
362	0	}
363
364		cmPkgConfigDependencyParser::cmPkgConfigDependencyParser()
365	0	{
366	0	llpkgc_dep_init(static_cast<llpkgc_dep_t*>(this), &Settings_);
367	0	}
368
369		llpkgc_dep_errno_t cmPkgConfigDependencyParser::Parse(char const* input,
370		std::size_t len)
371	0	{
372	0	return llpkgc_dep_execute(static_cast<llpkgc_dep_t*>(this), input, len);
373	0	}
374
375		llpkgc_dep_errno_t cmPkgConfigDependencyParser::Finish()
376	0	{
377	0	return llpkgc_dep_finish(static_cast<llpkgc_dep_t*>(this));
378	0	}
379
380		llpkgc_dep_errno_t cmPkgConfigDependencyParser::GetErrno() const
381	0	{
382	0	return llpkgc_dep_get_errno(static_cast<llpkgc_dep_t const*>(this));
383	0	}
384
385		char const* cmPkgConfigDependencyParser::ErrorReason() const
386	0	{
387	0	return llpkgc_dep_get_error_reason(static_cast<llpkgc_dep_t const*>(this));
388	0	}
389
390		int cmPkgConfigDependencyParser::OnDependencyName(char const* at,
391		std::size_t len)
392	0	{
393	0	Current_.Name.assign(at, len);
394	0	return 0;
395	0	}
396
397		int cmPkgConfigDependencyParser::OnDependencyNameTr(llpkgc_dep_t* parser,
398		char const* at,
399		std::size_t len)
400	0	{
401	0	return static_cast<cmPkgConfigDependencyParser*>(parser)->OnDependencyName(
402	0	at, len);
403	0	}
404
405		int cmPkgConfigDependencyParser::OnDependencyOperator(char const* at,
406		std::size_t len)
407	0	{
408	0	Current_.Operation = LookupDependencyOperation(cm::string_view{ at, len });
409	0	return 0;
410	0	}
411
412		int cmPkgConfigDependencyParser::OnDependencyOperatorTr(llpkgc_dep_t* parser,
413		char const* at,
414		std::size_t len)
415	0	{
416	0	return static_cast<cmPkgConfigDependencyParser*>(parser)
417	0	->OnDependencyOperator(at, len);
418	0	}
419
420		int cmPkgConfigDependencyParser::OnDependencyVersion(char const* at,
421		std::size_t len)
422	0	{
423	0	Current_.Version.assign(at, len);
424	0	return 0;
425	0	}
426
427		int cmPkgConfigDependencyParser::OnDependencyVersionTr(llpkgc_dep_t* parser,
428		char const* at,
429		std::size_t len)
430	0	{
431	0	return static_cast<cmPkgConfigDependencyParser*>(parser)
432	0	->OnDependencyVersion(at, len);
433	0	}
434
435		int cmPkgConfigDependencyParser::OnDependencyComplete()
436	0	{
437	0	Dependencies_.push_back(std::move(Current_));
438	0	Current_ = cmPkgConfigDependencySpec{};
439	0	return 0;
440	0	}
441
442		int cmPkgConfigDependencyParser::OnDependencyCompleteTr(llpkgc_dep_t* parser)
443	0	{
444	0	return static_cast<cmPkgConfigDependencyParser*>(parser)
445	0	->OnDependencyComplete();
446	0	}
447
448		llpkgc_file_errno_t cmPkgConfigParser::Parse(char const* input,
449		std::size_t len)
450	1	{
451	1	return File_.Parse(input, len);
452	1	}
453
454		llpkgc_file_errno_t cmPkgConfigParser::Finish()
455	1	{
456	1	return File_.Finish();
457	1	}
458
459		llpkgc_file_errno_t cmPkgConfigParser::Finish(char const* input,
460		std::size_t len)
461	0	{
462	0	auto err = Parse(input, len);
463	0	if (err != PFCE_OK) {
464	0	return err;
465	0	}
466	0	return Finish();
467	0	}
468
469		llpkgc_file_errno_t cmPkgConfigParser::GetErrno() const
470	0	{
471	0	return File_.GetErrno();
472	0	}
473
474		char const* cmPkgConfigParser::ErrorReason() const
475	0	{
476	0	return File_.ErrorReason();
477	0	}
478
479		std::ptrdiff_t cmPkgConfigParser::ErrorOffset(char const* base) const
480	0	{
481	0	return File_.ErrorOffset(base);
482	0	}
483
484		void cmPkgConfigParser::SetVariable(std::string name, std::string value)
485	0	{
486	0	ValueItems variable;
487	0	variable.emplace_back(std::move(value), false);
488	0	StoredVariables_[std::move(name)] = std::move(variable);
489	0	Cache_.clear();
490	0	}
491
492		std::string cmPkgConfigParser::GetVariable(std::string const& name)
493	0	{
494	0	return ResolveValue(StoredVariables_[name]);
495	0	}
496
497		bool cmPkgConfigParser::HasProperty(std::string const& name) const
498	0	{
499	0	return std::any_of(StoredProperties_.begin(), StoredProperties_.end(),
500	0	[&name](cmPkgConfigEntry const& entry) -> bool {
501	0	return entry.Ident == name;
502	0	});
503	0	}
504
505		std::vector<std::string> cmPkgConfigParser::GetFragments(
506		std::string const& name)
507	6	{
508	6	auto it = Cache_.find(name);
509	6	if (it != Cache_.end()) {
510	0	return it->second.Fragments;
511	0	}
512
513	6	cmPkgConfigResolvedValue cache;
514	6	if (!ResolveAndParse(name, cache)) {
515	6	return {};
516	6	}
517	0	return cache.Fragments;
518	6	}
519
520		std::vector<cmPkgConfigDependencySpec> cmPkgConfigParser::GetDependencies(
521		std::string const& name)
522	4	{
523	4	auto it = Cache_.find(name);
524	4	if (it != Cache_.end()) {
525	0	return it->second.Dependencies;
526	0	}
527
528	4	cmPkgConfigResolvedValue cache;
529	4	if (!ResolveAndParse(name, cache)) {
530	4	return {};
531	4	}
532	0	return cache.Dependencies;
533	4	}
534
535		std::string cmPkgConfigParser::GetLiteral(std::string const& name)
536	3	{
537	3	auto it = Cache_.find(name);
538	3	if (it != Cache_.end()) {
539	0	return it->second.Literal;
540	0	}
541
542	3	cmPkgConfigResolvedValue cache;
543	3	if (!ResolveAndParse(name, cache)) {
544	3	return {};
545	3	}
546	0	return cache.Literal;
547	3	}
548
549		void cmPkgConfigParser::ParseComplete()
550	1	{
551	1	StoredVariables_.clear();
552	1	StoredProperties_.clear();
553	1	Cache_.clear();
554
555	1.77k	for (auto const& entry : File_.Data_) {
556	1.77k	switch (entry.Kind) {
557	0	case cmPkgConfigEntryKind::Variable:
558	0	StoredVariables_[entry.Ident] = entry.Value;
559	0	break;
560	4	case cmPkgConfigEntryKind::Property:
561	4	StoredProperties_.push_back(entry);
562	4	break;
563	1.77k	default:
564	1.77k	break;
565	1.77k	}
566	1.77k	}
567	1	}
568
569		std::string cmPkgConfigParser::ResolveValue(ValueItems const& items)
570	0	{
571	0	return ResolveValueImpl(items, {});
572	0	}
573
574		std::string cmPkgConfigParser::ResolveValueImpl(
575		ValueItems const& items, std::set<std::string> resolving)
576	0	{
577	0	std::string result;
578	0	if (items.empty()) {
579	0	return result;
580	0	}
581
582	0	for (auto const& item : items) {
583	0	if (item.IsSubstitution) {
584	0	if (resolving.count(item.Text)) {
585	0	result += "${";
586	0	result += item.Text;
587	0	result += "}";
588	0	continue;
589	0	}
590	0	auto it = StoredVariables_.find(item.Text);
591	0	if (it != StoredVariables_.end()) {
592	0	resolving.insert(item.Text);
593	0	result += ResolveValueImpl(it->second, resolving);
594	0	}
595	0	} else {
596	0	result += item.Text;
597	0	}
598	0	}
599
600	0	return result;
601	0	}
602
603		bool cmPkgConfigParser::ResolveAndParse(std::string const& name,
604		cmPkgConfigResolvedValue& cache)
605	13	{
606	13	cmPkgConfigEntry const* entry = nullptr;
607	52	for (auto const& candidate : StoredProperties_) {
608	52	if (candidate.Ident == name) {
609	0	entry = &candidate;
610	0	break;
611	0	}
612	52	}
613	13	if (entry == nullptr) {
614	13	return false;
615	13	}
616
617	0	std::string resolved = ResolveValue(entry->Value);
618	0	auto start = resolved.find_first_not_of(" \t");
619	0	if (start != std::string::npos) {
620	0	resolved.erase(0, start);
621	0	}
622	0	cache.Literal = resolved;
623
624	0	std::string lower = name;
625	0	for (auto& c : lower) {
626	0	c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
627	0	}
628
629	0	if (IsFragmentProperty(lower)) {
630	0	cmPkgConfigFragmentParser fragmentParser;
631	0	auto err = fragmentParser.Parse(resolved.data(), resolved.size());
632	0	if (err == PFFE_OK && fragmentParser.Finish() == PFFE_OK) {
633	0	cache.Fragments = fragmentParser.Fragments();
634	0	}
635	0	} else if (IsDependencyProperty(lower)) {
636	0	cmPkgConfigDependencyParser dependencyParser;
637	0	auto err = dependencyParser.Parse(resolved.data(), resolved.size());
638	0	if (err == PDEP_OK && dependencyParser.Finish() == PDEP_OK) {
639	0	cache.Dependencies = dependencyParser.Dependencies();
640	0	}
641	0	}
642
643	0	Cache_[name] = cache;
644	0	return true;
645	13	}
646
647		bool cmPkgConfigParser::IsFragmentProperty(std::string const& lower)
648	0	{
649	0	return lower == "cflags" \|\| lower == "cflags.private" \|\|
650	0	lower == "cflags.shared" \|\| lower == "libs" \|\| lower == "libs.private" \|\|
651	0	lower == "libs.shared";
652	0	}
653
654		bool cmPkgConfigParser::IsDependencyProperty(std::string const& lower)
655	0	{
656	0	return lower == "conflicts" \|\| lower == "provides" \|\| lower == "requires" \|\|
657	0	lower == "requires.private" \|\| lower == "requires.internal" \|\|
658	0	lower == "requires.shared";
659	0	}