blob: 5342935244f19cf3da55982e5a010f935228be84 [file] [log] [blame]
/*
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
This file contains the Yacc grammar for GLSL ES preprocessor expression.
IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh,
WHICH GENERATES THE GLSL ES preprocessor expression parser.
*/
%{
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This file is auto-generated by generate_parser.sh. DO NOT EDIT!
#if defined(__GNUC__)
// Triggered by the auto-generated pplval variable.
#if !defined(__clang__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#else
#pragma GCC diagnostic ignored "-Wuninitialized"
#endif
#elif defined(_MSC_VER)
#pragma warning(disable: 4065 4244 4701 4702)
#endif
#include "ExpressionParser.h"
#if defined(_MSC_VER)
#include <malloc.h>
#else
#include <stdlib.h>
#endif
#include <limits>
#include <cassert>
#include <sstream>
#include <stdint.h>
#include "DiagnosticsBase.h"
#include "Lexer.h"
#include "Token.h"
#include "../../common/debug.h"
typedef int32_t YYSTYPE;
typedef uint32_t UNSIGNED_TYPE;
#define YYENABLE_NLS 0
#define YYLTYPE_IS_TRIVIAL 1
#define YYSTYPE_IS_TRIVIAL 1
#define YYSTYPE_IS_DECLARED 1
namespace {
struct Context
{
pp::Diagnostics* diagnostics;
pp::Lexer* lexer;
pp::Token* token;
int* result;
bool parsePresetToken;
pp::ExpressionParser::ErrorSettings errorSettings;
bool *valid;
void startIgnoreErrors() { ++ignoreErrors; }
void endIgnoreErrors() { --ignoreErrors; }
bool isIgnoringErrors() { return ignoreErrors > 0; }
int ignoreErrors;
};
} // namespace
%}
%pure-parser
%name-prefix "pp"
%parse-param {Context *context}
%lex-param {Context *context}
%{
static int yylex(YYSTYPE* lvalp, Context* context);
static void yyerror(Context* context, const char* reason);
%}
%token TOK_CONST_INT
%token TOK_IDENTIFIER
%left TOK_OP_OR
%left TOK_OP_AND
%left '|'
%left '^'
%left '&'
%left TOK_OP_EQ TOK_OP_NE
%left '<' '>' TOK_OP_LE TOK_OP_GE
%left TOK_OP_LEFT TOK_OP_RIGHT
%left '+' '-'
%left '*' '/' '%'
%right TOK_UNARY
%%
input
: expression {
*(context->result) = static_cast<int>($1);
YYACCEPT;
}
;
expression
: TOK_CONST_INT
| TOK_IDENTIFIER {
if (!context->isIgnoringErrors())
{
// 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(context->errorSettings.unexpectedIdentifier,
context->token->location, context->token->text);
*(context->valid) = false;
}
$$ = $1;
}
| expression TOK_OP_OR {
if ($1 != 0)
{
// Ignore errors in the short-circuited part of the expression.
// ESSL3.00 section 3.4:
// If an operand is not evaluated, the presence of undefined identifiers
// in the operand will not cause an error.
// Unevaluated division by zero should not cause an error either.
context->startIgnoreErrors();
}
} expression {
if ($1 != 0)
{
context->endIgnoreErrors();
$$ = static_cast<YYSTYPE>(1);
}
else
{
$$ = $1 || $4;
}
}
| expression TOK_OP_AND {
if ($1 == 0)
{
// Ignore errors in the short-circuited part of the expression.
// ESSL3.00 section 3.4:
// If an operand is not evaluated, the presence of undefined identifiers
// in the operand will not cause an error.
// Unevaluated division by zero should not cause an error either.
context->startIgnoreErrors();
}
} expression {
if ($1 == 0)
{
context->endIgnoreErrors();
$$ = static_cast<YYSTYPE>(0);
}
else
{
$$ = $1 && $4;
}
}
| expression '|' expression {
$$ = $1 | $3;
}
| expression '^' expression {
$$ = $1 ^ $3;
}
| expression '&' expression {
$$ = $1 & $3;
}
| expression TOK_OP_NE expression {
$$ = $1 != $3;
}
| expression TOK_OP_EQ expression {
$$ = $1 == $3;
}
| expression TOK_OP_GE expression {
$$ = $1 >= $3;
}
| expression TOK_OP_LE expression {
$$ = $1 <= $3;
}
| expression '>' expression {
$$ = $1 > $3;
}
| expression '<' expression {
$$ = $1 < $3;
}
| expression TOK_OP_RIGHT expression {
if ($3 < 0 || $3 > 31)
{
if (!context->isIgnoringErrors())
{
std::ostringstream stream;
stream << $1 << " >> " << $3;
std::string text = stream.str();
context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
context->token->location,
text.c_str());
*(context->valid) = false;
}
$$ = static_cast<YYSTYPE>(0);
}
else if ($1 < 0)
{
// Logical shift right.
$$ = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>($1) >> $3);
}
else
{
$$ = $1 >> $3;
}
}
| expression TOK_OP_LEFT expression {
if ($3 < 0 || $3 > 31)
{
if (!context->isIgnoringErrors())
{
std::ostringstream stream;
stream << $1 << " << " << $3;
std::string text = stream.str();
context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
context->token->location,
text.c_str());
*(context->valid) = false;
}
$$ = static_cast<YYSTYPE>(0);
}
else
{
// Logical shift left. Casting to unsigned is needed to ensure there's no signed integer
// overflow, which some tools treat as an error.
$$ = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>($1) << $3);
}
}
| expression '-' expression {
$$ = $1 - $3;
}
| expression '+' expression {
$$ = $1 + $3;
}
| expression '%' expression {
if ($3 == 0)
{
if (!context->isIgnoringErrors())
{
std::ostringstream stream;
stream << $1 << " % " << $3;
std::string text = stream.str();
context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
context->token->location,
text.c_str());
*(context->valid) = false;
}
$$ = static_cast<YYSTYPE>(0);
}
else if (($1 == std::numeric_limits<YYSTYPE>::min()) && ($3 == -1))
{
// Check for the special case where the minimum representable number is
// divided by -1. If left alone this has undefined results.
$$ = 0;
}
else
{
$$ = $1 % $3;
}
}
| expression '/' expression {
if ($3 == 0)
{
if (!context->isIgnoringErrors())
{
std::ostringstream stream;
stream << $1 << " / " << $3;
std::string text = stream.str();
context->diagnostics->report(pp::Diagnostics::PP_DIVISION_BY_ZERO,
context->token->location,
text.c_str());
*(context->valid) = false;
}
$$ = static_cast<YYSTYPE>(0);
}
else if (($1 == std::numeric_limits<YYSTYPE>::min()) && ($3 == -1))
{
// Check for the special case where the minimum representable number is
// divided by -1. If left alone this leads to integer overflow in C++, which
// has undefined results.
$$ = std::numeric_limits<YYSTYPE>::max();
}
else
{
$$ = $1 / $3;
}
}
| expression '*' expression {
$$ = $1 * $3;
}
| '!' expression %prec TOK_UNARY {
$$ = ! $2;
}
| '~' expression %prec TOK_UNARY {
$$ = ~ $2;
}
| '-' expression %prec TOK_UNARY {
// Check for negation of minimum representable integer to prevent undefined signed int
// overflow.
if ($2 == std::numeric_limits<YYSTYPE>::min())
{
$$ = std::numeric_limits<YYSTYPE>::min();
}
else
{
$$ = -$2;
}
}
| '+' expression %prec TOK_UNARY {
$$ = + $2;
}
| '(' expression ')' {
$$ = $2;
}
;
%%
int yylex(YYSTYPE *lvalp, Context *context)
{
pp::Token *token = context->token;
if (!context->parsePresetToken)
{
context->lexer->lex(token);
}
context->parsePresetToken = false;
int type = 0;
switch (token->type)
{
case pp::Token::CONST_INT: {
unsigned int val = 0;
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;
break;
}
case pp::Token::IDENTIFIER:
*lvalp = static_cast<YYSTYPE>(-1);
type = TOK_IDENTIFIER;
break;
case pp::Token::OP_OR:
type = TOK_OP_OR;
break;
case pp::Token::OP_AND:
type = TOK_OP_AND;
break;
case pp::Token::OP_NE:
type = TOK_OP_NE;
break;
case pp::Token::OP_EQ:
type = TOK_OP_EQ;
break;
case pp::Token::OP_GE:
type = TOK_OP_GE;
break;
case pp::Token::OP_LE:
type = TOK_OP_LE;
break;
case pp::Token::OP_RIGHT:
type = TOK_OP_RIGHT;
break;
case pp::Token::OP_LEFT:
type = TOK_OP_LEFT;
break;
case '|':
case '^':
case '&':
case '>':
case '<':
case '-':
case '+':
case '%':
case '/':
case '*':
case '!':
case '~':
case '(':
case ')':
type = token->type;
break;
default:
break;
}
return type;
}
void yyerror(Context *context, const char *reason)
{
context->diagnostics->report(pp::Diagnostics::PP_INVALID_EXPRESSION,
context->token->location,
reason);
}
namespace pp {
ExpressionParser::ExpressionParser(Lexer *lexer, Diagnostics *diagnostics)
: mLexer(lexer),
mDiagnostics(diagnostics)
{
}
bool ExpressionParser::parse(Token *token,
int *result,
bool parsePresetToken,
const ErrorSettings &errorSettings,
bool *valid)
{
Context context;
context.diagnostics = mDiagnostics;
context.lexer = mLexer;
context.token = token;
context.result = result;
context.ignoreErrors = 0;
context.parsePresetToken = parsePresetToken;
context.errorSettings = errorSettings;
context.valid = valid;
int ret = yyparse(&context);
switch (ret)
{
case 0:
case 1:
break;
case 2:
mDiagnostics->report(Diagnostics::PP_OUT_OF_MEMORY, token->location, "");
break;
default:
assert(false);
mDiagnostics->report(Diagnostics::PP_INTERNAL_ERROR, token->location, "");
break;
}
return ret == 0;
}
} // namespace pp