?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jscript: Added Date_toLocaleTimeString implementation.
[wine.git] / dlls / jscript / date.c
blobce703a4a2955e65a78282f015d433f4b36dcf62d
1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <limits.h>
20 #include <math.h>
21
22 #include "jscript.h"
23
24 #include "wine/debug.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
27
28 /* 1601 to 1970 is 369 years plus 89 leap days */
29 #define TIME_EPOCH ((ULONGLONG)(369 * 365 + 89) * 86400 * 1000)
30
31 typedef struct {
32 DispatchEx dispex;
33
34 /* ECMA-262 3rd Edition 15.9.1.1 */
35 DOUBLE time;
36
37 LONG bias;
38 SYSTEMTIME standardDate;
39 LONG standardBias;
40 SYSTEMTIME daylightDate;
41 LONG daylightBias;
42 } DateInstance;
43
44 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
45 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
46 static const WCHAR hasOwnPropertyW[] = {'h','a','s','O','w','n','P','r','o','p','e','r','t','y',0};
47 static const WCHAR propertyIsEnumerableW[] =
48 {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0};
49 static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0};
50 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
51 static const WCHAR toUTCStringW[] = {'t','o','U','T','C','S','t','r','i','n','g',0};
52 static const WCHAR toDateStringW[] = {'t','o','D','a','t','e','S','t','r','i','n','g',0};
53 static const WCHAR toTimeStringW[] = {'t','o','T','i','m','e','S','t','r','i','n','g',0};
54 static const WCHAR toLocaleDateStringW[] = {'t','o','L','o','c','a','l','e','D','a','t','e','S','t','r','i','n','g',0};
55 static const WCHAR toLocaleTimeStringW[] = {'t','o','L','o','c','a','l','e','T','i','m','e','S','t','r','i','n','g',0};
56 static const WCHAR getTimeW[] = {'g','e','t','T','i','m','e',0};
57 static const WCHAR getFullYearW[] = {'g','e','t','F','u','l','l','Y','e','a','r',0};
58 static const WCHAR getUTCFullYearW[] = {'g','e','t','U','T','C','F','u','l','l','Y','e','a','r',0};
59 static const WCHAR getMonthW[] = {'g','e','t','M','o','n','t','h',0};
60 static const WCHAR getUTCMonthW[] = {'g','e','t','U','T','C','M','o','n','t','h',0};
61 static const WCHAR getDateW[] = {'g','e','t','D','a','t','e',0};
62 static const WCHAR getUTCDateW[] = {'g','e','t','U','T','C','D','a','t','e',0};
63 static const WCHAR getDayW[] = {'g','e','t','D','a','y',0};
64 static const WCHAR getUTCDayW[] = {'g','e','t','U','T','C','D','a','y',0};
65 static const WCHAR getHoursW[] = {'g','e','t','H','o','u','r','s',0};
66 static const WCHAR getUTCHoursW[] = {'g','e','t','U','T','C','H','o','u','r','s',0};
67 static const WCHAR getMinutesW[] = {'g','e','t','M','i','n','u','t','e','s',0};
68 static const WCHAR getUTCMinutesW[] = {'g','e','t','U','T','C','M','i','n','u','t','e','s',0};
69 static const WCHAR getSecondsW[] = {'g','e','t','S','e','c','o','n','d','s',0};
70 static const WCHAR getUTCSecondsW[] = {'g','e','t','U','T','C','S','e','c','o','n','d','s',0};
71 static const WCHAR getMillisecondsW[] = {'g','e','t','M','i','l','l','i','s','e','c','o','n','d','s',0};
72 static const WCHAR getUTCMillisecondsW[] = {'g','e','t','U','T','C','M','i','l','l','i','s','e','c','o','n','d','s',0};
73 static const WCHAR getTimezoneOffsetW[] = {'g','e','t','T','i','m','e','z','o','n','e','O','f','f','s','e','t',0};
74 static const WCHAR setTimeW[] = {'s','e','t','T','i','m','e',0};
75 static const WCHAR setMillisecondsW[] = {'s','e','t','M','i','l','l','i','s','e','c','o','n','d','s',0};
76 static const WCHAR setUTCMillisecondsW[] = {'s','e','t','U','T','C','M','i','l','l','i','s','e','c','o','n','d','s',0};
77 static const WCHAR setSecondsW[] = {'s','e','t','S','e','c','o','n','d','s',0};
78 static const WCHAR setUTCSecondsW[] = {'s','e','t','U','T','C','S','e','c','o','n','d','s',0};
79 static const WCHAR setMinutesW[] = {'s','e','t','M','i','n','u','t','e','s',0};
80 static const WCHAR setUTCMinutesW[] = {'s','e','t','U','T','C','M','i','n','u','t','e','s',0};
81 static const WCHAR setHoursW[] = {'s','e','t','H','o','u','r','s',0};
82 static const WCHAR setUTCHoursW[] = {'s','e','t','U','T','C','H','o','u','r','s',0};
83 static const WCHAR setDateW[] = {'s','e','t','D','a','t','e',0};
84 static const WCHAR setUTCDateW[] = {'s','e','t','U','T','C','D','a','t','e',0};
85 static const WCHAR setMonthW[] = {'s','e','t','M','o','n','t','h',0};
86 static const WCHAR setUTCMonthW[] = {'s','e','t','U','T','C','M','o','n','t','h',0};
87 static const WCHAR setFullYearW[] = {'s','e','t','F','u','l','l','Y','e','a','r',0};
88 static const WCHAR setUTCFullYearW[] = {'s','e','t','U','T','C','F','u','l','l','Y','e','a','r',0};
89
90 /*ECMA-262 3rd Edition 15.9.1.2 */
91 #define MS_PER_DAY 86400000
92 #define MS_PER_HOUR 3600000
93 #define MS_PER_MINUTE 60000
94
95 /* ECMA-262 3rd Edition 15.9.1.2 */
96 static inline DOUBLE day(DOUBLE time)
97 {
98 return floor(time / MS_PER_DAY);
99 }
100
101 /* ECMA-262 3rd Edition 15.9.1.2 */
102 static inline DOUBLE time_within_day(DOUBLE time)
103 {
104 DOUBLE ret;
105
106 ret = fmod(time, MS_PER_DAY);
107 if(ret < 0)
108 ret += MS_PER_DAY;
109
110 return ret;
111 }
112
113 /* ECMA-262 3rd Edition 15.9.1.3 */
114 static inline DOUBLE days_in_year(DOUBLE year)
115 {
116 int y;
117
118 if(year != (int)year)
119 return ret_nan();
120
121 y = year;
122 if(y%4 != 0) return 365;
123 if(y%100 != 0) return 366;
124 if(y%400 != 0) return 365;
125 return 366;
126 }
127
128 /* ECMA-262 3rd Edition 15.9.1.3 */
129 static inline DOUBLE day_from_year(DOUBLE year)
130 {
131 if(year != (int)year)
132 return ret_nan();
133
134 return floor(365.0*(year-1970) + floor((year-1969)/4)
135 - floor((year-1901)/100) + floor((year-1601)/400));
136 }
137
138 static inline int day_from_month(int month, int in_leap_year)
139 {
140 switch(month)
141 {
142 case 0:
143 return 0;
144 case 1:
145 return 31;
146 case 2:
147 return 59+in_leap_year;
148 case 3:
149 return 90+in_leap_year;
150 case 4:
151 return 120+in_leap_year;
152 case 5:
153 return 151+in_leap_year;
154 case 6:
155 return 181+in_leap_year;
156 case 7:
157 return 212+in_leap_year;
158 case 8:
159 return 243+in_leap_year;
160 case 9:
161 return 273+in_leap_year;
162 case 10:
163 return 304+in_leap_year;
164 default:
165 return 334+in_leap_year;
166 }
167 }
168
169 /* ECMA-262 3rd Edition 15.9.1.3 */
170 static inline DOUBLE time_from_year(DOUBLE year)
171 {
172 return MS_PER_DAY*day_from_year(year);
173 }
174
175 /* ECMA-262 3rd Edition 15.9.1.3 */
176 static inline DOUBLE year_from_time(DOUBLE time)
177 {
178 int y;
179
180 if(isnan(time))
181 return ret_nan();
182
183 y = 1970 + time/365.25/MS_PER_DAY;
184
185 if(time_from_year(y) > time)
186 while(time_from_year(y) > time) y--;
187 else
188 while(time_from_year(y+1)<=time) y++;
189
190 return y;
191 }
192
193 /* ECMA-262 3rd Edition 15.9.1.3 */
194 static inline int in_leap_year(DOUBLE time)
195 {
196 if(days_in_year(year_from_time(time))==366)
197 return 1;
198 return 0;
199 }
200
201 /* ECMA-262 3rd Edition 15.9.1.4 */
202 static inline int day_within_year(DOUBLE time)
203 {
204 return day(time) - day_from_year(year_from_time(time));
205 }
206
207 /* ECMA-262 3rd Edition 15.9.1.4 */
208 static inline DOUBLE month_from_time(DOUBLE time)
209 {
210 int ily = in_leap_year(time);
211 int dwy = day_within_year(time);
212
213 if(isnan(time))
214 return ret_nan();
215
216 if(0<=dwy && dwy<31) return 0;
217 if(dwy < 59+ily) return 1;
218 if(dwy < 90+ily) return 2;
219 if(dwy < 120+ily) return 3;
220 if(dwy < 151+ily) return 4;
221 if(dwy < 181+ily) return 5;
222 if(dwy < 212+ily) return 6;
223 if(dwy < 243+ily) return 7;
224 if(dwy < 273+ily) return 8;
225 if(dwy < 304+ily) return 9;
226 if(dwy < 334+ily) return 10;
227 return 11;
228 }
229
230 /* ECMA-262 3rd Edition 15.9.1.5 */
231 static inline DOUBLE date_from_time(DOUBLE time)
232 {
233 int dwy = day_within_year(time);
234 int ily = in_leap_year(time);
235 int mft = month_from_time(time);
236
237 if(isnan(time))
238 return ret_nan();
239
240 if(mft==0) return dwy+1;
241 if(mft==1) return dwy-30;
242 if(mft==2) return dwy-58-ily;
243 if(mft==3) return dwy-89-ily;
244 if(mft==4) return dwy-119-ily;
245 if(mft==5) return dwy-150-ily;
246 if(mft==6) return dwy-180-ily;
247 if(mft==7) return dwy-211-ily;
248 if(mft==8) return dwy-242-ily;
249 if(mft==9) return dwy-272-ily;
250 if(mft==10) return dwy-303-ily;
251 return dwy-333-ily;
252 }
253
254 /* ECMA-262 3rd Edition 15.9.1.6 */
255 static inline DOUBLE week_day(DOUBLE time)
256 {
257 DOUBLE ret;
258
259 if(isnan(time))
260 return ret_nan();
261
262 ret = fmod(day(time)+4, 7);
263 if(ret<0) ret += 7;
264
265 return ret;
266 }
267
268 static inline DOUBLE convert_time(int year, SYSTEMTIME st)
269 {
270 DOUBLE time;
271 int set_week_day;
272
273 if(st.wMonth == 0)
274 return ret_nan();
275
276 if(st.wYear != 0)
277 year = st.wYear;
278
279 time = time_from_year(year);
280 time += (DOUBLE)day_from_month(st.wMonth-1, in_leap_year(time)) * MS_PER_DAY;
281
282 if(st.wYear == 0) {
283 set_week_day = st.wDayOfWeek-week_day(time);
284 if(set_week_day < 0)
285 set_week_day += 7;
286 time += set_week_day * MS_PER_DAY;
287
288 time += (DOUBLE)(st.wDay-1) * 7 * MS_PER_DAY;
289 if(month_from_time(time) != st.wMonth-1)
290 time -= 7 * MS_PER_DAY;
291 }
292 else
293 time += st.wDay * MS_PER_DAY;
294
295 time += st.wHour * MS_PER_HOUR;
296 time += st.wMinute * MS_PER_MINUTE;
297
298 return time;
299 }
300
301 /* ECMA-262 3rd Edition 15.9.1.9 */
302 static inline DOUBLE daylight_saving_ta(DOUBLE time, DateInstance *date)
303 {
304 int year = year_from_time(time);
305 DOUBLE standardTime, daylightTime;
306
307 if(isnan(time))
308 return 0;
309
310 standardTime = convert_time(year, date->standardDate);
311 daylightTime = convert_time(year, date->daylightDate);
312
313 if(isnan(standardTime) || isnan(daylightTime))
314 return 0;
315 else if(standardTime > daylightTime) {
316 if(daylightTime <= time && time < standardTime)
317 return date->daylightBias;
318
319 return date->standardBias;
320 }
321 else {
322 if(standardTime <= time && time < daylightTime)
323 return date->standardBias;
324
325 return date->daylightBias;
326 }
327 }
328
329 /* ECMA-262 3rd Edition 15.9.1.9 */
330 static inline DOUBLE local_time(DOUBLE time, DateInstance *date)
331 {
332 return time - (daylight_saving_ta(time, date)+date->bias)*MS_PER_MINUTE;
333 }
334
335 /* ECMA-262 3rd Edition 15.9.1.9 */
336 static inline DOUBLE utc(DOUBLE time, DateInstance *date)
337 {
338 time += date->bias * MS_PER_MINUTE;
339 return time + daylight_saving_ta(time, date)*MS_PER_MINUTE;
340 }
341
342 /* ECMA-262 3rd Edition 15.9.1.10 */
343 static inline DOUBLE hour_from_time(DOUBLE time)
344 {
345 DOUBLE ret;
346
347 if(isnan(time))
348 return ret_nan();
349
350 ret = fmod(floor(time/MS_PER_HOUR), 24);
351 if(ret<0) ret += 24;
352
353 return ret;
354 }
355
356 /* ECMA-262 3rd Edition 15.9.1.10 */
357 static inline DOUBLE min_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_MINUTE), 60);
365 if(ret<0) ret += 60;
366
367 return ret;
368 }
369
370 /* ECMA-262 3rd Edition 15.9.1.10 */
371 static inline DOUBLE sec_from_time(DOUBLE time)
372 {
373 DOUBLE ret;
374
375 if(isnan(time))
376 return ret_nan();
377
378 ret = fmod(floor(time/1000), 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 ms_from_time(DOUBLE time)
386 {
387 DOUBLE ret;
388
389 if(isnan(time))
390 return ret_nan();
391
392 ret = fmod(time, 1000);
393 if(ret<0) ret += 1000;
394
395 return ret;
396 }
397
398 /* ECMA-262 3rd Edition 15.9.1.11 */
399 static inline DOUBLE make_time(DOUBLE hour, DOUBLE min, DOUBLE sec, DOUBLE ms)
400 {
401 return hour*MS_PER_HOUR + min*MS_PER_MINUTE + sec*1000 + ms;
402 }
403
404 /* ECMA-262 3rd Edition 15.9.1.12 */
405 static inline DOUBLE make_day(DOUBLE year, DOUBLE month, DOUBLE day)
406 {
407 DOUBLE time;
408
409 year += floor(month/12);
410
411 month = fmod(month, 12);
412 if(month<0) month += 12;
413
414 time = time_from_year(year);
415
416 day += floor(time / MS_PER_DAY);
417 day += day_from_month(month, in_leap_year(time));
418
419 return day-1;
420 }
421
422 /* ECMA-262 3rd Edition 15.9.1.13 */
423 static inline DOUBLE make_date(DOUBLE day, DOUBLE time)
424 {
425 return day*MS_PER_DAY + time;
426 }
427
428 /* ECMA-262 3rd Edition 15.9.1.14 */
429 static inline DOUBLE time_clip(DOUBLE time)
430 {
431 if(8.64e15 < time || time < -8.64e15) {
432 return ret_nan();
433 }
434
435 return floor(time);
436 }
437
438 static SYSTEMTIME create_systemtime(DOUBLE time)
439 {
440 SYSTEMTIME st;
441
442 st.wYear = year_from_time(time);
443 st.wMonth = month_from_time(time) + 1;
444 st.wDayOfWeek = week_day(time);
445 st.wDay = date_from_time(time);
446 st.wHour = hour_from_time(time);
447 st.wMinute = min_from_time(time);
448 st.wSecond = sec_from_time(time);
449 st.wMilliseconds = ms_from_time(time);
450
451 return st;
452 }
453
454 static HRESULT Date_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
455 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
456 {
457 FIXME("\n");
458 return E_NOTIMPL;
459 }
460
461 static HRESULT Date_toLocaleString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
462 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
463 {
464 FIXME("\n");
465 return E_NOTIMPL;
466 }
467
468 static HRESULT Date_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
469 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
470 {
471 FIXME("\n");
472 return E_NOTIMPL;
473 }
474
475 static HRESULT Date_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
476 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
477 {
478 FIXME("\n");
479 return E_NOTIMPL;
480 }
481
482 static HRESULT Date_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
483 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
484 {
485 FIXME("\n");
486 return E_NOTIMPL;
487 }
488
489 static HRESULT Date_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
490 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
491 {
492 FIXME("\n");
493 return E_NOTIMPL;
494 }
495
496 static HRESULT Date_toUTCString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
497 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
498 {
499 FIXME("\n");
500 return E_NOTIMPL;
501 }
502
503 static HRESULT Date_toDateString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
504 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
505 {
506 FIXME("\n");
507 return E_NOTIMPL;
508 }
509
510 static HRESULT Date_toTimeString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
511 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
512 {
513 FIXME("\n");
514 return E_NOTIMPL;
515 }
516
517 /* ECMA-262 3rd Edition 15.9.5.6 */
518 static HRESULT Date_toLocaleDateString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
519 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
520 {
521 static const WCHAR NaNW[] = { 'N','a','N',0 };
522 SYSTEMTIME st;
523 DateInstance *date;
524 BSTR date_str;
525 int len;
526
527 TRACE("\n");
528
529 if(!is_class(dispex, JSCLASS_DATE)) {
530 FIXME("throw TypeError\n");
531 return E_FAIL;
532 }
533
534 date = (DateInstance*)dispex;
535
536 if(isnan(date->time)) {
537 if(retv) {
538 V_VT(retv) = VT_BSTR;
539 V_BSTR(retv) = SysAllocString(NaNW);
540 if(!V_BSTR(retv))
541 return E_OUTOFMEMORY;
542 }
543 return S_OK;
544 }
545
546 st = create_systemtime(local_time(date->time, date));
547
548 if(st.wYear<1601 || st.wYear>9999)
549 return Date_toDateString(dispex, lcid, flags, dp, retv, ei, caller);
550
551 if(retv) {
552 len = GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
553 date_str = SysAllocStringLen(NULL, len);
554 if(!date_str)
555 return E_OUTOFMEMORY;
556 GetDateFormatW(lcid, DATE_LONGDATE, &st, NULL, date_str, len);
557
558 V_VT(retv) = VT_BSTR;
559 V_BSTR(retv) = date_str;
560 }
561 return S_OK;
562 }
563
564 /* ECMA-262 3rd Edition 15.9.5.7 */
565 static HRESULT Date_toLocaleTimeString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
566 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
567 {
568 static const WCHAR NaNW[] = { 'N','a','N',0 };
569 SYSTEMTIME st;
570 DateInstance *date;
571 BSTR date_str;
572 int len;
573
574 TRACE("\n");
575
576 if(!is_class(dispex, JSCLASS_DATE)) {
577 FIXME("throw TypeError\n");
578 return E_FAIL;
579 }
580
581 date = (DateInstance*)dispex;
582
583 if(isnan(date->time)) {
584 if(retv) {
585 V_VT(retv) = VT_BSTR;
586 V_BSTR(retv) = SysAllocString(NaNW);
587 if(!V_BSTR(retv))
588 return E_OUTOFMEMORY;
589 }
590 return S_OK;
591 }
592
593 st = create_systemtime(local_time(date->time, date));
594
595 if(st.wYear<1601 || st.wYear>9999)
596 return Date_toTimeString(dispex, lcid, flags, dp, retv, ei, caller);
597
598 if(retv) {
599 len = GetTimeFormatW(lcid, 0, &st, NULL, NULL, 0);
600 date_str = SysAllocStringLen(NULL, len);
601 if(!date_str)
602 return E_OUTOFMEMORY;
603 GetTimeFormatW(lcid, 0, &st, NULL, date_str, len);
604
605 V_VT(retv) = VT_BSTR;
606 V_BSTR(retv) = date_str;
607 }
608 return S_OK;
609 }
610
611 /* ECMA-262 3rd Edition 15.9.5.9 */
612 static HRESULT Date_getTime(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
613 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
614 {
615 TRACE("\n");
616
617 if(!is_class(dispex, JSCLASS_DATE)) {
618 FIXME("throw TypeError\n");
619 return E_FAIL;
620 }
621
622 if(retv) {
623 DateInstance *date = (DateInstance*)dispex;
624 num_set_val(retv, date->time);
625 }
626 return S_OK;
627 }
628
629 /* ECMA-262 3rd Edition 15.9.5.10 */
630 static HRESULT Date_getFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
631 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
632 {
633 TRACE("\n");
634
635 if(!is_class(dispex, JSCLASS_DATE)) {
636 FIXME("throw TypeError\n");
637 return E_FAIL;
638 }
639
640 if(retv) {
641 DateInstance *date = (DateInstance*)dispex;
642 DOUBLE time = local_time(date->time, date);
643
644 num_set_val(retv, year_from_time(time));
645 }
646 return S_OK;
647 }
648
649 /* ECMA-262 3rd Edition 15.9.5.11 */
650 static HRESULT Date_getUTCFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
651 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
652 {
653 TRACE("\n");
654
655 if(!is_class(dispex, JSCLASS_DATE)) {
656 FIXME("throw TypeError\n");
657 return E_FAIL;
658 }
659
660 if(retv) {
661 DateInstance *date = (DateInstance*)dispex;
662 num_set_val(retv, year_from_time(date->time));
663 }
664 return S_OK;
665 }
666
667 /* ECMA-262 3rd Edition 15.9.5.12 */
668 static HRESULT Date_getMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
669 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
670 {
671 TRACE("\n");
672
673 if(!is_class(dispex, JSCLASS_DATE)) {
674 FIXME("throw TypeError\n");
675 return E_FAIL;
676 }
677
678 if(retv) {
679 DateInstance *date = (DateInstance*)dispex;
680 DOUBLE time = local_time(date->time, date);
681
682 num_set_val(retv, month_from_time(time));
683 }
684 return S_OK;
685 }
686
687 /* ECMA-262 3rd Edition 15.9.5.13 */
688 static HRESULT Date_getUTCMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
689 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
690 {
691 TRACE("\n");
692
693 if(!is_class(dispex, JSCLASS_DATE)) {
694 FIXME("throw TypeError\n");
695 return E_FAIL;
696 }
697
698 if(retv) {
699 DateInstance *date = (DateInstance*)dispex;
700 num_set_val(retv, month_from_time(date->time));
701 }
702 return S_OK;
703 }
704
705 /* ECMA-262 3rd Edition 15.9.5.14 */
706 static HRESULT Date_getDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
707 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
708 {
709 TRACE("\n");
710
711 if(!is_class(dispex, JSCLASS_DATE)) {
712 FIXME("throw TypeError\n");
713 return E_FAIL;
714 }
715
716 if(retv) {
717 DateInstance *date = (DateInstance*)dispex;
718 DOUBLE time = local_time(date->time, date);
719
720 num_set_val(retv, date_from_time(time));
721 }
722 return S_OK;
723 }
724
725 /* ECMA-262 3rd Edition 15.9.5.15 */
726 static HRESULT Date_getUTCDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
727 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
728 {
729 TRACE("\n");
730
731 if(!is_class(dispex, JSCLASS_DATE)) {
732 FIXME("throw TypeError\n");
733 return E_FAIL;
734 }
735
736 if(retv) {
737 DateInstance *date = (DateInstance*)dispex;
738 num_set_val(retv, date_from_time(date->time));
739 }
740 return S_OK;
741 }
742
743 /* ECMA-262 3rd Edition 15.9.5.16 */
744 static HRESULT Date_getDay(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
745 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
746 {
747 TRACE("\n");
748
749 if(!is_class(dispex, JSCLASS_DATE)) {
750 FIXME("throw TypeError\n");
751 return E_FAIL;
752 }
753
754 if(retv) {
755 DateInstance *date = (DateInstance*)dispex;
756 DOUBLE time = local_time(date->time, date);
757
758 num_set_val(retv, week_day(time));
759 }
760 return S_OK;
761 }
762
763 /* ECMA-262 3rd Edition 15.9.5.17 */
764 static HRESULT Date_getUTCDay(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
765 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
766 {
767 TRACE("\n");
768
769 if(!is_class(dispex, JSCLASS_DATE)) {
770 FIXME("throw TypeError\n");
771 return E_FAIL;
772 }
773
774 if(retv) {
775 DateInstance *date = (DateInstance*)dispex;
776 num_set_val(retv, week_day(date->time));
777 }
778 return S_OK;
779 }
780
781 /* ECMA-262 3rd Edition 15.9.5.18 */
782 static HRESULT Date_getHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
783 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
784 {
785 TRACE("\n");
786
787 if(!is_class(dispex, JSCLASS_DATE)) {
788 FIXME("throw TypeError\n");
789 return E_FAIL;
790 }
791
792 if(retv) {
793 DateInstance *date = (DateInstance*)dispex;
794 DOUBLE time = local_time(date->time, date);
795
796 num_set_val(retv, hour_from_time(time));
797 }
798 return S_OK;
799 }
800
801 /* ECMA-262 3rd Edition 15.9.5.19 */
802 static HRESULT Date_getUTCHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
803 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
804 {
805 TRACE("\n");
806
807 if(!is_class(dispex, JSCLASS_DATE)) {
808 FIXME("throw TypeError\n");
809 return E_FAIL;
810 }
811
812 if(retv) {
813 DateInstance *date = (DateInstance*)dispex;
814 num_set_val(retv, hour_from_time(date->time));
815 }
816 return S_OK;
817 }
818
819 /* ECMA-262 3rd Edition 15.9.5.20 */
820 static HRESULT Date_getMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
821 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
822 {
823 TRACE("\n");
824
825 if(!is_class(dispex, JSCLASS_DATE)) {
826 FIXME("throw TypeError\n");
827 return E_FAIL;
828 }
829
830 if(retv) {
831 DateInstance *date = (DateInstance*)dispex;
832 DOUBLE time = local_time(date->time, date);
833
834 num_set_val(retv, min_from_time(time));
835 }
836 return S_OK;
837 }
838
839 /* ECMA-262 3rd Edition 15.9.5.21 */
840 static HRESULT Date_getUTCMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
841 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
842 {
843 TRACE("\n");
844
845 if(!is_class(dispex, JSCLASS_DATE)) {
846 FIXME("throw TypeError\n");
847 return E_FAIL;
848 }
849
850 if(retv) {
851 DateInstance *date = (DateInstance*)dispex;
852 num_set_val(retv, min_from_time(date->time));
853 }
854 return S_OK;
855 }
856
857 /* ECMA-262 3rd Edition 15.9.5.22 */
858 static HRESULT Date_getSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
859 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
860 {
861 TRACE("\n");
862
863 if(!is_class(dispex, JSCLASS_DATE)) {
864 FIXME("throw TypeError\n");
865 return E_FAIL;
866 }
867
868 if(retv) {
869 DateInstance *date = (DateInstance*)dispex;
870 DOUBLE time = local_time(date->time, date);
871
872 num_set_val(retv, sec_from_time(time));
873 }
874 return S_OK;
875 }
876
877 /* ECMA-262 3rd Edition 15.9.5.23 */
878 static HRESULT Date_getUTCSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
879 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
880 {
881 TRACE("\n");
882
883 if(!is_class(dispex, JSCLASS_DATE)) {
884 FIXME("throw TypeError\n");
885 return E_FAIL;
886 }
887
888 if(retv) {
889 DateInstance *date = (DateInstance*)dispex;
890 num_set_val(retv, sec_from_time(date->time));
891 }
892 return S_OK;
893 }
894
895 /* ECMA-262 3rd Edition 15.9.5.24 */
896 static HRESULT Date_getMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
897 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
898 {
899 TRACE("\n");
900
901 if(!is_class(dispex, JSCLASS_DATE)) {
902 FIXME("throw TypeError\n");
903 return E_FAIL;
904 }
905
906 if(retv) {
907 DateInstance *date = (DateInstance*)dispex;
908 DOUBLE time = local_time(date->time, date);
909
910 num_set_val(retv, ms_from_time(time));
911 }
912 return S_OK;
913 }
914
915 /* ECMA-262 3rd Edition 15.9.5.25 */
916 static HRESULT Date_getUTCMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
917 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
918 {
919 TRACE("\n");
920
921 if(!is_class(dispex, JSCLASS_DATE)) {
922 FIXME("throw TypeError\n");
923 return E_FAIL;
924 }
925
926 if(retv) {
927 DateInstance *date = (DateInstance*)dispex;
928 num_set_val(retv, ms_from_time(date->time));
929 }
930 return S_OK;
931 }
932
933 /* ECMA-262 3rd Edition 15.9.5.26 */
934 static HRESULT Date_getTimezoneOffset(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
935 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
936 {
937 TRACE("\n");
938
939 if(!is_class(dispex, JSCLASS_DATE)) {
940 FIXME("throw TypeError\n");
941 return E_FAIL;
942 }
943
944 if(retv) {
945 DateInstance *date = (DateInstance*)dispex;
946 num_set_val(retv, floor(
947 (date->time-local_time(date->time, date))/MS_PER_MINUTE));
948 }
949 return S_OK;
950 }
951
952 /* ECMA-262 3rd Edition 15.9.5.27 */
953 static HRESULT Date_setTime(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
954 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
955 {
956 VARIANT v;
957 HRESULT hres;
958 DateInstance *date;
959
960 TRACE("\n");
961
962 if(!is_class(dispex, JSCLASS_DATE)) {
963 FIXME("throw TypeError\n");
964 return E_FAIL;
965 }
966
967 if(!arg_cnt(dp)) {
968 FIXME("throw ArgumentNotOptional\n");
969 if(retv) num_set_nan(retv);
970 return S_OK;
971 }
972
973 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
974 if(FAILED(hres))
975 return hres;
976
977 date = (DateInstance*)dispex;
978 date->time = time_clip(num_val(&v));
979
980 if(retv)
981 num_set_val(retv, date->time);
982
983 return S_OK;
984 }
985
986 /* ECMA-262 3rd Edition 15.9.5.28 */
987 static HRESULT Date_setMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
988 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
989 {
990 VARIANT v;
991 HRESULT hres;
992 DateInstance *date;
993 DOUBLE t;
994
995 TRACE("\n");
996
997 if(!is_class(dispex, JSCLASS_DATE)) {
998 FIXME("throw TypeError\n");
999 return E_FAIL;
1000 }
1001
1002 if(!arg_cnt(dp)) {
1003 FIXME("throw ArgumentNotOptional\n");
1004 if(retv) num_set_nan(retv);
1005 return S_OK;
1006 }
1007
1008 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1009 if(FAILED(hres))
1010 return hres;
1011
1012 date = (DateInstance*)dispex;
1013 t = local_time(date->time, date);
1014 t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1015 sec_from_time(t), num_val(&v)));
1016 date->time = time_clip(utc(t, date));
1017
1018 if(retv)
1019 num_set_val(retv, date->time);
1020
1021 return S_OK;
1022 }
1023
1024 /* ECMA-262 3rd Edition 15.9.5.29 */
1025 static HRESULT Date_setUTCMilliseconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1026 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1027 {
1028 VARIANT v;
1029 HRESULT hres;
1030 DateInstance *date;
1031 DOUBLE t;
1032
1033 TRACE("\n");
1034
1035 if(!is_class(dispex, JSCLASS_DATE)) {
1036 FIXME("throw TypeError\n");
1037 return E_FAIL;
1038 }
1039
1040 if(!arg_cnt(dp)) {
1041 FIXME("throw ArgumentNotOptional\n");
1042 if(retv) num_set_nan(retv);
1043 return S_OK;
1044 }
1045
1046 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1047 if(FAILED(hres))
1048 return hres;
1049
1050 date = (DateInstance*)dispex;
1051 t = date->time;
1052 t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1053 sec_from_time(t), num_val(&v)));
1054 date->time = time_clip(t);
1055
1056 if(retv)
1057 num_set_val(retv, date->time);
1058
1059 return S_OK;
1060 }
1061
1062 /* ECMA-262 3rd Edition 15.9.5.30 */
1063 static HRESULT Date_setSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1064 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1065 {
1066 VARIANT v;
1067 HRESULT hres;
1068 DateInstance *date;
1069 DOUBLE t, sec, ms;
1070
1071 TRACE("\n");
1072
1073 if(!is_class(dispex, JSCLASS_DATE)) {
1074 FIXME("throw TypeError\n");
1075 return E_FAIL;
1076 }
1077
1078 if(!arg_cnt(dp)) {
1079 FIXME("throw ArgumentNotOptional\n");
1080 if(retv) num_set_nan(retv);
1081 return S_OK;
1082 }
1083
1084 date = (DateInstance*)dispex;
1085 t = local_time(date->time, date);
1086
1087 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1088 if(FAILED(hres))
1089 return hres;
1090 sec = num_val(&v);
1091
1092 if(arg_cnt(dp) > 1) {
1093 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1094 if(FAILED(hres))
1095 return hres;
1096 ms = num_val(&v);
1097 }
1098 else ms = ms_from_time(t);
1099
1100 t = make_date(day(t), make_time(hour_from_time(t),
1101 min_from_time(t), sec, ms));
1102 date->time = time_clip(utc(t, date));
1103
1104 if(retv)
1105 num_set_val(retv, date->time);
1106
1107 return S_OK;
1108 }
1109
1110 /* ECMA-262 3rd Edition 15.9.5.31 */
1111 static HRESULT Date_setUTCSeconds(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1112 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1113 {
1114 VARIANT v;
1115 HRESULT hres;
1116 DateInstance *date;
1117 DOUBLE t, sec, ms;
1118
1119 TRACE("\n");
1120
1121 if(!is_class(dispex, JSCLASS_DATE)) {
1122 FIXME("throw TypeError\n");
1123 return E_FAIL;
1124 }
1125
1126 if(!arg_cnt(dp)) {
1127 FIXME("throw ArgumentNotOptional\n");
1128 if(retv) num_set_nan(retv);
1129 return S_OK;
1130 }
1131
1132 date = (DateInstance*)dispex;
1133 t = date->time;
1134
1135 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1136 if(FAILED(hres))
1137 return hres;
1138 sec = num_val(&v);
1139
1140 if(arg_cnt(dp) > 1) {
1141 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1142 if(FAILED(hres))
1143 return hres;
1144 ms = num_val(&v);
1145 }
1146 else ms = ms_from_time(t);
1147
1148 t = make_date(day(t), make_time(hour_from_time(t),
1149 min_from_time(t), sec, ms));
1150 date->time = time_clip(t);
1151
1152 if(retv)
1153 num_set_val(retv, date->time);
1154
1155 return S_OK;
1156 }
1157
1158 /* ECMA-262 3rd Edition 15.9.5.33 */
1159 static HRESULT Date_setMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1160 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1161 {
1162 VARIANT v;
1163 HRESULT hres;
1164 DateInstance *date;
1165 DOUBLE t, min, sec, ms;
1166
1167 TRACE("\n");
1168
1169 if(!is_class(dispex, JSCLASS_DATE)) {
1170 FIXME("throw TypeError\n");
1171 return E_FAIL;
1172 }
1173
1174 if(!arg_cnt(dp)) {
1175 FIXME("throw ArgumentNotOptional\n");
1176 if(retv) num_set_nan(retv);
1177 return S_OK;
1178 }
1179
1180 date = (DateInstance*)dispex;
1181 t = local_time(date->time, date);
1182
1183 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1184 if(FAILED(hres))
1185 return hres;
1186 min = num_val(&v);
1187
1188 if(arg_cnt(dp) > 1) {
1189 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1190 if(FAILED(hres))
1191 return hres;
1192 sec = num_val(&v);
1193 }
1194 else sec = sec_from_time(t);
1195
1196 if(arg_cnt(dp) > 2) {
1197 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1198 if(FAILED(hres))
1199 return hres;
1200 ms = num_val(&v);
1201 }
1202 else ms = ms_from_time(t);
1203
1204 t = make_date(day(t), make_time(hour_from_time(t),
1205 min, sec, ms));
1206 date->time = time_clip(utc(t, date));
1207
1208 if(retv)
1209 num_set_val(retv, date->time);
1210
1211 return S_OK;
1212 }
1213
1214 /* ECMA-262 3rd Edition 15.9.5.34 */
1215 static HRESULT Date_setUTCMinutes(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1216 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1217 {
1218 VARIANT v;
1219 HRESULT hres;
1220 DateInstance *date;
1221 DOUBLE t, min, sec, ms;
1222
1223 TRACE("\n");
1224
1225 if(!is_class(dispex, JSCLASS_DATE)) {
1226 FIXME("throw TypeError\n");
1227 return E_FAIL;
1228 }
1229
1230 if(!arg_cnt(dp)) {
1231 FIXME("throw ArgumentNotOptional\n");
1232 if(retv) num_set_nan(retv);
1233 return S_OK;
1234 }
1235
1236 date = (DateInstance*)dispex;
1237 t = date->time;
1238
1239 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1240 if(FAILED(hres))
1241 return hres;
1242 min = num_val(&v);
1243
1244 if(arg_cnt(dp) > 1) {
1245 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1246 if(FAILED(hres))
1247 return hres;
1248 sec = num_val(&v);
1249 }
1250 else sec = sec_from_time(t);
1251
1252 if(arg_cnt(dp) > 2) {
1253 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1254 if(FAILED(hres))
1255 return hres;
1256 ms = num_val(&v);
1257 }
1258 else ms = ms_from_time(t);
1259
1260 t = make_date(day(t), make_time(hour_from_time(t),
1261 min, sec, ms));
1262 date->time = time_clip(t);
1263
1264 if(retv)
1265 num_set_val(retv, date->time);
1266
1267 return S_OK;
1268 }
1269
1270 /* ECMA-262 3rd Edition 15.9.5.35 */
1271 static HRESULT Date_setHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1272 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1273 {
1274 VARIANT v;
1275 HRESULT hres;
1276 DateInstance *date;
1277 DOUBLE t, hour, min, sec, ms;
1278
1279 TRACE("\n");
1280
1281 if(!is_class(dispex, JSCLASS_DATE)) {
1282 FIXME("throw TypeError\n");
1283 return E_FAIL;
1284 }
1285
1286 if(!arg_cnt(dp)) {
1287 FIXME("throw ArgumentNotOptional\n");
1288 if(retv) num_set_nan(retv);
1289 return S_OK;
1290 }
1291
1292 date = (DateInstance*)dispex;
1293 t = local_time(date->time, date);
1294
1295 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1296 if(FAILED(hres))
1297 return hres;
1298 hour = num_val(&v);
1299
1300 if(arg_cnt(dp) > 1) {
1301 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1302 if(FAILED(hres))
1303 return hres;
1304 min = num_val(&v);
1305 }
1306 else min = min_from_time(t);
1307
1308 if(arg_cnt(dp) > 2) {
1309 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1310 if(FAILED(hres))
1311 return hres;
1312 sec = num_val(&v);
1313 }
1314 else sec = sec_from_time(t);
1315
1316 if(arg_cnt(dp) > 3) {
1317 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &v);
1318 if(FAILED(hres))
1319 return hres;
1320 ms = num_val(&v);
1321 }
1322 else ms = ms_from_time(t);
1323
1324 t = make_date(day(t), make_time(hour, min, sec, ms));
1325 date->time = time_clip(utc(t, date));
1326
1327 if(retv)
1328 num_set_val(retv, date->time);
1329
1330 return S_OK;
1331 }
1332
1333 /* ECMA-262 3rd Edition 15.9.5.36 */
1334 static HRESULT Date_setUTCHours(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1335 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1336 {
1337 VARIANT v;
1338 HRESULT hres;
1339 DateInstance *date;
1340 DOUBLE t, hour, min, sec, ms;
1341
1342 TRACE("\n");
1343
1344 if(!is_class(dispex, JSCLASS_DATE)) {
1345 FIXME("throw TypeError\n");
1346 return E_FAIL;
1347 }
1348
1349 if(!arg_cnt(dp)) {
1350 FIXME("throw ArgumentNotOptional\n");
1351 if(retv) num_set_nan(retv);
1352 return S_OK;
1353 }
1354
1355 date = (DateInstance*)dispex;
1356 t = date->time;
1357
1358 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1359 if(FAILED(hres))
1360 return hres;
1361 hour = num_val(&v);
1362
1363 if(arg_cnt(dp) > 1) {
1364 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1365 if(FAILED(hres))
1366 return hres;
1367 min = num_val(&v);
1368 }
1369 else min = min_from_time(t);
1370
1371 if(arg_cnt(dp) > 2) {
1372 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1373 if(FAILED(hres))
1374 return hres;
1375 sec = num_val(&v);
1376 }
1377 else sec = sec_from_time(t);
1378
1379 if(arg_cnt(dp) > 3) {
1380 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &v);
1381 if(FAILED(hres))
1382 return hres;
1383 ms = num_val(&v);
1384 }
1385 else ms = ms_from_time(t);
1386
1387 t = make_date(day(t), make_time(hour, min, sec, ms));
1388 date->time = time_clip(t);
1389
1390 if(retv)
1391 num_set_val(retv, date->time);
1392
1393 return S_OK;
1394 }
1395
1396 /* ECMA-262 3rd Edition 15.9.5.36 */
1397 static HRESULT Date_setDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1398 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1399 {
1400 VARIANT v;
1401 HRESULT hres;
1402 DateInstance *date;
1403 DOUBLE t;
1404
1405 TRACE("\n");
1406
1407 if(!is_class(dispex, JSCLASS_DATE)) {
1408 FIXME("throw TypeError\n");
1409 return E_FAIL;
1410 }
1411
1412 if(!arg_cnt(dp)) {
1413 FIXME("throw ArgumentNotOptional\n");
1414 if(retv) num_set_nan(retv);
1415 return S_OK;
1416 }
1417
1418 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1419 if(FAILED(hres))
1420 return hres;
1421
1422 date = (DateInstance*)dispex;
1423 t = local_time(date->time, date);
1424 t = make_date(make_day(year_from_time(t), month_from_time(t),
1425 num_val(&v)), time_within_day(t));
1426 date->time = time_clip(utc(t, date));
1427
1428 if(retv)
1429 num_set_val(retv, date->time);
1430
1431 return S_OK;
1432 }
1433
1434 /* ECMA-262 3rd Edition 15.9.5.37 */
1435 static HRESULT Date_setUTCDate(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1436 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1437 {
1438 VARIANT v;
1439 HRESULT hres;
1440 DateInstance *date;
1441 DOUBLE t;
1442
1443 TRACE("\n");
1444
1445 if(!is_class(dispex, JSCLASS_DATE)) {
1446 FIXME("throw TypeError\n");
1447 return E_FAIL;
1448 }
1449
1450 if(!arg_cnt(dp)) {
1451 FIXME("throw ArgumentNotOptional\n");
1452 if(retv) num_set_nan(retv);
1453 return S_OK;
1454 }
1455
1456 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1457 if(FAILED(hres))
1458 return hres;
1459
1460 date = (DateInstance*)dispex;
1461 t = date->time;
1462 t = make_date(make_day(year_from_time(t), month_from_time(t),
1463 num_val(&v)), time_within_day(t));
1464 date->time = time_clip(t);
1465
1466 if(retv)
1467 num_set_val(retv, date->time);
1468
1469 return S_OK;
1470 }
1471
1472 /* ECMA-262 3rd Edition 15.9.5.38 */
1473 static HRESULT Date_setMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1474 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1475 {
1476 VARIANT v;
1477 HRESULT hres;
1478 DateInstance *date;
1479 DOUBLE t, month, ddate;
1480
1481 TRACE("\n");
1482
1483 if(!is_class(dispex, JSCLASS_DATE)) {
1484 FIXME("throw TypeError\n");
1485 return E_FAIL;
1486 }
1487
1488 if(!arg_cnt(dp)) {
1489 FIXME("throw ArgumentNotOptional\n");
1490 if(retv) num_set_nan(retv);
1491 return S_OK;
1492 }
1493
1494 date = (DateInstance*)dispex;
1495 t = local_time(date->time, date);
1496
1497 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1498 if(FAILED(hres))
1499 return hres;
1500 month = num_val(&v);
1501
1502 if(arg_cnt(dp) > 1) {
1503 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1504 if(FAILED(hres))
1505 return hres;
1506 ddate = num_val(&v);
1507 }
1508 else ddate = date_from_time(t);
1509
1510 t = make_date(make_day(year_from_time(t), month, ddate),
1511 time_within_day(t));
1512 date->time = time_clip(utc(t, date));
1513
1514 if(retv)
1515 num_set_val(retv, date->time);
1516
1517 return S_OK;
1518 }
1519
1520 /* ECMA-262 3rd Edition 15.9.5.39 */
1521 static HRESULT Date_setUTCMonth(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1522 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1523 {
1524 VARIANT v;
1525 HRESULT hres;
1526 DateInstance *date;
1527 DOUBLE t, month, ddate;
1528
1529 TRACE("\n");
1530
1531 if(!is_class(dispex, JSCLASS_DATE)) {
1532 FIXME("throw TypeError\n");
1533 return E_FAIL;
1534 }
1535
1536 if(!arg_cnt(dp)) {
1537 FIXME("throw ArgumentNotOptional\n");
1538 if(retv) num_set_nan(retv);
1539 return S_OK;
1540 }
1541
1542 date = (DateInstance*)dispex;
1543 t = date->time;
1544
1545 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1546 if(FAILED(hres))
1547 return hres;
1548 month = num_val(&v);
1549
1550 if(arg_cnt(dp) > 1) {
1551 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1552 if(FAILED(hres))
1553 return hres;
1554 ddate = num_val(&v);
1555 }
1556 else ddate = date_from_time(t);
1557
1558 t = make_date(make_day(year_from_time(t), month, ddate),
1559 time_within_day(t));
1560 date->time = time_clip(t);
1561
1562 if(retv)
1563 num_set_val(retv, date->time);
1564
1565 return S_OK;
1566 }
1567
1568 /* ECMA-262 3rd Edition 15.9.5.40 */
1569 static HRESULT Date_setFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1570 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1571 {
1572 VARIANT v;
1573 HRESULT hres;
1574 DateInstance *date;
1575 DOUBLE t, year, month, ddate;
1576
1577 TRACE("\n");
1578
1579 if(!is_class(dispex, JSCLASS_DATE)) {
1580 FIXME("throw TypeError\n");
1581 return E_FAIL;
1582 }
1583
1584 if(!arg_cnt(dp)) {
1585 FIXME("throw ArgumentNotOptional\n");
1586 if(retv) num_set_nan(retv);
1587 return S_OK;
1588 }
1589
1590 date = (DateInstance*)dispex;
1591 t = local_time(date->time, date);
1592
1593 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1594 if(FAILED(hres))
1595 return hres;
1596 year = num_val(&v);
1597
1598 if(arg_cnt(dp) > 1) {
1599 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1600 if(FAILED(hres))
1601 return hres;
1602 month = num_val(&v);
1603 }
1604 else month = month_from_time(t);
1605
1606 if(arg_cnt(dp) > 2) {
1607 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1608 if(FAILED(hres))
1609 return hres;
1610 ddate = num_val(&v);
1611 }
1612 else ddate = date_from_time(t);
1613
1614 t = make_date(make_day(year, month, ddate), time_within_day(t));
1615 date->time = time_clip(utc(t, date));
1616
1617 if(retv)
1618 num_set_val(retv, date->time);
1619
1620 return S_OK;
1621 }
1622
1623 /* ECMA-262 3rd Edition 15.9.5.41 */
1624 static HRESULT Date_setUTCFullYear(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1625 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1626 {
1627 VARIANT v;
1628 HRESULT hres;
1629 DateInstance *date;
1630 DOUBLE t, year, month, ddate;
1631
1632 TRACE("\n");
1633
1634 if(!is_class(dispex, JSCLASS_DATE)) {
1635 FIXME("throw TypeError\n");
1636 return E_FAIL;
1637 }
1638
1639 if(!arg_cnt(dp)) {
1640 FIXME("throw ArgumentNotOptional\n");
1641 if(retv) num_set_nan(retv);
1642 return S_OK;
1643 }
1644
1645 date = (DateInstance*)dispex;
1646 t = date->time;
1647
1648 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &v);
1649 if(FAILED(hres))
1650 return hres;
1651 year = num_val(&v);
1652
1653 if(arg_cnt(dp) > 1) {
1654 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &v);
1655 if(FAILED(hres))
1656 return hres;
1657 month = num_val(&v);
1658 }
1659 else month = month_from_time(t);
1660
1661 if(arg_cnt(dp) > 2) {
1662 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &v);
1663 if(FAILED(hres))
1664 return hres;
1665 ddate = num_val(&v);
1666 }
1667 else ddate = date_from_time(t);
1668
1669 t = make_date(make_day(year, month, ddate), time_within_day(t));
1670 date->time = time_clip(t);
1671
1672 if(retv)
1673 num_set_val(retv, date->time);
1674
1675 return S_OK;
1676 }
1677
1678 static HRESULT Date_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1679 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
1680 {
1681 FIXME("\n");
1682 return E_NOTIMPL;
1683 }
1684
1685 static const builtin_prop_t Date_props[] = {
1686 {getDateW, Date_getDate, PROPF_METHOD},
1687 {getDayW, Date_getDay, PROPF_METHOD},
1688 {getFullYearW, Date_getFullYear, PROPF_METHOD},
1689 {getHoursW, Date_getHours, PROPF_METHOD},
1690 {getMillisecondsW, Date_getMilliseconds, PROPF_METHOD},
1691 {getMinutesW, Date_getMinutes, PROPF_METHOD},
1692 {getMonthW, Date_getMonth, PROPF_METHOD},
1693 {getSecondsW, Date_getSeconds, PROPF_METHOD},
1694 {getTimeW, Date_getTime, PROPF_METHOD},
1695 {getTimezoneOffsetW, Date_getTimezoneOffset, PROPF_METHOD},
1696 {getUTCDateW, Date_getUTCDate, PROPF_METHOD},
1697 {getUTCDayW, Date_getUTCDay, PROPF_METHOD},
1698 {getUTCFullYearW, Date_getUTCFullYear, PROPF_METHOD},
1699 {getUTCHoursW, Date_getUTCHours, PROPF_METHOD},
1700 {getUTCMillisecondsW, Date_getUTCMilliseconds, PROPF_METHOD},
1701 {getUTCMinutesW, Date_getUTCMinutes, PROPF_METHOD},
1702 {getUTCMonthW, Date_getUTCMonth, PROPF_METHOD},
1703 {getUTCSecondsW, Date_getUTCSeconds, PROPF_METHOD},
1704 {hasOwnPropertyW, Date_hasOwnProperty, PROPF_METHOD},
1705 {isPrototypeOfW, Date_isPrototypeOf, PROPF_METHOD},
1706 {propertyIsEnumerableW, Date_propertyIsEnumerable, PROPF_METHOD},
1707 {setDateW, Date_setDate, PROPF_METHOD},
1708 {setFullYearW, Date_setFullYear, PROPF_METHOD},
1709 {setHoursW, Date_setHours, PROPF_METHOD},
1710 {setMillisecondsW, Date_setMilliseconds, PROPF_METHOD},
1711 {setMinutesW, Date_setMinutes, PROPF_METHOD},
1712 {setMonthW, Date_setMonth, PROPF_METHOD},
1713 {setSecondsW, Date_setSeconds, PROPF_METHOD},
1714 {setTimeW, Date_setTime, PROPF_METHOD},
1715 {setUTCDateW, Date_setUTCDate, PROPF_METHOD},
1716 {setUTCFullYearW, Date_setUTCFullYear, PROPF_METHOD},
1717 {setUTCHoursW, Date_setUTCHours, PROPF_METHOD},
1718 {setUTCMillisecondsW, Date_setUTCMilliseconds, PROPF_METHOD},
1719 {setUTCMinutesW, Date_setUTCMinutes, PROPF_METHOD},
1720 {setUTCMonthW, Date_setUTCMonth, PROPF_METHOD},
1721 {setUTCSecondsW, Date_setUTCSeconds, PROPF_METHOD},
1722 {toDateStringW, Date_toDateString, PROPF_METHOD},
1723 {toLocaleDateStringW, Date_toLocaleDateString, PROPF_METHOD},
1724 {toLocaleStringW, Date_toLocaleString, PROPF_METHOD},
1725 {toLocaleTimeStringW, Date_toLocaleTimeString, PROPF_METHOD},
1726 {toStringW, Date_toString, PROPF_METHOD},
1727 {toTimeStringW, Date_toTimeString, PROPF_METHOD},
1728 {toUTCStringW, Date_toUTCString, PROPF_METHOD},
1729 {valueOfW, Date_valueOf, PROPF_METHOD},
1730 };
1731
1732 static const builtin_info_t Date_info = {
1733 JSCLASS_DATE,
1734 {NULL, Date_value, 0},
1735 sizeof(Date_props)/sizeof(*Date_props),
1736 Date_props,
1737 NULL,
1738 NULL
1739 };
1740
1741 static HRESULT create_date(script_ctx_t *ctx, BOOL use_constr, DOUBLE time, DispatchEx **ret)
1742 {
1743 DateInstance *date;
1744 HRESULT hres;
1745 TIME_ZONE_INFORMATION tzi;
1746 DWORD dret;
1747
1748 dret = GetTimeZoneInformation(&tzi);
1749
1750 date = heap_alloc_zero(sizeof(DateInstance));
1751 if(!date)
1752 return E_OUTOFMEMORY;
1753
1754 if(use_constr)
1755 hres = init_dispex_from_constr(&date->dispex, ctx, &Date_info, ctx->date_constr);
1756 else
1757 hres = init_dispex(&date->dispex, ctx, &Date_info, NULL);
1758 if(FAILED(hres)) {
1759 heap_free(date);
1760 return hres;
1761 }
1762
1763 date->time = time;
1764 date->bias = tzi.Bias;
1765 date->standardDate = tzi.StandardDate;
1766 date->standardBias = tzi.StandardBias;
1767 date->daylightDate = tzi.DaylightDate;
1768 date->daylightBias = tzi.DaylightBias;
1769
1770 *ret = &date->dispex;
1771 return S_OK;
1772 }
1773
1774 static HRESULT DateConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1775 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1776 {
1777 DispatchEx *date;
1778 HRESULT hres;
1779
1780 TRACE("\n");
1781
1782 switch(flags) {
1783 case DISPATCH_CONSTRUCT:
1784 switch(arg_cnt(dp)) {
1785 /* ECMA-262 3rd Edition 15.9.3.3 */
1786 case 0: {
1787 FILETIME time;
1788 LONGLONG lltime;
1789
1790 GetSystemTimeAsFileTime(&time);
1791 lltime = ((LONGLONG)time.dwHighDateTime<<32)
1792 + time.dwLowDateTime;
1793
1794 hres = create_date(dispex->ctx, TRUE, lltime/10000-TIME_EPOCH, &date);
1795 if(FAILED(hres))
1796 return hres;
1797 break;
1798 }
1799
1800 /* ECMA-262 3rd Edition 15.9.3.2 */
1801 case 1: {
1802 VARIANT prim, num;
1803
1804 hres = to_primitive(dispex->ctx, get_arg(dp,0), ei, &prim);
1805 if(FAILED(hres))
1806 return hres;
1807
1808 if(V_VT(&prim) == VT_BSTR) {
1809 FIXME("VT_BSTR not supported\n");
1810 return E_NOTIMPL;
1811 }
1812
1813 hres = to_number(dispex->ctx, &prim, ei, &num);
1814 VariantClear(&prim);
1815 if(FAILED(hres))
1816 return hres;
1817
1818 hres = create_date(dispex->ctx, TRUE, time_clip(num_val(&num)), &date);
1819 if(FAILED(hres))
1820 return hres;
1821 break;
1822 }
1823
1824 /* ECMA-262 3rd Edition 15.9.3.1 */
1825 default: {
1826 VARIANT year, month, vdate, hours, minutes, seconds, ms;
1827 DateInstance *di;
1828 int arg_no = arg_cnt(dp), y;
1829
1830 hres = to_number(dispex->ctx, get_arg(dp, 0), ei, &year);
1831 if(FAILED(hres))
1832 return hres;
1833 y = num_val(&year);
1834 if(0<=y && y<=99)
1835 y += 1900;
1836
1837
1838 hres = to_number(dispex->ctx, get_arg(dp, 1), ei, &month);
1839 if(FAILED(hres))
1840 return hres;
1841
1842 if(arg_no>2) {
1843 hres = to_number(dispex->ctx, get_arg(dp, 2), ei, &vdate);
1844 if(FAILED(hres))
1845 return hres;
1846 }
1847 else {
1848 V_VT(&vdate) = VT_R8;
1849 V_R8(&vdate) = 1;
1850 }
1851
1852 if(arg_no>3) {
1853 hres = to_number(dispex->ctx, get_arg(dp, 3), ei, &hours);
1854 if(FAILED(hres))
1855 return hres;
1856 }
1857 else {
1858 V_VT(&hours) = VT_R8;
1859 V_R8(&hours) = 0;
1860 }
1861
1862 if(arg_no>4) {
1863 hres = to_number(dispex->ctx, get_arg(dp, 4), ei, &minutes);
1864 if(FAILED(hres))
1865 return hres;
1866 }
1867 else {
1868 V_VT(&minutes) = VT_R8;
1869 V_R8(&minutes) = 0;
1870 }
1871
1872 if(arg_no>5) {
1873 hres = to_number(dispex->ctx, get_arg(dp, 5), ei, &seconds);
1874 if(FAILED(hres))
1875 return hres;
1876 }
1877 else {
1878 V_VT(&seconds) = VT_R8;
1879 V_R8(&seconds) = 0;
1880 }
1881
1882 if(arg_no>6) {
1883 hres = to_number(dispex->ctx, get_arg(dp, 6), ei, &ms);
1884 if(FAILED(hres))
1885 return hres;
1886 }
1887 else {
1888 V_VT(&ms) = VT_R8;
1889 V_R8(&ms) = 0;
1890 }
1891
1892 hres = create_date(dispex->ctx, TRUE, time_clip(
1893 make_date(make_day(y, num_val(&month), num_val(&vdate)),
1894 make_time(num_val(&hours), num_val(&minutes),
1895 num_val(&seconds), num_val(&ms)))), &date);
1896 if(FAILED(hres))
1897 return hres;
1898
1899 di = (DateInstance*)date;
1900 di->time = utc(di->time, di);
1901 }
1902 }
1903
1904 V_VT(retv) = VT_DISPATCH;
1905 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(date);
1906 return S_OK;
1907
1908 default:
1909 FIXME("unimplemented flags %x\n", flags);
1910 return E_NOTIMPL;
1911 }
1912
1913 return S_OK;
1914 }
1915
1916 HRESULT create_date_constr(script_ctx_t *ctx, DispatchEx **ret)
1917 {
1918 DispatchEx *date;
1919 HRESULT hres;
1920
1921 hres = create_date(ctx, FALSE, 0.0, &date);
1922 if(FAILED(hres))
1923 return hres;
1924
1925 hres = create_builtin_function(ctx, DateConstr_value, PROPF_CONSTR, date, ret);
1926
1927 jsdisp_release(date);
1928 return hres;
1929 }
Windows API implementation