// -------------------------------------------------------------------
+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"],
// 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) {
}
var objToString = %GetDataProperty(obj, "toString");
- return obj instanceof $Error && objToString === ErrorToString;
+ return obj instanceof GlobalError && objToString === ErrorToString;
}
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.
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 {
return constructorName;
}
-
-var stack_trace_symbol; // Set during bootstrapping.
var formatted_stack_trace_symbol = NEW_PRIVATE_OWN("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.
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;
// 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);
}
};
}
-function SetUpError() {
- // Define special error type constructors.
-
- 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());
+// 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 {
- %FunctionSetPrototype(f, new $Error());
- %InternalSetPrototype(f, $Error);
+ return new f(m);
}
- %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);
- };
-
- DefineError(function Error() { });
- DefineError(function TypeError() { });
- DefineError(function RangeError() { });
- DefineError(function SyntaxError() { });
- DefineError(function ReferenceError() { });
- DefineError(function EvalError() { });
- DefineError(function URIError() { });
-}
+ });
+ %SetNativeFlag(f);
+ return f;
+};
-SetUpError();
+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() { });
-$Error.captureStackTrace = captureStackTrace;
-%AddNamedProperty($Error.prototype, 'message', '', DONT_ENUM);
+GlobalError.captureStackTrace = captureStackTrace;
+
+%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;
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.
}
}
+InstallFunctions(GlobalError.prototype, DONT_ENUM, ['toString', ErrorToString]);
+
+$errorToString = ErrorToString;
+$formatMessage = FormatMessage;
+$getStackTraceLine = GetStackTraceLine;
+$messageGetPositionInLine = GetPositionInLine;
+$messageGetLineNumber = GetLineNumber;
+$messageGetSourceLine = GetSourceLine;
+$toDetailString = ToDetailString;
+
+$Error = GlobalError;
+$EvalError = GlobalEvalError;
+$RangeError = GlobalRangeError;
+$ReferenceError = GlobalReferenceError;
+$SyntaxError = GlobalSyntaxError;
+$TypeError = GlobalTypeError;
+$URIError = GlobalURIError;
+
+MakeError = function(type, arg0, arg1, arg2) {
+ return MakeGenericError(GlobalError, type, arg0, arg1, arg2);
+}
+
+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);
+}
-InstallFunctions($Error.prototype, DONT_ENUM, ['toString', ErrorToString]);
+MakeReferenceError = function(type, arg0, arg1, arg2) {
+ return MakeGenericError(GlobalReferenceError, type, arg0, arg1, arg2);
+}
-// Boilerplate for exceptions for stack overflows. Used from
-// Isolate::StackOverflow().
-function SetUpStackOverflowBoilerplate() {
- var boilerplate = MakeRangeError(kStackOverflow);
+MakeSyntaxError = function(type, arg0, arg1, arg2) {
+ return MakeGenericError(GlobalSyntaxError, type, arg0, arg1, arg2);
+}
- %DefineAccessorPropertyUnchecked(
- boilerplate, 'stack', StackTraceGetter, StackTraceSetter, DONT_ENUM);
+MakeTypeError = function(type, arg0, arg1, arg2) {
+ return MakeGenericError(GlobalTypeError, type, arg0, arg1, arg2);
+}
- return boilerplate;
+MakeURIError = function() {
+ return MakeGenericError(GlobalURIError, kURIMalformed);
}
-var kStackOverflowBoilerplate = SetUpStackOverflowBoilerplate();
+// 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);
+
+})();
projects / platform / upstream / v8.git / commitdiff