Refactor the enum RelocMode changing the naming scheme from lower case to...

src/parser.cc

 // Copyright 2006-2008 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 793 matching lines @@
   {
     // Parse the function literal.
     Handle<String> no_name = factory()->EmptySymbol();
     Scope* scope =
         factory()->NewScope(top_scope_, Scope::GLOBAL_SCOPE, inside_with());
     LexicalScope lexical_scope(this, scope);
     TemporaryScope temp_scope(this);
 
     FunctionLiteralType type = is_expression ? EXPRESSION : DECLARATION;
     bool ok = true;
-    result = ParseFunctionLiteral(name, kNoPosition, type, &ok);
+    result = ParseFunctionLiteral(name, RelocInfo::kNoPosition, type, &ok);
     // Make sure the results agree.
     ASSERT(ok == (result != NULL));
     // The only errors should be stack overflows.
     ASSERT(ok || scanner_.stack_overflow());
   }
 
   // Make sure the target stack is empty.
   ASSERT(target_stack_ == NULL);
 
   // If there was a stack overflow we have to get rid of AST and it is
@@ skipping 316 matching lines @@
   int parameters = fun->shared()->formal_parameter_count();
   boilerplate->shared()->set_formal_parameter_count(parameters);
 
   // TODO(1240846): It's weird that native function declarations are
   // introduced dynamically when we meet their declarations, whereas
   // other functions are setup when entering the surrounding scope.
   FunctionBoilerplateLiteral* lit =
       NEW(FunctionBoilerplateLiteral(boilerplate));
   VariableProxy* var = Declare(name, Variable::VAR, NULL, true, CHECK_OK);
   return NEW(ExpressionStatement(
-                 new Assignment(Token::INIT_VAR, var, lit, kNoPosition)));
+      new Assignment(Token::INIT_VAR, var, lit, RelocInfo::kNoPosition)));
 }
 
 
 Statement* Parser::ParseFunctionDeclaration(bool* ok) {
   // Parse a function literal. We may or may not have a function name.
   // If we have a name we use it as the variable name for the function
   // (a function declaration) and not as the function name of a function
   // expression.
 
   Expect(Token::FUNCTION, CHECK_OK);
@@ skipping 1520 matching lines @@
         // 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.
           if (peek() == Token::IDENTIFIER) {
             Handle<String> name = ParseIdentifier(CHECK_OK);
             FunctionLiteral* value =
-                ParseFunctionLiteral(name, kNoPosition, DECLARATION, CHECK_OK);
+                ParseFunctionLiteral(name, RelocInfo::kNoPosition,
+                                     DECLARATION, CHECK_OK);
             ObjectLiteral::Property* property =
                 NEW(ObjectLiteral::Property(is_getter, value));
             if (IsBoilerplateProperty(property))
               number_of_boilerplate_properties++;
             properties.Add(property);
             if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);
             continue;  // restart the while
           }
         }
         key = NEW(Literal(id));
@@ skipping 175 matching lines @@
     // NOTE: We create a proxy and resolve it here so that in the
     // future we can change the AST to only refer to VariableProxies
     // instead of Variables and Proxis as is the case now.
     if (!function_name.is_null() && function_name->length() > 0) {
       Variable* fvar = top_scope_->DeclareFunctionVar(function_name);
       VariableProxy* fproxy =
           top_scope_->NewUnresolved(function_name, inside_with());
       fproxy->BindTo(fvar);
       body.Add(new ExpressionStatement(
                    new Assignment(Token::INIT_VAR, fproxy,
-                                  NEW(ThisFunction()), kNoPosition)));
+                                  NEW(ThisFunction()),
+                                  RelocInfo::kNoPosition)));
     }
 
     // Determine if the function will be lazily compiled. The mode can
     // only be PARSE_LAZILY if the --lazy flag is true.
     bool is_lazily_compiled =
         mode() == PARSE_LAZILY && top_scope_->HasTrivialOuterContext();
 
     int materialized_literal_count;
     int expected_property_count;
     bool contains_array_literal;
@@ skipping 356 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal