{

private static final long serialVersionUID = -8307438915861678966L;

private static final Object DATE_TAG = "Date";

private static final String js_NaN_date_str = "Invalid Date";

static void init(Scriptable scope, boolean sealed)

{

NativeDate obj = new NativeDate();

// Set the value of the prototype Date to NaN ('invalid date');

obj.date = ScriptRuntime.NaN;

obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed);

}

private NativeDate()

{

}

@Override

public String getClassName()

{

return "Date";

}

@Override

public Object getDefaultValue(Class<?> typeHint)

{

if (typeHint == null)

typeHint = ScriptRuntime.StringClass;

return super.getDefaultValue(typeHint);

}

double getJSTimeValue()

{

return date;

}

@Override

protected void fillConstructorProperties(IdFunctionObject ctor)

{

addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_now,

"now", 0);

addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_parse,

"parse", 1);

addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_UTC,

"UTC", 7);

super.fillConstructorProperties(ctor);

}

@Override

protected void initPrototypeId(int id)

{

String s;

int arity;

switch (id) {

case Id_constructor: arity=7; s="constructor"; break;

case Id_toString: arity=0; s="toString"; break;

case Id_toTimeString: arity=0; s="toTimeString"; break;

case Id_toDateString: arity=0; s="toDateString"; break;

case Id_toLocaleString: arity=0; s="toLocaleString"; break;

case Id_toLocaleTimeString: arity=0; s="toLocaleTimeString"; break;

case Id_toLocaleDateString: arity=0; s="toLocaleDateString"; break;

case Id_toUTCString: arity=0; s="toUTCString"; break;

case Id_toSource: arity=0; s="toSource"; break;

case Id_valueOf: arity=0; s="valueOf"; break;

case Id_getTime: arity=0; s="getTime"; break;

case Id_getYear: arity=0; s="getYear"; break;

case Id_getFullYear: arity=0; s="getFullYear"; break;

case Id_getUTCFullYear: arity=0; s="getUTCFullYear"; break;

case Id_getMonth: arity=0; s="getMonth"; break;

case Id_getUTCMonth: arity=0; s="getUTCMonth"; break;

case Id_getDate: arity=0; s="getDate"; break;

case Id_getUTCDate: arity=0; s="getUTCDate"; break;

case Id_getDay: arity=0; s="getDay"; break;

case Id_getUTCDay: arity=0; s="getUTCDay"; break;

case Id_getHours: arity=0; s="getHours"; break;

case Id_getUTCHours: arity=0; s="getUTCHours"; break;

case Id_getMinutes: arity=0; s="getMinutes"; break;

case Id_getUTCMinutes: arity=0; s="getUTCMinutes"; break;

case Id_getSeconds: arity=0; s="getSeconds"; break;

case Id_getUTCSeconds: arity=0; s="getUTCSeconds"; break;

case Id_getMilliseconds: arity=0; s="getMilliseconds"; break;

case Id_getUTCMilliseconds: arity=0; s="getUTCMilliseconds"; break;

case Id_getTimezoneOffset: arity=0; s="getTimezoneOffset"; break;

case Id_setTime: arity=1; s="setTime"; break;

case Id_setMilliseconds: arity=1; s="setMilliseconds"; break;

case Id_setUTCMilliseconds: arity=1; s="setUTCMilliseconds"; break;

case Id_setSeconds: arity=2; s="setSeconds"; break;

case Id_setUTCSeconds: arity=2; s="setUTCSeconds"; break;

case Id_setMinutes: arity=3; s="setMinutes"; break;

case Id_setUTCMinutes: arity=3; s="setUTCMinutes"; break;

case Id_setHours: arity=4; s="setHours"; break;

case Id_setUTCHours: arity=4; s="setUTCHours"; break;

case Id_setDate: arity=1; s="setDate"; break;

case Id_setUTCDate: arity=1; s="setUTCDate"; break;

case Id_setMonth: arity=2; s="setMonth"; break;

case Id_setUTCMonth: arity=2; s="setUTCMonth"; break;

case Id_setFullYear: arity=3; s="setFullYear"; break;

case Id_setUTCFullYear: arity=3; s="setUTCFullYear"; break;

case Id_setYear: arity=1; s="setYear"; break;

case Id_toISOString: arity=0; s="toISOString"; break;

case Id_toJSON: arity=1; s="toJSON"; break;

default: throw new IllegalArgumentException(String.valueOf(id));

}

initPrototypeMethod(DATE_TAG, id, s, arity);

}

