?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push c89211be2889db25484c69db361f8abc539b86e2
[wine/hacks.git] / dlls / jscript / date.c
blob5085f212ebecb4f482e821f86a9848cd1554d8ef
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 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
595
596 date = (DateInstance*)dispex;
597 time = local_time(date->time, date);
598 offset = date->bias +
599 daylight_saving_ta(time, date);
600
601 return date_to_string(time, TRUE, offset, retv);
602 }
603
604 /* ECMA-262 3rd Edition 15.9.1.5 */
605 static HRESULT Date_toLocaleString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
606 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
607 {
608 static const WCHAR NaNW[] = { 'N','a','N',0 };
609 SYSTEMTIME st;
610 DateInstance *date;
611 BSTR date_str;
612 int date_len, time_len;
613
614 TRACE("\n");
615
616 if(!is_class(dispex, JSCLASS_DATE))
617 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
618
619 date = (DateInstance*)dispex;
620
621 if(isnan(date->time)) {
622 if(retv) {
623 V_VT(retv) = VT_BSTR;
624 V_BSTR(retv) = SysAllocString(NaNW);
625 if(!V_BSTR(retv))
626 return E_OUTOFMEMORY;
627 }
628 return S_OK;
629 }
630
631 st = create_systemtime(local_time(date->time, date));
632
633 if(st.wYear<1601 || st.wYear>9999)
634 return Date_toString(dispex, lcid, flags, dp, retv, ei, caller);
635
636 if(retv) {
637 date_len = GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
638 time_len = GetTimeFormatW(lcid, 0, &st, NULL, NULL, 0);
639 date_str = SysAllocStringLen(NULL, date_len+time_len-1);
640 if(!date_str)
641 return E_OUTOFMEMORY;
642 GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, date_str, date_len);
643 GetTimeFormatW(lcid, 0, &st, NULL, &date_str[date_len], time_len);
644 date_str[date_len-1] = ' ';
645
646 V_VT(retv) = VT_BSTR;
647 V_BSTR(retv) = date_str;
648 }
649 return S_OK;
650 }
651
652 static HRESULT Date_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
653 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
654 {
655 FIXME("\n");
656 return E_NOTIMPL;
657 }
658
659 static HRESULT Date_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
660 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
661 {
662 FIXME("\n");
663 return E_NOTIMPL;
664 }
665
666 static HRESULT Date_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
667 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
668 {
669 FIXME("\n");
670 return E_NOTIMPL;
671 }
672
673 static HRESULT Date_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
674 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
675 {
676 TRACE("\n");
677
678 if(!is_class(dispex, JSCLASS_DATE))
679 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
680
681 if(retv) {
682 DateInstance *date = (DateInstance*)dispex;
683 num_set_val(retv, date->time);
684 }
685 return S_OK;
686 }
687
688 /* ECMA-262 3rd Edition 15.9.5.42 */
689 static HRESULT Date_toUTCString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
690 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
691 {
692 static const WCHAR NaNW[] = { 'N','a','N',0 };
693 static const WCHAR formatADW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ',
694 '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
695 static const WCHAR formatBCW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ','B','.','C','.',' ',
696 '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
697
698 static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
699 LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
700 LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
701 static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
702 LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
703 LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
704 LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
705 LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
706 LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
707
708 BOOL formatAD = TRUE;
709 BSTR week, month;
710 DateInstance *date;
711 BSTR date_str;
712 int len, size, year, day;
713 DWORD lcid_en, week_id, month_id;
714
715 TRACE("\n");
716
717 if(!is_class(dispex, JSCLASS_DATE))
718 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
719
720 date = (DateInstance*)dispex;
721
722 if(isnan(date->time)) {
723 if(retv) {
724 V_VT(retv) = VT_BSTR;
725 V_BSTR(retv) = SysAllocString(NaNW);
726 if(!V_BSTR(retv))
727 return E_OUTOFMEMORY;
728 }
729 return S_OK;
730 }
731
732 if(retv) {
733 len = 17;
734
735 lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
736
737 week_id = week_ids[(int)week_day(date->time)];
738 size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
739 week = SysAllocStringLen(NULL, size);
740 if(!week)
741 return E_OUTOFMEMORY;
742 GetLocaleInfoW(lcid_en, week_id, week, size);
743 len += size-1;
744
745 month_id = month_ids[(int)month_from_time(date->time)];
746 size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
747 month = SysAllocStringLen(NULL, size);
748 if(!month) {
749 SysFreeString(week);
750 return E_OUTOFMEMORY;
751 }
752 GetLocaleInfoW(lcid_en, month_id, month, size);
753 len += size-1;
754
755 year = year_from_time(date->time);
756 if(year<0)
757 year = -year+1;
758 do {
759 year /= 10;
760 len++;
761 } while(year);
762
763 year = year_from_time(date->time);
764 if(year<0) {
765 formatAD = FALSE;
766 year = -year+1;
767 len += 5;
768 }
769
770 day = date_from_time(date->time);
771 do {
772 day /= 10;
773 len++;
774 } while(day);
775 day = date_from_time(date->time);
776
777 date_str = SysAllocStringLen(NULL, len);
778 if(!date_str) {
779 SysFreeString(week);
780 SysFreeString(month);
781 return E_OUTOFMEMORY;
782 }
783 sprintfW(date_str, formatAD?formatADW:formatBCW, week, day, month, year,
784 (int)hour_from_time(date->time), (int)min_from_time(date->time),
785 (int)sec_from_time(date->time));
786
787 SysFreeString(week);
788 SysFreeString(month);
789
790 V_VT(retv) = VT_BSTR;
791 V_BSTR(retv) = date_str;
792 }
793 return S_OK;
794 }
795
796 /* ECMA-262 3rd Edition 15.9.5.3 */
797 static HRESULT Date_toDateString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
798 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
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 DateInstance *date;
817 BSTR date_str;
818 DOUBLE time;
819 int len, size, year, day;
820 DWORD lcid_en, week_id, month_id;
821
822 TRACE("\n");
823
824 if(!is_class(dispex, JSCLASS_DATE))
825 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
826
827 date = (DateInstance*)dispex;
828
829 if(isnan(date->time)) {
830 if(retv) {
831 V_VT(retv) = VT_BSTR;
832 V_BSTR(retv) = SysAllocString(NaNW);
833 if(!V_BSTR(retv))
834 return E_OUTOFMEMORY;
835 }
836 return S_OK;
837 }
838
839 time = local_time(date->time, date);
840
841 if(retv) {
842 len = 5;
843
844 lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
845
846 week_id = week_ids[(int)week_day(time)];
847 size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
848 week = SysAllocStringLen(NULL, size);
849 if(!week)
850 return E_OUTOFMEMORY;
851 GetLocaleInfoW(lcid_en, week_id, week, size);
852 len += size-1;
853
854 month_id = month_ids[(int)month_from_time(time)];
855 size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
856 month = SysAllocStringLen(NULL, size);
857 if(!month) {
858 SysFreeString(week);
859 return E_OUTOFMEMORY;
860 }
861 GetLocaleInfoW(lcid_en, month_id, month, size);
862 len += size-1;
863
864 year = year_from_time(time);
865 if(year<0)
866 year = -year+1;
867 do {
868 year /= 10;
869 len++;
870 } while(year);
871
872 year = year_from_time(time);
873 if(year<0) {
874 formatAD = FALSE;
875 year = -year+1;
876 len += 5;
877 }
878
879 day = date_from_time(time);
880 do {
881 day /= 10;
882 len++;
883 } while(day);
884 day = date_from_time(time);
885
886 date_str = SysAllocStringLen(NULL, len);
887 if(!date_str) {
888 SysFreeString(week);
889 SysFreeString(month);
890 return E_OUTOFMEMORY;
891 }
892 sprintfW(date_str, formatAD?formatADW:formatBCW, week, month, day, year);
893
894 SysFreeString(week);
895 SysFreeString(month);
896
897 V_VT(retv) = VT_BSTR;
898 V_BSTR(retv) = date_str;
899 }
900 return S_OK;
901 }
902
903 /* ECMA-262 3rd Edition 15.9.5.4 */
904 static HRESULT Date_toTimeString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
905 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
906 {
907 static const WCHAR NaNW[] = { 'N','a','N',0 };
908 static const WCHAR formatW[] = { '%','0','2','d',':','%','0','2','d',':','%','0','2','d',
909 ' ','U','T','C','%','c','%','0','2','d','%','0','2','d',0 };
910 static const WCHAR formatUTCW[] = { '%','0','2','d',':','%','0','2','d',
911 ':','%','0','2','d',' ','U','T','C',0 };
912 DateInstance *date;
913 BSTR date_str;
914 DOUBLE time;
915 WCHAR sign;
916 int offset;
917
918 TRACE("\n");
919
920 if(!is_class(dispex, JSCLASS_DATE))
921 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
922
923 date = (DateInstance*)dispex;
924
925 if(isnan(date->time)) {
926 if(retv) {
927 V_VT(retv) = VT_BSTR;
928 V_BSTR(retv) = SysAllocString(NaNW);
929 if(!V_BSTR(retv))
930 return E_OUTOFMEMORY;
931 }
932 return S_OK;
933 }
934
935 time = local_time(date->time, date);
936
937 if(retv) {
938 date_str = SysAllocStringLen(NULL, 17);
939 if(!date_str)
940 return E_OUTOFMEMORY;
941
942 offset = date->bias +
943 daylight_saving_ta(time, date);
944
945 if(offset < 0) {
946 sign = '+';
947 offset = -offset;
948 }
949 else sign = '-';
950
951 if(offset)
952 sprintfW(date_str, formatW, (int)hour_from_time(time),
953 (int)min_from_time(time), (int)sec_from_time(time),
954 sign, offset/60, offset%60);
955 else
956 sprintfW(date_str, formatUTCW, (int)hour_from_time(time),
957 (int)min_from_time(time), (int)sec_from_time(time));
958
959 V_VT(retv) = VT_BSTR;
960 V_BSTR(retv) = date_str;
961 }
962 return S_OK;
963 }
964
965 /* ECMA-262 3rd Edition 15.9.5.6 */
966 static HRESULT Date_toLocaleDateString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
967 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
968 {
969 static const WCHAR NaNW[] = { 'N','a','N',0 };
970 SYSTEMTIME st;
971 DateInstance *date;
972 BSTR date_str;
973 int len;
974
975 TRACE("\n");
976
977 if(!is_class(dispex, JSCLASS_DATE))
978 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
979
980 date = (DateInstance*)dispex;
981
982 if(isnan(date->time)) {
983 if(retv) {
984 V_VT(retv) = VT_BSTR;
985 V_BSTR(retv) = SysAllocString(NaNW);
986 if(!V_BSTR(retv))
987 return E_OUTOFMEMORY;
988 }
989 return S_OK;
990 }
991
992 st = create_systemtime(local_time(date->time, date));
993
994 if(st.wYear<1601 || st.wYear>9999)
995 return Date_toDateString(dispex, lcid, flags, dp, retv, ei, caller);
996
997 if(retv) {
998 len = GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
999 date_str = SysAllocStringLen(NULL, len);
1000 if(!date_str)
1001 return E_OUTOFMEMORY;
1002 GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, date_str, len);
1003
1004 V_VT(retv) = VT_BSTR;
1005 V_BSTR(retv) = date_str;
1006 }
1007 return S_OK;
1008 }
1009
1010 /* ECMA-262 3rd Edition 15.9.5.7 */
1011 static HRESULT Date_toLocaleTimeString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1012 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1013 {
1014 static const WCHAR NaNW[] = { 'N','a','N',0 };
1015 SYSTEMTIME st;
1016 DateInstance *date;
1017 BSTR date_str;
1018 int len;
1019
1020 TRACE("\n");
1021
1022 if(!is_class(dispex, JSCLASS_DATE))
1023 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1024
1025 date = (DateInstance*)dispex;
1026
1027 if(isnan(date->time)) {
1028 if(retv) {
1029 V_VT(retv) = VT_BSTR;
1030 V_BSTR(retv) = SysAllocString(NaNW);
1031 if(!V_BSTR(retv))
1032 return E_OUTOFMEMORY;
1033 }
1034 return S_OK;
1035 }
1036
1037 st = create_systemtime(local_time(date->time, date));
1038
1039 if(st.wYear<1601 || st.wYear>9999)
1040 return Date_toTimeString(dispex, lcid, flags, dp, retv, ei, caller);
1041
1042 if(retv) {
1043 len = GetTimeFormatW(lcid, 0, &st, NULL, NULL, 0);
1044 date_str = SysAllocStringLen(NULL, len);
1045 if(!date_str)
1046 return E_OUTOFMEMORY;
1047 GetTimeFormatW(lcid, 0, &st, NULL, date_str, len);
1048
1049 V_VT(retv) = VT_BSTR;
1050 V_BSTR(retv) = date_str;
1051 }
1052 return S_OK;
1053 }
1054
1055 /* ECMA-262 3rd Edition 15.9.5.9 */
1056 static HRESULT Date_getTime(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1057 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1058 {
1059 TRACE("\n");
1060
1061 if(!is_class(dispex, JSCLASS_DATE))
1062 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1063
1064 if(retv) {
1065 DateInstance *date = (DateInstance*)dispex;
1066 num_set_val(retv, date->time);
1067 }
1068 return S_OK;
1069 }
1070
1071 /* ECMA-262 3rd Edition 15.9.5.10 */
1072 static HRESULT Date_getFullYear(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 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1079
1080 if(retv) {
1081 DateInstance *date = (DateInstance*)dispex;
1082 DOUBLE time = local_time(date->time, date);
1083
1084 num_set_val(retv, year_from_time(time));
1085 }
1086 return S_OK;
1087 }
1088
1089 /* ECMA-262 3rd Edition 15.9.5.11 */
1090 static HRESULT Date_getUTCFullYear(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 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1097
1098 if(retv) {
1099 DateInstance *date = (DateInstance*)dispex;
1100 num_set_val(retv, year_from_time(date->time));
1101 }
1102 return S_OK;
1103 }
1104
1105 /* ECMA-262 3rd Edition 15.9.5.12 */
1106 static HRESULT Date_getMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1107 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1108 {
1109 TRACE("\n");
1110
1111 if(!is_class(dispex, JSCLASS_DATE))
1112 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1113
1114 if(retv) {
1115 DateInstance *date = (DateInstance*)dispex;
1116 DOUBLE time = local_time(date->time, date);
1117
1118 num_set_val(retv, month_from_time(time));
1119 }
1120 return S_OK;
1121 }
1122
1123 /* ECMA-262 3rd Edition 15.9.5.13 */
1124 static HRESULT Date_getUTCMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1125 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1126 {
1127 TRACE("\n");
1128
1129 if(!is_class(dispex, JSCLASS_DATE))
1130 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1131
1132 if(retv) {
1133 DateInstance *date = (DateInstance*)dispex;
1134 num_set_val(retv, month_from_time(date->time));
1135 }
1136 return S_OK;
1137 }
1138
1139 /* ECMA-262 3rd Edition 15.9.5.14 */
1140 static HRESULT Date_getDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1141 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1142 {
1143 TRACE("\n");
1144
1145 if(!is_class(dispex, JSCLASS_DATE))
1146 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1147
1148 if(retv) {
1149 DateInstance *date = (DateInstance*)dispex;
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(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1159 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1160 {
1161 TRACE("\n");
1162
1163 if(!is_class(dispex, JSCLASS_DATE))
1164 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1165
1166 if(retv) {
1167 DateInstance *date = (DateInstance*)dispex;
1168 num_set_val(retv, date_from_time(date->time));
1169 }
1170 return S_OK;
1171 }
1172
1173 /* ECMA-262 3rd Edition 15.9.5.16 */
1174 static HRESULT Date_getDay(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1175 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1176 {
1177 TRACE("\n");
1178
1179 if(!is_class(dispex, JSCLASS_DATE))
1180 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1181
1182 if(retv) {
1183 DateInstance *date = (DateInstance*)dispex;
1184 DOUBLE time = local_time(date->time, date);
1185
1186 num_set_val(retv, week_day(time));
1187 }
1188 return S_OK;
1189 }
1190
1191 /* ECMA-262 3rd Edition 15.9.5.17 */
1192 static HRESULT Date_getUTCDay(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1193 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1194 {
1195 TRACE("\n");
1196
1197 if(!is_class(dispex, JSCLASS_DATE))
1198 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1199
1200 if(retv) {
1201 DateInstance *date = (DateInstance*)dispex;
1202 num_set_val(retv, week_day(date->time));
1203 }
1204 return S_OK;
1205 }
1206
1207 /* ECMA-262 3rd Edition 15.9.5.18 */
1208 static HRESULT Date_getHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1209 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1210 {
1211 TRACE("\n");
1212
1213 if(!is_class(dispex, JSCLASS_DATE))
1214 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1215
1216 if(retv) {
1217 DateInstance *date = (DateInstance*)dispex;
1218 DOUBLE time = local_time(date->time, date);
1219
1220 num_set_val(retv, hour_from_time(time));
1221 }
1222 return S_OK;
1223 }
1224
1225 /* ECMA-262 3rd Edition 15.9.5.19 */
1226 static HRESULT Date_getUTCHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1227 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1228 {
1229 TRACE("\n");
1230
1231 if(!is_class(dispex, JSCLASS_DATE))
1232 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1233
1234 if(retv) {
1235 DateInstance *date = (DateInstance*)dispex;
1236 num_set_val(retv, hour_from_time(date->time));
1237 }
1238 return S_OK;
1239 }
1240
1241 /* ECMA-262 3rd Edition 15.9.5.20 */
1242 static HRESULT Date_getMinutes(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 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1249
1250 if(retv) {
1251 DateInstance *date = (DateInstance*)dispex;
1252 DOUBLE time = local_time(date->time, date);
1253
1254 num_set_val(retv, min_from_time(time));
1255 }
1256 return S_OK;
1257 }
1258
1259 /* ECMA-262 3rd Edition 15.9.5.21 */
1260 static HRESULT Date_getUTCMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1261 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1262 {
1263 TRACE("\n");
1264
1265 if(!is_class(dispex, JSCLASS_DATE))
1266 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1267
1268 if(retv) {
1269 DateInstance *date = (DateInstance*)dispex;
1270 num_set_val(retv, min_from_time(date->time));
1271 }
1272 return S_OK;
1273 }
1274
1275 /* ECMA-262 3rd Edition 15.9.5.22 */
1276 static HRESULT Date_getSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1277 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1278 {
1279 TRACE("\n");
1280
1281 if(!is_class(dispex, JSCLASS_DATE))
1282 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1283
1284 if(retv) {
1285 DateInstance *date = (DateInstance*)dispex;
1286 DOUBLE time = local_time(date->time, date);
1287
1288 num_set_val(retv, sec_from_time(time));
1289 }
1290 return S_OK;
1291 }
1292
1293 /* ECMA-262 3rd Edition 15.9.5.23 */
1294 static HRESULT Date_getUTCSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1295 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1296 {
1297 TRACE("\n");
1298
1299 if(!is_class(dispex, JSCLASS_DATE))
1300 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1301
1302 if(retv) {
1303 DateInstance *date = (DateInstance*)dispex;
1304 num_set_val(retv, sec_from_time(date->time));
1305 }
1306 return S_OK;
1307 }
1308
1309 /* ECMA-262 3rd Edition 15.9.5.24 */
1310 static HRESULT Date_getMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1311 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1312 {
1313 TRACE("\n");
1314
1315 if(!is_class(dispex, JSCLASS_DATE))
1316 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1317
1318 if(retv) {
1319 DateInstance *date = (DateInstance*)dispex;
1320 DOUBLE time = local_time(date->time, date);
1321
1322 num_set_val(retv, ms_from_time(time));
1323 }
1324 return S_OK;
1325 }
1326
1327 /* ECMA-262 3rd Edition 15.9.5.25 */
1328 static HRESULT Date_getUTCMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1329 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1330 {
1331 TRACE("\n");
1332
1333 if(!is_class(dispex, JSCLASS_DATE))
1334 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1335
1336 if(retv) {
1337 DateInstance *date = (DateInstance*)dispex;
1338 num_set_val(retv, ms_from_time(date->time));
1339 }
1340 return S_OK;
1341 }
1342
1343 /* ECMA-262 3rd Edition 15.9.5.26 */
1344 static HRESULT Date_getTimezoneOffset(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1345 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1346 {
1347 TRACE("\n");
1348
1349 if(!is_class(dispex, JSCLASS_DATE))
1350 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1351
1352 if(retv) {
1353 DateInstance *date = (DateInstance*)dispex;
1354 num_set_val(retv, floor(
1355 (date->time-local_time(date->time, date))/MS_PER_MINUTE));
1356 }
1357 return S_OK;
1358 }
1359
1360 /* ECMA-262 3rd Edition 15.9.5.27 */
1361 static HRESULT Date_setTime(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1362 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1363 {
1364 VARIANT v;
1365 HRESULT hres;
1366 DateInstance *date;
1367
1368 TRACE("\n");
1369
1370 if(!is_class(dispex, JSCLASS_DATE))
1371 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1372
1373 if(!arg_cnt(dp))
1374 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1375
1376 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1377 if(FAILED(hres))
1378 return hres;
1379
1380 date = (DateInstance*)dispex;
1381 date->time = time_clip(num_val(&v));
1382
1383 if(retv)
1384 num_set_val(retv, date->time);
1385
1386 return S_OK;
1387 }
1388
1389 /* ECMA-262 3rd Edition 15.9.5.28 */
1390 static HRESULT Date_setMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1391 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1392 {
1393 VARIANT v;
1394 HRESULT hres;
1395 DateInstance *date;
1396 DOUBLE t;
1397
1398 TRACE("\n");
1399
1400 if(!is_class(dispex, JSCLASS_DATE))
1401 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1402
1403 if(!arg_cnt(dp))
1404 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1405
1406 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1407 if(FAILED(hres))
1408 return hres;
1409
1410 date = (DateInstance*)dispex;
1411 t = local_time(date->time, date);
1412 t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1413 sec_from_time(t), num_val(&v)));
1414 date->time = time_clip(utc(t, date));
1415
1416 if(retv)
1417 num_set_val(retv, date->time);
1418
1419 return S_OK;
1420 }
1421
1422 /* ECMA-262 3rd Edition 15.9.5.29 */
1423 static HRESULT Date_setUTCMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1424 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1425 {
1426 VARIANT v;
1427 HRESULT hres;
1428 DateInstance *date;
1429 DOUBLE t;
1430
1431 TRACE("\n");
1432
1433 if(!is_class(dispex, JSCLASS_DATE))
1434 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1435
1436 if(!arg_cnt(dp))
1437 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1438
1439 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1440 if(FAILED(hres))
1441 return hres;
1442
1443 date = (DateInstance*)dispex;
1444 t = date->time;
1445 t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1446 sec_from_time(t), num_val(&v)));
1447 date->time = time_clip(t);
1448
1449 if(retv)
1450 num_set_val(retv, date->time);
1451
1452 return S_OK;
1453 }
1454
1455 /* ECMA-262 3rd Edition 15.9.5.30 */
1456 static HRESULT Date_setSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1457 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1458 {
1459 VARIANT v;
1460 HRESULT hres;
1461 DateInstance *date;
1462 DOUBLE t, sec, ms;
1463
1464 TRACE("\n");
1465
1466 if(!is_class(dispex, JSCLASS_DATE))
1467 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1468
1469 if(!arg_cnt(dp))
1470 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1471
1472 date = (DateInstance*)dispex;
1473 t = local_time(date->time, date);
1474
1475 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1476 if(FAILED(hres))
1477 return hres;
1478 sec = num_val(&v);
1479
1480 if(arg_cnt(dp) > 1) {
1481 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1482 if(FAILED(hres))
1483 return hres;
1484 ms = num_val(&v);
1485 }
1486 else ms = ms_from_time(t);
1487
1488 t = make_date(day(t), make_time(hour_from_time(t),
1489 min_from_time(t), sec, ms));
1490 date->time = time_clip(utc(t, date));
1491
1492 if(retv)
1493 num_set_val(retv, date->time);
1494
1495 return S_OK;
1496 }
1497
1498 /* ECMA-262 3rd Edition 15.9.5.31 */
1499 static HRESULT Date_setUTCSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1500 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1501 {
1502 VARIANT v;
1503 HRESULT hres;
1504 DateInstance *date;
1505 DOUBLE t, sec, ms;
1506
1507 TRACE("\n");
1508
1509 if(!is_class(dispex, JSCLASS_DATE))
1510 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1511
1512 if(!arg_cnt(dp))
1513 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1514
1515 date = (DateInstance*)dispex;
1516 t = date->time;
1517
1518 hres = to_number(dispex->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(dispex->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(DispatchEx *dispex, LCID lcid, 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(!is_class(dispex, JSCLASS_DATE))
1553 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1554
1555 if(!arg_cnt(dp))
1556 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1557
1558 date = (DateInstance*)dispex;
1559 t = local_time(date->time, date);
1560
1561 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1562 if(FAILED(hres))
1563 return hres;
1564 min = num_val(&v);
1565
1566 if(arg_cnt(dp) > 1) {
1567 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1568 if(FAILED(hres))
1569 return hres;
1570 sec = num_val(&v);
1571 }
1572 else sec = sec_from_time(t);
1573
1574 if(arg_cnt(dp) > 2) {
1575 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1576 if(FAILED(hres))
1577 return hres;
1578 ms = num_val(&v);
1579 }
1580 else ms = ms_from_time(t);
1581
1582 t = make_date(day(t), make_time(hour_from_time(t),
1583 min, sec, ms));
1584 date->time = time_clip(utc(t, date));
1585
1586 if(retv)
1587 num_set_val(retv, date->time);
1588
1589 return S_OK;
1590 }
1591
1592 /* ECMA-262 3rd Edition 15.9.5.34 */
1593 static HRESULT Date_setUTCMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1594 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1595 {
1596 VARIANT v;
1597 HRESULT hres;
1598 DateInstance *date;
1599 DOUBLE t, min, sec, ms;
1600
1601 TRACE("\n");
1602
1603 if(!is_class(dispex, JSCLASS_DATE))
1604 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1605
1606 if(!arg_cnt(dp))
1607 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1608
1609 date = (DateInstance*)dispex;
1610 t = date->time;
1611
1612 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1613 if(FAILED(hres))
1614 return hres;
1615 min = num_val(&v);
1616
1617 if(arg_cnt(dp) > 1) {
1618 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1619 if(FAILED(hres))
1620 return hres;
1621 sec = num_val(&v);
1622 }
1623 else sec = sec_from_time(t);
1624
1625 if(arg_cnt(dp) > 2) {
1626 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1627 if(FAILED(hres))
1628 return hres;
1629 ms = num_val(&v);
1630 }
1631 else ms = ms_from_time(t);
1632
1633 t = make_date(day(t), make_time(hour_from_time(t),
1634 min, sec, ms));
1635 date->time = time_clip(t);
1636
1637 if(retv)
1638 num_set_val(retv, date->time);
1639
1640 return S_OK;
1641 }
1642
1643 /* ECMA-262 3rd Edition 15.9.5.35 */
1644 static HRESULT Date_setHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1645 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1646 {
1647 VARIANT v;
1648 HRESULT hres;
1649 DateInstance *date;
1650 DOUBLE t, hour, min, sec, ms;
1651
1652 TRACE("\n");
1653
1654 if(!is_class(dispex, JSCLASS_DATE))
1655 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1656
1657 if(!arg_cnt(dp))
1658 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1659
1660 date = (DateInstance*)dispex;
1661 t = local_time(date->time, date);
1662
1663 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1664 if(FAILED(hres))
1665 return hres;
1666 hour = num_val(&v);
1667
1668 if(arg_cnt(dp) > 1) {
1669 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1670 if(FAILED(hres))
1671 return hres;
1672 min = num_val(&v);
1673 }
1674 else min = min_from_time(t);
1675
1676 if(arg_cnt(dp) > 2) {
1677 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1678 if(FAILED(hres))
1679 return hres;
1680 sec = num_val(&v);
1681 }
1682 else sec = sec_from_time(t);
1683
1684 if(arg_cnt(dp) > 3) {
1685 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &v);
1686 if(FAILED(hres))
1687 return hres;
1688 ms = num_val(&v);
1689 }
1690 else ms = ms_from_time(t);
1691
1692 t = make_date(day(t), make_time(hour, min, sec, ms));
1693 date->time = time_clip(utc(t, date));
1694
1695 if(retv)
1696 num_set_val(retv, date->time);
1697
1698 return S_OK;
1699 }
1700
1701 /* ECMA-262 3rd Edition 15.9.5.36 */
1702 static HRESULT Date_setUTCHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1703 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1704 {
1705 VARIANT v;
1706 HRESULT hres;
1707 DateInstance *date;
1708 DOUBLE t, hour, min, sec, ms;
1709
1710 TRACE("\n");
1711
1712 if(!is_class(dispex, JSCLASS_DATE))
1713 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1714
1715 if(!arg_cnt(dp))
1716 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1717
1718 date = (DateInstance*)dispex;
1719 t = date->time;
1720
1721 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1722 if(FAILED(hres))
1723 return hres;
1724 hour = num_val(&v);
1725
1726 if(arg_cnt(dp) > 1) {
1727 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1728 if(FAILED(hres))
1729 return hres;
1730 min = num_val(&v);
1731 }
1732 else min = min_from_time(t);
1733
1734 if(arg_cnt(dp) > 2) {
1735 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1736 if(FAILED(hres))
1737 return hres;
1738 sec = num_val(&v);
1739 }
1740 else sec = sec_from_time(t);
1741
1742 if(arg_cnt(dp) > 3) {
1743 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &v);
1744 if(FAILED(hres))
1745 return hres;
1746 ms = num_val(&v);
1747 }
1748 else ms = ms_from_time(t);
1749
1750 t = make_date(day(t), make_time(hour, min, sec, ms));
1751 date->time = time_clip(t);
1752
1753 if(retv)
1754 num_set_val(retv, date->time);
1755
1756 return S_OK;
1757 }
1758
1759 /* ECMA-262 3rd Edition 15.9.5.36 */
1760 static HRESULT Date_setDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1761 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1762 {
1763 VARIANT v;
1764 HRESULT hres;
1765 DateInstance *date;
1766 DOUBLE t;
1767
1768 TRACE("\n");
1769
1770 if(!is_class(dispex, JSCLASS_DATE))
1771 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1772
1773 if(!arg_cnt(dp))
1774 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1775
1776 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1777 if(FAILED(hres))
1778 return hres;
1779
1780 date = (DateInstance*)dispex;
1781 t = local_time(date->time, date);
1782 t = make_date(make_day(year_from_time(t), month_from_time(t),
1783 num_val(&v)), time_within_day(t));
1784 date->time = time_clip(utc(t, date));
1785
1786 if(retv)
1787 num_set_val(retv, date->time);
1788
1789 return S_OK;
1790 }
1791
1792 /* ECMA-262 3rd Edition 15.9.5.37 */
1793 static HRESULT Date_setUTCDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1794 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1795 {
1796 VARIANT v;
1797 HRESULT hres;
1798 DateInstance *date;
1799 DOUBLE t;
1800
1801 TRACE("\n");
1802
1803 if(!is_class(dispex, JSCLASS_DATE))
1804 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1805
1806 if(!arg_cnt(dp))
1807 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1808
1809 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1810 if(FAILED(hres))
1811 return hres;
1812
1813 date = (DateInstance*)dispex;
1814 t = date->time;
1815 t = make_date(make_day(year_from_time(t), month_from_time(t),
1816 num_val(&v)), time_within_day(t));
1817 date->time = time_clip(t);
1818
1819 if(retv)
1820 num_set_val(retv, date->time);
1821
1822 return S_OK;
1823 }
1824
1825 /* ECMA-262 3rd Edition 15.9.5.38 */
1826 static HRESULT Date_setMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1827 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1828 {
1829 VARIANT v;
1830 HRESULT hres;
1831 DateInstance *date;
1832 DOUBLE t, month, ddate;
1833
1834 TRACE("\n");
1835
1836 if(!is_class(dispex, JSCLASS_DATE))
1837 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1838
1839 if(!arg_cnt(dp))
1840 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1841
1842 date = (DateInstance*)dispex;
1843 t = local_time(date->time, date);
1844
1845 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1846 if(FAILED(hres))
1847 return hres;
1848 month = num_val(&v);
1849
1850 if(arg_cnt(dp) > 1) {
1851 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1852 if(FAILED(hres))
1853 return hres;
1854 ddate = num_val(&v);
1855 }
1856 else ddate = date_from_time(t);
1857
1858 t = make_date(make_day(year_from_time(t), month, ddate),
1859 time_within_day(t));
1860 date->time = time_clip(utc(t, date));
1861
1862 if(retv)
1863 num_set_val(retv, date->time);
1864
1865 return S_OK;
1866 }
1867
1868 /* ECMA-262 3rd Edition 15.9.5.39 */
1869 static HRESULT Date_setUTCMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1870 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1871 {
1872 VARIANT v;
1873 HRESULT hres;
1874 DateInstance *date;
1875 DOUBLE t, month, ddate;
1876
1877 TRACE("\n");
1878
1879 if(!is_class(dispex, JSCLASS_DATE))
1880 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1881
1882 if(!arg_cnt(dp))
1883 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1884
1885 date = (DateInstance*)dispex;
1886 t = date->time;
1887
1888 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1889 if(FAILED(hres))
1890 return hres;
1891 month = num_val(&v);
1892
1893 if(arg_cnt(dp) > 1) {
1894 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1895 if(FAILED(hres))
1896 return hres;
1897 ddate = num_val(&v);
1898 }
1899 else ddate = date_from_time(t);
1900
1901 t = make_date(make_day(year_from_time(t), month, ddate),
1902 time_within_day(t));
1903 date->time = time_clip(t);
1904
1905 if(retv)
1906 num_set_val(retv, date->time);
1907
1908 return S_OK;
1909 }
1910
1911 /* ECMA-262 3rd Edition 15.9.5.40 */
1912 static HRESULT Date_setFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1913 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1914 {
1915 VARIANT v;
1916 HRESULT hres;
1917 DateInstance *date;
1918 DOUBLE t, year, month, ddate;
1919
1920 TRACE("\n");
1921
1922 if(!is_class(dispex, JSCLASS_DATE))
1923 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1924
1925 if(!arg_cnt(dp))
1926 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1927
1928 date = (DateInstance*)dispex;
1929 t = local_time(date->time, date);
1930
1931 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1932 if(FAILED(hres))
1933 return hres;
1934 year = num_val(&v);
1935
1936 if(arg_cnt(dp) > 1) {
1937 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1938 if(FAILED(hres))
1939 return hres;
1940 month = num_val(&v);
1941 }
1942 else month = month_from_time(t);
1943
1944 if(arg_cnt(dp) > 2) {
1945 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1946 if(FAILED(hres))
1947 return hres;
1948 ddate = num_val(&v);
1949 }
1950 else ddate = date_from_time(t);
1951
1952 t = make_date(make_day(year, month, ddate), time_within_day(t));
1953 date->time = time_clip(utc(t, date));
1954
1955 if(retv)
1956 num_set_val(retv, date->time);
1957
1958 return S_OK;
1959 }
1960
1961 /* ECMA-262 3rd Edition 15.9.5.41 */
1962 static HRESULT Date_setUTCFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1963 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1964 {
1965 VARIANT v;
1966 HRESULT hres;
1967 DateInstance *date;
1968 DOUBLE t, year, month, ddate;
1969
1970 TRACE("\n");
1971
1972 if(!is_class(dispex, JSCLASS_DATE))
1973 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
1974
1975 if(!arg_cnt(dp))
1976 return throw_type_error(dispex->ctx, ei, IDS_ARG_NOT_OPT, NULL);
1977
1978 date = (DateInstance*)dispex;
1979 t = date->time;
1980
1981 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1982 if(FAILED(hres))
1983 return hres;
1984 year = num_val(&v);
1985
1986 if(arg_cnt(dp) > 1) {
1987 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1988 if(FAILED(hres))
1989 return hres;
1990 month = num_val(&v);
1991 }
1992 else month = month_from_time(t);
1993
1994 if(arg_cnt(dp) > 2) {
1995 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1996 if(FAILED(hres))
1997 return hres;
1998 ddate = num_val(&v);
1999 }
2000 else ddate = date_from_time(t);
2001
2002 t = make_date(make_day(year, month, ddate), time_within_day(t));
2003 date->time = time_clip(t);
2004
2005 if(retv)
2006 num_set_val(retv, date->time);
2007
2008 return S_OK;
2009 }
2010
2011 /* ECMA-262 3rd Edition B2.4 */
2012 static HRESULT Date_getYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
2013 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
2014 {
2015 DateInstance *date;
2016 DOUBLE t, year;
2017
2018 TRACE("\n");
2019
2020 if(!is_class(dispex, JSCLASS_DATE))
2021 return throw_type_error(dispex->ctx, ei, IDS_NOT_DATE, NULL);
2022
2023 date = (DateInstance*)dispex;
2024 t = local_time(date->time, date);
2025
2026
2027 if(isnan(t)) {
2028 if(retv)
2029 num_set_nan(retv);
2030 return S_OK;
2031 }
2032
2033 year = year_from_time(t);
2034 if(retv)
2035 num_set_val(retv, (1900<=year && year<2000)?year-1900:year);
2036
2037 return S_OK;
2038 }
2039
2040 static HRESULT Date_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
2041 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
2042 {
2043 TRACE("\n");
2044
2045 switch(flags) {
2046 case INVOKE_FUNC:
2047 return throw_type_error(dispex->ctx, ei, IDS_NOT_FUNC, NULL);
2048 default:
2049 FIXME("unimplemented flags %x\n", flags);
2050 return E_NOTIMPL;
2051 }
2052
2053 return S_OK;
2054 }
2055
2056 static const builtin_prop_t Date_props[] = {
2057 {getDateW, Date_getDate, PROPF_METHOD},
2058 {getDayW, Date_getDay, PROPF_METHOD},
2059 {getFullYearW, Date_getFullYear, PROPF_METHOD},
2060 {getHoursW, Date_getHours, PROPF_METHOD},
2061 {getMillisecondsW, Date_getMilliseconds, PROPF_METHOD},
2062 {getMinutesW, Date_getMinutes, PROPF_METHOD},
2063 {getMonthW, Date_getMonth, PROPF_METHOD},
2064 {getSecondsW, Date_getSeconds, PROPF_METHOD},
2065 {getTimeW, Date_getTime, PROPF_METHOD},
2066 {getTimezoneOffsetW, Date_getTimezoneOffset, PROPF_METHOD},
2067 {getUTCDateW, Date_getUTCDate, PROPF_METHOD},
2068 {getUTCDayW, Date_getUTCDay, PROPF_METHOD},
2069 {getUTCFullYearW, Date_getUTCFullYear, PROPF_METHOD},
2070 {getUTCHoursW, Date_getUTCHours, PROPF_METHOD},
2071 {getUTCMillisecondsW, Date_getUTCMilliseconds, PROPF_METHOD},
2072 {getUTCMinutesW, Date_getUTCMinutes, PROPF_METHOD},
2073 {getUTCMonthW, Date_getUTCMonth, PROPF_METHOD},
2074 {getUTCSecondsW, Date_getUTCSeconds, PROPF_METHOD},
2075 {getYearW, Date_getYear, PROPF_METHOD},
2076 {hasOwnPropertyW, Date_hasOwnProperty, PROPF_METHOD},
2077 {isPrototypeOfW, Date_isPrototypeOf, PROPF_METHOD},
2078 {propertyIsEnumerableW, Date_propertyIsEnumerable, PROPF_METHOD},
2079 {setDateW, Date_setDate, PROPF_METHOD},
2080 {setFullYearW, Date_setFullYear, PROPF_METHOD},
2081 {setHoursW, Date_setHours, PROPF_METHOD},
2082 {setMillisecondsW, Date_setMilliseconds, PROPF_METHOD},
2083 {setMinutesW, Date_setMinutes, PROPF_METHOD},
2084 {setMonthW, Date_setMonth, PROPF_METHOD},
2085 {setSecondsW, Date_setSeconds, PROPF_METHOD},
2086 {setTimeW, Date_setTime, PROPF_METHOD},
2087 {setUTCDateW, Date_setUTCDate, PROPF_METHOD},
2088 {setUTCFullYearW, Date_setUTCFullYear, PROPF_METHOD},
2089 {setUTCHoursW, Date_setUTCHours, PROPF_METHOD},
2090 {setUTCMillisecondsW, Date_setUTCMilliseconds, PROPF_METHOD},
2091 {setUTCMinutesW, Date_setUTCMinutes, PROPF_METHOD},
2092 {setUTCMonthW, Date_setUTCMonth, PROPF_METHOD},
2093 {setUTCSecondsW, Date_setUTCSeconds, PROPF_METHOD},
2094 {toDateStringW, Date_toDateString, PROPF_METHOD},
2095 {toLocaleDateStringW, Date_toLocaleDateString, PROPF_METHOD},
2096 {toLocaleStringW, Date_toLocaleString, PROPF_METHOD},
2097 {toLocaleTimeStringW, Date_toLocaleTimeString, PROPF_METHOD},
2098 {toStringW, Date_toString, PROPF_METHOD},
2099 {toTimeStringW, Date_toTimeString, PROPF_METHOD},
2100 {toUTCStringW, Date_toUTCString, PROPF_METHOD},
2101 {valueOfW, Date_valueOf, PROPF_METHOD},
2102 };
2103
2104 static const builtin_info_t Date_info = {
2105 JSCLASS_DATE,
2106 {NULL, Date_value, 0},
2107 sizeof(Date_props)/sizeof(*Date_props),
2108 Date_props,
2109 NULL,
2110 NULL
2111 };
2112
2113 static HRESULT create_date(script_ctx_t *ctx, BOOL use_constr, DOUBLE time, DispatchEx **ret)
2114 {
2115 DateInstance *date;
2116 HRESULT hres;
2117 TIME_ZONE_INFORMATION tzi;
2118
2119 GetTimeZoneInformation(&tzi);
2120
2121 date = heap_alloc_zero(sizeof(DateInstance));
2122 if(!date)
2123 return E_OUTOFMEMORY;
2124
2125 if(use_constr)
2126 hres = init_dispex_from_constr(&date->dispex, ctx, &Date_info, ctx->date_constr);
2127 else
2128 hres = init_dispex(&date->dispex, ctx, &Date_info, NULL);
2129 if(FAILED(hres)) {
2130 heap_free(date);
2131 return hres;
2132 }
2133
2134 date->time = time;
2135 date->bias = tzi.Bias;
2136 date->standardDate = tzi.StandardDate;
2137 date->standardBias = tzi.StandardBias;
2138 date->daylightDate = tzi.DaylightDate;
2139 date->daylightBias = tzi.DaylightBias;
2140
2141 *ret = &date->dispex;
2142 return S_OK;
2143 }
2144
2145 static inline HRESULT date_parse(BSTR input, VARIANT *retv) {
2146 static const DWORD string_ids[] = { LOCALE_SMONTHNAME12, LOCALE_SMONTHNAME11,
2147 LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME8,
2148 LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME5,
2149 LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME2,
2150 LOCALE_SMONTHNAME1, LOCALE_SDAYNAME7, LOCALE_SDAYNAME1,
2151 LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
2152 LOCALE_SDAYNAME5, LOCALE_SDAYNAME6 };
2153 BSTR strings[sizeof(string_ids)/sizeof(DWORD)];
2154
2155 BSTR parse;
2156 int input_len, parse_len = 0, nest_level = 0, i, size;
2157 int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
2158 int ms = 0, offset = 0, hour_adjust = 0;
2159 BOOL set_year = FALSE, set_month = FALSE, set_day = FALSE, set_hour = FALSE;
2160 BOOL set_offset = FALSE, set_era = FALSE, ad = TRUE, set_am = FALSE, am = TRUE;
2161 BOOL set_hour_adjust = TRUE;
2162 TIME_ZONE_INFORMATION tzi;
2163 DateInstance di;
2164 DWORD lcid_en;
2165
2166 if(retv) num_set_nan(retv);
2167
2168 input_len = SysStringLen(input);
2169 for(i=0; i<input_len; i++) {
2170 if(input[i] == '(') nest_level++;
2171 else if(input[i] == ')') {
2172 nest_level--;
2173 if(nest_level<0)
2174 return S_OK;
2175 }
2176 else if(!nest_level) parse_len++;
2177 }
2178
2179 parse = SysAllocStringLen(NULL, parse_len);
2180 if(!parse)
2181 return E_OUTOFMEMORY;
2182 nest_level = 0;
2183 parse_len = 0;
2184 for(i=0; i<input_len; i++) {
2185 if(input[i] == '(') nest_level++;
2186 else if(input[i] == ')') nest_level--;
2187 else if(!nest_level) parse[parse_len++] = toupperW(input[i]);
2188 }
2189
2190 GetTimeZoneInformation(&tzi);
2191 di.bias = tzi.Bias;
2192 di.standardDate = tzi.StandardDate;
2193 di.standardBias = tzi.StandardBias;
2194 di.daylightDate = tzi.DaylightDate;
2195 di.daylightBias = tzi.DaylightBias;
2196
2197 lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2198 for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++) {
2199 size = GetLocaleInfoW(lcid_en, string_ids[i], NULL, 0);
2200 strings[i] = SysAllocStringLen(NULL, size);
2201 if(!strings[i]) {
2202 i--;
2203 while(i-- >= 0)
2204 SysFreeString(strings[i]);
2205 SysFreeString(parse);
2206 return E_OUTOFMEMORY;
2207 }
2208 GetLocaleInfoW(lcid_en, string_ids[i], strings[i], size);
2209 }
2210
2211 for(i=0; i<parse_len;) {
2212 while(isspaceW(parse[i])) i++;
2213 if(parse[i] == ',') {
2214 while(parse[i] == ',') i++;
2215 continue;
2216 }
2217
2218 if(parse[i]>='0' && parse[i]<='9') {
2219 int tmp = atoiW(&parse[i]);
2220 while(parse[i]>='0' && parse[i]<='9') i++;
2221 while(isspaceW(parse[i])) i++;
2222
2223 if(parse[i] == ':') {
2224 /* Time */
2225 if(set_hour) break;
2226 set_hour = TRUE;
2227
2228 hour = tmp;
2229
2230 while(parse[i] == ':') i++;
2231 while(isspaceW(parse[i])) i++;
2232 if(parse[i]>='0' && parse[i]<='9') {
2233 min = atoiW(&parse[i]);
2234 while(parse[i]>='0' && parse[i]<='9') i++;
2235 }
2236
2237 while(isspaceW(parse[i])) i++;
2238 while(parse[i] == ':') i++;
2239 while(isspaceW(parse[i])) i++;
2240 if(parse[i]>='0' && parse[i]<='9') {
2241 sec = atoiW(&parse[i]);
2242 while(parse[i]>='0' && parse[i]<='9') i++;
2243 }
2244 }
2245 else if(parse[i]=='-' || parse[i]=='/') {
2246 /* Short date */
2247 if(set_day || set_month || set_year) break;
2248 set_day = TRUE;
2249 set_month = TRUE;
2250 set_year = TRUE;
2251
2252 month = tmp-1;
2253
2254 while(isspaceW(parse[i])) i++;
2255 while(parse[i]=='-' || parse[i]=='/') i++;
2256 while(isspaceW(parse[i])) i++;
2257 if(parse[i]<'0' || parse[i]>'9') break;
2258 day = atoiW(&parse[i]);
2259 while(parse[i]>='0' && parse[i]<='9') i++;
2260
2261 while(parse[i]=='-' || parse[i]=='/') i++;
2262 while(isspaceW(parse[i])) i++;
2263 if(parse[i]<'0' || parse[i]>'9') break;
2264 year = atoiW(&parse[i]);
2265 while(parse[i]>='0' && parse[i]<='9') i++;
2266 }
2267 else if(tmp<0) break;
2268 else if(tmp<70) {
2269 /* Day */
2270 if(set_day) break;
2271 set_day = TRUE;
2272 day = tmp;
2273 }
2274 else {
2275 /* Year */
2276 if(set_year) break;
2277 set_year = TRUE;
2278 year = tmp;
2279 }
2280 }
2281 else {
2282 if(parse[i]<'A' || parse[i]>'Z') break;
2283 else if(parse[i]=='B' && (parse[i+1]=='C' ||
2284 (parse[i+1]=='.' && parse[i+2]=='C'))) {
2285 /* AD/BC */
2286 if(set_era) break;
2287 set_era = TRUE;
2288 ad = FALSE;
2289
2290 i++;
2291 if(parse[i] == '.') i++;
2292 i++;
2293 if(parse[i] == '.') i++;
2294 }
2295 else if(parse[i]=='A' && (parse[i+1]=='D' ||
2296 (parse[i+1]=='.' && parse[i+2]=='D'))) {
2297 /* AD/BC */
2298 if(set_era) break;
2299 set_era = TRUE;
2300
2301 i++;
2302 if(parse[i] == '.') i++;
2303 i++;
2304 if(parse[i] == '.') i++;
2305 }
2306 else if(parse[i+1]<'A' || parse[i+1]>'Z') {
2307 /* Timezone */
2308 if(set_offset) break;
2309 set_offset = TRUE;
2310
2311 if(parse[i] <= 'I') hour_adjust = parse[i]-'A'+2;
2312 else if(parse[i] == 'J') break;
2313 else if(parse[i] <= 'M') hour_adjust = parse[i]-'K'+11;
2314 else if(parse[i] <= 'Y') hour_adjust = parse[i]-'N';
2315 else hour_adjust = 1;
2316
2317 i++;
2318 if(parse[i] == '.') i++;
2319 }
2320 else if(parse[i]=='A' && parse[i+1]=='M') {
2321 /* AM/PM */
2322 if(set_am) break;
2323 set_am = TRUE;
2324 am = TRUE;
2325 i += 2;
2326 }
2327 else if(parse[i]=='P' && parse[i+1]=='M') {
2328 /* AM/PM */
2329 if(set_am) break;
2330 set_am = TRUE;
2331 am = FALSE;
2332 i += 2;
2333 }
2334 else if((parse[i]=='U' && parse[i+1]=='T' && parse[i+2]=='C')
2335 || (parse[i]=='G' && parse[i+1]=='M' && parse[i+2]=='T')) {
2336 /* Timezone */
2337 BOOL positive = TRUE;
2338
2339 if(set_offset) break;
2340 set_offset = TRUE;
2341 set_hour_adjust = FALSE;
2342
2343 i += 3;
2344 while(isspaceW(parse[i])) i++;
2345 if(parse[i] == '-') positive = FALSE;
2346 else if(parse[i] != '+') continue;
2347
2348 i++;
2349 while(isspaceW(parse[i])) i++;
2350 if(parse[i]<'0' || parse[i]>'9') break;
2351 offset = atoiW(&parse[i]);
2352 while(parse[i]>='0' && parse[i]<='9') i++;
2353
2354 if(offset<24) offset *= 60;
2355 else offset = (offset/100)*60 + offset%100;
2356
2357 if(positive) offset = -offset;
2358 }
2359 else {
2360 /* Month or garbage */
2361 int j;
2362
2363 for(size=i; parse[size]>='A' && parse[size]<='Z'; size++);
2364 size -= i;
2365
2366 for(j=0; j<sizeof(string_ids)/sizeof(DWORD); j++)
2367 if(!memicmpW(&parse[i], strings[j], size)) break;
2368
2369 if(j < 12) {
2370 if(set_month) break;
2371 set_month = TRUE;
2372 month = 11-j;
2373 }
2374 else if(j == sizeof(string_ids)/sizeof(DWORD)) break;
2375
2376 i += size;
2377 }
2378 }
2379 }
2380
2381 if(retv && i==parse_len && set_year && set_month
2382 && set_day && (!set_am || hour<13)) {
2383 if(set_am) {
2384 if(hour == 12) hour = 0;
2385 if(!am) hour += 12;
2386 }
2387
2388 if(!ad) year = -year+1;
2389 else if(year<100) year += 1900;
2390
2391 V_VT(retv) = VT_R8;
2392 V_R8(retv) = time_clip(make_date(make_day(year, month, day),
2393 make_time(hour+hour_adjust, min, sec, ms)) + offset*MS_PER_MINUTE);
2394
2395 if(set_hour_adjust) V_R8(retv) = utc(V_R8(retv), &di);
2396 }
2397
2398 for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++)
2399 SysFreeString(strings[i]);
2400 SysFreeString(parse);
2401
2402 return S_OK;
2403 }
2404
2405 static HRESULT DateConstr_parse(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
2406 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2407 {
2408 BSTR parse_str;
2409 HRESULT hres;
2410
2411 TRACE("\n");
2412
2413 if(!arg_cnt(dp)) {
2414 if(retv)
2415 num_set_nan(retv);
2416 return S_OK;
2417 }
2418
2419 hres = to_string(dispex->ctx, get_arg(dp,0), ei, &parse_str);
2420 if(FAILED(hres))
2421 return hres;
2422
2423 hres = date_parse(parse_str, retv);
2424
2425 SysFreeString(parse_str);
2426 return hres;
2427 }
2428
2429 static HRESULT DateConstr_UTC(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
2430 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2431 {
2432 VARIANT year, month, vdate, hours, minutes, seconds, ms;
2433 DOUBLE y;
2434 int arg_no = arg_cnt(dp);
2435 HRESULT hres;
2436
2437 TRACE("\n");
2438
2439 if(arg_no>0) {
2440 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &year);
2441 if(FAILED(hres))
2442 return hres;
2443 y = num_val(&year);
2444 if(0<=y && y<=99)
2445 y += 1900;
2446 }
2447 else y = 1900;
2448
2449 if(arg_no>1) {
2450 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &month);
2451 if(FAILED(hres))
2452 return hres;
2453 }
2454 else {
2455 V_VT(&month) = VT_R8;
2456 V_R8(&month) = 0;
2457 }
2458
2459 if(arg_no>2) {
2460 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &vdate);
2461 if(FAILED(hres))
2462 return hres;
2463 }
2464 else {
2465 V_VT(&vdate) = VT_R8;
2466 V_R8(&vdate) = 1;
2467 }
2468
2469 if(arg_no>3) {
2470 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &hours);
2471 if(FAILED(hres))
2472 return hres;
2473 }
2474 else {
2475 V_VT(&hours) = VT_R8;
2476 V_R8(&hours) = 0;
2477 }
2478
2479 if(arg_no>4) {
2480 hres = to_number(dispex->ctx, get_arg(dp, 4), ei, &minutes);
2481 if(FAILED(hres))
2482 return hres;
2483 }
2484 else {
2485 V_VT(&minutes) = VT_R8;
2486 V_R8(&minutes) = 0;
2487 }
2488
2489 if(arg_no>5) {
2490 hres = to_number(dispex->ctx, get_arg(dp, 5), ei, &seconds);
2491 if(FAILED(hres))
2492 return hres;
2493 }
2494 else {
2495 V_VT(&seconds) = VT_R8;
2496 V_R8(&seconds) = 0;
2497 }
2498
2499 if(arg_no>6) {
2500 hres = to_number(dispex->ctx, get_arg(dp, 6), ei, &ms);
2501 if(FAILED(hres))
2502 return hres;
2503 }
2504 else {
2505 V_VT(&ms) = VT_R8;
2506 V_R8(&ms) = 0;
2507 }
2508
2509 if(retv) {
2510 V_VT(retv) = VT_R8;
2511 V_R8(retv) = time_clip(make_date(
2512 make_day(y, num_val(&month), num_val(&vdate)),
2513 make_time(num_val(&hours), num_val(&minutes),
2514 num_val(&seconds), num_val(&ms))));
2515 }
2516
2517 return S_OK;
2518 }
2519
2520 static HRESULT DateConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
2521 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
2522 {
2523 DispatchEx *date;
2524 HRESULT hres;
2525
2526 TRACE("\n");
2527
2528 switch(flags) {
2529 case DISPATCH_CONSTRUCT:
2530 switch(arg_cnt(dp)) {
2531 /* ECMA-262 3rd Edition 15.9.3.3 */
2532 case 0: {
2533 FILETIME time;
2534 LONGLONG lltime;
2535
2536 GetSystemTimeAsFileTime(&time);
2537 lltime = ((LONGLONG)time.dwHighDateTime<<32)
2538 + time.dwLowDateTime;
2539
2540 hres = create_date(dispex->ctx, TRUE, lltime/10000-TIME_EPOCH, &date);
2541 if(FAILED(hres))
2542 return hres;
2543 break;
2544 }
2545
2546 /* ECMA-262 3rd Edition 15.9.3.2 */
2547 case 1: {
2548 VARIANT prim, num;
2549
2550 hres = to_primitive(dispex->ctx, get_arg(dp,0), ei, &prim, NO_HINT);
2551 if(FAILED(hres))
2552 return hres;
2553
2554 if(V_VT(&prim) == VT_BSTR)
2555 hres = date_parse(V_BSTR(&prim), &num);
2556 else
2557 hres = to_number(dispex->ctx, &prim, ei, &num);
2558
2559 VariantClear(&prim);
2560 if(FAILED(hres))
2561 return hres;
2562
2563 hres = create_date(dispex->ctx, TRUE, time_clip(num_val(&num)), &date);
2564 if(FAILED(hres))
2565 return hres;
2566 break;
2567 }
2568
2569 /* ECMA-262 3rd Edition 15.9.3.1 */
2570 default: {
2571 VARIANT ret_date;
2572 DateInstance *di;
2573
2574 DateConstr_UTC(dispex, lcid, flags, dp, &ret_date, ei, sp);
2575
2576 hres = create_date(dispex->ctx, TRUE, num_val(&ret_date), &date);
2577 if(FAILED(hres))
2578 return hres;
2579
2580 di = (DateInstance*)date;
2581 di->time = utc(di->time, di);
2582 }
2583 }
2584
2585 V_VT(retv) = VT_DISPATCH;
2586 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(date);
2587 return S_OK;
2588
2589 case INVOKE_FUNC: {
2590 FILETIME system_time, local_time;
2591 LONGLONG lltime;
2592
2593 GetSystemTimeAsFileTime(&system_time);
2594 FileTimeToLocalFileTime(&system_time, &local_time);
2595 lltime = ((LONGLONG)local_time.dwHighDateTime<<32)
2596 + local_time.dwLowDateTime;
2597
2598 return date_to_string(lltime/10000-TIME_EPOCH, FALSE, 0, retv);
2599 }
2600
2601 default:
2602 FIXME("unimplemented flags %x\n", flags);
2603 return E_NOTIMPL;
2604 }
2605
2606 return S_OK;
2607 }
2608
2609 static const builtin_prop_t DateConstr_props[] = {
2610 {UTCW, DateConstr_UTC, PROPF_METHOD},
2611 {parseW, DateConstr_parse, PROPF_METHOD}
2612 };
2613
2614 static const builtin_info_t DateConstr_info = {
2615 JSCLASS_FUNCTION,
2616 {NULL, Function_value, 0},
2617 sizeof(DateConstr_props)/sizeof(*DateConstr_props),
2618 DateConstr_props,
2619 NULL,
2620 NULL
2621 };
2622
2623 HRESULT create_date_constr(script_ctx_t *ctx, DispatchEx **ret)
2624 {
2625 DispatchEx *date;
2626 HRESULT hres;
2627
2628 hres = create_date(ctx, FALSE, 0.0, &date);
2629 if(FAILED(hres))
2630 return hres;
2631
2632 hres = create_builtin_function(ctx, DateConstr_value, &DateConstr_info, PROPF_CONSTR, date, ret);
2633
2634 jsdisp_release(date);
2635 return hres;
2636 }
useful hacks and other patches not (yet) suitable for mainline