v8::internal::ScopeIterator Class Reference

Collaboration diagram for v8::internal::ScopeIterator:

Public Types
enum	ScopeType {   ScopeTypeGlobal = 0 , ScopeTypeLocal , ScopeTypeWith , ScopeTypeClosure ,   ScopeTypeCatch , ScopeTypeBlock , ScopeTypeModule }

Public Member Functions
	ScopeIterator (Isolate *isolate, JavaScriptFrame *frame, int inlined_jsframe_index, bool ignore_nested_scopes=false)
	ScopeIterator (Isolate *isolate, Handle< JSFunction > function)
bool	Done ()
bool	Failed ()
void	Next ()
ScopeType	Type ()
MaybeHandle< JSObject >	ScopeObject ()
bool	SetVariableValue (Handle< String > variable_name, Handle< Object > new_value)
Handle< ScopeInfo >	CurrentScopeInfo ()
Handle< Context >	CurrentContext ()

Private Member Functions
void	RetrieveScopeChain (Scope *scope, Handle< SharedFunctionInfo > shared_info)
	DISALLOW_IMPLICIT_CONSTRUCTORS (ScopeIterator)

Private Attributes
Isolate *	isolate_
JavaScriptFrame *	frame_
int	inlined_jsframe_index_
Handle< JSFunction >	function_
Handle< Context >	context_
List< Handle< ScopeInfo > >	nested_scope_chain_
bool	failed_

Detailed Description

Definition at line 6482 of file runtime.cc.

Member Enumeration Documentation

ScopeType

enum v8::internal::ScopeIterator::ScopeType

Enumerator
ScopeTypeGlobal
ScopeTypeLocal
ScopeTypeWith
ScopeTypeClosure
ScopeTypeCatch
ScopeTypeBlock
ScopeTypeModule

Definition at line 6484 of file runtime.cc.

                 {
    ScopeTypeGlobal = 0,
    ScopeTypeLocal,
    ScopeTypeWith,
    ScopeTypeClosure,
    ScopeTypeCatch,
    ScopeTypeBlock,
    ScopeTypeModule
  };

Constructor & Destructor Documentation

ScopeIterator() [1/2]

v8::internal::ScopeIterator::ScopeIterator ( Isolate *  isolate, JavaScriptFrame *  frame, int  inlined_jsframe_index, bool  ignore_nested_scopes = false  )

inline

Definition at line 6494 of file runtime.cc.

      : isolate_(isolate),
        frame_(frame),
        inlined_jsframe_index_(inlined_jsframe_index),
        function_(frame->function()),
        context_(Context::cast(frame->context())),
        nested_scope_chain_(4),
        failed_(false) {
    // Catch the case when the debugger stops in an internal function.
    Handle<SharedFunctionInfo> shared_info(function_->shared());
    Handle<ScopeInfo> scope_info(shared_info->scope_info());
    if (shared_info->script() == isolate->heap()->undefined_value()) {
      while (context_->closure() == *function_) {
        context_ = Handle<Context>(context_->previous(), isolate_);
      }
      return;
    }
 
    // Get the debug info (create it if it does not exist).
    if (!isolate->debug()->EnsureDebugInfo(shared_info, function_)) {
      // Return if ensuring debug info failed.
      return;
    }
 
    // Currently it takes too much time to find nested scopes due to script
    // parsing. Sometimes we want to run the ScopeIterator as fast as possible
    // (for example, while collecting async call stacks on every
    // addEventListener call), even if we drop some nested scopes.
    // Later we may optimize getting the nested scopes (cache the result?)
    // and include nested scopes into the "fast" iteration case as well.
    if (!ignore_nested_scopes) {
      Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared_info);
 
      // Find the break point where execution has stopped.
      BreakLocationIterator break_location_iterator(debug_info,
                                                    ALL_BREAK_LOCATIONS);
      // pc points to the instruction after the current one, possibly a break
      // location as well. So the "- 1" to exclude it from the search.
      break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
 
      // Within the return sequence at the moment it is not possible to
      // get a source position which is consistent with the current scope chain.
      // Thus all nested with, catch and block contexts are skipped and we only
      // provide the function scope.
      ignore_nested_scopes = break_location_iterator.IsExit();
    }
 
    if (ignore_nested_scopes) {
      if (scope_info->HasContext()) {
        context_ = Handle<Context>(context_->declaration_context(), isolate_);
      } else {
        while (context_->closure() == *function_) {
          context_ = Handle<Context>(context_->previous(), isolate_);
        }
      }
      if (scope_info->scope_type() == FUNCTION_SCOPE) {
        nested_scope_chain_.Add(scope_info);
      }
    } else {
      // Reparse the code and analyze the scopes.
      Handle<Script> script(Script::cast(shared_info->script()));
      Scope* scope = NULL;
 
      // Check whether we are in global, eval or function code.
      Handle<ScopeInfo> scope_info(shared_info->scope_info());
      if (scope_info->scope_type() != FUNCTION_SCOPE) {
        // Global or eval code.
        CompilationInfoWithZone info(script);
        if (scope_info->scope_type() == GLOBAL_SCOPE) {
          info.MarkAsGlobal();
        } else {
          DCHECK(scope_info->scope_type() == EVAL_SCOPE);
          info.MarkAsEval();
          info.SetContext(Handle<Context>(function_->context()));
        }
        if (Parser::Parse(&info) && Scope::Analyze(&info)) {
          scope = info.function()->scope();
        }
        RetrieveScopeChain(scope, shared_info);
      } else {
        // Function code
        CompilationInfoWithZone info(shared_info);
        if (Parser::Parse(&info) && Scope::Analyze(&info)) {
          scope = info.function()->scope();
        }
        RetrieveScopeChain(scope, shared_info);
      }
    }
  }

