refactor: adjust zcg code for working in x64

src/Parser/Parsing/Impl/AbstractLexer.h

@@ -7,21 +7,82 @@
 #include "Utils/StringUtils.h"
 
 #include <cassert>
+#include <concepts>
 #include <deque>
 #include <sstream>
 
-template<typename TokenType> class AbstractLexer : public ILexer<TokenType>
+template<std::derived_from<IParserValue> TokenType> class AbstractLexer : public ILexer<TokenType>
 {
-    // TokenType must inherit IParserValue
-    static_assert(std::is_base_of<IParserValue, TokenType>::value);
+public:
+    const TokenType& GetToken(const size_t index) override
+    {
+        while (index >= m_token_cache.size())
+            m_token_cache.emplace_back(GetNextToken());
+
+        return m_token_cache[index];
+    }
+
+    void PopTokens(size_t amount) override
+    {
+        if (amount == 0 || m_token_cache.empty())
+            return;
+
+        if (m_token_cache.size() <= amount)
+        {
+            const auto& lastToken = m_token_cache.back();
+            while (
+                !m_line_cache.empty()
+                && (m_line_cache.front().m_line_number != lastToken.GetPos().m_line || *m_line_cache.front().m_filename != lastToken.GetPos().m_filename.get()))
+            {
+                m_line_cache.pop_front();
+                m_line_index--;
+            }
+            m_token_cache.clear();
+        }
+        else
+        {
+            m_token_cache.erase(m_token_cache.begin(), m_token_cache.begin() + amount);
+            const auto& firstToken = m_token_cache.front();
+            while (!m_line_cache.empty()
+                   && (m_line_cache.front().m_line_number != firstToken.GetPos().m_line
+                       || *m_line_cache.front().m_filename != firstToken.GetPos().m_filename.get()))
+            {
+                m_line_cache.pop_front();
+                m_line_index--;
+            }
+        }
+    }
+
+    [[nodiscard]] bool IsEof() override
+    {
+        return GetToken(0).IsEof();
+    }
+
+    [[nodiscard]] const TokenPos& GetPos() override
+    {
+        return GetToken(0).GetPos();
+    }
+
+    [[nodiscard]] ParserLine GetLineForPos(const TokenPos& pos) const override
+    {
+        for (const auto& line : m_line_cache)
+        {
+            if (line.m_filename && *line.m_filename == pos.m_filename.get() && line.m_line_number == pos.m_line)
+            {
+                return line;
+            }
+        }
+
+        return ParserLine();
+    }
 
 protected:
     std::deque<TokenType> m_token_cache;
     std::deque<ParserLine> m_line_cache;
-    IParserLineStream* const m_stream;
+    IParserLineStream* m_stream;
 
-    unsigned m_line_index;
-    unsigned m_current_line_offset;
+    size_t m_line_index;
+    size_t m_current_line_offset;
 
     explicit AbstractLexer(IParserLineStream* stream)
         : m_stream(stream),
@@ -83,28 +144,28 @@ protected:
         return m_line_cache[peekLine].m_line[peekLineOffset];
     }
 
-    _NODISCARD const ParserLine& CurrentLine() const
+    [[nodiscard]] const ParserLine& CurrentLine() const
     {
         return m_line_cache[m_line_index];
     }
 
-    _NODISCARD bool IsLineEnd() const
+    [[nodiscard]] bool IsLineEnd() const
     {
         return m_current_line_offset >= CurrentLine().m_line.size();
     }
 
-    _NODISCARD bool NextCharInLineIs(const char c)
+    [[nodiscard]] bool NextCharInLineIs(const char c)
     {
         return !IsLineEnd() && PeekChar() == c;
     }
 
-    _NODISCARD TokenPos GetPreviousCharacterPos() const
+    [[nodiscard]] TokenPos GetPreviousCharacterPos() const
     {
         const auto& currentLine = CurrentLine();
         return TokenPos(*currentLine.m_filename, currentLine.m_line_number, m_current_line_offset);
     }
 
-    _NODISCARD TokenPos GetNextCharacterPos()
+    [[nodiscard]] TokenPos GetNextCharacterPos()
     {
         const auto& currentLine = CurrentLine();
         if (m_current_line_offset + 1 >= currentLine.m_line.size())
@@ -227,7 +288,7 @@ protected:
         m_current_line_offset += numberLength - 1;
     }
 
