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