Created collector class and used it to collect identifiers during scanning.

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 3346 matching lines @@
         result = VariableProxySentinel::identifier_proxy();
       } else {
         result = top_scope_->NewUnresolved(name, inside_with());
       }
       break;
     }
 
     case Token::NUMBER: {
       Consume(Token::NUMBER);
       double value =
-        StringToDouble(scanner_.literal_string(), ALLOW_HEX | ALLOW_OCTALS);
+        StringToDouble(scanner_.literal(), ALLOW_HEX | ALLOW_OCTALS);
       result = NewNumberLiteral(value);
       break;
     }
 
     case Token::STRING: {
       Consume(Token::STRING);
       Handle<String> symbol =
           factory()->LookupSymbol(scanner_.literal_string(),
                                   scanner_.literal_length());
       result = NEW(Literal(symbol));
@@ skipping 337 matching lines @@
         if (!string.is_null() && string->AsArrayIndex(&index)) {
           key = NewNumberLiteral(index);
           break;
         }
         key = NEW(Literal(string));
         break;
       }
       case Token::NUMBER: {
         Consume(Token::NUMBER);
         double value =
-          StringToDouble(scanner_.literal_string(), ALLOW_HEX | ALLOW_OCTALS);
+          StringToDouble(scanner_.literal(), ALLOW_HEX | ALLOW_OCTALS);
         key = NewNumberLiteral(value);
         break;
       }
       default:
         if (Token::IsKeyword(next)) {
           Consume(next);
           Handle<String> string =
               factory()->LookupSymbol(scanner_.literal_string(),
                                       scanner_.literal_length());
           key = NEW(Literal(string));
@@ skipping 240 matching lines @@
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   Expect(Token::MOD, CHECK_OK);
   Handle<String> name = ParseIdentifier(CHECK_OK);
   Runtime::Function* function =
-      Runtime::FunctionForName(scanner_.literal_string());
+      Runtime::FunctionForName(scanner_.literal());
   ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
   if (function == NULL && extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
     top_scope_->ForceEagerCompilation();
   }
 
   // Check for built-in macros.
   if (!is_pre_parsing_) {
     if (function == Runtime::FunctionForId(Runtime::kIS_VAR)) {
@@ skipping 266 matching lines @@
       const char* literal_string = scanner_.literal_string();
       if (literal_length == 0) {
         return NEW(Literal(Factory::empty_string()));
       }
       Vector<const char> literal(literal_string, literal_length);
       return NEW(Literal(Factory::NewStringFromUtf8(literal, TENURED)));
     }
     case Token::NUMBER: {
       Consume(Token::NUMBER);
       ASSERT(scanner_.literal_length() > 0);
-      double value = StringToDouble(scanner_.literal_string(),
+      double value = StringToDouble(scanner_.literal(),
                                     NO_FLAGS,  // Hex, octal or trailing junk.
                                     OS::nan_value());
       return NewNumberLiteral(value);
     }
     case Token::FALSE_LITERAL:
       Consume(Token::FALSE_LITERAL);
       return NEW(Literal(Factory::false_value()));
     case Token::TRUE_LITERAL:
       Consume(Token::TRUE_LITERAL);
       return NEW(Literal(Factory::true_value()));
@@ skipping 1022 matching lines @@
       parser.ParseLazy(script_source, name,
                        start_position, end_position, is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal