The Tor Browser: gfx/angle/src/compiler/preprocessor/ExpressionParser.y@129ffea94266 (annotated)

gfx/angle/src/compiler/preprocessor/ExpressionParser.y@129ffea94266 (annotated)

gfx/angle/src/compiler/preprocessor/ExpressionParser.y

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
 //
 // Copyright (c) 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.
 //
 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 (c) 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.
 //
 // 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 4701)
 #endif
 #include "ExpressionParser.h"
 #include <cassert>
 #include <sstream>
 #include "DiagnosticsBase.h"
 #include "Lexer.h"
 #include "Token.h"
 #if defined(_MSC_VER)
 typedef __int64 YYSTYPE;
 #else
 #include <stdint.h>
 typedef intmax_t YYSTYPE;
 #endif  // _MSC_VER
 #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;
 };
 }  // 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
 %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
     | expression TOK_OP_OR expression {
         $$ = $1 || $3;
     }
     | expression TOK_OP_AND expression {
         $$ = $1 && $3;
     }
     | 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 {
         $$ = $1 >> $3;
     }
     | expression TOK_OP_LEFT expression {
         $$ = $1 << $3;
     }
     | expression '-' expression {
         $$ = $1 - $3;
     }
     | expression '+' expression {
         $$ = $1 + $3;
     }
     | expression '%' expression {
         if ($3 == 0) {
             std::ostringstream stream;
             stream << $1 << " % " << $3;
             std::string text = stream.str();
             context->diagnostics->report(pp::Diagnostics::DIVISION_BY_ZERO,
                                          context->token->location,
                                          text.c_str());
             YYABORT;
         } else {
             $$ = $1 % $3;
         }
     }
     | expression '/' expression {
         if ($3 == 0) {
             std::ostringstream stream;
             stream << $1 << " / " << $3;
             std::string text = stream.str();
             context->diagnostics->report(pp::Diagnostics::DIVISION_BY_ZERO,
                                          context->token->location,
                                          text.c_str());
             YYABORT;
         } else {
             $$ = $1 / $3;
         }
     }
     | expression '*' expression {
         $$ = $1 * $3;
     }
     | '!' expression %prec TOK_UNARY {
         $$ = ! $2;
     }
     | '~' expression %prec TOK_UNARY {
         $$ = ~ $2;
     }
     | '-' expression %prec TOK_UNARY {
         $$ = - $2;
     }
     | '+' expression %prec TOK_UNARY {
         $$ = + $2;
     }
     | '(' expression ')' {
         $$ = $2;
     }
 ;
 %%
 int yylex(YYSTYPE* lvalp, Context* context)
 {
     int type = 0;
     pp::Token* token = context->token;
     switch (token->type)
     {
       case pp::Token::CONST_INT:
       {
         unsigned int val = 0;
         if (!token->uValue(&val))
         {
             context->diagnostics->report(pp::Diagnostics::INTEGER_OVERFLOW,
                                          token->location, token->text);
         }
         *lvalp = static_cast<YYSTYPE>(val);
         type = TOK_CONST_INT;
         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 '|': type = '|'; break;
       case '^': type = '^'; break;
       case '&': type = '&'; break;
       case '>': type = '>'; break;
       case '<': type = '<'; break;
       case '-': type = '-'; break;
       case '+': type = '+'; break;
       case '%': type = '%'; break;
       case '/': type = '/'; break;
       case '*': type = '*'; break;
       case '!': type = '!'; break;
       case '~': type = '~'; break;
       case '(': type = '('; break;
       case ')': type = ')'; break;
       default: break;
     }
     // Advance to the next token if the current one is valid.
     if (type != 0) context->lexer->lex(token);
     return type;
 }
 void yyerror(Context* context, const char* reason)
 {
     context->diagnostics->report(pp::Diagnostics::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)
 {
     Context context;
     context.diagnostics = mDiagnostics;
     context.lexer = mLexer;
     context.token = token;
     context.result = result;
     int ret = yyparse(&context);
     switch (ret)
     {
       case 0:
       case 1:
         break;
       case 2:
         mDiagnostics->report(Diagnostics::OUT_OF_MEMORY, token->location, "");
         break;
       default:
         assert(false);
         mDiagnostics->report(Diagnostics::INTERNAL_ERROR, token->location, "");
         break;
     }
     return ret == 0;
 }
 }  // namespace pp

The Tor Browser / annotate

gfx/angle/src/compiler/preprocessor/ExpressionParser.y@129ffea94266 (annotated)

gfx/angle/src/compiler/preprocessor/ExpressionParser.y