Support parsing defined operator generated by macro expansion

src/compiler/preprocessor/DirectiveParser.cpp

@@ -141,71 +141,6 @@ bool isMacroPredefined(const std::string &name,
 namespace pp
 {
 
-class DefinedParser : public Lexer
-{
-  public:
-    DefinedParser(Lexer *lexer,
-                  const MacroSet *macroSet,
-                  Diagnostics *diagnostics)
-        : mLexer(lexer),
-          mMacroSet(macroSet),
-          mDiagnostics(diagnostics)
-    {
-    }
-
-  protected:
-    void lex(Token *token) override
-    {
-        const char kDefined[] = "defined";
-
-        mLexer->lex(token);
-        if (token->type != Token::IDENTIFIER)
-            return;
-        if (token->text != kDefined)
-            return;
-
-        bool paren = false;
-        mLexer->lex(token);
-        if (token->type == '(')
-        {
-            paren = true;
-            mLexer->lex(token);
-        }
-
-        if (token->type != Token::IDENTIFIER)
-        {
-            mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
-                                 token->location, token->text);
-            skipUntilEOD(mLexer, token);
-            return;
-        }
-        MacroSet::const_iterator iter = mMacroSet->find(token->text);
-        std::string expression = iter != mMacroSet->end() ? "1" : "0";
-
-        if (paren)
-        {
-            mLexer->lex(token);
-            if (token->type != ')')
-            {
-                mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN,
-                                     token->location, token->text);
-                skipUntilEOD(mLexer, token);
-                return;
-            }
-        }
-
-        // We have a valid defined operator.
-        // Convert the current token into a CONST_INT token.
-        token->type = Token::CONST_INT;
-        token->text = expression;
-    }
-
-  private:
-    Lexer *mLexer;
-    const MacroSet *mMacroSet;
-    Diagnostics *mDiagnostics;
-};
-
 DirectiveParser::DirectiveParser(Tokenizer *tokenizer,
                                  MacroSet *macroSet,
                                  Diagnostics *diagnostics,
@@ -839,7 +774,7 @@ void DirectiveParser::parseLine(Token *token)
     int line = 0, file = 0;
     int state = LINE_NUMBER;
 
-    MacroExpander macroExpander(mTokenizer, mMacroSet, mDiagnostics);
+    MacroExpander macroExpander(mTokenizer, mMacroSet, mDiagnostics, false);
     macroExpander.lex(token);
     while ((token->type != '\n') && (token->type != Token::LAST))
     {
@@ -954,8 +889,7 @@ int DirectiveParser::parseExpressionIf(Token *token)
     assert((getDirective(token) == DIRECTIVE_IF) ||
            (getDirective(token) == DIRECTIVE_ELIF));
 
-    DefinedParser definedParser(mTokenizer, mMacroSet, mDiagnostics);
-    MacroExpander macroExpander(&definedParser, mMacroSet, mDiagnostics);
+    MacroExpander macroExpander(mTokenizer, mMacroSet, mDiagnostics, true);
     ExpressionParser expressionParser(&macroExpander, mDiagnostics);
 
     int expression = 0;

src/compiler/preprocessor/MacroExpander.cpp

@@ -48,10 +48,9 @@ class TokenLexer : public Lexer
 
 MacroExpander::MacroExpander(Lexer *lexer,
                              MacroSet *macroSet,
-                             Diagnostics *diagnostics)
-    : mLexer(lexer),
-      mMacroSet(macroSet),
-      mDiagnostics(diagnostics)
+                             Diagnostics *diagnostics,
+                             bool parseDefined)
+    : mLexer(lexer), mMacroSet(macroSet), mDiagnostics(diagnostics), mParseDefined(parseDefined)
 {
 }
 
@@ -67,11 +66,54 @@ void MacroExpander::lex(Token *token)
 {
     while (true)
     {
+        const char kDefined[] = "defined";
+
         getToken(token);
 
         if (token->type != Token::IDENTIFIER)
             break;
 
+        // Defined operator is parsed here since it may be generated by macro expansion.
+        // Defined operator produced by macro expansion has undefined behavior according to C++
+        // spec, which the GLSL spec references (see C++14 draft spec section 16.1.4), but this
+        // behavior is needed for passing dEQP tests, which enforce stricter compatibility between
+        // implementations.
+        if (mParseDefined && token->text == kDefined)
+        {
+            bool paren = false;
+            getToken(token);
+            if (token->type == '(')
+            {
+                paren = true;
+                getToken(token);
+            }
+            if (token->type != Token::IDENTIFIER)
+            {
+                mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location,
+                                     token->text);
+                break;
+            }
+            auto iter              = mMacroSet->find(token->text);
+            std::string expression = iter != mMacroSet->end() ? "1" : "0";
+
+            if (paren)
+            {
+                getToken(token);
+                if (token->type != ')')
+                {
+                    mDiagnostics->report(Diagnostics::PP_UNEXPECTED_TOKEN, token->location,
+                                         token->text);
+                    break;
+                }
+            }
+
+            // We have a valid defined operator.
+            // Convert the current token into a CONST_INT token.
+            token->type = Token::CONST_INT;
+            token->text = expression;
+            break;
+        }
+
         if (token->expansionDisabled())
             break;
 
@@ -325,7 +367,7 @@ bool MacroExpander::collectMacroArgs(const Macro &macro,
     {
         MacroArg &arg = args->at(i);
         TokenLexer lexer(&arg);
-        MacroExpander expander(&lexer, mMacroSet, mDiagnostics);
+        MacroExpander expander(&lexer, mMacroSet, mDiagnostics, mParseDefined);
 
         arg.clear();
         expander.lex(&token);

src/compiler/preprocessor/MacroExpander.h

@@ -24,7 +24,7 @@ struct SourceLocation;
 class MacroExpander : public Lexer
 {
   public:
-    MacroExpander(Lexer *lexer, MacroSet *macroSet, Diagnostics *diagnostics);
+    MacroExpander(Lexer *lexer, MacroSet *macroSet, Diagnostics *diagnostics, bool parseDefined);
     ~MacroExpander() override;
 
     void lex(Token *token) override;
@@ -81,6 +81,7 @@ class MacroExpander : public Lexer
     Lexer *mLexer;
     MacroSet *mMacroSet;
     Diagnostics *mDiagnostics;
+    bool mParseDefined;
 
     std::auto_ptr<Token> mReserveToken;
     std::vector<MacroContext *> mContextStack;

src/compiler/preprocessor/Preprocessor.cpp

@@ -26,12 +26,11 @@ struct PreprocessorImpl
     DirectiveParser directiveParser;
     MacroExpander macroExpander;
 
-    PreprocessorImpl(Diagnostics *diag,
-                     DirectiveHandler *directiveHandler)
+    PreprocessorImpl(Diagnostics *diag, DirectiveHandler *directiveHandler)
         : diagnostics(diag),
           tokenizer(diag),
           directiveParser(&tokenizer, &macroSet, diag, directiveHandler),
-          macroExpander(&directiveParser, &macroSet, diag)
+          macroExpander(&directiveParser, &macroSet, diag, false)
     {
     }
 };

src/tests/preprocessor_tests/define_test.cpp

@@ -892,3 +892,33 @@ TEST_F(DefineTest, Predefined_FILE2)
     EXPECT_EQ(pp::Token::CONST_INT, token.type);
     EXPECT_EQ("21", token.text);
 }
+
+// Defined operator produced by macro expansion should be parsed inside #if directives
+TEST_F(DefineTest, ExpandedDefinedParsedInsideIf)
+{
+    const char *input =
+        "#define bar 1\n"
+        "#define foo defined(bar)\n"
+        "#if foo\n"
+        "bar\n"
+        "#endif\n";
+    const char *expected =
+        "\n"
+        "\n"
+        "\n"
+        "1\n"
+        "\n";
+    preprocess(input, expected);
+}
+
+// Defined operator produced by macro expansion should not be parsed outside #if directives
+TEST_F(DefineTest, ExpandedDefinedNotParsedOutsideIf)
+{
+    const char *input =
+        "#define foo defined(bar)\n"
+        "foo\n";
+    const char *expected =
+        "\n"
+        "defined(bar)\n";
+    preprocess(input, expected);
+}

src/tests/preprocessor_tests/if_test.cpp

@@ -891,3 +891,64 @@ TEST_F(IfTest, ShortCircuitedUndefined)
 
     preprocess(str, expected);
 }
+
+// Defined operator produced by macro expansion has undefined behavior according to C++ spec,
+// which the GLSL spec references (see C++14 draft spec section 16.1.4), but this behavior is
+// needed for passing dEQP tests, which enforce stricter compatibility between implementations.
+TEST_F(IfTest, DefinedOperatorValidAfterMacroExpansion)
+{
+    const char *str =
+        "#define foo defined\n"
+        "#if !foo bar\n"
+        "pass\n"
+        "#endif\n";
+    const char *expected =
+        "\n"
+        "\n"
+        "pass\n"
+        "\n";
+
+    preprocess(str, expected);
+}
+
+// Unterminated defined operator generated by macro expansion should generate appropriate errors.
+// Defined operator produced by macro expansion has undefined behavior according to C++ spec,
+// which the GLSL spec references (see C++14 draft spec section 16.1.4), but this behavior is
+// needed for passing dEQP tests, which enforce stricter compatibility between implementations.
+TEST_F(IfTest, UnterminatedDefinedInMacro)
+{
+    const char *str =
+        "#define foo defined(\n"
+        "#if foo\n"
+        "#endif\n";
+    ASSERT_TRUE(mPreprocessor.init(1, &str, 0));
+
+    EXPECT_CALL(mDiagnostics,
+                print(pp::Diagnostics::PP_UNEXPECTED_TOKEN, pp::SourceLocation(0, 2), "\n"));
+    EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_INVALID_EXPRESSION,
+                                    pp::SourceLocation(0, 2), "syntax error"));
+
+    pp::Token token;
+    mPreprocessor.lex(&token);
+}
+
+// Unterminated defined operator generated by macro expansion should generate appropriate errors.
+// Defined operator produced by macro expansion has undefined behavior according to C++ spec,
+// which the GLSL spec references (see C++14 draft spec section 16.1.4), but this behavior is
+// needed for passing dEQP tests, which enforce stricter compatibility between implementations.
+TEST_F(IfTest, UnterminatedDefinedInMacro2)
+{
+    const char *str =
+        "#define foo defined(bar\n"
+        "#if foo\n"
+        "#endif\n";
+    ASSERT_TRUE(mPreprocessor.init(1, &str, 0));
+
+    EXPECT_CALL(mDiagnostics,
+                print(pp::Diagnostics::PP_UNEXPECTED_TOKEN, pp::SourceLocation(0, 2), "\n"));
+    EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_INVALID_EXPRESSION,
+                                    pp::SourceLocation(0, 2), "syntax error"));
+
+    pp::Token token;
+    mPreprocessor.lex(&token);
+}