Simplify preparsing of "new"-expressions.

src/preparser.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 168 matching lines @@
 
   Expression ParseExpression(bool accept_IN, bool* ok);
   Expression ParseAssignmentExpression(bool accept_IN, bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
   Expression ParseUnaryExpression(bool* ok);
   Expression ParsePostfixExpression(bool* ok);
   Expression ParseLeftHandSideExpression(bool* ok);
   Expression ParseNewExpression(bool* ok);
   Expression ParseMemberExpression(bool* ok);
-  Expression ParseNewPrefix(int* new_count, bool* ok);
-  Expression ParseMemberWithNewPrefixesExpression(int* new_count, bool* ok);
+  Expression ParseMemberWithNewPrefixesExpression(unsigned new_count, bool* ok);
   Expression ParsePrimaryExpression(bool* ok);
   Expression ParseArrayLiteral(bool* ok);
   Expression ParseObjectLiteral(bool* ok);
   Expression ParseRegExpLiteral(bool seen_equal, bool* ok);
   Expression ParseV8Intrinsic(bool* ok);
 
   Arguments ParseArguments(bool* ok);
   Expression ParseFunctionLiteral(bool* ok);
 
   Identifier ParseIdentifier(bool* ok);
@@ skipping 757 matching lines @@
         break;
       }
 
       default:
         return result;
     }
   }
 }
 
 
-
 template <typename Scanner, typename Log>
-Expression PreParser<Scanner, Log>::ParseNewPrefix(int* new_count, bool* ok) {
+Expression PreParser<Scanner, Log>::ParseNewExpression(bool* ok) {
   // NewExpression ::
   //   ('new')+ MemberExpression
 
   // The grammar for new expressions is pretty warped. The keyword
   // 'new' can either be a part of the new expression (where it isn't
   // followed by an argument list) or a part of the member expression,
   // where it must be followed by an argument list. To accommodate
   // this, we parse the 'new' keywords greedily and keep track of how
   // many we have parsed. This information is then passed on to the
   // member expression parser, which is only allowed to match argument
   // lists as long as it has 'new' prefixes left
-  Expect(Token::NEW, CHECK_OK);
-  *new_count++;
+  unsigned new_count = 0;
+  do {
+    Consume(Token::NEW);
+    new_count++;
+  } while (peek() == Token::NEW);
 
-  if (peek() == Token::NEW) {
-    ParseNewPrefix(new_count, CHECK_OK);
-  } else {
-    ParseMemberWithNewPrefixesExpression(new_count, CHECK_OK);
-  }
-
-  if (*new_count > 0) {
-    *new_count--;
-  }
-  return kUnknownExpression;
-}
-
-
-template <typename Scanner, typename Log>
-Expression PreParser<Scanner, Log>::ParseNewExpression(bool* ok) {
-  int new_count = 0;
-  return ParseNewPrefix(&new_count, ok);
+  return ParseMemberWithNewPrefixesExpression(new_count, ok);
 }
 
 
 template <typename Scanner, typename Log>
 Expression PreParser<Scanner, Log>::ParseMemberExpression(bool* ok) {
-  return ParseMemberWithNewPrefixesExpression(NULL, ok);
+  return ParseMemberWithNewPrefixesExpression(0, ok);
 }
 
 
 template <typename Scanner, typename Log>
 Expression PreParser<Scanner, Log>::ParseMemberWithNewPrefixesExpression(
-    int* new_count, bool* ok) {
+    unsigned new_count, bool* ok) {
   // MemberExpression ::
   //   (PrimaryExpression | FunctionLiteral)
   //     ('[' Expression ']' | '.' Identifier | Arguments)*
 
   // Parse the initial primary or function expression.
   Expression result = NULL;
   if (peek() == Token::FUNCTION) {
     Consume(Token::FUNCTION);
     if (peek() == Token::IDENTIFIER) {
       ParseIdentifier(CHECK_OK);
@@ skipping 20 matching lines @@
         Consume(Token::PERIOD);
         ParseIdentifierName(CHECK_OK);
         if (result == kThisExpression) {
           result = kThisPropertyExpression;
         } else {
           result = kUnknownExpression;
         }
         break;
       }
       case Token::LPAREN: {
-        if ((new_count == NULL) || *new_count == 0) return result;
+        if (new_count == 0) return result;
         // Consume one of the new prefixes (already parsed).
         ParseArguments(CHECK_OK);
-        *new_count--;
+        new_count--;
         result = kUnknownExpression;
         break;
       }
       default:
         return result;
     }
   }
 }
 
 
@@ skipping 351 matching lines @@
     *is_get = strncmp(token, "get", 3) == 0;
     *is_set = !*is_get && strncmp(token, "set", 3) == 0;
   }
   return GetIdentifierSymbol();
 }
 
 #undef CHECK_OK
 } } }  // v8::internal::preparser
 
 #endif  // V8_PREPARSER_H