References v8::internal::ALL_BREAK_LOCATIONS, v8::internal::Scope::Analyze(), context_, DCHECK, v8::internal::Isolate::debug(), v8::internal::Debug::EnsureDebugInfo(), v8::internal::EVAL_SCOPE, v8::internal::BreakLocationIterator::FindBreakLocationFromAddress(), v8::internal::CompilationInfo::function(), function_, v8::internal::FUNCTION_SCOPE, v8::internal::Debug::GetDebugInfo(), v8::internal::GLOBAL_SCOPE, v8::internal::Isolate::heap(), v8::internal::BreakLocationIterator::IsExit(), isolate_, v8::internal::CompilationInfo::MarkAsEval(), v8::internal::CompilationInfo::MarkAsGlobal(), nested_scope_chain_, NULL, v8::internal::Parser::Parse(), RetrieveScopeChain(), and v8::internal::CompilationInfo::SetContext().

Here is the call graph for this function:

ScopeIterator() [2/2]

v8::internal::ScopeIterator::ScopeIterator ( Isolate *  isolate, Handle< JSFunction >  function  )

inline

Definition at line 6585 of file runtime.cc.

      : isolate_(isolate),
        frame_(NULL),
        inlined_jsframe_index_(0),
        function_(function),
        context_(function->context()),
        failed_(false) {
    if (function->IsBuiltin()) {
      context_ = Handle<Context>();
    }
  }

References context_.

Member Function Documentation

CurrentContext()

Handle<Context> v8::internal::ScopeIterator::CurrentContext ( )

inline

Definition at line 6742 of file runtime.cc.

                                   {
    DCHECK(!failed_);
    if (Type() == ScopeTypeGlobal || nested_scope_chain_.is_empty()) {
      return context_;
    } else if (nested_scope_chain_.last()->HasContext()) {
      return context_;
    } else {
      return Handle<Context>();
    }
  }

References context_, DCHECK, failed_, nested_scope_chain_, ScopeTypeGlobal, and Type().

Referenced by ScopeObject(), and SetVariableValue().

Here is the call graph for this function:

Here is the caller graph for this function:

CurrentScopeInfo()

Handle<ScopeInfo> v8::internal::ScopeIterator::CurrentScopeInfo ( )

inline

Definition at line 6728 of file runtime.cc.

                                       {
    DCHECK(!failed_);
    if (!nested_scope_chain_.is_empty()) {
      return nested_scope_chain_.last();
    } else if (context_->IsBlockContext()) {
      return Handle<ScopeInfo>(ScopeInfo::cast(context_->extension()));
    } else if (context_->IsFunctionContext()) {
      return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
    }
    return Handle<ScopeInfo>::null();
  }

References context_, DCHECK, failed_, nested_scope_chain_, and v8::internal::Handle< T >::null().

Here is the call graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::ScopeIterator::DISALLOW_IMPLICIT_CONSTRUCTORS ( ScopeIterator  )

private

Done()

bool v8::internal::ScopeIterator::Done ( )

inline

Definition at line 6598 of file runtime.cc.

              {
    DCHECK(!failed_);
    return context_.is_null();
  }

References context_, DCHECK, and failed_.

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::internal::SetScopeVariableValue().

Here is the caller graph for this function:

Failed()

bool v8::internal::ScopeIterator::Failed ( )

inline

Definition at line 6603 of file runtime.cc.

{ return failed_; }

References failed_.

Next()

void v8::internal::ScopeIterator::Next ( )

inline

