Version 2.3.6

src/parser.cc

 // 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 192 matching lines @@
   Expression* ParsePostfixExpression(bool* ok);
   Expression* ParseLeftHandSideExpression(bool* ok);
   Expression* ParseNewExpression(bool* ok);
   Expression* ParseMemberExpression(bool* ok);
   Expression* ParseNewPrefix(PositionStack* stack, bool* ok);
   Expression* ParseMemberWithNewPrefixesExpression(PositionStack* stack,
                                                    bool* ok);
   Expression* ParsePrimaryExpression(bool* ok);
   Expression* ParseArrayLiteral(bool* ok);
   Expression* ParseObjectLiteral(bool* ok);
+  ObjectLiteral::Property* ParseObjectLiteralGetSet(bool is_getter, bool* ok);
   Expression* ParseRegExpLiteral(bool seen_equal, bool* ok);
 
   // Populate the constant properties fixed array for a materialized object
   // literal.
   void BuildObjectLiteralConstantProperties(
       ZoneList<ObjectLiteral::Property*>* properties,
       Handle<FixedArray> constants,
       bool* is_simple,
       bool* fast_elements,
       int* depth);
@@ skipping 3146 matching lines @@
 
     case Token::MOD:
       if (allow_natives_syntax_ || extension_ != NULL) {
         result = ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
     default: {
-      Token::Value tok = peek();
-      // Token::Peek returns the value of the next token but
-      // location() gives info about the current token.
-      // Therefore, we need to read ahead to the next token
-      Next();
+      Token::Value tok = Next();
       ReportUnexpectedToken(tok);
       *ok = false;
       return NULL;
     }
   }
 
   return result;
 }
 
 
@@ skipping 183 matching lines @@
     constant_properties->set(position++, *key);
     constant_properties->set(position++, *value);
   }
   *fast_elements =
       (max_element_index <= 32) || ((2 * elements) >= max_element_index);
   *is_simple = is_simple_acc;
   *depth = depth_acc;
 }
 
 
+ObjectLiteral::Property* Parser::ParseObjectLiteralGetSet(bool is_getter,
+                                                          bool* ok) {
+  // Special handling of getter and setter syntax:
+  // { ... , get foo() { ... }, ... , set foo(v) { ... v ... } , ... }
+  // We have already read the "get" or "set" keyword.
+  Token::Value next = Next();
+  if (next == Token::IDENTIFIER ||
+      next == Token::STRING ||
+      next == Token::NUMBER ||
+      Token::IsKeyword(next)) {
+    Handle<String> name =
+        factory()->LookupSymbol(scanner_.literal_string(),
+                                scanner_.literal_length());
+    FunctionLiteral* value =
+        ParseFunctionLiteral(name,
+                             RelocInfo::kNoPosition,
+                             DECLARATION,
+                             CHECK_OK);
+    ObjectLiteral::Property* property =
+        NEW(ObjectLiteral::Property(is_getter, value));
+    return property;
+  } else {
+    ReportUnexpectedToken(next);
+    *ok = false;
+    return NULL;
+  }
+}
+
+
 Expression* Parser::ParseObjectLiteral(bool* ok) {
   // ObjectLiteral ::
   //   '{' (
   //       ((IdentifierName | String | Number) ':' AssignmentExpression)
   //     | (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)
   //    )*[','] '}'
 
   ZoneListWrapper<ObjectLiteral::Property> properties =
       factory()->NewList<ObjectLiteral::Property>(4);
   int number_of_boilerplate_properties = 0;
 
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     Literal* key = NULL;
     Token::Value next = peek();
     switch (next) {
       case Token::IDENTIFIER: {
-        // Store identifier keys as literal symbols to avoid
-        // resolving them when compiling code for the object
-        // literal.
         bool is_getter = false;
         bool is_setter = false;
         Handle<String> id =
             ParseIdentifierOrGetOrSet(&is_getter, &is_setter, CHECK_OK);
-        if (is_getter || is_setter) {
-          // Special handling of getter and setter syntax.
-          Handle<String> name;
-          next = peek();
-          if (next == Token::IDENTIFIER ||
-              next == Token::STRING ||
-              next == Token::NUMBER ||
-              Token::IsKeyword(next)) {
-            Consume(next);
-            Handle<String> name =
-                factory()->LookupSymbol(scanner_.literal_string(),
-                                        scanner_.literal_length());
-            FunctionLiteral* value =
-                ParseFunctionLiteral(name,
-                                     RelocInfo::kNoPosition,
-                                     DECLARATION,
-                                     CHECK_OK);
+        if ((is_getter || is_setter) && peek() != Token::COLON) {
             ObjectLiteral::Property* property =
-                NEW(ObjectLiteral::Property(is_getter, value));
+                ParseObjectLiteralGetSet(is_getter, CHECK_OK);
             if (IsBoilerplateProperty(property)) {
               number_of_boilerplate_properties++;
             }
             properties.Add(property);
             if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);
             continue;  // restart the while
-          }
         }
+        // Failed to parse as get/set property, so it's just a property
+        // called "get" or "set".
         key = NEW(Literal(id));
         break;
       }
-#define CASE_KEYWORD(name, ignore1, ignore2) \
-      case Token::name:
-      TOKEN_LIST(IGNORE_TOKEN, CASE_KEYWORD, IGNORE_TOKEN)
-#undef CASE_KEYWORD
-      // FALLTHROUGH - keyword tokens fall through to the same code as strings.
       case Token::STRING: {
-        Consume(next);
+        Consume(Token::STRING);
         Handle<String> string =
             factory()->LookupSymbol(scanner_.literal_string(),
                                     scanner_.literal_length());
         uint32_t index;
-        if (next == Token::STRING &&
-            !string.is_null() &&
+        if (!string.is_null() &&
             string->AsArrayIndex(&index)) {
           key = NewNumberLiteral(index);
-        } else {
-          key = NEW(Literal(string));
+          break;
         }
+        key = NEW(Literal(string));
         break;
       }
-
       case Token::NUMBER: {
         Consume(Token::NUMBER);
         double value =
           StringToDouble(scanner_.literal_string(), ALLOW_HEX | ALLOW_OCTALS);
         key = NewNumberLiteral(value);
         break;
       }
-
       default:
-        Expect(Token::RBRACE, CHECK_OK);
-        break;
+        if (Token::IsKeyword(next)) {
+          Consume(next);
+          Handle<String> string =
+              factory()->LookupSymbol(scanner_.literal_string(),
+                                      scanner_.literal_length());
+          key = NEW(Literal(string));
+        } else {
+          // Unexpected token.
+          Token::Value next = Next();
+          ReportUnexpectedToken(next);
+          *ok = false;
+          return NULL;
+        }
     }
 
     Expect(Token::COLON, CHECK_OK);
     Expression* value = ParseAssignmentExpression(true, CHECK_OK);
 
     ObjectLiteral::Property* property =
         NEW(ObjectLiteral::Property(key, value));
 
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
     if (IsBoilerplateProperty(property)) number_of_boilerplate_properties++;
@@ skipping 1547 matching lines @@
       parser.ParseLazy(script_source, name,
                        start_position, end_position, is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal