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