public static void finishInit(Scriptable scope, FunctionObject ctor,

Scriptable proto)

throws PropertyException

{

// initialization of cached values moved to static initializers.

// alias toUTCString to toGMTString

((ScriptableObject) proto).defineProperty("toGMTString",

proto.get("toUTCString", proto),

ScriptableObject.DONTENUM);

// Set some method length values.

// These functions need to be varargs, because their behavior

// depends on the number of arguments they are called with.

String[] specialLengthNames = { "setSeconds", "setUTCSeconds",

"setMinutes", "setUTCMinutes",

"setHours", "setUTCHours",

"setMonth", "setUTCMonth",

"setFullYear", "setUTCFullYear",

};

short[] specialLengthValues = { 2, 2,

3, 3,

4, 4,

2, 2,

3, 3,

};

for (int i=0; i < specialLengthNames.length; i++) {

Object obj = proto.get(specialLengthNames[i], proto);

((FunctionObject) obj).setLength(specialLengthValues[i]);

}

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

((NativeDate)proto).date = ScriptRuntime.NaN;

}

public NativeDate() {

}

public String getClassName() {

return "Date";

}

public Object getDefaultValue(Class typeHint) {

if (typeHint == null)

typeHint = ScriptRuntime.StringClass;

return super.getDefaultValue(typeHint);

}

/* ECMA helper functions */

private static boolean isFinite(double d) {

if (d != d ||

d == Double.POSITIVE_INFINITY ||

d == Double.NEGATIVE_INFINITY)

return false;

else

return true;

}

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 int DaysInYear(int y) {

if (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))

return 366;

else

return 365;

}

/* 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) {

int lo = (int) Math.floor((t / msPerDay) / 366) + 1970;

int hi = (int) Math.floor((t / msPerDay) / 365) + 1970;

int mid;

/* above doesn't work for negative dates... */

if (hi < lo) {

int temp = lo;

lo = hi;

hi = temp;

}

