| public static DoubleToInt64 ( double val ) : System.Int64 | ||
| val | double | |
| return | System.Int64 | |
internal object exec(string input)
{
Match match = null;
if (!this.globalInt)
{
match = this.regex.Match(input);
}
else
{
int startat = (int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(this.lastIndexInt));
if (startat <= 0)
{
match = this.regex.Match(input);
}
else if (startat <= input.Length)
{
match = this.regex.Match(input, startat);
}
}
if ((match == null) || !match.Success)
{
this.lastIndexInt = 0;
return(DBNull.Value);
}
this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
return(new RegExpMatch(this.regExpConst.arrayPrototype, this.regex, match, input));
}
public int Compare(Object x, Object y)
{
if (x == null || x is Missing)
{
if (y == null || y is Missing)
{
return(0);
}
else
{
return(1);
}
}
else if (y == null || y is Missing)
{
return(-1);
}
if (this.compareFn != null)
{
double result = Convert.ToNumber(this.compareFn.Call(new Object[] { x, y }, null));
if (result != result)
{
throw new JScriptException(JSError.NumberExpected);
}
return((int)Runtime.DoubleToInt64(result));
}
else
{
return(String.CompareOrdinal(Convert.ToString(x), Convert.ToString(y)));
}
}
internal bool test(string input)
{
Match match = null;
if (!this.globalInt)
{
match = this.regex.Match(input);
}
else
{
int startat = (int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(this.lastIndexInt));
if (startat <= 0)
{
match = this.regex.Match(input);
}
else if (startat <= input.Length)
{
match = this.regex.Match(input, startat);
}
}
if ((match == null) || !match.Success)
{
this.lastIndexInt = 0;
return(false);
}
this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
return(true);
}
internal bool test(String input)
{
Match match = null;
if (!this.globalInt)
{
match = this.regex.Match(input);
}
else
{
int lastIndex = (int)Runtime.DoubleToInt64(Convert.ToInteger(this.lastIndexInt));
if (lastIndex <= 0)
{
match = this.regex.Match(input);
}
else if (lastIndex <= input.Length)
{
match = this.regex.Match(input, lastIndex);
}
}
if (match == null || !match.Success)
{
this.lastIndexInt = 0;
return(false);
}
this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
return(true);
}
internal Object exec(String input)
{
Match match = null;
if (!this.globalInt)
{
match = this.regex.Match(input);
}
else
{
int lastIndex = (int)Runtime.DoubleToInt64(Convert.ToInteger(this.lastIndexInt));
if (lastIndex <= 0)
{
match = this.regex.Match(input);
}
else if (lastIndex <= input.Length)
{
match = this.regex.Match(input, lastIndex);
}
}
if (match == null || !match.Success)
{
this.lastIndexInt = 0;
return(DBNull.Value);
}
this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
return(new RegExpMatch(this.regExpConst.arrayPrototype, this.regex, match, input));
}
public static object DoOp(object v1, object v2)
{
IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v1);
IConvertible ic = Microsoft.JScript.Convert.GetIConvertible(v2);
v1 = Microsoft.JScript.Convert.ToPrimitive(v1, PreferredType.Either, ref iConvertible);
v2 = Microsoft.JScript.Convert.ToPrimitive(v2, PreferredType.Either, ref ic);
TypeCode typeCode = Microsoft.JScript.Convert.GetTypeCode(v1, iConvertible);
TypeCode tc = Microsoft.JScript.Convert.GetTypeCode(v2, ic);
if (typeCode == TypeCode.String)
{
if (v1 is ConcatString)
{
return(new ConcatString((ConcatString)v1, Microsoft.JScript.Convert.ToString(v2, ic)));
}
return(new ConcatString(iConvertible.ToString(null), Microsoft.JScript.Convert.ToString(v2, ic)));
}
if (tc == TypeCode.String)
{
return(Microsoft.JScript.Convert.ToString(v1, iConvertible) + ic.ToString(null));
}
if ((typeCode == TypeCode.Char) && (tc == TypeCode.Char))
{
return(iConvertible.ToString(null) + ic.ToString(null));
}
if (((typeCode != TypeCode.Char) || (!Microsoft.JScript.Convert.IsPrimitiveNumericTypeCode(tc) && (tc != TypeCode.Boolean))) && ((tc != TypeCode.Char) || (!Microsoft.JScript.Convert.IsPrimitiveNumericTypeCode(typeCode) && (typeCode != TypeCode.Boolean))))
{
return(Microsoft.JScript.Convert.ToNumber(v1, iConvertible) + Microsoft.JScript.Convert.ToNumber(v2, ic));
}
return((char)((int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToNumber(v1, iConvertible) + Microsoft.JScript.Convert.ToNumber(v2, ic))));
}
private int Compare(object x, object y)
{
if ((x == null) || (x is Missing))
{
if ((y != null) && !(y is Missing))
{
return(1);
}
return(0);
}
if ((y == null) || (y is Missing))
{
return(-1);
}
if (this.compareFn == null)
{
return(string.CompareOrdinal(Microsoft.JScript.Convert.ToString(x), Microsoft.JScript.Convert.ToString(y)));
}
double val = Microsoft.JScript.Convert.ToNumber(this.compareFn.Call(new object[] { x, y }, null));
if (val != val)
{
throw new JScriptException(JSError.NumberExpected);
}
return((int)Runtime.DoubleToInt64(val));
}
public static ArrayObject slice(Object thisob, VsaEngine engine, double start, Object end)
{
ArrayObject array = engine.GetOriginalArrayConstructor().Construct();
uint length = Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
// compute the start index
long startIndex = Runtime.DoubleToInt64(Convert.ToInteger(start));
if (startIndex < 0)
{
startIndex = length + startIndex;
if (startIndex < 0)
{
startIndex = 0;
}
}
else if (startIndex > length)
{
startIndex = length;
}
// compute the end index
long endIndex = length;
if (end != null && !(end is Missing))
{
endIndex = Runtime.DoubleToInt64(Convert.ToInteger(end));
if (endIndex < 0)
{
endIndex = length + endIndex;
if (endIndex < 0)
{
endIndex = 0;
}
}
else if (endIndex > length)
{
endIndex = length;
}
}
// slice
if (endIndex > startIndex)
{
array.length = endIndex - startIndex;
for (ulong i = (ulong)startIndex, j = 0; i < (ulong)endIndex; i++, j++)
{
Object val = LateBinding.GetValueAtIndex(thisob, i);
if (!(val is Missing))
{
LateBinding.SetValueAtIndex(array, j, val);
}
}
}
return(array);
}
public static ArrayObject slice(object thisob, VsaEngine engine, double start, object end)
{
ArrayObject obj2 = engine.GetOriginalArrayConstructor().Construct();
uint num = Microsoft.JScript.Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
long num2 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(start));
if (num2 < 0L)
{
num2 = num + num2;
if (num2 < 0L)
{
num2 = 0L;
}
}
else if (num2 > num)
{
num2 = num;
}
long num3 = num;
if ((end != null) && !(end is Missing))
{
num3 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(end));
if (num3 < 0L)
{
num3 = num + num3;
if (num3 < 0L)
{
num3 = 0L;
}
}
else if (num3 > num)
{
num3 = num;
}
}
if (num3 > num2)
{
obj2.length = num3 - num2;
ulong index = (ulong)num2;
for (ulong i = 0L; index < num3; i += (ulong)1L)
{
object valueAtIndex = LateBinding.GetValueAtIndex(thisob, index);
if (!(valueAtIndex is Missing))
{
LateBinding.SetValueAtIndex(obj2, i, valueAtIndex);
}
index += (ulong)1L;
}
}
return(obj2);
}
public new DateObject CreateInstance(params Object[] args)
{
if (args.Length == 0)
{
return(new DateObject(this.originalPrototype, DateTime.Now.ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970));
}
if (args.Length == 1)
{
Object arg0 = args[0];
IConvertible ic = Convert.GetIConvertible(arg0);
TypeCode tcode = Convert.GetTypeCode(arg0, ic);
if (tcode == TypeCode.DateTime)
{
return(new DateObject(this.originalPrototype, ic.ToDateTime(null).ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970));
}
Object yv = Convert.ToPrimitive(arg0, PreferredType.Either, ref ic);
if (Convert.GetTypeCode(yv, ic) == TypeCode.String)
{
return(new DateObject(this.originalPrototype, parse(ic.ToString(null))));
}
double d = Convert.ToNumber(yv, ic);
if (DatePrototype.minDate <= d && d <= DatePrototype.maxDate)
{
return(new DateObject(this.originalPrototype, d));
}
return(new DateObject(this.originalPrototype, Double.NaN));
}
double dyear = Convert.ToNumber(args[0]);
double dmonth = Convert.ToNumber(args[1]);
double ddate = (args.Length > 2) ? Convert.ToNumber(args[2]) : 1;
double dhours = (args.Length > 3) ? Convert.ToNumber(args[3]) : 0;
double dminutes = (args.Length > 4) ? Convert.ToNumber(args[4]) : 0;
double dseconds = (args.Length > 5) ? Convert.ToNumber(args[5]) : 0;
double dms = (args.Length > 6) ? Convert.ToNumber(args[6]) : 0;
int y = (int)Runtime.DoubleToInt64(dyear);
if (!Double.IsNaN(dyear) && 0 <= y && y <= 99)
{
dyear = y + 1900;
}
double day = DatePrototype.MakeDay(dyear, dmonth, ddate);
double time = DatePrototype.MakeTime(dhours, dminutes, dseconds, dms);
return(new DateObject(this.originalPrototype, DatePrototype.TimeClip(DatePrototype.UTC(DatePrototype.MakeDate(day, time)))));
}
public DateObject CreateInstance(params object[] args)
{
if (args.Length == 0)
{
return(new DateObject(this.originalPrototype, (((double)DateTime.Now.ToUniversalTime().Ticks) / 10000.0) - 62135596800000));
}
if (args.Length == 1)
{
object ob = args[0];
IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(ob);
if (Microsoft.JScript.Convert.GetTypeCode(ob, iConvertible) == TypeCode.DateTime)
{
return(new DateObject(this.originalPrototype, (((double)iConvertible.ToDateTime(null).ToUniversalTime().Ticks) / 10000.0) - 62135596800000));
}
object obj3 = Microsoft.JScript.Convert.ToPrimitive(ob, PreferredType.Either, ref iConvertible);
if (Microsoft.JScript.Convert.GetTypeCode(obj3, iConvertible) == TypeCode.String)
{
return(new DateObject(this.originalPrototype, parse(iConvertible.ToString(null))));
}
double num = Microsoft.JScript.Convert.ToNumber(obj3, iConvertible);
if ((-8.64E+15 <= num) && (num <= 8.64E+15))
{
return(new DateObject(this.originalPrototype, num));
}
return(new DateObject(this.originalPrototype, double.NaN));
}
double val = Microsoft.JScript.Convert.ToNumber(args[0]);
double month = Microsoft.JScript.Convert.ToNumber(args[1]);
double date = (args.Length > 2) ? Microsoft.JScript.Convert.ToNumber(args[2]) : 1.0;
double hour = (args.Length > 3) ? Microsoft.JScript.Convert.ToNumber(args[3]) : 0.0;
double min = (args.Length > 4) ? Microsoft.JScript.Convert.ToNumber(args[4]) : 0.0;
double sec = (args.Length > 5) ? Microsoft.JScript.Convert.ToNumber(args[5]) : 0.0;
double ms = (args.Length > 6) ? Microsoft.JScript.Convert.ToNumber(args[6]) : 0.0;
int num9 = (int)Runtime.DoubleToInt64(val);
if ((!double.IsNaN(val) && (0 <= num9)) && (num9 <= 0x63))
{
val = num9 + 0x76c;
}
double day = DatePrototype.MakeDay(val, month, date);
double time = DatePrototype.MakeTime(hour, min, sec, ms);
return(new DateObject(this.originalPrototype, DatePrototype.TimeClip(DatePrototype.UTC(DatePrototype.MakeDate(day, time)))));
}
public static Object DoOp(Object v1, Object v2)
{
IConvertible ic1 = Convert.GetIConvertible(v1);
IConvertible ic2 = Convert.GetIConvertible(v2);
v1 = Convert.ToPrimitive(v1, PreferredType.Either, ref ic1);
v2 = Convert.ToPrimitive(v2, PreferredType.Either, ref ic2);
TypeCode t1 = Convert.GetTypeCode(v1, ic1);
TypeCode t2 = Convert.GetTypeCode(v2, ic2);
if (t1 == TypeCode.String)
{
if (v1 is ConcatString)
{
return(new ConcatString((ConcatString)v1, Convert.ToString(v2, ic2)));
}
else
{
return(new ConcatString(ic1.ToString(null), Convert.ToString(v2, ic2)));
}
}
else if (t2 == TypeCode.String)
{
return(Convert.ToString(v1, ic1) + ic2.ToString(null));
}
else if (t1 == TypeCode.Char && t2 == TypeCode.Char)
{
return(ic1.ToString(null) + ic2.ToString(null));
}
else if ((t1 == TypeCode.Char && (Convert.IsPrimitiveNumericTypeCode(t2) || t2 == TypeCode.Boolean)) ||
(t2 == TypeCode.Char && (Convert.IsPrimitiveNumericTypeCode(t1) || t1 == TypeCode.Boolean)))
{
return((char)(int)Runtime.DoubleToInt64(Convert.ToNumber(v1, ic1) + Convert.ToNumber(v2, ic2)));
}
else
{
return(Convert.ToNumber(v1, ic1) + Convert.ToNumber(v2, ic2));
}
}
public static String substr(Object thisob, double start, Object count)
{
String thisStr = thisob as String;
if (thisStr == null)
{
thisStr = Convert.ToString(thisob);
}
int length = thisStr.Length;
double startIndex = Convert.ToInteger(start);
if (startIndex < 0)
{
startIndex += length;
}
if (startIndex < 0)
{
startIndex = 0;
}
else if (startIndex > length)
{
startIndex = length;
}
int nChars = count is int?(int)count:
((count == null || count is Missing) ? length - (int)Runtime.DoubleToInt64(startIndex) : (int)Runtime.DoubleToInt64(Convert.ToInteger(count)));
if (startIndex + nChars > length)
{
nChars = length - (int)startIndex;
}
if (nChars <= 0)
{
return("");
}
else
{
return(thisStr.Substring((int)startIndex, nChars));
}
}
public static double UTC(object year, object month, object date, object hours, object minutes, object seconds, object ms)
{
if (year is Missing)
{
return((((double)DateTime.Now.ToUniversalTime().Ticks) / 10000.0) - 62135596800000);
}
double val = Microsoft.JScript.Convert.ToNumber(year);
double num2 = (month is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(month);
double num3 = (date is Missing) ? 1.0 : Microsoft.JScript.Convert.ToNumber(date);
double hour = (hours is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(hours);
double min = (minutes is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(minutes);
double sec = (seconds is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(seconds);
double num7 = (ms is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(ms);
int num8 = (int)Runtime.DoubleToInt64(val);
if ((!double.IsNaN(val) && (0 <= num8)) && (num8 <= 0x63))
{
val = num8 + 0x76c;
}
double day = DatePrototype.MakeDay(val, num2, num3);
double time = DatePrototype.MakeTime(hour, min, sec, num7);
return(DatePrototype.TimeClip(DatePrototype.MakeDate(day, time)));
}
public static double UTC(Object year, Object month, Object date, Object hours, Object minutes, Object seconds, Object ms)
{
if (year is Missing)
{
return(DateTime.Now.ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970);
}
double dyear = Convert.ToNumber(year);
double dmonth = month is Missing ? 0 : Convert.ToNumber(month);
double ddate = date is Missing ? 1 : Convert.ToNumber(date);
double dhours = hours is Missing ? 0 : Convert.ToNumber(hours);
double dminutes = minutes is Missing ? 0 : Convert.ToNumber(minutes);
double dseconds = seconds is Missing ? 0 : Convert.ToNumber(seconds);
double dms = ms is Missing ? 0 : Convert.ToNumber(ms);
int y = (int)Runtime.DoubleToInt64(dyear);
if (!Double.IsNaN(dyear) && 0 <= y && y <= 99)
{
dyear = y + 1900;
}
double day = DatePrototype.MakeDay(dyear, dmonth, ddate);
double time = DatePrototype.MakeTime(dhours, dminutes, dseconds, dms);
return(DatePrototype.TimeClip(DatePrototype.MakeDate(day, time)));
}
private object EvaluateBitwiseBinary(object v1, object v2, JSToken operatorTok)
{
int num;
IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v1);
IConvertible ic = Microsoft.JScript.Convert.GetIConvertible(v2);
TypeCode typeCode = Microsoft.JScript.Convert.GetTypeCode(v1, iConvertible);
TypeCode code2 = Microsoft.JScript.Convert.GetTypeCode(v2, ic);
switch (typeCode)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(this.EvaluateBitwiseBinary(0, v2, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
num = iConvertible.ToInt32(null);
switch (code2)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(DoOp(num, 0, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
return(DoOp(num, ic.ToInt32(null), operatorTok));
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
return(DoOp(num, (int)Runtime.DoubleToInt64(ic.ToDouble(null)), operatorTok));
}
break;
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
num = (int)Runtime.DoubleToInt64(iConvertible.ToDouble(null));
switch (code2)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(DoOp(num, 0, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
return(DoOp(num, ic.ToInt32(null), operatorTok));
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
return(DoOp(num, (int)Runtime.DoubleToInt64(ic.ToDouble(null)), operatorTok));
}
break;
}
if (v2 == null)
{
return(DoOp(Microsoft.JScript.Convert.ToInt32(v1), 0, base.operatorTok));
}
MethodInfo @operator = base.GetOperator(v1.GetType(), v2.GetType());
if (@operator != null)
{
return(@operator.Invoke(null, BindingFlags.Default, JSBinder.ob, new object[] { v1, v2 }, null));
}
return(DoOp(Microsoft.JScript.Convert.ToInt32(v1), Microsoft.JScript.Convert.ToInt32(v2), base.operatorTok));
}
private void TranslateToIL(ILGenerator il, Object val, Type rtype)
{
IConvertible ic = Convert.GetIConvertible(val);
switch (Convert.GetTypeCode(val, ic))
{
case TypeCode.Empty:
il.Emit(OpCodes.Ldnull);
if (rtype.IsValueType)
{
Convert.Emit(this, il, Typeob.Object, rtype);
}
return;
case TypeCode.Object:
break;
case TypeCode.DBNull:
il.Emit(OpCodes.Ldsfld, Typeob.Null.GetField("Value"));
Convert.Emit(this, il, Typeob.Null, rtype);
return;
case TypeCode.Boolean:
ConstantWrapper.TranslateToILInt(il, ic.ToInt32(null));
Convert.Emit(this, il, Typeob.Boolean, rtype);
return;
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
ConstantWrapper.TranslateToILInt(il, ic.ToInt32(null));
if (rtype.IsEnum)
{
return;
}
if (val is EnumWrapper)
{
Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
}
else
{
Convert.Emit(this, il, Globals.TypeRefs.ToReferenceContext(val.GetType()), rtype);
}
return;
case TypeCode.UInt32:
ConstantWrapper.TranslateToILInt(il, (int)ic.ToUInt32(null));
if (rtype.IsEnum)
{
return;
}
if (val is EnumWrapper)
{
Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
}
else
{
Convert.Emit(this, il, Typeob.UInt32, rtype);
}
return;
case TypeCode.Int64:
long l = ic.ToInt64(null);
if (Int32.MinValue <= l && l <= Int32.MaxValue)
{
ConstantWrapper.TranslateToILInt(il, (int)l);
il.Emit(OpCodes.Conv_I8);
}
else
{
il.Emit(OpCodes.Ldc_I8, l);
}
if (rtype.IsEnum)
{
return;
}
if (val is EnumWrapper)
{
Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
}
else
{
Convert.Emit(this, il, Typeob.Int64, rtype);
}
return;
case TypeCode.UInt64:
ulong ul = ic.ToUInt64(null);
if (ul <= Int32.MaxValue)
{
ConstantWrapper.TranslateToILInt(il, (int)ul);
il.Emit(OpCodes.Conv_I8);
}
else
{
il.Emit(OpCodes.Ldc_I8, (long)ul);
}
if (rtype.IsEnum)
{
return;
}
if (val is EnumWrapper)
{
Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
}
else
{
Convert.Emit(this, il, Typeob.UInt64, rtype);
}
return;
case TypeCode.Single:
float f = ic.ToSingle(null);
if (f == f && (f != 0 || !Single.IsNegativeInfinity(1 / f)))
{
int i = (int)Runtime.DoubleToInt64(f);
if (-128 <= i && i <= 127 && f == (float)i)
{
ConstantWrapper.TranslateToILInt(il, i);
il.Emit(OpCodes.Conv_R4);
}
else
{
il.Emit(OpCodes.Ldc_R4, f);
}
}
else
{
il.Emit(OpCodes.Ldc_R4, f);
}
Convert.Emit(this, il, Typeob.Single, rtype);
return;
case TypeCode.Double:
double d = ic.ToDouble(null);
if (d == d && (d != 0 || !Double.IsNegativeInfinity(1 / d)))
{
int i = (int)Runtime.DoubleToInt64(d);
if (-128 <= i && i <= 127 && d == (double)i)
{
ConstantWrapper.TranslateToILInt(il, i);
il.Emit(OpCodes.Conv_R8);
}
else
{
il.Emit(OpCodes.Ldc_R8, d);
}
}
else
{
il.Emit(OpCodes.Ldc_R8, d);
}
Convert.Emit(this, il, Typeob.Double, rtype);
return;
case TypeCode.Decimal:
int[] bits = Decimal.GetBits(ic.ToDecimal(null));
ConstantWrapper.TranslateToILInt(il, bits[0]);
ConstantWrapper.TranslateToILInt(il, bits[1]);
ConstantWrapper.TranslateToILInt(il, bits[2]);
il.Emit(bits[3] < 0 ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); //bool isNegative
ConstantWrapper.TranslateToILInt(il, (bits[3] & 0x7FFFFFFF) >> 16);
il.Emit(OpCodes.Newobj, CompilerGlobals.decimalConstructor);
Convert.Emit(this, il, Typeob.Decimal, rtype);
return;
case TypeCode.DateTime:
l = ic.ToDateTime(null).Ticks;
il.Emit(OpCodes.Ldc_I8, l);
Convert.Emit(this, il, Typeob.Int64, rtype);
return;
case TypeCode.String:
String str = ic.ToString(null);
if (rtype == Typeob.Char && str.Length == 1)
{
ConstantWrapper.TranslateToILInt(il, (int)str[0]);
return;
}
il.Emit(OpCodes.Ldstr, str);
Convert.Emit(this, il, Typeob.String, rtype);
return;
}
if (val is Enum)
{
if (rtype == Typeob.String)
{
this.TranslateToIL(il, val.ToString(), rtype);
}
else if (rtype.IsPrimitive)
{
this.TranslateToIL(il, System.Convert.ChangeType(val, Enum.GetUnderlyingType(Globals.TypeRefs.ToReferenceContext(val.GetType())), CultureInfo.InvariantCulture), rtype);
}
else
{
Type et = Globals.TypeRefs.ToReferenceContext(val.GetType());
Type ut = Enum.GetUnderlyingType(et);
this.TranslateToIL(il, System.Convert.ChangeType(val, ut, CultureInfo.InvariantCulture), ut);
il.Emit(OpCodes.Box, et);
Convert.Emit(this, il, Typeob.Object, rtype);
}
return;
}
if (val is EnumWrapper)
{
if (rtype == Typeob.String)
{
this.TranslateToIL(il, val.ToString(), rtype);
}
else if (rtype.IsPrimitive)
{
this.TranslateToIL(il, ((EnumWrapper)val).ToNumericValue(), rtype);
}
else
{
Type et = ((EnumWrapper)val).type;
Type ut = Globals.TypeRefs.ToReferenceContext(((EnumWrapper)val).value.GetType());
this.TranslateToIL(il, ((EnumWrapper)val).value, ut);
il.Emit(OpCodes.Box, et);
Convert.Emit(this, il, Typeob.Object, rtype);
}
return;
}
if (val is Type)
{
il.Emit(OpCodes.Ldtoken, (Type)val);
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is Namespace)
{
il.Emit(OpCodes.Ldstr, ((Namespace)val).Name);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.getNamespaceMethod);
Convert.Emit(this, il, Typeob.Namespace, rtype);
}
else if (val is ClassScope)
{
il.Emit(OpCodes.Ldtoken, ((ClassScope)val).GetTypeBuilderOrEnumBuilder());
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is TypedArray)
{
il.Emit(OpCodes.Ldtoken, Convert.ToType((TypedArray)val));
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is NumberObject)
{
this.TranslateToIL(il, ((NumberObject)val).value, Typeob.Object);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Convert.Emit(this, il, Typeob.NumberObject, rtype);
}
else if (val is StringObject)
{
il.Emit(OpCodes.Ldstr, ((StringObject)val).value);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Convert.Emit(this, il, Typeob.StringObject, rtype);
}
else if (val is BooleanObject)
{
il.Emit(((BooleanObject)val).value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Box, Typeob.Boolean);
this.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Convert.Emit(this, il, Typeob.BooleanObject, rtype);
}
else if (val is ActiveXObjectConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ActiveXObject").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ArrayConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Array").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is BooleanConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Boolean").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is DateConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Date").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is EnumeratorConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Enumerator").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ErrorConstructor)
{
ErrorConstructor error = (ErrorConstructor)val;
if (error == ErrorConstructor.evalOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("EvalError").GetGetMethod());
}
else if (error == ErrorConstructor.rangeOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RangeError").GetGetMethod());
}
else if (error == ErrorConstructor.referenceOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ReferenceError").GetGetMethod());
}
else if (error == ErrorConstructor.syntaxOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("SyntaxError").GetGetMethod());
}
else if (error == ErrorConstructor.typeOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("TypeError").GetGetMethod());
}
else if (error == ErrorConstructor.uriOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("URIError").GetGetMethod());
}
else
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Error").GetGetMethod());
}
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is FunctionConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Function").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is MathObject)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Math").GetGetMethod());
Convert.Emit(this, il, Typeob.JSObject, rtype);
}
else if (val is NumberConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Number").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ObjectConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Object").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is RegExpConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RegExp").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is StringConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("String").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is VBArrayConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("VBArray").GetGetMethod());
Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is IntPtr)
{
il.Emit(OpCodes.Ldc_I8, (long)(IntPtr)val);
il.Emit(OpCodes.Conv_I);
Convert.Emit(this, il, Typeob.IntPtr, rtype);
}
else if (val is UIntPtr)
{
il.Emit(OpCodes.Ldc_I8, (long)(UIntPtr)val);
il.Emit(OpCodes.Conv_U);
Convert.Emit(this, il, Typeob.UIntPtr, rtype);
}
else if (val is Missing)
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.missingField);
Convert.Emit(this, il, Typeob.Object, rtype);
}
else if (val is System.Reflection.Missing)
{
if (rtype.IsPrimitive)
{
this.TranslateToIL(il, Double.NaN, rtype);
}
else if (rtype != Typeob.Object && !rtype.IsValueType)
{
il.Emit(OpCodes.Ldnull);
}
else
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.systemReflectionMissingField);
Convert.Emit(this, il, Typeob.Object, rtype);
}
}
else if (val != this.value) //Value was coerced to some type we have no compile time knowlegde of
{
this.TranslateToIL(il, this.value, rtype);
}
else
{
throw new JScriptException(JSError.InternalError, this.context); //It should not be possible to wrap any other kind of object
}
}
public object EvaluateUnary(object v)
{
IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v);
switch (Microsoft.JScript.Convert.GetTypeCode(v, iConvertible))
{
case TypeCode.Empty:
return(this.EvaluateUnary((double)1.0 / (double)0.0));
case TypeCode.DBNull:
return(this.EvaluateUnary(0));
case TypeCode.Boolean:
return(this.EvaluateUnary(iConvertible.ToBoolean(null) ? 1 : 0));
case TypeCode.Char:
return(this.EvaluateUnary((int)iConvertible.ToChar(null)));
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
{
int num = iConvertible.ToInt32(null);
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(num == 0);
case JSToken.BitwiseNot:
return(~num);
case JSToken.FirstBinaryOp:
return(num);
case JSToken.Minus:
switch (num)
{
case 0:
return(-((double)num));
case -2147483648:
return((ulong)-((double)num));
}
return(-num);
}
throw new JScriptException(JSError.InternalError, base.context);
}
case TypeCode.UInt32:
{
uint num2 = iConvertible.ToUInt32(null);
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(num2 == 0);
case JSToken.BitwiseNot:
return(~num2);
case JSToken.FirstBinaryOp:
return(num2);
case JSToken.Minus:
if ((num2 != 0) && (num2 <= 0x7fffffff))
{
return((int)-num2);
}
return(-((double)num2));
}
throw new JScriptException(JSError.InternalError, base.context);
}
case TypeCode.Int64:
{
long num3 = iConvertible.ToInt64(null);
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(num3 == 0L);
case JSToken.BitwiseNot:
return(~num3);
case JSToken.FirstBinaryOp:
return(num3);
case JSToken.Minus:
if ((num3 != 0L) && (num3 != -9223372036854775808L))
{
return(-num3);
}
return(-((double)num3));
}
throw new JScriptException(JSError.InternalError, base.context);
}
case TypeCode.UInt64:
{
ulong num4 = iConvertible.ToUInt64(null);
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(num4 == 0L);
case JSToken.BitwiseNot:
return(~num4);
case JSToken.FirstBinaryOp:
return(num4);
case JSToken.Minus:
if ((num4 != 0L) && (num4 <= 0x7fffffffffffffffL))
{
return((long)-num4);
}
return(-((double)num4));
}
throw new JScriptException(JSError.InternalError, base.context);
}
case TypeCode.Single:
case TypeCode.Double:
{
double d = iConvertible.ToDouble(null);
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(!Microsoft.JScript.Convert.ToBoolean(d));
case JSToken.BitwiseNot:
return(~((int)Runtime.DoubleToInt64(d)));
case JSToken.FirstBinaryOp:
return(d);
case JSToken.Minus:
return(-d);
}
throw new JScriptException(JSError.InternalError, base.context);
}
case TypeCode.String:
break;
default:
{
MethodInfo @operator = this.GetOperator(v.GetType());
if (@operator != null)
{
return(@operator.Invoke(null, BindingFlags.Default, JSBinder.ob, new object[] { v }, null));
}
break;
}
}
switch (this.operatorTok)
{
case JSToken.FirstOp:
return(!Microsoft.JScript.Convert.ToBoolean(v, iConvertible));
case JSToken.BitwiseNot:
return(~Microsoft.JScript.Convert.ToInt32(v, iConvertible));
case JSToken.FirstBinaryOp:
return(Microsoft.JScript.Convert.ToNumber(v, iConvertible));
case JSToken.Minus:
return(-Microsoft.JScript.Convert.ToNumber(v, iConvertible));
}
throw new JScriptException(JSError.InternalError, base.context);
}
public static ArrayObject splice(Object thisob, VsaEngine engine, double start, double deleteCnt, params Object[] args)
{
uint oldLength = Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
// compute the start index
long startIndex = Runtime.DoubleToInt64(Convert.ToInteger(start));
if (startIndex < 0)
{
startIndex = oldLength + startIndex;
if (startIndex < 0)
{
startIndex = 0;
}
}
else if (startIndex > oldLength)
{
startIndex = oldLength;
}
// compute the number of items to delete
long deleteCount = Runtime.DoubleToInt64(Convert.ToInteger(deleteCnt));
if (deleteCount < 0)
{
deleteCount = 0;
}
else if (deleteCount > oldLength - startIndex)
{
deleteCount = oldLength - startIndex;
}
long newLength = oldLength + args.Length - deleteCount;
// create an array for the result
ArrayObject result = engine.GetOriginalArrayConstructor().Construct();
result.length = deleteCount;
// special case array objects (nice speedup if dense)
if (thisob is ArrayObject)
{
((ArrayObject)thisob).Splice((uint)startIndex, (uint)deleteCount, args, result, (uint)oldLength, (uint)newLength);
return(result);
}
// copy the deleted items to the result array
for (ulong i = 0; i < (ulong)deleteCount; i++)
{
result.SetValueAtIndex((uint)i, LateBinding.GetValueAtIndex(thisob, i + (ulong)startIndex));
}
// shift the remaining elements left or right
long n = oldLength - startIndex - deleteCount;
if (newLength < oldLength)
{
for (long i = 0; i < n; i++)
{
LateBinding.SetValueAtIndex(thisob, (ulong)(i + startIndex + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)(i + startIndex + deleteCount)));
}
LateBinding.SetMemberValue(thisob, "length", newLength);
}
else
{
LateBinding.SetMemberValue(thisob, "length", newLength);
for (long i = n - 1; i >= 0; i--)
{
LateBinding.SetValueAtIndex(thisob, (ulong)(i + startIndex + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)(i + startIndex + deleteCount)));
}
}
// splice in the arguments
int m = args == null ? 0 : args.Length;
for (uint i = 0; i < m; i++)
{
LateBinding.SetValueAtIndex(thisob, i + (ulong)startIndex, args[i]);
}
return(result);
}
private Object EvaluateBitwiseBinary(Object v1, Object v2, JSToken operatorTok)
{
IConvertible ic1 = Convert.GetIConvertible(v1);
IConvertible ic2 = Convert.GetIConvertible(v2);
TypeCode t1 = Convert.GetTypeCode(v1, ic1);
TypeCode t2 = Convert.GetTypeCode(v2, ic2);
switch (t1)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(EvaluateBitwiseBinary(0, v2, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
int i = ic1.ToInt32(null);
switch (t2)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(DoOp(i, 0, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
return(DoOp(i, ic2.ToInt32(null), operatorTok));
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
return(DoOp(i, (int)Runtime.DoubleToInt64(ic2.ToDouble(null)), operatorTok));
case TypeCode.Object:
case TypeCode.Decimal:
case TypeCode.DateTime:
case TypeCode.String:
break;
}
break;
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
i = (int)Runtime.DoubleToInt64(ic1.ToDouble(null));
switch (t2)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return(DoOp(i, 0, operatorTok));
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
return(DoOp(i, ic2.ToInt32(null), operatorTok));
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
case TypeCode.Single:
case TypeCode.Double:
return(DoOp(i, (int)Runtime.DoubleToInt64(ic2.ToDouble(null)), operatorTok));
case TypeCode.Object:
case TypeCode.Decimal:
case TypeCode.DateTime:
case TypeCode.String:
break;
}
break;
case TypeCode.Object:
case TypeCode.Decimal:
case TypeCode.DateTime:
case TypeCode.String:
break;
}
if (v2 == null)
{
return(DoOp(Convert.ToInt32(v1), 0, this.operatorTok));
}
MethodInfo oper = this.GetOperator(v1.GetType(), v2.GetType());
if (oper != null)
{
return(oper.Invoke(null, (BindingFlags)0, JSBinder.ob, new Object[] { v1, v2 }, null));
}
else
{
return(DoOp(Convert.ToInt32(v1), Convert.ToInt32(v2), this.operatorTok));
}
}
private void TranslateToIL(ILGenerator il, object val, Type rtype)
{
long ticks;
IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(val);
switch (Microsoft.JScript.Convert.GetTypeCode(val, iConvertible))
{
case TypeCode.Empty:
il.Emit(OpCodes.Ldnull);
if (rtype.IsValueType)
{
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
return;
case TypeCode.DBNull:
il.Emit(OpCodes.Ldsfld, Typeob.Null.GetField("Value"));
Microsoft.JScript.Convert.Emit(this, il, Typeob.Null, rtype);
return;
case TypeCode.Boolean:
TranslateToILInt(il, iConvertible.ToInt32(null));
Microsoft.JScript.Convert.Emit(this, il, Typeob.Boolean, rtype);
return;
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
TranslateToILInt(il, iConvertible.ToInt32(null));
if (!rtype.IsEnum)
{
if (val is EnumWrapper)
{
Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
return;
}
Microsoft.JScript.Convert.Emit(this, il, Globals.TypeRefs.ToReferenceContext(val.GetType()), rtype);
return;
}
return;
case TypeCode.UInt32:
TranslateToILInt(il, (int)iConvertible.ToUInt32(null));
if (!rtype.IsEnum)
{
if (val is EnumWrapper)
{
Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
return;
}
Microsoft.JScript.Convert.Emit(this, il, Typeob.UInt32, rtype);
return;
}
return;
case TypeCode.Int64:
ticks = iConvertible.ToInt64(null);
if ((-2147483648L > ticks) || (ticks > 0x7fffffffL))
{
il.Emit(OpCodes.Ldc_I8, ticks);
break;
}
TranslateToILInt(il, (int)ticks);
il.Emit(OpCodes.Conv_I8);
break;
case TypeCode.UInt64:
{
ulong num2 = iConvertible.ToUInt64(null);
if (num2 > 0x7fffffffL)
{
il.Emit(OpCodes.Ldc_I8, (long)num2);
}
else
{
TranslateToILInt(il, (int)num2);
il.Emit(OpCodes.Conv_I8);
}
if (!rtype.IsEnum)
{
if (val is EnumWrapper)
{
Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
return;
}
Microsoft.JScript.Convert.Emit(this, il, Typeob.UInt64, rtype);
}
return;
}
case TypeCode.Single:
{
float arg = iConvertible.ToSingle(null);
if ((arg != arg) || ((arg == 0f) && float.IsNegativeInfinity(1f / arg)))
{
il.Emit(OpCodes.Ldc_R4, arg);
}
else
{
int i = (int)Runtime.DoubleToInt64((double)arg);
if (((-128 > i) || (i > 0x7f)) || (arg != i))
{
il.Emit(OpCodes.Ldc_R4, arg);
}
else
{
TranslateToILInt(il, i);
il.Emit(OpCodes.Conv_R4);
}
}
Microsoft.JScript.Convert.Emit(this, il, Typeob.Single, rtype);
return;
}
case TypeCode.Double:
{
double num5 = iConvertible.ToDouble(null);
if ((num5 != num5) || ((num5 == 0.0) && double.IsNegativeInfinity(1.0 / num5)))
{
il.Emit(OpCodes.Ldc_R8, num5);
}
else
{
int num6 = (int)Runtime.DoubleToInt64(num5);
if (((-128 > num6) || (num6 > 0x7f)) || (num5 != num6))
{
il.Emit(OpCodes.Ldc_R8, num5);
}
else
{
TranslateToILInt(il, num6);
il.Emit(OpCodes.Conv_R8);
}
}
Microsoft.JScript.Convert.Emit(this, il, Typeob.Double, rtype);
return;
}
case TypeCode.Decimal:
{
int[] bits = decimal.GetBits(iConvertible.ToDecimal(null));
TranslateToILInt(il, bits[0]);
TranslateToILInt(il, bits[1]);
TranslateToILInt(il, bits[2]);
il.Emit((bits[3] < 0) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
TranslateToILInt(il, (bits[3] & 0x7fffffff) >> 0x10);
il.Emit(OpCodes.Newobj, CompilerGlobals.decimalConstructor);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Decimal, rtype);
return;
}
case TypeCode.DateTime:
ticks = iConvertible.ToDateTime(null).Ticks;
il.Emit(OpCodes.Ldc_I8, ticks);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Int64, rtype);
return;
case TypeCode.String:
{
string str = iConvertible.ToString(null);
if (!(rtype == Typeob.Char) || (str.Length != 1))
{
il.Emit(OpCodes.Ldstr, str);
Microsoft.JScript.Convert.Emit(this, il, Typeob.String, rtype);
return;
}
TranslateToILInt(il, str[0]);
return;
}
default:
if (val is Enum)
{
if (rtype == Typeob.String)
{
this.TranslateToIL(il, val.ToString(), rtype);
return;
}
if (rtype.IsPrimitive)
{
this.TranslateToIL(il, System.Convert.ChangeType(val, Enum.GetUnderlyingType(Globals.TypeRefs.ToReferenceContext(val.GetType())), CultureInfo.InvariantCulture), rtype);
return;
}
Type enumType = Globals.TypeRefs.ToReferenceContext(val.GetType());
Type underlyingType = Enum.GetUnderlyingType(enumType);
this.TranslateToIL(il, System.Convert.ChangeType(val, underlyingType, CultureInfo.InvariantCulture), underlyingType);
il.Emit(OpCodes.Box, enumType);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
else if (val is EnumWrapper)
{
if (rtype == Typeob.String)
{
this.TranslateToIL(il, val.ToString(), rtype);
return;
}
if (rtype.IsPrimitive)
{
this.TranslateToIL(il, ((EnumWrapper)val).ToNumericValue(), rtype);
}
else
{
Type type = ((EnumWrapper)val).type;
Type type4 = Globals.TypeRefs.ToReferenceContext(((EnumWrapper)val).value.GetType());
this.TranslateToIL(il, ((EnumWrapper)val).value, type4);
il.Emit(OpCodes.Box, type);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
}
else if (val is Type)
{
il.Emit(OpCodes.Ldtoken, (Type)val);
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is Namespace)
{
il.Emit(OpCodes.Ldstr, ((Namespace)val).Name);
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.getNamespaceMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Namespace, rtype);
}
else if (val is ClassScope)
{
il.Emit(OpCodes.Ldtoken, ((ClassScope)val).GetTypeBuilderOrEnumBuilder());
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is TypedArray)
{
il.Emit(OpCodes.Ldtoken, Microsoft.JScript.Convert.ToType((TypedArray)val));
il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
}
else if (val is NumberObject)
{
this.TranslateToIL(il, ((NumberObject)val).value, Typeob.Object);
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.NumberObject, rtype);
}
else if (val is StringObject)
{
il.Emit(OpCodes.Ldstr, ((StringObject)val).value);
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.StringObject, rtype);
}
else if (val is BooleanObject)
{
il.Emit(((BooleanObject)val).value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Box, Typeob.Boolean);
base.EmitILToLoadEngine(il);
il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.BooleanObject, rtype);
}
else if (val is ActiveXObjectConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ActiveXObject").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ArrayConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Array").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is BooleanConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Boolean").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is DateConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Date").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is EnumeratorConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Enumerator").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ErrorConstructor)
{
ErrorConstructor constructor = (ErrorConstructor)val;
if (constructor == ErrorConstructor.evalOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("EvalError").GetGetMethod());
}
else if (constructor == ErrorConstructor.rangeOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RangeError").GetGetMethod());
}
else if (constructor == ErrorConstructor.referenceOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ReferenceError").GetGetMethod());
}
else if (constructor == ErrorConstructor.syntaxOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("SyntaxError").GetGetMethod());
}
else if (constructor == ErrorConstructor.typeOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("TypeError").GetGetMethod());
}
else if (constructor == ErrorConstructor.uriOb)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("URIError").GetGetMethod());
}
else
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Error").GetGetMethod());
}
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is FunctionConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Function").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is MathObject)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Math").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.JSObject, rtype);
}
else if (val is NumberConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Number").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is ObjectConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Object").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is RegExpConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RegExp").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is StringConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("String").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is VBArrayConstructor)
{
il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("VBArray").GetGetMethod());
Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
}
else if (val is IntPtr)
{
il.Emit(OpCodes.Ldc_I8, (long)((IntPtr)val));
il.Emit(OpCodes.Conv_I);
Microsoft.JScript.Convert.Emit(this, il, Typeob.IntPtr, rtype);
}
else if (val is UIntPtr)
{
il.Emit(OpCodes.Ldc_I8, (long)((ulong)((UIntPtr)val)));
il.Emit(OpCodes.Conv_U);
Microsoft.JScript.Convert.Emit(this, il, Typeob.UIntPtr, rtype);
}
else if (val is Microsoft.JScript.Missing)
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.missingField);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
else if (val is System.Reflection.Missing)
{
if (rtype.IsPrimitive)
{
this.TranslateToIL(il, (double)1.0 / (double)0.0, rtype);
}
else if ((rtype != Typeob.Object) && !rtype.IsValueType)
{
il.Emit(OpCodes.Ldnull);
}
else
{
il.Emit(OpCodes.Ldsfld, CompilerGlobals.systemReflectionMissingField);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
}
}
else
{
if (val == this.value)
{
throw new JScriptException(JSError.InternalError, base.context);
}
this.TranslateToIL(il, this.value, rtype);
}
return;
}
if (!rtype.IsEnum)
{
if (val is EnumWrapper)
{
Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
}
else
{
Microsoft.JScript.Convert.Emit(this, il, Typeob.Int64, rtype);
}
}
}
public Object EvaluateUnary(Object v)
{
IConvertible ic = Convert.GetIConvertible(v);
switch (Convert.GetTypeCode(v, ic))
{
case TypeCode.Empty: return(this.EvaluateUnary(Double.NaN));
case TypeCode.DBNull: return(this.EvaluateUnary(0));
case TypeCode.Boolean: return(this.EvaluateUnary(ic.ToBoolean(null) ? 1 : 0));
case TypeCode.Char: return(this.EvaluateUnary((int)ic.ToChar(null)));
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
int i = ic.ToInt32(null);
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~i);
case JSToken.LogicalNot:
return(i == 0);
case JSToken.Minus:
if (i == 0)
{
return(-(double)i);
}
if (i == Int32.MinValue)
{
return((ulong)-(double)i);
}
return(-i);
case JSToken.Plus:
return(i);
default:
throw new JScriptException(JSError.InternalError, this.context);
}
case TypeCode.UInt32:
uint ui = ic.ToUInt32(null);
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~ui);
case JSToken.LogicalNot:
return(ui == 0);
case JSToken.Minus:
if (ui != 0 && ui <= Int32.MaxValue)
{
return(-(int)ui);
}
else
{
return(-(double)ui);
}
case JSToken.Plus:
return(ui);
default:
throw new JScriptException(JSError.InternalError, this.context);
}
case TypeCode.Int64:
long l = ic.ToInt64(null);
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~l);
case JSToken.LogicalNot:
return(l == 0);
case JSToken.Minus:
if (l == 0 || l == Int64.MinValue)
{
return(-(double)l);
}
return(-l);
case JSToken.Plus:
return(l);
default:
throw new JScriptException(JSError.InternalError, this.context);
}
case TypeCode.UInt64:
ulong ul = ic.ToUInt64(null);
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~ul);
case JSToken.LogicalNot:
return(ul == 0);
case JSToken.Minus:
if (ul != 0 && ul <= Int64.MaxValue)
{
return(-(long)ul);
}
else
{
return(-(double)ul);
}
case JSToken.Plus:
return(ul);
default:
throw new JScriptException(JSError.InternalError, this.context);
}
case TypeCode.Single:
case TypeCode.Double:
double d = ic.ToDouble(null);
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~(int)Runtime.DoubleToInt64(d));
case JSToken.LogicalNot:
return(!Convert.ToBoolean(d));
case JSToken.Minus:
return(-d);
case JSToken.Plus:
return(d);
default:
throw new JScriptException(JSError.InternalError, this.context);
}
case TypeCode.String:
goto no_overload_case;
}
MethodInfo oper = this.GetOperator(v.GetType());
if (oper != null)
{
return(oper.Invoke(null, (BindingFlags)0, JSBinder.ob, new Object[] { v }, null));
}
no_overload_case:
switch (this.operatorTok)
{
case JSToken.BitwiseNot:
return(~Convert.ToInt32(v, ic));
case JSToken.LogicalNot:
return(!Convert.ToBoolean(v, ic));
case JSToken.Minus:
return(-Convert.ToNumber(v, ic));
case JSToken.Plus:
return(Convert.ToNumber(v, ic));
default:
throw new JScriptException(JSError.InternalError, this.context);
}
}
public static ArrayObject splice(object thisob, VsaEngine engine, double start, double deleteCnt, params object[] args)
{
uint oldLength = Microsoft.JScript.Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
long num2 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(start));
if (num2 < 0L)
{
num2 = oldLength + num2;
if (num2 < 0L)
{
num2 = 0L;
}
}
else if (num2 > oldLength)
{
num2 = oldLength;
}
long num3 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(deleteCnt));
if (num3 < 0L)
{
num3 = 0L;
}
else if (num3 > (oldLength - num2))
{
num3 = oldLength - num2;
}
long num4 = (oldLength + args.Length) - num3;
ArrayObject outArray = engine.GetOriginalArrayConstructor().Construct();
outArray.length = num3;
if (thisob is ArrayObject)
{
((ArrayObject)thisob).Splice((uint)num2, (uint)num3, args, outArray, oldLength, (uint)num4);
return(outArray);
}
for (ulong i = 0L; i < num3; i += (ulong)1L)
{
outArray.SetValueAtIndex((uint)i, LateBinding.GetValueAtIndex(thisob, i + ((ulong)num2)));
}
long num6 = (oldLength - num2) - num3;
if (num4 < oldLength)
{
for (long k = 0L; k < num6; k += 1L)
{
LateBinding.SetValueAtIndex(thisob, (ulong)((k + num2) + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)((k + num2) + num3)));
}
LateBinding.SetMemberValue(thisob, "length", num4);
}
else
{
LateBinding.SetMemberValue(thisob, "length", num4);
for (long m = num6 - 1L; m >= 0L; m -= 1L)
{
LateBinding.SetValueAtIndex(thisob, (ulong)((m + num2) + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)((m + num2) + num3)));
}
}
int num9 = (args == null) ? 0 : args.Length;
for (uint j = 0; j < num9; j++)
{
LateBinding.SetValueAtIndex(thisob, (ulong)(j + num2), args[j]);
}
return(outArray);
}
public static string substr(object thisob, double start, object count)
{
string str = thisob as string;
if (str == null)
{
str = Microsoft.JScript.Convert.ToString(thisob);
}
int length = str.Length;
double val = Microsoft.JScript.Convert.ToInteger(start);
if (val < 0.0)
{
val += length;
}
if (val < 0.0)
{
val = 0.0;
}
else if (val > length)
{
val = length;
}
int num3 = (count is int) ? ((int)count) : (((count == null) || (count is Missing)) ? (length - ((int)Runtime.DoubleToInt64(val))) : ((int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(count))));
if ((val + num3) > length)
{
num3 = length - ((int)val);
}
if (num3 <= 0)
{
return("");
}
return(str.Substring((int)val, num3));
}
