Ignore:
Timestamp:
Jun 12, 2006, 11:08:52 PM (19 years ago)
Author:
ggaren
Message:

JavaScriptCore:

Reviewed by TimO, Maciej.


  • Merged InterpreterImp code into Interpreter, which implements all interpreter functionality now. This is part of my continuing quest to create an external notion of JS "execution context" that is unified and simple -- something to replace the mix of Context, ContextImp, ExecState, Interpreter, InterpreterImp, and JSRun.


All tests pass. Leaks test has not regressed from its baseline ~207 leaks
with ~3460 leaked nodes.

  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • bindings/NP_jsobject.cpp:
  • bindings/objc/WebScriptObject.mm: (+[WebScriptObject throwException:]):
  • bindings/runtime_root.cpp:
  • bindings/runtime_root.h:
  • kjs/Context.cpp: (KJS::Context::Context):
  • kjs/ExecState.cpp: Added. (KJS::ExecState::lexicalInterpreter):
  • kjs/ExecState.h: Added. (KJS::ExecState::dynamicInterpreter):
  • kjs/SavedBuiltins.h: Added.
  • kjs/bool_object.cpp: (BooleanPrototype::BooleanPrototype):
  • kjs/collector.cpp: (KJS::Collector::collect): (KJS::Collector::numInterpreters):
  • kjs/context.h:
  • kjs/debugger.cpp: (Debugger::attach): (Debugger::detach):
  • kjs/function.cpp: (KJS::FunctionImp::callAsFunction): (KJS::GlobalFuncImp::callAsFunction):
  • kjs/function_object.cpp: (FunctionObjectImp::construct):
  • kjs/internal.cpp:
  • kjs/internal.h:
  • kjs/interpreter.cpp: (KJS::interpreterMap): (KJS::Interpreter::Interpreter): (KJS::Interpreter::init): (KJS::Interpreter::~Interpreter): (KJS::Interpreter::globalObject): (KJS::Interpreter::initGlobalObject): (KJS::Interpreter::globalExec): (KJS::Interpreter::checkSyntax): (KJS::Interpreter::evaluate): (KJS::Interpreter::builtinObject): (KJS::Interpreter::builtinFunction): (KJS::Interpreter::builtinArray): (KJS::Interpreter::builtinBoolean): (KJS::Interpreter::builtinString): (KJS::Interpreter::builtinNumber): (KJS::Interpreter::builtinDate): (KJS::Interpreter::builtinRegExp): (KJS::Interpreter::builtinError): (KJS::Interpreter::builtinObjectPrototype): (KJS::Interpreter::builtinFunctionPrototype): (KJS::Interpreter::builtinArrayPrototype): (KJS::Interpreter::builtinBooleanPrototype): (KJS::Interpreter::builtinStringPrototype): (KJS::Interpreter::builtinNumberPrototype): (KJS::Interpreter::builtinDatePrototype): (KJS::Interpreter::builtinRegExpPrototype): (KJS::Interpreter::builtinErrorPrototype): (KJS::Interpreter::builtinEvalError): (KJS::Interpreter::builtinRangeError): (KJS::Interpreter::builtinReferenceError): (KJS::Interpreter::builtinSyntaxError): (KJS::Interpreter::builtinTypeError): (KJS::Interpreter::builtinURIError): (KJS::Interpreter::builtinEvalErrorPrototype): (KJS::Interpreter::builtinRangeErrorPrototype): (KJS::Interpreter::builtinReferenceErrorPrototype): (KJS::Interpreter::builtinSyntaxErrorPrototype): (KJS::Interpreter::builtinTypeErrorPrototype): (KJS::Interpreter::builtinURIErrorPrototype): (KJS::Interpreter::mark): (KJS::Interpreter::interpreterWithGlobalObject): (KJS::Interpreter::saveBuiltins): (KJS::Interpreter::restoreBuiltins):
  • kjs/interpreter.h: (KJS::Interpreter::setCompatMode): (KJS::Interpreter::compatMode): (KJS::Interpreter::firstInterpreter): (KJS::Interpreter::nextInterpreter): (KJS::Interpreter::prevInterpreter): (KJS::Interpreter::debugger): (KJS::Interpreter::setDebugger): (KJS::Interpreter::setContext): (KJS::Interpreter::context):
  • kjs/nodes.cpp: (StatementNode::hitStatement): (RegExpNode::evaluate):
  • kjs/protect.h:

