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)
 607 {
 608     DateInstance *date;
 609
 610     TRACE("\n");
 611
 612     if(!(date = date_this(jsthis)))
 613         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 614
 615     return dateobj_to_string(date, retv);
 616 }
 617
 618 /* ECMA-262 3rd Edition    15.9.1.5 */
 619 static HRESULT Date_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 620         VARIANT *retv, jsexcept_t *ei)
 621 {
 622     static const WCHAR NaNW[] = { 'N','a','N',0 };
 623     SYSTEMTIME st;
 624     DateInstance *date;
 625     BSTR date_str;
 626     int date_len, time_len;
 627
 628     TRACE("\n");
 629
 630     if(!(date = date_this(jsthis)))
 631         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 632
 633     if(isnan(date->time)) {
 634         if(retv) {
 635             V_VT(retv) = VT_BSTR;
 636             V_BSTR(retv) = SysAllocString(NaNW);
 637             if(!V_BSTR(retv))
 638                 return E_OUTOFMEMORY;
 639         }
 640         return S_OK;
 641     }
 642
 643     st = create_systemtime(local_time(date->time, date));
 644
 645     if(st.wYear<1601 || st.wYear>9999)
 646         return dateobj_to_string(date, retv);
 647
 648     if(retv) {
 649         date_len = GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
 650         time_len = GetTimeFormatW(ctx->lcid, 0, &st, NULL, NULL, 0);
 651         date_str = SysAllocStringLen(NULL, date_len+time_len-1);
 652         if(!date_str)
 653             return E_OUTOFMEMORY;
 654         GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, date_str, date_len);
 655         GetTimeFormatW(ctx->lcid, 0, &st, NULL, &date_str[date_len], time_len);
 656         date_str[date_len-1] = ' ';
 657
 658         V_VT(retv) = VT_BSTR;
 659         V_BSTR(retv) = date_str;
 660     }
 661     return S_OK;
 662 }
 663
 664 static HRESULT Date_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 665         VARIANT *retv, jsexcept_t *ei)
 666 {
 667     DateInstance *date;
 668
 669     TRACE("\n");
 670
 671     if(!(date = date_this(jsthis)))
 672         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 673
 674     if(retv)
 675         num_set_val(retv, date->time);
 676     return S_OK;
 677 }
 678
 679 static inline HRESULT create_utc_string(script_ctx_t *ctx, vdisp_t *jsthis,
 680         VARIANT *retv, jsexcept_t *ei)
 681 {
 682     static const WCHAR NaNW[] = { 'N','a','N',0 };
 683     static const WCHAR formatADW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ',
 684         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
 685     static const WCHAR formatBCW[] = { '%','s',',',' ','%','d',' ','%','s',' ','%','d',' ','B','.','C','.',' ',
 686         '%','0','2','d',':','%','0','2','d',':','%','0','2','d',' ','U','T','C',0 };
 687
 688     static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
 689         LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
 690         LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
 691     static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
 692         LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
 693         LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
 694         LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
 695         LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
 696         LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
 697
 698     BOOL formatAD = TRUE;
 699     BSTR week, month;
 700     DateInstance *date;
 701     BSTR date_str;
 702     int len, size, year, day;
 703     DWORD lcid_en, week_id, month_id;
 704
 705     if(!(date = date_this(jsthis)))
 706         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 707
 708     if(isnan(date->time)) {
 709         if(retv) {
 710             V_VT(retv) = VT_BSTR;
 711             V_BSTR(retv) = SysAllocString(NaNW);
 712             if(!V_BSTR(retv))
 713                 return E_OUTOFMEMORY;
 714         }
 715         return S_OK;
 716     }
 717
 718     if(retv) {
 719         len = 17;
 720
 721         lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 722
 723         week_id = week_ids[(int)week_day(date->time)];
 724         size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
 725         week = SysAllocStringLen(NULL, size);
 726         if(!week)
 727             return E_OUTOFMEMORY;
 728         GetLocaleInfoW(lcid_en, week_id, week, size);
 729         len += size-1;
 730
 731         month_id = month_ids[(int)month_from_time(date->time)];
 732         size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
 733         month = SysAllocStringLen(NULL, size);
 734         if(!month) {
 735             SysFreeString(week);
 736             return E_OUTOFMEMORY;
 737         }
 738         GetLocaleInfoW(lcid_en, month_id, month, size);
 739         len += size-1;
 740
 741         year = year_from_time(date->time);
 742         if(year<0)
 743             year = -year+1;
 744         do {
 745             year /= 10;
 746             len++;
 747         } while(year);
 748
 749         year = year_from_time(date->time);
 750         if(year<0) {
 751             formatAD = FALSE;
 752             year = -year+1;
 753             len += 5;
 754         }
 755
 756         day = date_from_time(date->time);
 757         do {
 758             day /= 10;
 759             len++;
 760         } while(day);
 761         day = date_from_time(date->time);
 762
 763         date_str = SysAllocStringLen(NULL, len);
 764         if(!date_str) {
 765             SysFreeString(week);
 766             SysFreeString(month);
 767             return E_OUTOFMEMORY;
 768         }
 769         sprintfW(date_str, formatAD?formatADW:formatBCW, week, day, month, year,
 770                 (int)hour_from_time(date->time), (int)min_from_time(date->time),
 771                 (int)sec_from_time(date->time));
 772
 773         SysFreeString(week);
 774         SysFreeString(month);
 775
 776         V_VT(retv) = VT_BSTR;
 777         V_BSTR(retv) = date_str;
 778     }
 779     return S_OK;
 780 }
 781
 782 /* ECMA-262 3rd Edition    15.9.5.42 */
 783 static HRESULT Date_toUTCString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 784         VARIANT *retv, jsexcept_t *ei)
 785 {
 786     TRACE("\n");
 787     return create_utc_string(ctx, jsthis, retv, ei);
 788 }
 789
 790 static HRESULT Date_toGMTString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 791         VARIANT *retv, jsexcept_t *ei)
 792 {
 793     TRACE("\n");
 794     return create_utc_string(ctx, jsthis, retv, ei);
 795 }
 796
 797 /* ECMA-262 3rd Edition    15.9.5.3 */
 798 static HRESULT dateobj_to_date_string(DateInstance *date, VARIANT *retv)
 799 {
 800     static const WCHAR NaNW[] = { 'N','a','N',0 };
 801     static const WCHAR formatADW[] = { '%','s',' ','%','s',' ','%','d',' ','%','d',0 };
 802     static const WCHAR formatBCW[] = { '%','s',' ','%','s',' ','%','d',' ','%','d',' ','B','.','C','.',0 };
 803
 804     static const DWORD week_ids[] = { LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1,
 805         LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4,
 806         LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6 };
 807     static const DWORD month_ids[] = { LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2,
 808         LOCALE_SABBREVMONTHNAME3, LOCALE_SABBREVMONTHNAME4,
 809         LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
 810         LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8,
 811         LOCALE_SABBREVMONTHNAME9, LOCALE_SABBREVMONTHNAME10,
 812         LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12 };
 813
 814     BOOL formatAD = TRUE;
 815     BSTR week, month;
 816     BSTR date_str;
 817     DOUBLE time;
 818     int len, size, year, day;
 819     DWORD lcid_en, week_id, month_id;
 820
 821     if(isnan(date->time)) {
 822         if(retv) {
 823             V_VT(retv) = VT_BSTR;
 824             V_BSTR(retv) = SysAllocString(NaNW);
 825             if(!V_BSTR(retv))
 826                 return E_OUTOFMEMORY;
 827         }
 828         return S_OK;
 829     }
 830
 831     time = local_time(date->time, date);
 832
 833     if(retv) {
 834         len = 5;
 835
 836         lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 837
 838         week_id = week_ids[(int)week_day(time)];
 839         size = GetLocaleInfoW(lcid_en, week_id, NULL, 0);
 840         week = SysAllocStringLen(NULL, size);
 841         if(!week)
 842             return E_OUTOFMEMORY;
 843         GetLocaleInfoW(lcid_en, week_id, week, size);
 844         len += size-1;
 845
 846         month_id = month_ids[(int)month_from_time(time)];
 847         size = GetLocaleInfoW(lcid_en, month_id, NULL, 0);
 848         month = SysAllocStringLen(NULL, size);
 849         if(!month) {
 850             SysFreeString(week);
 851             return E_OUTOFMEMORY;
 852         }
 853         GetLocaleInfoW(lcid_en, month_id, month, size);
 854         len += size-1;
 855
 856         year = year_from_time(time);
 857         if(year<0)
 858             year = -year+1;
 859         do {
 860             year /= 10;
 861             len++;
 862         } while(year);
 863
 864         year = year_from_time(time);
 865         if(year<0) {
 866             formatAD = FALSE;
 867             year = -year+1;
 868             len += 5;
 869         }
 870
 871         day = date_from_time(time);
 872         do {
 873             day /= 10;
 874             len++;
 875         } while(day);
 876         day = date_from_time(time);
 877
 878         date_str = SysAllocStringLen(NULL, len);
 879         if(!date_str) {
 880             SysFreeString(week);
 881             SysFreeString(month);
 882             return E_OUTOFMEMORY;
 883         }
 884         sprintfW(date_str, formatAD?formatADW:formatBCW, week, month, day, year);
 885
 886         SysFreeString(week);
 887         SysFreeString(month);
 888
 889         V_VT(retv) = VT_BSTR;
 890         V_BSTR(retv) = date_str;
 891     }
 892     return S_OK;
 893 }
 894
 895 static HRESULT Date_toDateString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 896         VARIANT *retv, jsexcept_t *ei)
 897 {
 898     DateInstance *date;
 899
 900     if(!(date = date_this(jsthis)))
 901         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 902
 903     return dateobj_to_date_string(date, retv);
 904 }
 905
 906 /* ECMA-262 3rd Edition    15.9.5.4 */
 907 static HRESULT Date_toTimeString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 908         VARIANT *retv, jsexcept_t *ei)
 909 {
 910     static const WCHAR NaNW[] = { 'N','a','N',0 };
 911     static const WCHAR formatW[] = { '%','0','2','d',':','%','0','2','d',':','%','0','2','d',
 912         ' ','U','T','C','%','c','%','0','2','d','%','0','2','d',0 };
 913     static const WCHAR formatUTCW[] = { '%','0','2','d',':','%','0','2','d',
 914         ':','%','0','2','d',' ','U','T','C',0 };
 915     DateInstance *date;
 916     BSTR date_str;
 917     DOUBLE time;
 918     WCHAR sign;
 919     int offset;
 920
 921     TRACE("\n");
 922
 923     if(!(date = date_this(jsthis)))
 924         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 925
 926     if(isnan(date->time)) {
 927         if(retv) {
 928             V_VT(retv) = VT_BSTR;
 929             V_BSTR(retv) = SysAllocString(NaNW);
 930             if(!V_BSTR(retv))
 931                 return E_OUTOFMEMORY;
 932         }
 933         return S_OK;
 934     }
 935
 936     time = local_time(date->time, date);
 937
 938     if(retv) {
 939         date_str = SysAllocStringLen(NULL, 17);
 940         if(!date_str)
 941             return E_OUTOFMEMORY;
 942
 943         offset = date->bias +
 944             daylight_saving_ta(time, date);
 945
 946         if(offset < 0) {
 947             sign = '+';
 948             offset = -offset;
 949         }
 950         else sign = '-';
 951
 952         if(offset)
 953             sprintfW(date_str, formatW, (int)hour_from_time(time),
 954                     (int)min_from_time(time), (int)sec_from_time(time),
 955                     sign, offset/60, offset%60);
 956         else
 957             sprintfW(date_str, formatUTCW, (int)hour_from_time(time),
 958                     (int)min_from_time(time), (int)sec_from_time(time));
 959
 960         V_VT(retv) = VT_BSTR;
 961         V_BSTR(retv) = date_str;
 962     }
 963     return S_OK;
 964 }
 965
 966 /* ECMA-262 3rd Edition    15.9.5.6 */
 967 static HRESULT Date_toLocaleDateString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 968         VARIANT *retv, jsexcept_t *ei)
 969 {
 970     static const WCHAR NaNW[] = { 'N','a','N',0 };
 971     SYSTEMTIME st;
 972     DateInstance *date;
 973     BSTR date_str;
 974     int len;
 975
 976     TRACE("\n");
 977
 978     if(!(date = date_this(jsthis)))
 979         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
 980
 981     if(isnan(date->time)) {
 982         if(retv) {
 983             V_VT(retv) = VT_BSTR;
 984             V_BSTR(retv) = SysAllocString(NaNW);
 985             if(!V_BSTR(retv))
 986                 return E_OUTOFMEMORY;
 987         }
 988         return S_OK;
 989     }
 990
 991     st = create_systemtime(local_time(date->time, date));
 992
 993     if(st.wYear<1601 || st.wYear>9999)
 994         return dateobj_to_date_string(date, retv);
 995
 996     if(retv) {
 997         len = GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, NULL, 0);
 998         date_str = SysAllocStringLen(NULL, len);
 999         if(!date_str)
1000             return E_OUTOFMEMORY;
1001         GetDateFormatW(ctx->lcid, DATE_LONGDATE, &st, NULL, date_str, len);
1002
1003         V_VT(retv) = VT_BSTR;
1004         V_BSTR(retv) = date_str;
1005     }
1006     return S_OK;
1007 }
1008
1009 /* ECMA-262 3rd Edition    15.9.5.7 */
1010 static HRESULT Date_toLocaleTimeString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1011         VARIANT *retv, jsexcept_t *ei)
1012 {
1013     static const WCHAR NaNW[] = { 'N','a','N',0 };
1014     SYSTEMTIME st;
1015     DateInstance *date;
1016     BSTR date_str;
1017     int len;
1018
1019     TRACE("\n");
1020
1021     if(!(date = date_this(jsthis)))
1022         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1023
1024     if(isnan(date->time)) {
1025         if(retv) {
1026             V_VT(retv) = VT_BSTR;
1027             V_BSTR(retv) = SysAllocString(NaNW);
1028             if(!V_BSTR(retv))
1029                 return E_OUTOFMEMORY;
1030         }
1031         return S_OK;
1032     }
1033
1034     st = create_systemtime(local_time(date->time, date));
1035
1036     if(st.wYear<1601 || st.wYear>9999)
1037         return Date_toTimeString(ctx, jsthis, flags, dp, retv, ei);
1038
1039     if(retv) {
1040         len = GetTimeFormatW(ctx->lcid, 0, &st, NULL, NULL, 0);
1041         date_str = SysAllocStringLen(NULL, len);
1042         if(!date_str)
1043             return E_OUTOFMEMORY;
1044         GetTimeFormatW(ctx->lcid, 0, &st, NULL, date_str, len);
1045
1046         V_VT(retv) = VT_BSTR;
1047         V_BSTR(retv) = date_str;
1048     }
1049     return S_OK;
1050 }
1051
1052 /* ECMA-262 3rd Edition    15.9.5.9 */
1053 static HRESULT Date_getTime(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1054         VARIANT *retv, jsexcept_t *ei)
1055 {
1056     DateInstance *date;
1057
1058     TRACE("\n");
1059
1060     if(!(date = date_this(jsthis)))
1061         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1062
1063     if(retv)
1064         num_set_val(retv, date->time);
1065     return S_OK;
1066 }
1067
1068 /* ECMA-262 3rd Edition    15.9.5.10 */
1069 static HRESULT Date_getFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1070         VARIANT *retv, jsexcept_t *ei)
1071 {
1072     DateInstance *date;
1073
1074     TRACE("\n");
1075
1076     if(!(date = date_this(jsthis)))
1077         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1078
1079     if(retv) {
1080         DOUBLE time = local_time(date->time, date);
1081
1082         num_set_val(retv, year_from_time(time));
1083     }
1084     return S_OK;
1085 }
1086
1087 /* ECMA-262 3rd Edition    15.9.5.11 */
1088 static HRESULT Date_getUTCFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1089         VARIANT *retv, jsexcept_t *ei)
1090 {
1091     DateInstance *date;
1092
1093     TRACE("\n");
1094
1095     if(!(date = date_this(jsthis)))
1096         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1097
1098     if(retv)
1099         num_set_val(retv, year_from_time(date->time));
1100     return S_OK;
1101 }
1102
1103 /* ECMA-262 3rd Edition    15.9.5.12 */
1104 static HRESULT Date_getMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1105         VARIANT *retv, jsexcept_t *ei)
1106 {
1107     DateInstance *date;
1108
1109     TRACE("\n");
1110
1111     if(!(date = date_this(jsthis)))
1112         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1113
1114     if(retv) {
1115         DOUBLE time = local_time(date->time, date);
1116
1117         num_set_val(retv, month_from_time(time));
1118     }
1119     return S_OK;
1120 }
1121
1122 /* ECMA-262 3rd Edition    15.9.5.13 */
1123 static HRESULT Date_getUTCMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1124         VARIANT *retv, jsexcept_t *ei)
1125 {
1126     DateInstance *date;
1127
1128     TRACE("\n");
1129
1130     if(!(date = date_this(jsthis)))
1131         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1132
1133     if(retv)
1134         num_set_val(retv, month_from_time(date->time));
1135     return S_OK;
1136 }
1137
1138 /* ECMA-262 3rd Edition    15.9.5.14 */
1139 static HRESULT Date_getDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1140         VARIANT *retv, jsexcept_t *ei)
1141 {
1142     DateInstance *date;
1143
1144     TRACE("\n");
1145
1146     if(!(date = date_this(jsthis)))
1147         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1148
1149     if(retv) {
1150         DOUBLE time = local_time(date->time, date);
1151
1152         num_set_val(retv, date_from_time(time));
1153     }
1154     return S_OK;
1155 }
1156
1157 /* ECMA-262 3rd Edition    15.9.5.15 */
1158 static HRESULT Date_getUTCDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1159         VARIANT *retv, jsexcept_t *ei)
1160 {
1161     DateInstance *date;
1162
1163     TRACE("\n");
1164
1165     if(!(date = date_this(jsthis)))
1166         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1167
1168     if(retv)
1169         num_set_val(retv, date_from_time(date->time));
1170     return S_OK;
1171 }
1172
1173 /* ECMA-262 3rd Edition    15.9.5.16 */
1174 static HRESULT Date_getDay(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1175         VARIANT *retv, jsexcept_t *ei)
1176 {
1177     DateInstance *date;
1178
1179     TRACE("\n");
1180
1181     if(!(date = date_this(jsthis)))
1182         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1183
1184     if(retv) {
1185         DOUBLE time = local_time(date->time, date);
1186
1187         num_set_val(retv, week_day(time));
1188     }
1189     return S_OK;
1190 }
1191
1192 /* ECMA-262 3rd Edition    15.9.5.17 */
1193 static HRESULT Date_getUTCDay(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1194         VARIANT *retv, jsexcept_t *ei)
1195 {
1196     DateInstance *date;
1197
1198     TRACE("\n");
1199
1200     if(!(date = date_this(jsthis)))
1201         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1202
1203     if(retv)
1204         num_set_val(retv, week_day(date->time));
1205     return S_OK;
1206 }
1207
1208 /* ECMA-262 3rd Edition    15.9.5.18 */
1209 static HRESULT Date_getHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1210         VARIANT *retv, jsexcept_t *ei)
1211 {
1212     DateInstance *date;
1213
1214     TRACE("\n");
1215
1216     if(!(date = date_this(jsthis)))
1217         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1218
1219     if(retv) {
1220         DOUBLE time = local_time(date->time, date);
1221
1222         num_set_val(retv, hour_from_time(time));
1223     }
1224     return S_OK;
1225 }
1226
1227 /* ECMA-262 3rd Edition    15.9.5.19 */
1228 static HRESULT Date_getUTCHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1229         VARIANT *retv, jsexcept_t *ei)
1230 {
1231     DateInstance *date;
1232
1233     TRACE("\n");
1234
1235     if(!(date = date_this(jsthis)))
1236         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1237
1238     if(retv)
1239         num_set_val(retv, hour_from_time(date->time));
1240     return S_OK;
1241 }
1242
1243 /* ECMA-262 3rd Edition    15.9.5.20 */
1244 static HRESULT Date_getMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1245         VARIANT *retv, jsexcept_t *ei)
1246 {
1247     DateInstance *date;
1248
1249     TRACE("\n");
1250
1251     if(!(date = date_this(jsthis)))
1252         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1253
1254     if(retv) {
1255         DOUBLE time = local_time(date->time, date);
1256
1257         num_set_val(retv, min_from_time(time));
1258     }
1259     return S_OK;
1260 }
1261
1262 /* ECMA-262 3rd Edition    15.9.5.21 */
1263 static HRESULT Date_getUTCMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1264         VARIANT *retv, jsexcept_t *ei)
1265 {
1266     DateInstance *date;
1267
1268     TRACE("\n");
1269
1270     if(!(date = date_this(jsthis)))
1271         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1272
1273     if(retv)
1274         num_set_val(retv, min_from_time(date->time));
1275     return S_OK;
1276 }
1277
1278 /* ECMA-262 3rd Edition    15.9.5.22 */
1279 static HRESULT Date_getSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1280         VARIANT *retv, jsexcept_t *ei)
1281 {
1282     DateInstance *date;
1283
1284     TRACE("\n");
1285
1286     if(!(date = date_this(jsthis)))
1287         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1288
1289     if(retv) {
1290         DOUBLE time = local_time(date->time, date);
1291
1292         num_set_val(retv, sec_from_time(time));
1293     }
1294     return S_OK;
1295 }
1296
1297 /* ECMA-262 3rd Edition    15.9.5.23 */
1298 static HRESULT Date_getUTCSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1299         VARIANT *retv, jsexcept_t *ei)
1300 {
1301     DateInstance *date;
1302
1303     TRACE("\n");
1304
1305     if(!(date = date_this(jsthis)))
1306         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1307
1308     if(retv)
1309         num_set_val(retv, sec_from_time(date->time));
1310     return S_OK;
1311 }
1312
1313 /* ECMA-262 3rd Edition    15.9.5.24 */
1314 static HRESULT Date_getMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1315         VARIANT *retv, jsexcept_t *ei)
1316 {
1317     DateInstance *date;
1318
1319     TRACE("\n");
1320
1321     if(!(date = date_this(jsthis)))
1322         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1323
1324     if(retv) {
1325         DOUBLE time = local_time(date->time, date);
1326
1327         num_set_val(retv, ms_from_time(time));
1328     }
1329     return S_OK;
1330 }
1331
1332 /* ECMA-262 3rd Edition    15.9.5.25 */
1333 static HRESULT Date_getUTCMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1334         VARIANT *retv, jsexcept_t *ei)
1335 {
1336     DateInstance *date;
1337
1338     TRACE("\n");
1339
1340     if(!(date = date_this(jsthis)))
1341         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1342
1343     if(retv)
1344         num_set_val(retv, ms_from_time(date->time));
1345     return S_OK;
1346 }
1347
1348 /* ECMA-262 3rd Edition    15.9.5.26 */
1349 static HRESULT Date_getTimezoneOffset(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1350         VARIANT *retv, jsexcept_t *ei)
1351 {
1352     DateInstance *date;
1353
1354     TRACE("\n");
1355
1356     if(!(date = date_this(jsthis)))
1357         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1358
1359     if(retv)
1360         num_set_val(retv, floor(
1361                     (date->time-local_time(date->time, date))/MS_PER_MINUTE));
1362     return S_OK;
1363 }
1364
1365 /* ECMA-262 3rd Edition    15.9.5.27 */
1366 static HRESULT Date_setTime(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1367         VARIANT *retv, jsexcept_t *ei)
1368 {
1369     double n;
1370     HRESULT hres;
1371     DateInstance *date;
1372
1373     TRACE("\n");
1374
1375     if(!(date = date_this(jsthis)))
1376         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1377
1378     if(!arg_cnt(dp))
1379         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1380
1381     hres = to_number(ctx, get_arg(dp, 0), ei, &n);
1382     if(FAILED(hres))
1383         return hres;
1384
1385     date->time = time_clip(n);
1386
1387     if(retv)
1388         num_set_val(retv, date->time);
1389
1390     return S_OK;
1391 }
1392
1393 /* ECMA-262 3rd Edition    15.9.5.28 */
1394 static HRESULT Date_setMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1395         VARIANT *retv, jsexcept_t *ei)
1396 {
1397     DateInstance *date;
1398     double n, t;
1399     HRESULT hres;
1400
1401     TRACE("\n");
1402
1403     if(!(date = date_this(jsthis)))
1404         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1405
1406     if(!arg_cnt(dp))
1407         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1408
1409     hres = to_number(ctx, get_arg(dp, 0), ei, &n);
1410     if(FAILED(hres))
1411         return hres;
1412
1413     t = local_time(date->time, date);
1414     t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1415                 sec_from_time(t), n));
1416     date->time = time_clip(utc(t, date));
1417
1418     if(retv)
1419         num_set_val(retv, date->time);
1420
1421     return S_OK;
1422 }
1423
1424 /* ECMA-262 3rd Edition    15.9.5.29 */
1425 static HRESULT Date_setUTCMilliseconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1426         VARIANT *retv, jsexcept_t *ei)
1427 {
1428     DateInstance *date;
1429     double n, t;
1430     HRESULT hres;
1431
1432     TRACE("\n");
1433
1434     if(!(date = date_this(jsthis)))
1435         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1436
1437     if(!arg_cnt(dp))
1438         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1439
1440     hres = to_number(ctx, get_arg(dp, 0), ei, &n);
1441     if(FAILED(hres))
1442         return hres;
1443
1444     t = date->time;
1445     t = make_date(day(t), make_time(hour_from_time(t), min_from_time(t),
1446                 sec_from_time(t), n));
1447     date->time = time_clip(t);
1448
1449     if(retv)
1450         num_set_val(retv, date->time);
1451
1452     return S_OK;
1453 }
1454
1455 /* ECMA-262 3rd Edition    15.9.5.30 */
1456 static HRESULT Date_setSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1457         VARIANT *retv, jsexcept_t *ei)
1458 {
1459     DateInstance *date;
1460     double t, sec, ms;
1461     HRESULT hres;
1462
1463     TRACE("\n");
1464
1465     if(!(date = date_this(jsthis)))
1466         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1467
1468     if(!arg_cnt(dp))
1469         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1470
1471     t = local_time(date->time, date);
1472
1473     hres = to_number(ctx, get_arg(dp, 0), ei, &sec);
1474     if(FAILED(hres))
1475         return hres;
1476
1477     if(arg_cnt(dp) > 1) {
1478         hres = to_number(ctx, get_arg(dp, 1), ei, &ms);
1479         if(FAILED(hres))
1480             return hres;
1481     }else {
1482         ms = ms_from_time(t);
1483     }
1484
1485     t = make_date(day(t), make_time(hour_from_time(t),
1486                 min_from_time(t), sec, ms));
1487     date->time = time_clip(utc(t, date));
1488
1489     if(retv)
1490         num_set_val(retv, date->time);
1491
1492     return S_OK;
1493 }
1494
1495 /* ECMA-262 3rd Edition    15.9.5.31 */
1496 static HRESULT Date_setUTCSeconds(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1497         VARIANT *retv, jsexcept_t *ei)
1498 {
1499     DateInstance *date;
1500     double t, sec, ms;
1501     HRESULT hres;
1502
1503     TRACE("\n");
1504
1505     if(!(date = date_this(jsthis)))
1506         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1507
1508     if(!arg_cnt(dp))
1509         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1510
1511     t = date->time;
1512
1513     hres = to_number(ctx, get_arg(dp, 0), ei, &sec);
1514     if(FAILED(hres))
1515         return hres;
1516
1517     if(arg_cnt(dp) > 1) {
1518         hres = to_number(ctx, get_arg(dp, 1), ei, &ms);
1519         if(FAILED(hres))
1520             return hres;
1521     }else {
1522         ms = ms_from_time(t);
1523     }
1524
1525     t = make_date(day(t), make_time(hour_from_time(t),
1526                 min_from_time(t), sec, ms));
1527     date->time = time_clip(t);
1528
1529     if(retv)
1530         num_set_val(retv, date->time);
1531
1532     return S_OK;
1533 }
1534
1535 /* ECMA-262 3rd Edition    15.9.5.33 */
1536 static HRESULT Date_setMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1537         VARIANT *retv, jsexcept_t *ei)
1538 {
1539     DateInstance *date;
1540     double t, min, sec, ms;
1541     HRESULT hres;
1542
1543     TRACE("\n");
1544
1545     if(!(date = date_this(jsthis)))
1546         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1547
1548     if(!arg_cnt(dp))
1549         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1550
1551     t = local_time(date->time, date);
1552
1553     hres = to_number(ctx, get_arg(dp, 0), ei, &min);
1554     if(FAILED(hres))
1555         return hres;
1556
1557     if(arg_cnt(dp) > 1) {
1558         hres = to_number(ctx, get_arg(dp, 1), ei, &sec);
1559         if(FAILED(hres))
1560             return hres;
1561     }else {
1562         sec = sec_from_time(t);
1563     }
1564
1565     if(arg_cnt(dp) > 2) {
1566         hres = to_number(ctx, get_arg(dp, 2), ei, &ms);
1567         if(FAILED(hres))
1568             return hres;
1569     }else {
1570         ms = ms_from_time(t);
1571     }
1572
1573     t = make_date(day(t), make_time(hour_from_time(t),
1574                 min, sec, ms));
1575     date->time = time_clip(utc(t, date));
1576
1577     if(retv)
1578         num_set_val(retv, date->time);
1579
1580     return S_OK;
1581 }
1582
1583 /* ECMA-262 3rd Edition    15.9.5.34 */
1584 static HRESULT Date_setUTCMinutes(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1585         VARIANT *retv, jsexcept_t *ei)
1586 {
1587     DateInstance *date;
1588     double t, min, sec, ms;
1589     HRESULT hres;
1590
1591     TRACE("\n");
1592
1593     if(!(date = date_this(jsthis)))
1594         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1595
1596     if(!arg_cnt(dp))
1597         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1598
1599     t = date->time;
1600
1601     hres = to_number(ctx, get_arg(dp, 0), ei, &min);
1602     if(FAILED(hres))
1603         return hres;
1604
1605     if(arg_cnt(dp) > 1) {
1606         hres = to_number(ctx, get_arg(dp, 1), ei, &sec);
1607         if(FAILED(hres))
1608             return hres;
1609     }else {
1610         sec = sec_from_time(t);
1611     }
1612
1613     if(arg_cnt(dp) > 2) {
1614         hres = to_number(ctx, get_arg(dp, 2), ei, &ms);
1615         if(FAILED(hres))
1616             return hres;
1617     }else {
1618         ms = ms_from_time(t);
1619     }
1620
1621     t = make_date(day(t), make_time(hour_from_time(t),
1622                 min, sec, ms));
1623     date->time = time_clip(t);
1624
1625     if(retv)
1626         num_set_val(retv, date->time);
1627
1628     return S_OK;
1629 }
1630
1631 /* ECMA-262 3rd Edition    15.9.5.35 */
1632 static HRESULT Date_setHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1633         VARIANT *retv, jsexcept_t *ei)
1634 {
1635     DateInstance *date;
1636     double t, hour, min, sec, ms;
1637     HRESULT hres;
1638
1639     TRACE("\n");
1640
1641     if(!(date = date_this(jsthis)))
1642         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1643
1644     if(!arg_cnt(dp))
1645         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1646
1647     t = local_time(date->time, date);
1648
1649     hres = to_number(ctx, get_arg(dp, 0), ei, &hour);
1650     if(FAILED(hres))
1651         return hres;
1652
1653     if(arg_cnt(dp) > 1) {
1654         hres = to_number(ctx, get_arg(dp, 1), ei, &min);
1655         if(FAILED(hres))
1656             return hres;
1657     }else {
1658         min = min_from_time(t);
1659     }
1660
1661     if(arg_cnt(dp) > 2) {
1662         hres = to_number(ctx, get_arg(dp, 2), ei, &sec);
1663         if(FAILED(hres))
1664             return hres;
1665     }else {
1666         sec = sec_from_time(t);
1667     }
1668
1669     if(arg_cnt(dp) > 3) {
1670         hres = to_number(ctx, get_arg(dp, 3), ei, &ms);
1671         if(FAILED(hres))
1672             return hres;
1673     }else {
1674         ms = ms_from_time(t);
1675     }
1676
1677     t = make_date(day(t), make_time(hour, min, sec, ms));
1678     date->time = time_clip(utc(t, date));
1679
1680     if(retv)
1681         num_set_val(retv, date->time);
1682
1683     return S_OK;
1684 }
1685
1686 /* ECMA-262 3rd Edition    15.9.5.36 */
1687 static HRESULT Date_setUTCHours(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1688         VARIANT *retv, jsexcept_t *ei)
1689 {
1690     DateInstance *date;
1691     double t, hour, min, sec, ms;
1692     HRESULT hres;
1693
1694     TRACE("\n");
1695
1696     if(!(date = date_this(jsthis)))
1697         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1698
1699     if(!arg_cnt(dp))
1700         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1701
1702     t = date->time;
1703
1704     hres = to_number(ctx, get_arg(dp, 0), ei, &hour);
1705     if(FAILED(hres))
1706         return hres;
1707
1708     if(arg_cnt(dp) > 1) {
1709         hres = to_number(ctx, get_arg(dp, 1), ei, &min);
1710         if(FAILED(hres))
1711             return hres;
1712     }else {
1713         min = min_from_time(t);
1714     }
1715
1716     if(arg_cnt(dp) > 2) {
1717         hres = to_number(ctx, get_arg(dp, 2), ei, &sec);
1718         if(FAILED(hres))
1719             return hres;
1720     }else {
1721         sec = sec_from_time(t);
1722     }
1723
1724     if(arg_cnt(dp) > 3) {
1725         hres = to_number(ctx, get_arg(dp, 3), ei, &ms);
1726         if(FAILED(hres))
1727             return hres;
1728     }else {
1729         ms = ms_from_time(t);
1730     }
1731
1732     t = make_date(day(t), make_time(hour, min, sec, ms));
1733     date->time = time_clip(t);
1734
1735     if(retv)
1736         num_set_val(retv, date->time);
1737
1738     return S_OK;
1739 }
1740
1741 /* ECMA-262 3rd Edition    15.9.5.36 */
1742 static HRESULT Date_setDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1743         VARIANT *retv, jsexcept_t *ei)
1744 {
1745     DateInstance *date;
1746     double t, n;
1747     HRESULT hres;
1748
1749     TRACE("\n");
1750
1751     if(!(date = date_this(jsthis)))
1752         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1753
1754     if(!arg_cnt(dp))
1755         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1756
1757     hres = to_number(ctx, get_arg(dp, 0), ei, &n);
1758     if(FAILED(hres))
1759         return hres;
1760
1761     t = local_time(date->time, date);
1762     t = make_date(make_day(year_from_time(t), month_from_time(t), n), time_within_day(t));
1763     date->time = time_clip(utc(t, date));
1764
1765     if(retv)
1766         num_set_val(retv, date->time);
1767
1768     return S_OK;
1769 }
1770
1771 /* ECMA-262 3rd Edition    15.9.5.37 */
1772 static HRESULT Date_setUTCDate(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1773         VARIANT *retv, jsexcept_t *ei)
1774 {
1775     DateInstance *date;
1776     double t, n;
1777     HRESULT hres;
1778
1779     TRACE("\n");
1780
1781     if(!(date = date_this(jsthis)))
1782         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1783
1784     if(!arg_cnt(dp))
1785         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1786
1787     hres = to_number(ctx, get_arg(dp, 0), ei, &n);
1788     if(FAILED(hres))
1789         return hres;
1790
1791     t = date->time;
1792     t = make_date(make_day(year_from_time(t), month_from_time(t), n), time_within_day(t));
1793     date->time = time_clip(t);
1794
1795     if(retv)
1796         num_set_val(retv, date->time);
1797
1798     return S_OK;
1799 }
1800
1801 /* ECMA-262 3rd Edition    15.9.5.38 */
1802 static HRESULT Date_setMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1803         VARIANT *retv, jsexcept_t *ei)
1804 {
1805     DateInstance *date;
1806     DOUBLE t, month, ddate;
1807     HRESULT hres;
1808
1809     TRACE("\n");
1810
1811     if(!(date = date_this(jsthis)))
1812         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1813
1814     if(!arg_cnt(dp))
1815         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1816
1817     t = local_time(date->time, date);
1818
1819     hres = to_number(ctx, get_arg(dp, 0), ei, &month);
1820     if(FAILED(hres))
1821         return hres;
1822
1823     if(arg_cnt(dp) > 1) {
1824         hres = to_number(ctx, get_arg(dp, 1), ei, &ddate);
1825         if(FAILED(hres))
1826             return hres;
1827     }else {
1828         ddate = date_from_time(t);
1829     }
1830
1831     t = make_date(make_day(year_from_time(t), month, ddate),
1832             time_within_day(t));
1833     date->time = time_clip(utc(t, date));
1834
1835     if(retv)
1836         num_set_val(retv, date->time);
1837
1838     return S_OK;
1839 }
1840
1841 /* ECMA-262 3rd Edition    15.9.5.39 */
1842 static HRESULT Date_setUTCMonth(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1843         VARIANT *retv, jsexcept_t *ei)
1844 {
1845     DateInstance *date;
1846     double t, month, ddate;
1847     HRESULT hres;
1848
1849     TRACE("\n");
1850
1851     if(!(date = date_this(jsthis)))
1852         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1853
1854     if(!arg_cnt(dp))
1855         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1856
1857     t = date->time;
1858
1859     hres = to_number(ctx, get_arg(dp, 0), ei, &month);
1860     if(FAILED(hres))
1861         return hres;
1862
1863     if(arg_cnt(dp) > 1) {
1864         hres = to_number(ctx, get_arg(dp, 1), ei, &ddate);
1865         if(FAILED(hres))
1866             return hres;
1867     }else {
1868         ddate = date_from_time(t);
1869     }
1870
1871     t = make_date(make_day(year_from_time(t), month, ddate),
1872             time_within_day(t));
1873     date->time = time_clip(t);
1874
1875     if(retv)
1876         num_set_val(retv, date->time);
1877
1878     return S_OK;
1879 }
1880
1881 /* ECMA-262 3rd Edition    15.9.5.40 */
1882 static HRESULT Date_setFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1883         VARIANT *retv, jsexcept_t *ei)
1884 {
1885     DateInstance *date;
1886     double t, year, month, ddate;
1887     HRESULT hres;
1888
1889     TRACE("\n");
1890
1891     if(!(date = date_this(jsthis)))
1892         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1893
1894     if(!arg_cnt(dp))
1895         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1896
1897     t = local_time(date->time, date);
1898
1899     hres = to_number(ctx, get_arg(dp, 0), ei, &year);
1900     if(FAILED(hres))
1901         return hres;
1902
1903     if(arg_cnt(dp) > 1) {
1904         hres = to_number(ctx, get_arg(dp, 1), ei, &month);
1905         if(FAILED(hres))
1906             return hres;
1907     }else {
1908         month = month_from_time(t);
1909     }
1910
1911     if(arg_cnt(dp) > 2) {
1912         hres = to_number(ctx, get_arg(dp, 2), ei, &ddate);
1913         if(FAILED(hres))
1914             return hres;
1915     }else {
1916         ddate = date_from_time(t);
1917     }
1918
1919     t = make_date(make_day(year, month, ddate), time_within_day(t));
1920     date->time = time_clip(utc(t, date));
1921
1922     if(retv)
1923         num_set_val(retv, date->time);
1924
1925     return S_OK;
1926 }
1927
1928 /* ECMA-262 3rd Edition    15.9.5.41 */
1929 static HRESULT Date_setUTCFullYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1930         VARIANT *retv, jsexcept_t *ei)
1931 {
1932     DateInstance *date;
1933     double t, year, month, ddate;
1934     HRESULT hres;
1935
1936     TRACE("\n");
1937
1938     if(!(date = date_this(jsthis)))
1939         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1940
1941     if(!arg_cnt(dp))
1942         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
1943
1944     t = date->time;
1945
1946     hres = to_number(ctx, get_arg(dp, 0), ei, &year);
1947     if(FAILED(hres))
1948         return hres;
1949
1950     if(arg_cnt(dp) > 1) {
1951         hres = to_number(ctx, get_arg(dp, 1), ei, &month);
1952         if(FAILED(hres))
1953             return hres;
1954     }else {
1955         month = month_from_time(t);
1956     }
1957
1958     if(arg_cnt(dp) > 2) {
1959         hres = to_number(ctx, get_arg(dp, 2), ei, &ddate);
1960         if(FAILED(hres))
1961             return hres;
1962     }else {
1963         ddate = date_from_time(t);
1964     }
1965
1966     t = make_date(make_day(year, month, ddate), time_within_day(t));
1967     date->time = time_clip(t);
1968
1969     if(retv)
1970         num_set_val(retv, date->time);
1971
1972     return S_OK;
1973 }
1974
1975 /* ECMA-262 3rd Edition    B2.4 */
1976 static HRESULT Date_getYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
1977         VARIANT *retv, jsexcept_t *ei)
1978 {
1979     DateInstance *date;
1980     DOUBLE t, year;
1981
1982     TRACE("\n");
1983
1984     if(!(date = date_this(jsthis)))
1985         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
1986
1987     t = local_time(date->time, date);
1988     if(isnan(t)) {
1989         if(retv)
1990             num_set_nan(retv);
1991         return S_OK;
1992     }
1993
1994     year = year_from_time(t);
1995     if(retv)
1996         num_set_val(retv, (1900<=year && year<2000)?year-1900:year);
1997
1998     return S_OK;
1999 }
2000
2001 /* ECMA-262 3rd Edition    B2.5 */
2002 static HRESULT Date_setYear(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2003         VARIANT *retv, jsexcept_t *ei)
2004 {
2005     DateInstance *date;
2006     DOUBLE t, year;
2007     HRESULT hres;
2008
2009     TRACE("\n");
2010
2011     if(!(date = date_this(jsthis)))
2012         return throw_type_error(ctx, ei, JS_E_DATE_EXPECTED, NULL);
2013
2014     if(!arg_cnt(dp))
2015         return throw_type_error(ctx, ei, JS_E_MISSING_ARG, NULL);
2016
2017     t = local_time(date->time, date);
2018
2019     hres = to_number(ctx, get_arg(dp, 0), ei, &year);
2020     if(FAILED(hres))
2021         return hres;
2022
2023     if(isnan(year)) {
2024         date->time = year;
2025         if(retv)
2026             num_set_nan(retv);
2027         return S_OK;
2028     }
2029
2030     year = year >= 0.0 ? floor(year) : -floor(-year);
2031     if(-1.0 < year && year < 100.0)
2032         year += 1900.0;
2033
2034     date->time = time_clip(utc(make_date(make_day(year, month_from_time(t), date_from_time(t)), time_within_day(t)), date));
2035
2036     if(retv)
2037         num_set_val(retv, date->time);
2038     return S_OK;
2039 }
2040
2041 static HRESULT Date_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2042         VARIANT *retv, jsexcept_t *ei)
2043 {
2044     TRACE("\n");
2045
2046     switch(flags) {
2047     case INVOKE_FUNC:
2048         return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2049     default:
2050         FIXME("unimplemented flags %x\n", flags);
2051         return E_NOTIMPL;
2052     }
2053
2054     return S_OK;
2055 }
2056
2057 static const builtin_prop_t Date_props[] = {
2058     {getDateW,               Date_getDate,               PROPF_METHOD},
2059     {getDayW,                Date_getDay,                PROPF_METHOD},
2060     {getFullYearW,           Date_getFullYear,           PROPF_METHOD},
2061     {getHoursW,              Date_getHours,              PROPF_METHOD},
2062     {getMillisecondsW,       Date_getMilliseconds,       PROPF_METHOD},
2063     {getMinutesW,            Date_getMinutes,            PROPF_METHOD},
2064     {getMonthW,              Date_getMonth,              PROPF_METHOD},
2065     {getSecondsW,            Date_getSeconds,            PROPF_METHOD},
2066     {getTimeW,               Date_getTime,               PROPF_METHOD},
2067     {getTimezoneOffsetW,     Date_getTimezoneOffset,     PROPF_METHOD},
2068     {getUTCDateW,            Date_getUTCDate,            PROPF_METHOD},
2069     {getUTCDayW,             Date_getUTCDay,             PROPF_METHOD},
2070     {getUTCFullYearW,        Date_getUTCFullYear,        PROPF_METHOD},
2071     {getUTCHoursW,           Date_getUTCHours,           PROPF_METHOD},
2072     {getUTCMillisecondsW,    Date_getUTCMilliseconds,    PROPF_METHOD},
2073     {getUTCMinutesW,         Date_getUTCMinutes,         PROPF_METHOD},
2074     {getUTCMonthW,           Date_getUTCMonth,           PROPF_METHOD},
2075     {getUTCSecondsW,         Date_getUTCSeconds,         PROPF_METHOD},
2076     {getYearW,               Date_getYear,               PROPF_METHOD},
2077     {setDateW,               Date_setDate,               PROPF_METHOD|1},
2078     {setFullYearW,           Date_setFullYear,           PROPF_METHOD|3},
2079     {setHoursW,              Date_setHours,              PROPF_METHOD|4},
2080     {setMillisecondsW,       Date_setMilliseconds,       PROPF_METHOD|1},
2081     {setMinutesW,            Date_setMinutes,            PROPF_METHOD|3},
2082     {setMonthW,              Date_setMonth,              PROPF_METHOD|2},
2083     {setSecondsW,            Date_setSeconds,            PROPF_METHOD|2},
2084     {setTimeW,               Date_setTime,               PROPF_METHOD|1},
2085     {setUTCDateW,            Date_setUTCDate,            PROPF_METHOD|1},
2086     {setUTCFullYearW,        Date_setUTCFullYear,        PROPF_METHOD|3},
2087     {setUTCHoursW,           Date_setUTCHours,           PROPF_METHOD|4},
2088     {setUTCMillisecondsW,    Date_setUTCMilliseconds,    PROPF_METHOD|1},
2089     {setUTCMinutesW,         Date_setUTCMinutes,         PROPF_METHOD|3},
2090     {setUTCMonthW,           Date_setUTCMonth,           PROPF_METHOD|2},
2091     {setUTCSecondsW,         Date_setUTCSeconds,         PROPF_METHOD|2},
2092     {setYearW,               Date_setYear,               PROPF_METHOD|1},
2093     {toDateStringW,          Date_toDateString,          PROPF_METHOD},
2094     {toGMTStringW,           Date_toGMTString,           PROPF_METHOD},
2095     {toLocaleDateStringW,    Date_toLocaleDateString,    PROPF_METHOD},
2096     {toLocaleStringW,        Date_toLocaleString,        PROPF_METHOD},
2097     {toLocaleTimeStringW,    Date_toLocaleTimeString,    PROPF_METHOD},
2098     {toStringW,              Date_toString,              PROPF_METHOD},
2099     {toTimeStringW,          Date_toTimeString,          PROPF_METHOD},
2100     {toUTCStringW,           Date_toUTCString,           PROPF_METHOD},
2101     {valueOfW,               Date_valueOf,               PROPF_METHOD},
2102 };
2103
2104 static const builtin_info_t Date_info = {
2105     JSCLASS_DATE,
2106     {NULL, Date_value, 0},
2107     sizeof(Date_props)/sizeof(*Date_props),
2108     Date_props,
2109     NULL,
2110     NULL
2111 };
2112
2113 static HRESULT create_date(script_ctx_t *ctx, jsdisp_t *object_prototype, DOUBLE time, jsdisp_t **ret)
2114 {
2115     DateInstance *date;
2116     HRESULT hres;
2117     TIME_ZONE_INFORMATION tzi;
2118
2119     GetTimeZoneInformation(&tzi);
2120
2121     date = heap_alloc_zero(sizeof(DateInstance));
2122     if(!date)
2123         return E_OUTOFMEMORY;
2124
2125     if(object_prototype)
2126         hres = init_dispex(&date->dispex, ctx, &Date_info, object_prototype);
2127     else
2128         hres = init_dispex_from_constr(&date->dispex, ctx, &Date_info, ctx->date_constr);
2129     if(FAILED(hres)) {
2130         heap_free(date);
2131         return hres;
2132     }
2133
2134     date->time = time;
2135     date->bias = tzi.Bias;
2136     date->standardDate = tzi.StandardDate;
2137     date->standardBias = tzi.StandardBias;
2138     date->daylightDate = tzi.DaylightDate;
2139     date->daylightBias = tzi.DaylightBias;
2140
2141     *ret = &date->dispex;
2142     return S_OK;
2143 }
2144
2145 static inline HRESULT date_parse(BSTR input, double *ret) {
2146     static const DWORD string_ids[] = { LOCALE_SMONTHNAME12, LOCALE_SMONTHNAME11,
2147         LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME8,
2148         LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME5,
2149         LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME2,
2150         LOCALE_SMONTHNAME1, LOCALE_SDAYNAME7, LOCALE_SDAYNAME1,
2151         LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
2152         LOCALE_SDAYNAME5, LOCALE_SDAYNAME6 };
2153     BSTR strings[sizeof(string_ids)/sizeof(DWORD)];
2154
2155     BSTR parse;
2156     int input_len, parse_len = 0, nest_level = 0, i, size;
2157     int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
2158     int ms = 0, offset = 0, hour_adjust = 0;
2159     BOOL set_year = FALSE, set_month = FALSE, set_day = FALSE, set_hour = FALSE;
2160     BOOL set_offset = FALSE, set_era = FALSE, ad = TRUE, set_am = FALSE, am = TRUE;
2161     BOOL set_hour_adjust = TRUE;
2162     TIME_ZONE_INFORMATION tzi;
2163     DateInstance di;
2164     DWORD lcid_en;
2165
2166     input_len = SysStringLen(input);
2167     for(i=0; i<input_len; i++) {
2168         if(input[i] == '(') nest_level++;
2169         else if(input[i] == ')') {
2170             nest_level--;
2171             if(nest_level<0) {
2172                 *ret = ret_nan();
2173                 return S_OK;
2174             }
2175         }
2176         else if(!nest_level) parse_len++;
2177     }
2178
2179     parse = SysAllocStringLen(NULL, parse_len);
2180     if(!parse)
2181         return E_OUTOFMEMORY;
2182     nest_level = 0;
2183     parse_len = 0;
2184     for(i=0; i<input_len; i++) {
2185         if(input[i] == '(') nest_level++;
2186         else if(input[i] == ')') nest_level--;
2187         else if(!nest_level) parse[parse_len++] = toupperW(input[i]);
2188     }
2189
2190     GetTimeZoneInformation(&tzi);
2191     di.bias = tzi.Bias;
2192     di.standardDate = tzi.StandardDate;
2193     di.standardBias = tzi.StandardBias;
2194     di.daylightDate = tzi.DaylightDate;
2195     di.daylightBias = tzi.DaylightBias;
2196
2197     lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2198     for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++) {
2199         size = GetLocaleInfoW(lcid_en, string_ids[i], NULL, 0);
2200         strings[i] = SysAllocStringLen(NULL, size);
2201         if(!strings[i]) {
2202             i--;
2203             while(i-- >= 0)
2204                 SysFreeString(strings[i]);
2205             SysFreeString(parse);
2206             return E_OUTOFMEMORY;
2207         }
2208         GetLocaleInfoW(lcid_en, string_ids[i], strings[i], size);
2209     }
2210
2211     for(i=0; i<parse_len;) {
2212         while(isspaceW(parse[i])) i++;
2213         if(parse[i] == ',') {
2214             while(parse[i] == ',') i++;
2215             continue;
2216         }
2217
2218         if(parse[i]>='0' && parse[i]<='9') {
2219             int tmp = atoiW(&parse[i]);
2220             while(parse[i]>='0' && parse[i]<='9') i++;
2221             while(isspaceW(parse[i])) i++;
2222
2223             if(parse[i] == ':') {
2224                 /* Time */
2225                 if(set_hour) break;
2226                 set_hour = TRUE;
2227
2228                 hour = tmp;
2229
2230                 while(parse[i] == ':') i++;
2231                 while(isspaceW(parse[i])) i++;
2232                 if(parse[i]>='0' && parse[i]<='9') {
2233                     min = atoiW(&parse[i]);
2234                     while(parse[i]>='0' && parse[i]<='9') i++;
2235                 }
2236
2237                 while(isspaceW(parse[i])) i++;
2238                 while(parse[i] == ':') i++;
2239                 while(isspaceW(parse[i])) i++;
2240                 if(parse[i]>='0' && parse[i]<='9') {
2241                     sec = atoiW(&parse[i]);
2242                     while(parse[i]>='0' && parse[i]<='9') i++;
2243                 }
2244             }
2245             else if(parse[i]=='-' || parse[i]=='/') {
2246                 /* Short date */
2247                 if(set_day || set_month || set_year) break;
2248                 set_day = TRUE;
2249                 set_month = TRUE;
2250                 set_year = TRUE;
2251
2252                 month = tmp-1;
2253
2254                 while(isspaceW(parse[i])) i++;
2255                 while(parse[i]=='-' || parse[i]=='/') i++;
2256                 while(isspaceW(parse[i])) i++;
2257                 if(parse[i]<'0' || parse[i]>'9') break;
2258                 day = atoiW(&parse[i]);
2259                 while(parse[i]>='0' && parse[i]<='9') i++;
2260
2261                 while(parse[i]=='-' || parse[i]=='/') i++;
2262                 while(isspaceW(parse[i])) i++;
2263                 if(parse[i]<'0' || parse[i]>'9') break;
2264                 year = atoiW(&parse[i]);
2265                 while(parse[i]>='0' && parse[i]<='9') i++;
2266             }
2267             else if(tmp<0) break;
2268             else if(tmp<70) {
2269                 /* Day */
2270                 if(set_day) break;
2271                 set_day = TRUE;
2272                 day = tmp;
2273             }
2274             else {
2275                 /* Year */
2276                 if(set_year) break;
2277                 set_year = TRUE;
2278                 year = tmp;
2279             }
2280         }
2281         else {
2282             if(parse[i]<'A' || parse[i]>'Z') break;
2283             else if(parse[i]=='B' && (parse[i+1]=='C' ||
2284                         (parse[i+1]=='.' && parse[i+2]=='C'))) {
2285                 /* AD/BC */
2286                 if(set_era) break;
2287                 set_era = TRUE;
2288                 ad = FALSE;
2289
2290                 i++;
2291                 if(parse[i] == '.') i++;
2292                 i++;
2293                 if(parse[i] == '.') i++;
2294             }
2295             else if(parse[i]=='A' && (parse[i+1]=='D' ||
2296                         (parse[i+1]=='.' && parse[i+2]=='D'))) {
2297                 /* AD/BC */
2298                 if(set_era) break;
2299                 set_era = TRUE;
2300
2301                 i++;
2302                 if(parse[i] == '.') i++;
2303                 i++;
2304                 if(parse[i] == '.') i++;
2305             }
2306             else if(parse[i+1]<'A' || parse[i+1]>'Z') {
2307                 /* Timezone */
2308                 if(set_offset) break;
2309                 set_offset = TRUE;
2310
2311                 if(parse[i] <= 'I') hour_adjust = parse[i]-'A'+2;
2312                 else if(parse[i] == 'J') break;
2313                 else if(parse[i] <= 'M') hour_adjust = parse[i]-'K'+11;
2314                 else if(parse[i] <= 'Y') hour_adjust = parse[i]-'N';
2315                 else hour_adjust = 1;
2316
2317                 i++;
2318                 if(parse[i] == '.') i++;
2319             }
2320             else if(parse[i]=='A' && parse[i+1]=='M') {
2321                 /* AM/PM */
2322                 if(set_am) break;
2323                 set_am = TRUE;
2324                 am = TRUE;
2325                 i += 2;
2326             }
2327             else if(parse[i]=='P' && parse[i+1]=='M') {
2328                 /* AM/PM */
2329                 if(set_am) break;
2330                 set_am = TRUE;
2331                 am = FALSE;
2332                 i += 2;
2333             }
2334             else if((parse[i]=='U' && parse[i+1]=='T' && parse[i+2]=='C')
2335                     || (parse[i]=='G' && parse[i+1]=='M' && parse[i+2]=='T')) {
2336                 /* Timezone */
2337                 BOOL positive = TRUE;
2338
2339                 if(set_offset) break;
2340                 set_offset = TRUE;
2341                 set_hour_adjust = FALSE;
2342
2343                 i += 3;
2344                 while(isspaceW(parse[i])) i++;
2345                 if(parse[i] == '-')  positive = FALSE;
2346                 else if(parse[i] != '+') continue;
2347
2348                 i++;
2349                 while(isspaceW(parse[i])) i++;
2350                 if(parse[i]<'0' || parse[i]>'9') break;
2351                 offset = atoiW(&parse[i]);
2352                 while(parse[i]>='0' && parse[i]<='9') i++;
2353
2354                 if(offset<24) offset *= 60;
2355                 else offset = (offset/100)*60 + offset%100;
2356
2357                 if(positive) offset = -offset;
2358             }
2359             else {
2360                 /* Month or garbage */
2361                 int j;
2362
2363                 for(size=i; parse[size]>='A' && parse[size]<='Z'; size++);
2364                 size -= i;
2365
2366                 for(j=0; j<sizeof(string_ids)/sizeof(DWORD); j++)
2367                     if(!memicmpW(&parse[i], strings[j], size)) break;
2368
2369                 if(j < 12) {
2370                     if(set_month) break;
2371                     set_month = TRUE;
2372                     month = 11-j;
2373                 }
2374                 else if(j == sizeof(string_ids)/sizeof(DWORD)) break;
2375
2376                 i += size;
2377             }
2378         }
2379     }
2380
2381     if(i == parse_len && set_year && set_month && set_day && (!set_am || hour<13)) {
2382         if(set_am) {
2383             if(hour == 12) hour = 0;
2384             if(!am) hour += 12;
2385         }
2386
2387         if(!ad) year = -year+1;
2388         else if(year<100) year += 1900;
2389
2390         *ret = time_clip(make_date(make_day(year, month, day),
2391                     make_time(hour+hour_adjust, min, sec, ms)) + offset*MS_PER_MINUTE);
2392
2393         if(set_hour_adjust)
2394             *ret = utc(*ret, &di);
2395     }else {
2396         *ret = ret_nan();
2397     }
2398
2399     for(i=0; i<sizeof(string_ids)/sizeof(DWORD); i++)
2400         SysFreeString(strings[i]);
2401     SysFreeString(parse);
2402
2403     return S_OK;
2404 }
2405
2406 static HRESULT DateConstr_parse(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2407         VARIANT *retv, jsexcept_t *ei)
2408 {
2409     BSTR parse_str;
2410     double n;
2411     HRESULT hres;
2412
2413     TRACE("\n");
2414
2415     if(!arg_cnt(dp)) {
2416         if(retv)
2417             num_set_nan(retv);
2418         return S_OK;
2419     }
2420
2421     hres = to_string(ctx, get_arg(dp,0), ei, &parse_str);
2422     if(FAILED(hres))
2423         return hres;
2424
2425     hres = date_parse(parse_str, &n);
2426     SysFreeString(parse_str);
2427     if(FAILED(hres))
2428         return hres;
2429
2430     num_set_val(retv, n);
2431     return S_OK;
2432 }
2433
2434 static HRESULT date_utc(script_ctx_t *ctx, DISPPARAMS *dp, double *ret, jsexcept_t *ei)
2435 {
2436     double year, month, vdate, hours, minutes, seconds, ms;
2437     int arg_no = arg_cnt(dp);
2438     HRESULT hres;
2439
2440     TRACE("\n");
2441
2442     if(arg_no>0) {
2443         hres = to_number(ctx, get_arg(dp, 0), ei, &year);
2444         if(FAILED(hres))
2445             return hres;
2446         if(0 <= year && year <= 99)
2447             year += 1900;
2448     }else {
2449         year = 1900;
2450     }
2451
2452     if(arg_no>1) {
2453         hres = to_number(ctx, get_arg(dp, 1), ei, &month);
2454         if(FAILED(hres))
2455             return hres;
2456     }else {
2457         month = 0;
2458     }
2459
2460     if(arg_no>2) {
2461         hres = to_number(ctx, get_arg(dp, 2), ei, &vdate);
2462         if(FAILED(hres))
2463             return hres;
2464     }else {
2465         vdate = 1;
2466     }
2467
2468     if(arg_no>3) {
2469         hres = to_number(ctx, get_arg(dp, 3), ei, &hours);
2470         if(FAILED(hres))
2471             return hres;
2472     }else {
2473         hours = 0;
2474     }
2475
2476     if(arg_no>4) {
2477         hres = to_number(ctx, get_arg(dp, 4), ei, &minutes);
2478         if(FAILED(hres))
2479             return hres;
2480     }else {
2481         minutes = 0;
2482     }
2483
2484     if(arg_no>5) {
2485         hres = to_number(ctx, get_arg(dp, 5), ei, &seconds);
2486         if(FAILED(hres))
2487             return hres;
2488     }else {
2489         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     } else {
2497         ms = 0;
2498     }
2499
2500     *ret = time_clip(make_date(make_day(year, month, vdate),
2501             make_time(hours, minutes,seconds, ms)));
2502     return S_OK;
2503 }
2504
2505 static HRESULT DateConstr_UTC(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2506         VARIANT *retv, jsexcept_t *ei)
2507 {
2508     double n;
2509     HRESULT hres;
2510
2511     TRACE("\n");
2512
2513     hres = date_utc(ctx, dp, &n, ei);
2514     if(SUCCEEDED(hres) && retv)
2515         num_set_val(retv, n);
2516     return hres;
2517 }
2518
2519 static HRESULT DateConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
2520         VARIANT *retv, jsexcept_t *ei)
2521 {
2522     jsdisp_t *date;
2523     HRESULT hres;
2524
2525     TRACE("\n");
2526
2527     switch(flags) {
2528     case DISPATCH_CONSTRUCT:
2529         switch(arg_cnt(dp)) {
2530         /* ECMA-262 3rd Edition    15.9.3.3 */
2531         case 0: {
2532             FILETIME time;
2533             LONGLONG lltime;
2534
2535             GetSystemTimeAsFileTime(&time);
2536             lltime = ((LONGLONG)time.dwHighDateTime<<32)
2537                 + time.dwLowDateTime;
2538
2539             hres = create_date(ctx, NULL, lltime/10000-TIME_EPOCH, &date);
2540             if(FAILED(hres))
2541                 return hres;
2542             break;
2543         }
2544
2545         /* ECMA-262 3rd Edition    15.9.3.2 */
2546         case 1: {
2547             VARIANT prim;
2548             double n;
2549
2550             hres = to_primitive(ctx, get_arg(dp,0), ei, &prim, NO_HINT);
2551             if(FAILED(hres))
2552                 return hres;
2553
2554             if(V_VT(&prim) == VT_BSTR)
2555                 hres = date_parse(V_BSTR(&prim), &n);
2556             else
2557                 hres = to_number(ctx, &prim, ei, &n);
2558
2559             VariantClear(&prim);
2560             if(FAILED(hres))
2561                 return hres;
2562
2563             hres = create_date(ctx, NULL, time_clip(n), &date);
2564             if(FAILED(hres))
2565                 return hres;
2566             break;
2567         }
2568
2569         /* ECMA-262 3rd Edition    15.9.3.1 */
2570         default: {
2571             double ret_date;
2572             DateInstance *di;
2573
2574             hres = date_utc(ctx, dp, &ret_date, ei);
2575             if(FAILED(hres))
2576                 return hres;
2577
2578             hres = create_date(ctx, NULL, ret_date, &date);
2579             if(FAILED(hres))
2580                 return hres;
2581
2582             di = (DateInstance*)date;
2583             di->time = utc(di->time, di);
2584         }
2585         }
2586
2587         var_set_jsdisp(retv, date);
2588         return S_OK;
2589
2590     case INVOKE_FUNC: {
2591         FILETIME system_time, local_time;
2592         LONGLONG lltime;
2593
2594         GetSystemTimeAsFileTime(&system_time);
2595         FileTimeToLocalFileTime(&system_time, &local_time);
2596         lltime = ((LONGLONG)local_time.dwHighDateTime<<32)
2597             + local_time.dwLowDateTime;
2598
2599         return date_to_string(lltime/10000-TIME_EPOCH, FALSE, 0, retv);
2600     }
2601
2602     default:
2603         FIXME("unimplemented flags %x\n", flags);
2604         return E_NOTIMPL;
2605     }
2606
2607     return S_OK;
2608 }
2609
2610 static const builtin_prop_t DateConstr_props[] = {
2611     {UTCW,    DateConstr_UTC,    PROPF_METHOD},
2612     {parseW,  DateConstr_parse,  PROPF_METHOD}
2613 };
2614
2615 static const builtin_info_t DateConstr_info = {
2616     JSCLASS_FUNCTION,
2617     {NULL, Function_value, 0},
2618     sizeof(DateConstr_props)/sizeof(*DateConstr_props),
2619     DateConstr_props,
2620     NULL,
2621     NULL
2622 };
2623
2624 HRESULT create_date_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
2625 {
2626     jsdisp_t *date;
2627     HRESULT hres;
2628
2629     static const WCHAR DateW[] = {'D','a','t','e',0};
2630
2631     hres = create_date(ctx, object_prototype, 0.0, &date);
2632     if(FAILED(hres))
2633         return hres;
2634
2635     hres = create_builtin_function(ctx, DateConstr_value, DateW, &DateConstr_info,
2636             PROPF_CONSTR|7, date, ret);
2637
2638     jsdisp_release(date);
2639     return hres;
2640 }