1 /* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
\r
3 * The contents of this file are subject to the Netscape Public
\r
4 * License Version 1.1 (the "License"); you may not use this file
\r
5 * except in compliance with the License. You may obtain a copy of
\r
6 * the License at http://www.mozilla.org/NPL/
\r
8 * Software distributed under the License is distributed on an "AS
\r
9 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
\r
10 * implied. See the License for the specific language governing
\r
11 * rights and limitations under the License.
\r
13 * The Original Code is Rhino code, released
\r
16 * The Initial Developer of the Original Code is Netscape
\r
17 * Communications Corporation. Portions created by Netscape are
\r
18 * Copyright (C) 1997-1999 Netscape Communications Corporation. All
\r
25 * Alternatively, the contents of this file may be used under the
\r
26 * terms of the GNU Public License (the "GPL"), in which case the
\r
27 * provisions of the GPL are applicable instead of those above.
\r
28 * If you wish to allow use of your version of this file only
\r
29 * under the terms of the GPL and not to allow others to use your
\r
30 * version of this file under the NPL, indicate your decision by
\r
31 * deleting the provisions above and replace them with the notice
\r
32 * and other provisions required by the GPL. If you do not delete
\r
33 * the provisions above, a recipient may use your version of this
\r
34 * file under either the NPL or the GPL.
\r
37 package org.mozilla.javascript;
\r
39 import java.util.Date;
\r
40 import java.util.TimeZone;
\r
41 import java.util.Locale;
\r
42 import java.text.NumberFormat;
\r
43 import java.text.DateFormat;
\r
44 import java.text.SimpleDateFormat;
\r
47 * This class implements the Date native object.
\r
49 * @author Mike McCabe
\r
51 public class NativeDate extends IdScriptable {
\r
53 public static void init(Context cx, Scriptable scope, boolean sealed) {
\r
54 NativeDate obj = new NativeDate();
\r
55 obj.prototypeFlag = true;
\r
57 // Set the value of the prototype Date to NaN ('invalid date');
\r
58 obj.date = ScriptRuntime.NaN;
\r
60 obj.addAsPrototype(MAX_PROTOTYPE_ID, cx, scope, sealed);
\r
63 public NativeDate() {
\r
64 if (thisTimeZone == null) {
\r
65 // j.u.TimeZone is synchronized, so setting class statics from it
\r
67 thisTimeZone = java.util.TimeZone.getDefault();
\r
68 LocalTZA = thisTimeZone.getRawOffset();
\r
72 public String getClassName() {
\r
76 public Object getDefaultValue(Class typeHint) {
\r
77 if (typeHint == null)
\r
78 typeHint = ScriptRuntime.StringClass;
\r
79 return super.getDefaultValue(typeHint);
\r
82 protected void fillConstructorProperties
\r
83 (Context cx, IdFunction ctor, boolean sealed)
\r
85 addIdFunctionProperty(ctor, ConstructorId_UTC, sealed);
\r
86 addIdFunctionProperty(ctor, ConstructorId_parse, sealed);
\r
87 super.fillConstructorProperties(cx, ctor, sealed);
\r
90 public int methodArity(int methodId) {
\r
91 if (prototypeFlag) {
\r
93 case ConstructorId_UTC: return 1;
\r
94 case ConstructorId_parse: return 1;
\r
95 case Id_constructor: return 1;
\r
96 case Id_toString: return 0;
\r
97 case Id_toTimeString: return 0;
\r
98 case Id_toDateString: return 0;
\r
99 case Id_toLocaleString: return 0;
\r
100 case Id_toLocaleTimeString: return 0;
\r
101 case Id_toLocaleDateString: return 0;
\r
102 case Id_toUTCString: return 0;
\r
103 case Id_valueOf: return 0;
\r
104 case Id_getTime: return 0;
\r
105 case Id_getYear: return 0;
\r
106 case Id_getFullYear: return 0;
\r
107 case Id_getUTCFullYear: return 0;
\r
108 case Id_getMonth: return 0;
\r
109 case Id_getUTCMonth: return 0;
\r
110 case Id_getDate: return 0;
\r
111 case Id_getUTCDate: return 0;
\r
112 case Id_getDay: return 0;
\r
113 case Id_getUTCDay: return 0;
\r
114 case Id_getHours: return 0;
\r
115 case Id_getUTCHours: return 0;
\r
116 case Id_getMinutes: return 0;
\r
117 case Id_getUTCMinutes: return 0;
\r
118 case Id_getSeconds: return 0;
\r
119 case Id_getUTCSeconds: return 0;
\r
120 case Id_getMilliseconds: return 0;
\r
121 case Id_getUTCMilliseconds: return 0;
\r
122 case Id_getTimezoneOffset: return 0;
\r
123 case Id_setTime: return 1;
\r
124 case Id_setMilliseconds: return 1;
\r
125 case Id_setUTCMilliseconds: return 1;
\r
126 case Id_setSeconds: return 2;
\r
127 case Id_setUTCSeconds: return 2;
\r
128 case Id_setMinutes: return 3;
\r
129 case Id_setUTCMinutes: return 3;
\r
130 case Id_setHours: return 4;
\r
131 case Id_setUTCHours: return 4;
\r
132 case Id_setDate: return 1;
\r
133 case Id_setUTCDate: return 1;
\r
134 case Id_setMonth: return 2;
\r
135 case Id_setUTCMonth: return 2;
\r
136 case Id_setFullYear: return 3;
\r
137 case Id_setUTCFullYear: return 3;
\r
138 case Id_setYear: return 1;
\r
141 return super.methodArity(methodId);
\r
144 public String toString() {
\r
145 return date_format(date, FORMATSPEC_FULL);
\r
148 public Object execMethod
\r
149 (int methodId, IdFunction f,
\r
150 Context cx, Scriptable scope, Scriptable thisObj, Object[] args)
\r
151 throws JavaScriptException
\r
153 if (prototypeFlag) {
\r
154 switch (methodId) {
\r
155 case ConstructorId_UTC:
\r
156 return wrap_double(jsStaticFunction_UTC(args));
\r
158 case ConstructorId_parse:
\r
159 return wrap_double(jsStaticFunction_parse
\r
160 (ScriptRuntime.toString(args, 0)));
\r
162 case Id_constructor:
\r
163 return jsConstructor(args, thisObj == null);
\r
165 case Id_toString: {
\r
166 double t = realThis(thisObj, f, true).date;
\r
167 return date_format(t, FORMATSPEC_FULL);
\r
170 case Id_toTimeString: {
\r
171 double t = realThis(thisObj, f, true).date;
\r
172 return date_format(t, FORMATSPEC_TIME);
\r
175 case Id_toDateString: {
\r
176 double t = realThis(thisObj, f, true).date;
\r
177 return date_format(t, FORMATSPEC_DATE);
\r
180 case Id_toLocaleString: {
\r
181 double t = realThis(thisObj, f, true).date;
\r
182 return jsFunction_toLocaleString(t);
\r
185 case Id_toLocaleTimeString: {
\r
186 double t = realThis(thisObj, f, true).date;
\r
187 return jsFunction_toLocaleTimeString(t);
\r
190 case Id_toLocaleDateString: {
\r
191 double t = realThis(thisObj, f, true).date;
\r
192 return jsFunction_toLocaleDateString(t);
\r
195 case Id_toUTCString: {
\r
196 double t = realThis(thisObj, f, true).date;
\r
197 if (t == t) { return jsFunction_toUTCString(t); }
\r
198 return jsFunction_NaN_date_str;
\r
202 return wrap_double(realThis(thisObj, f, true).date);
\r
205 return wrap_double(realThis(thisObj, f, true).date);
\r
208 double t = realThis(thisObj, f, true).date;
\r
209 if (t == t) { t = jsFunction_getYear(cx, t); }
\r
210 return wrap_double(t);
\r
213 case Id_getFullYear: {
\r
214 double t = realThis(thisObj, f, true).date;
\r
215 if (t == t) { t = YearFromTime(LocalTime(t)); }
\r
216 return wrap_double(t);
\r
219 case Id_getUTCFullYear: {
\r
220 double t = realThis(thisObj, f, true).date;
\r
221 if (t == t) { t = YearFromTime(t); }
\r
222 return wrap_double(t);
\r
225 case Id_getMonth: {
\r
226 double t = realThis(thisObj, f, true).date;
\r
227 if (t == t) { t = MonthFromTime(LocalTime(t)); }
\r
228 return wrap_double(t);
\r
231 case Id_getUTCMonth: {
\r
232 double t = realThis(thisObj, f, true).date;
\r
233 if (t == t) { t = MonthFromTime(t); }
\r
234 return wrap_double(t);
\r
238 double t = realThis(thisObj, f, true).date;
\r
239 if (t == t) { t = DateFromTime(LocalTime(t)); }
\r
240 return wrap_double(t);
\r
243 case Id_getUTCDate: {
\r
244 double t = realThis(thisObj, f, true).date;
\r
245 if (t == t) { t = DateFromTime(t); }
\r
246 return wrap_double(t);
\r
250 double t = realThis(thisObj, f, true).date;
\r
251 if (t == t) { t = WeekDay(LocalTime(t)); }
\r
252 return wrap_double(t);
\r
255 case Id_getUTCDay: {
\r
256 double t = realThis(thisObj, f, true).date;
\r
257 if (t == t) { t = WeekDay(t); }
\r
258 return wrap_double(t);
\r
261 case Id_getHours: {
\r
262 double t = realThis(thisObj, f, true).date;
\r
263 if (t == t) { t = HourFromTime(LocalTime(t)); }
\r
264 return wrap_double(t);
\r
267 case Id_getUTCHours: {
\r
268 double t = realThis(thisObj, f, true).date;
\r
269 if (t == t) { t = HourFromTime(t); }
\r
270 return wrap_double(t);
\r
273 case Id_getMinutes: {
\r
274 double t = realThis(thisObj, f, true).date;
\r
275 if (t == t) { t = MinFromTime(LocalTime(t)); }
\r
276 return wrap_double(t);
\r
279 case Id_getUTCMinutes: {
\r
280 double t = realThis(thisObj, f, true).date;
\r
281 if (t == t) { t = MinFromTime(t); }
\r
282 return wrap_double(t);
\r
285 case Id_getSeconds: {
\r
286 double t = realThis(thisObj, f, true).date;
\r
287 if (t == t) { t = SecFromTime(LocalTime(t)); }
\r
288 return wrap_double(t);
\r
291 case Id_getUTCSeconds: {
\r
292 double t = realThis(thisObj, f, true).date;
\r
293 if (t == t) { t = SecFromTime(t); }
\r
294 return wrap_double(t);
\r
297 case Id_getMilliseconds: {
\r
298 double t = realThis(thisObj, f, true).date;
\r
299 if (t == t) { t = msFromTime(LocalTime(t)); }
\r
300 return wrap_double(t);
\r
303 case Id_getUTCMilliseconds: {
\r
304 double t = realThis(thisObj, f, true).date;
\r
305 if (t == t) { t = msFromTime(t); }
\r
306 return wrap_double(t);
\r
309 case Id_getTimezoneOffset: {
\r
310 double t = realThis(thisObj, f, true).date;
\r
311 if (t == t) { t = jsFunction_getTimezoneOffset(t); }
\r
312 return wrap_double(t);
\r
316 return wrap_double(realThis(thisObj, f, true).
\r
317 jsFunction_setTime(ScriptRuntime.toNumber(args, 0)));
\r
319 case Id_setMilliseconds:
\r
320 return wrap_double(realThis(thisObj, f, false).
\r
321 makeTime(args, 1, true));
\r
323 case Id_setUTCMilliseconds:
\r
324 return wrap_double(realThis(thisObj, f, false).
\r
325 makeTime(args, 1, false));
\r
327 case Id_setSeconds:
\r
328 return wrap_double(realThis(thisObj, f, false).
\r
329 makeTime(args, 2, true));
\r
331 case Id_setUTCSeconds:
\r
332 return wrap_double(realThis(thisObj, f, false).
\r
333 makeTime(args, 2, false));
\r
335 case Id_setMinutes:
\r
336 return wrap_double(realThis(thisObj, f, false).
\r
337 makeTime(args, 3, true));
\r
339 case Id_setUTCMinutes:
\r
340 return wrap_double(realThis(thisObj, f, false).
\r
341 makeTime(args, 3, false));
\r
344 return wrap_double(realThis(thisObj, f, false).
\r
345 makeTime(args, 4, true));
\r
347 case Id_setUTCHours:
\r
348 return wrap_double(realThis(thisObj, f, false).
\r
349 makeTime(args, 4, false));
\r
352 return wrap_double(realThis(thisObj, f, false).
\r
353 makeDate(args, 1, true));
\r
355 case Id_setUTCDate:
\r
356 return wrap_double(realThis(thisObj, f, false).
\r
357 makeDate(args, 1, false));
\r
360 return wrap_double(realThis(thisObj, f, false).
\r
361 makeDate(args, 2, true));
\r
363 case Id_setUTCMonth:
\r
364 return wrap_double(realThis(thisObj, f, false).
\r
365 makeDate(args, 2, false));
\r
367 case Id_setFullYear:
\r
368 return wrap_double(realThis(thisObj, f, false).
\r
369 makeDate(args, 3, true));
\r
371 case Id_setUTCFullYear:
\r
372 return wrap_double(realThis(thisObj, f, false).
\r
373 makeDate(args, 3, false));
\r
376 return wrap_double(realThis(thisObj, f, false).
\r
377 jsFunction_setYear(ScriptRuntime.toNumber(args, 0)));
\r
381 return super.execMethod(methodId, f, cx, scope, thisObj, args);
\r
384 private NativeDate realThis(Scriptable thisObj, IdFunction f,
\r
387 while (!(thisObj instanceof NativeDate)) {
\r
388 thisObj = nextInstanceCheck(thisObj, f, readOnly);
\r
390 return (NativeDate)thisObj;
\r
393 /* ECMA helper functions */
\r
395 private static final double HalfTimeDomain = 8.64e15;
\r
396 private static final double HoursPerDay = 24.0;
\r
397 private static final double MinutesPerHour = 60.0;
\r
398 private static final double SecondsPerMinute = 60.0;
\r
399 private static final double msPerSecond = 1000.0;
\r
400 private static final double MinutesPerDay = (HoursPerDay * MinutesPerHour);
\r
401 private static final double SecondsPerDay = (MinutesPerDay * SecondsPerMinute);
\r
402 private static final double SecondsPerHour = (MinutesPerHour * SecondsPerMinute);
\r
403 private static final double msPerDay = (SecondsPerDay * msPerSecond);
\r
404 private static final double msPerHour = (SecondsPerHour * msPerSecond);
\r
405 private static final double msPerMinute = (SecondsPerMinute * msPerSecond);
\r
407 private static double Day(double t) {
\r
408 return Math.floor(t / msPerDay);
\r
411 private static double TimeWithinDay(double t) {
\r
413 result = t % msPerDay;
\r
415 result += msPerDay;
\r
419 private static int DaysInYear(int y) {
\r
420 if (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
\r
427 /* math here has to be f.p, because we need
\r
428 * floor((1968 - 1969) / 4) == -1
\r
430 private static double DayFromYear(double y) {
\r
431 return ((365 * ((y)-1970) + Math.floor(((y)-1969)/4.0)
\r
432 - Math.floor(((y)-1901)/100.0) + Math.floor(((y)-1601)/400.0)));
\r
435 private static double TimeFromYear(double y) {
\r
436 return DayFromYear(y) * msPerDay;
\r
439 private static int YearFromTime(double t) {
\r
440 int lo = (int) Math.floor((t / msPerDay) / 366) + 1970;
\r
441 int hi = (int) Math.floor((t / msPerDay) / 365) + 1970;
\r
444 /* above doesn't work for negative dates... */
\r
451 /* Use a simple binary search algorithm to find the right
\r
452 year. This seems like brute force... but the computation
\r
453 of hi and lo years above lands within one year of the
\r
454 correct answer for years within a thousand years of
\r
455 1970; the loop below only requires six iterations
\r
456 for year 270000. */
\r
458 mid = (hi + lo) / 2;
\r
459 if (TimeFromYear(mid) > t) {
\r
462 if (TimeFromYear(mid) <= t) {
\r
463 int temp = mid + 1;
\r
464 if (TimeFromYear(temp) > t) {
\r
474 private static boolean InLeapYear(double t) {
\r
475 return DaysInYear(YearFromTime(t)) == 366;
\r
478 private static int DayWithinYear(double t) {
\r
479 int year = YearFromTime(t);
\r
480 return (int) (Day(t) - DayFromYear(year));
\r
483 * The following array contains the day of year for the first day of
\r
484 * each month, where index 0 is January, and day 0 is January 1.
\r
487 private static double DayFromMonth(int m, boolean leap) {
\r
490 if (m >= 7) { day += m / 2 - 1; }
\r
491 else if (m >= 2) { day += (m - 1) / 2 - 1; }
\r
494 if (leap && m >= 2) { ++day; }
\r
499 private static int MonthFromTime(double t) {
\r
502 d = DayWithinYear(t);
\r
504 if (d < (step = 31))
\r
507 // Originally coded as step += (InLeapYear(t) ? 29 : 28);
\r
508 // but some jits always returned 28!
\r
516 if (d < (step += 31))
\r
518 if (d < (step += 30))
\r
520 if (d < (step += 31))
\r
522 if (d < (step += 30))
\r
524 if (d < (step += 31))
\r
526 if (d < (step += 31))
\r
528 if (d < (step += 30))
\r
530 if (d < (step += 31))
\r
532 if (d < (step += 30))
\r
537 private static int DateFromTime(double t) {
\r
540 d = DayWithinYear(t);
\r
541 if (d <= (next = 30))
\r
545 // Originally coded as next += (InLeapYear(t) ? 29 : 28);
\r
546 // but some jits always returned 28!
\r
555 if (d <= (next += 31))
\r
558 if (d <= (next += 30))
\r
561 if (d <= (next += 31))
\r
564 if (d <= (next += 30))
\r
567 if (d <= (next += 31))
\r
570 if (d <= (next += 31))
\r
573 if (d <= (next += 30))
\r
576 if (d <= (next += 31))
\r
579 if (d <= (next += 30))
\r
586 private static int WeekDay(double t) {
\r
588 result = Day(t) + 4;
\r
589 result = result % 7;
\r
592 return (int) result;
\r
595 private static double Now() {
\r
596 return (double) System.currentTimeMillis();
\r
599 /* Should be possible to determine the need for this dynamically
\r
600 * if we go with the workaround... I'm not using it now, because I
\r
601 * can't think of any clean way to make toLocaleString() and the
\r
602 * time zone (comment) in toString match the generated string
\r
603 * values. Currently it's wrong-but-consistent in all but the
\r
604 * most recent betas of the JRE - seems to work in 1.1.7.
\r
606 private final static boolean TZO_WORKAROUND = false;
\r
607 private static double DaylightSavingTA(double t) {
\r
608 if (!TZO_WORKAROUND) {
\r
609 Date date = new Date((long) t);
\r
610 if (thisTimeZone.inDaylightTime(date))
\r
615 /* Use getOffset if inDaylightTime() is broken, because it
\r
616 * seems to work acceptably. We don't switch over to it
\r
617 * entirely, because it requires (expensive) exploded date arguments,
\r
618 * and the api makes it impossible to handle dst
\r
619 * changeovers cleanly.
\r
622 // Hardcode the assumption that the changeover always
\r
623 // happens at 2:00 AM:
\r
624 t += LocalTZA + (HourFromTime(t) <= 2 ? msPerHour : 0);
\r
626 int year = YearFromTime(t);
\r
627 double offset = thisTimeZone.getOffset(year > 0 ? 1 : 0,
\r
632 (int)TimeWithinDay(t));
\r
634 if ((offset - LocalTZA) != 0)
\r
638 // return offset - LocalTZA;
\r
642 private static double LocalTime(double t) {
\r
643 return t + LocalTZA + DaylightSavingTA(t);
\r
646 public static double internalUTC(double t) {
\r
647 return t - LocalTZA - DaylightSavingTA(t - LocalTZA);
\r
650 private static int HourFromTime(double t) {
\r
652 result = Math.floor(t / msPerHour) % HoursPerDay;
\r
654 result += HoursPerDay;
\r
655 return (int) result;
\r
658 private static int MinFromTime(double t) {
\r
660 result = Math.floor(t / msPerMinute) % MinutesPerHour;
\r
662 result += MinutesPerHour;
\r
663 return (int) result;
\r
666 private static int SecFromTime(double t) {
\r
668 result = Math.floor(t / msPerSecond) % SecondsPerMinute;
\r
670 result += SecondsPerMinute;
\r
671 return (int) result;
\r
674 private static int msFromTime(double t) {
\r
676 result = t % msPerSecond;
\r
678 result += msPerSecond;
\r
679 return (int) result;
\r
682 private static double MakeTime(double hour, double min,
\r
683 double sec, double ms)
\r
685 return ((hour * MinutesPerHour + min) * SecondsPerMinute + sec)
\r
686 * msPerSecond + ms;
\r
689 private static double MakeDay(double year, double month, double date) {
\r
695 year += Math.floor(month / 12);
\r
697 month = month % 12;
\r
701 leap = (DaysInYear((int) year) == 366);
\r
703 yearday = Math.floor(TimeFromYear(year) / msPerDay);
\r
704 monthday = DayFromMonth((int) month, leap);
\r
712 private static double MakeDate(double day, double time) {
\r
713 return day * msPerDay + time;
\r
716 private static double TimeClip(double d) {
\r
718 d == Double.POSITIVE_INFINITY ||
\r
719 d == Double.NEGATIVE_INFINITY ||
\r
720 Math.abs(d) > HalfTimeDomain)
\r
722 return ScriptRuntime.NaN;
\r
725 return Math.floor(d + 0.);
\r
727 return Math.ceil(d + 0.);
\r
730 /* end of ECMA helper functions */
\r
732 /* find UTC time from given date... no 1900 correction! */
\r
733 public static double date_msecFromDate(double year, double mon,
\r
734 double mday, double hour,
\r
735 double min, double sec,
\r
742 day = MakeDay(year, mon, mday);
\r
743 time = MakeTime(hour, min, sec, msec);
\r
744 result = MakeDate(day, time);
\r
749 private static final int MAXARGS = 7;
\r
750 private static double jsStaticFunction_UTC(Object[] args) {
\r
751 double array[] = new double[MAXARGS];
\r
755 for (loop = 0; loop < MAXARGS; loop++) {
\r
756 if (loop < args.length) {
\r
757 d = ScriptRuntime.toNumber(args[loop]);
\r
758 if (d != d || Double.isInfinite(d)) {
\r
759 return ScriptRuntime.NaN;
\r
761 array[loop] = ScriptRuntime.toInteger(args[loop]);
\r
767 /* adjust 2-digit years into the 20th century */
\r
768 if (array[0] >= 0 && array[0] <= 99)
\r
771 /* if we got a 0 for 'date' (which is out of range)
\r
772 * pretend it's a 1. (So Date.UTC(1972, 5) works) */
\r
776 d = date_msecFromDate(array[0], array[1], array[2],
\r
777 array[3], array[4], array[5], array[6]);
\r
780 // return new Double(d);
\r
784 * Use ported code from jsdate.c rather than the locale-specific
\r
785 * date-parsing code from Java, to keep js and rhino consistent.
\r
786 * Is this the right strategy?
\r
789 /* for use by date_parse */
\r
791 /* replace this with byte arrays? Cheaper? */
\r
792 private static String wtb[] = {
\r
794 "monday", "tuesday", "wednesday", "thursday", "friday",
\r
795 "saturday", "sunday",
\r
796 "january", "february", "march", "april", "may", "june",
\r
797 "july", "august", "september", "october", "november", "december",
\r
798 "gmt", "ut", "utc", "est", "edt", "cst", "cdt",
\r
799 "mst", "mdt", "pst", "pdt"
\r
800 /* time zone table needs to be expanded */
\r
803 private static int ttb[] = {
\r
804 -1, -2, 0, 0, 0, 0, 0, 0, 0, /* AM/PM */
\r
805 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
\r
806 10000 + 0, 10000 + 0, 10000 + 0, /* UT/UTC */
\r
807 10000 + 5 * 60, 10000 + 4 * 60, /* EDT */
\r
808 10000 + 6 * 60, 10000 + 5 * 60,
\r
809 10000 + 7 * 60, 10000 + 6 * 60,
\r
810 10000 + 8 * 60, 10000 + 7 * 60
\r
813 /* helper for date_parse */
\r
814 private static boolean date_regionMatches(String s1, int s1off,
\r
815 String s2, int s2off,
\r
818 boolean result = false;
\r
819 /* return true if matches, otherwise, false */
\r
820 int s1len = s1.length();
\r
821 int s2len = s2.length();
\r
823 while (count > 0 && s1off < s1len && s2off < s2len) {
\r
824 if (Character.toLowerCase(s1.charAt(s1off)) !=
\r
825 Character.toLowerCase(s2.charAt(s2off)))
\r
838 private static double date_parseString(String s) {
\r
851 double tzoffset = -1;
\r
854 boolean seenplusminus = false;
\r
856 if (s == null) // ??? Will s be null?
\r
857 return ScriptRuntime.NaN;
\r
858 limit = s.length();
\r
859 while (i < limit) {
\r
862 if (c <= ' ' || c == ',' || c == '-') {
\r
865 if (c == '-' && '0' <= si && si <= '9') {
\r
871 if (c == '(') { /* comments) */
\r
873 while (i < limit) {
\r
884 if ('0' <= c && c <= '9') {
\r
886 while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {
\r
887 n = n * 10 + c - '0';
\r
891 /* allow TZA before the year, so
\r
892 * 'Wed Nov 05 21:49:11 GMT-0800 1997'
\r
895 /* uses of seenplusminus allow : in TZA, so Java
\r
896 * no-timezone style of GMT+4:30 works
\r
898 if ((prevc == '+' || prevc == '-')/* && year>=0 */) {
\r
899 /* make ':' case below change tzoffset */
\r
900 seenplusminus = true;
\r
904 n = n * 60; /* EG. "GMT-3" */
\r
906 n = n % 100 + n / 100 * 60; /* eg "GMT-0430" */
\r
907 if (prevc == '+') /* plus means east of GMT */
\r
909 if (tzoffset != 0 && tzoffset != -1)
\r
910 return ScriptRuntime.NaN;
\r
912 } else if (n >= 70 ||
\r
913 (prevc == '/' && mon >= 0 && mday >= 0 && year < 0)) {
\r
915 return ScriptRuntime.NaN;
\r
916 else if (c <= ' ' || c == ',' || c == '/' || i >= limit)
\r
917 year = n < 100 ? n + 1900 : n;
\r
919 return ScriptRuntime.NaN;
\r
920 } else if (c == ':') {
\r
926 return ScriptRuntime.NaN;
\r
927 } else if (c == '/') {
\r
929 mon = /*byte*/ n-1;
\r
933 return ScriptRuntime.NaN;
\r
934 } else if (i < limit && c != ',' && c > ' ' && c != '-') {
\r
935 return ScriptRuntime.NaN;
\r
936 } else if (seenplusminus && n < 60) { /* handle GMT-3:30 */
\r
941 } else if (hour >= 0 && min < 0) {
\r
943 } else if (min >= 0 && sec < 0) {
\r
945 } else if (mday < 0) {
\r
948 return ScriptRuntime.NaN;
\r
951 } else if (c == '/' || c == ':' || c == '+' || c == '-') {
\r
956 while (i < limit) {
\r
958 if (!(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z')))
\r
963 return ScriptRuntime.NaN;
\r
964 for (k = wtb.length; --k >= 0;)
\r
965 if (date_regionMatches(wtb[k], 0, s, st, i-st)) {
\r
966 int action = ttb[k];
\r
970 * AM/PM. Count 12:30 AM as 00:30, 12:30 PM as
\r
971 * 12:30, instead of blindly adding 12 if PM.
\r
973 if (hour > 12 || hour < 0) {
\r
974 return ScriptRuntime.NaN;
\r
976 if (action == -1 && hour == 12) { // am
\r
978 } else if (action == -2 && hour != 12) {// pm
\r
982 } else if (action <= 13) { /* month! */
\r
984 mon = /*byte*/ (action - 2);
\r
986 return ScriptRuntime.NaN;
\r
989 tzoffset = action - 10000;
\r
995 return ScriptRuntime.NaN;
\r
999 if (year < 0 || mon < 0 || mday < 0)
\r
1000 return ScriptRuntime.NaN;
\r
1007 if (tzoffset == -1) { /* no time zone specified, have to use local */
\r
1009 time = date_msecFromDate(year, mon, mday, hour, min, sec, 0);
\r
1010 return internalUTC(time);
\r
1013 msec = date_msecFromDate(year, mon, mday, hour, min, sec, 0);
\r
1014 msec += tzoffset * msPerMinute;
\r
1018 private static double jsStaticFunction_parse(String s) {
\r
1019 return date_parseString(s);
\r
1022 private static final int FORMATSPEC_FULL = 0;
\r
1023 private static final int FORMATSPEC_DATE = 1;
\r
1024 private static final int FORMATSPEC_TIME = 2;
\r
1026 private static String date_format(double t, int format) {
\r
1028 return jsFunction_NaN_date_str;
\r
1030 StringBuffer result = new StringBuffer(60);
\r
1031 double local = LocalTime(t);
\r
1033 /* offset from GMT in minutes. The offset includes daylight savings,
\r
1035 int minutes = (int) Math.floor((LocalTZA + DaylightSavingTA(t))
\r
1037 /* map 510 minutes to 0830 hours */
\r
1038 int offset = (minutes / 60) * 100 + minutes % 60;
\r
1040 String dateStr = Integer.toString(DateFromTime(local));
\r
1041 String hourStr = Integer.toString(HourFromTime(local));
\r
1042 String minStr = Integer.toString(MinFromTime(local));
\r
1043 String secStr = Integer.toString(SecFromTime(local));
\r
1044 String offsetStr = Integer.toString(offset > 0 ? offset : -offset);
\r
1045 int year = YearFromTime(local);
\r
1046 String yearStr = Integer.toString(year > 0 ? year : -year);
\r
1048 /* Tue Oct 31 09:41:40 GMT-0800 (PST) 2000 */
\r
1049 /* Tue Oct 31 2000 */
\r
1050 /* 09:41:40 GMT-0800 (PST) */
\r
1052 if (format != FORMATSPEC_TIME) {
\r
1053 result.append(days[WeekDay(local)]);
\r
1054 result.append(' ');
\r
1055 result.append(months[MonthFromTime(local)]);
\r
1056 if (dateStr.length() == 1)
\r
1057 result.append(" 0");
\r
1059 result.append(' ');
\r
1060 result.append(dateStr);
\r
1061 result.append(' ');
\r
1064 if (format != FORMATSPEC_DATE) {
\r
1065 if (hourStr.length() == 1)
\r
1066 result.append('0');
\r
1067 result.append(hourStr);
\r
1068 if (minStr.length() == 1)
\r
1069 result.append(":0");
\r
1071 result.append(':');
\r
1072 result.append(minStr);
\r
1073 if (secStr.length() == 1)
\r
1074 result.append(":0");
\r
1076 result.append(':');
\r
1077 result.append(secStr);
\r
1079 result.append(" GMT+");
\r
1081 result.append(" GMT-");
\r
1082 for (int i = offsetStr.length(); i < 4; i++)
\r
1083 result.append('0');
\r
1084 result.append(offsetStr);
\r
1086 if (timeZoneFormatter == null)
\r
1087 timeZoneFormatter = new java.text.SimpleDateFormat("zzz");
\r
1089 if (timeZoneFormatter != null) {
\r
1090 result.append(" (");
\r
1091 java.util.Date date = new Date((long) t);
\r
1092 result.append(timeZoneFormatter.format(date));
\r
1093 result.append(')');
\r
1095 if (format != FORMATSPEC_TIME)
\r
1096 result.append(' ');
\r
1099 if (format != FORMATSPEC_TIME) {
\r
1101 result.append('-');
\r
1102 for (int i = yearStr.length(); i < 4; i++)
\r
1103 result.append('0');
\r
1104 result.append(yearStr);
\r
1107 return result.toString();
\r
1110 /* the javascript constructor */
\r
1111 private static Object jsConstructor(Object[] args, boolean inNewExpr) {
\r
1112 // if called as a function, just return a string
\r
1113 // representing the current time.
\r
1115 return date_format(Now(), FORMATSPEC_FULL);
\r
1117 NativeDate obj = new NativeDate();
\r
1119 // if called as a constructor with no args,
\r
1120 // return a new Date with the current time.
\r
1121 if (args.length == 0) {
\r
1126 // if called with just one arg -
\r
1127 if (args.length == 1) {
\r
1129 if (args[0] instanceof Scriptable)
\r
1130 args[0] = ((Scriptable) args[0]).getDefaultValue(null);
\r
1131 if (!(args[0] instanceof String)) {
\r
1132 // if it's not a string, use it as a millisecond date
\r
1133 date = ScriptRuntime.toNumber(args[0]);
\r
1135 // it's a string; parse it.
\r
1136 String str = (String) args[0];
\r
1137 date = date_parseString(str);
\r
1139 obj.date = TimeClip(date);
\r
1143 // multiple arguments; year, month, day etc.
\r
1144 double array[] = new double[MAXARGS];
\r
1148 for (loop = 0; loop < MAXARGS; loop++) {
\r
1149 if (loop < args.length) {
\r
1150 d = ScriptRuntime.toNumber(args[loop]);
\r
1152 if (d != d || Double.isInfinite(d)) {
\r
1153 obj.date = ScriptRuntime.NaN;
\r
1156 array[loop] = ScriptRuntime.toInteger(args[loop]);
\r
1162 /* adjust 2-digit years into the 20th century */
\r
1163 if (array[0] >= 0 && array[0] <= 99)
\r
1166 /* if we got a 0 for 'date' (which is out of range)
\r
1167 * pretend it's a 1 */
\r
1171 double day = MakeDay(array[0], array[1], array[2]);
\r
1172 double time = MakeTime(array[3], array[4], array[5], array[6]);
\r
1173 time = MakeDate(day, time);
\r
1174 time = internalUTC(time);
\r
1175 obj.date = TimeClip(time);
\r
1180 /* constants for toString, toUTCString */
\r
1181 private static String jsFunction_NaN_date_str = "Invalid Date";
\r
1183 private static String[] days = {
\r
1184 "Sun","Mon","Tue","Wed","Thu","Fri","Sat"
\r
1187 private static String[] months = {
\r
1188 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
\r
1189 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
\r
1192 private static String toLocale_helper(double t,
\r
1193 java.text.DateFormat formatter)
\r
1196 return jsFunction_NaN_date_str;
\r
1198 java.util.Date tempdate = new Date((long) t);
\r
1199 return formatter.format(tempdate);
\r
1202 private static String jsFunction_toLocaleString(double date) {
\r
1203 if (localeDateTimeFormatter == null)
\r
1204 localeDateTimeFormatter =
\r
1205 DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
\r
1207 return toLocale_helper(date, localeDateTimeFormatter);
\r
1210 private static String jsFunction_toLocaleTimeString(double date) {
\r
1211 if (localeTimeFormatter == null)
\r
1212 localeTimeFormatter = DateFormat.getTimeInstance(DateFormat.LONG);
\r
1214 return toLocale_helper(date, localeTimeFormatter);
\r
1217 private static String jsFunction_toLocaleDateString(double date) {
\r
1218 if (localeDateFormatter == null)
\r
1219 localeDateFormatter = DateFormat.getDateInstance(DateFormat.LONG);
\r
1221 return toLocale_helper(date, localeDateFormatter);
\r
1224 private static String jsFunction_toUTCString(double date) {
\r
1225 StringBuffer result = new StringBuffer(60);
\r
1227 String dateStr = Integer.toString(DateFromTime(date));
\r
1228 String hourStr = Integer.toString(HourFromTime(date));
\r
1229 String minStr = Integer.toString(MinFromTime(date));
\r
1230 String secStr = Integer.toString(SecFromTime(date));
\r
1231 int year = YearFromTime(date);
\r
1232 String yearStr = Integer.toString(year > 0 ? year : -year);
\r
1234 result.append(days[WeekDay(date)]);
\r
1235 result.append(", ");
\r
1236 if (dateStr.length() == 1)
\r
1237 result.append('0');
\r
1238 result.append(dateStr);
\r
1239 result.append(' ');
\r
1240 result.append(months[MonthFromTime(date)]);
\r
1242 result.append(" -");
\r
1244 result.append(' ');
\r
1246 for (i = yearStr.length(); i < 4; i++)
\r
1247 result.append('0');
\r
1248 result.append(yearStr);
\r
1250 if (hourStr.length() == 1)
\r
1251 result.append(" 0");
\r
1253 result.append(' ');
\r
1254 result.append(hourStr);
\r
1255 if (minStr.length() == 1)
\r
1256 result.append(":0");
\r
1258 result.append(':');
\r
1259 result.append(minStr);
\r
1260 if (secStr.length() == 1)
\r
1261 result.append(":0");
\r
1263 result.append(':');
\r
1264 result.append(secStr);
\r
1266 result.append(" GMT");
\r
1267 return result.toString();
\r
1270 private static double jsFunction_getYear(Context cx, double date) {
\r
1272 int result = YearFromTime(LocalTime(date));
\r
1274 if (cx.hasFeature(Context.FEATURE_NON_ECMA_GET_YEAR)) {
\r
1275 if (result >= 1900 && result < 2000) {
\r
1285 private static double jsFunction_getTimezoneOffset(double date) {
\r
1286 return (date - LocalTime(date)) / msPerMinute;
\r
1289 public double jsFunction_setTime(double time) {
\r
1290 this.date = TimeClip(time);
\r
1294 private double makeTime(Object[] args, int maxargs, boolean local) {
\r
1296 double conv[] = new double[4];
\r
1297 double hour, min, sec, msec;
\r
1298 double lorutime; /* Local or UTC version of date */
\r
1303 double date = this.date;
\r
1305 /* just return NaN if the date is already NaN */
\r
1309 /* Satisfy the ECMA rule that if a function is called with
\r
1310 * fewer arguments than the specified formal arguments, the
\r
1311 * remaining arguments are set to undefined. Seems like all
\r
1312 * the Date.setWhatever functions in ECMA are only varargs
\r
1313 * beyond the first argument; this should be set to undefined
\r
1314 * if it's not given. This means that "d = new Date();
\r
1315 * d.setMilliseconds()" returns NaN. Blech.
\r
1317 if (args.length == 0)
\r
1318 args = ScriptRuntime.padArguments(args, 1);
\r
1320 for (i = 0; i < args.length && i < maxargs; i++) {
\r
1321 conv[i] = ScriptRuntime.toNumber(args[i]);
\r
1323 // limit checks that happen in MakeTime in ECMA.
\r
1324 if (conv[i] != conv[i] || Double.isInfinite(conv[i])) {
\r
1325 this.date = ScriptRuntime.NaN;
\r
1328 conv[i] = ScriptRuntime.toInteger(conv[i]);
\r
1332 lorutime = LocalTime(date);
\r
1337 int stop = args.length;
\r
1339 if (maxargs >= 4 && i < stop)
\r
1342 hour = HourFromTime(lorutime);
\r
1344 if (maxargs >= 3 && i < stop)
\r
1347 min = MinFromTime(lorutime);
\r
1349 if (maxargs >= 2 && i < stop)
\r
1352 sec = SecFromTime(lorutime);
\r
1354 if (maxargs >= 1 && i < stop)
\r
1357 msec = msFromTime(lorutime);
\r
1359 time = MakeTime(hour, min, sec, msec);
\r
1360 result = MakeDate(Day(lorutime), time);
\r
1363 result = internalUTC(result);
\r
1364 date = TimeClip(result);
\r
1370 private double jsFunction_setHours(Object[] args) {
\r
1371 return makeTime(args, 4, true);
\r
1374 private double jsFunction_setUTCHours(Object[] args) {
\r
1375 return makeTime(args, 4, false);
\r
1378 private double makeDate(Object[] args, int maxargs, boolean local) {
\r
1380 double conv[] = new double[3];
\r
1381 double year, month, day;
\r
1382 double lorutime; /* local or UTC version of date */
\r
1385 double date = this.date;
\r
1387 /* See arg padding comment in makeTime.*/
\r
1388 if (args.length == 0)
\r
1389 args = ScriptRuntime.padArguments(args, 1);
\r
1391 for (i = 0; i < args.length && i < maxargs; i++) {
\r
1392 conv[i] = ScriptRuntime.toNumber(args[i]);
\r
1394 // limit checks that happen in MakeDate in ECMA.
\r
1395 if (conv[i] != conv[i] || Double.isInfinite(conv[i])) {
\r
1396 this.date = ScriptRuntime.NaN;
\r
1399 conv[i] = ScriptRuntime.toInteger(conv[i]);
\r
1402 /* return NaN if date is NaN and we're not setting the year,
\r
1403 * If we are, use 0 as the time. */
\r
1404 if (date != date) {
\r
1405 if (args.length < 3) {
\r
1406 return ScriptRuntime.NaN;
\r
1412 lorutime = LocalTime(date);
\r
1418 int stop = args.length;
\r
1420 if (maxargs >= 3 && i < stop)
\r
1423 year = YearFromTime(lorutime);
\r
1425 if (maxargs >= 2 && i < stop)
\r
1426 month = conv[i++];
\r
1428 month = MonthFromTime(lorutime);
\r
1430 if (maxargs >= 1 && i < stop)
\r
1433 day = DateFromTime(lorutime);
\r
1435 day = MakeDay(year, month, day); /* day within year */
\r
1436 result = MakeDate(day, TimeWithinDay(lorutime));
\r
1439 result = internalUTC(result);
\r
1441 date = TimeClip(result);
\r
1447 private double jsFunction_setYear(double year) {
\r
1448 double day, result;
\r
1449 if (year != year || Double.isInfinite(year)) {
\r
1450 this.date = ScriptRuntime.NaN;
\r
1454 if (this.date != this.date) {
\r
1457 this.date = LocalTime(this.date);
\r
1460 if (year >= 0 && year <= 99)
\r
1463 day = MakeDay(year, MonthFromTime(this.date), DateFromTime(this.date));
\r
1464 result = MakeDate(day, TimeWithinDay(this.date));
\r
1465 result = internalUTC(result);
\r
1467 this.date = TimeClip(result);
\r
1471 protected String getIdName(int id) {
\r
1472 if (prototypeFlag) {
\r
1474 case ConstructorId_UTC: return "UTC";
\r
1475 case ConstructorId_parse: return "parse";
\r
1476 case Id_constructor: return "constructor";
\r
1477 case Id_toString: return "toString";
\r
1478 case Id_toTimeString: return "toTimeString";
\r
1479 case Id_toDateString: return "toDateString";
\r
1480 case Id_toLocaleString: return "toLocaleString";
\r
1481 case Id_toLocaleTimeString: return "toLocaleTimeString";
\r
1482 case Id_toLocaleDateString: return "toLocaleDateString";
\r
1483 case Id_toUTCString: return "toUTCString";
\r
1484 case Id_valueOf: return "valueOf";
\r
1485 case Id_getTime: return "getTime";
\r
1486 case Id_getYear: return "getYear";
\r
1487 case Id_getFullYear: return "getFullYear";
\r
1488 case Id_getUTCFullYear: return "getUTCFullYear";
\r
1489 case Id_getMonth: return "getMonth";
\r
1490 case Id_getUTCMonth: return "getUTCMonth";
\r
1491 case Id_getDate: return "getDate";
\r
1492 case Id_getUTCDate: return "getUTCDate";
\r
1493 case Id_getDay: return "getDay";
\r
1494 case Id_getUTCDay: return "getUTCDay";
\r
1495 case Id_getHours: return "getHours";
\r
1496 case Id_getUTCHours: return "getUTCHours";
\r
1497 case Id_getMinutes: return "getMinutes";
\r
1498 case Id_getUTCMinutes: return "getUTCMinutes";
\r
1499 case Id_getSeconds: return "getSeconds";
\r
1500 case Id_getUTCSeconds: return "getUTCSeconds";
\r
1501 case Id_getMilliseconds: return "getMilliseconds";
\r
1502 case Id_getUTCMilliseconds: return "getUTCMilliseconds";
\r
1503 case Id_getTimezoneOffset: return "getTimezoneOffset";
\r
1504 case Id_setTime: return "setTime";
\r
1505 case Id_setMilliseconds: return "setMilliseconds";
\r
1506 case Id_setUTCMilliseconds: return "setUTCMilliseconds";
\r
1507 case Id_setSeconds: return "setSeconds";
\r
1508 case Id_setUTCSeconds: return "setUTCSeconds";
\r
1509 case Id_setMinutes: return "setMinutes";
\r
1510 case Id_setUTCMinutes: return "setUTCMinutes";
\r
1511 case Id_setHours: return "setHours";
\r
1512 case Id_setUTCHours: return "setUTCHours";
\r
1513 case Id_setDate: return "setDate";
\r
1514 case Id_setUTCDate: return "setUTCDate";
\r
1515 case Id_setMonth: return "setMonth";
\r
1516 case Id_setUTCMonth: return "setUTCMonth";
\r
1517 case Id_setFullYear: return "setFullYear";
\r
1518 case Id_setUTCFullYear: return "setUTCFullYear";
\r
1519 case Id_setYear: return "setYear";
\r
1525 // #string_id_map#
\r
1527 protected int mapNameToId(String s) {
\r
1528 if (!prototypeFlag) { return 0; }
\r
1530 // #generated# Last update: 2001-04-22 23:46:59 CEST
\r
1531 L0: { id = 0; String X = null; int c;
\r
1532 L: switch (s.length()) {
\r
1533 case 6: X="getDay";id=Id_getDay; break L;
\r
1534 case 7: switch (s.charAt(3)) {
\r
1535 case 'D': c=s.charAt(0);
\r
1536 if (c=='g') { X="getDate";id=Id_getDate; }
\r
1537 else if (c=='s') { X="setDate";id=Id_setDate; }
\r
1539 case 'T': c=s.charAt(0);
\r
1540 if (c=='g') { X="getTime";id=Id_getTime; }
\r
1541 else if (c=='s') { X="setTime";id=Id_setTime; }
\r
1543 case 'Y': c=s.charAt(0);
\r
1544 if (c=='g') { X="getYear";id=Id_getYear; }
\r
1545 else if (c=='s') { X="setYear";id=Id_setYear; }
\r
1547 case 'u': X="valueOf";id=Id_valueOf; break L;
\r
1549 case 8: c=s.charAt(0);
\r
1552 if (c=='h') { X="getMonth";id=Id_getMonth; }
\r
1553 else if (c=='s') { X="getHours";id=Id_getHours; }
\r
1555 else if (c=='s') {
\r
1557 if (c=='h') { X="setMonth";id=Id_setMonth; }
\r
1558 else if (c=='s') { X="setHours";id=Id_setHours; }
\r
1560 else if (c=='t') { X="toString";id=Id_toString; }
\r
1562 case 9: X="getUTCDay";id=Id_getUTCDay; break L;
\r
1563 case 10: c=s.charAt(3);
\r
1566 if (c=='g') { X="getMinutes";id=Id_getMinutes; }
\r
1567 else if (c=='s') { X="setMinutes";id=Id_setMinutes; }
\r
1569 else if (c=='S') {
\r
1571 if (c=='g') { X="getSeconds";id=Id_getSeconds; }
\r
1572 else if (c=='s') { X="setSeconds";id=Id_setSeconds; }
\r
1574 else if (c=='U') {
\r
1576 if (c=='g') { X="getUTCDate";id=Id_getUTCDate; }
\r
1577 else if (c=='s') { X="setUTCDate";id=Id_setUTCDate; }
\r
1580 case 11: switch (s.charAt(3)) {
\r
1581 case 'F': c=s.charAt(0);
\r
1582 if (c=='g') { X="getFullYear";id=Id_getFullYear; }
\r
1583 else if (c=='s') { X="setFullYear";id=Id_setFullYear; }
\r
1585 case 'M': X="toGMTString";id=Id_toGMTString; break L;
\r
1586 case 'T': X="toUTCString";id=Id_toUTCString; break L;
\r
1587 case 'U': c=s.charAt(0);
\r
1590 if (c=='r') { X="getUTCHours";id=Id_getUTCHours; }
\r
1591 else if (c=='t') { X="getUTCMonth";id=Id_getUTCMonth; }
\r
1593 else if (c=='s') {
\r
1595 if (c=='r') { X="setUTCHours";id=Id_setUTCHours; }
\r
1596 else if (c=='t') { X="setUTCMonth";id=Id_setUTCMonth; }
\r
1599 case 's': X="constructor";id=Id_constructor; break L;
\r
1601 case 12: c=s.charAt(2);
\r
1602 if (c=='D') { X="toDateString";id=Id_toDateString; }
\r
1603 else if (c=='T') { X="toTimeString";id=Id_toTimeString; }
\r
1605 case 13: c=s.charAt(0);
\r
1608 if (c=='M') { X="getUTCMinutes";id=Id_getUTCMinutes; }
\r
1609 else if (c=='S') { X="getUTCSeconds";id=Id_getUTCSeconds; }
\r
1611 else if (c=='s') {
\r
1613 if (c=='M') { X="setUTCMinutes";id=Id_setUTCMinutes; }
\r
1614 else if (c=='S') { X="setUTCSeconds";id=Id_setUTCSeconds; }
\r
1617 case 14: c=s.charAt(0);
\r
1618 if (c=='g') { X="getUTCFullYear";id=Id_getUTCFullYear; }
\r
1619 else if (c=='s') { X="setUTCFullYear";id=Id_setUTCFullYear; }
\r
1620 else if (c=='t') { X="toLocaleString";id=Id_toLocaleString; }
\r
1622 case 15: c=s.charAt(0);
\r
1623 if (c=='g') { X="getMilliseconds";id=Id_getMilliseconds; }
\r
1624 else if (c=='s') { X="setMilliseconds";id=Id_setMilliseconds; }
\r
1626 case 17: X="getTimezoneOffset";id=Id_getTimezoneOffset; break L;
\r
1627 case 18: c=s.charAt(0);
\r
1628 if (c=='g') { X="getUTCMilliseconds";id=Id_getUTCMilliseconds; }
\r
1629 else if (c=='s') { X="setUTCMilliseconds";id=Id_setUTCMilliseconds; }
\r
1630 else if (c=='t') {
\r
1632 if (c=='D') { X="toLocaleDateString";id=Id_toLocaleDateString; }
\r
1633 else if (c=='T') { X="toLocaleTimeString";id=Id_toLocaleTimeString; }
\r
1637 if (X!=null && X!=s && !X.equals(s)) id = 0;
\r
1643 private static final int
\r
1644 ConstructorId_UTC = -2,
\r
1645 ConstructorId_parse = -1,
\r
1647 Id_constructor = 1,
\r
1649 Id_toTimeString = 3,
\r
1650 Id_toDateString = 4,
\r
1651 Id_toLocaleString = 5,
\r
1652 Id_toLocaleTimeString = 6,
\r
1653 Id_toLocaleDateString = 7,
\r
1654 Id_toUTCString = 8,
\r
1658 Id_getFullYear = 12,
\r
1659 Id_getUTCFullYear = 13,
\r
1661 Id_getUTCMonth = 15,
\r
1663 Id_getUTCDate = 17,
\r
1665 Id_getUTCDay = 19,
\r
1667 Id_getUTCHours = 21,
\r
1668 Id_getMinutes = 22,
\r
1669 Id_getUTCMinutes = 23,
\r
1670 Id_getSeconds = 24,
\r
1671 Id_getUTCSeconds = 25,
\r
1672 Id_getMilliseconds = 26,
\r
1673 Id_getUTCMilliseconds = 27,
\r
1674 Id_getTimezoneOffset = 28,
\r
1676 Id_setMilliseconds = 30,
\r
1677 Id_setUTCMilliseconds = 31,
\r
1678 Id_setSeconds = 32,
\r
1679 Id_setUTCSeconds = 33,
\r
1680 Id_setMinutes = 34,
\r
1681 Id_setUTCMinutes = 35,
\r
1683 Id_setUTCHours = 37,
\r
1685 Id_setUTCDate = 39,
\r
1687 Id_setUTCMonth = 41,
\r
1688 Id_setFullYear = 42,
\r
1689 Id_setUTCFullYear = 43,
\r
1692 MAX_PROTOTYPE_ID = 44;
\r
1694 private static final int
\r
1695 Id_toGMTString = Id_toUTCString; // Alias, see Ecma B.2.6
\r
1696 // #/string_id_map#
\r
1698 /* cached values */
\r
1699 private static java.util.TimeZone thisTimeZone;
\r
1700 private static double LocalTZA;
\r
1701 private static java.text.DateFormat timeZoneFormatter;
\r
1702 private static java.text.DateFormat localeDateTimeFormatter;
\r
1703 private static java.text.DateFormat localeDateFormatter;
\r
1704 private static java.text.DateFormat localeTimeFormatter;
\r
1706 private double date;
\r
1708 private boolean prototypeFlag;
\r
1710 public long getRawTime() { return (long)this.date; }
\r