debug-scopes.h 4.96 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2015 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.

#ifndef V8_DEBUG_DEBUG_SCOPES_H_
#define V8_DEBUG_DEBUG_SCOPES_H_

8 9
#include <vector>

10 11 12 13 14 15
#include "src/debug/debug-frames.h"
#include "src/frames.h"

namespace v8 {
namespace internal {

16 17
class ParseInfo;

18 19 20 21 22 23 24 25 26 27 28 29 30 31
// Iterate over the actual scopes visible from a stack frame or from a closure.
// The iteration proceeds from the innermost visible nested scope outwards.
// All scopes are backed by an actual context except the local scope,
// which is inserted "artificially" in the context chain.
class ScopeIterator {
 public:
  enum ScopeType {
    ScopeTypeGlobal = 0,
    ScopeTypeLocal,
    ScopeTypeWith,
    ScopeTypeClosure,
    ScopeTypeCatch,
    ScopeTypeBlock,
    ScopeTypeScript,
32
    ScopeTypeEval,
33 34 35 36 37
    ScopeTypeModule
  };

  static const int kScopeDetailsTypeIndex = 0;
  static const int kScopeDetailsObjectIndex = 1;
38
  static const int kScopeDetailsNameIndex = 2;
39 40 41 42
  static const int kScopeDetailsStartPositionIndex = 3;
  static const int kScopeDetailsEndPositionIndex = 4;
  static const int kScopeDetailsFunctionIndex = 5;
  static const int kScopeDetailsSize = 6;
43

44 45
  enum Option { DEFAULT, IGNORE_NESTED_SCOPES, COLLECT_NON_LOCALS };

46
  ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
47
                Option options = DEFAULT);
48 49

  ScopeIterator(Isolate* isolate, Handle<JSFunction> function);
50
  ScopeIterator(Isolate* isolate, Handle<JSGeneratorObject> generator);
51
  ~ScopeIterator();
52

53
  Handle<JSObject> MaterializeScopeDetails();
54 55

  // More scopes?
56
  bool Done() const { return context_.is_null(); }
57 58 59 60

  // Move to the next scope.
  void Next();

61 62 63
  // Restart to the first scope and context.
  void Restart();

64
  // Return the type of the current scope.
65 66 67 68 69
  ScopeType Type() const;

  // Indicates which variables should be visited. Either only variables from the
  // scope that are available on the stack, or all variables.
  enum class Mode { STACK, ALL };
70 71

  // Return the JavaScript object with the content of the current scope.
72
  Handle<JSObject> ScopeObject(Mode mode);
73

74 75
  // Returns whether the current scope declares any variables.
  bool DeclaresLocals(Mode mode) const;
76 77 78 79

  // Set variable value and return true on success.
  bool SetVariableValue(Handle<String> variable_name, Handle<Object> new_value);

80 81
  // Populate the set with collected non-local variable names.
  Handle<StringSet> GetNonLocals();
82

83 84 85 86 87 88 89
  // Similar to JSFunction::GetName return the function's name or it's inferred
  // name.
  Handle<Object> GetFunctionDebugName() const;

  Handle<Script> GetScript() const { return script_; }

  bool HasPositionInfo();
90 91 92
  int start_position();
  int end_position();

93 94 95 96 97
#ifdef DEBUG
  // Debug print of the content of the current scope.
  void DebugPrint();
#endif

98 99 100 101 102 103
  bool InInnerScope() const { return !function_.is_null(); }
  bool HasContext() const;
  Handle<Context> CurrentContext() const {
    DCHECK(HasContext());
    return context_;
  }
104

105
 private:
106
  Isolate* isolate_;
107
  ParseInfo* info_ = nullptr;
108 109
  FrameInspector* const frame_inspector_ = nullptr;
  Handle<JSGeneratorObject> generator_;
110
  Handle<JSFunction> function_;
111
  Handle<Context> context_;
112
  Handle<Script> script_;
113
  Handle<StringSet> non_locals_;
114 115 116 117
  DeclarationScope* closure_scope_ = nullptr;
  Scope* start_scope_ = nullptr;
  Scope* current_scope_ = nullptr;
  bool seen_script_scope_ = false;
118

119 120
  inline JavaScriptFrame* GetFrame() const {
    return frame_inspector_->javascript_frame();
121 122
  }

123 124 125
  int GetSourcePosition();

  void TryParseAndRetrieveScopes(ScopeIterator::Option option);
126

verwaest's avatar
verwaest committed
127
  void RetrieveScopeChain(DeclarationScope* scope);
128

129
  void UnwrapEvaluationContext();
130

131 132 133
  typedef std::function<bool(Handle<String> name, Handle<Object> value)>
      Visitor;

134
  Handle<JSObject> WithContextExtension();
135 136 137

  bool SetLocalVariableValue(Handle<String> variable_name,
                             Handle<Object> new_value);
138
  bool SetContextVariableValue(Handle<String> variable_name,
139
                               Handle<Object> new_value);
140 141
  bool SetContextExtensionValue(Handle<String> variable_name,
                                Handle<Object> new_value);
142 143
  bool SetScriptVariableValue(Handle<String> variable_name,
                              Handle<Object> new_value);
144 145
  bool SetModuleVariableValue(Handle<String> variable_name,
                              Handle<Object> new_value);
146 147

  // Helper functions.
148 149 150 151 152 153 154
  void VisitScope(const Visitor& visitor, Mode mode) const;
  void VisitLocalScope(const Visitor& visitor, Mode mode) const;
  void VisitScriptScope(const Visitor& visitor) const;
  void VisitModuleScope(const Visitor& visitor) const;
  bool VisitLocals(const Visitor& visitor, Mode mode) const;
  bool VisitContextLocals(const Visitor& visitor, Handle<ScopeInfo> scope_info,
                          Handle<Context> context) const;
155

156 157 158 159 160 161 162
  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopeIterator);
};

}  // namespace internal
}  // namespace v8

#endif  // V8_DEBUG_DEBUG_SCOPES_H_