Wrap messages implementation in a function.

src/messages.js

 // Copyright 2012 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.
 
 // -------------------------------------------------------------------
 
+var $errorToString;
+var $formatMessage;
+var $getStackTraceLine;
+var $messageGetPositionInLine;
+var $messageGetLineNumber;
+var $messageGetSourceLine;
+var $stackOverflowBoilerplate;
+var $stackTraceSymbol;
+var $toDetailString;
+var $Error;
+var $EvalError;
+var $RangeError;
+var $ReferenceError;
+var $SyntaxError;
+var $TypeError;
+var $URIError;
+var MakeError;
+var MakeEvalError;
+var MakeRangeError;
+var MakeReferenceError;
+var MakeSyntaxError;
+var MakeTypeError;
+var MakeURIError;
+var MakeReferenceErrorEmbedded;
+var MakeSyntaxErrorEmbedded;
+var MakeTypeErrorEmbedded;
+
+(function() {
+
+%CheckIsBootstrapping();
+
+var GlobalObject = global.Object;
+var GlobalError;
+var GlobalTypeError;
+var GlobalRangeError;
+var GlobalURIError;
+var GlobalSyntaxError;
+var GlobalReferenceError;
+var GlobalEvalError;
+
+// -------------------------------------------------------------------
+
 var kMessages = {
   // Error
   constructor_is_generator:      ["Class constructor may not be a generator"],
   constructor_is_accessor:       ["Class constructor may not be an accessor"],
   // TypeError
   unexpected_token:              ["Unexpected token ", "%0"],
   unexpected_token_number:       ["Unexpected number"],
   unexpected_token_string:       ["Unexpected string"],
   unexpected_token_identifier:   ["Unexpected identifier"],
   unexpected_reserved:           ["Unexpected reserved word"],
@@ skipping 210 matching lines @@
   }
   if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
     return %_CallFunction(obj, ErrorToString);
   }
 
   return %_CallFunction(obj, NoSideEffectsObjectToString);
 }
 
 // To determine whether we can safely stringify an object using ErrorToString
 // without the risk of side-effects, we need to check whether the object is