@Override

public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,

Scriptable thisObj, Object[] args)

{

if (!f.hasTag(DATE_TAG)) {

return super.execIdCall(f, cx, scope, thisObj, args);

}

int id = f.methodId();

switch (id) {

case ConstructorId_now:

return ScriptRuntime.wrapNumber(now());

case ConstructorId_parse:

{

String dataStr = ScriptRuntime.toString(args, 0);

return ScriptRuntime.wrapNumber(date_parseString(dataStr));

}

case ConstructorId_UTC:

return ScriptRuntime.wrapNumber(jsStaticFunction_UTC(args));

case Id_constructor:

{

// if called as a function, just return a string

// representing the current time.

if (thisObj != null)

return date_format(now(), Id_toString);

return jsConstructor(args);

}

case Id_toJSON:

{

final String toISOString = "toISOString";

Scriptable o = ScriptRuntime.toObject(cx, scope, thisObj);

Object tv = ScriptRuntime.toPrimitive(o, ScriptRuntime.NumberClass);

if (tv instanceof Number) {

double d = ((Number) tv).doubleValue();

if (Double.isNaN(d) || Double.isInfinite(d)) {

return null;

}

}

Object toISO = ScriptableObject.getProperty(o, toISOString);

if (toISO == NOT_FOUND) {

throw ScriptRuntime.typeError2("msg.function.not.found.in",

toISOString,

ScriptRuntime.toString(o));

}

if ( !(toISO instanceof Callable) ) {

throw ScriptRuntime.typeError3("msg.isnt.function.in",

toISOString,

ScriptRuntime.toString(o),

ScriptRuntime.toString(toISO));

}

Object result = ((Callable) toISO).call(cx, scope, o,

ScriptRuntime.emptyArgs);

if ( !ScriptRuntime.isPrimitive(result) ) {

throw ScriptRuntime.typeError1("msg.toisostring.must.return.primitive",

ScriptRuntime.toString(result));

}

return result;

}

}

// The rest of Date.prototype methods require thisObj to be Date

if (!(thisObj instanceof NativeDate))

throw incompatibleCallError(f);

NativeDate realThis = (NativeDate)thisObj;

double t = realThis.date;

switch (id) {

case Id_toString:

case Id_toTimeString:

case Id_toDateString:

if (!Double.isNaN(t)) {

return date_format(t, id);

}

return js_NaN_date_str;

case Id_toLocaleString:

case Id_toLocaleTimeString:

case Id_toLocaleDateString:

if (!Double.isNaN(t)) {

return toLocale_helper(t, id);

}

return js_NaN_date_str;

case Id_toUTCString:

if (!Double.isNaN(t)) {

return js_toUTCString(t);

}

return js_NaN_date_str;

case Id_toSource:

return "(new Date("+ScriptRuntime.toString(t)+"))";

case Id_valueOf:

case Id_getTime:

return ScriptRuntime.wrapNumber(t);

case Id_getYear:

case Id_getFullYear:

case Id_getUTCFullYear:

if (!Double.isNaN(t)) {

if (id != Id_getUTCFullYear) t = LocalTime(t);

t = YearFromTime(t);

if (id == Id_getYear) {

if (cx.hasFeature(Context.FEATURE_NON_ECMA_GET_YEAR)) {

if (1900 <= t && t < 2000) {

t -= 1900;

}

} else {

t -= 1900;

}

}

}

return ScriptRuntime.wrapNumber(t);

case Id_getMonth:

case Id_getUTCMonth:

if (!Double.isNaN(t)) {

if (id == Id_getMonth) t = LocalTime(t);

t = MonthFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getDate:

case Id_getUTCDate:

if (!Double.isNaN(t)) {

if (id == Id_getDate) t = LocalTime(t);

t = DateFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getDay:

case Id_getUTCDay:

if (!Double.isNaN(t)) {

if (id == Id_getDay) t = LocalTime(t);

t = WeekDay(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getHours:

case Id_getUTCHours:

if (!Double.isNaN(t)) {

if (id == Id_getHours) t = LocalTime(t);

t = HourFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getMinutes:

case Id_getUTCMinutes:

if (!Double.isNaN(t)) {

if (id == Id_getMinutes) t = LocalTime(t);

t = MinFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getSeconds:

case Id_getUTCSeconds:

if (!Double.isNaN(t)) {

if (id == Id_getSeconds) t = LocalTime(t);

t = SecFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getMilliseconds:

case Id_getUTCMilliseconds:

if (!Double.isNaN(t)) {

if (id == Id_getMilliseconds) t = LocalTime(t);

t = msFromTime(t);

}

return ScriptRuntime.wrapNumber(t);

case Id_getTimezoneOffset:

if (!Double.isNaN(t)) {

t = (t - LocalTime(t)) / msPerMinute;

}

return ScriptRuntime.wrapNumber(t);

case Id_setTime:

t = TimeClip(ScriptRuntime.toNumber(args, 0));

realThis.date = t;

return ScriptRuntime.wrapNumber(t);

case Id_setMilliseconds:

case Id_setUTCMilliseconds:

case Id_setSeconds:

case Id_setUTCSeconds:

case Id_setMinutes:

case Id_setUTCMinutes:

case Id_setHours:

case Id_setUTCHours:

t = makeTime(t, args, id);

realThis.date = t;

return ScriptRuntime.wrapNumber(t);

case Id_setDate:

case Id_setUTCDate:

case Id_setMonth:

case Id_setUTCMonth:

case Id_setFullYear:

case Id_setUTCFullYear:

t = makeDate(t, args, id);

realThis.date = t;

return ScriptRuntime.wrapNumber(t);

case Id_setYear:

{

double year = ScriptRuntime.toNumber(args, 0);

if (Double.isNaN(year) || Double.isInfinite(year)) {

t = ScriptRuntime.NaN;

} else {

if (Double.isNaN(t)) {

t = 0;

} else {

t = LocalTime(t);

}

if (year >= 0 && year <= 99)

year += 1900;

double day = MakeDay(year, MonthFromTime(t),

DateFromTime(t));

t = MakeDate(day, TimeWithinDay(t));

t = internalUTC(t);

t = TimeClip(t);

}

}

realThis.date = t;

return ScriptRuntime.wrapNumber(t);

case Id_toISOString:

if (!Double.isNaN(t)) {

return js_toISOString(t);

}

String msg = ScriptRuntime.getMessage0("msg.invalid.date");

throw ScriptRuntime.constructError("RangeError", msg);

default: throw new IllegalArgumentException(String.valueOf(id));

}

}

/* ECMA helper functions */

private static final double HalfTimeDomain = 8.64e15;

private static final double HoursPerDay = 24.0;

private static final double MinutesPerHour = 60.0;

private static final double SecondsPerMinute = 60.0;

private static final double msPerSecond = 1000.0;

private static final double MinutesPerDay = (HoursPerDay * MinutesPerHour);

private static final double SecondsPerDay = (MinutesPerDay * SecondsPerMinute);

private static final double SecondsPerHour = (MinutesPerHour * SecondsPerMinute);

private static final double msPerDay = (SecondsPerDay * msPerSecond);

private static final double msPerHour = (SecondsPerHour * msPerSecond);

private static final double msPerMinute = (SecondsPerMinute * msPerSecond);

private static double Day(double t)

{

return Math.floor(t / msPerDay);

}

private static double TimeWithinDay(double t)

{

double result;

result = t % msPerDay;

if (result < 0)

result += msPerDay;

return result;

}

private static boolean IsLeapYear(int year)

{

return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);

}

/* math here has to be f.p, because we need

private static double DayFromYear(double y)

{

return ((365 * ((y)-1970) + Math.floor(((y)-1969)/4.0)

- Math.floor(((y)-1901)/100.0) + Math.floor(((y)-1601)/400.0)));

}

private static double TimeFromYear(double y)

{

return DayFromYear(y) * msPerDay;

}

private static int YearFromTime(double t)

{

if (Double.isInfinite(t) || Double.isNaN(t)) {

return 0;

}

double y = Math.floor(t / (msPerDay * 365.2425)) + 1970;

double t2 = TimeFromYear(y);

/*

if (t2 > t) {

y--;

} else {

if (t2 + msPerDay * DaysInYear(y) <= t)

y++;

}

return (int)y;

}

private static double DayFromMonth(int m, int year)

{

int day = m * 30;

if (m >= 7) { day += m / 2 - 1; }

else if (m >= 2) { day += (m - 1) / 2 - 1; }

else { day += m; }

if (m >= 2 && IsLeapYear(year)) { ++day; }

return day;

}

private static double DaysInYear(double year)

{

if (Double.isInfinite(year) || Double.isNaN(year)) {

return ScriptRuntime.NaN;

}

return IsLeapYear((int)year) ? 366.0 : 365.0;

}

private static int DaysInMonth(int year, int month)

{

// month is 1-based for DaysInMonth!

if (month == 2)

return IsLeapYear(year) ? 29 : 28;

return month >= 8

? 31 - (month & 1)

: 30 + (month & 1);

}

private static int MonthFromTime(double t)

{

int year = YearFromTime(t);

int d = (int)(Day(t) - DayFromYear(year));

d -= 31 + 28;

if (d < 0) {

return (d < -28) ? 0 : 1;

}

if (IsLeapYear(year)) {

if (d == 0)

return 1; // 29 February

--d;

}

// d: date count from 1 March

int estimate = d / 30; // approx number of month since March

int mstart;

switch (estimate) {

case 0: return 2;

case 1: mstart = 31; break;

case 2: mstart = 31+30; break;

case 3: mstart = 31+30+31; break;

case 4: mstart = 31+30+31+30; break;

case 5: mstart = 31+30+31+30+31; break;

case 6: mstart = 31+30+31+30+31+31; break;

case 7: mstart = 31+30+31+30+31+31+30; break;

case 8: mstart = 31+30+31+30+31+31+30+31; break;

case 9: mstart = 31+30+31+30+31+31+30+31+30; break;

case 10: return 11; //Late december

default: throw Kit.codeBug();

}

// if d < mstart then real month since March == estimate - 1

return (d >= mstart) ? estimate + 2 : estimate + 1;

}

private static int DateFromTime(double t)

{

int year = YearFromTime(t);

int d = (int)(Day(t) - DayFromYear(year));

d -= 31 + 28;

if (d < 0) {

return (d < -28) ? d + 31 + 28 + 1 : d + 28 + 1;

}

if (IsLeapYear(year)) {

if (d == 0)

return 29; // 29 February

--d;

}

// d: date count from 1 March

int mdays, mstart;

switch (d / 30) { // approx number of month since March

case 0: return d + 1;

case 1: mdays = 31; mstart = 31; break;

case 2: mdays = 30; mstart = 31+30; break;

case 3: mdays = 31; mstart = 31+30+31; break;

case 4: mdays = 30; mstart = 31+30+31+30; break;

case 5: mdays = 31; mstart = 31+30+31+30+31; break;

case 6: mdays = 31; mstart = 31+30+31+30+31+31; break;

case 7: mdays = 30; mstart = 31+30+31+30+31+31+30; break;

case 8: mdays = 31; mstart = 31+30+31+30+31+31+30+31; break;

case 9: mdays = 30; mstart = 31+30+31+30+31+31+30+31+30; break;

case 10:

return d - (31+30+31+30+31+31+30+31+30) + 1; //Late december

default: throw Kit.codeBug();

}

d -= mstart;

if (d < 0) {

// wrong estimate: sfhift to previous month

d += mdays;

}

return d + 1;

}

private static int WeekDay(double t)

{

double result;

result = Day(t) + 4;

result = result % 7;

if (result < 0)

result += 7;

return (int) result;

}

private static double now()

{

return System.currentTimeMillis();

}

private static double DaylightSavingTA(double t)

{

// Another workaround! The JRE doesn't seem to know about DST

// before year 1 AD, so we map to equivalent dates for the

// purposes of finding DST. To be safe, we do this for years

// before 1970.

if (t < 0.0) {

int year = EquivalentYear(YearFromTime(t));

double day = MakeDay(year, MonthFromTime(t), DateFromTime(t));

t = MakeDate(day, TimeWithinDay(t));

}

Date date = new Date((long) t);

if (thisTimeZone.inDaylightTime(date))

return msPerHour;

return 0;

}

/*

private static int EquivalentYear(int year)

{

int day = (int) DayFromYear(year) + 4;

day = day % 7;

if (day < 0)

day += 7;

// Years and leap years on which Jan 1 is a Sunday, Monday, etc.

if (IsLeapYear(year)) {

switch (day) {

case 0: return 1984;

case 1: return 1996;

case 2: return 1980;

case 3: return 1992;

case 4: return 1976;

case 5: return 1988;

case 6: return 1972;

}

} else {

switch (day) {

case 0: return 1978;

case 1: return 1973;

case 2: return 1985;

case 3: return 1986;

case 4: return 1981;

case 5: return 1971;

case 6: return 1977;

}

}

// Unreachable

throw Kit.codeBug();

}

private static double LocalTime(double t)

{

return t + LocalTZA + DaylightSavingTA(t);

}

private static double internalUTC(double t)

{

return t - LocalTZA - DaylightSavingTA(t - LocalTZA);

}

private static int HourFromTime(double t)

{

double result;

result = Math.floor(t / msPerHour) % HoursPerDay;

if (result < 0)

result += HoursPerDay;

return (int) result;

}

private static int MinFromTime(double t)

{

double result;

result = Math.floor(t / msPerMinute) % MinutesPerHour;

if (result < 0)

result += MinutesPerHour;

return (int) result;

}

private static int SecFromTime(double t)

{

double result;

result = Math.floor(t / msPerSecond) % SecondsPerMinute;

if (result < 0)

result += SecondsPerMinute;

return (int) result;

}

private static int msFromTime(double t)

{

double result;

result = t % msPerSecond;

if (result < 0)

result += msPerSecond;

return (int) result;

}

private static double MakeTime(double hour, double min,

double sec, double ms)

{

return ((hour * MinutesPerHour + min) * SecondsPerMinute + sec)

* msPerSecond + ms;

}

private static double MakeDay(double year, double month, double date)

{

year += Math.floor(month / 12);

month = month % 12;

if (month < 0)

month += 12;

double yearday = Math.floor(TimeFromYear(year) / msPerDay);

double monthday = DayFromMonth((int)month, (int)year);

return yearday + monthday + date - 1;

}

private static double MakeDate(double day, double time)

{

return day * msPerDay + time;

}

private static double TimeClip(double d)

{

if (Double.isNaN(d) ||

d == Double.POSITIVE_INFINITY ||

d == Double.NEGATIVE_INFINITY ||

Math.abs(d) > HalfTimeDomain)

{

return ScriptRuntime.NaN;

}

if (d > 0.0)

return Math.floor(d + 0.);

return Math.ceil(d + 0.);

}

/* end of ECMA helper functions */

/* find UTC time from given date... no 1900 correction! */

private static double date_msecFromDate(double year, double mon,

double mday, double hour,

double min, double sec,

double msec)

{

double day;

double time;

double result;

day = MakeDay(year, mon, mday);

time = MakeTime(hour, min, sec, msec);

result = MakeDate(day, time);

return result;

}

/* compute the time in msec (unclipped) from the given args */

private static final int MAXARGS = 7;

private static double date_msecFromArgs(Object[] args)

{

double array[] = new double[MAXARGS];

int loop;

double d;

for (loop = 0; loop < MAXARGS; loop++) {

if (loop < args.length) {

d = ScriptRuntime.toNumber(args[loop]);

if (Double.isNaN(d) || Double.isInfinite(d)) {

return ScriptRuntime.NaN;

}

array[loop] = ScriptRuntime.toInteger(args[loop]);

} else {

if (loop == 2) {

array[loop] = 1; /* Default the date argument to 1. */

} else {

array[loop] = 0;

}

}

}

/* adjust 2-digit years into the 20th century */

if (array[0] >= 0 && array[0] <= 99)

array[0] += 1900;

return date_msecFromDate(array[0], array[1], array[2],

array[3], array[4], array[5], array[6]);

}

private static double jsStaticFunction_UTC(Object[] args)

{

if (args.length == 0) {

return ScriptRuntime.NaN;

}

return TimeClip(date_msecFromArgs(args));

}

/**

private static double parseISOString(String s) {

// we use a simple state machine to parse the input string

final int ERROR = -1;

final int YEAR = 0, MONTH = 1, DAY = 2;

final int HOUR = 3, MIN = 4, SEC = 5, MSEC = 6;

final int TZHOUR = 7, TZMIN = 8;

int state = YEAR;

// default values per [15.9.1.15 Date Time String Format]

int[] values = { 1970, 1, 1, 0, 0, 0, 0, -1, -1 };

int yearlen = 4, yearmod = 1, tzmod = 1;

int i = 0, len = s.length();

if (len != 0) {

char c = s.charAt(0);

if (c == '+' || c == '-') {

// 15.9.1.15.1 Extended years

i += 1;

yearlen = 6;

yearmod = (c == '-') ? -1 : 1;

} else if (c == 'T') {

// time-only forms no longer in spec, but follow spidermonkey here

i += 1;

state = HOUR;

}

}

loop: while (state != ERROR) {

int m = i + (state == YEAR ? yearlen : state == MSEC ? 3 : 2);

if (m > len) {

state = ERROR;

break;

}

int value = 0;

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

char c = s.charAt(i);

if (c < '0' || c > '9') { state = ERROR; break loop; }

value = 10 * value + (c - '0');

}

values[state] = value;

if (i == len) {

// reached EOF, check for end state

switch (state) {

case HOUR:

case TZHOUR:

state = ERROR;

}

break;

}

char c = s.charAt(i++);

if (c == 'Z') {

// handle abbrevation for UTC timezone

values[TZHOUR] = 0;

values[TZMIN] = 0;

switch (state) {

case MIN:

case SEC:

case MSEC:

break;

default:

state = ERROR;

}

break;

}

// state transition

switch (state) {

case YEAR:

case MONTH:

state = (c == '-' ? state + 1 : c == 'T' ? HOUR : ERROR);

break;

case DAY:

state = (c == 'T' ? HOUR : ERROR);

break;

case HOUR:

state = (c == ':' ? MIN : ERROR);

break;

case TZHOUR:

// state = (c == ':' ? state + 1 : ERROR);

// Non-standard extension, https://bugzilla.mozilla.org/show_bug.cgi?id=682754

if (c != ':') {

// back off by one and try to read without ':' separator

i -= 1;

}

state = TZMIN;

break;

case MIN:

state = (c == ':' ? SEC : c == '+' || c == '-' ? TZHOUR : ERROR);

break;

case SEC:

state = (c == '.' ? MSEC : c == '+' || c == '-' ? TZHOUR : ERROR);

break;

case MSEC:

state = (c == '+' || c == '-' ? TZHOUR : ERROR);

break;

case TZMIN:

state = ERROR;

break;

}

if (state == TZHOUR) {

// save timezone modificator

tzmod = (c == '-') ? -1 : 1;

}

}

syntax: {

// error or unparsed characters

if (state == ERROR || i != len) break syntax;

// check values

int year = values[YEAR], month = values[MONTH], day = values[DAY];

int hour = values[HOUR], min = values[MIN], sec = values[SEC], msec = values[MSEC];

int tzhour = values[TZHOUR], tzmin = values[TZMIN];

if (year > 275943 // ceil(1e8/365) + 1970 = 275943

|| (month < 1 || month > 12)

|| (day < 1 || day > DaysInMonth(year, month))

|| hour > 24

|| (hour == 24 && (min > 0 || sec > 0 || msec > 0))

|| min > 59

|| sec > 59

|| tzhour > 23

|| tzmin > 59

) {

break syntax;

}

// valid ISO-8601 format, compute date in milliseconds

double date = date_msecFromDate(year * yearmod, month - 1, day,

hour, min, sec, msec);

if (tzhour == -1) {

// Spec says to use UTC timezone, the following bug report says

// that local timezone was meant to be used. Stick with spec for now.

// https://bugs.ecmascript.org/show_bug.cgi?id=112

// date = internalUTC(date);

} else {

date -= (tzhour * 60 + tzmin) * msPerMinute * tzmod;

}

if (date < -HalfTimeDomain || date > HalfTimeDomain) break syntax;

return date;

}

// invalid ISO-8601 format, return NaN

return ScriptRuntime.NaN;

}

private static double date_parseString(String s)

{

double d = parseISOString(s);

if (!Double.isNaN(d)) {

return d;

}

int year = -1;

int mon = -1;

int mday = -1;

int hour = -1;

int min = -1;

int sec = -1;

char c = 0;

char si = 0;

int i = 0;

int n = -1;

double tzoffset = -1;

char prevc = 0;

int limit = 0;

boolean seenplusminus = false;

limit = s.length();

while (i < limit) {

c = s.charAt(i);

i++;

if (c <= ' ' || c == ',' || c == '-') {

if (i < limit) {

si = s.charAt(i);

if (c == '-' && '0' <= si && si <= '9') {

prevc = c;

}

}

continue;

}

if (c == '(') { /* comments) */

int depth = 1;

while (i < limit) {

c = s.charAt(i);

i++;

if (c == '(')

depth++;

else if (c == ')')

if (--depth <= 0)

break;

}

continue;

}

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

n = c - '0';

while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {

n = n * 10 + c - '0';

i++;

}

/* allow TZA before the year, so

/* uses of seenplusminus allow : in TZA, so Java

if ((prevc == '+' || prevc == '-')/* && year>=0 */) {

/* make ':' case below change tzoffset */

seenplusminus = true;

/* offset */

if (n < 24)

n = n * 60; /* EG. "GMT-3" */

else

n = n % 100 + n / 100 * 60; /* eg "GMT-0430" */

if (prevc == '+') /* plus means east of GMT */

n = -n;

if (tzoffset != 0 && tzoffset != -1)

return ScriptRuntime.NaN;