{

/// <summary> No instances should be created.</summary>

protected internal ScriptRuntime ()

{

}

public const int MAXSTACKSIZE = 1000;

private static readonly object LIBRARY_SCOPE_KEY = new object ();

public static bool IsNativeRuntimeType (Type cl)

{

if (cl.IsPrimitive) {

return (cl != typeof (char));

}

else {

return (cl == typeof (string) || cl == typeof (bool)

|| CliHelper.IsNumberType (cl)

|| typeof (IScriptable).IsAssignableFrom (cl));

}

}

public static ScriptableObject InitStandardObjects (Context cx, ScriptableObject scope, bool zealed)

{

if (scope == null) {

scope = new BuiltinObject ();

}

scope.AssociateValue (LIBRARY_SCOPE_KEY, scope);

BaseFunction.Init (scope, zealed);

BuiltinObject.Init (scope, zealed);

IScriptable objectProto = ScriptableObject.GetObjectPrototype (scope);

// Function.prototype.__proto__ should be Object.prototype

IScriptable functionProto = ScriptableObject.GetFunctionPrototype (scope);

functionProto.SetPrototype (objectProto);

// Set the prototype of the object passed in if need be

if (scope.GetPrototype () == null)

scope.SetPrototype (objectProto);

// must precede NativeGlobal since it's needed therein

BuiltinError.Init (scope, zealed);

BuiltinGlobal.Init (cx, scope, zealed);

if (scope is BuiltinGlobalObject) {

((BuiltinGlobalObject)scope).Init (scope, zealed);

}

BuiltinArray.Init (scope, zealed);

BuiltinString.Init (scope, zealed);

BuiltinBoolean.Init (scope, zealed);

BuiltinNumber.Init (scope, zealed);

BuiltinDate.Init (scope, zealed);

BuiltinMath.Init (scope, zealed);

BuiltinWith.Init (scope, zealed);

BuiltinCall.Init (scope, zealed);

BuiltinScript.Init (scope, zealed);

BuiltinRegExp.Init (scope, zealed);

if (cx.HasFeature (Context.Features.E4x)) {

Types.E4X.XMLLib.Init (scope, zealed);

}

Continuation.Init (scope, zealed);

if (cx.HasFeature (Context.Features.NonEcmaItObject)) {

InitItObject (cx, scope);

}

return scope;

}

static void InitItObject (Context cx, ScriptableObject scope) {

BuiltinObject itObj = new BuiltinObject ();

itObj.SetPrototype (scope);

itObj.DefineProperty ("color", Undefined.Value, ScriptableObject.PERMANENT);

itObj.DefineProperty ("height", Undefined.Value, ScriptableObject.PERMANENT);

itObj.DefineProperty ("width", Undefined.Value, ScriptableObject.PERMANENT);

itObj.DefineProperty ("funny", Undefined.Value, ScriptableObject.PERMANENT);

itObj.DefineProperty ("array", Undefined.Value, ScriptableObject.PERMANENT);

itObj.DefineProperty ("rdonly", Undefined.Value, ScriptableObject.READONLY);

scope.DefineProperty ("it", itObj, ScriptableObject.PERMANENT);

}

public static ScriptableObject getLibraryScopeOrNull (IScriptable scope)

{

ScriptableObject libScope;

libScope = (ScriptableObject)ScriptableObject.GetTopScopeValue (scope, LIBRARY_SCOPE_KEY);

return libScope;

}

// It is public so NativeRegExp can access it .

public static bool isJSLineTerminator (int c)

{

// Optimization for faster check for eol character:

// they do not have 0xDFD0 bits set

if ((c & 0xDFD0) != 0) {

return false;

}

return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;

}

/// <summary> Helper function for builtin objects that use the varargs form.

/// ECMA function formal arguments are undefined if not supplied;

/// this function pads the argument array out to the expected

/// length, if necessary.

/// </summary>

public static object [] padArguments (object [] args, int count)

{

if (count < args.Length)

return args;

int i;

object [] result = new object [count];

for (i = 0; i < args.Length; i++) {

result [i] = args [i];

}

for (; i < count; i++) {

result [i] = Undefined.Value;

}

return result;

}

public static string escapeString (string s)

{

return escapeString (s, '"');

}

/// <summary> For escaping strings printed by object and array literals; not quite

/// the same as 'escape.'

/// </summary>

public static string escapeString (string s, char escapeQuote)

{

if (!(escapeQuote == '"' || escapeQuote == '\''))

Context.CodeBug ();

System.Text.StringBuilder sb = null;

for (int i = 0, L = s.Length; i != L; ++i) {

int c = s [i];

if (' ' <= c && c <= '~' && c != escapeQuote && c != '\\') {

// an ordinary print character (like C isprint()) and not "

// or \ .

if (sb != null) {

sb.Append ((char)c);

}

continue;

}

if (sb == null) {

sb = new System.Text.StringBuilder (L + 3);

sb.Append (s);

sb.Length = i;

}

int escape = -1;

switch (c) {

case '\b':

escape = 'b';

break;

case '\f':

escape = 'f';

break;

case '\n':

escape = 'n';

break;

case '\r':

escape = 'r';

break;

case '\t':

escape = 't';

break;

case 0xb:

escape = 'v';

break; // Java lacks \v.

case ' ':

escape = ' ';

break;

case '\\':

escape = '\\';

break;

}

if (escape >= 0) {

// an \escaped sort of character

sb.Append ('\\');

sb.Append ((char)escape);

}

else if (c == escapeQuote) {

sb.Append ('\\');

sb.Append (escapeQuote);

}

else {

int hexSize;

if (c < 256) {

// 2-digit hex

sb.Append ("\\x");

hexSize = 2;

}

else {

// Unicode.

sb.Append ("\\u");

hexSize = 4;

}

// append hexadecimal form of c left-padded with 0

for (int shift = (hexSize - 1) * 4; shift >= 0; shift -= 4) {

int digit = 0xf & (c >> shift);

int hc = (digit < 10) ? '0' + digit : 'a' - 10 + digit;

sb.Append ((char)hc);

}

}

}

return (sb == null) ? s : sb.ToString ();

}

internal static bool isValidIdentifierName (string s)

{

int L = s.Length;

if (L == 0)

return false;

if (!(char.IsLetter (s [0]) || s [0].CompareTo ('$') == 0 || s [0].CompareTo ('_') == 0))

return false;

for (int i = 1; i != L; ++i) {

if (!TokenStream.IsJavaIdentifierPart (s [i]))

return false;

}

return !TokenStream.isKeyword (s);

}

internal static string DefaultObjectToString (IScriptable obj)

{

return "[object " + obj.ClassName + ']';

}

internal static string uneval (Context cx, IScriptable scope, object value)

{

if (value == null) {

return "null";

}

if (value == Undefined.Value) {

return "undefined";

}

if (value is string) {

string escaped = escapeString ((string)value);

System.Text.StringBuilder sb = new System.Text.StringBuilder (escaped.Length + 2);

sb.Append ('\"');

sb.Append (escaped);

sb.Append ('\"');

return sb.ToString ();

}

if (CliHelper.IsNumber (value)) {

double d = Convert.ToDouble (value);

if (d == 0 && 1 / d < 0) {

return "-0";

}

return ScriptConvert.ToString (d);

}

if (value is bool) {

return ScriptConvert.ToString (value);

}

if (value is IScriptable) {

IScriptable obj = (IScriptable)value;

object v = ScriptableObject.GetProperty (obj, "toSource");

if (v is IFunction) {

IFunction f = (IFunction)v;

return ScriptConvert.ToString (f.Call (cx, scope, obj, EmptyArgs));

}

return ScriptConvert.ToString (value);

}

WarnAboutNonJSObject (value);

return value.ToString ();

}

internal static string defaultObjectToSource (Context cx, IScriptable scope, IScriptable thisObj, object [] args)

{

using (Helpers.StackOverflowVerifier sov = new Helpers.StackOverflowVerifier (1024)) {

bool toplevel, iterating;

if (cx.iterating == null) {

toplevel = true;

iterating = false;

cx.iterating = new ObjToIntMap (31);

}

else {

toplevel = false;

iterating = cx.iterating.has (thisObj);

}

System.Text.StringBuilder result = new System.Text.StringBuilder (128);

if (toplevel) {

result.Append ("(");

}

result.Append ('{');

// Make sure cx.iterating is set to null when done

// so we don't leak memory

try {

if (!iterating) {

cx.iterating.intern (thisObj); // stop recursion.

object [] ids = thisObj.GetIds ();

for (int i = 0; i < ids.Length; i++) {

if (i > 0)

result.Append (", ");

object id = ids [i];

object value;

if (id is int) {

int intId = ((int)id);

value = thisObj.Get (intId, thisObj);

result.Append (intId);

}

else {

string strId = (string)id;

value = thisObj.Get (strId, thisObj);

if (ScriptRuntime.isValidIdentifierName (strId)) {

result.Append (strId);

}

else {

result.Append ('\'');

result.Append (ScriptRuntime.escapeString (strId, '\''));

result.Append ('\'');

}

}

result.Append (':');

result.Append (ScriptRuntime.uneval (cx, scope, value));

}

}

}

finally {

if (toplevel) {

cx.iterating = null;

}

}

result.Append ('}');

if (toplevel) {

result.Append (')');

}

return result.ToString ();

}

}

public static IScriptable NewObject (Context cx, IScriptable scope, string constructorName, object [] args)

{

scope = ScriptableObject.GetTopLevelScope (scope);

IFunction ctor = getExistingCtor (cx, scope, constructorName);

if (args == null) {

args = ScriptRuntime.EmptyArgs;

}

return ctor.Construct (cx, scope, args);

}

// TODO: this is until setDefaultNamespace will learn how to store NS

// TODO: properly and separates namespace form Scriptable.get etc.

private const string DEFAULT_NS_TAG = "__default_namespace__";

public static object setDefaultNamespace (object ns, Context cx)

{

IScriptable scope = cx.currentActivationCall;

if (scope == null) {

scope = getTopCallScope (cx);

}

XMLLib xmlLib = CurrentXMLLib (cx);

object obj = xmlLib.ToDefaultXmlNamespace (cx, ns);

// TODO: this should be in separated namesapce from Scriptable.get/put

if (!scope.Has (DEFAULT_NS_TAG, scope)) {

// TODO: this is racy of cause

ScriptableObject.DefineProperty (scope, DEFAULT_NS_TAG, obj, ScriptableObject.PERMANENT | ScriptableObject.DONTENUM);

}

else {

scope.Put (DEFAULT_NS_TAG, scope, obj);

}

return Undefined.Value;

}

public static object searchDefaultNamespace (Context cx)

{

IScriptable scope = cx.currentActivationCall;

if (scope == null) {

scope = getTopCallScope (cx);

}

object nsObject;

for (; ; ) {

IScriptable parent = scope.ParentScope;

if (parent == null) {

nsObject = ScriptableObject.GetProperty (scope, DEFAULT_NS_TAG);

if (nsObject == UniqueTag.NotFound) {

return null;

}

break;

}

nsObject = scope.Get (DEFAULT_NS_TAG, scope);

if (nsObject != UniqueTag.NotFound) {

break;

}

scope = parent;

}

return nsObject;

}

public static object getTopLevelProp (IScriptable scope, string id)

{

scope = ScriptableObject.GetTopLevelScope (scope);

return ScriptableObject.GetProperty (scope, id);

}

internal static IFunction getExistingCtor (Context cx, IScriptable scope, string constructorName)

{

object ctorVal = ScriptableObject.GetProperty (scope, constructorName);

if (ctorVal is IFunction) {

return (IFunction)ctorVal;

}

if (ctorVal == UniqueTag.NotFound) {

throw Context.ReportRuntimeErrorById ("msg.ctor.not.found", constructorName);

}

else {

throw Context.ReportRuntimeErrorById ("msg.not.ctor", constructorName);

}

}

/// <summary> Return -1L if str is not an index or the index value as lower 32

/// bits of the result.

/// </summary>

private static long indexFromString (string str)

{

// The length of the decimal string representation of

// Integer.MAX_VALUE, 2147483647

const int MAX_VALUE_LENGTH = 10;

int len = str.Length;

if (len > 0) {

int i = 0;

bool negate = false;

int c = str [0];

if (c == '-') {

if (len > 1) {

c = str [1];

i = 1;

negate = true;

}

}

c -= '0';

if (0 <= c && c <= 9 && len <= (negate ? MAX_VALUE_LENGTH + 1 : MAX_VALUE_LENGTH)) {

// Use negative numbers to accumulate index to handle

// Integer.MIN_VALUE that is greater by 1 in absolute value

// then Integer.MAX_VALUE

int index = -c;

int oldIndex = 0;

i++;

if (index != 0) {

// Note that 00, 01, 000 etc. are not indexes

while (i != len && 0 <= (c = str [i] - '0') && c <= 9) {

oldIndex = index;

index = 10 * index - c;

i++;

}

}

// Make sure all characters were consumed and that it couldn't

// have overflowed.

if (i == len && (oldIndex > (int.MinValue / 10) || (oldIndex == (int.MinValue / 10) && c <= (negate ? -(int.MinValue % 10) : (int.MaxValue % 10))))) {

return unchecked ((int)0xFFFFFFFFL) & (negate ? index : -index);

}

}

}

return -1L;

}

/// <summary> If str is a decimal presentation of Uint32 value, return it as long.

/// Othewise return -1L;

/// </summary>

public static long testUint32String (string str)

{

// The length of the decimal string representation of

// UINT32_MAX_VALUE, 4294967296

const int MAX_VALUE_LENGTH = 10;

int len = str.Length;

if (1 <= len && len <= MAX_VALUE_LENGTH) {

int c = str [0];

c -= '0';

if (c == 0) {

// Note that 00,01 etc. are not valid Uint32 presentations

return (len == 1) ? 0L : -1L;

}

if (1 <= c && c <= 9) {

long v = c;

for (int i = 1; i != len; ++i) {

c = str [i] - '0';

if (!(0 <= c && c <= 9)) {

return -1;

}

v = 10 * v + c;

}

// Check for overflow

if ((ulong)v >> 32 == 0) {

return v;

}

}

}

return -1;

}

/// <summary> If s represents index, then return index value wrapped as Integer

/// and othewise return s.

/// </summary>

internal static object getIndexObject (string s)

{

long indexTest = indexFromString (s);

if (indexTest >= 0) {

return (int)indexTest;

}

return s;

}

/// <summary> If d is exact int value, return its value wrapped as Integer

/// and othewise return d converted to String.

/// </summary>

internal static object getIndexObject (double d)

{

int i = (int)d;

if ((double)i == d) {

return (int)i;

}

return ScriptConvert.ToString (d);

}

/// <summary> If ScriptConvert.ToString(id) is a decimal presentation of int32 value, then id

/// is index. In this case return null and make the index available

/// as ScriptRuntime.lastIndexResult(cx). Otherwise return ScriptConvert.ToString(id).

/// </summary>

internal static string ToStringIdOrIndex (Context cx, object id)

{

if (CliHelper.IsNumber (id)) {

double d = Convert.ToDouble (id);

int index = (int)d;

if (((double)index) == d) {

storeIndexResult (cx, index);

return null;

}

return ScriptConvert.ToString (id);

}

else {

string s;

if (id is string) {

s = ((string)id);

}

else {

s = ScriptConvert.ToString (id);

}

long indexTest = indexFromString (s);

if (indexTest >= 0) {

storeIndexResult (cx, (int)indexTest);

return null;

}

return s;

}

}

/// <summary> Call obj.[[Get]](id)</summary>

public static object getObjectElem (object obj, object elem, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefReadError (obj, elem);

}

return getObjectElem (sobj, elem, cx);

}