/* Use a simple binary search algorithm to find the right

while (hi > lo) {

mid = (hi + lo) / 2;

if (TimeFromYear(mid) > t) {

hi = mid - 1;

} else {

if (TimeFromYear(mid) <= t) {

int temp = mid + 1;

if (TimeFromYear(temp) > t) {

return mid;

}

lo = mid + 1;

}

}

}

return lo;

}

private static boolean InLeapYear(double t) {

return DaysInYear(YearFromTime(t)) == 366;

}

private static int DayWithinYear(double t) {

int year = YearFromTime(t);

return (int) (Day(t) - DayFromYear(year));

}

/*

private static double DayFromMonth(int m, boolean leap) {

double firstDay[] = {0.0, 31.0, 59.0, 90.0, 120.0, 151.0,

181.0, 212.0, 243.0, 273.0, 304.0, 334.0};

double leapFirstDay[] = {0.0, 31.0, 60.0, 91.0, 121.0, 152.0,

182.0, 213.0, 244.0, 274.0, 305.0, 335.0};

if (leap)

return leapFirstDay[m];

else

return firstDay[m];

}

private static int MonthFromTime(double t) {

int d, step;

d = DayWithinYear(t);

if (d < (step = 31))

return 0;

// Originally coded as step += (InLeapYear(t) ? 29 : 28);

// but some jits always returned 28!

if (InLeapYear(t))

step += 29;

else

step += 28;

if (d < step)

return 1;

if (d < (step += 31))

return 2;

if (d < (step += 30))

return 3;

if (d < (step += 31))

return 4;

if (d < (step += 30))

return 5;

if (d < (step += 31))

return 6;

if (d < (step += 31))

return 7;

if (d < (step += 30))

return 8;

if (d < (step += 31))

return 9;

if (d < (step += 30))

return 10;

return 11;

}

private static int DateFromTime(double t) {

int d, step, next;

d = DayWithinYear(t);

if (d <= (next = 30))

return d + 1;

step = next;

// Originally coded as next += (InLeapYear(t) ? 29 : 28);

// but some jits always returned 28!

if (InLeapYear(t))

next += 29;

else

next += 28;

if (d <= next)

return d - step;

step = next;

if (d <= (next += 31))

return d - step;

step = next;

if (d <= (next += 30))

return d - step;

step = next;

if (d <= (next += 31))

return d - step;

step = next;

if (d <= (next += 30))

return d - step;

step = next;

if (d <= (next += 31))

return d - step;

step = next;

if (d <= (next += 31))

return d - step;

step = next;

if (d <= (next += 30))

return d - step;

step = next;

if (d <= (next += 31))

return d - step;

step = next;

if (d <= (next += 30))

return d - step;

step = next;

return d - step;

}

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 (double) System.currentTimeMillis();

}

/* Should be possible to determine the need for this dynamically

private final static boolean TZO_WORKAROUND = false;

private static double DaylightSavingTA(double t) {

if (!TZO_WORKAROUND) {

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

if (thisTimeZone.inDaylightTime(date))

return msPerHour;

else

return 0;

} else {

/* Use getOffset if inDaylightTime() is broken, because it

// Hardcode the assumption that the changeover always

// happens at 2:00 AM:

t += LocalTZA + (HourFromTime(t) <= 2 ? msPerHour : 0);

int year = YearFromTime(t);

double offset = thisTimeZone.getOffset(year > 0 ? 1 : 0,

year,

MonthFromTime(t),

DateFromTime(t),

WeekDay(t),

(int)TimeWithinDay(t));

if ((offset - LocalTZA) != 0)

return msPerHour;

else

return 0;

// return offset - LocalTZA;

}

}

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) {

double result;

boolean leap;

double yearday;

double monthday;

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

month = month % 12;

if (month < 0)

month += 12;

leap = (DaysInYear((int) year) == 366);

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

monthday = DayFromMonth((int) month, leap);

result = yearday

+ monthday

+ date - 1;

return result;

}

private static double MakeDate(double day, double time) {

return day * msPerDay + time;

}

private static double TimeClip(double d) {

if (d != 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.);

else

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;

}

private static final int MAXARGS = 7;

public static double jsStaticFunction_UTC(Context cx, Scriptable thisObj,

Object[] args, Function funObj)

{

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 (d != d || Double.isInfinite(d)) {

return ScriptRuntime.NaN;

}

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

} else {

array[loop] = 0;

}

}

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

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

array[0] += 1900;

/* if we got a 0 for 'date' (which is out of range)

if (array[2] < 1)

array[2] = 1;

d = date_msecFromDate(array[0], array[1], array[2],

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

d = TimeClip(d);

return d;

// return new Double(d);

}

/*

/* for use by date_parse */

/* replace this with byte arrays? Cheaper? */

private static String wtb[] = {

"am", "pm",

"monday", "tuesday", "wednesday", "thursday", "friday",

"saturday", "sunday",

"january", "february", "march", "april", "may", "june",

"july", "august", "september", "october", "november", "december",

"gmt", "ut", "utc", "est", "edt", "cst", "cdt",

"mst", "mdt", "pst", "pdt"

/* time zone table needs to be expanded */

};

private static int ttb[] = {

-1, -2, 0, 0, 0, 0, 0, 0, 0, /* AM/PM */

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,

10000 + 0, 10000 + 0, 10000 + 0, /* UT/UTC */

10000 + 5 * 60, 10000 + 4 * 60, /* EDT */

10000 + 6 * 60, 10000 + 5 * 60,

10000 + 7 * 60, 10000 + 6 * 60,

10000 + 8 * 60, 10000 + 7 * 60

};

/* helper for date_parse */

private static boolean date_regionMatches(String s1, int s1off,

String s2, int s2off,

int count)

{

boolean result = false;

/* return true if matches, otherwise, false */

int s1len = s1.length();

int s2len = s2.length();

while (count > 0 && s1off < s1len && s2off < s2len) {

if (Character.toLowerCase(s1.charAt(s1off)) !=

Character.toLowerCase(s2.charAt(s2off)))

break;

s1off++;

s2off++;

count--;

}

if (count == 0) {

result = true;

}

return result;

}

