git.oblomov.eu Git - wine/blob - dlls/jscript/date.c

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