Rename defines if directive parsing to defines directive parsing

src/Parser/Parsing/Impl/Defines/DefinesDirectiveExpressionSequence.cpp

@@ -0,0 +1,16 @@
+#include "DefinesDirectiveExpressionSequence.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+#include "DefinesExpressionMatchers.h"
+
+DefinesDirectiveExpressionSequence::DefinesDirectiveExpressionSequence()
+{
+    const SimpleMatcherFactory create(this);
+    AddLabeledMatchers(DefinesExpressionMatchers().Expression(this), SimpleExpressionMatchers::LABEL_EXPRESSION);
+    AddMatchers(create.Label(SimpleExpressionMatchers::LABEL_EXPRESSION));
+}
+
+void DefinesDirectiveExpressionSequence::ProcessMatch(DefinesDirectiveParsingState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    state->m_expression = DefinesExpressionMatchers(state).ProcessExpression(result);
+}

src/Parser/Parsing/Impl/Defines/DefinesDirectiveExpressionSequence.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "DefinesDirectiveParser.h"
+#include "DefinesDirectiveParsingState.h"
+
+class DefinesDirectiveExpressionSequence final : public DefinesDirectiveParser::sequence_t
+{
+public:
+    DefinesDirectiveExpressionSequence();
+
+protected:
+    void ProcessMatch(DefinesDirectiveParsingState* state, SequenceResult<SimpleParserValue>& result) const override;
+};

src/Parser/Parsing/Impl/Defines/DefinesDirectiveParser.cpp

@@ -0,0 +1,22 @@
+#include "DefinesDirectiveParser.h"
+
+#include "DefinesDirectiveExpressionSequence.h"
+
+DefinesDirectiveParser::DefinesDirectiveParser(ILexer<SimpleParserValue>* lexer, const std::map<std::string, DefinesStreamProxy::Define>& defines)
+    : AbstractParser<SimpleParserValue, DefinesDirectiveParsingState>(lexer, std::make_unique<DefinesDirectiveParsingState>(defines))
+{
+}
+
+const std::vector<AbstractParser<SimpleParserValue, DefinesDirectiveParsingState>::sequence_t*>& DefinesDirectiveParser::GetTestsForState()
+{
+    static std::vector<sequence_t*> sequences
+    {
+        new DefinesDirectiveExpressionSequence()
+    };
+    return sequences;
+}
+
+std::unique_ptr<ISimpleExpression> DefinesDirectiveParser::GetParsedExpression() const
+{
+    return std::move(m_state->m_expression);
+}

src/Parser/Parsing/Impl/Defines/DefinesDirectiveParser.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "DefinesDirectiveParsingState.h"
+#include "Parsing/Impl/AbstractParser.h"
+#include "Parsing/Simple/SimpleParserValue.h"
+
+class DefinesDirectiveParser final : public AbstractParser<SimpleParserValue, DefinesDirectiveParsingState>
+{
+public:
+    DefinesDirectiveParser(ILexer<SimpleParserValue>* lexer, const std::map<std::string, DefinesStreamProxy::Define>& defines);
+
+protected:
+    const std::vector<sequence_t*>& GetTestsForState() override;
+
+public:
+    _NODISCARD std::unique_ptr<ISimpleExpression> GetParsedExpression() const;
+};

src/Parser/Parsing/Impl/Defines/DefinesDirectiveParsingState.cpp

@@ -0,0 +1,6 @@
+#include "DefinesDirectiveParsingState.h"
+
+DefinesDirectiveParsingState::DefinesDirectiveParsingState(const std::map<std::string, DefinesStreamProxy::Define>& defines)
+    : m_defines(defines)
+{
+}

src/Parser/Parsing/Impl/Defines/DefinesDirectiveParsingState.h

@@ -6,11 +6,11 @@
 #include "Parsing/Impl/DefinesStreamProxy.h"
 #include "Parsing/Simple/Expression/ISimpleExpression.h"
 
-class DefinesIfDirectiveParsingState
+class DefinesDirectiveParsingState
 {
 public:
     const std::map<std::string, DefinesStreamProxy::Define>& m_defines;
     std::unique_ptr<ISimpleExpression> m_expression;
 
-    explicit DefinesIfDirectiveParsingState(const std::map<std::string, DefinesStreamProxy::Define>& defines);
+    explicit DefinesDirectiveParsingState(const std::map<std::string, DefinesStreamProxy::Define>& defines);
 };

src/Parser/Parsing/Impl/Defines/DefinesExpressionMatchers.cpp

@@ -1,19 +1,19 @@
-#include "DefinesIfExpressionMatchers.h"
+#include "DefinesExpressionMatchers.h"
 
 #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
 
-DefinesIfExpressionMatchers::DefinesIfExpressionMatchers()
+DefinesExpressionMatchers::DefinesExpressionMatchers()
-    : DefinesIfExpressionMatchers(nullptr)
+    : DefinesExpressionMatchers(nullptr)
 {
 }
 