private static double date_parseString(String s) {

double msec;

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;

if (s == null) // ??? Will s be null?

return ScriptRuntime.NaN;

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;

tzoffset = n;

} else if (n >= 70 ||

(prevc == '/' && mon >= 0 && mday >= 0 && year < 0)) {

if (year >= 0)

return ScriptRuntime.NaN;

else if (c <= ' ' || c == ',' || c == '/' || i >= limit)

year = n < 100 ? n + 1900 : n;

else

return ScriptRuntime.NaN;

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

if (hour < 0)

hour = /*byte*/ n;

else if (min < 0)

min = /*byte*/ n;

else

return ScriptRuntime.NaN;

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

if (mon < 0)

mon = /*byte*/ n-1;

else if (mday < 0)

mday = /*byte*/ n;

else

return ScriptRuntime.NaN;

} else if (i < limit && c != ',' && c > ' ' && c != '-') {

return ScriptRuntime.NaN;

} else if (seenplusminus && n < 60) { /* handle GMT-3:30 */

if (tzoffset < 0)

tzoffset -= n;

else

tzoffset += n;

} else if (hour >= 0 && min < 0) {

min = /*byte*/ n;

} else if (min >= 0 && sec < 0) {

sec = /*byte*/ n;

} else if (mday < 0) {

mday = /*byte*/ n;

} else {

return ScriptRuntime.NaN;

}

prevc = 0;

} else if (c == '/' || c == ':' || c == '+' || c == '-') {

prevc = c;

} else {

int st = i - 1;

int k;

while (i < limit) {

c = s.charAt(i);

if (!(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')))

break;

i++;

}

if (i <= st + 1)

return ScriptRuntime.NaN;

for (k = wtb.length; --k >= 0;)

if (date_regionMatches(wtb[k], 0, s, st, i-st)) {

int action = ttb[k];

if (action != 0) {

if (action < 0) {

/*

if (hour > 12 || hour < 0) {

return ScriptRuntime.NaN;

} else {

if (action == -1 && hour == 12) { // am

hour = 0;

} else if (action == -2 && hour != 12) {// pm

hour += 12;

}

}

} else if (action <= 13) { /* month! */

if (mon < 0) {

mon = /*byte*/ (action - 2);

} else {

return ScriptRuntime.NaN;

}

} else {

tzoffset = action - 10000;

}

}

break;

}

if (k < 0)

return ScriptRuntime.NaN;

prevc = 0;

}

}

if (year < 0 || mon < 0 || mday < 0)

return ScriptRuntime.NaN;

if (sec < 0)

sec = 0;

if (min < 0)

min = 0;

if (hour < 0)

hour = 0;

if (tzoffset == -1) { /* no time zone specified, have to use local */

double time;

time = date_msecFromDate(year, mon, mday, hour, min, sec, 0);

return internalUTC(time);

}

msec = date_msecFromDate(year, mon, mday, hour, min, sec, 0);

msec += tzoffset * msPerMinute;

return msec;

}

public static double jsStaticFunction_parse(String s) {

return date_parseString(s);

}

private static String date_format(double t) {

StringBuffer result = new StringBuffer(60);

double local = LocalTime(t);

/* offset from GMT in minutes. The offset includes daylight savings,

int minutes = (int) Math.floor((LocalTZA + DaylightSavingTA(t))

/ msPerMinute);

/* map 510 minutes to 0830 hours */

int offset = (minutes / 60) * 100 + minutes % 60;

String dateStr = Integer.toString(DateFromTime(local));

String hourStr = Integer.toString(HourFromTime(local));

String minStr = Integer.toString(MinFromTime(local));

String secStr = Integer.toString(SecFromTime(local));

String offsetStr = Integer.toString(offset > 0 ? offset : -offset);

int year = YearFromTime(local);

String yearStr = Integer.toString(year > 0 ? year : -year);

result.append(days[WeekDay(local)]);

result.append(" ");

result.append(months[MonthFromTime(local)]);

if (dateStr.length() == 1)

result.append(" 0");

else

result.append(" ");

result.append(dateStr);

if (hourStr.length() == 1)

result.append(" 0");

else

result.append(" ");

result.append(hourStr);

if (minStr.length() == 1)

result.append(":0");

else

result.append(":");

result.append(minStr);

if (secStr.length() == 1)

result.append(":0");

else

result.append(":");

result.append(secStr);

if (offset > 0)

result.append(" GMT+");

else

result.append(" GMT-");

int i;

for (i = offsetStr.length(); i < 4; i++)

result.append("0");

result.append(offsetStr);

// ask Java for a time zone string, if we've been able to find

// a formatter for it.

if (timeZoneFormatter != null) {

result.append(" (");

java.util.Date date = new Date((long) t);

result.append(timeZoneFormatter.format(date));

result.append(") ");

} else {

result.append(" ");

}

if (year < 0)

result.append("-");

for (i = yearStr.length(); i < 4; i++)

result.append("0");

result.append(yearStr);

return result.toString();

}

