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