-// either an instance of a native error type (via '%_ClassOf'), or has $Error
+// either an instance of a native error type (via '%_ClassOf'), or has Error
 // in its prototype chain and hasn't overwritten 'toString' with something
 // strange and unusual.
 function CanBeSafelyTreatedAsAnErrorObject(obj) {
   switch (%_ClassOf(obj)) {
     case 'Error':
     case 'EvalError':
     case 'RangeError':
     case 'ReferenceError':
     case 'SyntaxError':
     case 'TypeError':
     case 'URIError':
       return true;
   }
 
   var objToString = %GetDataProperty(obj, "toString");
-  return obj instanceof $Error && objToString === ErrorToString;
+  return obj instanceof GlobalError && objToString === ErrorToString;
 }
 
 
 // When formatting internally created error messages, do not
 // invoke overwritten error toString methods but explicitly use
 // the error to string method. This is to avoid leaking error
 // objects between script tags in a browser setting.
 function ToStringCheckErrorObject(obj) {
   if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
     return %_CallFunction(obj, ErrorToString);
@@ skipping 67 matching lines @@
 // Returns the source code line containing the given source
 // position, or the empty string if the position is invalid.
 function GetSourceLine(message) {
   var script = %MessageGetScript(message);
   var start_position = %MessageGetStartPosition(message);
   var location = script.locationFromPosition(start_position, true);
   if (location == null) return "";
   return location.sourceText();
 }
 
-
-function MakeError(type, arg0, arg1, arg2) {
-  return MakeGenericError($Error, type, arg0, arg1, arg2);
-}
-
-
-function MakeTypeError(type, arg0, arg1, arg2) {
-  return MakeGenericError($TypeError, type, arg0, arg1, arg2);
-}
-
-
-function MakeRangeError(type, arg0, arg1, arg2) {
-  return MakeGenericError($RangeError, type, arg0, arg1, arg2);
-}
-
-
-function MakeSyntaxError(type, arg0, arg1, arg2) {
-  return MakeGenericError($SyntaxError, type, arg0, arg1, arg2);
-}
-
-
-function MakeReferenceError(type, arg0, arg1, arg2) {
-  return MakeGenericError($ReferenceError, type, arg0, arg1, arg2);
-}
-
-
-function MakeEvalError(type, arg0, arg1, arg2) {
-  return MakeGenericError($EvalError, type, arg0, arg1, arg2);
-}
-
-
-function MakeURIError() {
-  return MakeGenericError($URIError, kURIMalformed);
-}
-
-// The embedded versions are called from unoptimized code, with embedded
-// arguments. Those arguments cannot be arrays, which are context-dependent.
-function MakeTypeErrorEmbedded(type, arg) {
-  return MakeGenericError($TypeError, type, [arg]);
-}
-
-
-function MakeSyntaxErrorEmbedded(type, arg) {
-  return MakeGenericError($SyntaxError, type, [arg]);
-}
-
-
-function MakeReferenceErrorEmbedded(type, arg) {
-  return MakeGenericError($ReferenceError, type, [arg]);
-}
-
 /**
  * Find a line number given a specific source position.
  * @param {number} position The source position.
  * @return {number} 0 if input too small, -1 if input too large,
        else the line number.
  */
 function ScriptLineFromPosition(position) {
   var lower = 0;
   var upper = this.lineCount() - 1;
   var line_ends = this.line_ends;
@@ skipping 623 matching lines @@
   return frames;
 }
 
 
 // Flag to prevent recursive call of Error.prepareStackTrace.
 var formatting_custom_stack_trace = false;
 
 
 function FormatStackTrace(obj, raw_stack) {
   var frames = GetStackFrames(raw_stack);
-  if (IS_FUNCTION($Error.prepareStackTrace) && !formatting_custom_stack_trace) {
+  if (IS_FUNCTION(GlobalError.prepareStackTrace) &&
+      !formatting_custom_stack_trace) {
     var array = [];
     %MoveArrayContents(frames, array);
     formatting_custom_stack_trace = true;
     var stack_trace = UNDEFINED;
     try {
-      stack_trace = $Error.prepareStackTrace(obj, array);
+      stack_trace = GlobalError.prepareStackTrace(obj, array);
     } catch (e) {
       throw e;  // The custom formatting function threw.  Rethrow.
     } finally {
       formatting_custom_stack_trace = false;
     }
     return stack_trace;
   }
 
   var lines = new InternalArray();
   lines.push(FormatErrorString(obj));
@@ skipping 23 matching lines @@
         %_CallFunction(receiver, NoSideEffectsObjectToString);
   }
   var constructorName = constructor.name;
   if (!constructorName) {
     return requireConstructor ? null :
         %_CallFunction(receiver, NoSideEffectsObjectToString);
   }
   return constructorName;
 }
 
-
-var stack_trace_symbol;  // Set during bootstrapping.
 var formatted_stack_trace_symbol = NEW_PRIVATE_OWN("formatted stack trace");
 
 
 // Format the stack trace if not yet done, and return it.
 // Cache the formatted stack trace on the holder.
 var StackTraceGetter = function() {
   var formatted_stack_trace = UNDEFINED;
   var holder = this;
   while (holder) {
     var formatted_stack_trace =
       GET_PRIVATE(holder, formatted_stack_trace_symbol);
     if (IS_UNDEFINED(formatted_stack_trace)) {
       // No formatted stack trace available.
-      var stack_trace = GET_PRIVATE(holder, stack_trace_symbol);
+      var stack_trace = GET_PRIVATE(holder, $stackTraceSymbol);
       if (IS_UNDEFINED(stack_trace)) {
         // Neither formatted nor structured stack trace available.
         // Look further up the prototype chain.
         holder = %_GetPrototype(holder);
         continue;
       }
       formatted_stack_trace = FormatStackTrace(holder, stack_trace);
-      SET_PRIVATE(holder, stack_trace_symbol, UNDEFINED);
+      SET_PRIVATE(holder, $stackTraceSymbol, UNDEFINED);
       SET_PRIVATE(holder, formatted_stack_trace_symbol, formatted_stack_trace);
     }
     return formatted_stack_trace;
   }
   return UNDEFINED;
 };
 
 
 // If the receiver equals the holder, set the formatted stack trace that the
 // getter returns.
 var StackTraceSetter = function(v) {
-  if (HAS_PRIVATE(this, stack_trace_symbol)) {
-    SET_PRIVATE(this, stack_trace_symbol, UNDEFINED);
+  if (HAS_PRIVATE(this, $stackTraceSymbol)) {
+    SET_PRIVATE(this, $stackTraceSymbol, UNDEFINED);
     SET_PRIVATE(this, formatted_stack_trace_symbol, v);
   }
 };
 
 
 // Use a dummy function since we do not actually want to capture a stack trace
 // when constructing the initial Error prototytpes.
 var captureStackTrace = function captureStackTrace(obj, cons_opt) {
   // Define accessors first, as this may fail and throw.
   ObjectDefineProperty(obj, 'stack', { get: StackTraceGetter,
                                        set: StackTraceSetter,
                                        configurable: true });
   %CollectStackTrace(obj, cons_opt ? cons_opt : captureStackTrace);
 }
 
 
-function SetUpError() {
-  // Define special error type constructors.
+// Define special error type constructors.
+function DefineError(f) {
+  // Store the error function in both the global object
+  // and the runtime object. The function is fetched
+  // from the runtime object when throwing errors from
+  // within the runtime system to avoid strange side
+  // effects when overwriting the error functions from
+  // user code.
+  var name = f.name;
+  %AddNamedProperty(global, name, f, DONT_ENUM);
+  // Configure the error function.
+  if (name == 'Error') {
+    // The prototype of the Error object must itself be an error.
+    // However, it can't be an instance of the Error object because
+    // it hasn't been properly configured yet.  Instead we create a
+    // special not-a-true-error-but-close-enough object.
+    var ErrorPrototype = function() {};
+    %FunctionSetPrototype(ErrorPrototype, GlobalObject.prototype);
+    %FunctionSetInstanceClassName(ErrorPrototype, 'Error');
+    %FunctionSetPrototype(f, new ErrorPrototype());
+  } else {
+    %FunctionSetPrototype(f, new GlobalError());
+    %InternalSetPrototype(f, GlobalError);
+  }
+  %FunctionSetInstanceClassName(f, 'Error');
+  %AddNamedProperty(f.prototype, 'constructor', f, DONT_ENUM);
+  %AddNamedProperty(f.prototype, 'name', name, DONT_ENUM);
+  %SetCode(f, function(m) {
+    if (%_IsConstructCall()) {
+      try { captureStackTrace(this, f); } catch (e) { }
+      // Define all the expected properties directly on the error
+      // object. This avoids going through getters and setters defined
+      // on prototype objects.
+      if (!IS_UNDEFINED(m)) {
+        %AddNamedProperty(this, 'message', ToString(m), DONT_ENUM);
+      }
+    } else {
+      return new f(m);
+    }
+  });
+  %SetNativeFlag(f);
+  return f;
+};
 
-  var DefineError = function(f) {
-    // Store the error function in both the global object
-    // and the runtime object. The function is fetched
-    // from the runtime object when throwing errors from
-    // within the runtime system to avoid strange side
-    // effects when overwriting the error functions from
-    // user code.
-    var name = f.name;
-    %AddNamedProperty(global, name, f, DONT_ENUM);
-    %AddNamedProperty(builtins, '$' + name, f,
-                      DONT_ENUM | DONT_DELETE | READ_ONLY);
-    // Configure the error function.
-    if (name == 'Error') {
-      // The prototype of the Error object must itself be an error.
-      // However, it can't be an instance of the Error object because
-      // it hasn't been properly configured yet.  Instead we create a
-      // special not-a-true-error-but-close-enough object.
-      var ErrorPrototype = function() {};
-      %FunctionSetPrototype(ErrorPrototype, $Object.prototype);
-      %FunctionSetInstanceClassName(ErrorPrototype, 'Error');
-      %FunctionSetPrototype(f, new ErrorPrototype());
-    } else {
-      %FunctionSetPrototype(f, new $Error());
-      %InternalSetPrototype(f, $Error);
-    }
-    %FunctionSetInstanceClassName(f, 'Error');
-    %AddNamedProperty(f.prototype, 'constructor', f, DONT_ENUM);
-    %AddNamedProperty(f.prototype, 'name', name, DONT_ENUM);
-    %SetCode(f, function(m) {
-      if (%_IsConstructCall()) {
-        try { captureStackTrace(this, f); } catch (e) { }
-        // Define all the expected properties directly on the error
-        // object. This avoids going through getters and setters defined
-        // on prototype objects.
-        if (!IS_UNDEFINED(m)) {
-          %AddNamedProperty(this, 'message', ToString(m), DONT_ENUM);
-        }
-      } else {
-        return new f(m);
-      }
-    });
-    %SetNativeFlag(f);
-  };
+GlobalError = DefineError(function Error() { });
+GlobalEvalError = DefineError(function EvalError() { });
+GlobalRangeError = DefineError(function RangeError() { });
+GlobalReferenceError = DefineError(function ReferenceError() { });
+GlobalSyntaxError = DefineError(function SyntaxError() { });
+GlobalTypeError = DefineError(function TypeError() { });
+GlobalURIError = DefineError(function URIError() { });
 
-  DefineError(function Error() { });
-  DefineError(function TypeError() { });
-  DefineError(function RangeError() { });
-  DefineError(function SyntaxError() { });
-  DefineError(function ReferenceError() { });
-  DefineError(function EvalError() { });
-  DefineError(function URIError() { });
-}
 
-SetUpError();
+GlobalError.captureStackTrace = captureStackTrace;
 
-$Error.captureStackTrace = captureStackTrace;
-
-%AddNamedProperty($Error.prototype, 'message', '', DONT_ENUM);
+%AddNamedProperty(GlobalError.prototype, 'message', '', DONT_ENUM);
 
 // Global list of error objects visited during ErrorToString. This is
 // used to detect cycles in error toString formatting.
 var visited_errors = new InternalArray();
-var cyclic_error_marker = new $Object();
+var cyclic_error_marker = new GlobalObject();
 
 function GetPropertyWithoutInvokingMonkeyGetters(error, name) {
   var current = error;
   // Climb the prototype chain until we find the holder.
   while (current && !%HasOwnProperty(current, name)) {
     current = %_GetPrototype(current);
   }
   if (IS_NULL(current)) return UNDEFINED;
   if (!IS_OBJECT(current)) return error[name];
   // If the property is an accessor on one of the predefined errors that can be
   // generated statically by the compiler, don't touch it. This is to address
   // http://code.google.com/p/chromium/issues/detail?id=69187
   var desc = %GetOwnProperty(current, name);
   if (desc && desc[IS_ACCESSOR_INDEX]) {
     var isName = name === "name";
-    if (current === $ReferenceError.prototype)
+    if (current === GlobalReferenceError.prototype)
       return isName ? "ReferenceError" : UNDEFINED;
-    if (current === $SyntaxError.prototype)
+    if (current === GlobalSyntaxError.prototype)
       return isName ? "SyntaxError" : UNDEFINED;
-    if (current === $TypeError.prototype)
+    if (current === GlobalTypeError.prototype)
       return isName ? "TypeError" : UNDEFINED;
   }
   // Otherwise, read normally.
   return error[name];
 }
 
 function ErrorToStringDetectCycle(error) {
   if (!%PushIfAbsent(visited_errors, error)) throw cyclic_error_marker;
   try {
     var name = GetPropertyWithoutInvokingMonkeyGetters(error, "name");
@@ skipping 18 matching lines @@
   } catch(e) {
     // If this error message was encountered already return the empty
     // string for it instead of recursively formatting it.
     if (e === cyclic_error_marker) {
       return '';
     }
     throw e;
   }
 }
 
+InstallFunctions(GlobalError.prototype, DONT_ENUM, ['toString', ErrorToString]);
 
-InstallFunctions($Error.prototype, DONT_ENUM, ['toString', ErrorToString]);
+$errorToString = ErrorToString;
+$formatMessage = FormatMessage;
+$getStackTraceLine = GetStackTraceLine;
+$messageGetPositionInLine = GetPositionInLine;
+$messageGetLineNumber = GetLineNumber;
+$messageGetSourceLine = GetSourceLine;
+$toDetailString = ToDetailString;
 
-// Boilerplate for exceptions for stack overflows. Used from
-// Isolate::StackOverflow().
-function SetUpStackOverflowBoilerplate() {
-  var boilerplate = MakeRangeError(kStackOverflow);
+$Error = GlobalError;
+$EvalError = GlobalEvalError;
+$RangeError = GlobalRangeError;
+$ReferenceError = GlobalReferenceError;
+$SyntaxError = GlobalSyntaxError;
+$TypeError = GlobalTypeError;
+$URIError = GlobalURIError;
 
-  %DefineAccessorPropertyUnchecked(
-      boilerplate, 'stack', StackTraceGetter, StackTraceSetter, DONT_ENUM);
-
-  return boilerplate;
+MakeError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalError, type, arg0, arg1, arg2);
 }
 
-var kStackOverflowBoilerplate = SetUpStackOverflowBoilerplate();
+MakeEvalError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalEvalError, type, arg0, arg1, arg2);
+}
+
+MakeRangeError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalRangeError, type, arg0, arg1, arg2);
+}
+
+MakeReferenceError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalReferenceError, type, arg0, arg1, arg2);
+}
+
+MakeSyntaxError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalSyntaxError, type, arg0, arg1, arg2);
+}
+
+MakeTypeError = function(type, arg0, arg1, arg2) {
+  return MakeGenericError(GlobalTypeError, type, arg0, arg1, arg2);
+}
+
+MakeURIError = function() {
+  return MakeGenericError(GlobalURIError, kURIMalformed);
+}
+
+// The embedded versions are called from unoptimized code, with embedded
+// arguments. Those arguments cannot be arrays, which are context-dependent.
+MakeSyntaxErrorEmbedded = function(type, arg) {
+  return MakeGenericError(GlobalSyntaxError, type, [arg]);
+}
+
+MakeReferenceErrorEmbedded = function(type, arg) {
+  return MakeGenericError(GlobalReferenceError, type, [arg]);
+}
+
+MakeTypeErrorEmbedded = function(type, arg) {
+  return MakeGenericError(GlobalTypeError, type, [arg]);
+}
+
+//Boilerplate for exceptions for stack overflows. Used from
+//Isolate::StackOverflow().
+$stackOverflowBoilerplate = MakeRangeError(kStackOverflow);
+%DefineAccessorPropertyUnchecked($stackOverflowBoilerplate, 'stack',
+                                 StackTraceGetter, StackTraceSetter, DONT_ENUM);
+
+})();