Allow limited form of expressions in #line directives
Reuse ExpressionParser that's also used for parsing preprocessor
conditionals to parse line and file numbers in #line directives.
According to recent Khronos discussions, the intent of the spec is that
expressions in #line directives should be interpreted similarly to
expressions in conditional directives, so reusing ExpressionParser is a
natural way to implement this. This enables simple math operators
operating on integers. There are a few unclear corner cases, but this
approach is enough to support practical use cases and pass the dEQP
tests.
Valid line directives have one of the following forms:
#line line-expression
#line line-expression file-expression
ExpressionParser is first run to parse the line-expression. In ambiguous
cases the ExpressionParser consumes as much of the line as possible to
form line-expression. Then, if end-of-line hasn't been reached,
file-expression is parsed by running ExpressionParser again. As an
example of an ambiguous case:
#line 1 + 2
This could alternatively be interpreted to mean line-expression "1" and
file-expression "+ 2" where + is the unary + operator, but ANGLE now
interprets it to mean line-expression "1 + 2". Because of these ambiguous
cases, a bison grammar that would parse multiple expressions on the same
line couldn't be easily constructed, so this solution where
ExpressionParser is run twice was chosen instead.
The problematic corner cases are:
- ExpressionParser uses 64-bit integers internally for evaluating the
expression's value. It's possible to interpret the ESSL3 spec so that
32-bit integer wraparound behavior would be required also for #line
directive expressions.
- It's unclear whether the defined operator can be used in #line
expressions. In this patch it is disabled. Hoping for further
clarification from Khronos.
- It's unclear how short-circuiting should affect the parsing of
undefined identifiers in #line expressions. Now it's consistent with #if
expressions (undefined identifiers are OK if they're short-circuited).
dEQP expectations are updated for preprocessor tests, including ones
not affected specifically by this change.
BUG=angleproject:989
TEST=angle_unittests,
dEQP-GLES3.functional.shaders.preprocessor.* (4 start passing),
dEQP-GLES2.functional.shaders.preprocessor.* (4 start passing)
Change-Id: I55c5bf75857da5de855cc600d3603ee19399f328
Reviewed-on: https://chromium-review.googlesource.com/300964
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tryjob-Request: Olli Etuaho <oetuaho@nvidia.com>
Tested-by: Olli Etuaho <oetuaho@nvidia.com>
diff --git a/src/compiler/preprocessor/ExpressionParser.cpp b/src/compiler/preprocessor/ExpressionParser.cpp
index 21064b7..193b150 100644
--- a/src/compiler/preprocessor/ExpressionParser.cpp
+++ b/src/compiler/preprocessor/ExpressionParser.cpp
@@ -123,6 +123,10 @@
pp::Lexer* lexer;
pp::Token* token;
int* result;
+ bool parsePresetToken;
+
+ pp::ExpressionParser::ErrorSettings errorSettings;
+ bool *valid;
void startIgnoreErrors() { ++ignoreErrors; }
void endIgnoreErrors() { --ignoreErrors; }
@@ -496,9 +500,9 @@
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 106, 106, 113, 114, 124, 124, 145, 145, 166,
- 169, 172, 175, 178, 181, 184, 187, 190, 193, 196,
- 199, 202, 205, 224, 243, 246, 249, 252, 255, 258
+ 0, 110, 110, 117, 118, 129, 129, 150, 150, 171,
+ 174, 177, 180, 183, 186, 189, 192, 195, 198, 201,
+ 204, 207, 210, 230, 250, 253, 256, 259, 262, 265
};
#endif
@@ -1343,8 +1347,9 @@
{
// This rule should be applied right after the token is lexed, so we can
// refer to context->token in the error message.
- context->diagnostics->report(pp::Diagnostics::PP_CONDITIONAL_UNEXPECTED_TOKEN,
+ context->diagnostics->report(context->errorSettings.unexpectedIdentifier,
context->token->location, context->token->text);
+ *(context->valid) = false;
}
(yyval) = (yyvsp[0]);
}
@@ -1532,6 +1537,7 @@
context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
context->token->location,
text.c_str());
+ *(context->valid) = false;
}
(yyval) = static_cast<YYSTYPE>(0);
}
@@ -1556,6 +1562,7 @@
context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
context->token->location,
text.c_str());
+ *(context->valid) = false;
}
(yyval) = static_cast<YYSTYPE>(0);
}
@@ -1850,7 +1857,11 @@
int yylex(YYSTYPE *lvalp, Context *context)
{
pp::Token *token = context->token;
- context->lexer->lex(token);
+ if (!context->parsePresetToken)
+ {
+ context->lexer->lex(token);
+ }
+ context->parsePresetToken = false;
int type = 0;
@@ -1858,10 +1869,13 @@
{
case pp::Token::CONST_INT: {
unsigned int val = 0;
- if (!token->uValue(&val))
+ int testVal = 0;
+ if (!token->uValue(&val) || (!token->iValue(&testVal) &&
+ context->errorSettings.integerLiteralsMustFit32BitSignedRange))
{
context->diagnostics->report(pp::Diagnostics::PP_INTEGER_OVERFLOW,
token->location, token->text);
+ *(context->valid) = false;
}
*lvalp = static_cast<YYSTYPE>(val);
type = TOK_CONST_INT;
@@ -1934,7 +1948,11 @@
{
}
-bool ExpressionParser::parse(Token *token, int *result)
+bool ExpressionParser::parse(Token *token,
+ int *result,
+ bool parsePresetToken,
+ const ErrorSettings &errorSettings,
+ bool *valid)
{
Context context;
context.diagnostics = mDiagnostics;
@@ -1942,6 +1960,9 @@
context.token = token;
context.result = result;
context.ignoreErrors = 0;
+ context.parsePresetToken = parsePresetToken;
+ context.errorSettings = errorSettings;
+ context.valid = valid;
int ret = yyparse(&context);
switch (ret)
{