?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add AppDefaults app selection to control panel
[wine/gsoc-2012-control.git] / dlls / jscript / date.c
blobf5cf591f3a09123eeb3b550084a114d2f53a400e
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 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 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 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 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 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 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 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 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 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 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 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 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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, argc, argv, 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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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, unsigned argc, VARIANT *argv,
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(!argc)
1379 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1380
1381 hres = to_number(ctx, argv, 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, unsigned argc, VARIANT *argv,
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(!argc)
1407 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1408
1409 hres = to_number(ctx, argv, 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, unsigned argc, VARIANT *argv,
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(!argc)
1438 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1439
1440 hres = to_number(ctx, argv, 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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &sec);
1474 if(FAILED(hres))
1475 return hres;
1476
1477 if(argc > 1) {
1478 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1509 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1510
1511 t = date->time;
1512
1513 hres = to_number(ctx, argv, ei, &sec);
1514 if(FAILED(hres))
1515 return hres;
1516
1517 if(argc > 1) {
1518 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &min);
1554 if(FAILED(hres))
1555 return hres;
1556
1557 if(argc > 1) {
1558 hres = to_number(ctx, argv+1, ei, &sec);
1559 if(FAILED(hres))
1560 return hres;
1561 }else {
1562 sec = sec_from_time(t);
1563 }
1564
1565 if(argc > 2) {
1566 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1597 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1598
1599 t = date->time;
1600
1601 hres = to_number(ctx, argv, ei, &min);
1602 if(FAILED(hres))
1603 return hres;
1604
1605 if(argc > 1) {
1606 hres = to_number(ctx, argv+1, ei, &sec);
1607 if(FAILED(hres))
1608 return hres;
1609 }else {
1610 sec = sec_from_time(t);
1611 }
1612
1613 if(argc > 2) {
1614 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &hour);
1650 if(FAILED(hres))
1651 return hres;
1652
1653 if(argc > 1) {
1654 hres = to_number(ctx, argv+1, ei, &min);
1655 if(FAILED(hres))
1656 return hres;
1657 }else {
1658 min = min_from_time(t);
1659 }
1660
1661 if(argc > 2) {
1662 hres = to_number(ctx, argv+2, ei, &sec);
1663 if(FAILED(hres))
1664 return hres;
1665 }else {
1666 sec = sec_from_time(t);
1667 }
1668
1669 if(argc > 3) {
1670 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1700 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1701
1702 t = date->time;
1703
1704 hres = to_number(ctx, argv, ei, &hour);
1705 if(FAILED(hres))
1706 return hres;
1707
1708 if(argc > 1) {
1709 hres = to_number(ctx, argv+1, ei, &min);
1710 if(FAILED(hres))
1711 return hres;
1712 }else {
1713 min = min_from_time(t);
1714 }
1715
1716 if(argc > 2) {
1717 hres = to_number(ctx, argv+2, ei, &sec);
1718 if(FAILED(hres))
1719 return hres;
1720 }else {
1721 sec = sec_from_time(t);
1722 }
1723
1724 if(argc > 3) {
1725 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1755 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1756
1757 hres = to_number(ctx, argv, 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, unsigned argc, VARIANT *argv,
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(!argc)
1785 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1786
1787 hres = to_number(ctx, argv, 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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &month);
1820 if(FAILED(hres))
1821 return hres;
1822
1823 if(argc > 1) {
1824 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1855 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1856
1857 t = date->time;
1858
1859 hres = to_number(ctx, argv, ei, &month);
1860 if(FAILED(hres))
1861 return hres;
1862
1863 if(argc > 1) {
1864 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &year);
1900 if(FAILED(hres))
1901 return hres;
1902
1903 if(argc > 1) {
1904 hres = to_number(ctx, argv+1, ei, &month);
1905 if(FAILED(hres))
1906 return hres;
1907 }else {
1908 month = month_from_time(t);
1909 }
1910
1911 if(argc > 2) {
1912 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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(!argc)
1942 return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1943
1944 t = date->time;
1945
1946 hres = to_number(ctx, argv, ei, &year);
1947 if(FAILED(hres))
1948 return hres;
1949
1950 if(argc > 1) {
1951 hres = to_number(ctx, argv+1, ei, &month);
1952 if(FAILED(hres))
1953 return hres;
1954 }else {
1955 month = month_from_time(t);
1956 }
1957
1958 if(argc > 2) {
1959 hres = to_number(ctx, argv+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, unsigned argc, VARIANT *argv,
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_val(retv, NAN);
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, unsigned argc, VARIANT *argv,
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(!argc)
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, argv, ei, &year);
2020 if(FAILED(hres))
2021 return hres;
2022
2023 if(isnan(year)) {
2024 date->time = year;
2025 if(retv)
2026 num_set_val(retv, NAN);
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, unsigned argc, VARIANT *argv,
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 const builtin_info_t DateInst_info = {
2114 JSCLASS_DATE,
2115 {NULL, Date_value, 0},
2116 0, NULL,
2117 NULL,
2118 NULL
2119 };
2120
2121 static HRESULT create_date(script_ctx_t *ctx, jsdisp_t *object_prototype, DOUBLE time, jsdisp_t **ret)
2122 {
2123 DateInstance *date;
2124 HRESULT hres;
2125 TIME_ZONE_INFORMATION tzi;
2126
2127 GetTimeZoneInformation(&tzi);
2128
2129 date = heap_alloc_zero(sizeof(DateInstance));
2130 if(!date)
2131 return E_OUTOFMEMORY;
2132
2133 if(object_prototype)
2134 hres = init_dispex(&date->dispex, ctx, &Date_info, object_prototype);
2135 else
2136 hres = init_dispex_from_constr(&date->dispex, ctx, &DateInst_info, ctx->date_constr);
2137 if(FAILED(hres)) {
2138 heap_free(date);
2139 return hres;
2140 }
2141
2142 date->time = time;
2143 date->bias = tzi.Bias;
2144 date->standardDate = tzi.StandardDate;
2145 date->standardBias = tzi.StandardBias;
2146 date->daylightDate = tzi.DaylightDate;
2147 date->daylightBias = tzi.DaylightBias;
2148
2149 *ret = &date->dispex;
2150 return S_OK;
2151 }
2152
2153 static inline HRESULT date_parse(BSTR input, double *ret) {
2154 static const DWORD string_ids[] = { LOCALE_SMONTHNAME12, LOCALE_SMONTHNAME11,
2155 LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME8,
2156 LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME5,
2157 LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME2,
2158 LOCALE_SMONTHNAME1, LOCALE_SDAYNAME7, LOCALE_SDAYNAME1,
2159 LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
2160 LOCALE_SDAYNAME5, LOCALE_SDAYNAME6 };
2161 BSTR strings[sizeof(string_ids)/sizeof(DWORD)];
2162
2163 BSTR parse;
2164 int input_len, parse_len = 0, nest_level = 0, i, size;
2165 int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
2166 int ms = 0, offset = 0, hour_adjust = 0;
2167 BOOL set_year = FALSE, set_month = FALSE, set_day = FALSE, set_hour = FALSE;
2168 BOOL set_offset = FALSE, set_era = FALSE, ad = TRUE, set_am = FALSE, am = TRUE;
2169 BOOL set_hour_adjust = TRUE;
2170 TIME_ZONE_INFORMATION tzi;
2171 DateInstance di;
2172 DWORD lcid_en;
2173
2174 input_len = SysStringLen(input);
2175 for(i=0; i<input_len; i++) {
2176 if(input[i] == '(') nest_level++;
2177 else if(input[i] == ')') {
2178 nest_level--;
2179 if(nest_level<0) {
2180 *ret = NAN;
2181 return S_OK;
2182 }
2183 }
2184 else if(!nest_level) parse_len++;
2185 }
2186
2187 parse = SysAllocStringLen(NULL, parse_len);
2188 if(!parse)
2189 return E_OUTOFMEMORY;
2190 nest_level = 0;
2191 parse_len = 0;
2192 for(i=0; i<input_len; i++) {
2193 if(input[i] == '(') nest_level++;
2194 else if(input[i] == ')') nest_level--;
2195 else if(!nest_level) parse[parse_len++] = toupperW(input[i]);
2196 }
2197
2198 GetTimeZoneInformation(&tzi);
2199 di.bias = tzi.Bias;
2200 di.standardDate = tzi.StandardDate;
2201 di.standardBias = tzi.StandardBias;
2202 di.daylightDate = tzi.DaylightDate;
2203 di.daylightBias = tzi.DaylightBias;
2204
2205 lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2206 for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++) {
2207 size = GetLocaleInfoW(lcid_en, string_ids[i], NULL, 0);
2208 strings[i] = SysAllocStringLen(NULL, size);
2209 if(!strings[i]) {
2210 i--;
2211 while(i-- >= 0)
2212 SysFreeString(strings[i]);
2213 SysFreeString(parse);
2214 return E_OUTOFMEMORY;
2215 }
2216 GetLocaleInfoW(lcid_en, string_ids[i], strings[i], size);
2217 }
2218
2219 for(i=0; i<parse_len;) {
2220 while(isspaceW(parse[i])) i++;
2221 if(parse[i] == ',') {
2222 while(parse[i] == ',') i++;
2223 continue;
2224 }
2225
2226 if(parse[i]>='0' && parse[i]<='9') {
2227 int tmp = atoiW(&parse[i]);
2228 while(parse[i]>='0' && parse[i]<='9') i++;
2229 while(isspaceW(parse[i])) i++;
2230
2231 if(parse[i] == ':') {
2232 /* Time */
2233 if(set_hour) break;
2234 set_hour = TRUE;
2235
2236 hour = tmp;
2237
2238 while(parse[i] == ':') i++;
2239 while(isspaceW(parse[i])) i++;
2240 if(parse[i]>='0' && parse[i]<='9') {
2241 min = atoiW(&parse[i]);
2242 while(parse[i]>='0' && parse[i]<='9') i++;
2243 }
2244
2245 while(isspaceW(parse[i])) i++;
2246 while(parse[i] == ':') i++;
2247 while(isspaceW(parse[i])) i++;
2248 if(parse[i]>='0' && parse[i]<='9') {
2249 sec = atoiW(&parse[i]);
2250 while(parse[i]>='0' && parse[i]<='9') i++;
2251 }
2252 }
2253 else if(parse[i]=='-' || parse[i]=='/') {
2254 /* Short date */
2255 if(set_day || set_month || set_year) break;
2256 set_day = TRUE;
2257 set_month = TRUE;
2258 set_year = TRUE;
2259
2260 month = tmp-1;
2261
2262 while(isspaceW(parse[i])) i++;
2263 while(parse[i]=='-' || parse[i]=='/') i++;
2264 while(isspaceW(parse[i])) i++;
2265 if(parse[i]<'0' || parse[i]>'9') break;
2266 day = atoiW(&parse[i]);
2267 while(parse[i]>='0' && parse[i]<='9') i++;
2268
2269 while(parse[i]=='-' || parse[i]=='/') i++;
2270 while(isspaceW(parse[i])) i++;
2271 if(parse[i]<'0' || parse[i]>'9') break;
2272 year = atoiW(&parse[i]);
2273 while(parse[i]>='0' && parse[i]<='9') i++;
2274 }
2275 else if(tmp<0) break;
2276 else if(tmp<70) {
2277 /* Day */
2278 if(set_day) break;
2279 set_day = TRUE;
2280 day = tmp;
2281 }
2282 else {
2283 /* Year */
2284 if(set_year) break;
2285 set_year = TRUE;
2286 year = tmp;
2287 }
2288 }
2289 else {
2290 if(parse[i]<'A' || parse[i]>'Z') break;
2291 else if(parse[i]=='B' && (parse[i+1]=='C' ||
2292 (parse[i+1]=='.' && parse[i+2]=='C'))) {
2293 /* AD/BC */
2294 if(set_era) break;
2295 set_era = TRUE;
2296 ad = FALSE;
2297
2298 i++;
2299 if(parse[i] == '.') i++;
2300 i++;
2301 if(parse[i] == '.') i++;
2302 }
2303 else if(parse[i]=='A' && (parse[i+1]=='D' ||
2304 (parse[i+1]=='.' && parse[i+2]=='D'))) {
2305 /* AD/BC */
2306 if(set_era) break;
2307 set_era = TRUE;
2308
2309 i++;
2310 if(parse[i] == '.') i++;
2311 i++;
2312 if(parse[i] == '.') i++;
2313 }
2314 else if(parse[i+1]<'A' || parse[i+1]>'Z') {
2315 /* Timezone */
2316 if(set_offset) break;
2317 set_offset = TRUE;
2318
2319 if(parse[i] <= 'I') hour_adjust = parse[i]-'A'+2;
2320 else if(parse[i] == 'J') break;
2321 else if(parse[i] <= 'M') hour_adjust = parse[i]-'K'+11;
2322 else if(parse[i] <= 'Y') hour_adjust = parse[i]-'N';
2323 else hour_adjust = 1;
2324
2325 i++;
2326 if(parse[i] == '.') i++;
2327 }
2328 else if(parse[i]=='A' && parse[i+1]=='M') {
2329 /* AM/PM */
2330 if(set_am) break;
2331 set_am = TRUE;
2332 am = TRUE;
2333 i += 2;
2334 }
2335 else if(parse[i]=='P' && parse[i+1]=='M') {
2336 /* AM/PM */
2337 if(set_am) break;
2338 set_am = TRUE;
2339 am = FALSE;
2340 i += 2;
2341 }
2342 else if((parse[i]=='U' && parse[i+1]=='T' && parse[i+2]=='C')
2343 || (parse[i]=='G' && parse[i+1]=='M' && parse[i+2]=='T')) {
2344 /* Timezone */
2345 BOOL positive = TRUE;
2346
2347 if(set_offset) break;
2348 set_offset = TRUE;
2349 set_hour_adjust = FALSE;
2350
2351 i += 3;
2352 while(isspaceW(parse[i])) i++;
2353 if(parse[i] == '-') positive = FALSE;
2354 else if(parse[i] != '+') continue;
2355
2356 i++;
2357 while(isspaceW(parse[i])) i++;
2358 if(parse[i]<'0' || parse[i]>'9') break;
2359 offset = atoiW(&parse[i]);
2360 while(parse[i]>='0' && parse[i]<='9') i++;
2361
2362 if(offset<24) offset *= 60;
2363 else offset = (offset/100)*60 + offset%100;
2364
2365 if(positive) offset = -offset;
2366 }
2367 else {
2368 /* Month or garbage */
2369 int j;
2370
2371 for(size=i; parse[size]>='A' && parse[size]<='Z'; size++);
2372 size -= i;
2373
2374 for(j=0; j<sizeof(string_ids)/sizeof(DWORD); j++)
2375 if(!memicmpW(&parse[i], strings[j], size)) break;
2376
2377 if(j < 12) {
2378 if(set_month) break;
2379 set_month = TRUE;
2380 month = 11-j;
2381 }
2382 else if(j == sizeof(string_ids)/sizeof(DWORD)) break;
2383
2384 i += size;
2385 }
2386 }
2387 }
2388
2389 if(i == parse_len && set_year && set_month && set_day && (!set_am || hour<13)) {
2390 if(set_am) {
2391 if(hour == 12) hour = 0;
2392 if(!am) hour += 12;
2393 }
2394
2395 if(!ad) year = -year+1;
2396 else if(year<100) year += 1900;
2397
2398 *ret = time_clip(make_date(make_day(year, month, day),
2399 make_time(hour+hour_adjust, min, sec, ms)) + offset*MS_PER_MINUTE);
2400
2401 if(set_hour_adjust)
2402 *ret = utc(*ret, &di);
2403 }else {
2404 *ret = NAN;
2405 }
2406
2407 for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++)
2408 SysFreeString(strings[i]);
2409 SysFreeString(parse);
2410
2411 return S_OK;
2412 }
2413
2414 static HRESULT DateConstr_parse(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, VARIANT *argv,
2415 VARIANT *retv, jsexcept_t *ei)
2416 {
2417 BSTR parse_str;
2418 double n;
2419 HRESULT hres;
2420
2421 TRACE("\n");
2422
2423 if(!argc) {
2424 if(retv)
2425 num_set_val(retv, NAN);
2426 return S_OK;
2427 }
2428
2429 hres = to_string(ctx, argv, ei, &parse_str);
2430 if(FAILED(hres))
2431 return hres;
2432
2433 hres = date_parse(parse_str, &n);
2434 SysFreeString(parse_str);
2435 if(FAILED(hres))
2436 return hres;
2437
2438 num_set_val(retv, n);
2439 return S_OK;
2440 }
2441
2442 static HRESULT date_utc(script_ctx_t *ctx, unsigned argc, VARIANT *argv, double *ret, jsexcept_t *ei)
2443 {
2444 double year, month, vdate, hours, minutes, seconds, ms;
2445 HRESULT hres;
2446
2447 TRACE("\n");
2448
2449 if(argc) {
2450 hres = to_number(ctx, argv, ei, &year);
2451 if(FAILED(hres))
2452 return hres;
2453 if(0 <= year && year <= 99)
2454 year += 1900;
2455 }else {
2456 year = 1900;
2457 }
2458
2459 if(argc>1) {
2460 hres = to_number(ctx, argv+1, ei, &month);
2461 if(FAILED(hres))
2462 return hres;
2463 }else {
2464 month = 0;
2465 }
2466
2467 if(argc>2) {
2468 hres = to_number(ctx, argv+2, ei, &vdate);
2469 if(FAILED(hres))
2470 return hres;
2471 }else {
2472 vdate = 1;
2473 }
2474
2475 if(argc>3) {
2476 hres = to_number(ctx, argv+3, ei, &hours);
2477 if(FAILED(hres))
2478 return hres;
2479 }else {
2480 hours = 0;
2481 }
2482
2483 if(argc>4) {
2484 hres = to_number(ctx, argv+4, ei, &minutes);
2485 if(FAILED(hres))
2486 return hres;
2487 }else {
2488 minutes = 0;
2489 }
2490
2491 if(argc>5) {
2492 hres = to_number(ctx, argv+5, ei, &seconds);
2493 if(FAILED(hres))
2494 return hres;
2495 }else {
2496 seconds = 0;
2497 }
2498
2499 if(argc>6) {
2500 hres = to_number(ctx, argv+6, ei, &ms);
2501 if(FAILED(hres))
2502 return hres;
2503 } else {
2504 ms = 0;
2505 }
2506
2507 *ret = time_clip(make_date(make_day(year, month, vdate),
2508 make_time(hours, minutes,seconds, ms)));
2509 return S_OK;
2510 }
2511
2512 static HRESULT DateConstr_UTC(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, VARIANT *argv,
2513 VARIANT *retv, jsexcept_t *ei)
2514 {
2515 double n;
2516 HRESULT hres;
2517
2518 TRACE("\n");
2519
2520 hres = date_utc(ctx, argc, argv, &n, ei);
2521 if(SUCCEEDED(hres) && retv)
2522 num_set_val(retv, n);
2523 return hres;
2524 }
2525
2526 static HRESULT DateConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, VARIANT *argv,
2527 VARIANT *retv, jsexcept_t *ei)
2528 {
2529 jsdisp_t *date;
2530 HRESULT hres;
2531
2532 TRACE("\n");
2533
2534 switch(flags) {
2535 case DISPATCH_CONSTRUCT:
2536 switch(argc) {
2537 /* ECMA-262 3rd Edition 15.9.3.3 */
2538 case 0: {
2539 FILETIME time;
2540 LONGLONG lltime;
2541
2542 GetSystemTimeAsFileTime(&time);
2543 lltime = ((LONGLONG)time.dwHighDateTime<<32)
2544 + time.dwLowDateTime;
2545
2546 hres = create_date(ctx, NULL, lltime/10000-TIME_EPOCH, &date);
2547 if(FAILED(hres))
2548 return hres;
2549 break;
2550 }
2551
2552 /* ECMA-262 3rd Edition 15.9.3.2 */
2553 case 1: {
2554 VARIANT prim;
2555 double n;
2556
2557 hres = to_primitive(ctx, argv, ei, &prim, NO_HINT);
2558 if(FAILED(hres))
2559 return hres;
2560
2561 if(V_VT(&prim) == VT_BSTR)
2562 hres = date_parse(V_BSTR(&prim), &n);
2563 else
2564 hres = to_number(ctx, &prim, ei, &n);
2565
2566 VariantClear(&prim);
2567 if(FAILED(hres))
2568 return hres;
2569
2570 hres = create_date(ctx, NULL, time_clip(n), &date);
2571 if(FAILED(hres))
2572 return hres;
2573 break;
2574 }
2575
2576 /* ECMA-262 3rd Edition 15.9.3.1 */
2577 default: {
2578 double ret_date;
2579 DateInstance *di;
2580
2581 hres = date_utc(ctx, argc, argv, &ret_date, ei);
2582 if(FAILED(hres))
2583 return hres;
2584
2585 hres = create_date(ctx, NULL, ret_date, &date);
2586 if(FAILED(hres))
2587 return hres;
2588
2589 di = (DateInstance*)date;
2590 di->time = utc(di->time, di);
2591 }
2592 }
2593
2594 var_set_jsdisp(retv, date);
2595 return S_OK;
2596
2597 case INVOKE_FUNC: {
2598 FILETIME system_time, local_time;
2599 LONGLONG lltime;
2600
2601 GetSystemTimeAsFileTime(&system_time);
2602 FileTimeToLocalFileTime(&system_time, &local_time);
2603 lltime = ((LONGLONG)local_time.dwHighDateTime<<32)
2604 + local_time.dwLowDateTime;
2605
2606 return date_to_string(lltime/10000-TIME_EPOCH, FALSE, 0, retv);
2607 }
2608
2609 default:
2610 FIXME("unimplemented flags %x\n", flags);
2611 return E_NOTIMPL;
2612 }
2613
2614 return S_OK;
2615 }
2616
2617 static const builtin_prop_t DateConstr_props[] = {
2618 {UTCW, DateConstr_UTC, PROPF_METHOD},
2619 {parseW, DateConstr_parse, PROPF_METHOD}
2620 };
2621
2622 static const builtin_info_t DateConstr_info = {
2623 JSCLASS_FUNCTION,
2624 {NULL, Function_value, 0},
2625 sizeof(DateConstr_props)/sizeof(*DateConstr_props),
2626 DateConstr_props,
2627 NULL,
2628 NULL
2629 };
2630
2631 HRESULT create_date_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
2632 {
2633 jsdisp_t *date;
2634 HRESULT hres;
2635
2636 static const WCHAR DateW[] = {'D','a','t','e',0};
2637
2638 hres = create_date(ctx, object_prototype, 0.0, &date);
2639 if(FAILED(hres))
2640 return hres;
2641
2642 hres = create_builtin_constructor(ctx, DateConstr_value, DateW, &DateConstr_info,
2643 PROPF_CONSTR|7, date, ret);
2644
2645 jsdisp_release(date);
2646 return hres;
2647 }
GSOC 2012 project to enhance the control panel