| // |
| // Copyright 2012 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| |
| #include <sstream> |
| |
| #include "PreprocessorTest.h" |
| #include "compiler/preprocessor/Token.h" |
| |
| namespace angle |
| { |
| |
| using testing::_; |
| |
| class DefineTest : public SimplePreprocessorTest |
| {}; |
| |
| TEST_F(DefineTest, NonIdentifier) |
| { |
| const char *input = |
| "#define 2 foo\n" |
| "2\n"; |
| const char *expected = |
| "\n" |
| "2\n"; |
| |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_UNEXPECTED_TOKEN, pp::SourceLocation(0, 1), "2")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, RedefinePredefined) |
| { |
| const char *input = |
| "#define __LINE__ 10\n" |
| "__LINE__\n" |
| "#define __FILE__ 20\n" |
| "__FILE__\n" |
| "#define __VERSION__ 200\n" |
| "__VERSION__\n" |
| "#define GL_ES 0\n" |
| "GL_ES\n"; |
| const char *expected = |
| "\n" |
| "2\n" |
| "\n" |
| "0\n" |
| "\n" |
| "100\n" |
| "\n" |
| "1\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_REDEFINED, |
| pp::SourceLocation(0, 1), "__LINE__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_REDEFINED, |
| pp::SourceLocation(0, 3), "__FILE__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_REDEFINED, |
| pp::SourceLocation(0, 5), "__VERSION__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_REDEFINED, |
| pp::SourceLocation(0, 7), "GL_ES")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ReservedUnderScore1) |
| { |
| const char *input = |
| "#define __foo bar\n" |
| "__foo\n"; |
| const char *expected = |
| "\n" |
| "bar\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_WARNING_MACRO_NAME_RESERVED, |
| pp::SourceLocation(0, 1), "__foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ReservedUnderScore2) |
| { |
| const char *input = |
| "#define foo__bar baz\n" |
| "foo__bar\n"; |
| const char *expected = |
| "\n" |
| "baz\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_WARNING_MACRO_NAME_RESERVED, |
| pp::SourceLocation(0, 1), "foo__bar")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ReservedGL) |
| { |
| const char *input = |
| "#define GL_foo bar\n" |
| "GL_foo\n"; |
| const char *expected = |
| "\n" |
| "GL_foo\n"; |
| |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_NAME_RESERVED, pp::SourceLocation(0, 1), "GL_foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjRedefineValid) |
| { |
| const char *input = |
| "#define foo (1-1)\n" |
| "#define foo /* whitespace */ (1-1) /* other */ \n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "(1-1)\n"; |
| // No error or warning. |
| using testing::_; |
| EXPECT_CALL(mDiagnostics, print(_, _, _)).Times(0); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjRedefineInvalid) |
| { |
| const char *input = |
| "#define foo (0)\n" |
| "#define foo (1-1)\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "(0)\n"; |
| |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_REDEFINED, pp::SourceLocation(0, 2), "foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncRedefineValid) |
| { |
| const char *input = |
| "#define foo(a) ( a )\n" |
| "#define foo( a )( /* whitespace */ a /* other */ )\n" |
| "foo(b)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "( b )\n"; |
| // No error or warning. |
| using testing::_; |
| EXPECT_CALL(mDiagnostics, print(_, _, _)).Times(0); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncRedefineInvalid) |
| { |
| const char *input = |
| "#define foo(b) ( a )\n" |
| "#define foo(b) ( b )\n" |
| "foo(1)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "( a )\n"; |
| |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_REDEFINED, pp::SourceLocation(0, 2), "foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjBasic) |
| { |
| const char *input = |
| "#define foo 1\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjEmpty) |
| { |
| const char *input = |
| "#define foo\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjChain) |
| { |
| const char *input = |
| "#define foo 1\n" |
| "#define bar foo\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjChainReverse) |
| { |
| const char *input = |
| "#define bar foo\n" |
| "#define foo 1\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjRecursive) |
| { |
| const char *input = |
| "#define foo bar\n" |
| "#define bar baz\n" |
| "#define baz foo\n" |
| "foo\n" |
| "bar\n" |
| "baz\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "foo\n" |
| "bar\n" |
| "baz\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjCompositeChain) |
| { |
| const char *input = |
| "#define foo 1\n" |
| "#define bar a foo\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "a 1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjCompositeChainReverse) |
| { |
| const char *input = |
| "#define bar a foo\n" |
| "#define foo 1\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "a 1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjCompositeRecursive) |
| { |
| const char *input = |
| "#define foo a bar\n" |
| "#define bar b baz\n" |
| "#define baz c foo\n" |
| "foo\n" |
| "bar\n" |
| "baz\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "a b c foo\n" |
| "b c a bar\n" |
| "c a b baz\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjChainSelfRecursive) |
| { |
| const char *input = |
| "#define foo foo\n" |
| "#define bar foo\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "foo\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjectLikeWithParens) |
| { |
| const char *input = |
| "#define foo ()1\n" |
| "foo()\n" |
| "#define bar ()2\n" |
| "bar()\n"; |
| const char *expected = |
| "\n" |
| "()1()\n" |
| "\n" |
| "()2()\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncEmpty) |
| { |
| const char *input = |
| "#define foo()\n" |
| "foo()\n"; |
| const char *expected = |
| "\n" |
| "\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncNoArgs) |
| { |
| const char *input = |
| "#define foo() bar\n" |
| "foo()\n"; |
| const char *expected = |
| "\n" |
| "bar\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncOneArgUnused) |
| { |
| const char *input = |
| "#define foo(x) 1\n" |
| "foo(bar)\n"; |
| const char *expected = |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncTwoArgsUnused) |
| { |
| const char *input = |
| "#define foo(x,y) 1\n" |
| "foo(bar,baz)\n"; |
| const char *expected = |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncOneArg) |
| { |
| const char *input = |
| "#define foo(x) ((x)+1)\n" |
| "foo(bar)\n"; |
| const char *expected = |
| "\n" |
| "((bar)+1)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncTwoArgs) |
| { |
| const char *input = |
| "#define foo(x,y) ((x)*(y))\n" |
| "foo(bar,baz)\n"; |
| const char *expected = |
| "\n" |
| "((bar)*(baz))\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncEmptyArgs) |
| { |
| const char *input = |
| "#define zero() pass\n" |
| "#define one(x) pass\n" |
| "#define two(x,y) pass\n" |
| "zero()\n" |
| "one()\n" |
| "two(,)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "pass\n" |
| "pass\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncMacroAsParam) |
| { |
| const char *input = |
| "#define x 0\n" |
| "#define foo(x) x\n" |
| "foo(1)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncOneArgMulti) |
| { |
| const char *input = |
| "#define foo(x) (x)\n" |
| "foo(this is a multi-word argument)\n"; |
| const char *expected = |
| "\n" |
| "(this is a multi-word argument)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncTwoArgsMulti) |
| { |
| const char *input = |
| "#define foo(x,y) x,two fish,red fish,y\n" |
| "foo(one fish, blue fish)\n"; |
| const char *expected = |
| "\n" |
| "one fish,two fish,red fish,blue fish\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncCompose) |
| { |
| const char *input = |
| "#define bar(x) (1+(x))\n" |
| "#define foo(y) (2*(y))\n" |
| "foo(bar(3))\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "(2*((1+(3))))\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncArgWithParens) |
| { |
| const char *input = |
| "#define foo(x) (x)\n" |
| "foo(argument(with parens) FTW)\n"; |
| const char *expected = |
| "\n" |
| "(argument(with parens) FTW)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncMacroAsNonMacro) |
| { |
| const char *input = |
| "#define foo(bar) bar\n" |
| "foo bar\n"; |
| const char *expected = |
| "\n" |
| "foo bar\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncExtraNewlines) |
| { |
| const char *input = |
| "#define foo(a) (a)\n" |
| "foo\n" |
| "(\n" |
| "1\n" |
| ")\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "(1)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFunc) |
| { |
| const char *input = |
| "#define foo() pass\n" |
| "#define bar foo()\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToNonFunc) |
| { |
| const char *input = |
| "#define pass() fail\n" |
| "#define bar pass\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFuncWithArgs) |
| { |
| const char *input = |
| "#define foo(fail) fail\n" |
| "#define bar foo(pass)\n" |
| "bar\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFuncCompose) |
| { |
| const char *input = |
| "#define baz(fail) fail\n" |
| "#define bar(fail) fail\n" |
| "#define foo bar(baz(pass))\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFuncParensInText1) |
| { |
| const char *input = |
| "#define fail() pass\n" |
| "#define foo fail\n" |
| "foo()\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFuncParensInText2) |
| { |
| const char *input = |
| "#define bar with,embedded,commas\n" |
| "#define func(x) pass\n" |
| "#define foo func\n" |
| "foo(bar)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainObjToFuncMultiLevel) |
| { |
| const char *input = |
| "#define foo(x) pass\n" |
| "#define bar foo\n" |
| "#define baz bar\n" |
| "#define joe baz\n" |
| "joe (fail)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ObjToFuncRecursive) |
| { |
| const char *input = |
| "#define A(a,b) B(a,b)\n" |
| "#define C A(0,C)\n" |
| "C\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "B(0,C)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, ChainFuncToFuncCompose) |
| { |
| const char *input = |
| "#define baz(fail) fail\n" |
| "#define bar(fail) fail\n" |
| "#define foo() bar(baz(pass))\n" |
| "foo()\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncSelfRecursive) |
| { |
| const char *input = |
| "#define foo(a) foo(2*(a))\n" |
| "foo(3)\n"; |
| const char *expected = |
| "\n" |
| "foo(2*(3))\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncSelfCompose) |
| { |
| const char *input = |
| "#define foo(a) foo(2*(a))\n" |
| "foo(foo(3))\n"; |
| const char *expected = |
| "\n" |
| "foo(2*(foo(2*(3))))\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncSelfComposeNonFunc) |
| { |
| const char *input = |
| "#define foo(bar) bar\n" |
| "foo(foo)\n"; |
| const char *expected = |
| "\n" |
| "foo\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncSelfComposeNonFuncMultiTokenArg) |
| { |
| const char *input = |
| "#define foo(bar) bar\n" |
| "foo(1+foo)\n"; |
| const char *expected = |
| "\n" |
| "1+foo\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FinalizeUnexpandedMacro) |
| { |
| const char *input = |
| "#define expand(x) expand(x once)\n" |
| "#define foo(x) x\n" |
| "foo(expand(just))\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "expand(just once)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncArgWithCommas) |
| { |
| const char *input = |
| "#define foo(x) pass\n" |
| "foo(argument (with,embedded, commas) -- baz)\n"; |
| const char *expected = |
| "\n" |
| "pass\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncArgObjMaroWithComma) |
| { |
| const char *input = |
| "#define foo(a) (a)\n" |
| "#define bar two,words\n" |
| "foo(bar)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "(two,words)\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncLeftParenInMacroRightParenInText) |
| { |
| const char *input = |
| "#define bar(a) a*2\n" |
| "#define foo bar(\n" |
| "foo b)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "b*2\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, RepeatedArg) |
| { |
| const char *input = |
| "#define double(x) x x\n" |
| "double(1)\n"; |
| const char *expected = |
| "\n" |
| "1 1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncMissingRightParen) |
| { |
| const char *input = |
| "#define foo(x) (2*(x))\n" |
| "foo(3\n"; |
| const char *expected = |
| "\n" |
| "\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_UNTERMINATED_INVOCATION, |
| pp::SourceLocation(0, 2), "foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, FuncIncorrectArgCount) |
| { |
| const char *input = |
| "#define foo(x,y) ((x)+(y))\n" |
| "foo()\n" |
| "foo(1)\n" |
| "foo(1,2,3)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n"; |
| |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_TOO_FEW_ARGS, pp::SourceLocation(0, 2), "foo")); |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_TOO_FEW_ARGS, pp::SourceLocation(0, 3), "foo")); |
| EXPECT_CALL(mDiagnostics, |
| print(pp::Diagnostics::PP_MACRO_TOO_MANY_ARGS, pp::SourceLocation(0, 4), "foo")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, Undef) |
| { |
| const char *input = |
| "#define foo 1\n" |
| "foo\n" |
| "#undef foo\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "1\n" |
| "\n" |
| "foo\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, UndefPredefined) |
| { |
| const char *input = |
| "#undef __LINE__\n" |
| "__LINE__\n" |
| "#undef __FILE__\n" |
| "__FILE__\n" |
| "#undef __VERSION__\n" |
| "__VERSION__\n" |
| "#undef GL_ES\n" |
| "GL_ES\n"; |
| const char *expected = |
| "\n" |
| "2\n" |
| "\n" |
| "0\n" |
| "\n" |
| "100\n" |
| "\n" |
| "1\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED, |
| pp::SourceLocation(0, 1), "__LINE__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED, |
| pp::SourceLocation(0, 3), "__FILE__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED, |
| pp::SourceLocation(0, 5), "__VERSION__")); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED, |
| pp::SourceLocation(0, 7), "GL_ES")); |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, UndefRedefine) |
| { |
| const char *input = |
| "#define foo 1\n" |
| "foo\n" |
| "#undef foo\n" |
| "foo\n" |
| "#define foo 2\n" |
| "foo\n"; |
| const char *expected = |
| "\n" |
| "1\n" |
| "\n" |
| "foo\n" |
| "\n" |
| "2\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| // Example from C99 standard section 6.10.3.5 Scope of macro definitions |
| TEST_F(DefineTest, C99Example) |
| { |
| const char *input = |
| "#define x 3 \n" |
| "#define f(a) f(x * (a)) \n" |
| "#undef x \n" |
| "#define x 2 \n" |
| "#define g f \n" |
| "#define z z[0] \n" |
| "#define h g(~ \n" |
| "#define m(a) a(w) \n" |
| "#define w 0,1 \n" |
| "#define t(a) a \n" |
| "#define p() int \n" |
| "#define q(x) x \n" |
| " \n" |
| "f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);\n" |
| "g(x+(3,4)-w) | h 5) & m\n" |
| " (f)^m(m);\n" |
| "p() i[q()] = { q(1), 23, 4, 5, };\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);\n" |
| "f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &\n" |
| " f(2 * (0,1))^m(0,1);\n" |
| "int i[] = { 1, 23, 4, 5, };\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, Predefined_GL_ES) |
| { |
| const char *input = "GL_ES\n"; |
| const char *expected = "1\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, Predefined_VERSION) |
| { |
| const char *input = "__VERSION__\n"; |
| const char *expected = "100\n"; |
| |
| preprocess(input, expected); |
| } |
| |
| TEST_F(DefineTest, Predefined_LINE1) |
| { |
| const char *str = "\n\n__LINE__"; |
| |
| pp::Token token; |
| lexSingleToken(str, &token); |
| EXPECT_EQ(pp::Token::CONST_INT, token.type); |
| EXPECT_EQ("3", token.text); |
| } |
| |
| TEST_F(DefineTest, Predefined_LINE2) |
| { |
| const char *str = |
| "#line 10\n" |
| "__LINE__\n"; |
| |
| pp::Token token; |
| lexSingleToken(str, &token); |
| EXPECT_EQ(pp::Token::CONST_INT, token.type); |
| EXPECT_EQ("10", token.text); |
| } |
| |
| TEST_F(DefineTest, Predefined_FILE1) |
| { |
| const char *const str[] = {"", "", "__FILE__"}; |
| |
| pp::Token token; |
| lexSingleToken(3, str, &token); |
| EXPECT_EQ(pp::Token::CONST_INT, token.type); |
| EXPECT_EQ("2", token.text); |
| } |
| |
| TEST_F(DefineTest, Predefined_FILE2) |
| { |
| const char *const str[] = {"#line 10 20\n", "__FILE__"}; |
| |
| pp::Token token; |
| lexSingleToken(2, str, &token); |
| 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); |
| } |
| |
| // Test that line directive expressions give errors on negative or undefined shifts. |
| TEST_F(DefineTest, NegativeShiftInLineDirective) |
| { |
| const char *input = |
| "#line 1 << -1\n" |
| "#line 1 >> -1\n" |
| "#line 1 << x\n" |
| "#line 1 >> x\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_UNDEFINED_SHIFT, _, _)).Times(4); |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_INVALID_LINE_NUMBER, _, _)).Times(2); |
| preprocess(input, expected); |
| } |
| |
| // Undefining a macro in its invocation parameters produces and error |
| TEST_F(DefineTest, UndefineInInvocation) |
| { |
| const char *input = |
| "#define G(a, b) a b\n" |
| "G(\n" |
| "#undef G\n" |
| "1, 2)\n"; |
| const char *expected = "\n\n\n1 2\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_UNDEFINED_WHILE_INVOKED, |
| pp::SourceLocation(0, 3), _)); |
| |
| preprocess(input, expected); |
| } |
| |
| // Undefining a macro before its invocation parameters produces and error |
| TEST_F(DefineTest, UndefineInInvocationPreLParen) |
| { |
| const char *input = |
| "#define G(a, b) a b\n" |
| "G\n" |
| "#undef G\n" |
| "(1, 2)\n"; |
| const char *expected = "\n\n\n1 2\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_UNDEFINED_WHILE_INVOKED, |
| pp::SourceLocation(0, 3), _)); |
| |
| preprocess(input, expected); |
| } |
| |
| // The name of the macro "a" is inside an incomplete macro invocation of macro "m()" in its own |
| // expansion. This should not result in infinite recursion. |
| TEST_F(DefineTest, RecursiveMacroNameInsideIncompleteMacroInvocationInMacroExpansion) |
| { |
| const char *input = |
| "#define m(a)\n" |
| "#define a m((a)\n" |
| "a)\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n"; |
| preprocess(input, expected); |
| } |
| |
| // The name of the macro "a" is inside an incomplete macro invocation of macro "m()" in its own |
| // expansion. Then the macro "a" is undef'd. This is a regression test for a memory management bug |
| // where macro "a" would be freed on undef even though cleaning up the recursive macro invocation |
| // would still need to refer to macro "a". |
| TEST_F(DefineTest, UndefInsideRecursiveMacroInvocation) |
| { |
| const char *input = |
| "#define m(a)\n" |
| "#define a m((a)\n" |
| "a\n" |
| "#undef a\n" |
| ")\n"; |
| const char *expected = |
| "\n" |
| "\n" |
| "\n" |
| "\n" |
| "\n"; |
| preprocess(input, expected); |
| } |
| |
| // The macro invocations form a long chain. The macro expander should protect against stack overflow |
| // and generate an error in this case. |
| TEST_F(DefineTest, LongMacroInvocationChain) |
| { |
| std::stringstream inputStream; |
| std::stringstream expectedStream; |
| |
| inputStream << "#define b(x) x\n"; |
| inputStream << "#define a0(x) foo x\n"; |
| for (int i = 1; i < 20; ++i) |
| { |
| inputStream << "#define a" << i << "(x) b(a" << (i - 1) << "(x))\n"; |
| } |
| inputStream << "a19(y)\n"; |
| |
| EXPECT_CALL(mDiagnostics, print(pp::Diagnostics::PP_MACRO_INVOCATION_CHAIN_TOO_DEEP, |
| pp::SourceLocation(0, 22), _)); |
| |
| pp::PreprocessorSettings settings(SH_GLES2_SPEC); |
| settings.maxMacroExpansionDepth = 19; |
| |
| preprocess(inputStream.str().c_str(), settings); |
| } |
| |
| } // namespace angle |