JavaScriptGlue:

Reviewed by TimO, Maciej.


  • JSGlue part of merging InterpreterImp into Interpreter.


Since there's now a kjs forwarding header, I moved all forwarding
headers into a "ForwardingHeaders" directory, like in WebCore.

  • ForwardingHeaders: Added.
  • ForwardingHeaders/kjs: Added.
  • ForwardingHeaders/kjs/ExecState.h: Added.
  • ForwardingHeaders/wtf: Added.
  • JavaScriptGlue.xcodeproj/project.pbxproj:
  • config.h:
  • wtf: Removed.
  • wtf/AlwaysInline.h: Removed.
  • wtf/Assertions.h: Removed.
  • wtf/FastMalloc.h: Removed.
  • wtf/Forward.h: Removed.
  • wtf/HashCountedSet.h: Removed.
  • wtf/HashSet.h: Removed.
  • wtf/Noncopyable.h: Removed.
  • wtf/OwnArrayPtr.h: Removed.
  • wtf/OwnPtr.h: Removed.
  • wtf/PassRefPtr.h: Removed.
  • wtf/Platform.h: Removed.
  • wtf/RefPtr.h: Removed.
  • wtf/Vector.h: Removed.

WebCore:

Reviewed by TimO, Maciej.

  • WebCore part of merging InterpreterImp into Interpreter. No test because there's no behavior change.