-    _NODISCARD bool IsIntegerNumber() const
+    [[nodiscard]] bool IsIntegerNumber() const
     {
         const auto& currentLine = CurrentLine();
         const auto* currentCharacter = &currentLine.m_line.c_str()[m_current_line_offset - 1];
@@ -350,67 +411,4 @@ protected:
             integerValue = ReadInteger();
         }
     }
-
-public:
-    const TokenType& GetToken(unsigned index) override
-    {
-        while (index >= m_token_cache.size())
-            m_token_cache.emplace_back(GetNextToken());
-
-        return m_token_cache[index];
-    }
-
-    void PopTokens(int amount) override
-    {
-        if (amount <= 0 || m_token_cache.empty())
-            return;
-
-        if (static_cast<int>(m_token_cache.size()) <= amount)
-        {
-            const auto& lastToken = m_token_cache.back();
-            while (
-                !m_line_cache.empty()
-                && (m_line_cache.front().m_line_number != lastToken.GetPos().m_line || *m_line_cache.front().m_filename != lastToken.GetPos().m_filename.get()))
-            {
-                m_line_cache.pop_front();
-                m_line_index--;
-            }
-            m_token_cache.clear();
-        }
-        else
-        {
-            m_token_cache.erase(m_token_cache.begin(), m_token_cache.begin() + amount);
-            const auto& firstToken = m_token_cache.front();
-            while (!m_line_cache.empty()
-                   && (m_line_cache.front().m_line_number != firstToken.GetPos().m_line
-                       || *m_line_cache.front().m_filename != firstToken.GetPos().m_filename.get()))
-            {
-                m_line_cache.pop_front();
-                m_line_index--;
-            }
-        }
-    }
-
-    _NODISCARD bool IsEof() override
-    {
-        return GetToken(0).IsEof();
-    }
-
-    _NODISCARD const TokenPos& GetPos() override
-    {
-        return GetToken(0).GetPos();
-    }
-
-    _NODISCARD ParserLine GetLineForPos(const TokenPos& pos) const override
-    {
-        for (const auto& line : m_line_cache)
-        {
-            if (line.m_filename && *line.m_filename == pos.m_filename.get() && line.m_line_number == pos.m_line)
-            {
-                return line;
-            }
-        }
-
-        return ParserLine();
-    }
 };

src/Parser/Parsing/Impl/DefinesStreamProxy.cpp

@@ -5,7 +5,6 @@
 #include "Parsing/Simple/Expression/ISimpleExpression.h"
 #include "Parsing/Simple/Expression/SimpleExpressionMatchers.h"
 #include "Parsing/Simple/SimpleExpressionInterpreter.h"
-#include "Utils/ClassUtils.h"
 #include "Utils/StringUtils.h"
 
 #include <regex>
@@ -114,7 +113,7 @@ void DefinesStreamProxy::Define::IdentifyParameters(const std::vector<std::strin
                 {
                     m_contains_token_pasting_operators = true;
 
-                    // Skip next char since it's # anyway and we do not want to count it as stringize
+                    // Skip next char since it's # anyway, and we do not want to count it as stringize
                     i++;
                 }
             }
@@ -484,7 +483,7 @@ bool DefinesStreamProxy::MatchEndifDirective(const ParserLine& line, const size_
     return true;
 }
 
-bool DefinesStreamProxy::MatchDirectives(ParserLine& line)
+bool DefinesStreamProxy::MatchDirectives(const ParserLine& line)
 {
     size_t directiveStartPos;
     size_t directiveEndPos;
@@ -522,7 +521,7 @@ bool DefinesStreamProxy::FindMacroForIdentifier(const std::string& input,
 }
 
 void DefinesStreamProxy::ExtractParametersFromMacroUsage(
-    const ParserLine& line, unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos)
+    const ParserLine& line, const unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos)
 {
     if (input[inputPos] != '(')
         return;
@@ -588,7 +587,7 @@ void DefinesStreamProxy::ExpandDefinedExpressions(ParserLine& line) const
     }
 }
 
