Various clean-ups after top-level lexical declarations are done.

src/contexts.cc

 // Copyright 2011 the V8 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.
 
 #include "src/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/debug.h"
 #include "src/scopeinfo.h"
 
 namespace v8 {
 namespace internal {
 
 
-Handle<GlobalContextTable> GlobalContextTable::Extend(
-    Handle<GlobalContextTable> table, Handle<Context> global_context) {
-  Handle<GlobalContextTable> result;
+Handle<ScriptContextTable> ScriptContextTable::Extend(
+    Handle<ScriptContextTable> table, Handle<Context> script_context) {
+  Handle<ScriptContextTable> result;
   int used = table->used();
   int length = table->length();
   CHECK(used >= 0 && length > 0 && used < length);
   if (used + 1 == length) {
     CHECK(length < Smi::kMaxValue / 2);
-    result = Handle<GlobalContextTable>::cast(
+    result = Handle<ScriptContextTable>::cast(
         FixedArray::CopySize(table, length * 2));
   } else {
     result = table;
   }
   result->set_used(used + 1);
 
-  DCHECK(global_context->IsGlobalContext());
-  result->set(used + 1, *global_context);
+  DCHECK(script_context->IsScriptContext());
+  result->set(used + 1, *script_context);
   return result;
 }
 
 
-bool GlobalContextTable::Lookup(Handle<GlobalContextTable> table,
+bool ScriptContextTable::Lookup(Handle<ScriptContextTable> table,
                                 Handle<String> name, LookupResult* result) {
   for (int i = 0; i < table->used(); i++) {
     Handle<Context> context = GetContext(table, i);
-    DCHECK(context->IsGlobalContext());
+    DCHECK(context->IsScriptContext());
     Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
     int slot_index = ScopeInfo::ContextSlotIndex(
         scope_info, name, &result->mode, &result->init_flag,
         &result->maybe_assigned_flag);
 
     if (slot_index >= 0) {
       result->context_index = i;
       result->slot_index = slot_index;
       return true;
     }
@@ skipping 16 matching lines @@
   GlobalObject* object = global_object();
   if (object->IsJSGlobalObject()) {
     return JSGlobalObject::cast(object)->builtins();
   } else {
     DCHECK(object->IsJSBuiltinsObject());
     return JSBuiltinsObject::cast(object);
   }
 }
 
 
-Context* Context::global_context() {
+Context* Context::script_context() {
   Context* current = this;
-  while (!current->IsGlobalContext()) {
+  while (!current->IsScriptContext()) {
     current = current->previous();
   }
   return current;
 }
 
 
 Context* Context::native_context() {
   // Fast case: the global object for this context has been set.  In
   // that case, the global object has a direct pointer to the global
   // context.
@@ skipping 117 matching lines @@
 
   if (FLAG_trace_contexts) {
     PrintF("Context::Lookup(");
     name->ShortPrint();
     PrintF(")\n");
   }
 
   do {
     if (FLAG_trace_contexts) {
       PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
-      if (context->IsGlobalContext()) PrintF(" (global context)");
+      if (context->IsScriptContext()) PrintF(" (script context)");
       if (context->IsNativeContext()) PrintF(" (native context)");
       PrintF("\n");
     }
 
 
     // 1. Check global objects, subjects of with, and extension objects.
     if (context->IsNativeContext() ||
         context->IsWithContext() ||
         (context->IsFunctionContext() && context->has_extension())) {
       Handle<JSReceiver> object(
           JSReceiver::cast(context->extension()), isolate);
 
       if (context->IsNativeContext()) {
         if (FLAG_trace_contexts) {
-          PrintF(" - trying other global contexts\n");
+          PrintF(" - trying other script contexts\n");
         }
-        // Try other global contexts.
-        Handle<GlobalContextTable> global_contexts(
-            context->global_object()->native_context()->global_context_table());
-        GlobalContextTable::LookupResult r;
-        if (GlobalContextTable::Lookup(global_contexts, name, &r)) {
+        // Try other script contexts.
+        Handle<ScriptContextTable> script_contexts(
+            context->global_object()->native_context()->script_context_table());
+        ScriptContextTable::LookupResult r;
+        if (ScriptContextTable::Lookup(script_contexts, name, &r)) {
           if (FLAG_trace_contexts) {
-            Handle<Context> c = GlobalContextTable::GetContext(global_contexts,
+            Handle<Context> c = ScriptContextTable::GetContext(script_contexts,
                                                                r.context_index);
-            PrintF("=> found property in global context %d: %p\n",
+            PrintF("=> found property in script context %d: %p\n",
                    r.context_index, reinterpret_cast<void*>(*c));
           }
           *index = r.slot_index;
           GetAttributesAndBindingFlags(r.mode, r.init_flag, attributes,
                                        binding_flags);
-          return GlobalContextTable::GetContext(global_contexts,
+          return ScriptContextTable::GetContext(script_contexts,
                                                 r.context_index);
         }
       }
 
       // Context extension objects needs to behave as if they have no
       // prototype.  So even if we want to follow prototype chains, we need
       // to only do a local lookup for context extension objects.
       Maybe<PropertyAttributes> maybe;
       if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
           object->IsJSContextExtensionObject()) {
@@ skipping 13 matching lines @@
         if (FLAG_trace_contexts) {
           PrintF("=> found property in context object %p\n",
                  reinterpret_cast<void*>(*object));
         }
         return object;
       }
     }
 
     // 2. Check the context proper if it has slots.
     if (context->IsFunctionContext() || context->IsBlockContext() ||
-        (FLAG_harmony_scoping && context->IsGlobalContext())) {
+        (FLAG_harmony_scoping && context->IsScriptContext())) {
       // Use serialized scope information of functions and blocks to search
       // for the context index.
       Handle<ScopeInfo> scope_info;
       if (context->IsFunctionContext()) {
         scope_info = Handle<ScopeInfo>(
             context->closure()->shared()->scope_info(), isolate);
       } else {
         scope_info = Handle<ScopeInfo>(
             ScopeInfo::cast(context->extension()), isolate);
       }
@@ skipping 180 matching lines @@
 
 
 #ifdef DEBUG
 bool Context::IsBootstrappingOrValidParentContext(
     Object* object, Context* child) {
   // During bootstrapping we allow all objects to pass as
   // contexts. This is necessary to fix circular dependencies.
   if (child->GetIsolate()->bootstrapper()->IsActive()) return true;
   if (!object->IsContext()) return false;
   Context* context = Context::cast(object);
-  return context->IsNativeContext() || context->IsGlobalContext() ||
+  return context->IsNativeContext() || context->IsScriptContext() ||
          context->IsModuleContext() || !child->IsModuleContext();
 }
 
 
 bool Context::IsBootstrappingOrGlobalObject(Isolate* isolate, Object* object) {
   // During bootstrapping we allow all objects to pass as global
   // objects. This is necessary to fix circular dependencies.
   return isolate->heap()->gc_state() != Heap::NOT_IN_GC ||
       isolate->bootstrapper()->IsActive() ||
       object->IsGlobalObject();
 }
 #endif
 
 } }  // namespace v8::internal