Add parser for pkg-config files

.github/workflows/meson.yml

@@ -130,10 +130,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Brew Install
-        run: brew install pkg-config ninja cli11 googletest nlohmann-json fmt cmake meson tl-expected
+        run: brew install pkg-config ninja cli11 googletest nlohmann-json fmt cmake meson tl-expected bison flex
       - name: Build cps-config
         run: |
-          meson setup builddir -Dunity=on -Dunity_size=12
+          PATH=/opt/homebrew/opt/bison/bin:/opt/homebrew/opt/flex/bin:$PATH \
+            meson setup builddir -Dunity=on -Dunity_size=12
           ninja -C builddir
       - name: Run tests
         run: meson test -C builddir

src/CMakeLists.txt

@@ -1,3 +1,10 @@
+# PC file parser
+find_package(BISON REQUIRED)
+find_package(FLEX REQUIRED)
+bison_target(PcParser cps/pc_compat/pc.y ${CMAKE_CURRENT_BINARY_DIR}/cps/pc_compat/pc.parser.cpp)
+flex_target(PcScanner cps/pc_compat/pc.l ${CMAKE_CURRENT_BINARY_DIR}/cps/pc_compat/pc.lexer.cpp)
+add_flex_bison_dependency(PcScanner PcParser)
+
 # cps library
 add_library(
     cps
@@ -8,6 +15,9 @@ add_library(
     cps/search.cpp
     cps/utils.cpp
     cps/version.cpp
+    ${BISON_PcParser_OUTPUTS}
+    ${FLEX_PcScanner_OUTPUTS}
+    cps/pc_compat/pc_loader.cpp
 )
 
 # Configure config.hpp

src/cps/env.cpp

@@ -19,6 +19,9 @@ namespace cps {
             // TODO: Windows
             env.cps_prefix_path = utils::split(env_c, ":");
         }
+        if (const char * env_c = std::getenv("PKG_CONFIG_PATH")) {
+            env.pc_path = std::string(env_c);
+        }
         if (std::getenv("PKG_CONFIG_DEBUG_SPEW") || std::getenv("CPS_CONFIG_DEBUG_SPEW")) {
             env.debug_spew = true;
         }

src/cps/env.hpp

@@ -13,6 +13,7 @@ namespace cps {
     struct Env {
         std::optional<std::string> cps_path = std::nullopt;
         std::optional<std::vector<std::string>> cps_prefix_path = std::nullopt;
+        std::optional<std::string> pc_path = std::nullopt;
         bool debug_spew = false;
     };
 

src/cps/loader.cpp

@@ -17,8 +17,6 @@ namespace cps::loader {
 
     namespace {
 
-        constexpr static std::string_view CPS_VERSION = "0.12.0";
-
         template <typename T>
         tl::expected<std::optional<T>, std::string>
         get_optional(const nlohmann::json & parent, std::string_view parent_name, const std::string & name) {

src/cps/loader.hpp

@@ -140,6 +140,8 @@ namespace cps::loader {
         version::Schema version_schema;
     };
 
+    constexpr inline std::string_view CPS_VERSION = "0.12.0";
+
     tl::expected<Package, std::string> load(std::istream & input_buffer, const std::filesystem::path & filename);
 
 } // namespace cps::loader

src/cps/meson.build

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # Copyright © 2023-2024 Dylan Baker
 
+subdir('pc_compat')
+
 conf = configuration_data()
 conf.set_quoted('CPS_CONFIG_VERSION', meson.project_version())
 conf.set_quoted('CPS_CONFIG_LIBDIR', get_option('libdir'))

src/cps/pc_compat/meson.build

@@ -0,0 +1,34 @@
+_flex_version = '>= 2.6'
+_bison_version = '>= 2.6'
+prog_flex = find_program('', required : false)
+flex_args = []
+prog_bison = find_program('', required : false)
+if host_machine.system() == 'windows'
+  prog_flex = find_program('win_flex', required : false, version : _flex_vesrion)
+  if prog_flex.found()
+    # This uses <io.h> instead of <unistd.h>
+    flex_args = ['--wincompat']
+  endif
+
+  prog_bison = find_program('win_bison', required : false, version : _bison_version)
+endif
+if not prog_flex.found()
+  prog_flex = find_program('flex', version : _flex_version)
+endif
+if not prog_bison.found()
+  prog_bison = find_program('bison', version : _bison_version)
+endif
+
+pc_scanner = custom_target(
+  'pc_scanner',
+  command : [prog_flex, flex_args, '--outfile=@OUTPUT0@', '--header-file=@OUTPUT1@', '@INPUT@'],
+  input : 'pc.l',
+  output : ['@[email protected]', '@[email protected]'],
+)
+
+pc_parser = custom_target(
+  'pc_parser',
+  command : [prog_bison, '-d', '@INPUT@', '-v', '--output=@OUTPUT0@', '--defines=@OUTPUT1@'],
+  input : 'pc.y',
+  output : ['@[email protected]', '@[email protected]', 'locations.hpp']
+)

src/cps/pc_compat/pc.l

@@ -0,0 +1,63 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright © 2024 Haowen Liu
+ */
+
+%option noyywrap
+
+%{
+#include <string>
+#include <istream>
+#include "cps/pc_compat/pc_loader.hpp"
+#include "cps/pc_compat/pc.parser.hpp"
+%}
+
+/* To debug scanner, set debug as an option */
+/* TODO: Add a way to debug scanner without rebuilding */
+%option noyywrap nounput noinput batch
+
+%{
+std::istream *yyinput = nullptr;
+
+#define YY_INPUT(buf,result,max_size) { \
+    yyinput->read(buf, max_size); \
+    result = yyinput->gcount(); \
+}
+%}
+
+str     [^ \t\r\n#:=${}]+
+blank   [ \t\r]+
+comment #[^\n]*
+
+%%
+":"                 { return yy::parser::make_COLON(); }
+"="                 { return yy::parser::make_EQ(); }
+"<"                 { return yy::parser::make_LT(); }
+"<="                { return yy::parser::make_LE(); }
+"!="                { return yy::parser::make_NE(); }
+">="                { return yy::parser::make_GE(); }
+">"                 { return yy::parser::make_GT(); }
+"\n"                { return yy::parser::make_LF(); }
+"$"                 { return yy::parser::make_DOLLAR(); }
+"{"                 { return yy::parser::make_LBRACE(); }
+"}"                 { return yy::parser::make_RBRACE(); }
+","                 { return yy::parser::make_COMMA(); }
+"Requires"          { return yy::parser::make_REQUIRES(); }
+"Requires.private"  { return yy::parser::make_REQUIRES_P(); }
+"Conflicts"         { return yy::parser::make_CONFLICTS(); }
+"Provides"          { return yy::parser::make_PROVIDES(); }
+
+{comment}           {}
+{blank}             { return yy::parser::make_BLANK(yytext); }
+{str}               { return yy::parser::make_STR(yytext); }
+<<EOF>>             { return yy::parser::make_YYEOF(); }
+%%
+
+namespace cps::pc_compat {
+
+    void PcLoader::scan_begin(std::istream &istream) const {
+        yyinput = &istream;
+    }
+
+}
+

src/cps/pc_compat/pc.y

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2024 Haowen Liu
+
+%skeleton "lalr1.cc"
+
+%define api.token.raw
+
+%define api.token.constructor
+%define api.value.type variant
+%define parse.assert
+
+%code requires {
+    #include "cps/utils.hpp"
+    #include "cps/pc_compat/pc_base.hpp"
+}
+
+// The parsing context.
+%param { cps::pc_compat::PcLoader& loader }
+
+%define parse.trace
+%define parse.error detailed
+%define parse.lac full
+
+%code {
+    #include "cps/pc_compat/pc_loader.hpp"
+}
+
+%define api.token.prefix {TOK_}
+%token
+    COLON       ":"
+    LF          "\n"
+    EQ          "="
+    LT          "<"
+    LE          "<="
+    NE          "!="
+    GT          ">"
+    GE          ">="
+    DOLLAR      "$"
+    LBRACE      "{"
+    RBRACE      "}"
+    COMMA       ","
+    REQUIRES    "Requires"
+    REQUIRES_P  "Requires.private"
+    CONFLICTS   "Conflicts"
+    PROVIDES    "Provides"
+;
+
+%token <std::string> STR "str"
+%token <std::string> BLANK "blank"
+%nterm <std::string> literal
+%nterm <std::string> variable
+%nterm <std::string> name
+%nterm <cps::pc_compat::VersionOperation> version_op_token
+%nterm <cps::pc_compat::VersionOperation> version_op
+%nterm <cps::pc_compat::PackageRequirement> package_requirement
+%nterm <std::vector<cps::pc_compat::PackageRequirement>> package_requirements
+%nterm <std::variant<std::string, std::vector<cps::pc_compat::PackageRequirement>>> literal_property
+
+%printer { yyo << $$; } <*>;
+
+%%
+%start file;
+
+// This rule allows for the last line to not be terminated by '\n'
+file:
+    lines
+  | lines statement;
+
+lines:
+    %empty
+  | lines line;
+
+// In this grammar, leading whitespace is handled by this rule.
+// Everything else only takes care of trailing whitespace.
+line:
+    "\n"
+  | statement "\n"
+  | "blank" statement "\n";
+
+// Statement is a meaningful line, not including line feed
+statement:
+    property
+  | assignment;
+
+// property is a line that sets a property to a value
+property:
+    "Requires" colon package_requirements { loader.properties.emplace("Requires", $3); }
+  | "Requires.private" colon package_requirements { loader.properties.emplace("Requires.private", $3); }
+  | "Conflicts" colon package_requirements { loader.properties.emplace("Conflicts", $3); }
+  | "Provides" colon package_requirements { loader.properties.emplace("Provides", $3); }
+  | name colon literal_property { loader.properties.emplace($1, $3); }
+
+// version_op_token captures all the valid tokens for version comparison
+version_op_token:
+    "<" { $$ = cps::pc_compat::VersionOperation::lt; }
+  | "<=" { $$ = cps::pc_compat::VersionOperation::le; }
+  | "=" { $$ = cps::pc_compat::VersionOperation::eq; }
+  | "!=" { $$ = cps::pc_compat::VersionOperation::ne; }
+  | ">" { $$ = cps::pc_compat::VersionOperation::gt; }
+  | ">=" { $$ = cps::pc_compat::VersionOperation::ge; };
+
+// version_op handles trailing space for version comparisons
+version_op:
+    version_op_token
+  | version_op_token "blank" { $$ = $1; };
+
+// package_requirement parses a package name, optionally followed by some version requirement
+package_requirement:
+    name version_op "str" {
+        $$ = cps::pc_compat::PackageRequirement {
+            .package = $1,
+            .operation = $2,
+            .version = $3,
+        };
+    }
+  | package_requirement "blank" { $$ = $1; };
+
+// package_requirements is a comma separated list of package_requirement
+package_requirements:
+    package_requirement { $$ = std::vector{$1}; }
+  | package_requirements comma package_requirement {
+        $1.emplace_back($3);
+        $$ = $1;
+    }
+  | package_requirements comma "str" {
+        $1.emplace_back(cps::pc_compat::PackageRequirement {
+            .package = $3,
+            .operation = std::nullopt,
+            .version = std::nullopt,
+        });
+        $$ = $1;
+    };
+
+// assignment is a line that sets a variable to a value
+assignment:
+    name "=" literal { loader.variables.emplace($1, cps::utils::trim($3)); };
+
+// name handles surrounding spaces for a variable or property name
+name:
+    "str"
+  | "str" "blank" { $$ = $1; };
+
+// literal_property constructs a variant with the trimmed literal value
+literal_property:
+    literal { $$ = cps::pc_compat::PcPropertyValue{std::in_place_type<std::string>, cps::utils::trim($1)}; };
+
+// Literal is a literal string. This could contain trailing whitespace so trim the result before using.
+literal:
+    ":" { $$ = ":"; }
+  | "str" { $$ = $1; }
+  | variable { $$ = $1; }
+  | literal ":" { $$ = $1 + ":"; }
+  | literal "str" { $$ = $1 + $2; }
+  | literal variable { $$ = $1 + $2; }
+  | literal "blank" { $$ = $1 + $2; };
+
+variable:
+    "$" "{" "str" "}" { $$ = loader.variables[$3]; }
+
+// colon and comma handles trailing whitespace
+colon:
+    ":"
+  | ":" "blank";
+comma:
+    ","
+  | "," "blank";
+%%
+
+void
+yy::parser::error (const std::string& m)
+{
+    std::cerr << "Error: " << m << '\n';
+}

src/cps/pc_compat/pc_base.hpp

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2024 Haowen Liu
+
+// This header is created to avoid writing non-trivial C++ code in pc.y.
+// This header contains types and declarations that are needed by both loader and parser.
+
+#pragma once
+
+#include <optional>
+#include <ostream>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace cps::pc_compat {
+    class PcLoader;
+
+    // The following types needs to be declared in the parser because
+    // PackageRequirement is the type of a non-terminal. bison needs
+    // to do a sizeof on this type and cannot do so with a forward
+    // declaration.
+    enum class VersionOperation { lt, le, ne, eq, gt, ge };
+    struct PackageRequirement {
+        std::string package;
+        std::optional<VersionOperation> operation;
+        std::optional<std::string> version;
+
+        // For parser debug output
+        friend std::ostream & operator<<(std::ostream & ost, const PackageRequirement & package_requirement);
+    };
+
+    // For parser debug output
+    std::ostream & operator<<(std::ostream & ost, const std::optional<VersionOperation> & version_operation);
+    std::ostream & operator<<(std::ostream & ost, const std::vector<PackageRequirement> & package_requirements);
+    std::ostream & operator<<(std::ostream & ost,
+                              const std::variant<std::string, std::vector<PackageRequirement>> & property_value);
+} // namespace cps::pc_compat