-bool DefinesStreamProxy::FindNextMacro(const std::string& input, unsigned& inputPos, unsigned& defineStart, const DefinesStreamProxy::Define*& define)
+bool DefinesStreamProxy::FindNextMacro(const std::string& input, unsigned& inputPos, unsigned& defineStart, const Define*& define) const
 {
     const auto inputSize = input.size();
     auto wordStart = 0u;
@@ -655,7 +654,7 @@ bool DefinesStreamProxy::FindNextMacro(const std::string& input, unsigned& input
 
 namespace
 {
-    enum class TokenPasteTokenType
+    enum class TokenPasteTokenType : std::uint8_t
     {
         NONE,
         STRING,
@@ -673,13 +672,7 @@ namespace
         {
         }
 
-        ~TokenPasteToken() = default;
-        TokenPasteToken(const TokenPasteToken& other) = default;
-        TokenPasteToken(TokenPasteToken&& other) = default;
-        TokenPasteToken& operator=(const TokenPasteToken& other) = default;
-        TokenPasteToken& operator=(TokenPasteToken&& other) noexcept = default;
-
-        void SetFromInput(ParserLine& line, unsigned& linePos, const std::string& input, unsigned& offset)
+        void SetFromInput(const ParserLine& line, const unsigned& linePos, const std::string& input, unsigned& offset)
         {
             m_start = offset;
 
@@ -698,8 +691,8 @@ namespace
                 }
 
                 if (offset >= inputSize)
-                    throw new ParsingException(TokenPos(*line.m_filename, line.m_line_number, static_cast<int>(linePos + 1)),
-                                               "Token-pasting operator cannot be used on unclosed string");
+                    throw ParsingException(TokenPos(*line.m_filename, line.m_line_number, static_cast<int>(linePos + 1)),
+                                           "Token-pasting operator cannot be used on unclosed string");
 
                 offset++;
             }
@@ -743,12 +736,16 @@ namespace
         unsigned m_end;
     };
 
-    void EmitPastedTokens(
-        ParserLine& line, unsigned& linePos, std::ostream& out, const std::string& input, const TokenPasteToken& token0, const TokenPasteToken& token1)
+    void EmitPastedTokens(const ParserLine& line,
+                          const unsigned& linePos,
+                          std::ostream& out,
+                          const std::string& input,
+                          const TokenPasteToken& token0,
+                          const TokenPasteToken& token1)
     {
         if ((token0.m_type == TokenPasteTokenType::STRING) != (token1.m_type == TokenPasteTokenType::STRING))
-            throw new ParsingException(TokenPos(*line.m_filename, line.m_line_number, static_cast<int>(linePos + 1)),
-                                       "String token can only use token-pasting operator on other string token");
+            throw ParsingException(TokenPos(*line.m_filename, line.m_line_number, static_cast<int>(linePos + 1)),
+                                   "String token can only use token-pasting operator on other string token");
         if (token0.m_type == TokenPasteTokenType::STRING)
         {
             out << '"';
@@ -767,7 +764,7 @@ namespace
 } // namespace
 
 void DefinesStreamProxy::ProcessTokenPastingOperators(
-    ParserLine& line, unsigned& linePos, std::vector<const Define*>& callstack, std::string& input, unsigned& inputPos)
+    const ParserLine& line, const unsigned& linePos, std::vector<const Define*>& callstack, std::string& input, unsigned& inputPos)
 {
     std::ostringstream ss;
 
@@ -789,7 +786,7 @@ void DefinesStreamProxy::ProcessTokenPastingOperators(
         if (c == '#' && IsTokenPastingOperatorForwardLookup(input, i))
         {
             if (currentToken.m_type == TokenPasteTokenType::NONE)
-                throw new ParsingException(CreatePos(line, linePos), "Cannot use token-pasting operator without previous token");
+                throw ParsingException(CreatePos(line, linePos), "Cannot use token-pasting operator without previous token");
 
             if (previousToken.m_end < currentToken.m_start)
                 ss << std::string(input, previousToken.m_end, currentToken.m_start - previousToken.m_end);
@@ -816,12 +813,12 @@ void DefinesStreamProxy::ProcessTokenPastingOperators(
         ss << std::string(input, previousToken.m_end, inputSize - previousToken.m_end);
 
     if (pasteNext)
-        throw new ParsingException(CreatePos(line, linePos), "Cannot use token-pasting operator without following token");
+        throw ParsingException(CreatePos(line, linePos), "Cannot use token-pasting operator without following token");
 
     input = ss.str();
 }
 
-void DefinesStreamProxy::InsertMacroParameters(std::ostringstream& out, const DefinesStreamProxy::Define* macro, std::vector<std::string>& parameterValues)
+void DefinesStreamProxy::InsertMacroParameters(std::ostringstream& out, const Define* macro, const std::vector<std::string>& parameterValues)
 {
     if (parameterValues.empty() || macro->m_parameter_positions.empty())
     {
@@ -829,7 +826,7 @@ void DefinesStreamProxy::InsertMacroParameters(std::ostringstream& out, const De
         return;
     }
 
-    auto lastPos = 0u;
+    auto lastPos = 0uz;
     for (const auto& parameterPosition : macro->m_parameter_positions)
     {
         if (lastPos < parameterPosition.m_parameter_position)
@@ -857,7 +854,7 @@ void DefinesStreamProxy::ExpandMacro(ParserLine& line,
                                      std::ostringstream& out,
                                      std::vector<const Define*>& callstack,
                                      const DefinesStreamProxy::Define* macro,
-                                     std::vector<std::string>& parameterValues)
+                                     const std::vector<std::string>& parameterValues)
 {
     std::ostringstream rawOutput;
     InsertMacroParameters(rawOutput, macro, parameterValues);
@@ -873,7 +870,7 @@ void DefinesStreamProxy::ExpandMacro(ParserLine& line,
 }
 
 void DefinesStreamProxy::ContinueMacroParameters(
-    const ParserLine& line, unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos)
+    const ParserLine& line, const unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos)
 {
     const auto inputLength = input.size();
     while (state.m_parameter_state != ParameterState::NOT_IN_PARAMETERS && inputPos < inputLength)

src/Parser/Parsing/Impl/DefinesStreamProxy.h

@@ -107,26 +107,29 @@ private:
     _NODISCARD bool MatchIfdefDirective(const ParserLine& line, size_t directiveStartPosition, size_t directiveEndPosition);
     _NODISCARD bool MatchElseDirective(const ParserLine& line, size_t directiveStartPosition, size_t directiveEndPosition);
     _NODISCARD bool MatchEndifDirective(const ParserLine& line, size_t directiveStartPosition, size_t directiveEndPosition);
-    _NODISCARD bool MatchDirectives(ParserLine& line);
+    _NODISCARD bool MatchDirectives(const ParserLine& line);
 
-    void ExtractParametersFromMacroUsage(const ParserLine& line, unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos);
-    bool FindMacroForIdentifier(const std::string& input, unsigned wordStart, unsigned wordEnd, const Define*& value) const;
+    static void ExtractParametersFromMacroUsage(
+        const ParserLine& line, const unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos);
+    bool FindMacroForIdentifier(const std::string& input, unsigned identifierStart, unsigned identifierEnd, const Define*& value) const;
 
     static bool MatchDefinedExpression(const ParserLine& line, size_t& pos, std::string& definitionName);
     void ExpandDefinedExpressions(ParserLine& line) const;
 
-    bool FindNextMacro(const std::string& input, unsigned& inputPos, unsigned& defineStart, const DefinesStreamProxy::Define*& define);
+    bool FindNextMacro(const std::string& input, unsigned& inputPos, unsigned& defineStart, const DefinesStreamProxy::Define*& define) const;
 
-    void ProcessTokenPastingOperators(ParserLine& line, unsigned& linePos, std::vector<const Define*>& callstack, std::string& input, unsigned& inputPos);
-    void InsertMacroParameters(std::ostringstream& out, const DefinesStreamProxy::Define* macro, std::vector<std::string>& parameterValues);
+    static void ProcessTokenPastingOperators(
+        const ParserLine& line, const unsigned& linePos, std::vector<const Define*>& callstack, std::string& input, unsigned& inputPos);
+    static void InsertMacroParameters(std::ostringstream& out, const DefinesStreamProxy::Define* macro, const std::vector<std::string>& parameterValues);
     void ExpandMacro(ParserLine& line,
                      unsigned& linePos,
                      std::ostringstream& out,
                      std::vector<const Define*>& callstack,
                      const DefinesStreamProxy::Define* macro,
-                     std::vector<std::string>& parameterValues);
+                     const std::vector<std::string>& parameterValues);
 
-    void ContinueMacroParameters(const ParserLine& line, unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos);
+    static void
+        ContinueMacroParameters(const ParserLine& line, const unsigned& linePos, MacroParameterState& state, const std::string& input, unsigned& inputPos);
     void ContinueMultiLineMacro(ParserLine& line);
 
     void ProcessNestedMacros(ParserLine& line, unsigned& linePos, std::vector<const Define*>& callstack, std::string& input, unsigned& inputPos);