/* the javascript constructor */

public static Object jsConstructor(Context cx, Object[] args,

Function ctorObj, boolean inNewExpr)

{

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

// representing the current time.

if (!inNewExpr)

return date_format(Now());

NativeDate obj = new NativeDate();

// if called as a constructor with no args,

// return a new Date with the current time.

if (args.length == 0) {

obj.date = Now();

return obj;

}

// if called with just one arg -

if (args.length == 1) {

double date;

// if it's not a string, use it as a millisecond date

if (!(args[0] instanceof String)) {

date = ScriptRuntime.toNumber(args[0]);

} else {

// it's a string; parse it.

String str = (String) args[0];

date = date_parseString(str);

}

obj.date = TimeClip(date);

return obj;

}

// multiple arguments; year, month, day etc.

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 (d != d || Double.isInfinite(d)) {

obj.date = ScriptRuntime.NaN;

return obj;

}

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

} else {

array[loop] = 0;

}

}

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

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

array[0] += 1900;

/* if we got a 0 for 'date' (which is out of range)

if (array[2] < 1)

array[2] = 1;

double day = MakeDay(array[0], array[1], array[2]);

double time = MakeTime(array[3], array[4], array[5], array[6]);

time = MakeDate(day, time);

time = internalUTC(time);

obj.date = TimeClip(time);

return obj;

}

/* constants for toString, toUTCString */

private static String js_NaN_date_str = "Invalid Date";

private static String[] days = {

"Sun","Mon","Tue","Wed","Thu","Fri","Sat"

};

private static String[] months = {

"Jan", "Feb", "Mar", "Apr", "May", "Jun",

"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

};

public String jsFunction_toString() {

/* all for want of printf. All of this garbage seems necessary

if (this.date != this.date)

return js_NaN_date_str;

return date_format(this.date);

}

public String jsFunction_toLocaleString() {

if (this.date != this.date)

return js_NaN_date_str;

// the string this returns doesn't have much resemblance

// to what jsdate.c returns... does this matter?

java.util.Date tempdate = new Date((long) this.date);

return localeDateFormatter.format(tempdate);

}

public String jsFunction_toUTCString() {

if (this.date != this.date)

return js_NaN_date_str;

StringBuffer result = new StringBuffer(60);

String dateStr = Integer.toString(DateFromTime(this.date));

String hourStr = Integer.toString(HourFromTime(this.date));

String minStr = Integer.toString(MinFromTime(this.date));

String secStr = Integer.toString(SecFromTime(this.date));

int year = YearFromTime(this.date);

String yearStr = Integer.toString(year > 0 ? year : -year);

result.append(days[WeekDay(this.date)]);

result.append(", ");

if (dateStr.length() == 1)

result.append("0");

result.append(dateStr);

result.append(" ");

result.append(months[MonthFromTime(this.date)]);

if (year < 0)

result.append(" -");

else

result.append(" ");

int i;

for (i = yearStr.length(); i < 4; i++)

result.append("0");

result.append(yearStr);

if (hourStr.length() == 1)

result.append(" 0");

else

result.append(" ");

result.append(hourStr);

if (minStr.length() == 1)

result.append(":0");

else

result.append(":");

result.append(minStr);

if (secStr.length() == 1)

result.append(":0");

else

result.append(":");

result.append(secStr);

result.append(" GMT");

return result.toString();

}

public double jsFunction_valueOf() {

return this.date;

}

public double jsFunction_getTime() {

return this.date;

}

public double jsFunction_getYear() {

if (this.date != this.date)

return this.date;

int result = YearFromTime(LocalTime(this.date));

/*

Context cx = Context.getContext();

int version = cx.getLanguageVersion();

if (version == Context.VERSION_1_0 ||

version == Context.VERSION_1_1 ||

version == Context.VERSION_1_2)

{

if (result >= 1900 && result < 2000)

result -= 1900;

} else {