Add empty AM extended command parsing

Author: Argmaster

cpp/gerber/include/gerber/ast/aperture/AM.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include "gerber/ast/aperture/AMclose.hpp"
+#include "gerber/ast/aperture/AMopen.hpp"
+#include "gerber/ast/command.hpp"
+#include "gerber/ast/extended_command.hpp"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace gerber {
+    class AM : public ExtendedCommand {
+      private:
+        std::shared_ptr<AMopen>               amOpen;
+        std::vector<std::shared_ptr<Command>> primitives;
+        std::shared_ptr<AMclose>              amClose;
+
+      public:
+        using primitive_t            = Command;
+        using primitives_container_t = std::vector<std::shared_ptr<primitive_t>>;
+
+        AM(std::shared_ptr<AMopen>  amOpen,
+           primitives_container_t   primitives,
+           std::shared_ptr<AMclose> amClose);
+
+        std::string              getNodeName() const override;
+        std::shared_ptr<AMopen>  getAmOpen() const;
+        primitives_container_t   getPrimitives() const;
+        std::shared_ptr<AMclose> getAmClose() const;
+    };
+} // namespace gerber

cpp/gerber/include/gerber/ast/aperture/AMclose.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include "gerber/ast/node.hpp"
+#include <string>
+
+namespace gerber {
+    class AMclose : public Node {
+      public:
+        AMclose();
+        std::string getNodeName() const override;
+    };
+} // namespace gerber

cpp/gerber/include/gerber/ast/aperture/AMopen.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include "gerber/ast/node.hpp"
+#include <string>
+
+namespace gerber {
+    class AMopen: public Node {
+      private:
+        std::string apertureId;
+
+        AMopen() = delete;
+
+      public:
+        AMopen(const std::string_view& apertureId);
+        std::string getNodeName() const override;
+        std::string getApertureId() const;
+    };
+} // namespace gerber

cpp/gerber/include/gerber/ast/ast.hpp

@@ -7,8 +7,11 @@
 #include "./aperture/AD.hpp"
 #include "./aperture/ADC.hpp"
 #include "./aperture/ADO.hpp"
-#include "./aperture/ADR.hpp"
 #include "./aperture/ADP.hpp"
+#include "./aperture/ADR.hpp"
+#include "./aperture/AM.hpp"
+#include "./aperture/AMclose.hpp"
+#include "./aperture/AMopen.hpp"
 
 #include "./d_codes/D01.hpp"
 #include "./d_codes/D02.hpp"

cpp/gerber/include/gerber/parser.hpp

