public static object call(object thisObj, object thisArg, params object [] args) { SemanticAnalyser.assert_type(thisObj, typeof(ScriptFunction)); ScriptFunction fun = (ScriptFunction)thisObj; return(fun.Invoke(thisArg, args)); }
public static string toString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(RegExpObject)); RegExpObject re = (RegExpObject)thisObj; return(re.ToString()); }
public static double setUTCSeconds(object thisObj, double dsec, object msec) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double t = date.ms; double new_ms; if (msec == null) { new_ms = DateConstructor.msFromTime(t); } else { new_ms = Convert.ToNumber(msec); } double time = DateConstructor.MakeTime(DateConstructor.HourFromTime(t), DateConstructor.MinFromTime(t), dsec, new_ms); double day = Math.Floor(t / DateConstructor.MS_PER_DAY); double new_val = DateConstructor.MakeDate(day, time); date.ms = DateConstructor.TimeClip(new_val); return(date.ms); }
public static string toLocaleString(object thisObj) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; string separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator + " "; Hashtable elems = array_obj.elems; uint n = (uint)array_obj.length; StringBuilder str = new StringBuilder(); bool first = true; for (uint i = 0; i < n; i++) { ScriptObject elem = (ScriptObject)Convert.ToObject(elems [i], null); if (!first && elem != null) { str.Append(separator); } first = false; if (elem != null) { str.Append(Convert.ToString(elem.CallMethod("toLocaleString", new object [] { }))); } } return(str.ToString()); }
public static double setMonth(object thisObj, double dmonth, object date) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject dt = (DateObject)thisObj; double t = DateConstructor.LocalTime(dt.ms); double new_date; if (date == null) { new_date = DateConstructor.DateFromTime(t); } else { new_date = Convert.ToNumber(date); } double day = DateConstructor.MakeDay((double)DateConstructor.YearFromTime(t), dmonth, new_date); double new_val = DateConstructor.ToUTC(DateConstructor.MakeDate(day, t % DateConstructor.MS_PER_DAY)); dt.ms = DateConstructor.TimeClip(new_val); return(dt.ms); }
public static string toString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(ErrorObject)); ErrorObject error = (ErrorObject)thisObj; return(error.message.ToString()); }
public static string toUTCString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date_obj = (DateObject)thisObj; double val = date_obj.ms; int year = DateConstructor.YearFromTime(val); int month = DateConstructor.MonthFromTime(val); int date = DateConstructor.DateFromTime(val); int hour = DateConstructor.HourFromTime(val); int min = DateConstructor.MinFromTime(val); int sec = DateConstructor.SecFromTime(val); DateTime dt; try { dt = new DateTime(year, month + 1, date); } catch (ArgumentOutOfRangeException) { return(InvalidDateString); } string date_string = dt.ToString("ddd, d MMM yyyy ", CultureInfo.InvariantCulture); string time_string = String.Format(@"{0:00}:{1:00}:{2:00} UTC", hour, min, sec); return(date_string + time_string); }
public static object shift(object thisObj) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; Hashtable elems = array_obj.elems; uint n = (uint)array_obj.length; object result = null; if (n > 0) { if (elems.ContainsKey((uint)0)) { result = elems [(uint)0]; elems.Remove((uint)0); for (uint i = 1; i < n; i++) { elems [i - 1] = elems [i]; } } // Last element gets removed automatically array_obj.length = n - 1; } return(result); }
public static double getTime(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; return(date.ms); }
public static object unshift(object thisObj, params object [] args) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; Hashtable elems = array_obj.elems; uint old_length = (uint)array_obj.length; uint arg_length = (uint)args.Length; uint new_length = old_length + arg_length; if (arg_length > 0) { // First let's make some free space for the new items long i = (long)old_length - 1; long j = i + (long)arg_length; for (; i >= 0; i--, j--) { elems [(uint)j] = elems [(uint)i]; } // Then insert the new items in the now free space for (; j >= 0; j--) { elems [(uint)j] = args [(uint)j]; } } // // NOTE: MSC returns the new array, but // ECMA-262 says to return the new length. We // conform to the standard. // array_obj.length = new_length; return(new_length); }
public static double setTime(object thisObj, double time) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; date.ms = DateConstructor.TimeClip(time); return(date.ms); }
public static ArrayObject slice(object thisObj, VsaEngine engine, double start, object end) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; uint array_len = (uint)array_obj.length; uint _start, _end; if (start > array_len) { _start = array_len; } else { _start = (uint)start; if (_start < 0) { _start += array_len; } } if (end == null) { _end = array_len; } else { _end = Convert.ToUint32(end); if (_end < 0) { _end += array_len; } else if (_end > array_len) { _end = array_len; } } if (_end < _start) { _end = _start; } ArrayObject result = new ArrayObject(); result.length = _end - _start; for (uint i = _start; i < _end; i++) { result.elems [i - _start] = array_obj.elems [i]; } return(result); }
public static string toString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); string date_str = toDateString(thisObj); if (date_str == InvalidDateString) { return(date_str); } return(date_str.Insert(date_str.LastIndexOf(' '), " " + toTimeString(thisObj))); }
public static double setUTCDate(object thisObj, double ddate) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double t = date.ms; double day = DateConstructor.MakeDay((double)DateConstructor.YearFromTime(t), (double)DateConstructor.MonthFromTime(t), ddate); double new_val = DateConstructor.MakeDate(day, t % DateConstructor.MS_PER_DAY); date.ms = DateConstructor.TimeClip(new_val); return(date.ms); }
public static double setUTCMilliseconds(object thisObj, double msec) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double t = date.ms; double time = DateConstructor.MakeTime(DateConstructor.HourFromTime(t), DateConstructor.MinFromTime(t), DateConstructor.SecFromTime(t), msec); double day = Math.Floor(t / DateConstructor.MS_PER_DAY); double new_val = DateConstructor.MakeDate(day, time); date.ms = DateConstructor.TimeClip(new_val); return(date.ms); }
public static object sort(object thisObj, object function) { // TODO: Shouldn't this be generic? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; ScriptFunction fun = function as ScriptFunction; uint n = (uint)array_obj.length; if (n > 1) { SortHelper.qsort(array_obj.elems, 0, n - 1, SortHelper.CompareDelegateFor(fun)); } return(array_obj); }
public static string toTimeString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date_obj = (DateObject)thisObj; double val = date_obj.ms; double lv = DateConstructor.LocalTime(val); int hour = DateConstructor.HourFromTime(lv); int min = DateConstructor.MinFromTime(lv); int sec = DateConstructor.SecFromTime(lv); double off = getTimezoneOffset(thisObj); return(String.Format(@"{0:00}:{1:00}:{2:00} UTC{3:\+0;\-0;\+0}", hour, min, sec, -off / 60)); }
public static double getUTCMilliseconds(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double val = date.ms; if (Double.IsNaN(val)) { return(Double.NaN); } else { return(DateConstructor.msFromTime(val)); } }
public static double getFullYear(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double val = date.ms; if (Double.IsNaN(val)) { return(Double.NaN); } else { return(DateConstructor.YearFromTime(DateConstructor.LocalTime(val))); } }
public static double getTimezoneOffset(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double val = date.ms; if (Double.IsNaN(val)) { return(Double.NaN); } else { return((val - DateConstructor.LocalTime(val)) / DateConstructor.MS_PER_MINUTE); } }
public static double setHours(object thisObj, double dhour, object min, object sec, object msec) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date = (DateObject)thisObj; double t = DateConstructor.LocalTime(date.ms); double new_min; if (min == null) { new_min = DateConstructor.MinFromTime(t); } else { new_min = Convert.ToNumber(min); } double new_sec; if (sec == null) { new_sec = DateConstructor.SecFromTime(t); } else { new_sec = Convert.ToNumber(sec); } double new_ms; if (msec == null) { new_ms = DateConstructor.msFromTime(t); } else { new_ms = Convert.ToNumber(msec); } double time = DateConstructor.MakeTime(dhour, new_min, new_sec, new_ms); double day = Math.Floor(t / DateConstructor.MS_PER_DAY); double new_val = DateConstructor.ToUTC(DateConstructor.MakeDate(day, time)); date.ms = DateConstructor.TimeClip(new_val); return(date.ms); }
public static long push(object thisObj, params object [] args) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; Hashtable elems = array_obj.elems; uint i = (uint)array_obj.length; long n = i + args.Length; for (uint j = 0; i < n; i++, j++) { elems [i] = args [j]; } array_obj.length = n; return(n); }
public static string toLocaleDateString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject date_obj = (DateObject)thisObj; double val = date_obj.ms; double lv = DateConstructor.LocalTime(val); int year = DateConstructor.YearFromTime(lv); int month = DateConstructor.MonthFromTime(lv); int date = DateConstructor.DateFromTime(lv); DateTime dt; try { dt = new DateTime(year, month + 1, date); } catch (ArgumentOutOfRangeException) { return(InvalidDateString); } return(dt.ToString("D")); }
public static object reverse(object thisObj) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; Hashtable elems = array_obj.elems; uint n = (uint)array_obj.length; uint half_n = n / 2; uint j = n - 1; object temp; for (uint i = 0; i < half_n; i++, j--) { temp = elems [i]; elems [i] = elems [j]; elems [j] = temp; } return(array_obj); }
public static double setUTCFullYear(object thisObj, double dyear, object month, object date) { SemanticAnalyser.assert_type(thisObj, typeof(DateObject)); DateObject dt = (DateObject)thisObj; double t = dt.ms; if (Double.IsNaN(t)) { t = 0; } double new_month; if (month == null) { new_month = DateConstructor.MonthFromTime(t); } else { new_month = Convert.ToNumber(month); } double new_date; if (date == null) { new_date = DateConstructor.DateFromTime(t); } else { new_date = Convert.ToNumber(date); } double day = DateConstructor.MakeDay(dyear, new_month, new_date); double new_val = DateConstructor.MakeDate(day, t % DateConstructor.MS_PER_DAY); dt.ms = DateConstructor.TimeClip(new_val); return(dt.ms); }
public static ArrayObject concat(object thisObj, VsaEngine engine, params object [] args) { uint i = 0; ArrayObject result = new ArrayObject(); int arg_idx = -1; int arg_count = args.Length; // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); object cur_obj = thisObj; ArrayObject cur_ary; while (cur_obj != null) { if (cur_obj is ArrayObject) { cur_ary = (ArrayObject)cur_obj; uint n = (uint)cur_ary.length; for (uint j = 0; j < n; j++, i++) { result.elems [i] = cur_ary.elems [j]; } } else { result.elems [i++] = cur_obj; } arg_idx++; cur_obj = arg_idx < arg_count ? args [arg_idx] : null; } result.length = i; return(result); }
public static object pop(object thisObj) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; Hashtable elems = array_obj.elems; uint n = (uint)array_obj.length; object result = null; if (n > 0) { uint new_len = n - 1; if (elems.ContainsKey(new_len)) { result = elems [new_len]; } // Element gets removed automatically array_obj.length = new_len; } return(result); }
public static string join(object thisObj, object separator) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; string _separator; if (separator == null) { _separator = ","; } else { _separator = Convert.ToString(separator); } Hashtable elems = array_obj.elems; uint n = (uint)array_obj.length; StringBuilder str = new StringBuilder(); bool first = true; for (uint i = 0; i < n; i++) { if (!first) { str.Append(_separator); } first = false; object elem = elems [i]; if (elem != null) { str.Append(Convert.ToString(elem)); } } return(str.ToString()); }
public static ArrayObject splice(object thisObj, VsaEngine engine, double start, double deleteCnt, params object [] args) { // TODO: Shouldn't this be generic!? SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); ArrayObject array_obj = (ArrayObject)thisObj; ArrayObject result = new ArrayObject(); Hashtable elems = array_obj.elems; Hashtable del_elems = result.elems; uint old_length = (uint)array_obj.length; start = (long)start; if (start < 0) { start = Math.Max(start + old_length, 0); } else { start = Math.Min(old_length, start); } deleteCnt = (long)deleteCnt; deleteCnt = Math.Min(Math.Max(deleteCnt, 0), old_length - start); uint arg_length = (uint)args.Length; long add_length = (long)((long)arg_length - (uint)deleteCnt); add_length = (long)Math.Max(add_length, -((long)old_length)); long del_length = -add_length; uint new_length = (uint)((long)old_length + add_length); long i, j, m; // First let's make some free space for the new items (if needed) if (add_length > 0) { i = (long)old_length - 1; j = (uint)(i + add_length); for (; i >= start; i--, j--) { elems [(uint)j] = elems [(uint)i]; } } // Then insert the new items in the now free space / replace existing ones j = m = 0; long old_start = (long)(start + add_length); for (i = (long)start; j < arg_length; i++, j++) { if (i >= old_start && elems.ContainsKey((uint)i)) { del_elems [(uint)m] = elems [(uint)i]; m++; elems.Remove((uint)i); } if (j < arg_length) { elems [(uint)i] = args [(uint)j]; } } // Finally, delete elements which have no replacement elements if (add_length < 0) { uint last_elem_idx = (uint)(i + del_length); for (uint k = 0; k < del_length; i++, j++, k++) { if (elems.ContainsKey((uint)i)) { del_elems [(uint)m] = elems [(uint)i]; m++; elems.Remove((uint)i); } } // And move up trailing elements uint l = (uint)(last_elem_idx - del_length); for (uint k = last_elem_idx; l < old_length; k++, l++) { if (elems.ContainsKey(k)) { elems [l] = elems [k]; } else if (elems.ContainsKey(l)) { elems.Remove(l); } } } array_obj.length = new_length; result.length = (uint)deleteCnt; return(result); }
public static string toString(object thisObj) { SemanticAnalyser.assert_type(thisObj, typeof(ArrayObject)); return(ArrayPrototype.join(thisObj, null)); }