CMake/Source/cmPkgConfigParser.h

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

#pragma once

#include "cmConfigure.h" // IWYU pragma: keep

#include <cstddef>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>

#include <cmllpkgc/llpkgc.h>

struct cmPkgConfigValueItem
{
  cmPkgConfigValueItem() = default;
  cmPkgConfigValueItem(std::string text, bool isSubstitution);

  std::string Text;
  bool IsSubstitution = false;
};

enum class cmPkgConfigEntryKind
{
  Property,
  Variable,
  Barewords,
};

struct cmPkgConfigEntry
{
  cmPkgConfigEntry() = default;
  cmPkgConfigEntry(std::vector<cmPkgConfigValueItem> value, std::string ident,
                   cmPkgConfigEntryKind kind);

  std::vector<cmPkgConfigValueItem> Value;
  std::string Ident;
  cmPkgConfigEntryKind Kind = cmPkgConfigEntryKind::Barewords;
};

class cmPkgConfigFileParser : private llpkgc_file_t
{
  friend class cmPkgConfigParser;

public:
  cmPkgConfigFileParser();
  cmPkgConfigFileParser(cmPkgConfigFileParser const& other);
  cmPkgConfigFileParser(cmPkgConfigFileParser&& other) noexcept;
  cmPkgConfigFileParser& operator=(cmPkgConfigFileParser const& other);
  cmPkgConfigFileParser& operator=(cmPkgConfigFileParser&& other) noexcept;

  llpkgc_file_errno_t Parse(char const* input, std::size_t len);
  llpkgc_file_errno_t Finish();
  void Resume();

  llpkgc_file_errno_t GetErrno() const;
  char const* ErrorReason() const;
  std::ptrdiff_t ErrorOffset(char const* base) const;

private:
  void ResetCallbacks();

  int OnIdentNext(char const* at, std::size_t len);
  static int OnIdentNextTr(llpkgc_file_t* parser, char const* at,
                           std::size_t len);

  void AppendValue(std::string text, bool isSubstitution);

  int OnSpanNext(char const*, std::size_t len);
  static int OnSpanNextTr(llpkgc_file_t* parser, char const* at,
                          std::size_t len);

  int OnIdent(char const* at, std::size_t len);
  static int OnIdentTr(llpkgc_file_t* parser, char const* at, std::size_t len);

  int OnPropertyComplete();
  static int OnPropertyCompleteTr(llpkgc_file_t* parser);

  int OnVariableComplete();
  static int OnVariableCompleteTr(llpkgc_file_t* parser);

  int OnBarewordsComplete();
  static int OnBarewordsCompleteTr(llpkgc_file_t* parser);

  int OnValueLiteral(char const* at, std::size_t len);
  static int OnValueLiteralTr(llpkgc_file_t* parser, char const* at,
                              std::size_t len);

  int OnValueLiteralComplete();
  static int OnValueLiteralCompleteTr(llpkgc_file_t* parser);

  int OnValueSubstitution(char const* at, std::size_t len);
  static int OnValueSubstitutionTr(llpkgc_file_t* parser, char const* at,
                                   std::size_t len);

  int OnValueSubstitutionComplete();
  static int OnValueSubstitutionCompleteTr(llpkgc_file_t* parser);

  int OnValueComplete();
  static int OnValueCompleteTr(llpkgc_file_t* parser);

  llpkgc_file_settings_t Settings_{
    OnIdentTr,
    OnValueLiteralTr,
    OnValueSubstitutionTr,
    nullptr, // on_line_begin
    OnPropertyCompleteTr,
    OnVariableCompleteTr,
    OnBarewordsCompleteTr,
    OnValueLiteralCompleteTr,
    OnValueSubstitutionCompleteTr,
    OnValueCompleteTr,
    nullptr, // on_pkgc_complete
  };

  char const* Ptr_ = nullptr;
  std::size_t Len_ = 0;
  std::string Ident_;
  std::vector<cmPkgConfigEntry> Data_;
};

class cmPkgConfigFragmentParser : private llpkgc_frag_t
{
public:
  cmPkgConfigFragmentParser();

  llpkgc_frag_errno_t Parse(char const* input, std::size_t len);
  llpkgc_frag_errno_t Finish();

