Merge commit '50d3e596bbe89c95615f96eb71f6bc5be737a1db' into Basilisk-releasev2018.07.18

# Conflicts:
#	browser/app/profile/firefox.js
#	browser/components/preferences/jar.mn

26 files changed, 351 insertions, 976 deletions

diff --git a/gfx/angle/src/compiler/preprocessor/64bit-tokenizer-safety.patch b/gfx/angle/src/compiler/preprocessor/64bit-tokenizer-safety.patch
index 912520c74..4c2f79441 100755
--- a/gfx/angle/src/compiler/preprocessor/64bit-tokenizer-safety.patch
+++ b/gfx/angle/src/compiler/preprocessor/64bit-tokenizer-safety.patch
@@ -1,79 +1,31 @@
-diff --git a/src/compiler/preprocessor/Tokenizer.cpp b/src/compiler/preprocessor/Tokenizer.cpp
-index 0d7ad58..5ef0e5e 100644
 --- a/src/compiler/preprocessor/Tokenizer.cpp
 +++ b/src/compiler/preprocessor/Tokenizer.cpp
-@@ -1703,7 +1703,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
- 	else
- 		{
- 			int num_to_read =
--			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-+			static_cast<int>(YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1);
- 
- 		while ( num_to_read <= 0 )
- 			{ /* Not enough room in the buffer - grow it. */
-@@ -1737,8 +1737,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
- 
- 			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
- 
--			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
--						number_to_move - 1;
-+			num_to_read = static_cast<int>(YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-+						number_to_move - 1);
- 
- 			}
- 
-@@ -1746,8 +1746,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
- 			num_to_read = YY_READ_BUF_SIZE;
- 
- 		/* Read in more data. */
-+		yy_size_t ret = 0;
- 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
--			yyg->yy_n_chars, num_to_read );
-+			ret, num_to_read );
-+		yyg->yy_n_chars = static_cast<int>(ret);
- 
- 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- 		}
-@@ -1773,13 +1775,13 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
- 
- 	if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
- 		/* Extend the array by 50%, plus the number we really need. */
--		int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-+		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
- 		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
- 		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
- 			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
- 	}
- 
--	yyg->yy_n_chars += number_to_move;
-+	yyg->yy_n_chars += static_cast<int>(number_to_move);
- 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
- 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
- 
-@@ -2171,7 +2173,7 @@ void pppop_buffer_state (yyscan_t yyscanner)
+@@ -56,6 +56,7 @@ typedef int16_t flex_int16_t;
+ typedef uint16_t flex_uint16_t;
+ typedef int32_t flex_int32_t;
+ typedef uint32_t flex_uint32_t;
++typedef uint64_t flex_uint64_t;
+ #else
+ typedef signed char flex_int8_t;
+ typedef short int flex_int16_t;
+@@ -179,6 +180,11 @@ typedef void* yyscan_t;
+ typedef struct yy_buffer_state *YY_BUFFER_STATE;
+ #endif
+
++#ifndef YY_TYPEDEF_YY_SIZE_T
++#define YY_TYPEDEF_YY_SIZE_T
++typedef size_t yy_size_t;
++#endif
++
+ #define EOB_ACT_CONTINUE_SCAN 0
+ #define EOB_ACT_END_OF_FILE 1
+ #define EOB_ACT_LAST_MATCH 2
+@@ -353,7 +354,7 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
   */
- static void ppensure_buffer_stack (yyscan_t yyscanner)
- {
--	int num_to_alloc;
-+	yy_size_t num_to_alloc;
-     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- 
- 	if (!yyg->yy_buffer_stack) {
-@@ -2238,7 +2240,7 @@ YY_BUFFER_STATE pp_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscann
- 	if ( ! b )
- 		YY_FATAL_ERROR( "out of dynamic memory in pp_scan_buffer()" );
- 
--	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-+	b->yy_buf_size = static_cast<int>(size - 2);	/* "- 2" to take care of EOB's */
- 	b->yy_buf_pos = b->yy_ch_buf = base;
- 	b->yy_is_our_buffer = 0;
- 	b->yy_input_file = NULL;
-@@ -2293,7 +2295,7 @@ YY_BUFFER_STATE pp_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yysc
- 	if ( ! buf )
- 		YY_FATAL_ERROR( "out of dynamic memory in pp_scan_bytes()" );
- 
--	for ( i = 0; i < _yybytes_len; ++i )
-+	for ( i = 0; i < static_cast<yy_size_t>(_yybytes_len); ++i )
- 		buf[i] = yybytes[i];
- 
- 	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+ #define YY_DO_BEFORE_ACTION \
+ 	yyg->yytext_ptr = yy_bp; \
+-	yyleng = (size_t) (yy_cp - yy_bp); \
++	yyleng = (yy_size_t) (yy_cp - yy_bp); \
+ 	yyg->yy_hold_char = *yy_cp; \
+ 	*yy_cp = '\0'; \
+ 	yyg->yy_c_buf_p = yy_cp;
diff --git a/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.cpp b/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.cpp
index fcb24e4e8..9f62a9e0e 100755
--- a/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.cpp
+++ b/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.cpp
@@ -4,9 +4,9 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/DiagnosticsBase.h"
+#include "DiagnosticsBase.h"
 
-#include "common/debug.h"
+#include <cassert>
 
 namespace pp
 {
@@ -31,7 +31,7 @@ Diagnostics::Severity Diagnostics::severity(ID id)
     if ((id > PP_WARNING_BEGIN) && (id < PP_WARNING_END))
         return PP_WARNING;
 
-    UNREACHABLE();
+    assert(false);
     return PP_ERROR;
 }
 
@@ -74,8 +74,6 @@ std::string Diagnostics::message(ID id)
         return "predefined macro undefined";
       case PP_MACRO_UNTERMINATED_INVOCATION:
         return "unterminated macro invocation";
-      case PP_MACRO_UNDEFINED_WHILE_INVOKED:
-          return "macro undefined while being invoked";
       case PP_MACRO_TOO_FEW_ARGS:
         return "Not enough arguments for macro";
       case PP_MACRO_TOO_MANY_ARGS:
@@ -133,8 +131,8 @@ std::string Diagnostics::message(ID id)
         return "macro name with a double underscore is reserved - unintented behavior is possible";
       // Warnings end.
       default:
-          UNREACHABLE();
-          return "";
+        assert(false);
+        return "";
     }
 }
 
diff --git a/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.h b/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.h
index 6c3fe9ee9..a0899203f 100755
--- a/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.h
+++ b/gfx/angle/src/compiler/preprocessor/DiagnosticsBase.h
@@ -44,7 +44,6 @@ class Diagnostics
         PP_MACRO_PREDEFINED_REDEFINED,
         PP_MACRO_PREDEFINED_UNDEFINED,
         PP_MACRO_UNTERMINATED_INVOCATION,
-        PP_MACRO_UNDEFINED_WHILE_INVOKED,
         PP_MACRO_TOO_FEW_ARGS,
         PP_MACRO_TOO_MANY_ARGS,
         PP_MACRO_DUPLICATE_PARAMETER_NAMES,
diff --git a/gfx/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp b/gfx/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp
index 049dae907..ef35c6ed5 100755
--- a/gfx/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp
+++ b/gfx/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp
@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/DirectiveHandlerBase.h"
+#include "DirectiveHandlerBase.h"
 
 namespace pp
 {
diff --git a/gfx/angle/src/compiler/preprocessor/DirectiveParser.cpp b/gfx/angle/src/compiler/preprocessor/DirectiveParser.cpp
index 643f73bd9..aceb3b2b2 100755
--- a/gfx/angle/src/compiler/preprocessor/DirectiveParser.cpp
+++ b/gfx/angle/src/compiler/preprocessor/DirectiveParser.cpp
@@ -4,19 +4,19 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/DirectiveParser.h"
+#include "DirectiveParser.h"
 
 #include <algorithm>
+#include <cassert>
 #include <cstdlib>
 #include <sstream>
 
-#include "common/debug.h"
-#include "compiler/preprocessor/DiagnosticsBase.h"
-#include "compiler/preprocessor/DirectiveHandlerBase.h"
-#include "compiler/preprocessor/ExpressionParser.h"
-#include "compiler/preprocessor/MacroExpander.h"
-#include "compiler/preprocessor/Token.h"
-#include "compiler/preprocessor/Tokenizer.h"
+#include "DiagnosticsBase.h"
+#include "DirectiveHandlerBase.h"
+#include "ExpressionParser.h"
+#include "MacroExpander.h"
+#include "Token.h"
+#include "Tokenizer.h"
 
 namespace {
 enum DirectiveType
@@ -248,7 +248,7 @@ void DirectiveParser::lex(Token *token)
 
 void DirectiveParser::parseDirective(Token *token)
 {
-    ASSERT(token->type == Token::PP_HASH);
+    assert(token->type == Token::PP_HASH);
 
     mTokenizer->lex(token);
     if (isEOD(token))
@@ -314,8 +314,8 @@ void DirectiveParser::parseDirective(Token *token)
         parseLine(token);
         break;
       default:
-          UNREACHABLE();
-          break;
+        assert(false);
+        break;
     }
 
     skipUntilEOD(mTokenizer, token);
@@ -328,7 +328,7 @@ void DirectiveParser::parseDirective(Token *token)
 
 void DirectiveParser::parseDefine(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_DEFINE);
+    assert(getDirective(token) == DIRECTIVE_DEFINE);
 
     mTokenizer->lex(token);
     if (token->type != Token::IDENTIFIER)
@@ -428,7 +428,7 @@ void DirectiveParser::parseDefine(Token *token)
 
 void DirectiveParser::parseUndef(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_UNDEF);
+    assert(getDirective(token) == DIRECTIVE_UNDEF);
 
     mTokenizer->lex(token);
     if (token->type != Token::IDENTIFIER)
@@ -445,13 +445,6 @@ void DirectiveParser::parseUndef(Token *token)
         {
             mDiagnostics->report(Diagnostics::PP_MACRO_PREDEFINED_UNDEFINED,
                                  token->location, token->text);
-            return;
-        }
-        else if (iter->second.expansionCount > 0)
-        {
-            mDiagnostics->report(Diagnostics::PP_MACRO_UNDEFINED_WHILE_INVOKED, token->location,
-                                 token->text);
-            return;
         }
         else
         {
@@ -470,25 +463,25 @@ void DirectiveParser::parseUndef(Token *token)
 
 void DirectiveParser::parseIf(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_IF);
+    assert(getDirective(token) == DIRECTIVE_IF);
     parseConditionalIf(token);
 }
 
 void DirectiveParser::parseIfdef(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_IFDEF);
+    assert(getDirective(token) == DIRECTIVE_IFDEF);
     parseConditionalIf(token);
 }
 
 void DirectiveParser::parseIfndef(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_IFNDEF);
+    assert(getDirective(token) == DIRECTIVE_IFNDEF);
     parseConditionalIf(token);
 }
 
 void DirectiveParser::parseElse(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_ELSE);
