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