public static object getObjectElem (IScriptable obj, object elem, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

return xmlObject.EcmaGet (cx, elem);

}

object result;

string s = ScriptRuntime.ToStringIdOrIndex (cx, elem);

if (s == null) {

int index = lastIndexResult (cx);

result = ScriptableObject.GetProperty (obj, index);

}

else {

result = ScriptableObject.GetProperty (obj, s);

}

if (result == UniqueTag.NotFound) {

result = Undefined.Value;

}

return result;

}

/// <summary> Version of getObjectElem when elem is a valid JS identifier name.</summary>

public static object getObjectProp (object obj, string property, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefReadError (obj, property);

}

return getObjectProp (sobj, property, cx);

}

public static object getObjectProp (IScriptable obj, string property, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

return xmlObject.EcmaGet (cx, property);

}

object result = ScriptableObject.GetProperty (obj, property);

if (result == UniqueTag.NotFound) {

result = Undefined.Value;

}

return result;

}

/*

public static object getObjectIndex (object obj, double dblIndex, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefReadError (obj, ScriptConvert.ToString (dblIndex));

}

int index = (int)dblIndex;

if ((double)index == dblIndex) {

return getObjectIndex (sobj, index, cx);

}

else {

string s = ScriptConvert.ToString (dblIndex);

return getObjectProp (sobj, s, cx);

}

}

public static object getObjectIndex (IScriptable obj, int index, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

return xmlObject.EcmaGet (cx, (object)index);

}

object result = ScriptableObject.GetProperty (obj, index);

if (result == UniqueTag.NotFound) {

result = Undefined.Value;

}

return result;

}

/*

public static object setObjectElem (object obj, object elem, object value, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefWriteError (obj, elem, value);

}

return setObjectElem (sobj, elem, value, cx);

}

public static object setObjectElem (IScriptable obj, object elem, object value, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

xmlObject.EcmaPut (cx, elem, value);

return value;

}

string s = ScriptRuntime.ToStringIdOrIndex (cx, elem);

if (s == null) {

int index = lastIndexResult (cx);

ScriptableObject.PutProperty (obj, index, value);

}

else {

ScriptableObject.PutProperty (obj, s, value);

}

return value;

}

/// <summary> Version of setObjectElem when elem is a valid JS identifier name.</summary>

public static object setObjectProp (object obj, string property, object value, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefWriteError (obj, property, value);

}

return setObjectProp (sobj, property, value, cx);

}

public static object setObjectProp (IScriptable obj, string property, object value, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

xmlObject.EcmaPut (cx, property, value);

}

else {

return ScriptableObject.PutProperty (obj, property, value);

}

return value;

}

/*

public static object setObjectIndex (object obj, double dblIndex, object value, Context cx)

{

IScriptable sobj = ScriptConvert.ToObjectOrNull (cx, obj);

if (sobj == null) {

throw UndefWriteError (obj, Convert.ToString (dblIndex), value);

}

int index = (int)dblIndex;

if ((double)index == dblIndex) {

return setObjectIndex (sobj, index, value, cx);

}

else {

string s = ScriptConvert.ToString (dblIndex);

return setObjectProp (sobj, s, value, cx);

}

}

public static object setObjectIndex (IScriptable obj, int index, object value, Context cx)

{

if (obj is XMLObject) {

XMLObject xmlObject = (XMLObject)obj;

xmlObject.EcmaPut (cx, (object)index, value);

}

else {

return ScriptableObject.PutProperty (obj, index, value);

}

return value;

}

public static bool deleteObjectElem (IScriptable target, object elem, Context cx)

{

bool result;

if (target is XMLObject) {

XMLObject xmlObject = (XMLObject)target;

result = xmlObject.EcmaDelete (cx, elem);

}

else {

string s = ScriptRuntime.ToStringIdOrIndex (cx, elem);

if (s == null) {

int index = lastIndexResult (cx);

result = ScriptableObject.DeleteProperty (target, index);

}

else {

result = ScriptableObject.DeleteProperty (target, s);

}

}

return result;

}

public static bool hasObjectElem (IScriptable target, object elem, Context cx)