src/OpenGL/compiler/preprocessor/ExpressionParser.y - SwiftShader - Git at Google

 /*
 // 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
	/*
	// 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