Definition at line 6606 of file runtime.cc.

              {
    DCHECK(!failed_);
    ScopeType scope_type = Type();
    if (scope_type == ScopeTypeGlobal) {
      // The global scope is always the last in the chain.
      DCHECK(context_->IsNativeContext());
      context_ = Handle<Context>();
      return;
    }
    if (nested_scope_chain_.is_empty()) {
      context_ = Handle<Context>(context_->previous(), isolate_);
    } else {
      if (nested_scope_chain_.last()->HasContext()) {
        DCHECK(context_->previous() != NULL);
        context_ = Handle<Context>(context_->previous(), isolate_);
      }
      nested_scope_chain_.RemoveLast();
    }
  }

References context_, DCHECK, failed_, isolate_, nested_scope_chain_, NULL, ScopeTypeGlobal, and Type().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

RetrieveScopeChain()

void v8::internal::ScopeIterator::RetrieveScopeChain ( Scope *  scope, Handle< SharedFunctionInfo >  shared_info  )

inlineprivate

Definition at line 6817 of file runtime.cc.

                                                                  {
    if (scope != NULL) {
      int source_position = shared_info->code()->SourcePosition(frame_->pc());
      scope->GetNestedScopeChain(&nested_scope_chain_, source_position);
    } else {
      // A failed reparse indicates that the preparser has diverged from the
      // parser or that the preparse data given to the initial parse has been
      // faulty. We fail in debug mode but in release mode we only provide the
      // information we get from the context chain but nothing about
      // completely stack allocated scopes or stack allocated locals.
      // Or it could be due to stack overflow.
      DCHECK(isolate_->has_pending_exception());
      failed_ = true;
    }
  }

References DCHECK, failed_, frame_, v8::internal::Scope::GetNestedScopeChain(), v8::internal::Isolate::has_pending_exception(), isolate_, nested_scope_chain_, and NULL.

Referenced by ScopeIterator().

Here is the call graph for this function:

Here is the caller graph for this function:

ScopeObject()

MaybeHandle<JSObject> v8::internal::ScopeIterator::ScopeObject ( )

inline

Definition at line 6675 of file runtime.cc.

                                      {
    DCHECK(!failed_);
    switch (Type()) {
      case ScopeIterator::ScopeTypeGlobal:
        return Handle<JSObject>(CurrentContext()->global_object());
      case ScopeIterator::ScopeTypeLocal:
        // Materialize the content of the local scope into a JSObject.
        DCHECK(nested_scope_chain_.length() == 1);
        return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
      case ScopeIterator::ScopeTypeWith:
        // Return the with object.
        return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
      case ScopeIterator::ScopeTypeCatch:
        return MaterializeCatchScope(isolate_, CurrentContext());
      case ScopeIterator::ScopeTypeClosure:
        // Materialize the content of the closure scope into a JSObject.
        return MaterializeClosure(isolate_, CurrentContext());
      case ScopeIterator::ScopeTypeBlock:
        return MaterializeBlockScope(isolate_, CurrentContext());
      case ScopeIterator::ScopeTypeModule:
        return MaterializeModuleScope(isolate_, CurrentContext());
    }
    UNREACHABLE();
    return Handle<JSObject>();
  }

References CurrentContext(), DCHECK, failed_, frame_, inlined_jsframe_index_, isolate_, v8::internal::MaterializeBlockScope(), v8::internal::MaterializeCatchScope(), v8::internal::MaterializeClosure(), v8::internal::MaterializeLocalScope(), v8::internal::MaterializeModuleScope(), nested_scope_chain_, ScopeTypeBlock, ScopeTypeCatch, ScopeTypeClosure, ScopeTypeGlobal, ScopeTypeLocal, ScopeTypeModule, ScopeTypeWith, Type(), and UNREACHABLE.

Referenced by v8::internal::MaterializeScopeDetails().

Here is the call graph for this function:

Here is the caller graph for this function:

SetVariableValue()

bool v8::internal::ScopeIterator::SetVariableValue ( Handle< String >  variable_name, Handle< Object >  new_value  )

inline

Definition at line 6701 of file runtime.cc.

                                                  {
    DCHECK(!failed_);
    switch (Type()) {
      case ScopeIterator::ScopeTypeGlobal:
        break;
      case ScopeIterator::ScopeTypeLocal:
        return SetLocalVariableValue(isolate_, frame_, inlined_jsframe_index_,
                                     variable_name, new_value);
      case ScopeIterator::ScopeTypeWith:
        break;
      case ScopeIterator::ScopeTypeCatch:
        return SetCatchVariableValue(isolate_, CurrentContext(), variable_name,
                                     new_value);
      case ScopeIterator::ScopeTypeClosure:
        return SetClosureVariableValue(isolate_, CurrentContext(),
                                       variable_name, new_value);
      case ScopeIterator::ScopeTypeBlock:
        // TODO(2399): should we implement it?
        break;
      case ScopeIterator::ScopeTypeModule:
        // TODO(2399): should we implement it?
        break;
    }
    return false;
  }

