jscript: Use bytecode for '&=' expression implementation.
[wine] / dlls / jscript / date.c
1 /*
2  * Copyright 2008 Jacek Caban for CodeWeavers
3  * Copyright 2009 Piotr Caban
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #include "config.h"
21 #include "wine/port.h"
22
23 #include <limits.h>
24 #include <math.h>
25
26 #include "jscript.h"
27
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
31
32 /* 1601 to 1970 is 369 years plus 89 leap days */
33 #define TIME_EPOCH  ((ULONGLONG)(369 * 365 + 89) * 86400 * 1000)
34
35 typedef struct {
36     jsdisp_t dispex;
37
38     /* ECMA-262 3rd Edition    15.9.1.1 */
39     DOUBLE time;
40
41     LONG bias;
42     SYSTEMTIME standardDate;
43     LONG standardBias;
44     SYSTEMTIME daylightDate;
45     LONG daylightBias;
46 } DateInstance;
47
48 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
49 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
50 static const WCHAR propertyIsEnumerableW[] =
51     {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0};
52 static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0};
53 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
54 static const WCHAR toUTCStringW[] = {'t','o','U','T','C','S','t','r','i','n','g',0};
55 static const WCHAR toGMTStringW[] = {'t','o','G','M','T','S','t','r','i','n','g',0};
56 static const WCHAR toDateStringW[] = {'t','o','D','a','t','e','S','t','r','i','n','g',0};
57 static const WCHAR toTimeStringW[] = {'t','o','T','i','m','e','S','t','r','i','n','g',0};
58 static const WCHAR toLocaleDateStringW[] = {'t','o','L','o','c','a','l','e','D','a','t','e','S','t','r','i','n','g',0};
59 static const WCHAR toLocaleTimeStringW[] = {'t','o','L','o','c','a','l','e','T','i','m','e','S','t','r','i','n','g',0};
60 static const WCHAR getTimeW[] = {'g','e','t','T','i','m','e',0};
61 static const WCHAR getFullYearW[] = {'g','e','t','F','u','l','l','Y','e','a','r',0};
62 static const WCHAR getUTCFullYearW[] = {'g','e','t','U','T','C','F','u','l','l','Y','e','a','r',0};
63 static const WCHAR getMonthW[] = {'g','e','t','M','o','n','t','h',0};
64 static const WCHAR getUTCMonthW[] = {'g','e','t','U','T','C','M','o','n','t','h',0};
65 static const WCHAR getDateW[] = {'g','e','t','D','a','t','e',0};
66 static const WCHAR getUTCDateW[] = {'g','e','t','U','T','C','D','a','t','e',0};
67 static const WCHAR getDayW[] = {'g','e','t','D','a','y',0};
68 static const WCHAR getUTCDayW[] = {'g','e','t','U','T','C','D','a','y',0};
69 static const WCHAR getHoursW[] = {'g','e','t','H','o','u','r','s',0};
70 static const WCHAR getUTCHoursW[] = {'g','e','t','U','T','C','H','o','u','r','s',0};
71 static const WCHAR getMinutesW[] = {'g','e','t','M','i','n','u','t','e','s',0};
72 static const WCHAR getUTCMinutesW[] = {'g','e','t','U','T','C','M','i','n','u','t','e','s',0};
73 static const WCHAR getSecondsW[] = {'g','e','t','S','e','c','o','n','d','s',0};
74 static const WCHAR getUTCSecondsW[] = {'g','e','t','U','T','C','S','e','c','o','n','d','s',0};
75 static const WCHAR getMillisecondsW[] = {'g','e','t','M','i','l','l','i','s','e','c','o','n','d','s',0};
76 static const WCHAR getUTCMillisecondsW[] = {'g','e','t','U','T','C','M','i','l','l','i','s','e','c','o','n','d','s',0};
77 static const WCHAR getTimezoneOffsetW[] = {'g','e','t','T','i','m','e','z','o','n','e','O','f','f','s','e','t',0};
78 static const WCHAR setTimeW[] = {'s','e','t','T','i','m','e',0};
79 static const WCHAR setMillisecondsW[] = {'s','e','t','M','i','l','l','i','s','e','c','o','n','d','s',0};
80 static const WCHAR setUTCMillisecondsW[] = {'s','e','t','U','T','C','M','i','l','l','i','s','e','c','o','n','d','s',0};
81 static const WCHAR setSecondsW[] = {'s','e','t','S','e','c','o','n','d','s',0};
82 static const WCHAR setUTCSecondsW[] = {'s','e','t','U','T','C','S','e','c','o','n','d','s',0};
83 static const WCHAR setMinutesW[] = {'s','e','t','M','i','n','u','t','e','s',0};
84 static const WCHAR setUTCMinutesW[] = {'s','e','t','U','T','C','M','i','n','u','t','e','s',0};
85 static const WCHAR setHoursW[] = {'s','e','t','H','o','u','r','s',0};
86 static const WCHAR setUTCHoursW[] = {'s','e','t','U','T','C','H','o','u','r','s',0};
87 static const WCHAR setDateW[] = {'s','e','t','D','a','t','e',0};
88 static const WCHAR setUTCDateW[] = {'s','e','t','U','T','C','D','a','t','e',0};
89 static const WCHAR setMonthW[] = {'s','e','t','M','o','n','t','h',0};
90 static const WCHAR setUTCMonthW[] = {'s','e','t','U','T','C','M','o','n','t','h',0};
91 static const WCHAR setFullYearW[] = {'s','e','t','F','u','l','l','Y','e','a','r',0};
92 static const WCHAR setUTCFullYearW[] = {'s','e','t','U','T','C','F','u','l','l','Y','e','a','r',0};
93 static const WCHAR getYearW[] = {'g','e','t','Y','e','a','r',0};
94 static const WCHAR setYearW[] = {'s','e','t','Y','e','a','r',0};
95
96 static const WCHAR UTCW[] = {'U','T','C',0};
97 static const WCHAR parseW[] = {'p','a','r','s','e',0};
98
99 static inline DateInstance *date_this(vdisp_t *jsthis)
100 {
101     return is_vclass(jsthis, JSCLASS_DATE) ? (DateInstance*)jsthis->u.jsdisp : NULL;
102 }
103
104 /*ECMA-262 3rd Edition    15.9.1.2 */
105 #define MS_PER_DAY 86400000
106 #define MS_PER_HOUR 3600000
107 #define MS_PER_MINUTE 60000
108
109 /* ECMA-262 3rd Edition    15.9.1.2 */
110 static inline DOUBLE day(DOUBLE time)
111 {
112     return floor(time / MS_PER_DAY);
113 }
114
115 /* ECMA-262 3rd Edition    15.9.1.2 */
116 static inline DOUBLE time_within_day(DOUBLE time)
117 {
118     DOUBLE ret;
119
120     ret = fmod(time, MS_PER_DAY);
121     if(ret < 0)
122         ret += MS_PER_DAY;
123
124     return ret;
125 }
126
127 /* ECMA-262 3rd Edition    15.9.1.3 */
128 static inline DOUBLE days_in_year(DOUBLE year)
129 {
130     int y;
131
132     if(year != (int)year)
133         return ret_nan();
134
135     y = year;
136     if(y%4 != 0) return 365;
137     if(y%100 != 0) return 366;
138     if(y%400 != 0) return 365;
139     return 366;
140 }
141
142 /* ECMA-262 3rd Edition    15.9.1.3 */
143 static inline DOUBLE day_from_year(DOUBLE year)
144 {
145     if(year != (int)year)
146         return ret_nan();
147
148     return floor(365.0*(year-1970) + floor((year-1969)/4)
149         - floor((year-1901)/100) + floor((year-1601)/400));
150 }
151
152 static inline int day_from_month(int month, int in_leap_year)
153 {
154     switch(month)
155     {
156         case 0:
157             return 0;
158         case 1:
159             return 31;
160         case 2:
161             return 59+in_leap_year;
162         case 3:
163             return 90+in_leap_year;
164         case 4:
165             return 120+in_leap_year;
166         case 5:
167             return 151+in_leap_year;
168         case 6:
169             return 181+in_leap_year;
170         case 7:
171             return 212+in_leap_year;
172         case 8:
173             return 243+in_leap_year;
174         case 9:
175             return 273+in_leap_year;
176         case 10:
177             return 304+in_leap_year;
178         default:
179             return 334+in_leap_year;
180     }
181 }
182
183 /* ECMA-262 3rd Edition    15.9.1.3 */
184 static inline DOUBLE time_from_year(DOUBLE year)
185 {
186     return MS_PER_DAY*day_from_year(year);
187 }
188
189 /* ECMA-262 3rd Edition    15.9.1.3 */
190 static inline DOUBLE year_from_time(DOUBLE time)
191 {
192     int y;
193
194     if(isnan(time))
195         return ret_nan();
196
197     y = 1970 + time/365.25/MS_PER_DAY;
198
199     if(time_from_year(y) > time)
200         while(time_from_year(y) > time) y--;
201     else
202         while(time_from_year(y+1)<=time) y++;
203
204     return y;
205 }
206
207 /* ECMA-262 3rd Edition    15.9.1.3 */
208 static inline int in_leap_year(DOUBLE time)
209 {
210     if(days_in_year(year_from_time(time))==366)
211         return 1;
212     return 0;
213 }
214
215 /* ECMA-262 3rd Edition    15.9.1.4 */
216 static inline int day_within_year(DOUBLE time)
217 {
218     return day(time) - day_from_year(year_from_time(time));
219 }
220
221 /* ECMA-262 3rd Edition    15.9.1.4 */
222 static inline DOUBLE month_from_time(DOUBLE time)
223 {
224     int ily = in_leap_year(time);
225     int dwy = day_within_year(time);
226
227     if(isnan(time))
228         return ret_nan();
229
230     if(0<=dwy && dwy<31) return 0;
231     if(dwy < 59+ily) return 1;
232     if(dwy < 90+ily) return 2;
233     if(dwy < 120+ily) return 3;
234     if(dwy < 151+ily) return 4;
235     if(dwy < 181+ily) return 5;
236     if(dwy < 212+ily) return 6;
237     if(dwy < 243+ily) return 7;
238     if(dwy < 273+ily) return 8;
239     if(dwy < 304+ily) return  9;
240     if(dwy < 334+ily) return  10;
241     return  11;
242 }
243
244 /* ECMA-262 3rd Edition    15.9.1.5 */
245 static inline DOUBLE date_from_time(DOUBLE time)
246 {
247     int dwy = day_within_year(time);
248     int ily = in_leap_year(time);
249     int mft = month_from_time(time);
250
251     if(isnan(time))
252         return ret_nan();
253
254     if(mft==0) return dwy+1;
255     if(mft==1) return dwy-30;
256     if(mft==2) return dwy-58-ily;
257     if(mft==3) return dwy-89-ily;
258     if(mft==4) return dwy-119-ily;
259     if(mft==5) return dwy-150-ily;
260     if(mft==6) return dwy-180-ily;
261     if(mft==7) return dwy-211-ily;
262     if(mft==8) return dwy-242-ily;
263     if(mft==9) return dwy-272-ily;
264     if(mft==10) return dwy-303-ily;
265     return dwy-333-ily;
266 }
267
268 /* ECMA-262 3rd Edition    15.9.1.6 */
269 static inline DOUBLE week_day(DOUBLE time)
270 {
271     DOUBLE ret;
272
273     if(isnan(time))
274         return ret_nan();
275
276     ret = fmod(day(time)+4, 7);
277     if(ret<0) ret += 7;
278
279     return ret;
280 }
281
282 static inline DOUBLE convert_time(int year, SYSTEMTIME st)
283 {
284     DOUBLE time;
285     int set_week_day;
286
287     if(st.wMonth == 0)
288         return ret_nan();
289
290     if(st.wYear != 0)
291         year = st.wYear;
292
293     time = time_from_year(year);
294     time += (DOUBLE)day_from_month(st.wMonth-1, in_leap_year(time)) * MS_PER_DAY;
295
296     if(st.wYear == 0) {
297         set_week_day = st.wDayOfWeek-week_day(time);
298         if(set_week_day < 0)
299             set_week_day += 7;
300         time += set_week_day * MS_PER_DAY;
301
302         time += (DOUBLE)(st.wDay-1) * 7 * MS_PER_DAY;
303         if(month_from_time(time) != st.wMonth-1)
304             time -= 7 * MS_PER_DAY;
305     }
306     else
307         time += st.wDay * MS_PER_DAY;
308
309     time += st.wHour * MS_PER_HOUR;
310     time += st.wMinute * MS_PER_MINUTE;
311
312     return time;
313 }
314
315 /* ECMA-262 3rd Edition    15.9.1.9 */
316 static inline DOUBLE daylight_saving_ta(DOUBLE time, DateInstance *date)
317 {
318     int year = year_from_time(time);
319     DOUBLE standardTime, daylightTime;
320
321     if(isnan(time))
322         return 0;
323
324     standardTime = convert_time(year, date->standardDate);
325     daylightTime = convert_time(year, date->daylightDate);
326
327     if(isnan(standardTime) || isnan(daylightTime))
328         return 0;
329     else if(standardTime > daylightTime) {
330         if(daylightTime <= time && time < standardTime)
331             return date->daylightBias;
332
333         return date->standardBias;
334     }
335     else {
336         if(standardTime <= time && time < daylightTime)
337             return date->standardBias;
338
339         return date->daylightBias;
340     }
341 }
342
343 /* ECMA-262 3rd Edition    15.9.1.9 */
344 static inline DOUBLE local_time(DOUBLE time, DateInstance *date)
345 {
346     return time - (daylight_saving_ta(time, date)+date->bias)*MS_PER_MINUTE;
347 }
348
349 /* ECMA-262 3rd Edition    15.9.1.9 */
350 static inline DOUBLE utc(DOUBLE time, DateInstance *date)
351 {
352     time += date->bias * MS_PER_MINUTE;
353     return time + daylight_saving_ta(time, date)*MS_PER_MINUTE;
354 }
355
356 /* ECMA-262 3rd Edition    15.9.1.10 */
357 static inline DOUBLE hour_from_time(DOUBLE time)
358 {
359     DOUBLE ret;
360
361     if(isnan(time))
362         return ret_nan();
363
364     ret = fmod(floor(time/MS_PER_HOUR), 24);
365     if(ret<0) ret += 24;
366
367     return ret;
368 }
369
370 /* ECMA-262 3rd Edition    15.9.1.10 */
371 static inline DOUBLE min_from_time(DOUBLE time)
372 {
373     DOUBLE ret;
374
375     if(isnan(time))
376         return ret_nan();
377
378     ret = fmod(floor(time/MS_PER_MINUTE), 60);
379     if(ret<0) ret += 60;
380
381     return ret;
382 }
383
384 /* ECMA-262 3rd Edition    15.9.1.10 */
385 static inline DOUBLE sec_from_time(DOUBLE time)
386 {
387     DOUBLE ret;
388
389     if(isnan(time))
390         return ret_nan();
391
392     ret = fmod(floor(time/1000), 60);
393     if(ret<0) ret += 60;
394
395     return ret;
396 }
397
398 /* ECMA-262 3rd Edition    15.9.1.10 */
399 static inline DOUBLE ms_from_time(DOUBLE time)
400 {
401     DOUBLE ret;
402
403     if(isnan(time))
404         return ret_nan();
405
406     ret = fmod(time, 1000);
407     if(ret<0) ret += 1000;
408
409     return ret;
410 }
411
412 /* ECMA-262 3rd Edition    15.9.1.11 */
413 static inline DOUBLE make_time(DOUBLE hour, DOUBLE min, DOUBLE sec, DOUBLE ms)
414 {
415     return hour*MS_PER_HOUR + min*MS_PER_MINUTE + sec*1000 + ms;
416 }
417
418 /* ECMA-262 3rd Edition    15.9.1.12 */
419 static inline DOUBLE make_day(DOUBLE year, DOUBLE month, DOUBLE day)
420 {
421     DOUBLE time;
422
423     year += floor(month/12);
424
425     month = fmod(month, 12);
426     if(month<0) month += 12;
427
428     time = time_from_year(year);
429
430     day += floor(time / MS_PER_DAY);
431     day += day_from_month(month, in_leap_year(time));
432
433     return day-1;
434 }
435
436 /* ECMA-262 3rd Edition    15.9.1.13 */
437 static inline DOUBLE make_date(DOUBLE day, DOUBLE time)
438 {
439     return day*MS_PER_DAY + time;
440 }
441
442 /* ECMA-262 3rd Edition    15.9.1.14 */
443 static inline DOUBLE time_clip(DOUBLE time)
444 {
445     if(8.64e15 < time || time < -8.64e15) {
446         return ret_nan();
447     }
448
449     return floor(time);
450 }
451
452 static SYSTEMTIME create_systemtime(DOUBLE time)
453 {
454     SYSTEMTIME st;
455
456     st.wYear = year_from_time(time);
457     st.wMonth = month_from_time(time) + 1;
458     st.wDayOfWeek = week_day(time);
459     st.wDay = date_from_time(time);
460     st.wHour = hour_from_time(time);
461     st.wMinute = min_from_time(time);
462     st.wSecond = sec_from_time(time);
463     st.wMilliseconds = ms_from_time(time);
464
465     return st;
466 }
467
468 static inline HRESULT date_to_string(DOUBLE time, BOOL show_offset, int offset, VARIANT *retv)
469 {
470     static const WCHAR NaNW[] = { 'N','a','N',0 };
471     static const WCHAR formatW[] = { '%','s',' ','%','s',' ','%','d',' ',
472         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ',
473         'U','T','C','%','c','%','0','2','d','%','0','2','d',' ','%','d','%','s',0 };
474     static const WCHAR formatUTCW[] = { '%','s',' ','%','s',' ','%','d',' ',
475         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ',
476         'U','T','C',' ','%','d','%','s',0 };
477     static const WCHAR formatNoOffsetW[] = { '%','s',' ','%','s',' ',
478         '%','d',' ','%','0','2','d',':','%','0','2','d',':',
479         '%','0','2','d',' ','%','d','%','s',0 };
480     static const WCHAR ADW[] = { 0 };
481     static const WCHAR BCW[] = { ' ','B','.','C','.',0 };
482
483     static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
484         LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
485         LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
486     static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
487         LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
488         LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
489         LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
490         LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
491         LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
492
493     BOOL formatAD = TRUE;
494     BSTR week, month;
495     BSTR date_str;
496     int len, size, year, day;
497     DWORD lcid_en, week_id, month_id;
498     WCHAR sign = '-';
499
500     if(isnan(time)) {
501         if(retv) {
502             V_VT(retv) = VT_BSTR;
503             V_BSTR(retv) = SysAllocString(NaNW);
504             if(!V_BSTR(retv))
505                 return E_OUTOFMEMORY;
506         }
507         return S_OK;
508     }
509
510     if(retv) {
511         len = 21;
512
513         lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
514
515         week_id = week_ids[(int)week_day(time)];
516         size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
517         week = SysAllocStringLen(NULL, size);
518         if(!week)
519             return E_OUTOFMEMORY;
520         GetLocaleInfoW(lcid_en, week_id, week, size);
521         len += size-1;
522
523         month_id = month_ids[(int)month_from_time(time)];
524         size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
525         month = SysAllocStringLen(NULL, size);
526         if(!month) {
527             SysFreeString(week);
528             return E_OUTOFMEMORY;
529         }
530         GetLocaleInfoW(lcid_en, month_id, month, size);
531         len += size-1;
532
533         year = year_from_time(time);
534         if(year<0)
535             year = -year+1;
536         do {
537             year /= 10;
538             len++;
539         } while(year);
540
541         year = year_from_time(time);
542         if(year<0) {
543             formatAD = FALSE;
544             year = -year+1;
545             len += 5;
546         }
547
548         day = date_from_time(time);
549         do {
550             day /= 10;
551             len++;
552         } while(day);
553         day = date_from_time(time);
554
555         if(!show_offset) len -= 9;
556         else if(offset == 0) len -= 5;
557         else if(offset < 0) {
558             sign = '+';
559             offset = -offset;
560         }
561
562         date_str = SysAllocStringLen(NULL, len);
563         if(!date_str) {
564             SysFreeString(week);
565             SysFreeString(month);
566             return E_OUTOFMEMORY;
567         }
568
569         if(!show_offset)
570             sprintfW(date_str, formatNoOffsetW, week, month, day,
571                     (int)hour_from_time(time), (int)min_from_time(time),
572                     (int)sec_from_time(time), year, formatAD?ADW:BCW);
573         else if(offset)
574             sprintfW(date_str, formatW, week, month, day,
575                     (int)hour_from_time(time), (int)min_from_time(time),
576                     (int)sec_from_time(time), sign, offset/60, offset%60,
577                     year, formatAD?ADW:BCW);
578         else
579             sprintfW(date_str, formatUTCW, week, month, day,
580                     (int)hour_from_time(time), (int)min_from_time(time),
581                     (int)sec_from_time(time), year, formatAD?ADW:BCW);
582
583         SysFreeString(week);
584         SysFreeString(month);
585
586         V_VT(retv) = VT_BSTR;
587         V_BSTR(retv) = date_str;
588     }
589     return S_OK;
590 }
591
592 /* ECMA-262 3rd Edition    15.9.1.2 */
593 static HRESULT dateobj_to_string(DateInstance *date, VARIANT *retv)
594 {
595     DOUBLE time;
596     int offset;
597
598     time = local_time(date->time, date);
599     offset = date->bias +
600         daylight_saving_ta(time, date);
601
602     return date_to_string(time, TRUE, offset, retv);
603 }
604
605 static HRESULT Date_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
606         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
607 {
608     DateInstance *date;
609
610     TRACE("\n");
611
612     if(!(date = date_this(jsthis)))
613         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
614
615     return dateobj_to_string(date, retv);
616 }
617
618 /* ECMA-262 3rd Edition    15.9.1.5 */
619 static HRESULT Date_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
620         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
621 {
622     static const WCHAR NaNW[] = { 'N','a','N',0 };
623     SYSTEMTIME st;
624     DateInstance *date;
625     BSTR date_str;
626     int date_len, time_len;
627
628     TRACE("\n");
629
630     if(!(date = date_this(jsthis)))
631         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
632
633     if(isnan(date->time)) {
634         if(retv) {
635             V_VT(retv) = VT_BSTR;
636             V_BSTR(retv) = SysAllocString(NaNW);
637             if(!V_BSTR(retv))
638                 return E_OUTOFMEMORY;
639         }
640         return S_OK;
641     }
642
643     st = create_systemtime(local_time(date->time, date));
644
645     if(st.wYear<1601 || st.wYear>9999)
646         return dateobj_to_string(date, retv);
647
648     if(retv) {
649         date_len = GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
650         time_len = GetTimeFormatW(ctx->lcid, 0, &st, NULL, NULL, 0);
651         date_str = SysAllocStringLen(NULL, date_len+time_len-1);
652         if(!date_str)
653             return E_OUTOFMEMORY;
654         GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, date_str, date_len);
655         GetTimeFormatW(ctx->lcid, 0, &st, NULL, &date_str[date_len], time_len);
656         date_str[date_len-1] = ' ';
657
658         V_VT(retv) = VT_BSTR;
659         V_BSTR(retv) = date_str;
660     }
661     return S_OK;
662 }
663
664 static HRESULT Date_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
665         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
666 {
667     DateInstance *date;
668
669     TRACE("\n");
670
671     if(!(date = date_this(jsthis)))
672         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
673
674     if(retv)
675         num_set_val(retv, date->time);
676     return S_OK;
677 }
678
679 static inline HRESULT create_utc_string(script_ctx_t *ctx, vdisp_t *jsthis,
680         VARIANT *retv, jsexcept_t *ei)
681 {
682     static const WCHAR NaNW[] = { 'N','a','N',0 };
683     static const WCHAR formatADW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ',
684         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
685     static const WCHAR formatBCW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ','B','.','C','.',' ',
686         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
687
688     static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
689         LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
690         LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
691     static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
692         LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
693         LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
694         LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
695         LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
696         LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
697
698     BOOL formatAD = TRUE;
699     BSTR week, month;
700     DateInstance *date;
701     BSTR date_str;
702     int len, size, year, day;
703     DWORD lcid_en, week_id, month_id;
704
705     if(!(date = date_this(jsthis)))
706         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
707
708     if(isnan(date->time)) {
709         if(retv) {
710             V_VT(retv) = VT_BSTR;
711             V_BSTR(retv) = SysAllocString(NaNW);
712             if(!V_BSTR(retv))
713                 return E_OUTOFMEMORY;
714         }
715         return S_OK;
716     }
717
718     if(retv) {
719         len = 17;
720
721         lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
722
723         week_id = week_ids[(int)week_day(date->time)];
724         size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
725         week = SysAllocStringLen(NULL, size);
726         if(!week)
727             return E_OUTOFMEMORY;
728         GetLocaleInfoW(lcid_en, week_id, week, size);
729         len += size-1;
730
731         month_id = month_ids[(int)month_from_time(date->time)];
732         size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
733         month = SysAllocStringLen(NULL, size);
734         if(!month) {
735             SysFreeString(week);
736             return E_OUTOFMEMORY;
737         }
738         GetLocaleInfoW(lcid_en, month_id, month, size);
739         len += size-1;
740
741         year = year_from_time(date->time);
742         if(year<0)
743             year = -year+1;
744         do {
745             year /= 10;
746             len++;
747         } while(year);
748
749         year = year_from_time(date->time);
750         if(year<0) {
751             formatAD = FALSE;
752             year = -year+1;
753             len += 5;
754         }
755
756         day = date_from_time(date->time);
757         do {
758             day /= 10;
759             len++;
760         } while(day);
761         day = date_from_time(date->time);
762
763         date_str = SysAllocStringLen(NULL, len);
764         if(!date_str) {
765             SysFreeString(week);
766             SysFreeString(month);
767             return E_OUTOFMEMORY;
768         }
769         sprintfW(date_str, formatAD?formatADW:formatBCW, week, day, month, year,
770                 (int)hour_from_time(date->time), (int)min_from_time(date->time),
771                 (int)sec_from_time(date->time));
772
773         SysFreeString(week);
774         SysFreeString(month);
775
776         V_VT(retv) = VT_BSTR;
777         V_BSTR(retv) = date_str;
778     }
779     return S_OK;
780 }
781
782 /* ECMA-262 3rd Edition    15.9.5.42 */
783 static HRESULT Date_toUTCString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
784         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
785 {
786     TRACE("\n");
787     return create_utc_string(ctx, jsthis, retv, ei);
788 }
789
790 static HRESULT Date_toGMTString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
791         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
792 {
793     TRACE("\n");
794     return create_utc_string(ctx, jsthis, retv, ei);
795 }
796
797 /* ECMA-262 3rd Edition    15.9.5.3 */
798 static HRESULT dateobj_to_date_string(DateInstance *date, VARIANT *retv)
799 {
800     static const WCHAR NaNW[] = { 'N','a','N',0 };
801     static const WCHAR formatADW[] = { '%','s',' ','%','s',' ','%','d',' ','%','d',0 };
802     static const WCHAR formatBCW[] = { '%','s',' ','%','s',' ','%','d',' ','%','d',' ','B','.','C','.',0 };
803
804     static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
805         LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
806         LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
807     static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
808         LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
809         LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
810         LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
811         LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
812         LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
813
814     BOOL formatAD = TRUE;
815     BSTR week, month;
816     BSTR date_str;
817     DOUBLE time;
818     int len, size, year, day;
819     DWORD lcid_en, week_id, month_id;
820
821     if(isnan(date->time)) {
822         if(retv) {
823             V_VT(retv) = VT_BSTR;
824             V_BSTR(retv) = SysAllocString(NaNW);
825             if(!V_BSTR(retv))
826                 return E_OUTOFMEMORY;
827         }
828         return S_OK;
829     }
830
831     time = local_time(date->time, date);
832
833     if(retv) {
834         len = 5;
835
836         lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
837
838         week_id = week_ids[(int)week_day(time)];
839         size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
840         week = SysAllocStringLen(NULL, size);
841         if(!week)
842             return E_OUTOFMEMORY;
843         GetLocaleInfoW(lcid_en, week_id, week, size);
844         len += size-1;
845
846         month_id = month_ids[(int)month_from_time(time)];
847         size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
848         month = SysAllocStringLen(NULL, size);
849         if(!month) {
850             SysFreeString(week);
851             return E_OUTOFMEMORY;
852         }
853         GetLocaleInfoW(lcid_en, month_id, month, size);
854         len += size-1;
855
856         year = year_from_time(time);
857         if(year<0)
858             year = -year+1;
859         do {
860             year /= 10;
861             len++;
862         } while(year);
863
864         year = year_from_time(time);
865         if(year<0) {
866             formatAD = FALSE;
867             year = -year+1;
868             len += 5;
869         }
870
871         day = date_from_time(time);
872         do {
873             day /= 10;
874             len++;
875         } while(day);
876         day = date_from_time(time);
877
878         date_str = SysAllocStringLen(NULL, len);
879         if(!date_str) {
880             SysFreeString(week);
881             SysFreeString(month);
882             return E_OUTOFMEMORY;
883         }
884         sprintfW(date_str, formatAD?formatADW:formatBCW, week, month, day, year);
885
886         SysFreeString(week);
887         SysFreeString(month);
888
889         V_VT(retv) = VT_BSTR;
890         V_BSTR(retv) = date_str;
891     }
892     return S_OK;
893 }
894
895 static HRESULT Date_toDateString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
896         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
897 {
898     DateInstance *date;
899
900     if(!(date = date_this(jsthis)))
901         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
902
903     return dateobj_to_date_string(date, retv);
904 }
905
906 /* ECMA-262 3rd Edition    15.9.5.4 */
907 static HRESULT Date_toTimeString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
908         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
909 {
910     static const WCHAR NaNW[] = { 'N','a','N',0 };
911     static const WCHAR formatW[] = { '%','0','2','d',':','%','0','2','d',':','%','0','2','d',
912         ' ','U','T','C','%','c','%','0','2','d','%','0','2','d',0 };
913     static const WCHAR formatUTCW[] = { '%','0','2','d',':','%','0','2','d',
914         ':','%','0','2','d',' ','U','T','C',0 };
915     DateInstance *date;
916     BSTR date_str;
917     DOUBLE time;
918     WCHAR sign;
919     int offset;
920
921     TRACE("\n");
922
923     if(!(date = date_this(jsthis)))
924         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
925
926     if(isnan(date->time)) {
927         if(retv) {
928             V_VT(retv) = VT_BSTR;
929             V_BSTR(retv) = SysAllocString(NaNW);
930             if(!V_BSTR(retv))
931                 return E_OUTOFMEMORY;
932         }
933         return S_OK;
934     }
935
936     time = local_time(date->time, date);
937
938     if(retv) {
939         date_str = SysAllocStringLen(NULL, 17);
940         if(!date_str)
941             return E_OUTOFMEMORY;
942
943         offset = date->bias +
944             daylight_saving_ta(time, date);
945
946         if(offset < 0) {
947             sign = '+';
948             offset = -offset;
949         }
950         else sign = '-';
951
952         if(offset)
953             sprintfW(date_str, formatW, (int)hour_from_time(time),
954                     (int)min_from_time(time), (int)sec_from_time(time),
955                     sign, offset/60, offset%60);
956         else
957             sprintfW(date_str, formatUTCW, (int)hour_from_time(time),
958                     (int)min_from_time(time), (int)sec_from_time(time));
959
960         V_VT(retv) = VT_BSTR;
961         V_BSTR(retv) = date_str;
962     }
963     return S_OK;
964 }
965
966 /* ECMA-262 3rd Edition    15.9.5.6 */
967 static HRESULT Date_toLocaleDateString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
968         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
969 {
970     static const WCHAR NaNW[] = { 'N','a','N',0 };
971     SYSTEMTIME st;
972     DateInstance *date;
973     BSTR date_str;
974     int len;
975
976     TRACE("\n");
977
978     if(!(date = date_this(jsthis)))
979         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
980
981     if(isnan(date->time)) {
982         if(retv) {
983             V_VT(retv) = VT_BSTR;
984             V_BSTR(retv) = SysAllocString(NaNW);
985             if(!V_BSTR(retv))
986                 return E_OUTOFMEMORY;
987         }
988         return S_OK;
989     }
990
991     st = create_systemtime(local_time(date->time, date));
992
993     if(st.wYear<1601 || st.wYear>9999)
994         return dateobj_to_date_string(date, retv);
995
996     if(retv) {
997         len = GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
998         date_str = SysAllocStringLen(NULL, len);
999         if(!date_str)
1000             return E_OUTOFMEMORY;
1001         GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, date_str, len);
1002
1003         V_VT(retv) = VT_BSTR;
1004         V_BSTR(retv) = date_str;
1005     }
1006     return S_OK;
1007 }
1008
1009 /* ECMA-262 3rd Edition    15.9.5.7 */
1010 static HRESULT Date_toLocaleTimeString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1011         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1012 {
1013     static const WCHAR NaNW[] = { 'N','a','N',0 };
1014     SYSTEMTIME st;
1015     DateInstance *date;
1016     BSTR date_str;
1017     int len;
1018
1019     TRACE("\n");
1020
1021     if(!(date = date_this(jsthis)))
1022         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1023
1024     if(isnan(date->time)) {
1025         if(retv) {
1026             V_VT(retv) = VT_BSTR;
1027             V_BSTR(retv) = SysAllocString(NaNW);
1028             if(!V_BSTR(retv))
1029                 return E_OUTOFMEMORY;
1030         }
1031         return S_OK;
1032     }
1033
1034     st = create_systemtime(local_time(date->time, date));
1035
1036     if(st.wYear<1601 || st.wYear>9999)
1037         return Date_toTimeString(ctx, jsthis, flags, dp, retv, ei, caller);
1038
1039     if(retv) {
1040         len = GetTimeFormatW(ctx->lcid, 0, &st, NULL, NULL, 0);
1041         date_str = SysAllocStringLen(NULL, len);
1042         if(!date_str)
1043             return E_OUTOFMEMORY;
1044         GetTimeFormatW(ctx->lcid, 0, &st, NULL, date_str, len);
1045
1046         V_VT(retv) = VT_BSTR;
1047         V_BSTR(retv) = date_str;
1048     }
1049     return S_OK;
1050 }
1051
1052 /* ECMA-262 3rd Edition    15.9.5.9 */
1053 static HRESULT Date_getTime(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1054         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1055 {
1056     DateInstance *date;
1057
1058     TRACE("\n");
1059
1060     if(!(date = date_this(jsthis)))
1061         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1062
1063     if(retv)
1064         num_set_val(retv, date->time);
1065     return S_OK;
1066 }
1067
1068 /* ECMA-262 3rd Edition    15.9.5.10 */
1069 static HRESULT Date_getFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1070         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1071 {
1072     DateInstance *date;
1073
1074     TRACE("\n");
1075
1076     if(!(date = date_this(jsthis)))
1077         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1078
1079     if(retv) {
1080         DOUBLE time = local_time(date->time, date);
1081
1082         num_set_val(retv, year_from_time(time));
1083     }
1084     return S_OK;
1085 }
1086
1087 /* ECMA-262 3rd Edition    15.9.5.11 */
1088 static HRESULT Date_getUTCFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1089         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1090 {
1091     DateInstance *date;
1092
1093     TRACE("\n");
1094
1095     if(!(date = date_this(jsthis)))
1096         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1097
1098     if(retv)
1099         num_set_val(retv, year_from_time(date->time));
1100     return S_OK;
1101 }
1102
1103 /* ECMA-262 3rd Edition    15.9.5.12 */
1104 static HRESULT Date_getMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1105         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1106 {
1107     DateInstance *date;
1108
1109     TRACE("\n");
1110
1111     if(!(date = date_this(jsthis)))
1112         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1113
1114     if(retv) {
1115         DOUBLE time = local_time(date->time, date);
1116
1117         num_set_val(retv, month_from_time(time));
1118     }
1119     return S_OK;
1120 }
1121
1122 /* ECMA-262 3rd Edition    15.9.5.13 */
1123 static HRESULT Date_getUTCMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1124         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1125 {
1126     DateInstance *date;
1127
1128     TRACE("\n");
1129
1130     if(!(date = date_this(jsthis)))
1131         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1132
1133     if(retv)
1134         num_set_val(retv, month_from_time(date->time));
1135     return S_OK;
1136 }
1137
1138 /* ECMA-262 3rd Edition    15.9.5.14 */
1139 static HRESULT Date_getDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1140         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1141 {
1142     DateInstance *date;
1143
1144     TRACE("\n");
1145
1146     if(!(date = date_this(jsthis)))
1147         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1148
1149     if(retv) {
1150         DOUBLE time = local_time(date->time, date);
1151
1152         num_set_val(retv, date_from_time(time));
1153     }
1154     return S_OK;
1155 }
1156
1157 /* ECMA-262 3rd Edition    15.9.5.15 */
1158 static HRESULT Date_getUTCDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1159         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1160 {
1161     DateInstance *date;
1162
1163     TRACE("\n");
1164
1165     if(!(date = date_this(jsthis)))
1166         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1167
1168     if(retv)
1169         num_set_val(retv, date_from_time(date->time));
1170     return S_OK;
1171 }
1172
1173 /* ECMA-262 3rd Edition    15.9.5.16 */
1174 static HRESULT Date_getDay(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1175         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1176 {
1177     DateInstance *date;
1178
1179     TRACE("\n");
1180
1181     if(!(date = date_this(jsthis)))
1182         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1183
1184     if(retv) {
1185         DOUBLE time = local_time(date->time, date);
1186
1187         num_set_val(retv, week_day(time));
1188     }
1189     return S_OK;
1190 }
1191
1192 /* ECMA-262 3rd Edition    15.9.5.17 */
1193 static HRESULT Date_getUTCDay(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1194         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1195 {
1196     DateInstance *date;
1197
1198     TRACE("\n");
1199
1200     if(!(date = date_this(jsthis)))
1201         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1202
1203     if(retv)
1204         num_set_val(retv, week_day(date->time));
1205     return S_OK;
1206 }
1207
1208 /* ECMA-262 3rd Edition    15.9.5.18 */
1209 static HRESULT Date_getHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1210         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1211 {
1212     DateInstance *date;
1213
1214     TRACE("\n");
1215
1216     if(!(date = date_this(jsthis)))
1217         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1218
1219     if(retv) {
1220         DOUBLE time = local_time(date->time, date);
1221
1222         num_set_val(retv, hour_from_time(time));
1223     }
1224     return S_OK;
1225 }
1226
1227 /* ECMA-262 3rd Edition    15.9.5.19 */
1228 static HRESULT Date_getUTCHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1229         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1230 {
1231     DateInstance *date;
1232
1233     TRACE("\n");
1234
1235     if(!(date = date_this(jsthis)))
1236         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1237
1238     if(retv)
1239         num_set_val(retv, hour_from_time(date->time));
1240     return S_OK;
1241 }
1242
1243 /* ECMA-262 3rd Edition    15.9.5.20 */
1244 static HRESULT Date_getMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1245         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1246 {
1247     DateInstance *date;
1248
1249     TRACE("\n");
1250
1251     if(!(date = date_this(jsthis)))
1252         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1253
1254     if(retv) {
1255         DOUBLE time = local_time(date->time, date);
1256
1257         num_set_val(retv, min_from_time(time));
1258     }
1259     return S_OK;
1260 }
1261
1262 /* ECMA-262 3rd Edition    15.9.5.21 */
1263 static HRESULT Date_getUTCMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1264         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1265 {
1266     DateInstance *date;
1267
1268     TRACE("\n");
1269
1270     if(!(date = date_this(jsthis)))
1271         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1272
1273     if(retv)
1274         num_set_val(retv, min_from_time(date->time));
1275     return S_OK;
1276 }
1277
1278 /* ECMA-262 3rd Edition    15.9.5.22 */
1279 static HRESULT Date_getSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1280         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1281 {
1282     DateInstance *date;
1283
1284     TRACE("\n");
1285
1286     if(!(date = date_this(jsthis)))
1287         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1288
1289     if(retv) {
1290         DOUBLE time = local_time(date->time, date);
1291
1292         num_set_val(retv, sec_from_time(time));
1293     }
1294     return S_OK;
1295 }
1296
1297 /* ECMA-262 3rd Edition    15.9.5.23 */
1298 static HRESULT Date_getUTCSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1299         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1300 {
1301     DateInstance *date;
1302
1303     TRACE("\n");
1304
1305     if(!(date = date_this(jsthis)))
1306         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1307
1308     if(retv)
1309         num_set_val(retv, sec_from_time(date->time));
1310     return S_OK;
1311 }
1312
1313 /* ECMA-262 3rd Edition    15.9.5.24 */
1314 static HRESULT Date_getMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1315         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1316 {
1317     DateInstance *date;
1318
1319     TRACE("\n");
1320
1321     if(!(date = date_this(jsthis)))
1322         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1323
1324     if(retv) {
1325         DOUBLE time = local_time(date->time, date);
1326
1327         num_set_val(retv, ms_from_time(time));
1328     }
1329     return S_OK;
1330 }
1331
1332 /* ECMA-262 3rd Edition    15.9.5.25 */
1333 static HRESULT Date_getUTCMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1334         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1335 {
1336     DateInstance *date;
1337
1338     TRACE("\n");
1339
1340     if(!(date = date_this(jsthis)))
1341         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1342
1343     if(retv)
1344         num_set_val(retv, ms_from_time(date->time));
1345     return S_OK;
1346 }
1347
1348 /* ECMA-262 3rd Edition    15.9.5.26 */
1349 static HRESULT Date_getTimezoneOffset(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1350         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1351 {
1352     DateInstance *date;
1353
1354     TRACE("\n");
1355
1356     if(!(date = date_this(jsthis)))
1357         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1358
1359     if(retv)
1360         num_set_val(retv, floor(
1361                     (date->time-local_time(date->time, date))/MS_PER_MINUTE));
1362     return S_OK;
1363 }
1364
1365 /* ECMA-262 3rd Edition    15.9.5.27 */
1366 static HRESULT Date_setTime(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1367         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1368 {
1369     VARIANT v;
1370     HRESULT hres;
1371     DateInstance *date;
1372
1373     TRACE("\n");
1374
1375     if(!(date = date_this(jsthis)))
1376         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1377
1378     if(!arg_cnt(dp))
1379         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1380
1381     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1382     if(FAILED(hres))
1383         return hres;
1384
1385     date->time = time_clip(num_val(&v));
1386
1387     if(retv)
1388         num_set_val(retv, date->time);
1389
1390     return S_OK;
1391 }
1392
1393 /* ECMA-262 3rd Edition    15.9.5.28 */
1394 static HRESULT Date_setMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1395         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1396 {
1397     VARIANT v;
1398     HRESULT hres;
1399     DateInstance *date;
1400     DOUBLE t;
1401
1402     TRACE("\n");
1403
1404     if(!(date = date_this(jsthis)))
1405         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1406
1407     if(!arg_cnt(dp))
1408         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1409
1410     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1411     if(FAILED(hres))
1412         return hres;
1413
1414     t = local_time(date->time, date);
1415     t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1416                 sec_from_time(t), num_val(&v)));
1417     date->time = time_clip(utc(t, date));
1418
1419     if(retv)
1420         num_set_val(retv, date->time);
1421
1422     return S_OK;
1423 }
1424
1425 /* ECMA-262 3rd Edition    15.9.5.29 */
1426 static HRESULT Date_setUTCMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1427         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1428 {
1429     VARIANT v;
1430     HRESULT hres;
1431     DateInstance *date;
1432     DOUBLE t;
1433
1434     TRACE("\n");
1435
1436     if(!(date = date_this(jsthis)))
1437         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1438
1439     if(!arg_cnt(dp))
1440         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1441
1442     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1443     if(FAILED(hres))
1444         return hres;
1445
1446     t = date->time;
1447     t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1448                 sec_from_time(t), num_val(&v)));
1449     date->time = time_clip(t);
1450
1451     if(retv)
1452         num_set_val(retv, date->time);
1453
1454     return S_OK;
1455 }
1456
1457 /* ECMA-262 3rd Edition    15.9.5.30 */
1458 static HRESULT Date_setSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1459         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1460 {
1461     VARIANT v;
1462     HRESULT hres;
1463     DateInstance *date;
1464     DOUBLE t, sec, ms;
1465
1466     TRACE("\n");
1467
1468     if(!(date = date_this(jsthis)))
1469         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1470
1471     if(!arg_cnt(dp))
1472         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1473
1474     t = local_time(date->time, date);
1475
1476     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1477     if(FAILED(hres))
1478         return hres;
1479     sec = num_val(&v);
1480
1481     if(arg_cnt(dp) > 1) {
1482         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1483         if(FAILED(hres))
1484             return hres;
1485         ms = num_val(&v);
1486     }
1487     else ms = ms_from_time(t);
1488
1489     t = make_date(day(t), make_time(hour_from_time(t),
1490                 min_from_time(t), sec, ms));
1491     date->time = time_clip(utc(t, date));
1492
1493     if(retv)
1494         num_set_val(retv, date->time);
1495
1496     return S_OK;
1497 }
1498
1499 /* ECMA-262 3rd Edition    15.9.5.31 */
1500 static HRESULT Date_setUTCSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1501         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1502 {
1503     VARIANT v;
1504     HRESULT hres;
1505     DateInstance *date;
1506     DOUBLE t, sec, ms;
1507
1508     TRACE("\n");
1509
1510     if(!(date = date_this(jsthis)))
1511         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1512
1513     if(!arg_cnt(dp))
1514         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1515
1516     t = date->time;
1517
1518     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1519     if(FAILED(hres))
1520         return hres;
1521     sec = num_val(&v);
1522
1523     if(arg_cnt(dp) > 1) {
1524         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1525         if(FAILED(hres))
1526             return hres;
1527         ms = num_val(&v);
1528     }
1529     else ms = ms_from_time(t);
1530
1531     t = make_date(day(t), make_time(hour_from_time(t),
1532                 min_from_time(t), sec, ms));
1533     date->time = time_clip(t);
1534
1535     if(retv)
1536         num_set_val(retv, date->time);
1537
1538     return S_OK;
1539 }
1540
1541 /* ECMA-262 3rd Edition    15.9.5.33 */
1542 static HRESULT Date_setMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1543         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1544 {
1545     VARIANT v;
1546     HRESULT hres;
1547     DateInstance *date;
1548     DOUBLE t, min, sec, ms;
1549
1550     TRACE("\n");
1551
1552     if(!(date = date_this(jsthis)))
1553         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1554
1555     if(!arg_cnt(dp))
1556         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1557
1558     t = local_time(date->time, date);
1559
1560     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1561     if(FAILED(hres))
1562         return hres;
1563     min = num_val(&v);
1564
1565     if(arg_cnt(dp) > 1) {
1566         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1567         if(FAILED(hres))
1568             return hres;
1569         sec = num_val(&v);
1570     }
1571     else sec = sec_from_time(t);
1572
1573     if(arg_cnt(dp) > 2) {
1574         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1575         if(FAILED(hres))
1576             return hres;
1577         ms = num_val(&v);
1578     }
1579     else ms = ms_from_time(t);
1580
1581     t = make_date(day(t), make_time(hour_from_time(t),
1582                 min, sec, ms));
1583     date->time = time_clip(utc(t, date));
1584
1585     if(retv)
1586         num_set_val(retv, date->time);
1587
1588     return S_OK;
1589 }
1590
1591 /* ECMA-262 3rd Edition    15.9.5.34 */
1592 static HRESULT Date_setUTCMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1593         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1594 {
1595     VARIANT v;
1596     HRESULT hres;
1597     DateInstance *date;
1598     DOUBLE t, min, sec, ms;
1599
1600     TRACE("\n");
1601
1602     if(!(date = date_this(jsthis)))
1603         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1604
1605     if(!arg_cnt(dp))
1606         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1607
1608     t = date->time;
1609
1610     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1611     if(FAILED(hres))
1612         return hres;
1613     min = num_val(&v);
1614
1615     if(arg_cnt(dp) > 1) {
1616         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1617         if(FAILED(hres))
1618             return hres;
1619         sec = num_val(&v);
1620     }
1621     else sec = sec_from_time(t);
1622
1623     if(arg_cnt(dp) > 2) {
1624         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1625         if(FAILED(hres))
1626             return hres;
1627         ms = num_val(&v);
1628     }
1629     else ms = ms_from_time(t);
1630
1631     t = make_date(day(t), make_time(hour_from_time(t),
1632                 min, sec, ms));
1633     date->time = time_clip(t);
1634
1635     if(retv)
1636         num_set_val(retv, date->time);
1637
1638     return S_OK;
1639 }
1640
1641 /* ECMA-262 3rd Edition    15.9.5.35 */
1642 static HRESULT Date_setHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1643         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1644 {
1645     VARIANT v;
1646     HRESULT hres;
1647     DateInstance *date;
1648     DOUBLE t, hour, min, sec, ms;
1649
1650     TRACE("\n");
1651
1652     if(!(date = date_this(jsthis)))
1653         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1654
1655     if(!arg_cnt(dp))
1656         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1657
1658     t = local_time(date->time, date);
1659
1660     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1661     if(FAILED(hres))
1662         return hres;
1663     hour = num_val(&v);
1664
1665     if(arg_cnt(dp) > 1) {
1666         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1667         if(FAILED(hres))
1668             return hres;
1669         min = num_val(&v);
1670     }
1671     else min = min_from_time(t);
1672
1673     if(arg_cnt(dp) > 2) {
1674         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1675         if(FAILED(hres))
1676             return hres;
1677         sec = num_val(&v);
1678     }
1679     else sec = sec_from_time(t);
1680
1681     if(arg_cnt(dp) > 3) {
1682         hres = to_number(ctx, get_arg(dp, 3), ei, &v);
1683         if(FAILED(hres))
1684             return hres;
1685         ms = num_val(&v);
1686     }
1687     else ms = ms_from_time(t);
1688
1689     t = make_date(day(t), make_time(hour, min, sec, ms));
1690     date->time = time_clip(utc(t, date));
1691
1692     if(retv)
1693         num_set_val(retv, date->time);
1694
1695     return S_OK;
1696 }
1697
1698 /* ECMA-262 3rd Edition    15.9.5.36 */
1699 static HRESULT Date_setUTCHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1700         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1701 {
1702     DateInstance *date;
1703     VARIANT v;
1704     HRESULT hres;
1705     DOUBLE t, hour, min, sec, ms;
1706
1707     TRACE("\n");
1708
1709     if(!(date = date_this(jsthis)))
1710         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1711
1712     if(!arg_cnt(dp))
1713         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1714
1715     t = date->time;
1716
1717     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1718     if(FAILED(hres))
1719         return hres;
1720     hour = num_val(&v);
1721
1722     if(arg_cnt(dp) > 1) {
1723         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1724         if(FAILED(hres))
1725             return hres;
1726         min = num_val(&v);
1727     }
1728     else min = min_from_time(t);
1729
1730     if(arg_cnt(dp) > 2) {
1731         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1732         if(FAILED(hres))
1733             return hres;
1734         sec = num_val(&v);
1735     }
1736     else sec = sec_from_time(t);
1737
1738     if(arg_cnt(dp) > 3) {
1739         hres = to_number(ctx, get_arg(dp, 3), ei, &v);
1740         if(FAILED(hres))
1741             return hres;
1742         ms = num_val(&v);
1743     }
1744     else ms = ms_from_time(t);
1745
1746     t = make_date(day(t), make_time(hour, min, sec, ms));
1747     date->time = time_clip(t);
1748
1749     if(retv)
1750         num_set_val(retv, date->time);
1751
1752     return S_OK;
1753 }
1754
1755 /* ECMA-262 3rd Edition    15.9.5.36 */
1756 static HRESULT Date_setDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1757         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1758 {
1759     VARIANT v;
1760     HRESULT hres;
1761     DateInstance *date;
1762     DOUBLE t;
1763
1764     TRACE("\n");
1765
1766     if(!(date = date_this(jsthis)))
1767         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1768
1769     if(!arg_cnt(dp))
1770         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1771
1772     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1773     if(FAILED(hres))
1774         return hres;
1775
1776     t = local_time(date->time, date);
1777     t = make_date(make_day(year_from_time(t), month_from_time(t),
1778                 num_val(&v)), time_within_day(t));
1779     date->time = time_clip(utc(t, date));
1780
1781     if(retv)
1782         num_set_val(retv, date->time);
1783
1784     return S_OK;
1785 }
1786
1787 /* ECMA-262 3rd Edition    15.9.5.37 */
1788 static HRESULT Date_setUTCDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1789         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1790 {
1791     VARIANT v;
1792     HRESULT hres;
1793     DateInstance *date;
1794     DOUBLE t;
1795
1796     TRACE("\n");
1797
1798     if(!(date = date_this(jsthis)))
1799         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1800
1801     if(!arg_cnt(dp))
1802         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1803
1804     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1805     if(FAILED(hres))
1806         return hres;
1807
1808     t = date->time;
1809     t = make_date(make_day(year_from_time(t), month_from_time(t),
1810                 num_val(&v)), time_within_day(t));
1811     date->time = time_clip(t);
1812
1813     if(retv)
1814         num_set_val(retv, date->time);
1815
1816     return S_OK;
1817 }
1818
1819 /* ECMA-262 3rd Edition    15.9.5.38 */
1820 static HRESULT Date_setMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1821         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1822 {
1823     VARIANT v;
1824     HRESULT hres;
1825     DateInstance *date;
1826     DOUBLE t, month, ddate;
1827
1828     TRACE("\n");
1829
1830     if(!(date = date_this(jsthis)))
1831         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1832
1833     if(!arg_cnt(dp))
1834         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1835
1836     t = local_time(date->time, date);
1837
1838     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1839     if(FAILED(hres))
1840         return hres;
1841     month = num_val(&v);
1842
1843     if(arg_cnt(dp) > 1) {
1844         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1845         if(FAILED(hres))
1846             return hres;
1847         ddate = num_val(&v);
1848     }
1849     else ddate = date_from_time(t);
1850
1851     t = make_date(make_day(year_from_time(t), month, ddate),
1852             time_within_day(t));
1853     date->time = time_clip(utc(t, date));
1854
1855     if(retv)
1856         num_set_val(retv, date->time);
1857
1858     return S_OK;
1859 }
1860
1861 /* ECMA-262 3rd Edition    15.9.5.39 */
1862 static HRESULT Date_setUTCMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1863         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1864 {
1865     VARIANT v;
1866     HRESULT hres;
1867     DateInstance *date;
1868     DOUBLE t, month, ddate;
1869
1870     TRACE("\n");
1871
1872     if(!(date = date_this(jsthis)))
1873         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1874
1875     if(!arg_cnt(dp))
1876         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1877
1878     t = date->time;
1879
1880     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1881     if(FAILED(hres))
1882         return hres;
1883     month = num_val(&v);
1884
1885     if(arg_cnt(dp) > 1) {
1886         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1887         if(FAILED(hres))
1888             return hres;
1889         ddate = num_val(&v);
1890     }
1891     else ddate = date_from_time(t);
1892
1893     t = make_date(make_day(year_from_time(t), month, ddate),
1894             time_within_day(t));
1895     date->time = time_clip(t);
1896
1897     if(retv)
1898         num_set_val(retv, date->time);
1899
1900     return S_OK;
1901 }
1902
1903 /* ECMA-262 3rd Edition    15.9.5.40 */
1904 static HRESULT Date_setFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1905         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1906 {
1907     VARIANT v;
1908     HRESULT hres;
1909     DateInstance *date;
1910     DOUBLE t, year, month, ddate;
1911
1912     TRACE("\n");
1913
1914     if(!(date = date_this(jsthis)))
1915         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1916
1917     if(!arg_cnt(dp))
1918         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1919
1920     t = local_time(date->time, date);
1921
1922     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1923     if(FAILED(hres))
1924         return hres;
1925     year = num_val(&v);
1926
1927     if(arg_cnt(dp) > 1) {
1928         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1929         if(FAILED(hres))
1930             return hres;
1931         month = num_val(&v);
1932     }
1933     else month = month_from_time(t);
1934
1935     if(arg_cnt(dp) > 2) {
1936         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1937         if(FAILED(hres))
1938             return hres;
1939         ddate = num_val(&v);
1940     }
1941     else ddate = date_from_time(t);
1942
1943     t = make_date(make_day(year, month, ddate), time_within_day(t));
1944     date->time = time_clip(utc(t, date));
1945
1946     if(retv)
1947         num_set_val(retv, date->time);
1948
1949     return S_OK;
1950 }
1951
1952 /* ECMA-262 3rd Edition    15.9.5.41 */
1953 static HRESULT Date_setUTCFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1954         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1955 {
1956     VARIANT v;
1957     HRESULT hres;
1958     DateInstance *date;
1959     DOUBLE t, year, month, ddate;
1960
1961     TRACE("\n");
1962
1963     if(!(date = date_this(jsthis)))
1964         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1965
1966     if(!arg_cnt(dp))
1967         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1968
1969     t = date->time;
1970
1971     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
1972     if(FAILED(hres))
1973         return hres;
1974     year = num_val(&v);
1975
1976     if(arg_cnt(dp) > 1) {
1977         hres = to_number(ctx, get_arg(dp, 1), ei, &v);
1978         if(FAILED(hres))
1979             return hres;
1980         month = num_val(&v);
1981     }
1982     else month = month_from_time(t);
1983
1984     if(arg_cnt(dp) > 2) {
1985         hres = to_number(ctx, get_arg(dp, 2), ei, &v);
1986         if(FAILED(hres))
1987             return hres;
1988         ddate = num_val(&v);
1989     }
1990     else ddate = date_from_time(t);
1991
1992     t = make_date(make_day(year, month, ddate), time_within_day(t));
1993     date->time = time_clip(t);
1994
1995     if(retv)
1996         num_set_val(retv, date->time);
1997
1998     return S_OK;
1999 }
2000
2001 /* ECMA-262 3rd Edition    B2.4 */
2002 static HRESULT Date_getYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2003         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
2004 {
2005     DateInstance *date;
2006     DOUBLE t, year;
2007
2008     TRACE("\n");
2009
2010     if(!(date = date_this(jsthis)))
2011         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
2012
2013     t = local_time(date->time, date);
2014     if(isnan(t)) {
2015         if(retv)
2016             num_set_nan(retv);
2017         return S_OK;
2018     }
2019
2020     year = year_from_time(t);
2021     if(retv)
2022         num_set_val(retv, (1900<=year && year<2000)?year-1900:year);
2023
2024     return S_OK;
2025 }
2026
2027 /* ECMA-262 3rd Edition    B2.5 */
2028 static HRESULT Date_setYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2029         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
2030 {
2031     DateInstance *date;
2032     DOUBLE t, year;
2033     VARIANT v;
2034     HRESULT hres;
2035
2036     TRACE("\n");
2037
2038     if(!(date = date_this(jsthis)))
2039         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
2040
2041     if(!arg_cnt(dp))
2042         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
2043
2044     t = local_time(date->time, date);
2045
2046     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
2047     if(FAILED(hres))
2048         return hres;
2049
2050     year = num_val(&v);
2051     if(isnan(year)) {
2052         date->time = year;
2053         if(retv)
2054             num_set_nan(retv);
2055         return S_OK;
2056     }
2057
2058     year = year >= 0.0 ? floor(year) : -floor(-year);
2059     if(-1.0 < year && year < 100.0)
2060         year += 1900.0;
2061
2062     date->time = time_clip(utc(make_date(make_day(year, month_from_time(t), date_from_time(t)), time_within_day(t)), date));
2063
2064     if(retv)
2065         num_set_val(retv, date->time);
2066     return S_OK;
2067 }
2068
2069 static HRESULT Date_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2070         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
2071 {
2072     TRACE("\n");
2073
2074     switch(flags) {
2075     case INVOKE_FUNC:
2076         return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2077     default:
2078         FIXME("unimplemented flags %x\n", flags);
2079         return E_NOTIMPL;
2080     }
2081
2082     return S_OK;
2083 }
2084
2085 static const builtin_prop_t Date_props[] = {
2086     {getDateW,               Date_getDate,               PROPF_METHOD},
2087     {getDayW,                Date_getDay,                PROPF_METHOD},
2088     {getFullYearW,           Date_getFullYear,           PROPF_METHOD},
2089     {getHoursW,              Date_getHours,              PROPF_METHOD},
2090     {getMillisecondsW,       Date_getMilliseconds,       PROPF_METHOD},
2091     {getMinutesW,            Date_getMinutes,            PROPF_METHOD},
2092     {getMonthW,              Date_getMonth,              PROPF_METHOD},
2093     {getSecondsW,            Date_getSeconds,            PROPF_METHOD},
2094     {getTimeW,               Date_getTime,               PROPF_METHOD},
2095     {getTimezoneOffsetW,     Date_getTimezoneOffset,     PROPF_METHOD},
2096     {getUTCDateW,            Date_getUTCDate,            PROPF_METHOD},
2097     {getUTCDayW,             Date_getUTCDay,             PROPF_METHOD},
2098     {getUTCFullYearW,        Date_getUTCFullYear,        PROPF_METHOD},
2099     {getUTCHoursW,           Date_getUTCHours,           PROPF_METHOD},
2100     {getUTCMillisecondsW,    Date_getUTCMilliseconds,    PROPF_METHOD},
2101     {getUTCMinutesW,         Date_getUTCMinutes,         PROPF_METHOD},
2102     {getUTCMonthW,           Date_getUTCMonth,           PROPF_METHOD},
2103     {getUTCSecondsW,         Date_getUTCSeconds,         PROPF_METHOD},
2104     {getYearW,               Date_getYear,               PROPF_METHOD},
2105     {setDateW,               Date_setDate,               PROPF_METHOD|1},
2106     {setFullYearW,           Date_setFullYear,           PROPF_METHOD|3},
2107     {setHoursW,              Date_setHours,              PROPF_METHOD|4},
2108     {setMillisecondsW,       Date_setMilliseconds,       PROPF_METHOD|1},
2109     {setMinutesW,            Date_setMinutes,            PROPF_METHOD|3},
2110     {setMonthW,              Date_setMonth,              PROPF_METHOD|2},
2111     {setSecondsW,            Date_setSeconds,            PROPF_METHOD|2},
2112     {setTimeW,               Date_setTime,               PROPF_METHOD|1},
2113     {setUTCDateW,            Date_setUTCDate,            PROPF_METHOD|1},
2114     {setUTCFullYearW,        Date_setUTCFullYear,        PROPF_METHOD|3},
2115     {setUTCHoursW,           Date_setUTCHours,           PROPF_METHOD|4},
2116     {setUTCMillisecondsW,    Date_setUTCMilliseconds,    PROPF_METHOD|1},
2117     {setUTCMinutesW,         Date_setUTCMinutes,         PROPF_METHOD|3},
2118     {setUTCMonthW,           Date_setUTCMonth,           PROPF_METHOD|2},
2119     {setUTCSecondsW,         Date_setUTCSeconds,         PROPF_METHOD|2},
2120     {setYearW,               Date_setYear,               PROPF_METHOD|1},
2121     {toDateStringW,          Date_toDateString,          PROPF_METHOD},
2122     {toGMTStringW,           Date_toGMTString,           PROPF_METHOD},
2123     {toLocaleDateStringW,    Date_toLocaleDateString,    PROPF_METHOD},
2124     {toLocaleStringW,        Date_toLocaleString,        PROPF_METHOD},
2125     {toLocaleTimeStringW,    Date_toLocaleTimeString,    PROPF_METHOD},
2126     {toStringW,              Date_toString,              PROPF_METHOD},
2127     {toTimeStringW,          Date_toTimeString,          PROPF_METHOD},
2128     {toUTCStringW,           Date_toUTCString,           PROPF_METHOD},
2129     {valueOfW,               Date_valueOf,               PROPF_METHOD},
2130 };
2131
2132 static const builtin_info_t Date_info = {
2133     JSCLASS_DATE,
2134     {NULL, Date_value, 0},
2135     sizeof(Date_props)/sizeof(*Date_props),
2136     Date_props,
2137     NULL,
2138     NULL
2139 };
2140
2141 static HRESULT create_date(script_ctx_t *ctx, jsdisp_t *object_prototype, DOUBLE time, jsdisp_t **ret)
2142 {
2143     DateInstance *date;
2144     HRESULT hres;
2145     TIME_ZONE_INFORMATION tzi;
2146
2147     GetTimeZoneInformation(&tzi);
2148
2149     date = heap_alloc_zero(sizeof(DateInstance));
2150     if(!date)
2151         return E_OUTOFMEMORY;
2152
2153     if(object_prototype)
2154         hres = init_dispex(&date->dispex, ctx, &Date_info, object_prototype);
2155     else
2156         hres = init_dispex_from_constr(&date->dispex, ctx, &Date_info, ctx->date_constr);
2157     if(FAILED(hres)) {
2158         heap_free(date);
2159         return hres;
2160     }
2161
2162     date->time = time;
2163     date->bias = tzi.Bias;
2164     date->standardDate = tzi.StandardDate;
2165     date->standardBias = tzi.StandardBias;
2166     date->daylightDate = tzi.DaylightDate;
2167     date->daylightBias = tzi.DaylightBias;
2168
2169     *ret = &date->dispex;
2170     return S_OK;
2171 }
2172
2173 static inline HRESULT date_parse(BSTR input, VARIANT *retv) {
2174     static const DWORD string_ids[] = { LOCALE_SMONTHNAME12, LOCALE_SMONTHNAME11,
2175         LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME8,
2176         LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME5,
2177         LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME2,
2178         LOCALE_SMONTHNAME1, LOCALE_SDAYNAME7, LOCALE_SDAYNAME1,
2179         LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
2180         LOCALE_SDAYNAME5, LOCALE_SDAYNAME6 };
2181     BSTR strings[sizeof(string_ids)/sizeof(DWORD)];
2182
2183     BSTR parse;
2184     int input_len, parse_len = 0, nest_level = 0, i, size;
2185     int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
2186     int ms = 0, offset = 0, hour_adjust = 0;
2187     BOOL set_year = FALSE, set_month = FALSE, set_day = FALSE, set_hour = FALSE;
2188     BOOL set_offset = FALSE, set_era = FALSE, ad = TRUE, set_am = FALSE, am = TRUE;
2189     BOOL set_hour_adjust = TRUE;
2190     TIME_ZONE_INFORMATION tzi;
2191     DateInstance di;
2192     DWORD lcid_en;
2193
2194     if(retv) num_set_nan(retv);
2195
2196     input_len = SysStringLen(input);
2197     for(i=0; i<input_len; i++) {
2198         if(input[i] == '(') nest_level++;
2199         else if(input[i] == ')') {
2200             nest_level--;
2201             if(nest_level<0)
2202                 return S_OK;
2203         }
2204         else if(!nest_level) parse_len++;
2205     }
2206
2207     parse = SysAllocStringLen(NULL, parse_len);
2208     if(!parse)
2209         return E_OUTOFMEMORY;
2210     nest_level = 0;
2211     parse_len = 0;
2212     for(i=0; i<input_len; i++) {
2213         if(input[i] == '(') nest_level++;
2214         else if(input[i] == ')') nest_level--;
2215         else if(!nest_level) parse[parse_len++] = toupperW(input[i]);
2216     }
2217
2218     GetTimeZoneInformation(&tzi);
2219     di.bias = tzi.Bias;
2220     di.standardDate = tzi.StandardDate;
2221     di.standardBias = tzi.StandardBias;
2222     di.daylightDate = tzi.DaylightDate;
2223     di.daylightBias = tzi.DaylightBias;
2224
2225     lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2226     for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++) {
2227         size = GetLocaleInfoW(lcid_en, string_ids[i], NULL, 0);
2228         strings[i] = SysAllocStringLen(NULL, size);
2229         if(!strings[i]) {
2230             i--;
2231             while(i-- >= 0)
2232                 SysFreeString(strings[i]);
2233             SysFreeString(parse);
2234             return E_OUTOFMEMORY;
2235         }
2236         GetLocaleInfoW(lcid_en, string_ids[i], strings[i], size);
2237     }
2238
2239     for(i=0; i<parse_len;) {
2240         while(isspaceW(parse[i])) i++;
2241         if(parse[i] == ',') {
2242             while(parse[i] == ',') i++;
2243             continue;
2244         }
2245
2246         if(parse[i]>='0' && parse[i]<='9') {
2247             int tmp = atoiW(&parse[i]);
2248             while(parse[i]>='0' && parse[i]<='9') i++;
2249             while(isspaceW(parse[i])) i++;
2250
2251             if(parse[i] == ':') {
2252                 /* Time */
2253                 if(set_hour) break;
2254                 set_hour = TRUE;
2255
2256                 hour = tmp;
2257
2258                 while(parse[i] == ':') i++;
2259                 while(isspaceW(parse[i])) i++;
2260                 if(parse[i]>='0' && parse[i]<='9') {
2261                     min = atoiW(&parse[i]);
2262                     while(parse[i]>='0' && parse[i]<='9') i++;
2263                 }
2264
2265                 while(isspaceW(parse[i])) i++;
2266                 while(parse[i] == ':') i++;
2267                 while(isspaceW(parse[i])) i++;
2268                 if(parse[i]>='0' && parse[i]<='9') {
2269                     sec = atoiW(&parse[i]);
2270                     while(parse[i]>='0' && parse[i]<='9') i++;
2271                 }
2272             }
2273             else if(parse[i]=='-' || parse[i]=='/') {
2274                 /* Short date */
2275                 if(set_day || set_month || set_year) break;
2276                 set_day = TRUE;
2277                 set_month = TRUE;
2278                 set_year = TRUE;
2279
2280                 month = tmp-1;
2281
2282                 while(isspaceW(parse[i])) i++;
2283                 while(parse[i]=='-' || parse[i]=='/') i++;
2284                 while(isspaceW(parse[i])) i++;
2285                 if(parse[i]<'0' || parse[i]>'9') break;
2286                 day = atoiW(&parse[i]);
2287                 while(parse[i]>='0' && parse[i]<='9') i++;
2288
2289                 while(parse[i]=='-' || parse[i]=='/') i++;
2290                 while(isspaceW(parse[i])) i++;
2291                 if(parse[i]<'0' || parse[i]>'9') break;
2292                 year = atoiW(&parse[i]);
2293                 while(parse[i]>='0' && parse[i]<='9') i++;
2294             }
2295             else if(tmp<0) break;
2296             else if(tmp<70) {
2297                 /* Day */
2298                 if(set_day) break;
2299                 set_day = TRUE;
2300                 day = tmp;
2301             }
2302             else {
2303                 /* Year */
2304                 if(set_year) break;
2305                 set_year = TRUE;
2306                 year = tmp;
2307             }
2308         }
2309         else {
2310             if(parse[i]<'A' || parse[i]>'Z') break;
2311             else if(parse[i]=='B' && (parse[i+1]=='C' ||
2312                         (parse[i+1]=='.' && parse[i+2]=='C'))) {
2313                 /* AD/BC */
2314                 if(set_era) break;
2315                 set_era = TRUE;
2316                 ad = FALSE;
2317
2318                 i++;
2319                 if(parse[i] == '.') i++;
2320                 i++;
2321                 if(parse[i] == '.') i++;
2322             }
2323             else if(parse[i]=='A' && (parse[i+1]=='D' ||
2324                         (parse[i+1]=='.' && parse[i+2]=='D'))) {
2325                 /* AD/BC */
2326                 if(set_era) break;
2327                 set_era = TRUE;
2328
2329                 i++;
2330                 if(parse[i] == '.') i++;
2331                 i++;
2332                 if(parse[i] == '.') i++;
2333             }
2334             else if(parse[i+1]<'A' || parse[i+1]>'Z') {
2335                 /* Timezone */
2336                 if(set_offset) break;
2337                 set_offset = TRUE;
2338
2339                 if(parse[i] <= 'I') hour_adjust = parse[i]-'A'+2;
2340                 else if(parse[i] == 'J') break;
2341                 else if(parse[i] <= 'M') hour_adjust = parse[i]-'K'+11;
2342                 else if(parse[i] <= 'Y') hour_adjust = parse[i]-'N';
2343                 else hour_adjust = 1;
2344
2345                 i++;
2346                 if(parse[i] == '.') i++;
2347             }
2348             else if(parse[i]=='A' && parse[i+1]=='M') {
2349                 /* AM/PM */
2350                 if(set_am) break;
2351                 set_am = TRUE;
2352                 am = TRUE;
2353                 i += 2;
2354             }
2355             else if(parse[i]=='P' && parse[i+1]=='M') {
2356                 /* AM/PM */
2357                 if(set_am) break;
2358                 set_am = TRUE;
2359                 am = FALSE;
2360                 i += 2;
2361             }
2362             else if((parse[i]=='U' && parse[i+1]=='T' && parse[i+2]=='C')
2363                     || (parse[i]=='G' && parse[i+1]=='M' && parse[i+2]=='T')) {
2364                 /* Timezone */
2365                 BOOL positive = TRUE;
2366
2367                 if(set_offset) break;
2368                 set_offset = TRUE;
2369                 set_hour_adjust = FALSE;
2370
2371                 i += 3;
2372                 while(isspaceW(parse[i])) i++;
2373                 if(parse[i] == '-')  positive = FALSE;
2374                 else if(parse[i] != '+') continue;
2375
2376                 i++;
2377                 while(isspaceW(parse[i])) i++;
2378                 if(parse[i]<'0' || parse[i]>'9') break;
2379                 offset = atoiW(&parse[i]);
2380                 while(parse[i]>='0' && parse[i]<='9') i++;
2381
2382                 if(offset<24) offset *= 60;
2383                 else offset = (offset/100)*60 + offset%100;
2384
2385                 if(positive) offset = -offset;
2386             }
2387             else {
2388                 /* Month or garbage */
2389                 int j;
2390
2391                 for(size=i; parse[size]>='A' && parse[size]<='Z'; size++);
2392                 size -= i;
2393
2394                 for(j=0; j<sizeof(string_ids)/sizeof(DWORD); j++)
2395                     if(!memicmpW(&parse[i], strings[j], size)) break;
2396
2397                 if(j < 12) {
2398                     if(set_month) break;
2399                     set_month = TRUE;
2400                     month = 11-j;
2401                 }
2402                 else if(j == sizeof(string_ids)/sizeof(DWORD)) break;
2403
2404                 i += size;
2405             }
2406         }
2407     }
2408
2409     if(retv && i==parse_len && set_year && set_month
2410             && set_day && (!set_am || hour<13)) {
2411         if(set_am) {
2412             if(hour == 12) hour = 0;
2413             if(!am) hour += 12;
2414         }
2415
2416         if(!ad) year = -year+1;
2417         else if(year<100) year += 1900;
2418
2419         V_VT(retv) = VT_R8;
2420         V_R8(retv) = time_clip(make_date(make_day(year, month, day),
2421                     make_time(hour+hour_adjust, min, sec, ms)) + offset*MS_PER_MINUTE);
2422
2423         if(set_hour_adjust) V_R8(retv) = utc(V_R8(retv), &di);
2424     }
2425
2426     for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++)
2427         SysFreeString(strings[i]);
2428     SysFreeString(parse);
2429
2430     return S_OK;
2431 }
2432
2433 static HRESULT DateConstr_parse(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2434         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2435 {
2436     BSTR parse_str;
2437     HRESULT hres;
2438
2439     TRACE("\n");
2440
2441     if(!arg_cnt(dp)) {
2442         if(retv)
2443             num_set_nan(retv);
2444         return S_OK;
2445     }
2446
2447     hres = to_string(ctx, get_arg(dp,0), ei, &parse_str);
2448     if(FAILED(hres))
2449         return hres;
2450
2451     hres = date_parse(parse_str, retv);
2452
2453     SysFreeString(parse_str);
2454     return hres;
2455 }
2456
2457 static HRESULT date_utc(script_ctx_t *ctx, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei)
2458 {
2459     VARIANT year, month, vdate, hours, minutes, seconds, ms;
2460     DOUBLE y;
2461     int arg_no = arg_cnt(dp);
2462     HRESULT hres;
2463
2464     TRACE("\n");
2465
2466     if(arg_no>0) {
2467         hres = to_number(ctx, get_arg(dp, 0), ei, &year);
2468         if(FAILED(hres))
2469             return hres;
2470         y = num_val(&year);
2471         if(0<=y && y<=99)
2472             y += 1900;
2473     }
2474     else y = 1900;
2475
2476     if(arg_no>1) {
2477         hres = to_number(ctx, get_arg(dp, 1), ei, &month);
2478         if(FAILED(hres))
2479             return hres;
2480     }
2481     else {
2482         V_VT(&month) = VT_R8;
2483         V_R8(&month) = 0;
2484     }
2485
2486     if(arg_no>2) {
2487         hres = to_number(ctx, get_arg(dp, 2), ei, &vdate);
2488         if(FAILED(hres))
2489             return hres;
2490     }
2491     else {
2492         V_VT(&vdate) = VT_R8;
2493         V_R8(&vdate) = 1;
2494     }
2495
2496     if(arg_no>3) {
2497         hres = to_number(ctx, get_arg(dp, 3), ei, &hours);
2498         if(FAILED(hres))
2499             return hres;
2500     }
2501     else {
2502         V_VT(&hours) = VT_R8;
2503         V_R8(&hours) = 0;
2504     }
2505
2506     if(arg_no>4) {
2507         hres = to_number(ctx, get_arg(dp, 4), ei, &minutes);
2508         if(FAILED(hres))
2509             return hres;
2510     }
2511     else {
2512         V_VT(&minutes) = VT_R8;
2513         V_R8(&minutes) = 0;
2514     }
2515
2516     if(arg_no>5) {
2517         hres = to_number(ctx, get_arg(dp, 5), ei, &seconds);
2518         if(FAILED(hres))
2519             return hres;
2520     }
2521     else {
2522         V_VT(&seconds) = VT_R8;
2523         V_R8(&seconds) = 0;
2524     }
2525
2526     if(arg_no>6) {
2527         hres = to_number(ctx, get_arg(dp, 6), ei, &ms);
2528         if(FAILED(hres))
2529             return hres;
2530     }
2531     else {
2532         V_VT(&ms) = VT_R8;
2533         V_R8(&ms) = 0;
2534     }
2535
2536     if(retv) {
2537         V_VT(retv) = VT_R8;
2538         V_R8(retv) = time_clip(make_date(
2539                     make_day(y, num_val(&month), num_val(&vdate)),
2540                     make_time(num_val(&hours), num_val(&minutes),
2541                     num_val(&seconds), num_val(&ms))));
2542     }
2543
2544     return S_OK;
2545 }
2546
2547 static HRESULT DateConstr_UTC(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2548         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2549 {
2550     TRACE("\n");
2551
2552     return date_utc(ctx, dp, retv, ei);
2553 }
2554
2555 static HRESULT DateConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2556         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2557 {
2558     jsdisp_t *date;
2559     HRESULT hres;
2560
2561     TRACE("\n");
2562
2563     switch(flags) {
2564     case DISPATCH_CONSTRUCT:
2565         switch(arg_cnt(dp)) {
2566         /* ECMA-262 3rd Edition    15.9.3.3 */
2567         case 0: {
2568             FILETIME time;
2569             LONGLONG lltime;
2570
2571             GetSystemTimeAsFileTime(&time);
2572             lltime = ((LONGLONG)time.dwHighDateTime<<32)
2573                 + time.dwLowDateTime;
2574
2575             hres = create_date(ctx, NULL, lltime/10000-TIME_EPOCH, &date);
2576             if(FAILED(hres))
2577                 return hres;
2578             break;
2579         }
2580
2581         /* ECMA-262 3rd Edition    15.9.3.2 */
2582         case 1: {
2583             VARIANT prim, num;
2584
2585             hres = to_primitive(ctx, get_arg(dp,0), ei, &prim, NO_HINT);
2586             if(FAILED(hres))
2587                 return hres;
2588
2589             if(V_VT(&prim) == VT_BSTR)
2590                 hres = date_parse(V_BSTR(&prim), &num);
2591             else
2592                 hres = to_number(ctx, &prim, ei, &num);
2593
2594             VariantClear(&prim);
2595             if(FAILED(hres))
2596                 return hres;
2597
2598             hres = create_date(ctx, NULL, time_clip(num_val(&num)), &date);
2599             if(FAILED(hres))
2600                 return hres;
2601             break;
2602         }
2603
2604         /* ECMA-262 3rd Edition    15.9.3.1 */
2605         default: {
2606             VARIANT ret_date;
2607             DateInstance *di;
2608
2609             hres = date_utc(ctx, dp, &ret_date, ei);
2610             if(FAILED(hres))
2611                 return hres;
2612
2613             hres = create_date(ctx, NULL, num_val(&ret_date), &date);
2614             if(FAILED(hres))
2615                 return hres;
2616
2617             di = (DateInstance*)date;
2618             di->time = utc(di->time, di);
2619         }
2620         }
2621
2622         var_set_jsdisp(retv, date);
2623         return S_OK;
2624
2625     case INVOKE_FUNC: {
2626         FILETIME system_time, local_time;
2627         LONGLONG lltime;
2628
2629         GetSystemTimeAsFileTime(&system_time);
2630         FileTimeToLocalFileTime(&system_time, &local_time);
2631         lltime = ((LONGLONG)local_time.dwHighDateTime<<32)
2632             + local_time.dwLowDateTime;
2633
2634         return date_to_string(lltime/10000-TIME_EPOCH, FALSE, 0, retv);
2635     }
2636
2637     default:
2638         FIXME("unimplemented flags %x\n", flags);
2639         return E_NOTIMPL;
2640     }
2641
2642     return S_OK;
2643 }
2644
2645 static const builtin_prop_t DateConstr_props[] = {
2646     {UTCW,    DateConstr_UTC,    PROPF_METHOD},
2647     {parseW,  DateConstr_parse,  PROPF_METHOD}
2648 };
2649
2650 static const builtin_info_t DateConstr_info = {
2651     JSCLASS_FUNCTION,
2652     {NULL, Function_value, 0},
2653     sizeof(DateConstr_props)/sizeof(*DateConstr_props),
2654     DateConstr_props,
2655     NULL,
2656     NULL
2657 };
2658
2659 HRESULT create_date_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
2660 {
2661     jsdisp_t *date;
2662     HRESULT hres;
2663
2664     static const WCHAR DateW[] = {'D','a','t','e',0};
2665
2666     hres = create_date(ctx, object_prototype, 0.0, &date);
2667     if(FAILED(hres))
2668         return hres;
2669
2670     hres = create_builtin_function(ctx, DateConstr_value, DateW, &DateConstr_info,
2671             PROPF_CONSTR|7, date, ret);
2672
2673     jsdisp_release(date);
2674     return hres;
2675 }