+    assert(getDirective(token) == DIRECTIVE_ELSE);
 
     if (mConditionalStack.empty())
     {
@@ -529,7 +522,7 @@ void DirectiveParser::parseElse(Token *token)
 
 void DirectiveParser::parseElif(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_ELIF);
+    assert(getDirective(token) == DIRECTIVE_ELIF);
 
     if (mConditionalStack.empty())
     {
@@ -569,7 +562,7 @@ void DirectiveParser::parseElif(Token *token)
 
 void DirectiveParser::parseEndif(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_ENDIF);
+    assert(getDirective(token) == DIRECTIVE_ENDIF);
 
     if (mConditionalStack.empty())
     {
@@ -593,7 +586,7 @@ void DirectiveParser::parseEndif(Token *token)
 
 void DirectiveParser::parseError(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_ERROR);
+    assert(getDirective(token) == DIRECTIVE_ERROR);
 
     std::ostringstream stream;
     mTokenizer->lex(token);
@@ -608,7 +601,7 @@ void DirectiveParser::parseError(Token *token)
 // Parses pragma of form: #pragma name[(value)].
 void DirectiveParser::parsePragma(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_PRAGMA);
+    assert(getDirective(token) == DIRECTIVE_PRAGMA);
 
     enum State
     {
@@ -669,7 +662,7 @@ void DirectiveParser::parsePragma(Token *token)
 
 void DirectiveParser::parseExtension(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_EXTENSION);
+    assert(getDirective(token) == DIRECTIVE_EXTENSION);
 
     enum State
     {
@@ -750,7 +743,7 @@ void DirectiveParser::parseExtension(Token *token)
 
 void DirectiveParser::parseVersion(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_VERSION);
+    assert(getDirective(token) == DIRECTIVE_VERSION);
 
     if (mPastFirstStatement)
     {
@@ -837,7 +830,7 @@ void DirectiveParser::parseVersion(Token *token)
 
 void DirectiveParser::parseLine(Token *token)
 {
-    ASSERT(getDirective(token) == DIRECTIVE_LINE);
+    assert(getDirective(token) == DIRECTIVE_LINE);
 
     bool valid = true;
     bool parsedFileNumber = false;
@@ -938,8 +931,8 @@ void DirectiveParser::parseConditionalIf(Token *token)
             expression = parseExpressionIfdef(token) == 0 ? 1 : 0;
             break;
           default:
-              UNREACHABLE();
-              break;
+            assert(false);
+            break;
         }
         block.skipGroup = expression == 0;
         block.foundValidGroup = expression != 0;
@@ -949,7 +942,8 @@ void DirectiveParser::parseConditionalIf(Token *token)
 
 int DirectiveParser::parseExpressionIf(Token *token)
 {
-    ASSERT((getDirective(token) == DIRECTIVE_IF) || (getDirective(token) == DIRECTIVE_ELIF));
+    assert((getDirective(token) == DIRECTIVE_IF) ||
+           (getDirective(token) == DIRECTIVE_ELIF));
 
     DefinedParser definedParser(mTokenizer, mMacroSet, mDiagnostics);
     MacroExpander macroExpander(&definedParser, mMacroSet, mDiagnostics);
@@ -976,7 +970,8 @@ int DirectiveParser::parseExpressionIf(Token *token)
 
 int DirectiveParser::parseExpressionIfdef(Token *token)
 {
-    ASSERT((getDirective(token) == DIRECTIVE_IFDEF) || (getDirective(token) == DIRECTIVE_IFNDEF));
+    assert((getDirective(token) == DIRECTIVE_IFDEF) ||
+           (getDirective(token) == DIRECTIVE_IFNDEF));
 
     mTokenizer->lex(token);
     if (token->type != Token::IDENTIFIER)
diff --git a/gfx/angle/src/compiler/preprocessor/DirectiveParser.h b/gfx/angle/src/compiler/preprocessor/DirectiveParser.h
index f0e889c8a..2888e289c 100755
--- a/gfx/angle/src/compiler/preprocessor/DirectiveParser.h
+++ b/gfx/angle/src/compiler/preprocessor/DirectiveParser.h
@@ -7,9 +7,10 @@
 #ifndef COMPILER_PREPROCESSOR_DIRECTIVEPARSER_H_
 #define COMPILER_PREPROCESSOR_DIRECTIVEPARSER_H_
 
-#include "compiler/preprocessor/Lexer.h"
-#include "compiler/preprocessor/Macro.h"
-#include "compiler/preprocessor/SourceLocation.h"
+#include "Lexer.h"
+#include "Macro.h"
+#include "pp_utils.h"
+#include "SourceLocation.h"
 
 namespace pp
 {
@@ -29,6 +30,7 @@ class DirectiveParser : public Lexer
     void lex(Token *token) override;
 
   private:
+    PP_DISALLOW_COPY_AND_ASSIGN(DirectiveParser);
 
     void parseDirective(Token *token);
     void parseDefine(Token *token);
diff --git a/gfx/angle/src/compiler/preprocessor/ExpressionParser.cpp b/gfx/angle/src/compiler/preprocessor/ExpressionParser.cpp
index ee20a6ff6..b765c644c 100755
--- a/gfx/angle/src/compiler/preprocessor/ExpressionParser.cpp
+++ b/gfx/angle/src/compiler/preprocessor/ExpressionParser.cpp
@@ -99,15 +99,17 @@
 
 #include <cassert>
 #include <sstream>
-#include <stdint.h>
 
 #include "DiagnosticsBase.h"
 #include "Lexer.h"
 #include "Token.h"
-#include "common/mathutil.h"
 
-typedef int32_t YYSTYPE;
-typedef uint32_t UNSIGNED_TYPE;
+#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
@@ -496,12 +498,9 @@ static const yytype_uint8 yytranslate[] =
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-static const yytype_uint16 yyrline[] =
-{
-       0,   108,   108,   115,   116,   127,   127,   148,   148,   169,
-     172,   175,   178,   181,   184,   187,   190,   193,   196,   221,
-     246,   249,   252,   278,   305,   308,   311,   314,   326,   329
-};
+static const yytype_uint16 yyrline[] = {0,   110, 110, 117, 118, 129, 129, 150, 150, 171,
+                                        174, 177, 180, 183, 186, 189, 192, 195, 198, 218,
+                                        238, 241, 244, 264, 284, 287, 290, 293, 296, 299};
 #endif
 
 #if YYDEBUG || YYERROR_VERBOSE || 0
@@ -1493,7 +1492,7 @@ yyreduce:
   case 18:
 
     {
-        if ((yyvsp[0]) < 0 || (yyvsp[0]) > 31)
+        if ((yyvsp[0]) < 0)
         {
             if (!context->isIgnoringErrors())
             {
@@ -1501,17 +1500,11 @@ yyreduce:
                 stream << (yyvsp[-2]) << " >> " << (yyvsp[0]);
                 std::string text = stream.str();
                 context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
-                                             context->token->location,
-                                             text.c_str());
+                                             context->token->location, text.c_str());
                 *(context->valid) = false;
             }
             (yyval) = static_cast<YYSTYPE>(0);
         }
-        else if ((yyvsp[-2]) < 0)
-        {
-            // Logical shift right.
-            (yyval) = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>((yyvsp[-2])) >> (yyvsp[0]));
-        }
         else
         {
             (yyval) = (yyvsp[-2]) >> (yyvsp[0]);
@@ -1523,7 +1516,7 @@ yyreduce:
   case 19:
 
     {
-        if ((yyvsp[0]) < 0 || (yyvsp[0]) > 31)
+        if ((yyvsp[0]) < 0)
         {
             if (!context->isIgnoringErrors())
             {
@@ -1531,17 +1524,11 @@ yyreduce:
                 stream << (yyvsp[-2]) << " << " << (yyvsp[0]);
                 std::string text = stream.str();
                 context->diagnostics->report(pp::Diagnostics::PP_UNDEFINED_SHIFT,
-                                             context->token->location,
-                                             text.c_str());
+                                             context->token->location, text.c_str());
                 *(context->valid) = false;
             }
             (yyval) = static_cast<YYSTYPE>(0);
         }
-        else if ((yyvsp[-2]) < 0)
-        {
-            // Logical shift left.
-            (yyval) = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>((yyvsp[-2])) << (yyvsp[0]));
-        }
         else
         {
             (yyval) = (yyvsp[-2]) << (yyvsp[0]);
@@ -1553,7 +1540,7 @@ yyreduce:
   case 20:
 
     {
-        (yyval) = gl::WrappingDiff<YYSTYPE>((yyvsp[-2]), (yyvsp[0]));
+        (yyval) = (yyvsp[-2]) - (yyvsp[0]);
     }
 
     break;
@@ -1561,7 +1548,7 @@ yyreduce:
   case 21:
 
     {
-        (yyval) = gl::WrappingSum<YYSTYPE>((yyvsp[-2]), (yyvsp[0]));
+        (yyval) = (yyvsp[-2]) + (yyvsp[0]);
     }
 
     break;
@@ -1583,12 +1570,6 @@ yyreduce:
             }
             (yyval) = static_cast<YYSTYPE>(0);
         }
-        else if (((yyvsp[-2]) == std::numeric_limits<YYSTYPE>::min()) && ((yyvsp[0]) == -1))
-        {
-            // Check for the special case where the minimum representable number is
-            // divided by -1. If left alone this has undefined results.
-            (yyval) = 0;
-        }
         else
         {
             (yyval) = (yyvsp[-2]) % (yyvsp[0]);
@@ -1614,13 +1595,6 @@ yyreduce:
             }
             (yyval) = static_cast<YYSTYPE>(0);
         }
-        else if (((yyvsp[-2]) == std::numeric_limits<YYSTYPE>::min()) && ((yyvsp[0]) == -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.
-            (yyval) = std::numeric_limits<YYSTYPE>::max();
-        }
         else
         {
             (yyval) = (yyvsp[-2]) / (yyvsp[0]);
@@ -1632,7 +1606,7 @@ yyreduce:
   case 24:
 
     {
-        (yyval) = gl::WrappingMul((yyvsp[-2]), (yyvsp[0]));
+        (yyval) = (yyvsp[-2]) * (yyvsp[0]);
     }
 
     break;
@@ -1656,16 +1630,7 @@ yyreduce:
   case 27:
 
     {
-        // Check for negation of minimum representable integer to prevent undefined signed int
-        // overflow.
-        if ((yyvsp[0]) == std::numeric_limits<YYSTYPE>::min())
-        {
-            (yyval) = std::numeric_limits<YYSTYPE>::min();
-        }
-        else
-        {
-            (yyval) = -(yyvsp[0]);
-        }
+        (yyval) = - (yyvsp[0]);
     }
 
     break;
diff --git a/gfx/angle/src/compiler/preprocessor/ExpressionParser.h b/gfx/angle/src/compiler/preprocessor/ExpressionParser.h
index 0f2901b87..841c67b61 100755
--- a/gfx/angle/src/compiler/preprocessor/ExpressionParser.h
+++ b/gfx/angle/src/compiler/preprocessor/ExpressionParser.h
@@ -7,8 +7,8 @@
 #ifndef COMPILER_PREPROCESSOR_EXPRESSIONPARSER_H_
 #define COMPILER_PREPROCESSOR_EXPRESSIONPARSER_H_
 
-#include "common/angleutils.h"
-#include "compiler/preprocessor/DiagnosticsBase.h"
+#include "DiagnosticsBase.h"
+#include "pp_utils.h"
 
 namespace pp
 {
@@ -16,7 +16,7 @@ namespace pp
 class Lexer;
 struct Token;
 
-class ExpressionParser : angle::NonCopyable
+class ExpressionParser
 {
   public:
     struct ErrorSettings
@@ -34,6 +34,8 @@ class ExpressionParser : angle::NonCopyable
                bool *valid);
 
   private:
+    PP_DISALLOW_COPY_AND_ASSIGN(ExpressionParser);
+
     Lexer *mLexer;
     Diagnostics *mDiagnostics;
 };
diff --git a/gfx/angle/src/compiler/preprocessor/ExpressionParser.y b/gfx/angle/src/compiler/preprocessor/ExpressionParser.y
index 4dbc9e828..dc0080eac 100755
--- a/gfx/angle/src/compiler/preprocessor/ExpressionParser.y
+++ b/gfx/angle/src/compiler/preprocessor/ExpressionParser.y
@@ -41,15 +41,17 @@ WHICH GENERATES THE GLSL ES preprocessor expression parser.
 
 #include <cassert>
 #include <sstream>
-#include <stdint.h>
 
 #include "DiagnosticsBase.h"
 #include "Lexer.h"
 #include "Token.h"
-#include "common/mathutil.h"
 
-typedef int32_t YYSTYPE;
-typedef uint32_t UNSIGNED_TYPE;
+#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
@@ -194,7 +196,7 @@ expression
         $$ = $1 < $3;
     }
     | expression TOK_OP_RIGHT expression {
-        if ($3 < 0 || $3 > 31)
+        if ($3 < 0)
         {
             if (!context->isIgnoringErrors())
             {
@@ -208,18 +210,13 @@ expression
             }
             $$ = 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 ($3 < 0)
         {
             if (!context->isIgnoringErrors())
             {
@@ -233,21 +230,16 @@ expression
             }
             $$ = static_cast<YYSTYPE>(0);
         }
-        else if ($1 < 0)
-        {
-            // Logical shift left.
-            $$ = static_cast<YYSTYPE>(static_cast<UNSIGNED_TYPE>($1) << $3);
-        }
         else
         {
             $$ = $1 << $3;
         }
     }
     | expression '-' expression {
-        $$ = gl::WrappingDiff<YYSTYPE>($1, $3);
+        $$ = $1 - $3;
     }
     | expression '+' expression {
-        $$ = gl::WrappingSum<YYSTYPE>($1, $3);
+        $$ = $1 + $3;
     }
     | expression '%' expression {
         if ($3 == 0)
@@ -264,12 +256,6 @@ expression
             }
             $$ = 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;
@@ -290,20 +276,13 @@ expression
             }
             $$ = 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 {
-        $$ = gl::WrappingMul($1, $3);
+        $$ = $1 * $3;
     }
     | '!' expression %prec TOK_UNARY {
         $$ = ! $2;
@@ -312,16 +291,7 @@ expression
         $$ = ~ $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;
-        }
+        $$ = - $2;
     }
     | '+' expression %prec TOK_UNARY {
         $$ = + $2;
diff --git a/gfx/angle/src/compiler/preprocessor/Input.cpp b/gfx/angle/src/compiler/preprocessor/Input.cpp
index 8bce56ff2..5541d46f7 100755
--- a/gfx/angle/src/compiler/preprocessor/Input.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Input.cpp
@@ -4,13 +4,12 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/Input.h"
+#include "Input.h"
 
 #include <algorithm>
+#include <cassert>
 #include <cstring>
 
-#include "common/debug.h"
-
 namespace pp
 {
 
@@ -33,7 +32,7 @@ Input::Input(size_t count, const char *const string[], const int length[]) :
 const char *Input::skipChar()
 {
     // This function should only be called when there is a character to skip.
-    ASSERT(mReadLoc.cIndex < mLength[mReadLoc.sIndex]);
+    assert(mReadLoc.cIndex < mLength[mReadLoc.sIndex]);
     ++mReadLoc.cIndex;
     if (mReadLoc.cIndex == mLength[mReadLoc.sIndex])
     {
diff --git a/gfx/angle/src/compiler/preprocessor/Input.h b/gfx/angle/src/compiler/preprocessor/Input.h
index ecbb04962..a1de7ddd8 100755
--- a/gfx/angle/src/compiler/preprocessor/Input.h
+++ b/gfx/angle/src/compiler/preprocessor/Input.h
@@ -7,7 +7,7 @@
 #ifndef COMPILER_PREPROCESSOR_INPUT_H_
 #define COMPILER_PREPROCESSOR_INPUT_H_
 
-#include <cstddef>
+#include <stddef.h>
 #include <vector>
 
 namespace pp
diff --git a/gfx/angle/src/compiler/preprocessor/Lexer.cpp b/gfx/angle/src/compiler/preprocessor/Lexer.cpp
index 89cb3cf44..7c663ee76 100755
--- a/gfx/angle/src/compiler/preprocessor/Lexer.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Lexer.cpp
@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/Lexer.h"
+#include "Lexer.h"
 
 namespace pp
 {
diff --git a/gfx/angle/src/compiler/preprocessor/Lexer.h b/gfx/angle/src/compiler/preprocessor/Lexer.h
index 775bc0a20..990dc5e21 100755
--- a/gfx/angle/src/compiler/preprocessor/Lexer.h
+++ b/gfx/angle/src/compiler/preprocessor/Lexer.h
@@ -7,14 +7,12 @@
 #ifndef COMPILER_PREPROCESSOR_LEXER_H_
 #define COMPILER_PREPROCESSOR_LEXER_H_
 
-#include "common/angleutils.h"
-
 namespace pp
 {
 
 struct Token;
 
-class Lexer : angle::NonCopyable
+class Lexer
 {
   public:
     virtual ~Lexer();
diff --git a/gfx/angle/src/compiler/preprocessor/Macro.cpp b/gfx/angle/src/compiler/preprocessor/Macro.cpp
index f5c94399d..4c4d5fd2e 100755
--- a/gfx/angle/src/compiler/preprocessor/Macro.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Macro.cpp
@@ -4,10 +4,11 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/Macro.h"
+#include "Macro.h"
 
-#include "common/angleutils.h"
-#include "compiler/preprocessor/Token.h"
+#include <sstream>
+
+#include "Token.h"
 
 namespace pp
 {
@@ -22,9 +23,12 @@ bool Macro::equals(const Macro &other) const
 
 void PredefineMacro(MacroSet *macroSet, const char *name, int value)
 {
+    std::ostringstream stream;
+    stream << value;
+
     Token token;
     token.type = Token::CONST_INT;
-    token.text = ToString(value);
+    token.text = stream.str();
 
     Macro macro;
     macro.predefined = true;
diff --git a/gfx/angle/src/compiler/preprocessor/Macro.h b/gfx/angle/src/compiler/preprocessor/Macro.h
index 557df163c..31ee22c26 100755
--- a/gfx/angle/src/compiler/preprocessor/Macro.h
+++ b/gfx/angle/src/compiler/preprocessor/Macro.h
@@ -26,12 +26,16 @@ struct Macro
     typedef std::vector<std::string> Parameters;
     typedef std::vector<Token> Replacements;
 
-    Macro() : predefined(false), disabled(false), expansionCount(0), type(kTypeObj) {}
+    Macro()
+        : predefined(false),
+          disabled(false),
+          type(kTypeObj)
+    {
+    }
     bool equals(const Macro &other) const;
 
     bool predefined;
     mutable bool disabled;
-    mutable int expansionCount;
 
     Type type;
     std::string name;
diff --git a/gfx/angle/src/compiler/preprocessor/MacroExpander.cpp b/gfx/angle/src/compiler/preprocessor/MacroExpander.cpp
index 2f854f5a6..3c0423e72 100755
--- a/gfx/angle/src/compiler/preprocessor/MacroExpander.cpp
+++ b/gfx/angle/src/compiler/preprocessor/MacroExpander.cpp
@@ -4,22 +4,17 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/MacroExpander.h"
+#include "MacroExpander.h"
 
 #include <algorithm>
+#include <sstream>
 
-#include "common/debug.h"
-#include "compiler/preprocessor/DiagnosticsBase.h"
-#include "compiler/preprocessor/Token.h"
+#include "DiagnosticsBase.h"
+#include "Token.h"
 
 namespace pp
 {
 
-namespace
-{
-
-const size_t kMaxContextTokens = 10000;
-
 class TokenLexer : public Lexer
 {
  public:
@@ -45,52 +40,22 @@ class TokenLexer : public Lexer
     }
 
  private:
+    PP_DISALLOW_COPY_AND_ASSIGN(TokenLexer);
+
     TokenVector mTokens;
     TokenVector::const_iterator mIter;
 };
 
-}  // anonymous namespace
-
-class MacroExpander::ScopedMacroReenabler final : angle::NonCopyable
-{
-  public:
-    ScopedMacroReenabler(MacroExpander *expander);
-    ~ScopedMacroReenabler();
-
-  private:
-    MacroExpander *mExpander;
-};
-
-MacroExpander::ScopedMacroReenabler::ScopedMacroReenabler(MacroExpander *expander)
-    : mExpander(expander)
-{
-    mExpander->mDeferReenablingMacros = true;
-}
-
-MacroExpander::ScopedMacroReenabler::~ScopedMacroReenabler()
-{
-    mExpander->mDeferReenablingMacros = false;
-    for (auto *macro : mExpander->mMacrosToReenable)
-    {
-        macro->disabled = false;
-    }
-    mExpander->mMacrosToReenable.clear();
-}
-
 MacroExpander::MacroExpander(Lexer *lexer, MacroSet *macroSet, Diagnostics *diagnostics)
-    : mLexer(lexer),
-      mMacroSet(macroSet),
-      mDiagnostics(diagnostics),
-      mTotalTokensInContexts(0),
-      mDeferReenablingMacros(false)
+    : mLexer(lexer), mMacroSet(macroSet), mDiagnostics(diagnostics)
 {
 }
 
 MacroExpander::~MacroExpander()
 {
-    for (MacroContext *context : mContextStack)
+    for (std::size_t i = 0; i < mContextStack.size(); ++i)
     {
-        delete context;
+        delete mContextStack[i];
     }
 }
 
@@ -117,15 +82,10 @@ void MacroExpander::lex(Token *token)
             token->setExpansionDisabled(true);
             break;
         }
-
-        // Bump the expansion count before peeking if the next token is a '('
-        // otherwise there could be a #undef of the macro before the next token.
-        macro.expansionCount++;
         if ((macro.type == Macro::kTypeFunc) && !isNextTokenLeftParen())
         {
             // If the token immediately after the macro name is not a '(',
             // this macro should not be expanded.
-            macro.expansionCount--;
             break;
         }
 
@@ -154,7 +114,6 @@ void MacroExpander::getToken(Token *token)
     }
     else
     {
-        ASSERT(mTotalTokensInContexts == 0);
         mLexer->lex(token);
     }
 }
@@ -165,11 +124,11 @@ void MacroExpander::ungetToken(const Token &token)
     {
         MacroContext *context = mContextStack.back();
         context->unget();
-        ASSERT(context->replacements[context->index] == token);
+        assert(context->replacements[context->index] == token);
     }
     else
     {
-        ASSERT(!mReserveToken.get());
+        assert(!mReserveToken.get());
         mReserveToken.reset(new Token(token));
     }
 }
@@ -187,10 +146,10 @@ bool MacroExpander::isNextTokenLeftParen()
 
 bool MacroExpander::pushMacro(const Macro &macro, const Token &identifier)
 {
-    ASSERT(!macro.disabled);
-    ASSERT(!identifier.expansionDisabled());
-    ASSERT(identifier.type == Token::IDENTIFIER);
-    ASSERT(identifier.text == macro.name);
+    assert(!macro.disabled);
+    assert(!identifier.expansionDisabled());
+    assert(identifier.type == Token::IDENTIFIER);
+    assert(identifier.text == macro.name);
 
     std::vector<Token> replacements;
     if (!expandMacro(macro, identifier, &replacements))
@@ -203,30 +162,19 @@ bool MacroExpander::pushMacro(const Macro &macro, const Token &identifier)
     context->macro = &macro;
     context->replacements.swap(replacements);
     mContextStack.push_back(context);
-    mTotalTokensInContexts += context->replacements.size();
     return true;
 }
 
 void MacroExpander::popMacro()
 {
-    ASSERT(!mContextStack.empty());
+    assert(!mContextStack.empty());
 
     MacroContext *context = mContextStack.back();
     mContextStack.pop_back();
 
-    ASSERT(context->empty());
-    ASSERT(context->macro->disabled);
-    ASSERT(context->macro->expansionCount > 0);
-    if (mDeferReenablingMacros)
-    {
-        mMacrosToReenable.push_back(context->macro);
-    }
-    else
-    {
-        context->macro->disabled = false;
-    }
-    context->macro->expansionCount--;
-    mTotalTokensInContexts -= context->replacements.size();
+    assert(context->empty());
+    assert(context->macro->disabled);
+    context->macro->disabled = false;
     delete context;
 }
 
@@ -251,21 +199,25 @@ bool MacroExpander::expandMacro(const Macro &macro,
             const char kLine[] = "__LINE__";
             const char kFile[] = "__FILE__";
 
-            ASSERT(replacements->size() == 1);
+            assert(replacements->size() == 1);
             Token& repl = replacements->front();
             if (macro.name == kLine)
             {
-                repl.text = ToString(identifier.location.line);
+                std::ostringstream stream;
+                stream << identifier.location.line;
+                repl.text = stream.str();
             }
             else if (macro.name == kFile)
             {
-                repl.text = ToString(identifier.location.file);
+                std::ostringstream stream;
+                stream << identifier.location.file;
+                repl.text = stream.str();
             }
         }
     }
     else
     {
-        ASSERT(macro.type == Macro::kTypeFunc);
+        assert(macro.type == Macro::kTypeFunc);
         std::vector<MacroArg> args;
         args.reserve(macro.parameters.size());
         if (!collectMacroArgs(macro, identifier, &args, &replacementLocation))
@@ -296,17 +248,10 @@ bool MacroExpander::collectMacroArgs(const Macro &macro,
 {
     Token token;
     getToken(&token);
-    ASSERT(token.type == '(');
+    assert(token.type == '(');
 
     args->push_back(MacroArg());
-
-    // Defer reenabling macros until args collection is finished to avoid the possibility of
-    // infinite recursion. Otherwise infinite recursion might happen when expanding the args after
-    // macros have been popped from the context stack when parsing the args.
-    ScopedMacroReenabler deferReenablingMacros(this);
-
-    int openParens = 1;
-    while (openParens != 0)
+    for (int openParens = 1; openParens != 0; )
     {
         getToken(&token);
 
@@ -372,9 +317,9 @@ bool MacroExpander::collectMacroArgs(const Macro &macro,
     // Pre-expand each argument before substitution.
     // This step expands each argument individually before they are
     // inserted into the macro body.
-    size_t numTokens = 0;
-    for (auto &arg : *args)
+    for (std::size_t i = 0; i < args->size(); ++i)
     {
+        MacroArg &arg = args->at(i);
         TokenLexer lexer(&arg);
         MacroExpander expander(&lexer, mMacroSet, mDiagnostics);
 
@@ -384,12 +329,6 @@ bool MacroExpander::collectMacroArgs(const Macro &macro,
         {
             arg.push_back(token);
             expander.lex(&token);
-            numTokens++;
-            if (numTokens + mTotalTokensInContexts > kMaxContextTokens)
-            {
-                mDiagnostics->report(Diagnostics::PP_OUT_OF_MEMORY, token.location, token.text);
-                return false;
-            }
         }
     }
     return true;
@@ -401,14 +340,6 @@ void MacroExpander::replaceMacroParams(const Macro &macro,
 {
     for (std::size_t i = 0; i < macro.replacements.size(); ++i)
     {
-        if (!replacements->empty() &&
-            replacements->size() + mTotalTokensInContexts > kMaxContextTokens)
-        {
-            const Token &token = replacements->back();
-            mDiagnostics->report(Diagnostics::PP_OUT_OF_MEMORY, token.location, token.text);
-            return;
-        }
-
         const Token &repl = macro.replacements[i];
         if (repl.type != Token::IDENTIFIER)
         {
@@ -441,25 +372,5 @@ void MacroExpander::replaceMacroParams(const Macro &macro,
     }
 }
 
-MacroExpander::MacroContext::MacroContext() : macro(0), index(0)
-{
-}
-
-bool MacroExpander::MacroContext::empty() const
-{
-    return index == replacements.size();
-}
-
-const Token &MacroExpander::MacroContext::get()
-{
-    return replacements[index++];
-}
-
-void MacroExpander::MacroContext::unget()
-{
-    ASSERT(index > 0);
-    --index;
-}
-
 }  // namespace pp
 
diff --git a/gfx/angle/src/compiler/preprocessor/MacroExpander.h b/gfx/angle/src/compiler/preprocessor/MacroExpander.h
index 3a8450f5e..dbf980308 100755
--- a/gfx/angle/src/compiler/preprocessor/MacroExpander.h
+++ b/gfx/angle/src/compiler/preprocessor/MacroExpander.h
@@ -7,11 +7,13 @@
 #ifndef COMPILER_PREPROCESSOR_MACROEXPANDER_H_
 #define COMPILER_PREPROCESSOR_MACROEXPANDER_H_
 
+#include <cassert>
 #include <memory>
 #include <vector>
 
-#include "compiler/preprocessor/Lexer.h"
-#include "compiler/preprocessor/Macro.h"
+#include "Lexer.h"
+#include "Macro.h"
+#include "pp_utils.h"
 
 namespace pp
 {
@@ -28,6 +30,8 @@ class MacroExpander : public Lexer
     void lex(Token *token) override;
 
   private:
+    PP_DISALLOW_COPY_AND_ASSIGN(MacroExpander);
+
     void getToken(Token *token);
     void ungetToken(const Token &token);
     bool isNextTokenLeftParen();
@@ -50,14 +54,28 @@ class MacroExpander : public Lexer
 
     struct MacroContext
     {
-        MacroContext();
-        bool empty() const;
-        const Token &get();
-        void unget();
-
         const Macro *macro;
         std::size_t index;
         std::vector<Token> replacements;
+
+        MacroContext()
+            : macro(0),
+              index(0)
+        {
+        }
+        bool empty() const
+        {
+            return index == replacements.size();
+        }
+        const Token &get()
+        {
+            return replacements[index++];
+        }
+        void unget()
+        {
+            assert(index > 0);
+            --index;
+        }
     };
 
     Lexer *mLexer;
@@ -66,12 +84,6 @@ class MacroExpander : public Lexer
 
     std::unique_ptr<Token> mReserveToken;
     std::vector<MacroContext *> mContextStack;
-    size_t mTotalTokensInContexts;
-
-    bool mDeferReenablingMacros;
-    std::vector<const Macro *> mMacrosToReenable;
-
-    class ScopedMacroReenabler;
 };
 
 }  // namespace pp
diff --git a/gfx/angle/src/compiler/preprocessor/Preprocessor.cpp b/gfx/angle/src/compiler/preprocessor/Preprocessor.cpp
index 1709d6673..2fa87fe74 100755
--- a/gfx/angle/src/compiler/preprocessor/Preprocessor.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Preprocessor.cpp
@@ -4,15 +4,16 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/Preprocessor.h"
+#include "Preprocessor.h"
 
-#include "common/debug.h"
-#include "compiler/preprocessor/DiagnosticsBase.h"
-#include "compiler/preprocessor/DirectiveParser.h"
-#include "compiler/preprocessor/Macro.h"
-#include "compiler/preprocessor/MacroExpander.h"
-#include "compiler/preprocessor/Token.h"
-#include "compiler/preprocessor/Tokenizer.h"
+#include <cassert>
+
+#include "DiagnosticsBase.h"
+#include "DirectiveParser.h"
+#include "Macro.h"
+#include "MacroExpander.h"
+#include "Token.h"
+#include "Tokenizer.h"
 
 namespace pp
 {
@@ -77,8 +78,8 @@ void Preprocessor::lex(Token *token)
           // Convert preprocessing tokens to compiler tokens or report
           // diagnostics.
           case Token::PP_HASH:
-              UNREACHABLE();
-              break;
+            assert(false);
+            break;
           case Token::PP_NUMBER:
             mImpl->diagnostics->report(Diagnostics::PP_INVALID_NUMBER,
                                        token->location, token->text);
diff --git a/gfx/angle/src/compiler/preprocessor/Preprocessor.h b/gfx/angle/src/compiler/preprocessor/Preprocessor.h
index cd699786f..fe25daa12 100755
--- a/gfx/angle/src/compiler/preprocessor/Preprocessor.h
+++ b/gfx/angle/src/compiler/preprocessor/Preprocessor.h
@@ -7,9 +7,9 @@
 #ifndef COMPILER_PREPROCESSOR_PREPROCESSOR_H_
 #define COMPILER_PREPROCESSOR_PREPROCESSOR_H_
 
-#include <cstddef>
+#include <stddef.h>
 
-#include "common/angleutils.h"
+#include "pp_utils.h"
 
 namespace pp
 {
@@ -19,7 +19,7 @@ class DirectiveHandler;
 struct PreprocessorImpl;
 struct Token;
 
-class Preprocessor : angle::NonCopyable
+class Preprocessor
 {
   public:
     Preprocessor(Diagnostics *diagnostics, DirectiveHandler *directiveHandler);
@@ -44,6 +44,8 @@ class Preprocessor : angle::NonCopyable
     void setMaxTokenSize(size_t maxTokenSize);
 
   private:
+    PP_DISALLOW_COPY_AND_ASSIGN(Preprocessor);
+
     PreprocessorImpl *mImpl;
 };
 
diff --git a/gfx/angle/src/compiler/preprocessor/Token.cpp b/gfx/angle/src/compiler/preprocessor/Token.cpp
index 41610a402..d10265474 100755
--- a/gfx/angle/src/compiler/preprocessor/Token.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Token.cpp
@@ -4,10 +4,11 @@
 // found in the LICENSE file.
 //
 
-#include "compiler/preprocessor/Token.h"
+#include "Token.h"
 
-#include "common/debug.h"
-#include "compiler/preprocessor/numeric_lex.h"
+#include <cassert>
+
+#include "numeric_lex.h"
 
 namespace pp
 {
@@ -54,19 +55,19 @@ void Token::setExpansionDisabled(bool disable)
 
 bool Token::iValue(int *value) const
 {
-    ASSERT(type == CONST_INT);
+    assert(type == CONST_INT);
     return numeric_lex_int(text, value);
 }
 
 bool Token::uValue(unsigned int *value) const
 {
-    ASSERT(type == CONST_INT);
+    assert(type == CONST_INT);
     return numeric_lex_int(text, value);
 }
 
 bool Token::fValue(float *value) const
 {
-    ASSERT(type == CONST_FLOAT);
+    assert(type == CONST_FLOAT);
     return numeric_lex_float(text, value);
 }
 
diff --git a/gfx/angle/src/compiler/preprocessor/Token.h b/gfx/angle/src/compiler/preprocessor/Token.h
index 716503b32..347c47e30 100755
--- a/gfx/angle/src/compiler/preprocessor/Token.h
+++ b/gfx/angle/src/compiler/preprocessor/Token.h
@@ -10,7 +10,7 @@
 #include <ostream>
 #include <string>
 
-#include "compiler/preprocessor/SourceLocation.h"
+#include "SourceLocation.h"
 
 namespace pp
 {
@@ -113,7 +113,7 @@ inline bool operator!=(const Token &lhs, const Token &rhs)
     return !lhs.equals(rhs);
 }
 
-std::ostream &operator<<(std::ostream &out, const Token &token);
+extern std::ostream &operator<<(std::ostream &out, const Token &token);
 
 }  // namepsace pp
 
diff --git a/gfx/angle/src/compiler/preprocessor/Tokenizer.cpp b/gfx/angle/src/compiler/preprocessor/Tokenizer.cpp
index 40e910e22..eb6156f47 100755
--- a/gfx/angle/src/compiler/preprocessor/Tokenizer.cpp
+++ b/gfx/angle/src/compiler/preprocessor/Tokenizer.cpp
@@ -9,96 +9,20 @@
 
 
 
+#line 13 "./Tokenizer.cpp"
+
 #define  YY_INT_ALIGNED short int
 
 /* A lexical scanner generated by flex */
 
-
-
-
-
-
-
-
-
-
-
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 1
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 39
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-        
-        
-    
-    
-
-
-    
-    
-
-
-
-    
-    
-
-
-
-    
-    
-    
-
-
-
-
-
-
 /* First, we deal with  platform-specific or compiler-specific issues. */
 
 /* begin standard C headers. */
@@ -132,6 +56,7 @@ typedef int16_t flex_int16_t;
 typedef uint16_t flex_uint16_t;
 typedef int32_t flex_int32_t;
 typedef uint32_t flex_uint32_t;
+typedef uint64_t flex_uint64_t;
 #else
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
@@ -173,27 +98,30 @@ typedef unsigned int flex_uint32_t;
 
 #endif /* ! FLEXINT_H */
 
+#ifdef __cplusplus
 
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
 
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
+#else	/* ! __cplusplus */
 
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
 
-    
+#define YY_USE_CONST
 
+#endif	/* defined (__STDC__) */
+#endif	/* ! __cplusplus */
 
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
 
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
-
-
 /* Promotes a possibly negative, possibly signed char to an unsigned
  * integer for use as an array index.  If the signed char is negative,
  * we want to instead treat it as an 8-bit unsigned char, hence the
@@ -201,34 +129,12 @@ typedef unsigned int flex_uint32_t;
  */
 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 
-
-
-
-
 /* An opaque pointer. */
 #ifndef YY_TYPEDEF_YY_SCANNER_T
 #define YY_TYPEDEF_YY_SCANNER_T
 typedef void* yyscan_t;
 #endif
 
-
-
-
-
-
-
-
-
-    
-    
-
-
-
-
-
-
-
-
 /* For convenience, these vars (plus the bison vars far below)
    are macros in the reentrant scanner. */
 #define yyin yyg->yyin_r
@@ -240,29 +146,12 @@ typedef void* yyscan_t;
 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 #define yy_flex_debug yyg->yy_flex_debug_r
 
-
-
-
-
-
-
-
-
-    
-    
-    
-    
-
-
-
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
 #define BEGIN yyg->yy_start = 1 + 2 *
 
-
-
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
@@ -270,41 +159,23 @@ typedef void* yyscan_t;
 #define YY_START ((yyg->yy_start - 1) / 2)
 #define YYSTATE YY_START
 
-
-
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
-
-
 /* Special action meaning "start processing a new file". */
 #define YY_NEW_FILE pprestart(yyin ,yyscanner )
 
-
-
 #define YY_END_OF_BUFFER_CHAR 0
 
-
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
 #define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
 #endif
 
-
 /* The state buf must be large enough to hold one state per character in the main buffer.
  */
 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 
-
-
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 #define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
@@ -315,22 +186,18 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 typedef size_t yy_size_t;
 #endif
 
-
-
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-
-
-    
     #define YY_LESS_LINENO(n)
     #define YY_LINENO_REWIND_TO(ptr)
     
-
-
-
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
 	do \
@@ -345,31 +212,26 @@ typedef size_t yy_size_t;
 		} \
 	while ( 0 )
 
-
-
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 
-
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
 	{
 	FILE *yy_input_file;
 
-
-
 	char *yy_ch_buf;		/* input buffer */
 	char *yy_buf_pos;		/* current position in input buffer */
 
 	/* Size of input buffer in bytes, not including room for EOB
 	 * characters.
 	 */
-	int yy_buf_size;
+	yy_size_t yy_buf_size;
 
 	/* Number of characters read into yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	int yy_n_chars;
+	yy_size_t yy_n_chars;
 
 	/* Whether we "own" the buffer - i.e., we know we created it,
 	 * and can realloc() it to grow it, and should free() it to
@@ -393,7 +255,6 @@ struct yy_buffer_state
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
     
-
 	/* Whether to try to fill the input buffer when we reach the
 	 * end of it.
 	 */
@@ -418,10 +279,6 @@ struct yy_buffer_state
 	};
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-
-
-
-
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
@@ -432,18 +289,11 @@ struct yy_buffer_state
                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                           : NULL)
 
-
-
 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
  */
 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 
-
-
-
-
-
 void pprestart (FILE *input_file ,yyscan_t yyscanner );
 void pp_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 YY_BUFFER_STATE pp_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
@@ -452,30 +302,22 @@ void pp_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 void pppush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 void pppop_buffer_state (yyscan_t yyscanner );
 
-
 static void ppensure_buffer_stack (yyscan_t yyscanner );
 static void pp_load_buffer_state (yyscan_t yyscanner );
 static void pp_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 
-
-
 #define YY_FLUSH_BUFFER pp_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 
-
 YY_BUFFER_STATE pp_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 YY_BUFFER_STATE pp_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE pp_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
+YY_BUFFER_STATE pp_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
 
 void *ppalloc (yy_size_t ,yyscan_t yyscanner );
 void *pprealloc (void *,yy_size_t ,yyscan_t yyscanner );
 void ppfree (void * ,yyscan_t yyscanner );
 
-
 #define yy_new_buffer pp_create_buffer
 
-
-
 #define yy_set_interactive(is_interactive) \
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){ \
@@ -486,8 +328,6 @@ void ppfree (void * ,yyscan_t yyscanner );
 	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 	}
 
-
-
 #define yy_set_bol(at_bol) \
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){\
@@ -498,50 +338,34 @@ void ppfree (void * ,yyscan_t yyscanner );
 	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 	}
 
-
-
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
-
 /* Begin user sect3 */
 
-#define ppwrap(yyscanner) (/*CONSTCOND*/1)
+#define ppwrap(yyscanner) 1
 #define YY_SKIP_YYWRAP
 
 typedef unsigned char YY_CHAR;
 
-
-
-
 typedef int yy_state_type;
 
 #define yytext_ptr yytext_r
 
-
-
-
-
-
 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
 static int yy_get_next_buffer (yyscan_t yyscanner );
-static void yynoreturn yy_fatal_error (yyconst char* msg ,yyscan_t yyscanner );
-
-
-
+static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
 #define YY_DO_BEFORE_ACTION \
 	yyg->yytext_ptr = yy_bp; \
-	yyleng = (int) (yy_cp - yy_bp); \
+	yyleng = (yy_size_t) (yy_cp - yy_bp); \
 	yyg->yy_hold_char = *yy_cp; \
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-
-
 #define YY_NUM_RULES 38
 #define YY_END_OF_BUFFER 39
 /* This struct is not used in this scanner,
@@ -566,7 +390,7 @@ static yyconst flex_int16_t yy_accept[98] =
 
     } ;
 
-static yyconst YY_CHAR yy_ec[256] =
+static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
@@ -598,14 +422,14 @@ static yyconst YY_CHAR yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst YY_CHAR yy_meta[30] =
+static yyconst flex_int32_t yy_meta[30] =
     {   0,
         1,    1,    2,    2,    1,    1,    1,    1,    1,    3,
         1,    1,    4,    1,    5,    5,    5,    1,    1,    1,
         5,    5,    5,    5,    5,    5,    1,    1,    1
     } ;
 
-static yyconst flex_uint16_t yy_base[103] =
+static yyconst flex_int16_t yy_base[103] =
     {   0,
         0,    0,   27,   29,  137,  194,  133,  194,  117,  100,
       194,   98,   26,  194,   94,   24,   28,   33,   32,   39,
@@ -637,7 +461,7 @@ static yyconst flex_int16_t yy_def[103] =
        97,   97
     } ;
 
-static yyconst flex_uint16_t yy_nxt[224] =
+static yyconst flex_int16_t yy_nxt[224] =
     {   0,
         6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
        16,   17,   18,   19,   20,   21,   21,   22,   23,   24,
@@ -720,10 +544,10 @@ IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh.
 #pragma warning(disable: 4005)
 #endif
 
-#include "compiler/preprocessor/Tokenizer.h"
+#include "Tokenizer.h"
 
-#include "compiler/preprocessor/DiagnosticsBase.h"
-#include "compiler/preprocessor/Token.h"
+#include "DiagnosticsBase.h"
+#include "Token.h"
 
 #if defined(__GNUC__)
 // Triggered by the auto-generated yy_fatal_error function.
@@ -772,23 +596,11 @@ typedef pp::SourceLocation YYLTYPE;
 #define YY_INPUT(buf, result, maxSize) \
     result = yyextra->input.read(buf, maxSize, &yylineno);
 
-
-
-
-
 #define INITIAL 0
 #define COMMENT 1
 
-
-
-
-
-
 #define YY_EXTRA_TYPE pp::Tokenizer::Context*
 
-
-
-
 /* Holds the entire state of the reentrant scanner. */
 struct yyguts_t
     {
@@ -802,8 +614,8 @@ struct yyguts_t
     size_t yy_buffer_stack_max; /**< capacity of stack. */
     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
     char yy_hold_char;
-    int yy_n_chars;
-    int yyleng_r;
+    yy_size_t yy_n_chars;
+    yy_size_t yyleng_r;
     char *yy_c_buf_p;
     int yy_init;
     int yy_start;
@@ -817,132 +629,69 @@ struct yyguts_t
     int yylineno_r;
     int yy_flex_debug_r;
 
-
-
-
     char *yytext_r;
     int yy_more_flag;
     int yy_more_len;
 
-
-
     YYSTYPE * yylval_r;
 
-
-
     YYLTYPE * yylloc_r;
 
-
     }; /* end struct yyguts_t */
 
-
-
-
 static int yy_init_globals (yyscan_t yyscanner );
 
-
-
-
-    
     /* This must go here because YYSTYPE and YYLTYPE are included
      * from bison output in section 1.*/
     #    define yylval yyg->yylval_r
     
-
-    
     #    define yylloc yyg->yylloc_r
     
-
-
 int pplex_init (yyscan_t* scanner);
 
 int pplex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
 
-
-
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 
-
 int pplex_destroy (yyscan_t yyscanner );
 
-
-
 int ppget_debug (yyscan_t yyscanner );
 
-
-
 void ppset_debug (int debug_flag ,yyscan_t yyscanner );
 
-
-
 YY_EXTRA_TYPE ppget_extra (yyscan_t yyscanner );
 
-
-
 void ppset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 
-
-
 FILE *ppget_in (yyscan_t yyscanner );
 
-
-
-void ppset_in  (FILE * _in_str ,yyscan_t yyscanner );
-
-
+void ppset_in  (FILE * in_str ,yyscan_t yyscanner );
 
 FILE *ppget_out (yyscan_t yyscanner );
 
+void ppset_out  (FILE * out_str ,yyscan_t yyscanner );
 
-
-void ppset_out  (FILE * _out_str ,yyscan_t yyscanner );
-
-
-
-			int ppget_leng (yyscan_t yyscanner );
-
-
+yy_size_t ppget_leng (yyscan_t yyscanner );
 
 char *ppget_text (yyscan_t yyscanner );
 
-
-
 int ppget_lineno (yyscan_t yyscanner );
 
-
-
-void ppset_lineno (int _line_number ,yyscan_t yyscanner );
-
-
-
+void ppset_lineno (int line_number ,yyscan_t yyscanner );
 
 int ppget_column  (yyscan_t yyscanner );
 
-
-
-
-
-void ppset_column (int _column_no ,yyscan_t yyscanner );
-
-
-
+void ppset_column (int column_no ,yyscan_t yyscanner );
 
 YYSTYPE * ppget_lval (yyscan_t yyscanner );
 
-
 void ppset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
 
-
-    
        YYLTYPE *ppget_lloc (yyscan_t yyscanner );
     
-
-    
         void ppset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
     
-
-
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
@@ -955,12 +704,6 @@ extern int ppwrap (yyscan_t yyscanner );
 #endif
 #endif
 
-
-#ifndef YY_NO_UNPUT
-    
-#endif
-
-
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 #endif
@@ -979,34 +722,19 @@ static int input (yyscan_t yyscanner );
 
 #endif
 
-
-
-
-
-
-
-
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
 #define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
 #endif
 
-
 /* Copy whatever the last rule matched to the standard output. */
 #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
-
-
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  * is returned in "result".
  */
@@ -1028,7 +756,7 @@ static int input (yyscan_t yyscanner );
 	else \
 		{ \
 		errno=0; \
-		while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 			{ \
 			if( errno != EINTR) \
 				{ \
@@ -1043,8 +771,6 @@ static int input (yyscan_t yyscanner );
 
 #endif
 
-
-
 /* No semi-colon after return; correct usage is to write "yyterminate();" -
  * we don't want an extra ';' after the "return" because that will cause
  * some compilers to complain about unreachable statements.
@@ -1053,48 +779,24 @@ static int input (yyscan_t yyscanner );
 #define yyterminate() return YY_NULL
 #endif
 
-
 /* Number of entries by which start-condition stack grows. */
 #ifndef YY_START_STACK_INCR
 #define YY_START_STACK_INCR 25
 #endif
 
-
 /* Report a fatal error. */
 #ifndef YY_FATAL_ERROR
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 #endif
 
-
-
-
-
 /* end tables serialization structures and prototypes */
 
-
-
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
 #define YY_DECL_IS_OURS 1
 
-
-
-
-
-
-        
-    
-    
-
-
-
-    
-    
-    
-
-
 extern int pplex \
                (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
 
@@ -1102,7 +804,6 @@ extern int pplex \
                (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
 #endif /* !YY_DECL */
 
-
 /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.
  */
@@ -1110,39 +811,27 @@ extern int pplex \
 #define YY_USER_ACTION
 #endif
 
-
-
 /* Code executed at the end of each rule. */
 #ifndef YY_BREAK
-#define YY_BREAK /*LINTED*/break;
+#define YY_BREAK break;
 #endif
 
-
-
 #define YY_RULE_SETUP \
 	YY_USER_ACTION
 
-
-
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
-	yy_state_type yy_current_state;
-	char *yy_cp, *yy_bp;
-	int yy_act;
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
-
-
-
     yylval = yylval_param;
 
-
-
     yylloc = yylloc_param;
 
-
 	if ( !yyg->yy_init )
 		{
 		yyg->yy_init = 1;
@@ -1151,8 +840,6 @@ YY_DECL
 		YY_USER_INIT;
 #endif
 
-
-
 		if ( ! yyg->yy_start )
 			yyg->yy_start = 1;	/* first start state */
 
@@ -1173,10 +860,9 @@ YY_DECL
 
 	{
 
-
     /* Line comment */
 
-	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
+	while ( 1 )		/* loops until end-of-file is reached */
 		{
 		yy_cp = yyg->yy_c_buf_p;
 
@@ -1192,7 +878,7 @@ YY_DECL
 yy_match:
 		do
 			{
-			YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
 			if ( yy_accept[yy_current_state] )
 				{
 				yyg->yy_last_accepting_state = yy_current_state;
@@ -1204,7 +890,7 @@ yy_match:
 				if ( yy_current_state >= 98 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
 		while ( yy_current_state != 97 );
@@ -1216,11 +902,8 @@ yy_find_action:
 
 		YY_DO_BEFORE_ACTION;
 
-
-
 do_action:	/* This label is used only to access EOF actions. */
 
-
 		switch ( yy_act )
 	{ /* beginning of action switch */
 			case 0: /* must back up */
@@ -1643,11 +1326,6 @@ ECHO;
 	} /* end of user's declarations */
 } /* end of pplex */
 
-
-
-
-
-
 /* yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
@@ -1658,9 +1336,9 @@ ECHO;
 static int yy_get_next_buffer (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	char *source = yyg->yytext_ptr;
-	yy_size_t number_to_move, i;
+	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	register char *source = yyg->yytext_ptr;
+	register int number_to_move, i;
 	int ret_val;
 
 	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
@@ -1689,7 +1367,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	/* Try to read more data. */
 
 	/* First move last chars to start of buffer. */
-	number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
+	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
 
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
@@ -1702,8 +1380,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 	else
 		{
-			int num_to_read =
-			static_cast<int>(YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1);
+			yy_size_t num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
@@ -1716,7 +1394,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 			if ( b->yy_is_our_buffer )
 				{
-				int new_size = b->yy_buf_size * 2;
+				yy_size_t new_size = b->yy_buf_size * 2;
 
 				if ( new_size <= 0 )
 					b->yy_buf_size += b->yy_buf_size / 8;
@@ -1729,7 +1407,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 				}
 			else
 				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = NULL;
+				b->yy_ch_buf = 0;
 
 			if ( ! b->yy_ch_buf )
 				YY_FATAL_ERROR(
@@ -1737,8 +1415,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-			num_to_read = static_cast<int>(YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1);
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
 
 			}
 
@@ -1746,10 +1424,8 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 			num_to_read = YY_READ_BUF_SIZE;
 
 		/* Read in more data. */
-		yy_size_t ret = 0;
 		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			ret, num_to_read );
-		yyg->yy_n_chars = static_cast<int>(ret);
+			yyg->yy_n_chars, num_to_read );
 
 		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
 		}
@@ -1773,7 +1449,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-	if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 		/* Extend the array by 50%, plus the number we really need. */
 		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
 		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
@@ -1781,7 +1457,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
 	}
 
-	yyg->yy_n_chars += static_cast<int>(number_to_move);
+	yyg->yy_n_chars += number_to_move;
 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
 	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 
@@ -1790,21 +1466,19 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	return ret_val;
 }
 
-
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
-
     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
 {
-	yy_state_type yy_current_state;
-	char *yy_cp;
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
 	yy_current_state = yyg->yy_start;
 
 	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
 		{
-		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 		if ( yy_accept[yy_current_state] )
 			{
 			yyg->yy_last_accepting_state = yy_current_state;
@@ -1816,13 +1490,12 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 			if ( yy_current_state >= 98 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 		}
 
 	return yy_current_state;
 }
 
-
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
@@ -1830,11 +1503,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
  */
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
 {
-	int yy_is_jam;
+	register int yy_is_jam;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	char *yy_cp = yyg->yy_c_buf_p;
+	register char *yy_cp = yyg->yy_c_buf_p;
 
-	YY_CHAR yy_c = 1;
+	register YY_CHAR yy_c = 1;
 	if ( yy_accept[yy_current_state] )
 		{
 		yyg->yy_last_accepting_state = yy_current_state;
@@ -1846,18 +1519,13 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		if ( yy_current_state >= 98 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 	yy_is_jam = (yy_current_state == 97);
 
 	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
 }
 
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
 #ifndef YY_NO_INPUT
 #ifdef __cplusplus
     static int yyinput (yyscan_t yyscanner)
@@ -1883,7 +1551,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
 		else
 			{ /* need more input */
-			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+			yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
 			++yyg->yy_c_buf_p;
 
 			switch ( yy_get_next_buffer( yyscanner ) )
@@ -1907,7 +1575,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 				case EOB_ACT_END_OF_FILE:
 					{
 					if ( ppwrap(yyscanner ) )
-						return 0;
+						return EOF;
 
 					if ( ! yyg->yy_did_buffer_switch_on_eof )
 						YY_NEW_FILE;
@@ -1929,7 +1597,6 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
 	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
 
-
 	return c;
 }
 #endif	/* ifndef YY_NO_INPUT */
@@ -1953,7 +1620,6 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	pp_load_buffer_state(yyscanner );
 }
 
-
 /** Switch to a different input buffer.
  * @param new_buffer The new input buffer.
  * @param yyscanner The scanner object.
@@ -1990,7 +1656,6 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	yyg->yy_did_buffer_switch_on_eof = 1;
 }
 
-
 static void pp_load_buffer_state  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
@@ -2014,7 +1679,7 @@ static void pp_load_buffer_state  (yyscan_t yyscanner)
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in pp_create_buffer()" );
 
-	b->yy_buf_size = (yy_size_t)size;
+	b->yy_buf_size = size;
 
 	/* yy_ch_buf has to be 2 characters longer than the size given because
 	 * we need to put in 2 end-of-buffer characters.
@@ -2030,7 +1695,6 @@ static void pp_load_buffer_state  (yyscan_t yyscanner)
 	return b;
 }
 
-
 /** Destroy the buffer.
  * @param b a buffer created with pp_create_buffer()
  * @param yyscanner The scanner object.
@@ -2051,7 +1715,6 @@ static void pp_load_buffer_state  (yyscan_t yyscanner)
 	ppfree((void *) b ,yyscanner );
 }
 
-
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
  * such as during a pprestart() or at EOF.
@@ -2076,11 +1739,8 @@ static void pp_load_buffer_state  (yyscan_t yyscanner)
         b->yy_bs_column = 0;
     }
 
-
-    
         b->yy_is_interactive = 0;
     
-
 	errno = oerrno;
 }
 
@@ -2145,7 +1805,6 @@ void pppush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
 	yyg->yy_did_buffer_switch_on_eof = 1;
 }
 
-
 /** Removes and deletes the top of the stack, if present.
  *  The next element becomes the new top.
  *  @param yyscanner The scanner object.
@@ -2167,7 +1826,6 @@ void pppop_buffer_state (yyscan_t yyscanner)
 	}
 }
 
-
 /* Allocates the stack if it does not exist.
  *  Guarantees space for at least one push.
  */
@@ -2182,14 +1840,13 @@ static void ppensure_buffer_stack (yyscan_t yyscanner)
 		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
 		 * immediate realloc on the next call.
          */
-      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+		num_to_alloc = 1;
 		yyg->yy_buffer_stack = (struct yy_buffer_state**)ppalloc
 								(num_to_alloc * sizeof(struct yy_buffer_state*)
 								, yyscanner);
 		if ( ! yyg->yy_buffer_stack )
 			YY_FATAL_ERROR( "out of dynamic memory in ppensure_buffer_stack()" );
 								  
-		
 		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
 				
 		yyg->yy_buffer_stack_max = num_to_alloc;
@@ -2200,7 +1857,7 @@ static void ppensure_buffer_stack (yyscan_t yyscanner)
 	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
 
 		/* Increase the buffer to prepare for a possible push. */
-		yy_size_t grow_size = 8 /* arbitrary grow size */;
+		int grow_size = 8 /* arbitrary grow size */;
 
 		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
 		yyg->yy_buffer_stack = (struct yy_buffer_state**)pprealloc
@@ -2216,10 +1873,6 @@ static void ppensure_buffer_stack (yyscan_t yyscanner)
 	}
 }
 
-
-
-
-
 /** Setup the input buffer state to scan directly from a user-specified character buffer.
  * @param base the character buffer
  * @param size the size in bytes of the character buffer
@@ -2234,16 +1887,16 @@ YY_BUFFER_STATE pp_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscann
 	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
 	     base[size-1] != YY_END_OF_BUFFER_CHAR )
 		/* They forgot to leave room for the EOB's. */
-		return NULL;
+		return 0;
 
 	b = (YY_BUFFER_STATE) ppalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in pp_scan_buffer()" );
 
-	b->yy_buf_size = static_cast<int>(size - 2);	/* "- 2" to take care of EOB's */
+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
 	b->yy_buf_pos = b->yy_ch_buf = base;
 	b->yy_is_our_buffer = 0;
-	b->yy_input_file = NULL;
+	b->yy_input_file = 0;
 	b->yy_n_chars = b->yy_buf_size;
 	b->yy_is_interactive = 0;
 	b->yy_at_bol = 1;
@@ -2255,9 +1908,6 @@ YY_BUFFER_STATE pp_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscann
 	return b;
 }
 
-
-
-
 /** Setup the input buffer state to scan a string. The next call to pplex() will
  * scan from a @e copy of @a str.
  * @param yystr a NUL-terminated string to scan
@@ -2269,12 +1919,9 @@ YY_BUFFER_STATE pp_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscann
 YY_BUFFER_STATE pp_scan_string (yyconst char * yystr , yyscan_t yyscanner)
 {
     
-	return pp_scan_bytes(yystr,(int) strlen(yystr) ,yyscanner);
+	return pp_scan_bytes(yystr,strlen(yystr) ,yyscanner);
 }
 
-
-
-
 /** Setup the input buffer state to scan the given bytes. The next call to pplex() will
  * scan from a @e copy of @a bytes.
  * @param yybytes the byte buffer to scan
@@ -2282,7 +1929,7 @@ YY_BUFFER_STATE pp_scan_string (yyconst char * yystr , yyscan_t yyscanner)
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE pp_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE pp_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
 	char *buf;
@@ -2290,12 +1937,12 @@ YY_BUFFER_STATE pp_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yysc
 	yy_size_t i;
     
 	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = (yy_size_t) _yybytes_len + 2;
+	n = _yybytes_len + 2;
 	buf = (char *) ppalloc(n ,yyscanner );
 	if ( ! buf )
 		YY_FATAL_ERROR( "out of dynamic memory in pp_scan_bytes()" );
 
-	for ( i = 0; i < static_cast<yy_size_t>(_yybytes_len); ++i )
+	for ( i = 0; i < _yybytes_len; ++i )
 		buf[i] = yybytes[i];
 
 	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
@@ -2312,25 +1959,13 @@ YY_BUFFER_STATE pp_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yysc
 	return b;
 }
 
-
-
-
-
-
-
-
-
-
-
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
 #endif
 
-static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
+static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
 {
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-	(void) fprintf( stderr, "%s\n", msg );
+    	(void) fprintf( stderr, "%s\n", msg );
 	exit( YY_EXIT_FAILURE );
 }
 
@@ -2351,11 +1986,8 @@ static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
 		} \
 	while ( 0 )
 
-
-
 /* Accessor  methods (get/set functions) to struct members. */
 
-
 /** Get the user-defined data for this scanner.
  * @param yyscanner The scanner object.
  */
@@ -2365,8 +1997,6 @@ YY_EXTRA_TYPE ppget_extra  (yyscan_t yyscanner)
     return yyextra;
 }
 
-
-
 /** Get the current line number.
  * @param yyscanner The scanner object.
  */
@@ -2374,16 +2004,12 @@ int ppget_lineno  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     
-    
         if (! YY_CURRENT_BUFFER)
             return 0;
     
     return yylineno;
 }
 
-
-
-
 /** Get the current column number.
  * @param yyscanner The scanner object.
  */
@@ -2391,16 +2017,12 @@ int ppget_column  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     
-    
         if (! YY_CURRENT_BUFFER)
             return 0;
     
     return yycolumn;
 }
 
-
-
-
 /** Get the input stream.
  * @param yyscanner The scanner object.
  */
@@ -2410,8 +2032,6 @@ FILE *ppget_in  (yyscan_t yyscanner)
     return yyin;
 }
 
-
-
 /** Get the output stream.
  * @param yyscanner The scanner object.
  */
@@ -2421,18 +2041,15 @@ FILE *ppget_out  (yyscan_t yyscanner)
     return yyout;
 }
 
-
-
 /** Get the length of the current token.
  * @param yyscanner The scanner object.
  */
-int ppget_leng  (yyscan_t yyscanner)
+yy_size_t ppget_leng  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yyleng;
 }
 
-
 /** Get the current token.
  * @param yyscanner The scanner object.
  */
@@ -2443,8 +2060,6 @@ char *ppget_text  (yyscan_t yyscanner)
     return yytext;
 }
 
-
-
 /** Set the user-defined data. This data is never touched by the scanner.
  * @param user_defined The data to be associated with this scanner.
  * @param yyscanner The scanner object.
@@ -2455,123 +2070,92 @@ void ppset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
     yyextra = user_defined ;
 }
 
-
-
 /** Set the current line number.
- * @param _line_number line number
+ * @param line_number
  * @param yyscanner The scanner object.
  */
-void ppset_lineno (int  _line_number , yyscan_t yyscanner)
+void ppset_lineno (int  line_number , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
-    
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            YY_FATAL_ERROR( "ppset_lineno called with no buffer" );
     
-    yylineno = _line_number;
+    yylineno = line_number;
 }
 
-
-
-
 /** Set the current column.
- * @param _column_no column number
+ * @param line_number
  * @param yyscanner The scanner object.
  */
-void ppset_column (int  _column_no , yyscan_t yyscanner)
+void ppset_column (int  column_no , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
-    
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            YY_FATAL_ERROR( "ppset_column called with no buffer" );
     
-    yycolumn = _column_no;
+    yycolumn = column_no;
 }
 
-
-
-
-
 /** Set the input stream. This does not discard the current
  * input buffer.
- * @param _in_str A readable stream.
+ * @param in_str A readable stream.
  * @param yyscanner The scanner object.
  * @see pp_switch_to_buffer
  */
-void ppset_in (FILE *  _in_str , yyscan_t yyscanner)
+void ppset_in (FILE *  in_str , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = _in_str ;
+    yyin = in_str ;
 }
 
-
-
-void ppset_out (FILE *  _out_str , yyscan_t yyscanner)
+void ppset_out (FILE *  out_str , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = _out_str ;
+    yyout = out_str ;
 }
 
-
-
-
 int ppget_debug  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yy_flex_debug;
 }
 
-
-
-void ppset_debug (int  _bdebug , yyscan_t yyscanner)
+void ppset_debug (int  bdebug , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = _bdebug ;
+    yy_flex_debug = bdebug ;
 }
 
-
 /* Accessor methods for yylval and yylloc */
 
-
 YYSTYPE * ppget_lval  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yylval;
 }
 
-
-
 void ppset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylval = yylval_param;
 }
 
-
-
-    
 YYLTYPE *ppget_lloc  (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yylloc;
 }
     
-
-    
 void ppset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylloc = yylloc_param;
 }
     
-
-
-
-
 /* User-visible API */
 
 /* pplex_init is special because it creates the scanner itself, so it is
@@ -2600,7 +2184,6 @@ int pplex_init(yyscan_t* ptr_yy_globals)
     return yy_init_globals ( *ptr_yy_globals );
 }
 
-
 /* pplex_init_extra has the same functionality as pplex_init, but follows the
  * convention of taking the scanner as the last argument. Note however, that
  * this is a *pointer* to a scanner, as it will be allocated by this call (and
@@ -2637,7 +2220,6 @@ int pplex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
     return yy_init_globals ( *ptr_yy_globals );
 }
 
-
 static int yy_init_globals (yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
@@ -2645,31 +2227,24 @@ static int yy_init_globals (yyscan_t yyscanner)
      * This function is called from pplex_destroy(), so don't allocate here.
      */
 
-
-    yyg->yy_buffer_stack = NULL;
+    yyg->yy_buffer_stack = 0;
     yyg->yy_buffer_stack_top = 0;
     yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = NULL;
+    yyg->yy_c_buf_p = (char *) 0;
     yyg->yy_init = 0;
     yyg->yy_start = 0;
 
-
     yyg->yy_start_stack_ptr = 0;
     yyg->yy_start_stack_depth = 0;
     yyg->yy_start_stack =  NULL;
 
-
-
-
-
-
 /* Defined in main.c */
 #ifdef YY_STDINIT
     yyin = stdin;
     yyout = stdout;
 #else
-    yyin = NULL;
-    yyout = NULL;
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
 #endif
 
     /* For future reference: Set errno on error, since we are called by
@@ -2678,7 +2253,6 @@ static int yy_init_globals (yyscan_t yyscanner)
     return 0;
 }
 
-
 /* pplex_destroy is for both reentrant and non-reentrant scanners. */
 int pplex_destroy  (yyscan_t yyscanner)
 {
@@ -2695,14 +2269,10 @@ int pplex_destroy  (yyscan_t yyscanner)
 	ppfree(yyg->yy_buffer_stack ,yyscanner);
 	yyg->yy_buffer_stack = NULL;
 
-
     /* Destroy the start condition stack. */
         ppfree(yyg->yy_start_stack ,yyscanner );
         yyg->yy_start_stack = NULL;
 
-
-
-
     /* Reset the globals. This is important in a non-reentrant scanner so the next time
      * pplex() is called, initialization will occur. */
     yy_init_globals( yyscanner);
@@ -2713,32 +2283,23 @@ int pplex_destroy  (yyscan_t yyscanner)
     return 0;
 }
 
-
-
 /*
  * Internal utility routines.
  */
 
-
-
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
 {
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-
-	int i;
+	register int i;
 	for ( i = 0; i < n; ++i )
 		s1[i] = s2[i];
 }
 #endif
 
-
-
 #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
 {
-	int n;
+	register int n;
 	for ( n = 0; s[n]; ++n )
 		;
 
@@ -2746,22 +2307,13 @@ static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
 }
 #endif
 
-
-
 void *ppalloc (yy_size_t  size , yyscan_t yyscanner)
 {
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-	return malloc(size);
+	return (void *) malloc( size );
 }
 
-
-
 void *pprealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
 {
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
-
 	/* The cast to (char *) in the following accommodates both
 	 * implementations that use char* generic pointers, and those
 	 * that use void* generic pointers.  It works with the latter
@@ -2769,32 +2321,21 @@ void *pprealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
 	 * any pointer type to void*, and deal with argument conversions
 	 * as though doing an assignment.
 	 */
-	return realloc(ptr, size);
+	return (void *) realloc( (char *) ptr, size );
 }
 
-
-
 void ppfree (void * ptr , yyscan_t yyscanner)
 {
-	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	(void)yyg;
 	free( (char *) ptr );	/* see pprealloc() for (char *) cast */
 }
 
-
 #define YYTABLES_NAME "yytables"
 
-
-
-
-
-
-
-
-
 namespace pp {
 
-Tokenizer::Tokenizer(Diagnostics *diagnostics) : mHandle(nullptr), mMaxTokenSize(256)
+Tokenizer::Tokenizer(Diagnostics *diagnostics)
+    : mHandle(0),
+      mMaxTokenSize(256)
 {
     mContext.diagnostics = diagnostics;
 }
@@ -2851,7 +2392,7 @@ void Tokenizer::lex(Token *token)
 
 bool Tokenizer::initScanner()
 {
-    if ((mHandle == nullptr) && pplex_init_extra(&mContext, &mHandle))
+    if ((mHandle == NULL) && pplex_init_extra(&mContext,&mHandle))
         return false;
 
     pprestart(0,mHandle);
@@ -2860,13 +2401,12 @@ bool Tokenizer::initScanner()
 
 void Tokenizer::destroyScanner()
 {
-    if (mHandle == nullptr)
+    if (mHandle == NULL)
         return;
 
     pplex_destroy(mHandle);
-    mHandle = nullptr;
+    mHandle = NULL;
 }
 
 }  // namespace pp
 
-
diff --git a/gfx/angle/src/compiler/preprocessor/Tokenizer.h b/gfx/angle/src/compiler/preprocessor/Tokenizer.h
index 6dfb19c66..49e64fa20 100755
--- a/gfx/angle/src/compiler/preprocessor/Tokenizer.h
+++ b/gfx/angle/src/compiler/preprocessor/Tokenizer.h
@@ -7,9 +7,9 @@
 #ifndef COMPILER_PREPROCESSOR_TOKENIZER_H_
 #define COMPILER_PREPROCESSOR_TOKENIZER_H_
 
-#include "common/angleutils.h"
-#include "compiler/preprocessor/Input.h"
-#include "compiler/preprocessor/Lexer.h"
+#include "Input.h"
+#include "Lexer.h"
+#include "pp_utils.h"
 
 namespace pp
 {
@@ -45,6 +45,7 @@ class Tokenizer : public Lexer
     void lex(Token *token) override;
 
   private:
+    PP_DISALLOW_COPY_AND_ASSIGN(Tokenizer);
     bool initScanner();
     void destroyScanner();
 
diff --git a/gfx/angle/src/compiler/preprocessor/Tokenizer.l b/gfx/angle/src/compiler/preprocessor/Tokenizer.l
index 62eb4caa6..d316da88b 100755
--- a/gfx/angle/src/compiler/preprocessor/Tokenizer.l
+++ b/gfx/angle/src/compiler/preprocessor/Tokenizer.l
@@ -27,10 +27,10 @@ IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh.
 #pragma warning(disable: 4005)
 #endif
 
-#include "compiler/preprocessor/Tokenizer.h"
+#include "Tokenizer.h"
 
-#include "compiler/preprocessor/DiagnosticsBase.h"
-#include "compiler/preprocessor/Token.h"
+#include "DiagnosticsBase.h"
+#include "Token.h"
 
 #if defined(__GNUC__)
 // Triggered by the auto-generated yy_fatal_error function.
@@ -280,7 +280,9 @@ FRACTIONAL_CONSTANT  ({DIGIT}*"."{DIGIT}+)|({DIGIT}+".")
 
 namespace pp {
 
-Tokenizer::Tokenizer(Diagnostics *diagnostics) : mHandle(nullptr), mMaxTokenSize(256)
+Tokenizer::Tokenizer(Diagnostics *diagnostics)
+    : mHandle(0),
+      mMaxTokenSize(256)
 {
     mContext.diagnostics = diagnostics;
 }
@@ -337,7 +339,7 @@ void Tokenizer::lex(Token *token)
 
 bool Tokenizer::initScanner()
 {
-    if ((mHandle == nullptr) && yylex_init_extra(&mContext, &mHandle))
+    if ((mHandle == NULL) && yylex_init_extra(&mContext, &mHandle))
         return false;
 
     yyrestart(0, mHandle);
@@ -346,11 +348,11 @@ bool Tokenizer::initScanner()
 
 void Tokenizer::destroyScanner()
 {
-    if (mHandle == nullptr)
+    if (mHandle == NULL)
         return;
 
     yylex_destroy(mHandle);
-    mHandle = nullptr;
+    mHandle = NULL;
 }
 
 }  // namespace pp
diff --git a/gfx/angle/src/compiler/preprocessor/numeric_lex.h b/gfx/angle/src/compiler/preprocessor/numeric_lex.h
index 7cf976988..b32e42253 100755
--- a/gfx/angle/src/compiler/preprocessor/numeric_lex.h
+++ b/gfx/angle/src/compiler/preprocessor/numeric_lex.h
@@ -9,7 +9,6 @@
 #ifndef COMPILER_PREPROCESSOR_NUMERICLEX_H_
 #define COMPILER_PREPROCESSOR_NUMERICLEX_H_
 
-#include <cmath>
 #include <sstream>
 
 namespace pp {
@@ -64,7 +63,7 @@ bool numeric_lex_float(const std::string &str, FloatType *value)
     stream.imbue(std::locale::classic());
 
     stream >> (*value);
-    return !stream.fail() && std::isfinite(*value);
+    return !stream.fail();
 #endif
 }
 
diff --git a/gfx/angle/src/compiler/preprocessor/pp_utils.h b/gfx/angle/src/compiler/preprocessor/pp_utils.h
new file mode 100644
index 000000000..9fba9385c
--- /dev/null
+++ b/gfx/angle/src/compiler/preprocessor/pp_utils.h
@@ -0,0 +1,18 @@
+//
+// 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.
+//
+
+// pp_utils.h: Common preprocessor utilities
+
+#ifndef COMPILER_PREPROCESSOR_PPUTILS_H_
+#define COMPILER_PREPROCESSOR_PPUTILS_H_
+
+// A macro to disallow the copy constructor and operator= functions
+// This must be used in the private: declarations for a class.
+#define PP_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName &);               \
+  void operator=(const TypeName &)
+
+#endif // COMPILER_PREPROCESSOR_PPUTILS_H_