References CurrentContext(), DCHECK, failed_, frame_, inlined_jsframe_index_, isolate_, ScopeTypeBlock, ScopeTypeCatch, ScopeTypeClosure, ScopeTypeGlobal, ScopeTypeLocal, ScopeTypeModule, ScopeTypeWith, v8::internal::SetCatchVariableValue(), v8::internal::SetClosureVariableValue(), v8::internal::SetLocalVariableValue(), and Type().

Referenced by v8::internal::SetScopeVariableValue().

Here is the call graph for this function:

Here is the caller graph for this function:

Type()

ScopeType v8::internal::ScopeIterator::Type ( )

inline

Definition at line 6627 of file runtime.cc.

                   {
    DCHECK(!failed_);
    if (!nested_scope_chain_.is_empty()) {
      Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
      switch (scope_info->scope_type()) {
        case FUNCTION_SCOPE:
          DCHECK(context_->IsFunctionContext() || !scope_info->HasContext());
          return ScopeTypeLocal;
        case MODULE_SCOPE:
          DCHECK(context_->IsModuleContext());
          return ScopeTypeModule;
        case GLOBAL_SCOPE:
          DCHECK(context_->IsNativeContext());
          return ScopeTypeGlobal;
        case WITH_SCOPE:
          DCHECK(context_->IsWithContext());
          return ScopeTypeWith;
        case CATCH_SCOPE:
          DCHECK(context_->IsCatchContext());
          return ScopeTypeCatch;
        case BLOCK_SCOPE:
          DCHECK(!scope_info->HasContext() || context_->IsBlockContext());
          return ScopeTypeBlock;
        case EVAL_SCOPE:
          UNREACHABLE();
      }
    }
    if (context_->IsNativeContext()) {
      DCHECK(context_->global_object()->IsGlobalObject());
      return ScopeTypeGlobal;
    }
    if (context_->IsFunctionContext()) {
      return ScopeTypeClosure;
    }
    if (context_->IsCatchContext()) {
      return ScopeTypeCatch;
    }
    if (context_->IsBlockContext()) {
      return ScopeTypeBlock;
    }
    if (context_->IsModuleContext()) {
      return ScopeTypeModule;
    }
    DCHECK(context_->IsWithContext());
    return ScopeTypeWith;
  }

References v8::internal::BLOCK_SCOPE, v8::internal::CATCH_SCOPE, context_, DCHECK, v8::internal::EVAL_SCOPE, failed_, v8::internal::FUNCTION_SCOPE, v8::internal::GLOBAL_SCOPE, v8::internal::MODULE_SCOPE, nested_scope_chain_, ScopeTypeBlock, ScopeTypeCatch, ScopeTypeClosure, ScopeTypeGlobal, ScopeTypeLocal, ScopeTypeModule, ScopeTypeWith, UNREACHABLE, and v8::internal::WITH_SCOPE.

Referenced by CurrentContext(), v8::internal::MaterializeScopeDetails(), Next(), ScopeObject(), and SetVariableValue().

Here is the caller graph for this function:

Member Data Documentation

context_

Handle<Context> v8::internal::ScopeIterator::context_

private

Definition at line 6813 of file runtime.cc.

Referenced by CurrentContext(), CurrentScopeInfo(), Done(), Next(), ScopeIterator(), and Type().

failed_

bool v8::internal::ScopeIterator::failed_

private

Definition at line 6815 of file runtime.cc.

Referenced by CurrentContext(), CurrentScopeInfo(), Done(), Failed(), Next(), RetrieveScopeChain(), ScopeObject(), SetVariableValue(), and Type().

frame_

JavaScriptFrame* v8::internal::ScopeIterator::frame_

private

Definition at line 6810 of file runtime.cc.

Referenced by RetrieveScopeChain(), ScopeObject(), and SetVariableValue().

function_

Handle<JSFunction> v8::internal::ScopeIterator::function_

private

Definition at line 6812 of file runtime.cc.

Referenced by ScopeIterator().

inlined_jsframe_index_

int v8::internal::ScopeIterator::inlined_jsframe_index_

private

Definition at line 6811 of file runtime.cc.

Referenced by ScopeObject(), and SetVariableValue().

isolate_

Isolate* v8::internal::ScopeIterator::isolate_

private

Definition at line 6809 of file runtime.cc.

Referenced by Next(), RetrieveScopeChain(), ScopeIterator(), ScopeObject(), and SetVariableValue().

nested_scope_chain_

List<Handle<ScopeInfo> > v8::internal::ScopeIterator::nested_scope_chain_

private

Definition at line 6814 of file runtime.cc.

Referenced by CurrentContext(), CurrentScopeInfo(), Next(), RetrieveScopeChain(), ScopeIterator(), ScopeObject(), and Type().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/runtime/runtime.cc