@@ -36,6 +36,7 @@ namespace gerber {
         std::regex m_code_regex{"^[Mm]0*([1-9][0-9]*)\\*"};
         // Helper regex
         std::regex float_regex{"([+-]?((([0-9]+)(\\.[0-9]*)?)|(\\.[0-9]+)))"};
+        std::regex name_regex{"([._a-zA-Z$][._a-zA-Z0-9]*)"};
 
       public:
         Parser();
@@ -86,22 +87,44 @@ namespace gerber {
          * to point to the next character after the float. If there is no valid float
          * literal throw SyntaxError.
          */
-        double consume_float(std::string_view& source, offset_t& offset);
+        double      consume_float(std::string_view& source, offset_t& offset);
         /**
          * Check if next character in the source string is the expected one. If it is,
          * move source and offset to point to the next character. Otherwise throw SyntaxError.
          */
-        char   consume_char(std::string_view& source, offset_t& offset, char expected);
+        char        consume_char(std::string_view& source, offset_t& offset, char expected);
         /**
          * Check if next character in the source string is the expected one. If it is,
          * move source, offset to point to the next character and return True. Otherwise
          * return False.
          */
-        bool   try_consume_char(std::string_view& source, offset_t& offset, char expected);
+        bool        try_consume_char(std::string_view& source, offset_t& offset, char expected);
+        /**
+         * Check if next characters in the source string match regex. If they do,
+         * move source and offset to point to the next character after the match and
+         * return matched string. Otherwise throw SyntaxError.
+         */
+        std::string consume_regex(std::string_view& source, offset_t& offset, std::regex& expected);
 
         offset_t    match_char(const std::string_view& source, char expected);
         std::string match_float(const std::string_view& source);
 
+        offset_t parse_aperture_macro(const std::string_view& source);
+        void     parse_aperture_macro_open(
+                std::string_view& source, offset_t& offset, std::shared_ptr<AMopen>& amOpen
+            );
+        offset_t parse_aperture_macro_primitive(
+            const std::string_view& source, AM::primitives_container_t& primitives
+        );
+        void parse_aperture_macro_close(
+            std::string_view& source, offset_t& offset, std::shared_ptr<AMclose>& amClose
+        );
+        /**
+         * Check if next characters in the source string are whitespace. If they are,
+         * move source and offset to point to the next character after whitespaces.
+         */
+        void skip_whitespace(std::string_view& source, offset_t& offset);
+
         offset_t parse_g_code(const std::string_view& gerber, const location_t& index);
         offset_t parse_m_code(const std::string_view& gerber);
         offset_t parse_d_code(const std::string_view& source, const location_t& index);

cpp/gerber/src/ast/aperture/AM.cpp

@@ -0,0 +1,28 @@
+#include "gerber/ast/aperture/AM.hpp"
+
+namespace gerber {
+    AM::AM(
+        std::shared_ptr<AMopen>    amOpen_,
+        AM::primitives_container_t primitives_,
+        std::shared_ptr<AMclose>   amClose_
+    ) :
+        amOpen(amOpen_),
+        primitives(primitives_),
+        amClose(amClose_) {}
+
+    std::string AM::getNodeName() const {
+        return "AM";
+    }
+
+    std::shared_ptr<AMopen> AM::getAmOpen() const {
+        return amOpen;
+    }
+
+    AM::primitives_container_t AM::getPrimitives() const {
+        return primitives;
+    }
+
+    std::shared_ptr<AMclose> AM::getAmClose() const {
+        return amClose;
+    }
+} // namespace gerber

cpp/gerber/src/ast/aperture/AMclose.cpp

@@ -0,0 +1,9 @@
+#include "gerber/ast/aperture/AMclose.hpp"
+
+namespace gerber {
+    AMclose::AMclose() {}
+
+    std::string AMclose::getNodeName() const {
+        return "AMclose";
+    }
+} // namespace gerber

cpp/gerber/src/ast/aperture/AMopen.cpp

@@ -0,0 +1,14 @@
+#include "gerber/ast/aperture/AMopen.hpp"
+
+namespace gerber {
+    AMopen::AMopen(const std::string_view& apertureId_) :
+        apertureId(apertureId_) {}
+
+    std::string AMopen::getNodeName() const {
+        return "AMopen";
+    }
+
+    std::string AMopen::getApertureId() const {
+        return apertureId;
+    }
+} // namespace gerber

cpp/gerber/src/parser.cpp

@@ -1,5 +1,6 @@
 #include "gerber/parser.hpp"
 #include "gerber/ast/ast.hpp"
+#include "gerber/ast/command.hpp"
 #include "gerber/ast/m_codes/M02.hpp"
 #include <algorithm>
 #include <cassert>
@@ -119,6 +120,10 @@ namespace gerber {
                 return parse_aperture_definition(source);
                 break;
 
+            case 'M':
+                return parse_aperture_macro(source);
+                break;
+
             default:
                 break;
         }
@@ -253,6 +258,26 @@ namespace gerber {
         return true;
     }
 
+    std::string
+    Parser::consume_regex(std::string_view& source, offset_t& offset, std::regex& expected) {
+        std::cmatch match;
+
+        const auto result = std::regex_search(
+            source.data(),
+            source.data() + source.size(),
+            match,
+            expected,
+            std::regex_constants::match_continuous
+        );
+        if (result && match.size() >= 1) {
+            auto match_length = match.length();
+            offset += match_length;
+            source = source.substr(match_length);
+            return match[0].str();
+        }
+        throw_syntax_error();
+    }
+
     offset_t Parser::match_char(const std::string_view& source, char expected) {
         if (source.empty() || source[0] != expected) {
             throw_syntax_error();
@@ -276,6 +301,62 @@ namespace gerber {
         throw_syntax_error();
     }
 
+    offset_t Parser::parse_aperture_macro(const std::string_view& source) {
+        std::shared_ptr<AMopen>    amOpen;
+        AM::primitives_container_t primitives;
+        std::shared_ptr<AMclose>   amClose;
+
+        std::string_view rest = source;
+
+        offset_t offset = 0;
+        parse_aperture_macro_open(rest, offset, amOpen);
+
+        offset_t previous_offset = offset;
+        while (!source.empty() && previous_offset) {
+            skip_whitespace(rest, offset);
+            previous_offset = parse_aperture_macro_primitive(rest, primitives);
+        }
+
+        parse_aperture_macro_close(rest, offset, amClose);
+
+        commands.push_back(std::make_shared<AM>(amOpen, primitives, amClose));
+        return offset;
+    }
+
+    void Parser::parse_aperture_macro_open(
+        std::string_view& source, offset_t& offset, std::shared_ptr<AMopen>& amOpen
+    ) {
+        consume_char(source, offset, '%');
+        consume_char(source, offset, 'A');
+        consume_char(source, offset, 'M');
+        auto name = consume_regex(source, offset, name_regex);
+        consume_char(source, offset, '*');
+
+        amOpen = std::make_shared<AMopen>(name);
+    }
+
+    offset_t Parser::parse_aperture_macro_primitive(
+        const std::string_view& source, AM::primitives_container_t& primitives
+    ) {
+        return 0;
+    }
+
+    void Parser::parse_aperture_macro_close(
+        std::string_view& source, offset_t& offset, std::shared_ptr<AMclose>& amClose
+    ) {
+        consume_char(source, offset, '%');
+        amClose = std::make_shared<AMclose>();
+    }
+
+    void Parser::skip_whitespace(std::string_view& source, offset_t& offset) {
+        offset_t local_offset = 0;
+        while (local_offset < source.length() && std::isspace(source[local_offset])) {
+            local_offset++;
+        }
+        source = source.substr(local_offset);
+        offset += local_offset;
+    }
+
     offset_t Parser::parse_g_code(const std::string_view& gerber, const location_t& index) {
         std::cmatch match;