A substantive change here is that ScriptInterpreter::mark must now chain to
Interpreter::mark, since Interpreter needs to mark the things that
InterpreterImp used to mark.


  • WebCore.xcodeproj/project.pbxproj:
  • bindings/js/kjs_binding.cpp:
  • bindings/js/kjs_window.cpp: (KJS::Window::put):
  • bridge/mac/WebCoreFrameBridge.mm:
  • bridge/mac/WebCoreScriptDebugger.mm: (-[WebCoreScriptCallFrame evaluateWebScript:]):
  • kwq/KWQPageState.mm:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/internal.cpp

    r14799 r14834  
    188188}
    189189
    190 // ------------------------------ InterpreterImp -------------------------------
    191 
    192 InterpreterImp* InterpreterImp::s_hook = 0L;
    193 
    194 typedef HashMap<JSObject *, InterpreterImp *> InterpreterMap;
    195 
    196 static inline InterpreterMap &interpreterMap()
    197 {
    198     static InterpreterMap *map = new InterpreterMap;
    199     return *map;
    200 }
    201 
    202 InterpreterImp::InterpreterImp(Interpreter *interp, JSObject *glob)
    203     : globExec(interp, 0)
    204     , _context(0)
    205 {
    206   // add this interpreter to the global chain
    207   // as a root set for garbage collection
    208   JSLock lock;
    209 
    210   m_interpreter = interp;
    211   if (s_hook) {
    212     prev = s_hook;
    213     next = s_hook->next;
    214     s_hook->next->prev = this;
    215     s_hook->next = this;
    216   } else {
    217     // This is the first interpreter
    218     s_hook = next = prev = this;
    219   }
    220 
    221   interpreterMap().set(glob, this);
    222 
    223   global = glob;
    224   dbg = 0;
    225   m_compatMode = Interpreter::NativeMode;
    226 
    227   // initialize properties of the global object
    228   initGlobalObject();
    229 
    230   recursion = 0;
    231 }
    232 
    233 void InterpreterImp::initGlobalObject()
    234 {
    235   Identifier::init();
    236  
    237   // Contructor prototype objects (Object.prototype, Array.prototype etc)
    238 
    239   FunctionPrototype *funcProto = new FunctionPrototype(&globExec);
    240   b_FunctionPrototype = funcProto;
    241   ObjectPrototype *objProto = new ObjectPrototype(&globExec, funcProto);
    242   b_ObjectPrototype = objProto;
    243   funcProto->setPrototype(b_ObjectPrototype);
    244 
    245   ArrayPrototype *arrayProto = new ArrayPrototype(&globExec, objProto);
    246   b_ArrayPrototype = arrayProto;
    247   StringPrototype *stringProto = new StringPrototype(&globExec, objProto);
    248   b_StringPrototype = stringProto;
    249   BooleanPrototype *booleanProto = new BooleanPrototype(&globExec, objProto, funcProto);
    250   b_BooleanPrototype = booleanProto;
    251   NumberPrototype *numberProto = new NumberPrototype(&globExec, objProto, funcProto);
    252   b_NumberPrototype = numberProto;
    253   DatePrototype *dateProto = new DatePrototype(&globExec, objProto);
    254   b_DatePrototype = dateProto;
    255   RegExpPrototype *regexpProto = new RegExpPrototype(&globExec, objProto, funcProto);
    256   b_RegExpPrototype = regexpProto;
    257   ErrorPrototype *errorProto = new ErrorPrototype(&globExec, objProto, funcProto);
    258   b_ErrorPrototype = errorProto;
    259 
    260   JSObject* o = global;
    261   while (o->prototype()->isObject())
    262       o = static_cast<JSObject*>(o->prototype());
    263   o->setPrototype(b_ObjectPrototype);
    264 
    265   // Constructors (Object, Array, etc.)
    266   b_Object = new ObjectObjectImp(&globExec, objProto, funcProto);
    267   b_Function = new FunctionObjectImp(&globExec, funcProto);
    268   b_Array = new ArrayObjectImp(&globExec, funcProto, arrayProto);
    269   b_String = new StringObjectImp(&globExec, funcProto, stringProto);
    270   b_Boolean = new BooleanObjectImp(&globExec, funcProto, booleanProto);
    271   b_Number = new NumberObjectImp(&globExec, funcProto, numberProto);
    272   b_Date = new DateObjectImp(&globExec, funcProto, dateProto);
    273   b_RegExp = new RegExpObjectImp(&globExec, funcProto, regexpProto);
    274   b_Error = new ErrorObjectImp(&globExec, funcProto, errorProto);
    275 
    276   // Error object prototypes
    277   b_evalErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, EvalError, "EvalError", "EvalError");
    278   b_rangeErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, RangeError, "RangeError", "RangeError");
    279   b_referenceErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, ReferenceError, "ReferenceError", "ReferenceError");
    280   b_syntaxErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, SyntaxError, "SyntaxError", "SyntaxError");
    281   b_typeErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, TypeError, "TypeError", "TypeError");
    282   b_uriErrorPrototype = new NativeErrorPrototype(&globExec, errorProto, URIError, "URIError", "URIError");
    283 
    284   // Error objects
    285   b_evalError = new NativeErrorImp(&globExec, funcProto, b_evalErrorPrototype);
    286   b_rangeError = new NativeErrorImp(&globExec, funcProto, b_rangeErrorPrototype);
    287   b_referenceError = new NativeErrorImp(&globExec, funcProto, b_referenceErrorPrototype);
    288   b_syntaxError = new NativeErrorImp(&globExec, funcProto, b_syntaxErrorPrototype);
    289   b_typeError = new NativeErrorImp(&globExec, funcProto, b_typeErrorPrototype);
    290   b_uriError = new NativeErrorImp(&globExec, funcProto, b_uriErrorPrototype);
    291 
    292   // ECMA 15.3.4.1
    293   funcProto->put(&globExec, constructorPropertyName, b_Function, DontEnum);
    294 
    295   global->put(&globExec, "Object", b_Object, DontEnum);
    296   global->put(&globExec, "Function", b_Function, DontEnum);
    297   global->put(&globExec, "Array", b_Array, DontEnum);
    298   global->put(&globExec, "Boolean", b_Boolean, DontEnum);
    299   global->put(&globExec, "String", b_String, DontEnum);
    300   global->put(&globExec, "Number", b_Number, DontEnum);
    301   global->put(&globExec, "Date", b_Date, DontEnum);
    302   global->put(&globExec, "RegExp", b_RegExp, DontEnum);
    303   global->put(&globExec, "Error", b_Error, DontEnum);
    304   // Using Internal for those to have something != 0
    305   // (see kjs_window). Maybe DontEnum would be ok too ?
    306   global->put(&globExec, "EvalError",b_evalError, Internal);
    307   global->put(&globExec, "RangeError",b_rangeError, Internal);
    308   global->put(&globExec, "ReferenceError",b_referenceError, Internal);
    309   global->put(&globExec, "SyntaxError",b_syntaxError, Internal);
    310   global->put(&globExec, "TypeError",b_typeError, Internal);
    311   global->put(&globExec, "URIError",b_uriError, Internal);
    312 
    313   // Set the constructorPropertyName property of all builtin constructors
    314   objProto->put(&globExec, constructorPropertyName, b_Object, DontEnum | DontDelete | ReadOnly);
    315   funcProto->put(&globExec, constructorPropertyName, b_Function, DontEnum | DontDelete | ReadOnly);
    316   arrayProto->put(&globExec, constructorPropertyName, b_Array, DontEnum | DontDelete | ReadOnly);
    317   booleanProto->put(&globExec, constructorPropertyName, b_Boolean, DontEnum | DontDelete | ReadOnly);
    318   stringProto->put(&globExec, constructorPropertyName, b_String, DontEnum | DontDelete | ReadOnly);
    319   numberProto->put(&globExec, constructorPropertyName, b_Number, DontEnum | DontDelete | ReadOnly);
    320   dateProto->put(&globExec, constructorPropertyName, b_Date, DontEnum | DontDelete | ReadOnly);
    321   regexpProto->put(&globExec, constructorPropertyName, b_RegExp, DontEnum | DontDelete | ReadOnly);
    322   errorProto->put(&globExec, constructorPropertyName, b_Error, DontEnum | DontDelete | ReadOnly);
    323   b_evalErrorPrototype->put(&globExec, constructorPropertyName, b_evalError, DontEnum | DontDelete | ReadOnly);
    324   b_rangeErrorPrototype->put(&globExec, constructorPropertyName, b_rangeError, DontEnum | DontDelete | ReadOnly);
    325   b_referenceErrorPrototype->put(&globExec, constructorPropertyName, b_referenceError, DontEnum | DontDelete | ReadOnly);
    326   b_syntaxErrorPrototype->put(&globExec, constructorPropertyName, b_syntaxError, DontEnum | DontDelete | ReadOnly);
    327   b_typeErrorPrototype->put(&globExec, constructorPropertyName, b_typeError, DontEnum | DontDelete | ReadOnly);
    328   b_uriErrorPrototype->put(&globExec, constructorPropertyName, b_uriError, DontEnum | DontDelete | ReadOnly);
    329 
    330   // built-in values
    331   global->put(&globExec, "NaN",        jsNaN(), DontEnum|DontDelete);
    332   global->put(&globExec, "Infinity",   jsNumber(Inf), DontEnum|DontDelete);
    333   global->put(&globExec, "undefined",  jsUndefined(), DontEnum|DontDelete);
    334 
    335   // built-in functions
    336   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::Eval, 1, "eval"), DontEnum);
    337   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::ParseInt, 2, "parseInt"), DontEnum);
    338   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::ParseFloat, 1, "parseFloat"), DontEnum);
    339   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::IsNaN, 1, "isNaN"), DontEnum);
    340   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::IsFinite, 1, "isFinite"), DontEnum);
    341   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::Escape, 1, "escape"), DontEnum);
    342   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::UnEscape, 1, "unescape"), DontEnum);
    343   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::DecodeURI, 1, "decodeURI"), DontEnum);
    344   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::DecodeURIComponent, 1, "decodeURIComponent"), DontEnum);
    345   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::EncodeURI, 1, "encodeURI"), DontEnum);
    346   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::EncodeURIComponent, 1, "encodeURIComponent"), DontEnum);
    347 #ifndef NDEBUG
    348   global->putDirectFunction(new GlobalFuncImp(&globExec, funcProto, GlobalFuncImp::KJSPrint, 1, "kjsprint"), DontEnum);
    349 #endif
    350 
    351   // built-in objects
    352   global->put(&globExec, "Math", new MathObjectImp(&globExec, objProto), DontEnum);
    353 }
    354 
    355 InterpreterImp::~InterpreterImp()
    356 {
    357   if (dbg)
    358     dbg->detach(m_interpreter);
    359   clear();
    360 }
    361 
    362 void InterpreterImp::clear()
    363 {
    364   //fprintf(stderr,"InterpreterImp::clear\n");
    365   // remove from global chain (see init())
    366   JSLock lock;
    367 
    368   next->prev = prev;
    369   prev->next = next;
    370   s_hook = next;
    371   if (s_hook == this)
    372   {
    373     // This was the last interpreter
    374     s_hook = 0L;
    375   }
    376   interpreterMap().remove(global);
    377 }
    378 
    379 void InterpreterImp::mark(bool currentThreadIsMainThread)
    380 {
    381   if (m_interpreter)
    382     m_interpreter->mark(currentThreadIsMainThread);
    383   if (_context)
    384     _context->mark();
    385   if (global)
    386       global->mark();
    387   if (globExec.exception())
    388       globExec.exception()->mark();
    389 }
    390 
    391 bool InterpreterImp::checkSyntax(const UString &code)
    392 {
    393   JSLock lock;
    394 
    395   // Parser::parse() returns 0 in a syntax error occurs, so we just check for that
    396   RefPtr<ProgramNode> progNode = Parser::parse(UString(), 0, code.data(), code.size(), 0, 0, 0);
    397   return progNode;
    398 }
    399 
    400 Completion InterpreterImp::evaluate(const UChar* code, int codeLength, JSValue* thisV, const UString& sourceURL, int startingLineNumber)
    401 {
    402   JSLock lock;
    403 
    404   // prevent against infinite recursion
    405   if (recursion >= 20)
    406     return Completion(Throw, Error::create(&globExec, GeneralError, "Recursion too deep"));
    407 
    408   // parse the source code
    409   int sid;
    410   int errLine;
    411   UString errMsg;
    412   RefPtr<ProgramNode> progNode = Parser::parse(sourceURL, startingLineNumber, code, codeLength, &sid, &errLine, &errMsg);
    413 
    414   // notify debugger that source has been parsed
    415   if (dbg) {
    416     bool cont = dbg->sourceParsed(&globExec, sid, sourceURL, UString(code, codeLength), errLine);
    417     if (!cont)
    418       return Completion(Break);
    419   }
    420  
    421   // no program node means a syntax error occurred
    422   if (!progNode)
    423     return Completion(Throw, Error::create(&globExec, SyntaxError, errMsg, errLine, sid, &sourceURL));
    424 
    425   globExec.clearException();
    426 
    427   recursion++;
    428 
    429   JSObject* globalObj = globalObject();
    430   JSObject* thisObj = globalObj;
    431 
    432   // "this" must be an object... use same rules as Function.prototype.apply()
    433   if (thisV && !thisV->isUndefinedOrNull())
    434       thisObj = thisV->toObject(&globExec);
    435 
    436   Completion res;
    437   if (globExec.hadException())
    438     // the thisV->toObject() conversion above might have thrown an exception - if so, propagate it
    439     res = Completion(Throw, globExec.exception());
    440   else {
    441     // execute the code
    442     Context ctx(globalObj, this, thisObj, progNode.get());
    443     ExecState newExec(m_interpreter, &ctx);
    444     progNode->processVarDecls(&newExec);
    445     res = progNode->execute(&newExec);
    446   }
    447 
    448   recursion--;
    449 
    450   return res;
    451 }
    452 
    453 void InterpreterImp::saveBuiltins (SavedBuiltins &builtins) const
    454 {
    455   if (!builtins._internal) {
    456     builtins._internal = new SavedBuiltinsInternal;
    457   }
    458 
    459   builtins._internal->b_Object = b_Object;
    460   builtins._internal->b_Function = b_Function;
    461   builtins._internal->b_Array = b_Array;
    462   builtins._internal->b_Boolean = b_Boolean;
    463   builtins._internal->b_String = b_String;
    464   builtins._internal->b_Number = b_Number;
    465   builtins._internal->b_Date = b_Date;
    466   builtins._internal->b_RegExp = b_RegExp;
    467   builtins._internal->b_Error = b_Error;
    468  
    469   builtins._internal->b_ObjectPrototype = b_ObjectPrototype;
    470   builtins._internal->b_FunctionPrototype = b_FunctionPrototype;
    471   builtins._internal->b_ArrayPrototype = b_ArrayPrototype;
    472   builtins._internal->b_BooleanPrototype = b_BooleanPrototype;
    473   builtins._internal->b_StringPrototype = b_StringPrototype;
    474   builtins._internal->b_NumberPrototype = b_NumberPrototype;
    475   builtins._internal->b_DatePrototype = b_DatePrototype;
    476   builtins._internal->b_RegExpPrototype = b_RegExpPrototype;
    477   builtins._internal->b_ErrorPrototype = b_ErrorPrototype;
    478  
    479   builtins._internal->b_evalError = b_evalError;
    480   builtins._internal->b_rangeError = b_rangeError;
    481   builtins._internal->b_referenceError = b_referenceError;
    482   builtins._internal->b_syntaxError = b_syntaxError;
    483   builtins._internal->b_typeError = b_typeError;
    484   builtins._internal->b_uriError = b_uriError;
    485  
    486   builtins._internal->b_evalErrorPrototype = b_evalErrorPrototype;
    487   builtins._internal->b_rangeErrorPrototype = b_rangeErrorPrototype;
    488   builtins._internal->b_referenceErrorPrototype = b_referenceErrorPrototype;
    489   builtins._internal->b_syntaxErrorPrototype = b_syntaxErrorPrototype;
    490   builtins._internal->b_typeErrorPrototype = b_typeErrorPrototype;
    491   builtins._internal->b_uriErrorPrototype = b_uriErrorPrototype;
    492 }
    493 
    494 void InterpreterImp::restoreBuiltins (const SavedBuiltins &builtins)
    495 {
    496   if (!builtins._internal) {
    497     return;
    498   }
    499 
    500   b_Object = builtins._internal->b_Object;
    501   b_Function = builtins._internal->b_Function;
    502   b_Array = builtins._internal->b_Array;
    503   b_Boolean = builtins._internal->b_Boolean;
    504   b_String = builtins._internal->b_String;
    505   b_Number = builtins._internal->b_Number;
    506   b_Date = builtins._internal->b_Date;
    507   b_RegExp = builtins._internal->b_RegExp;
    508   b_Error = builtins._internal->b_Error;
    509  
    510   b_ObjectPrototype = builtins._internal->b_ObjectPrototype;
    511   b_FunctionPrototype = builtins._internal->b_FunctionPrototype;
    512   b_ArrayPrototype = builtins._internal->b_ArrayPrototype;
    513   b_BooleanPrototype = builtins._internal->b_BooleanPrototype;
    514   b_StringPrototype = builtins._internal->b_StringPrototype;
    515   b_NumberPrototype = builtins._internal->b_NumberPrototype;
    516   b_DatePrototype = builtins._internal->b_DatePrototype;
    517   b_RegExpPrototype = builtins._internal->b_RegExpPrototype;
    518   b_ErrorPrototype = builtins._internal->b_ErrorPrototype;
    519  
    520   b_evalError = builtins._internal->b_evalError;
    521   b_rangeError = builtins._internal->b_rangeError;
    522   b_referenceError = builtins._internal->b_referenceError;
    523   b_syntaxError = builtins._internal->b_syntaxError;
    524   b_typeError = builtins._internal->b_typeError;
    525   b_uriError = builtins._internal->b_uriError;
    526  
    527   b_evalErrorPrototype = builtins._internal->b_evalErrorPrototype;
    528   b_rangeErrorPrototype = builtins._internal->b_rangeErrorPrototype;
    529   b_referenceErrorPrototype = builtins._internal->b_referenceErrorPrototype;
    530   b_syntaxErrorPrototype = builtins._internal->b_syntaxErrorPrototype;
    531   b_typeErrorPrototype = builtins._internal->b_typeErrorPrototype;
    532   b_uriErrorPrototype = builtins._internal->b_uriErrorPrototype;
    533 }
    534 
    535 InterpreterImp *InterpreterImp::interpreterWithGlobalObject(JSObject *global)
    536 {
    537     return interpreterMap().get(global);
    538 }
    539 
    540 
    541190// ------------------------------ InternalFunctionImp --------------------------
    542191
Note: See TracChangeset for help on using the changeset viewer.