-DefinesIfExpressionMatchers::DefinesIfExpressionMatchers(const DefinesIfDirectiveParsingState* state)
+DefinesExpressionMatchers::DefinesExpressionMatchers(const DefinesDirectiveParsingState* state)
     : SimpleExpressionMatchers(false, false, true, true, false),
       m_state(state)
 {
 }
 
-std::unique_ptr<SimpleExpressionMatchers::matcher_t> DefinesIfExpressionMatchers::ParseOperandExtension(const supplier_t* labelSupplier) const
+std::unique_ptr<SimpleExpressionMatchers::matcher_t> DefinesExpressionMatchers::ParseOperandExtension(const supplier_t* labelSupplier) const
 {
     const SimpleMatcherFactory create(labelSupplier);
 
@@ -25,7 +25,7 @@ std::unique_ptr<SimpleExpressionMatchers::matcher_t> DefinesIfExpressionMatchers
     });
 }
 
-std::unique_ptr<ISimpleExpression> DefinesIfExpressionMatchers::ProcessOperandExtension(SequenceResult<SimpleParserValue>& result) const
+std::unique_ptr<ISimpleExpression> DefinesExpressionMatchers::ProcessOperandExtension(SequenceResult<SimpleParserValue>& result) const
 {
     const auto& defineCapture = result.NextCapture(CAPTURE_DEFINE_NAME);
 

src/Parser/Parsing/Impl/Defines/DefinesExpressionMatchers.h

@@ -2,20 +2,20 @@
 
 #include <memory>
 
-#include "DefinesIfDirectiveParsingState.h"
+#include "DefinesDirectiveParsingState.h"
 #include "Parsing/Simple/Expression/SimpleExpressionMatchers.h"
 
-class DefinesIfExpressionMatchers final : public SimpleExpressionMatchers
+class DefinesExpressionMatchers final : public SimpleExpressionMatchers
 {
     static constexpr auto CAPTURE_DEFINE_NAME = CAPTURE_OFFSET_EXPRESSION_EXT + 1;
 
-    const DefinesIfDirectiveParsingState* m_state;
+    const DefinesDirectiveParsingState* m_state;
 
 protected:
     std::unique_ptr<matcher_t> ParseOperandExtension(const supplier_t* labelSupplier) const override;
     std::unique_ptr<ISimpleExpression> ProcessOperandExtension(SequenceResult<SimpleParserValue>& result) const override;
 
 public:
-    DefinesIfExpressionMatchers();
+    DefinesExpressionMatchers();
-    explicit DefinesIfExpressionMatchers(const DefinesIfDirectiveParsingState* state);
+    explicit DefinesExpressionMatchers(const DefinesDirectiveParsingState* state);
 };

src/Parser/Parsing/Impl/Defines/DefinesIfDirectiveExpressionSequence.cpp

@@ -1,16 +0,0 @@
-#include "DefinesIfDirectiveExpressionSequence.h"
-
-#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
-#include "DefinesIfExpressionMatchers.h"
-
-DefinesIfDirectiveExpressionSequence::DefinesIfDirectiveExpressionSequence()
-{
-    const SimpleMatcherFactory create(this);
-    AddLabeledMatchers(DefinesIfExpressionMatchers().Expression(this), SimpleExpressionMatchers::LABEL_EXPRESSION);
-    AddMatchers(create.Label(SimpleExpressionMatchers::LABEL_EXPRESSION));
-}
-
-void DefinesIfDirectiveExpressionSequence::ProcessMatch(DefinesIfDirectiveParsingState* state, SequenceResult<SimpleParserValue>& result) const
-{
-    state->m_expression = DefinesIfExpressionMatchers(state).ProcessExpression(result);
-}

src/Parser/Parsing/Impl/Defines/DefinesIfDirectiveExpressionSequence.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "DefinesIfDirectiveParser.h"
-#include "DefinesIfDirectiveParsingState.h"
-
-class DefinesIfDirectiveExpressionSequence final : public DefinesIfDirectiveParser::sequence_t
-{
-public:
-    DefinesIfDirectiveExpressionSequence();
-
-protected:
-    void ProcessMatch(DefinesIfDirectiveParsingState* state, SequenceResult<SimpleParserValue>& result) const override;
-};

src/Parser/Parsing/Impl/Defines/DefinesIfDirectiveParser.cpp

@@ -1,22 +0,0 @@
-#include "DefinesIfDirectiveParser.h"
-
-#include "DefinesIfDirectiveExpressionSequence.h"
-
-DefinesIfDirectiveParser::DefinesIfDirectiveParser(ILexer<SimpleParserValue>* lexer, const std::map<std::string, DefinesStreamProxy::Define>& defines)
-    : AbstractParser<SimpleParserValue, DefinesIfDirectiveParsingState>(lexer, std::make_unique<DefinesIfDirectiveParsingState>(defines))
-{
-}
-
-const std::vector<AbstractParser<SimpleParserValue, DefinesIfDirectiveParsingState>::sequence_t*>& DefinesIfDirectiveParser::GetTestsForState()
-{
-    static std::vector<sequence_t*> sequences
-    {
-        new DefinesIfDirectiveExpressionSequence()
-    };
-    return sequences;
-}
-
-std::unique_ptr<ISimpleExpression> DefinesIfDirectiveParser::GetParsedExpression() const
-{
-    return std::move(m_state->m_expression);
-}

src/Parser/Parsing/Impl/Defines/DefinesIfDirectiveParser.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "DefinesIfDirectiveParsingState.h"
-#include "Parsing/Impl/AbstractParser.h"
-#include "Parsing/Simple/SimpleParserValue.h"
-
-class DefinesIfDirectiveParser final : public AbstractParser<SimpleParserValue, DefinesIfDirectiveParsingState>
-{
-public:
-    DefinesIfDirectiveParser(ILexer<SimpleParserValue>* lexer, const std::map<std::string, DefinesStreamProxy::Define>& defines);
-
-protected:
-    const std::vector<sequence_t*>& GetTestsForState() override;
-
-public:
-    _NODISCARD std::unique_ptr<ISimpleExpression> GetParsedExpression() const;
-};

src/Parser/Parsing/Impl/Defines/DefinesIfDirectiveParsingState.cpp

@@ -1,6 +0,0 @@
-#include "DefinesIfDirectiveParsingState.h"
-
-DefinesIfDirectiveParsingState::DefinesIfDirectiveParsingState(const std::map<std::string, DefinesStreamProxy::Define>& defines)
-    : m_defines(defines)
-{
-}

src/Parser/Parsing/Impl/DefinesStreamProxy.cpp

@@ -6,7 +6,7 @@
 #include "Utils/ClassUtils.h"
 #include "AbstractParser.h"
 #include "ParserSingleInputStream.h"
-#include "Defines/DefinesIfDirectiveParser.h"
+#include "Defines/DefinesDirectiveParser.h"
 #include "Parsing/ParsingException.h"
 #include "Parsing/Simple/SimpleLexer.h"
 #include "Parsing/Simple/Expression/ISimpleExpression.h"
@@ -278,7 +278,7 @@ bool DefinesStreamProxy::MatchUndefDirective(const ParserLine& line, const unsig
     return true;
 }
 
-std::unique_ptr<ISimpleExpression> DefinesStreamProxy::ParseIfExpression(const std::string& expressionString) const
+std::unique_ptr<ISimpleExpression> DefinesStreamProxy::ParseExpression(const std::string& expressionString) const
 {
     std::istringstream ss(expressionString);
     ParserSingleInputStream inputStream(ss, "#if expression");
@@ -291,7 +291,7 @@ std::unique_ptr<ISimpleExpression> DefinesStreamProxy::ParseIfExpression(const s
     SimpleExpressionMatchers().ApplyTokensToLexerConfig(lexerConfig);
 
     SimpleLexer lexer(&inputStream, std::move(lexerConfig));
-    DefinesIfDirectiveParser parser(&lexer, m_defines);
+    DefinesDirectiveParser parser(&lexer, m_defines);
 
     if (!parser.Parse())
         return nullptr;
@@ -323,7 +323,7 @@ bool DefinesStreamProxy::MatchIfDirective(const ParserLine& line, const unsigned
     if (expressionString.empty())
         throw ParsingException(CreatePos(line, currentPos), "Cannot if without an expression.");
 
-    const auto expression = ParseIfExpression(expressionString);
+    const auto expression = ParseExpression(expressionString);
     if (!expression)
         throw ParsingException(CreatePos(line, currentPos), "Failed to parse if expression");
 
@@ -365,7 +365,7 @@ bool DefinesStreamProxy::MatchElIfDirective(const ParserLine& line, const unsign
     if (expressionString.empty())
         throw ParsingException(CreatePos(line, currentPos), "Cannot elif without an expression.");
 
-    const auto expression = ParseIfExpression(expressionString);
+    const auto expression = ParseExpression(expressionString);
     if (!expression)
         throw ParsingException(CreatePos(line, currentPos), "Failed to parse elif expression");
 

src/Parser/Parsing/Impl/DefinesStreamProxy.h

@@ -66,7 +66,6 @@ private:
     static int GetLineEndEscapePos(const ParserLine& line);
     static std::vector<std::string> MatchDefineParameters(const ParserLine& line, unsigned& parameterPosition);
     void ContinueDefine(const ParserLine& line);
-    _NODISCARD std::unique_ptr<ISimpleExpression> ParseIfExpression(const std::string& expressionString) const;
     _NODISCARD bool MatchDefineDirective(const ParserLine& line, unsigned directiveStartPosition, unsigned directiveEndPosition);
     _NODISCARD bool MatchUndefDirective(const ParserLine& line, unsigned directiveStartPosition, unsigned directiveEndPosition);
     _NODISCARD bool MatchIfDirective(const ParserLine& line, unsigned directiveStartPosition, unsigned directiveEndPosition);
@@ -86,6 +85,8 @@ public:
     void AddDefine(Define define);
     void Undefine(const std::string& name);
 
+    _NODISCARD std::unique_ptr<ISimpleExpression> ParseExpression(const std::string& expressionString) const;
+
     ParserLine NextLine() override;
     bool IncludeFile(const std::string& filename) override;
     void PopCurrentFile() override;