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