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