  llpkgc_frag_errno_t GetErrno() const;
  char const* ErrorReason() const;

  std::vector<std::string> const& Fragments() const { return Fragments_; }

private:
  int OnFragmentText(char const* at, std::size_t len);
  static int OnFragmentTextTr(llpkgc_frag_t* parser, char const* at,
                              std::size_t len);

  int OnFragmentComplete();
  static int OnFragmentCompleteTr(llpkgc_frag_t* parser);

  llpkgc_frag_settings_t Settings_{
    OnFragmentTextTr, OnFragmentCompleteTr,
    nullptr, // on_fraglist_complete
  };

  std::string CurrentFragment_;
  std::vector<std::string> Fragments_;
};

enum class cmPkgConfigDependencyOperation
{
  None,
  LessThan,
  LessThanEqual,
  Equal,
  NotEqual,
  GreaterThan,
  GreaterThanEqual,
};

struct cmPkgConfigDependencySpec
{
  std::string Name;
  cmPkgConfigDependencyOperation Operation =
    cmPkgConfigDependencyOperation::None;
  std::string Version;
};

class cmPkgConfigDependencyParser : private llpkgc_dep_t
{
public:
  cmPkgConfigDependencyParser();

  llpkgc_dep_errno_t Parse(char const* input, std::size_t len);
  llpkgc_dep_errno_t Finish();

  llpkgc_dep_errno_t GetErrno() const;
  char const* ErrorReason() const;

  std::vector<cmPkgConfigDependencySpec> const& Dependencies() const
  {
    return Dependencies_;
  }

private:
  int OnDependencyName(char const* at, std::size_t len);
  static int OnDependencyNameTr(llpkgc_dep_t* parser, char const* at,
                                std::size_t len);

  int OnDependencyOperator(char const* at, std::size_t len);
  static int OnDependencyOperatorTr(llpkgc_dep_t* parser, char const* at,
                                    std::size_t len);

  int OnDependencyVersion(char const* at, std::size_t len);
  static int OnDependencyVersionTr(llpkgc_dep_t* parser, char const* at,
                                   std::size_t len);

  int OnDependencyComplete();
  static int OnDependencyCompleteTr(llpkgc_dep_t* parser);

  llpkgc_dep_settings_t Settings_{
    OnDependencyNameTr,
    OnDependencyOperatorTr,
    OnDependencyVersionTr,
    OnDependencyCompleteTr,
    nullptr, // on_dep_list_complete
  };

  cmPkgConfigDependencySpec Current_;
  std::vector<cmPkgConfigDependencySpec> Dependencies_;
};

struct cmPkgConfigResolvedValue
{
  std::vector<std::string> Fragments;
  std::vector<cmPkgConfigDependencySpec> Dependencies;
  std::string Literal;
};

class cmPkgConfigParser
{
public:
  cmPkgConfigParser() = default;

  llpkgc_file_errno_t Parse(char const* input, std::size_t len);
  llpkgc_file_errno_t Finish();
  llpkgc_file_errno_t Finish(char const* data, std::size_t len);

  llpkgc_file_errno_t GetErrno() const;
  char const* ErrorReason() const;
  std::ptrdiff_t ErrorOffset(char const* base) const;

  void SetVariable(std::string name, std::string value);
  std::string GetVariable(std::string const& name);
  bool HasProperty(std::string const& name) const;
  std::vector<std::string> GetFragments(std::string const& name);
  std::vector<cmPkgConfigDependencySpec> GetDependencies(
    std::string const& name);
  std::string GetLiteral(std::string const& name);

  void ParseComplete();

private:
  using ValueItems = std::vector<cmPkgConfigValueItem>;

  std::string ResolveValue(ValueItems const& items);
  std::string ResolveValueImpl(ValueItems const& items,
                               std::set<std::string> resolving);

  bool ResolveAndParse(std::string const& name,
                       cmPkgConfigResolvedValue& cache);

  static bool IsFragmentProperty(std::string const& lower);
  static bool IsDependencyProperty(std::string const& lower);

  cmPkgConfigFileParser File_;
  std::unordered_map<std::string, ValueItems> StoredVariables_;
  std::vector<cmPkgConfigEntry> StoredProperties_;
  std::unordered_map<std::string, cmPkgConfigResolvedValue> Cache_;
};