|
0
|
1
|
|
|
2 /* Digital Mars DMDScript source code.
|
|
|
3 * Copyright (c) 2000-2002 by Chromium Communications
|
|
|
4 * D version Copyright (c) 2004-2005 by Digital Mars
|
|
|
5 * All Rights Reserved
|
|
|
6 * written by Walter Bright
|
|
|
7 * www.digitalmars.com
|
|
|
8 * Use at your own risk. There is no warranty, express or implied.
|
|
|
9 * License for redistribution is by the GNU General Public License in gpl.txt.
|
|
|
10 *
|
|
|
11 * A binary, non-exclusive license for commercial use can be
|
|
|
12 * purchased from www.digitalmars.com/dscript/buy.html.
|
|
|
13 *
|
|
|
14 * DMDScript is implemented in the D Programming Language,
|
|
|
15 * www.digitalmars.com/d/
|
|
|
16 *
|
|
|
17 * For a C++ implementation of DMDScript, including COM support,
|
|
|
18 * see www.digitalmars.com/dscript/cppscript.html.
|
|
|
19 */
|
|
|
20
|
|
|
21
|
|
3
|
22 module dmdscript_tango.ddate;
|
|
0
|
23
|
|
|
24 import std.math;
|
|
|
25 import std.date;
|
|
|
26
|
|
3
|
27 import dmdscript_tango.script;
|
|
|
28 import dmdscript_tango.dobject;
|
|
|
29 import dmdscript_tango.value;
|
|
|
30 import dmdscript_tango.threadcontext;
|
|
|
31 import dmdscript_tango.dfunction;
|
|
|
32 import dmdscript_tango.dnative;
|
|
|
33 import dmdscript_tango.property;
|
|
|
34 import dmdscript_tango.text;
|
|
|
35 import dmdscript_tango.textgen.errmsgs;
|
|
0
|
36
|
|
|
37 version = DATETOSTRING; // use DateToString
|
|
|
38
|
|
|
39 enum TIMEFORMAT
|
|
|
40 {
|
|
|
41 String,
|
|
|
42 DateString,
|
|
|
43 TimeString,
|
|
|
44 LocaleString,
|
|
|
45 LocaleDateString,
|
|
|
46 LocaleTimeString,
|
|
|
47 UTCString,
|
|
|
48 }
|
|
|
49
|
|
|
50 d_time parseDateString(CallContext *cc, d_string s)
|
|
|
51 {
|
|
|
52 return std.date.parse(s);
|
|
|
53 }
|
|
|
54
|
|
|
55 d_string dateToString(CallContext *cc, d_time t, TIMEFORMAT tf)
|
|
|
56 { tchar[] p;
|
|
|
57
|
|
|
58 if (t == d_time_nan)
|
|
|
59 p = "Invalid Date";
|
|
|
60 else
|
|
|
61 {
|
|
|
62 switch (tf)
|
|
|
63 {
|
|
|
64 case TIMEFORMAT.String:
|
|
|
65 t = std.date.LocalTimetoUTC(t);
|
|
|
66 p = std.date.toString(t);
|
|
|
67 break;
|
|
|
68
|
|
|
69 case TIMEFORMAT.DateString:
|
|
|
70 t = std.date.LocalTimetoUTC(t);
|
|
|
71 p = std.date.toDateString(t);
|
|
|
72 break;
|
|
|
73
|
|
|
74 case TIMEFORMAT.TimeString:
|
|
|
75 t = std.date.LocalTimetoUTC(t);
|
|
|
76 p = std.date.toTimeString(t);
|
|
|
77 break;
|
|
|
78
|
|
|
79 case TIMEFORMAT.LocaleString:
|
|
|
80 //p = std.date.toLocaleString(t);
|
|
|
81 p = std.date.toString(t);
|
|
|
82 break;
|
|
|
83
|
|
|
84 case TIMEFORMAT.LocaleDateString:
|
|
|
85 //p = std.date.toLocaleDateString(t);
|
|
|
86 p = std.date.toDateString(t);
|
|
|
87 break;
|
|
|
88
|
|
|
89 case TIMEFORMAT.LocaleTimeString:
|
|
|
90 //p = std.date.toLocaleTimeString(t);
|
|
|
91 p = std.date.toTimeString(t);
|
|
|
92 break;
|
|
|
93
|
|
|
94 case TIMEFORMAT.UTCString:
|
|
|
95 p = std.date.toUTCString(t);
|
|
|
96 //p = std.date.toString(t);
|
|
|
97 break;
|
|
|
98
|
|
|
99 default:
|
|
|
100 assert(0);
|
|
|
101 }
|
|
|
102 }
|
|
|
103 return p;
|
|
|
104 }
|
|
|
105
|
|
|
106
|
|
|
107 /* ===================== Ddate.constructor functions ==================== */
|
|
|
108
|
|
|
109 void* Ddate_parse(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
110 {
|
|
|
111
|
|
|
112 // ECMA 15.9.4.2
|
|
|
113 d_string s;
|
|
|
114 d_time n;
|
|
|
115
|
|
|
116 if (arglist.length == 0)
|
|
|
117 n = d_time_nan;
|
|
|
118 else
|
|
|
119 {
|
|
|
120 s = arglist[0].toString();
|
|
|
121 n = parseDateString(cc, s);
|
|
|
122 }
|
|
|
123
|
|
|
124 ret.putVtime(n);
|
|
|
125 return null;
|
|
|
126 }
|
|
|
127
|
|
|
128 void* Ddate_UTC(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
129 {
|
|
|
130 // ECMA 15.9.4.3 - 15.9.4.10
|
|
|
131
|
|
|
132 d_time n;
|
|
|
133
|
|
|
134 d_time year;
|
|
|
135 d_time month = 0;
|
|
|
136 d_time date = 0;
|
|
|
137 d_time hours = 0;
|
|
|
138 d_time minutes = 0;
|
|
|
139 d_time seconds = 0;
|
|
|
140 d_time ms = 0;
|
|
|
141
|
|
|
142 d_time day;
|
|
|
143 d_time time = 0;
|
|
|
144
|
|
|
145 switch (arglist.length)
|
|
|
146 {
|
|
|
147 default:
|
|
|
148 case 7:
|
|
|
149 ms = arglist[6].toDtime();
|
|
|
150 case 6:
|
|
|
151 seconds = arglist[5].toDtime();
|
|
|
152 case 5:
|
|
|
153 minutes = arglist[4].toDtime();
|
|
|
154 case 4:
|
|
|
155 hours = arglist[3].toDtime();
|
|
|
156 time = std.date.MakeTime(hours, minutes, seconds, ms);
|
|
|
157 case 3:
|
|
|
158 date = arglist[2].toDtime();
|
|
|
159 case 2:
|
|
|
160 month = arglist[1].toDtime();
|
|
|
161 case 1:
|
|
|
162 year = arglist[0].toDtime();
|
|
|
163
|
|
|
164 if (year != d_time_nan && year >= 0 && year <= 99)
|
|
|
165 year += 1900;
|
|
|
166 day = std.date.MakeDay(year, month, date);
|
|
|
167 n = std.date.TimeClip(std.date.MakeDate(day,time));
|
|
|
168 break;
|
|
|
169
|
|
|
170 case 0:
|
|
|
171 n = std.date.getUTCtime();
|
|
|
172 break;
|
|
|
173 }
|
|
|
174 ret.putVtime(n);
|
|
|
175 return null;
|
|
|
176 }
|
|
|
177
|
|
|
178 /* ===================== Ddate_constructor ==================== */
|
|
|
179
|
|
|
180 class Ddate_constructor : Dfunction
|
|
|
181 {
|
|
|
182 this(ThreadContext *tc)
|
|
|
183 {
|
|
|
184 super(7, tc.Dfunction_prototype);
|
|
|
185 name = "Date";
|
|
|
186
|
|
|
187 static NativeFunctionData nfd[] =
|
|
|
188 [
|
|
|
189 { &TEXT_parse, &Ddate_parse, 1 },
|
|
|
190 { &TEXT_UTC, &Ddate_UTC, 7 },
|
|
|
191 ];
|
|
|
192
|
|
|
193 DnativeFunction.init(this, nfd, 0);
|
|
|
194 }
|
|
|
195
|
|
|
196 void *Construct(CallContext *cc, Value *ret, Value[] arglist)
|
|
|
197 {
|
|
|
198 // ECMA 15.9.3
|
|
|
199 Dobject o;
|
|
|
200 d_time n;
|
|
|
201
|
|
|
202 d_time year;
|
|
|
203 d_time month;
|
|
|
204 d_time date = 0;
|
|
|
205 d_time hours = 0;
|
|
|
206 d_time minutes = 0;
|
|
|
207 d_time seconds = 0;
|
|
|
208 d_time ms = 0;
|
|
|
209
|
|
|
210 d_time day;
|
|
|
211 d_time time = 0;
|
|
|
212
|
|
|
213 //writefln("Ddate_constructor.Construct()");
|
|
|
214 switch (arglist.length)
|
|
|
215 {
|
|
|
216 default:
|
|
|
217 case 7:
|
|
|
218 ms = arglist[6].toDtime();
|
|
|
219 case 6:
|
|
|
220 seconds = arglist[5].toDtime();
|
|
|
221 case 5:
|
|
|
222 minutes = arglist[4].toDtime();
|
|
|
223 case 4:
|
|
|
224 hours = arglist[3].toDtime();
|
|
|
225 time = std.date.MakeTime(hours, minutes, seconds, ms);
|
|
|
226 case 3:
|
|
|
227 date = arglist[2].toDtime();
|
|
|
228 case 2:
|
|
|
229 month = arglist[1].toDtime();
|
|
|
230 year = arglist[0].toDtime();
|
|
|
231
|
|
|
232 if (year != d_time_nan && year >= 0 && year <= 99)
|
|
|
233 year += 1900;
|
|
|
234 day = std.date.MakeDay(year, month, date);
|
|
|
235 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(day, time)));
|
|
|
236 break;
|
|
|
237
|
|
|
238 case 1:
|
|
|
239 arglist[0].toPrimitive(ret, null);
|
|
|
240 if (ret.getType() == TypeString)
|
|
|
241 {
|
|
|
242 n = parseDateString(cc, ret.string);
|
|
|
243 }
|
|
|
244 else
|
|
|
245 {
|
|
|
246 n = ret.toDtime();
|
|
|
247 n = std.date.TimeClip(n);
|
|
|
248 }
|
|
|
249 break;
|
|
|
250
|
|
|
251 case 0:
|
|
|
252 n = std.date.getUTCtime();
|
|
|
253 break;
|
|
|
254 }
|
|
|
255 //writefln("\tn = %s", n);
|
|
|
256 o = new Ddate(n);
|
|
|
257 ret.putVobject(o);
|
|
|
258 return null;
|
|
|
259 }
|
|
|
260
|
|
|
261 void *Call(CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
262 {
|
|
|
263 // ECMA 15.9.2
|
|
|
264 // return string as if (new Date()).toString()
|
|
|
265 d_string s;
|
|
|
266 d_time t;
|
|
|
267
|
|
|
268 version (DATETOSTRING)
|
|
|
269 {
|
|
|
270 t = std.date.getUTCtime();
|
|
|
271 t = std.date.UTCtoLocalTime(t);
|
|
|
272 s = dateToString(cc, t, TIMEFORMAT.String);
|
|
|
273 }
|
|
|
274 else
|
|
|
275 {
|
|
|
276 t = std.date.time();
|
|
|
277 s = std.date.toString(t);
|
|
|
278 }
|
|
|
279 ret.putVstring(s);
|
|
|
280 return null;
|
|
|
281 }
|
|
|
282 }
|
|
|
283
|
|
|
284
|
|
|
285 /* ===================== Ddate.prototype functions =============== */
|
|
|
286
|
|
|
287 void *checkdate(Value* ret, tchar[] name, Dobject othis)
|
|
|
288 {
|
|
|
289 ret.putVundefined();
|
|
|
290 ErrInfo errinfo;
|
|
|
291 return Dobject.RuntimeError(&errinfo, errmsgtbl[ERR_FUNCTION_WANTS_DATE],
|
|
|
292 name, othis.classname);
|
|
|
293 }
|
|
|
294
|
|
|
295 int getThisTime(Value* ret, Dobject othis, out d_time n)
|
|
|
296 { d_number x;
|
|
|
297
|
|
|
298 n = cast(d_time)othis.value.number;
|
|
|
299 ret.putVtime(n);
|
|
|
300 return (n == d_time_nan) ? 1 : 0;
|
|
|
301 }
|
|
|
302
|
|
|
303 int getThisLocalTime(Value* ret, Dobject othis, out d_time n)
|
|
|
304 { int isn = 1;
|
|
|
305
|
|
|
306 n = cast(d_time)othis.value.number;
|
|
|
307 if (n != d_time_nan)
|
|
|
308 { isn = 0;
|
|
|
309 n = std.date.UTCtoLocalTime(n);
|
|
|
310 }
|
|
|
311 ret.putVtime(n);
|
|
|
312 return isn;
|
|
|
313 }
|
|
|
314
|
|
|
315 void* Ddate_prototype_toString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
316 {
|
|
|
317 // ECMA 15.9.5.2
|
|
|
318 d_time n;
|
|
|
319 d_string s;
|
|
|
320
|
|
|
321 //writefln("Ddate_prototype_toString()");
|
|
|
322 if (!othis.isDdate())
|
|
|
323 return checkdate(ret, TEXT_toString, othis);
|
|
|
324
|
|
|
325 version (DATETOSTRING)
|
|
|
326 {
|
|
|
327 getThisLocalTime(ret, othis, n);
|
|
|
328 s = dateToString(cc, n, TIMEFORMAT.String);
|
|
|
329 }
|
|
|
330 else
|
|
|
331 {
|
|
|
332 getThisTime(ret, othis, n);
|
|
|
333 s = std.date.ToString(n);
|
|
|
334 }
|
|
|
335 ret.putVstring(s);
|
|
|
336 return null;
|
|
|
337 }
|
|
|
338
|
|
|
339 void* Ddate_prototype_toDateString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
340 {
|
|
|
341 // ECMA 15.9.5.3
|
|
|
342 d_time n;
|
|
|
343 d_string s;
|
|
|
344
|
|
|
345 if (!othis.isDdate())
|
|
|
346 return checkdate(ret, TEXT_toDateString, othis);
|
|
|
347
|
|
|
348 version (DATETOSTRING)
|
|
|
349 {
|
|
|
350 getThisLocalTime(ret, othis, n);
|
|
|
351 s = dateToString(cc, n, TIMEFORMAT.DateString);
|
|
|
352 }
|
|
|
353 else
|
|
|
354 {
|
|
|
355 getThisTime(ret, othis, n);
|
|
|
356 s = std.date.ToDateString(n);
|
|
|
357 }
|
|
|
358 ret.putVstring(s);
|
|
|
359 return null;
|
|
|
360 }
|
|
|
361
|
|
|
362 void* Ddate_prototype_toTimeString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
363 {
|
|
|
364 // ECMA 15.9.5.4
|
|
|
365 d_time n;
|
|
|
366 d_string s;
|
|
|
367
|
|
|
368 if (!othis.isDdate())
|
|
|
369 return checkdate(ret, TEXT_toTimeString, othis);
|
|
|
370
|
|
|
371 version (DATETOSTRING)
|
|
|
372 {
|
|
|
373 getThisLocalTime(ret, othis, n);
|
|
|
374 s = dateToString(cc, n, TIMEFORMAT.TimeString);
|
|
|
375 }
|
|
|
376 else
|
|
|
377 {
|
|
|
378 getThisTime(ret, othis, n);
|
|
|
379 s = std.date.ToTimeString(n);
|
|
|
380 }
|
|
|
381 //s = std.date.ToTimeString(n);
|
|
|
382 ret.putVstring(s);
|
|
|
383 return null;
|
|
|
384 }
|
|
|
385
|
|
|
386 void* Ddate_prototype_valueOf(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
387 {
|
|
|
388 // ECMA 15.9.5.3
|
|
|
389 d_time n;
|
|
|
390
|
|
|
391 if (!othis.isDdate())
|
|
|
392 return checkdate(ret, TEXT_valueOf, othis);
|
|
|
393 getThisTime(ret, othis, n);
|
|
|
394 return null;
|
|
|
395 }
|
|
|
396
|
|
|
397 void* Ddate_prototype_getTime(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
398 {
|
|
|
399 // ECMA 15.9.5.4
|
|
|
400 d_time n;
|
|
|
401
|
|
|
402 if (!othis.isDdate())
|
|
|
403 return checkdate(ret, TEXT_getTime, othis);
|
|
|
404 getThisTime(ret, othis, n);
|
|
|
405 return null;
|
|
|
406 }
|
|
|
407
|
|
|
408 void* Ddate_prototype_getYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
409 {
|
|
|
410 // ECMA 15.9.5.5
|
|
|
411 d_time n;
|
|
|
412
|
|
|
413 if (!othis.isDdate())
|
|
|
414 return checkdate(ret, TEXT_getYear, othis);
|
|
|
415
|
|
|
416 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
417 {
|
|
|
418 n = std.date.YearFromTime(n);
|
|
|
419 if (n != d_time_nan)
|
|
|
420 {
|
|
|
421 n -= 1900;
|
|
|
422 version (all) // emulate jscript bug
|
|
|
423 {
|
|
|
424 if (n < 0 || n >= 100)
|
|
|
425 n += 1900;
|
|
|
426 }
|
|
|
427 }
|
|
|
428 ret.putVtime(n);
|
|
|
429 }
|
|
|
430 return null;
|
|
|
431 }
|
|
|
432
|
|
|
433 void* Ddate_prototype_getFullYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
434 {
|
|
|
435 // ECMA 15.9.5.6
|
|
|
436 d_time n;
|
|
|
437
|
|
|
438 if (!othis.isDdate())
|
|
|
439 return checkdate(ret, TEXT_getFullYear, othis);
|
|
|
440
|
|
|
441 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
442 {
|
|
|
443 n = std.date.YearFromTime(n);
|
|
|
444 ret.putVtime(n);
|
|
|
445 }
|
|
|
446 return null;
|
|
|
447 }
|
|
|
448
|
|
|
449 void* Ddate_prototype_getUTCFullYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
450 {
|
|
|
451 // ECMA 15.9.5.7
|
|
|
452 d_time n;
|
|
|
453
|
|
|
454 if (!othis.isDdate())
|
|
|
455 return checkdate(ret, TEXT_getUTCFullYear, othis);
|
|
|
456 if (getThisTime(ret, othis, n) == 0)
|
|
|
457 {
|
|
|
458 n = std.date.YearFromTime(n);
|
|
|
459 ret.putVtime(n);
|
|
|
460 }
|
|
|
461 return null;
|
|
|
462 }
|
|
|
463
|
|
|
464 void* Ddate_prototype_getMonth(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
465 {
|
|
|
466 // ECMA 15.9.5.8
|
|
|
467 d_time n;
|
|
|
468
|
|
|
469 if (!othis.isDdate())
|
|
|
470 return checkdate(ret, TEXT_getMonth, othis);
|
|
|
471
|
|
|
472 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
473 {
|
|
|
474 n = std.date.MonthFromTime(n);
|
|
|
475 ret.putVtime(n);
|
|
|
476 }
|
|
|
477 return null;
|
|
|
478 }
|
|
|
479
|
|
|
480 void* Ddate_prototype_getUTCMonth(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
481 {
|
|
|
482 // ECMA 15.9.5.9
|
|
|
483 d_time n;
|
|
|
484
|
|
|
485 if (!othis.isDdate())
|
|
|
486 return checkdate(ret, TEXT_getUTCMonth, othis);
|
|
|
487
|
|
|
488 if (getThisTime(ret, othis, n) == 0)
|
|
|
489 {
|
|
|
490 n = std.date.MonthFromTime(n);
|
|
|
491 ret.putVtime(n);
|
|
|
492 }
|
|
|
493 return null;
|
|
|
494 }
|
|
|
495
|
|
|
496 void* Ddate_prototype_getDate(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
497 {
|
|
|
498 // ECMA 15.9.5.10
|
|
|
499 d_time n;
|
|
|
500
|
|
|
501 if (!othis.isDdate())
|
|
|
502 return checkdate(ret, TEXT_getDate, othis);
|
|
|
503
|
|
|
504 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
505 {
|
|
|
506 //printf("LocalTime = %.16g\n", n);
|
|
|
507 //printf("DaylightSavingTA(n) = %d\n", std.date.DaylightSavingTA(n));
|
|
|
508 n = std.date.DateFromTime(n);
|
|
|
509 ret.putVtime(n);
|
|
|
510 }
|
|
|
511 return null;
|
|
|
512 }
|
|
|
513
|
|
|
514 void* Ddate_prototype_getUTCDate(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
515 {
|
|
|
516 // ECMA 15.9.5.11
|
|
|
517 d_time n;
|
|
|
518
|
|
|
519 if (!othis.isDdate())
|
|
|
520 return checkdate(ret, TEXT_getUTCDate, othis);
|
|
|
521
|
|
|
522 if (getThisTime(ret, othis, n) == 0)
|
|
|
523 {
|
|
|
524 n = std.date.DateFromTime(n);
|
|
|
525 ret.putVtime(n);
|
|
|
526 }
|
|
|
527 return null;
|
|
|
528 }
|
|
|
529
|
|
|
530 void* Ddate_prototype_getDay(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
531 {
|
|
|
532 // ECMA 15.9.5.12
|
|
|
533 d_time n;
|
|
|
534
|
|
|
535 if (!othis.isDdate())
|
|
|
536 return checkdate(ret, TEXT_getDay, othis);
|
|
|
537
|
|
|
538 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
539 {
|
|
|
540 n = std.date.WeekDay(n);
|
|
|
541 ret.putVtime(n);
|
|
|
542 }
|
|
|
543 return null;
|
|
|
544 }
|
|
|
545
|
|
|
546 void* Ddate_prototype_getUTCDay(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
547 {
|
|
|
548 // ECMA 15.9.5.13
|
|
|
549 d_time n;
|
|
|
550
|
|
|
551 if (!othis.isDdate())
|
|
|
552 return checkdate(ret, TEXT_getUTCDay, othis);
|
|
|
553
|
|
|
554 if (getThisTime(ret, othis, n) == 0)
|
|
|
555 {
|
|
|
556 n = std.date.WeekDay(n);
|
|
|
557 ret.putVtime(n);
|
|
|
558 }
|
|
|
559 return null;
|
|
|
560 }
|
|
|
561
|
|
|
562 void* Ddate_prototype_getHours(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
563 {
|
|
|
564 // ECMA 15.9.5.14
|
|
|
565 d_time n;
|
|
|
566
|
|
|
567 if (!othis.isDdate())
|
|
|
568 return checkdate(ret, TEXT_getHours, othis);
|
|
|
569
|
|
|
570 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
571 {
|
|
|
572 n = std.date.HourFromTime(n);
|
|
|
573 ret.putVtime(n);
|
|
|
574 }
|
|
|
575 return null;
|
|
|
576 }
|
|
|
577
|
|
|
578 void* Ddate_prototype_getUTCHours(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
579 {
|
|
|
580 // ECMA 15.9.5.15
|
|
|
581 d_time n;
|
|
|
582
|
|
|
583 if (!othis.isDdate())
|
|
|
584 return checkdate(ret, TEXT_getUTCHours, othis);
|
|
|
585
|
|
|
586 if (getThisTime(ret, othis, n) == 0)
|
|
|
587 {
|
|
|
588 n = std.date.HourFromTime(n);
|
|
|
589 ret.putVtime(n);
|
|
|
590 }
|
|
|
591 return null;
|
|
|
592 }
|
|
|
593
|
|
|
594 void* Ddate_prototype_getMinutes(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
595 {
|
|
|
596 // ECMA 15.9.5.16
|
|
|
597 d_time n;
|
|
|
598
|
|
|
599 if (!othis.isDdate())
|
|
|
600 return checkdate(ret, TEXT_getMinutes, othis);
|
|
|
601
|
|
|
602 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
603 {
|
|
|
604 n = std.date.MinFromTime(n);
|
|
|
605 ret.putVtime(n);
|
|
|
606 }
|
|
|
607 return null;
|
|
|
608 }
|
|
|
609
|
|
|
610 void* Ddate_prototype_getUTCMinutes(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
611 {
|
|
|
612 // ECMA 15.9.5.17
|
|
|
613 d_time n;
|
|
|
614
|
|
|
615 if (!othis.isDdate())
|
|
|
616 return checkdate(ret, TEXT_getUTCMinutes, othis);
|
|
|
617
|
|
|
618 if (getThisTime(ret, othis, n) == 0)
|
|
|
619 {
|
|
|
620 n = std.date.MinFromTime(n);
|
|
|
621 ret.putVtime(n);
|
|
|
622 }
|
|
|
623 return null;
|
|
|
624 }
|
|
|
625
|
|
|
626 void* Ddate_prototype_getSeconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
627 {
|
|
|
628 // ECMA 15.9.5.18
|
|
|
629 d_time n;
|
|
|
630
|
|
|
631 if (!othis.isDdate())
|
|
|
632 return checkdate(ret, TEXT_getSeconds, othis);
|
|
|
633
|
|
|
634 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
635 {
|
|
|
636 n = std.date.SecFromTime(n);
|
|
|
637 ret.putVtime(n);
|
|
|
638 }
|
|
|
639 return null;
|
|
|
640 }
|
|
|
641
|
|
|
642 void* Ddate_prototype_getUTCSeconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
643 {
|
|
|
644 // ECMA 15.9.5.19
|
|
|
645 d_time n;
|
|
|
646
|
|
|
647 if (!othis.isDdate())
|
|
|
648 return checkdate(ret, TEXT_getUTCSeconds, othis);
|
|
|
649
|
|
|
650 if (getThisTime(ret, othis, n) == 0)
|
|
|
651 {
|
|
|
652 n = std.date.SecFromTime(n);
|
|
|
653 ret.putVtime(n);
|
|
|
654 }
|
|
|
655 return null;
|
|
|
656 }
|
|
|
657
|
|
|
658 void* Ddate_prototype_getMilliseconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
659 {
|
|
|
660 // ECMA 15.9.5.20
|
|
|
661 d_time n;
|
|
|
662
|
|
|
663 if (!othis.isDdate())
|
|
|
664 return checkdate(ret, TEXT_getMilliseconds, othis);
|
|
|
665
|
|
|
666 if (getThisLocalTime(ret, othis, n) == 0)
|
|
|
667 {
|
|
|
668 n = std.date.msFromTime(n);
|
|
|
669 ret.putVtime(n);
|
|
|
670 }
|
|
|
671 return null;
|
|
|
672 }
|
|
|
673
|
|
|
674 void* Ddate_prototype_getUTCMilliseconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
675 {
|
|
|
676 // ECMA 15.9.5.21
|
|
|
677 d_time n;
|
|
|
678
|
|
|
679 if (!othis.isDdate())
|
|
|
680 return checkdate(ret, TEXT_getUTCMilliseconds, othis);
|
|
|
681
|
|
|
682 if (getThisTime(ret, othis, n) == 0)
|
|
|
683 {
|
|
|
684 n = std.date.msFromTime(n);
|
|
|
685 ret.putVtime(n);
|
|
|
686 }
|
|
|
687 return null;
|
|
|
688 }
|
|
|
689
|
|
|
690 void* Ddate_prototype_getTimezoneOffset(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
691 {
|
|
|
692 // ECMA 15.9.5.22
|
|
|
693 d_time n;
|
|
|
694
|
|
|
695 if (!othis.isDdate())
|
|
|
696 return checkdate(ret, TEXT_getTimezoneOffset, othis);
|
|
|
697
|
|
|
698 if (getThisTime(ret, othis, n) == 0)
|
|
|
699 {
|
|
|
700 n = (n - std.date.UTCtoLocalTime(n)) / (60 * 1000);
|
|
|
701 ret.putVtime(n);
|
|
|
702 }
|
|
|
703 return null;
|
|
|
704 }
|
|
|
705
|
|
|
706 void* Ddate_prototype_setTime(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
707 {
|
|
|
708 // ECMA 15.9.5.23
|
|
|
709 d_time n;
|
|
|
710
|
|
|
711 if (!othis.isDdate())
|
|
|
712 return checkdate(ret, TEXT_setTime, othis);
|
|
|
713
|
|
|
714 if (!arglist.length)
|
|
|
715 n = d_time_nan;
|
|
|
716 else
|
|
|
717 n = arglist[0].toDtime();
|
|
|
718 n = std.date.TimeClip(n);
|
|
|
719 othis.value.putVtime(n);
|
|
|
720 ret.putVtime(n);
|
|
|
721 return null;
|
|
|
722 }
|
|
|
723
|
|
|
724 void* Ddate_prototype_setMilliseconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
725 {
|
|
|
726 // ECMA 15.9.5.24
|
|
|
727
|
|
|
728 d_time ms;
|
|
|
729 d_time t;
|
|
|
730 d_time time;
|
|
|
731 d_time n;
|
|
|
732
|
|
|
733 if (!othis.isDdate())
|
|
|
734 return checkdate(ret, TEXT_setMilliseconds, othis);
|
|
|
735
|
|
|
736 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
737 {
|
|
|
738 if (!arglist.length)
|
|
|
739 ms = d_time_nan;
|
|
|
740 else
|
|
|
741 ms = arglist[0].toDtime();
|
|
|
742 time = std.date.MakeTime(std.date.HourFromTime(t), std.date.MinFromTime(t), std.date.SecFromTime(t), ms);
|
|
|
743 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(std.date.Day(t),time)));
|
|
|
744 othis.value.putVtime(n);
|
|
|
745 ret.putVtime(n);
|
|
|
746 }
|
|
|
747 return null;
|
|
|
748 }
|
|
|
749
|
|
|
750 void* Ddate_prototype_setUTCMilliseconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
751 {
|
|
|
752 // ECMA 15.9.5.25
|
|
|
753 d_time ms;
|
|
|
754 d_time t;
|
|
|
755 d_time time;
|
|
|
756 d_time n;
|
|
|
757
|
|
|
758 if (!othis.isDdate())
|
|
|
759 return checkdate(ret, TEXT_setUTCMilliseconds, othis);
|
|
|
760
|
|
|
761 if (getThisTime(ret, othis, t) == 0)
|
|
|
762 {
|
|
|
763 if (!arglist.length)
|
|
|
764 ms = d_time_nan;
|
|
|
765 else
|
|
|
766 ms = arglist[0].toDtime();
|
|
|
767 time = std.date.MakeTime(std.date.HourFromTime(t), std.date.MinFromTime(t), std.date.SecFromTime(t), ms);
|
|
|
768 n = std.date.TimeClip(std.date.MakeDate(std.date.Day(t),time));
|
|
|
769 othis.value.putVtime(n);
|
|
|
770 ret.putVtime(n);
|
|
|
771 }
|
|
|
772 return null;
|
|
|
773 }
|
|
|
774
|
|
|
775 void* Ddate_prototype_setSeconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
776 {
|
|
|
777 // ECMA 15.9.5.26
|
|
|
778 d_time ms;
|
|
|
779 d_time seconds;
|
|
|
780 d_time t;
|
|
|
781 d_time time;
|
|
|
782 d_time n;
|
|
|
783
|
|
|
784 if (!othis.isDdate())
|
|
|
785 return checkdate(ret, TEXT_setSeconds, othis);
|
|
|
786
|
|
|
787 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
788 {
|
|
|
789 switch (arglist.length)
|
|
|
790 {
|
|
|
791 default:
|
|
|
792 case 2:
|
|
|
793 ms = arglist[1].toDtime();
|
|
|
794 seconds = arglist[0].toDtime();
|
|
|
795 break;
|
|
|
796
|
|
|
797 case 1:
|
|
|
798 ms = std.date.msFromTime(t);
|
|
|
799 seconds = arglist[0].toDtime();
|
|
|
800 break;
|
|
|
801
|
|
|
802 case 0:
|
|
|
803 ms = std.date.msFromTime(t);
|
|
|
804 seconds = d_time_nan;
|
|
|
805 break;
|
|
|
806 }
|
|
|
807 time = std.date.MakeTime(std.date.HourFromTime(t), std.date.MinFromTime(t), seconds, ms);
|
|
|
808 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(std.date.Day(t),time)));
|
|
|
809 othis.value.putVtime(n);
|
|
|
810 ret.putVtime(n);
|
|
|
811 }
|
|
|
812 return null;
|
|
|
813 }
|
|
|
814
|
|
|
815 void* Ddate_prototype_setUTCSeconds(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
816 {
|
|
|
817 // ECMA 15.9.5.27
|
|
|
818 d_time ms;
|
|
|
819 d_time seconds;
|
|
|
820 d_time t;
|
|
|
821 d_time time;
|
|
|
822 d_time n;
|
|
|
823
|
|
|
824 if (!othis.isDdate())
|
|
|
825 return checkdate(ret, TEXT_setUTCSeconds, othis);
|
|
|
826
|
|
|
827 if (getThisTime(ret, othis, t) == 0)
|
|
|
828 {
|
|
|
829 switch (arglist.length)
|
|
|
830 {
|
|
|
831 default:
|
|
|
832 case 2:
|
|
|
833 ms = arglist[1].toDtime();
|
|
|
834 seconds = arglist[0].toDtime();
|
|
|
835 break;
|
|
|
836
|
|
|
837 case 1:
|
|
|
838 ms = std.date.msFromTime(t);
|
|
|
839 seconds = arglist[0].toDtime();
|
|
|
840 break;
|
|
|
841
|
|
|
842 case 0:
|
|
|
843 ms = std.date.msFromTime(t);
|
|
|
844 seconds = d_time_nan;
|
|
|
845 break;
|
|
|
846 }
|
|
|
847 time = std.date.MakeTime(std.date.HourFromTime(t), std.date.MinFromTime(t), seconds, ms);
|
|
|
848 n = std.date.TimeClip(std.date.MakeDate(std.date.Day(t),time));
|
|
|
849 othis.value.putVtime(n);
|
|
|
850 ret.putVtime(n);
|
|
|
851 }
|
|
|
852 return null;
|
|
|
853 }
|
|
|
854
|
|
|
855 void* Ddate_prototype_setMinutes(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
856 {
|
|
|
857 // ECMA 15.9.5.28
|
|
|
858 d_time ms;
|
|
|
859 d_time seconds;
|
|
|
860 d_time minutes;
|
|
|
861 d_time t;
|
|
|
862 d_time time;
|
|
|
863 d_time n;
|
|
|
864
|
|
|
865 if (!othis.isDdate())
|
|
|
866 return checkdate(ret, TEXT_setMinutes, othis);
|
|
|
867
|
|
|
868 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
869 {
|
|
|
870 switch (arglist.length)
|
|
|
871 {
|
|
|
872 default:
|
|
|
873 case 3:
|
|
|
874 ms = arglist[2].toDtime();
|
|
|
875 seconds = arglist[1].toDtime();
|
|
|
876 minutes = arglist[0].toDtime();
|
|
|
877 break;
|
|
|
878
|
|
|
879 case 2:
|
|
|
880 ms = std.date.msFromTime(t);
|
|
|
881 seconds = arglist[1].toDtime();
|
|
|
882 minutes = arglist[0].toDtime();
|
|
|
883 break;
|
|
|
884
|
|
|
885 case 1:
|
|
|
886 ms = std.date.msFromTime(t);
|
|
|
887 seconds = std.date.SecFromTime(t);
|
|
|
888 minutes = arglist[0].toDtime();
|
|
|
889 break;
|
|
|
890
|
|
|
891 case 0:
|
|
|
892 ms = std.date.msFromTime(t);
|
|
|
893 seconds = std.date.SecFromTime(t);
|
|
|
894 minutes = d_time_nan;
|
|
|
895 break;
|
|
|
896 }
|
|
|
897 time = std.date.MakeTime(std.date.HourFromTime(t), minutes, seconds, ms);
|
|
|
898 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(std.date.Day(t),time)));
|
|
|
899 othis.value.putVtime(n);
|
|
|
900 ret.putVtime(n);
|
|
|
901 }
|
|
|
902 return null;
|
|
|
903 }
|
|
|
904
|
|
|
905 void* Ddate_prototype_setUTCMinutes(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
906 {
|
|
|
907 // ECMA 15.9.5.29
|
|
|
908 d_time ms;
|
|
|
909 d_time seconds;
|
|
|
910 d_time minutes;
|
|
|
911 d_time t;
|
|
|
912 d_time time;
|
|
|
913 d_time n;
|
|
|
914
|
|
|
915 if (!othis.isDdate())
|
|
|
916 return checkdate(ret, TEXT_setUTCMinutes, othis);
|
|
|
917
|
|
|
918 if (getThisTime(ret, othis, t) == 0)
|
|
|
919 {
|
|
|
920 switch (arglist.length)
|
|
|
921 {
|
|
|
922 default:
|
|
|
923 case 3:
|
|
|
924 ms = arglist[2].toDtime();
|
|
|
925 seconds = arglist[1].toDtime();
|
|
|
926 minutes = arglist[0].toDtime();
|
|
|
927 break;
|
|
|
928
|
|
|
929 case 2:
|
|
|
930 ms = std.date.msFromTime(t);
|
|
|
931 seconds = arglist[1].toDtime();
|
|
|
932 minutes = arglist[0].toDtime();
|
|
|
933 break;
|
|
|
934
|
|
|
935 case 1:
|
|
|
936 ms = std.date.msFromTime(t);
|
|
|
937 seconds = std.date.SecFromTime(t);
|
|
|
938 minutes = arglist[0].toDtime();
|
|
|
939 break;
|
|
|
940
|
|
|
941 case 0:
|
|
|
942 ms = std.date.msFromTime(t);
|
|
|
943 seconds = std.date.SecFromTime(t);
|
|
|
944 minutes = d_time_nan;
|
|
|
945 break;
|
|
|
946 }
|
|
|
947 time = std.date.MakeTime(std.date.HourFromTime(t), minutes, seconds, ms);
|
|
|
948 n = std.date.TimeClip(std.date.MakeDate(std.date.Day(t),time));
|
|
|
949 othis.value.putVtime(n);
|
|
|
950 ret.putVtime(n);
|
|
|
951 }
|
|
|
952 return null;
|
|
|
953 }
|
|
|
954
|
|
|
955 void* Ddate_prototype_setHours(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
956 {
|
|
|
957 // ECMA 15.9.5.30
|
|
|
958 d_time ms;
|
|
|
959 d_time seconds;
|
|
|
960 d_time minutes;
|
|
|
961 d_time hours;
|
|
|
962 d_time t;
|
|
|
963 d_time time;
|
|
|
964 d_time n;
|
|
|
965
|
|
|
966 if (!othis.isDdate())
|
|
|
967 return checkdate(ret, TEXT_setHours, othis);
|
|
|
968
|
|
|
969 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
970 {
|
|
|
971 switch (arglist.length)
|
|
|
972 {
|
|
|
973 default:
|
|
|
974 case 4:
|
|
|
975 ms = arglist[3].toDtime();
|
|
|
976 seconds = arglist[2].toDtime();
|
|
|
977 minutes = arglist[1].toDtime();
|
|
|
978 hours = arglist[0].toDtime();
|
|
|
979 break;
|
|
|
980
|
|
|
981 case 3:
|
|
|
982 ms = std.date.msFromTime(t);
|
|
|
983 seconds = arglist[2].toDtime();
|
|
|
984 minutes = arglist[1].toDtime();
|
|
|
985 hours = arglist[0].toDtime();
|
|
|
986 break;
|
|
|
987
|
|
|
988 case 2:
|
|
|
989 ms = std.date.msFromTime(t);
|
|
|
990 seconds = std.date.SecFromTime(t);
|
|
|
991 minutes = arglist[1].toDtime();
|
|
|
992 hours = arglist[0].toDtime();
|
|
|
993 break;
|
|
|
994
|
|
|
995 case 1:
|
|
|
996 ms = std.date.msFromTime(t);
|
|
|
997 seconds = std.date.SecFromTime(t);
|
|
|
998 minutes = std.date.MinFromTime(t);
|
|
|
999 hours = arglist[0].toDtime();
|
|
|
1000 break;
|
|
|
1001
|
|
|
1002 case 0:
|
|
|
1003 ms = std.date.msFromTime(t);
|
|
|
1004 seconds = std.date.SecFromTime(t);
|
|
|
1005 minutes = std.date.MinFromTime(t);
|
|
|
1006 hours = d_time_nan;
|
|
|
1007 break;
|
|
|
1008 }
|
|
|
1009 time = std.date.MakeTime(hours, minutes, seconds, ms);
|
|
|
1010 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(std.date.Day(t),time)));
|
|
|
1011 othis.value.putVtime(n);
|
|
|
1012 ret.putVtime(n);
|
|
|
1013 }
|
|
|
1014 return null;
|
|
|
1015 }
|
|
|
1016
|
|
|
1017 void* Ddate_prototype_setUTCHours(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1018 {
|
|
|
1019 // ECMA 15.9.5.31
|
|
|
1020 d_time ms;
|
|
|
1021 d_time seconds;
|
|
|
1022 d_time minutes;
|
|
|
1023 d_time hours;
|
|
|
1024 d_time t;
|
|
|
1025 d_time time;
|
|
|
1026 d_time n;
|
|
|
1027
|
|
|
1028 if (!othis.isDdate())
|
|
|
1029 return checkdate(ret, TEXT_setUTCHours, othis);
|
|
|
1030
|
|
|
1031 if (getThisTime(ret, othis, t) == 0)
|
|
|
1032 {
|
|
|
1033 switch (arglist.length)
|
|
|
1034 {
|
|
|
1035 default:
|
|
|
1036 case 4:
|
|
|
1037 ms = arglist[3].toDtime();
|
|
|
1038 seconds = arglist[2].toDtime();
|
|
|
1039 minutes = arglist[1].toDtime();
|
|
|
1040 hours = arglist[0].toDtime();
|
|
|
1041 break;
|
|
|
1042
|
|
|
1043 case 3:
|
|
|
1044 ms = std.date.msFromTime(t);
|
|
|
1045 seconds = arglist[2].toDtime();
|
|
|
1046 minutes = arglist[1].toDtime();
|
|
|
1047 hours = arglist[0].toDtime();
|
|
|
1048 break;
|
|
|
1049
|
|
|
1050 case 2:
|
|
|
1051 ms = std.date.msFromTime(t);
|
|
|
1052 seconds = std.date.SecFromTime(t);
|
|
|
1053 minutes = arglist[1].toDtime();
|
|
|
1054 hours = arglist[0].toDtime();
|
|
|
1055 break;
|
|
|
1056
|
|
|
1057 case 1:
|
|
|
1058 ms = std.date.msFromTime(t);
|
|
|
1059 seconds = std.date.SecFromTime(t);
|
|
|
1060 minutes = std.date.MinFromTime(t);
|
|
|
1061 hours = arglist[0].toDtime();
|
|
|
1062 break;
|
|
|
1063
|
|
|
1064 case 0:
|
|
|
1065 ms = std.date.msFromTime(t);
|
|
|
1066 seconds = std.date.SecFromTime(t);
|
|
|
1067 minutes = std.date.MinFromTime(t);
|
|
|
1068 hours = d_time_nan;
|
|
|
1069 break;
|
|
|
1070 }
|
|
|
1071 time = std.date.MakeTime(hours, minutes, seconds, ms);
|
|
|
1072 n = std.date.TimeClip(std.date.MakeDate(std.date.Day(t),time));
|
|
|
1073 othis.value.putVtime(n);
|
|
|
1074 ret.putVtime(n);
|
|
|
1075 }
|
|
|
1076 return null;
|
|
|
1077 }
|
|
|
1078
|
|
|
1079 void* Ddate_prototype_setDate(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1080 {
|
|
|
1081 // ECMA 15.9.5.32
|
|
|
1082 d_time date;
|
|
|
1083 d_time t;
|
|
|
1084 d_time day;
|
|
|
1085 d_time n;
|
|
|
1086
|
|
|
1087 if (!othis.isDdate())
|
|
|
1088 return checkdate(ret, TEXT_setDate, othis);
|
|
|
1089
|
|
|
1090 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
1091 {
|
|
|
1092 if (!arglist.length)
|
|
|
1093 date = d_time_nan;
|
|
|
1094 else
|
|
|
1095 date = arglist[0].toDtime();
|
|
|
1096 day = std.date.MakeDay(std.date.YearFromTime(t), std.date.MonthFromTime(t), date);
|
|
|
1097 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(day, std.date.TimeWithinDay(t))));
|
|
|
1098 othis.value.putVtime(n);
|
|
|
1099 ret.putVtime(n);
|
|
|
1100 }
|
|
|
1101 return null;
|
|
|
1102 }
|
|
|
1103
|
|
|
1104 void* Ddate_prototype_setUTCDate(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1105 {
|
|
|
1106 // ECMA 15.9.5.33
|
|
|
1107 d_time date;
|
|
|
1108 d_time t;
|
|
|
1109 d_time day;
|
|
|
1110 d_time n;
|
|
|
1111
|
|
|
1112 if (!othis.isDdate())
|
|
|
1113 return checkdate(ret, TEXT_setUTCDate, othis);
|
|
|
1114
|
|
|
1115 if (getThisTime(ret, othis, t) == 0)
|
|
|
1116 {
|
|
|
1117 if (!arglist.length)
|
|
|
1118 date = d_time_nan;
|
|
|
1119 else
|
|
|
1120 date = arglist[0].toDtime();
|
|
|
1121 day = std.date.MakeDay(std.date.YearFromTime(t), std.date.MonthFromTime(t), date);
|
|
|
1122 n = std.date.TimeClip(std.date.MakeDate(day, std.date.TimeWithinDay(t)));
|
|
|
1123 othis.value.putVtime(n);
|
|
|
1124 ret.putVtime(n);
|
|
|
1125 }
|
|
|
1126 return null;
|
|
|
1127 }
|
|
|
1128
|
|
|
1129 void* Ddate_prototype_setMonth(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1130 {
|
|
|
1131 // ECMA 15.9.5.34
|
|
|
1132 d_time date;
|
|
|
1133 d_time month;
|
|
|
1134 d_time t;
|
|
|
1135 d_time day;
|
|
|
1136 d_time n;
|
|
|
1137
|
|
|
1138 if (!othis.isDdate())
|
|
|
1139 return checkdate(ret, TEXT_setMonth, othis);
|
|
|
1140
|
|
|
1141 if (getThisLocalTime(ret, othis, t) == 0)
|
|
|
1142 {
|
|
|
1143 switch (arglist.length)
|
|
|
1144 { default:
|
|
|
1145 case 2:
|
|
|
1146 month = arglist[0].toDtime();
|
|
|
1147 date = arglist[1].toDtime();
|
|
|
1148 break;
|
|
|
1149
|
|
|
1150 case 1:
|
|
|
1151 month = arglist[0].toDtime();
|
|
|
1152 date = std.date.DateFromTime(t);
|
|
|
1153 break;
|
|
|
1154
|
|
|
1155 case 0:
|
|
|
1156 month = d_time_nan;
|
|
|
1157 date = std.date.DateFromTime(t);
|
|
|
1158 break;
|
|
|
1159 }
|
|
|
1160 day = std.date.MakeDay(std.date.YearFromTime(t), month, date);
|
|
|
1161 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(day, std.date.TimeWithinDay(t))));
|
|
|
1162 othis.value.putVtime(n);
|
|
|
1163 ret.putVtime(n);
|
|
|
1164 }
|
|
|
1165 return null;
|
|
|
1166 }
|
|
|
1167
|
|
|
1168 void* Ddate_prototype_setUTCMonth(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1169 {
|
|
|
1170 // ECMA 15.9.5.35
|
|
|
1171 d_time date;
|
|
|
1172 d_time month;
|
|
|
1173 d_time t;
|
|
|
1174 d_time day;
|
|
|
1175 d_time n;
|
|
|
1176
|
|
|
1177 if (!othis.isDdate())
|
|
|
1178 return checkdate(ret, TEXT_setUTCMonth, othis);
|
|
|
1179
|
|
|
1180 if (getThisTime(ret, othis, t) == 0)
|
|
|
1181 {
|
|
|
1182 switch (arglist.length)
|
|
|
1183 { default:
|
|
|
1184 case 2:
|
|
|
1185 month = arglist[0].toDtime();
|
|
|
1186 date = arglist[1].toDtime();
|
|
|
1187 break;
|
|
|
1188
|
|
|
1189 case 1:
|
|
|
1190 month = arglist[0].toDtime();
|
|
|
1191 date = std.date.DateFromTime(t);
|
|
|
1192 break;
|
|
|
1193
|
|
|
1194 case 0:
|
|
|
1195 month = d_time_nan;
|
|
|
1196 date = std.date.DateFromTime(t);
|
|
|
1197 break;
|
|
|
1198 }
|
|
|
1199 day = std.date.MakeDay(std.date.YearFromTime(t), month, date);
|
|
|
1200 n = std.date.TimeClip(std.date.MakeDate(day, std.date.TimeWithinDay(t)));
|
|
|
1201 othis.value.putVtime(n);
|
|
|
1202 ret.putVtime(n);
|
|
|
1203 }
|
|
|
1204 return null;
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 void* Ddate_prototype_setFullYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1208 {
|
|
|
1209 // ECMA 15.9.5.36
|
|
|
1210 d_time date;
|
|
|
1211 d_time month;
|
|
|
1212 d_time year;
|
|
|
1213 d_time t;
|
|
|
1214 d_time day;
|
|
|
1215 d_time n;
|
|
|
1216
|
|
|
1217 if (!othis.isDdate())
|
|
|
1218 return checkdate(ret, TEXT_setFullYear, othis);
|
|
|
1219
|
|
|
1220 if (getThisLocalTime(ret, othis, t))
|
|
|
1221 t = 0;
|
|
|
1222
|
|
|
1223 switch (arglist.length)
|
|
|
1224 { default:
|
|
|
1225 case 3:
|
|
|
1226 date = arglist[2].toDtime();
|
|
|
1227 month = arglist[1].toDtime();
|
|
|
1228 year = arglist[0].toDtime();
|
|
|
1229 break;
|
|
|
1230
|
|
|
1231 case 2:
|
|
|
1232 date = std.date.DateFromTime(t);
|
|
|
1233 month = arglist[1].toDtime();
|
|
|
1234 year = arglist[0].toDtime();
|
|
|
1235 break;
|
|
|
1236
|
|
|
1237 case 1:
|
|
|
1238 date = std.date.DateFromTime(t);
|
|
|
1239 month = std.date.MonthFromTime(t);
|
|
|
1240 year = arglist[0].toDtime();
|
|
|
1241 break;
|
|
|
1242
|
|
|
1243 case 0:
|
|
|
1244 date = std.date.DateFromTime(t);
|
|
|
1245 month = std.date.MonthFromTime(t);
|
|
|
1246 year = d_time_nan;
|
|
|
1247 break;
|
|
|
1248 }
|
|
|
1249 day = std.date.MakeDay(year, month, date);
|
|
|
1250 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(day, std.date.TimeWithinDay(t))));
|
|
|
1251 othis.value.putVtime(n);
|
|
|
1252 ret.putVtime(n);
|
|
|
1253 return null;
|
|
|
1254 }
|
|
|
1255
|
|
|
1256 void* Ddate_prototype_setUTCFullYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1257 {
|
|
|
1258 // ECMA 15.9.5.37
|
|
|
1259 d_time date;
|
|
|
1260 d_time month;
|
|
|
1261 d_time year;
|
|
|
1262 d_time t;
|
|
|
1263 d_time day;
|
|
|
1264 d_time n;
|
|
|
1265
|
|
|
1266 if (!othis.isDdate())
|
|
|
1267 return checkdate(ret, TEXT_setUTCFullYear, othis);
|
|
|
1268
|
|
|
1269 getThisTime(ret, othis, t);
|
|
|
1270 if (t == d_time_nan)
|
|
|
1271 t = 0;
|
|
|
1272 switch (arglist.length)
|
|
|
1273 { default:
|
|
|
1274 case 3:
|
|
|
1275 month = arglist[2].toDtime();
|
|
|
1276 date = arglist[1].toDtime();
|
|
|
1277 year = arglist[0].toDtime();
|
|
|
1278 break;
|
|
|
1279
|
|
|
1280 case 2:
|
|
|
1281 month = std.date.MonthFromTime(t);
|
|
|
1282 date = arglist[1].toDtime();
|
|
|
1283 year = arglist[0].toDtime();
|
|
|
1284 break;
|
|
|
1285
|
|
|
1286 case 1:
|
|
|
1287 month = std.date.MonthFromTime(t);
|
|
|
1288 date = std.date.DateFromTime(t);
|
|
|
1289 year = arglist[0].toDtime();
|
|
|
1290 break;
|
|
|
1291
|
|
|
1292 case 0:
|
|
|
1293 month = std.date.MonthFromTime(t);
|
|
|
1294 date = std.date.DateFromTime(t);
|
|
|
1295 year = d_time_nan;
|
|
|
1296 break;
|
|
|
1297 }
|
|
|
1298 day = std.date.MakeDay(year, month, date);
|
|
|
1299 n = std.date.TimeClip(std.date.MakeDate(day, std.date.TimeWithinDay(t)));
|
|
|
1300 othis.value.putVtime(n);
|
|
|
1301 ret.putVtime(n);
|
|
|
1302 return null;
|
|
|
1303 }
|
|
|
1304
|
|
|
1305 void* Ddate_prototype_setYear(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1306 {
|
|
|
1307 // ECMA 15.9.5.38
|
|
|
1308 d_time date;
|
|
|
1309 d_time month;
|
|
|
1310 d_time year;
|
|
|
1311 d_time t;
|
|
|
1312 d_time day;
|
|
|
1313 d_time n;
|
|
|
1314
|
|
|
1315 if (!othis.isDdate())
|
|
|
1316 return checkdate(ret, TEXT_setYear, othis);
|
|
|
1317
|
|
|
1318 if (getThisLocalTime(ret, othis, t))
|
|
|
1319 t = 0;
|
|
|
1320 switch (arglist.length)
|
|
|
1321 { default:
|
|
|
1322 case 1:
|
|
|
1323 month = std.date.MonthFromTime(t);
|
|
|
1324 date = std.date.DateFromTime(t);
|
|
|
1325 year = arglist[0].toDtime();
|
|
|
1326 if (0 <= year && year <= 99)
|
|
|
1327 year += 1900;
|
|
|
1328 day = std.date.MakeDay(year, month, date);
|
|
|
1329 n = std.date.TimeClip(std.date.LocalTimetoUTC(std.date.MakeDate(day, std.date.TimeWithinDay(t))));
|
|
|
1330 break;
|
|
|
1331
|
|
|
1332 case 0:
|
|
|
1333 n = d_time_nan;
|
|
|
1334 break;
|
|
|
1335 }
|
|
|
1336 othis.value.putVtime(n);
|
|
|
1337 ret.putVtime(n);
|
|
|
1338 return null;
|
|
|
1339 }
|
|
|
1340
|
|
|
1341 void* Ddate_prototype_toLocaleString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1342 {
|
|
|
1343 // ECMA 15.9.5.39
|
|
|
1344 d_string s;
|
|
|
1345 d_time t;
|
|
|
1346
|
|
|
1347 if (!othis.isDdate())
|
|
|
1348 return checkdate(ret, TEXT_toLocaleString, othis);
|
|
|
1349
|
|
|
1350 if (getThisLocalTime(ret, othis, t))
|
|
|
1351 t = 0;
|
|
|
1352
|
|
|
1353 s = dateToString(cc, t, TIMEFORMAT.LocaleString);
|
|
|
1354 ret.putVstring(s);
|
|
|
1355 return null;
|
|
|
1356 }
|
|
|
1357
|
|
|
1358 void* Ddate_prototype_toLocaleDateString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1359 {
|
|
|
1360 // ECMA 15.9.5.6
|
|
|
1361 d_string s;
|
|
|
1362 d_time t;
|
|
|
1363
|
|
|
1364 if (!othis.isDdate())
|
|
|
1365 return checkdate(ret, TEXT_toLocaleDateString, othis);
|
|
|
1366
|
|
|
1367 if (getThisLocalTime(ret, othis, t))
|
|
|
1368 t = 0;
|
|
|
1369
|
|
|
1370 s = dateToString(cc, t, TIMEFORMAT.LocaleDateString);
|
|
|
1371 ret.putVstring(s);
|
|
|
1372 return null;
|
|
|
1373 }
|
|
|
1374
|
|
|
1375 void* Ddate_prototype_toLocaleTimeString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1376 {
|
|
|
1377 // ECMA 15.9.5.7
|
|
|
1378 d_string s;
|
|
|
1379 d_time t;
|
|
|
1380
|
|
|
1381 if (!othis.isDdate())
|
|
|
1382 return checkdate(ret, TEXT_toLocaleTimeString, othis);
|
|
|
1383
|
|
|
1384 if (getThisLocalTime(ret, othis, t))
|
|
|
1385 t = 0;
|
|
|
1386 s = dateToString(cc, t, TIMEFORMAT.LocaleTimeString);
|
|
|
1387 ret.putVstring(s);
|
|
|
1388 return null;
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 void* Ddate_prototype_toUTCString(Dobject pthis, CallContext *cc, Dobject othis, Value* ret, Value[] arglist)
|
|
|
1392 {
|
|
|
1393 // ECMA 15.9.5.40
|
|
|
1394 d_string s;
|
|
|
1395 d_time t;
|
|
|
1396
|
|
|
1397 if (!othis.isDdate())
|
|
|
1398 return checkdate(ret, TEXT_toUTCString, othis);
|
|
|
1399
|
|
|
1400 if (getThisTime(ret, othis, t))
|
|
|
1401 t = 0;
|
|
|
1402 s = dateToString(cc, t, TIMEFORMAT.UTCString);
|
|
|
1403 ret.putVstring(s);
|
|
|
1404 return null;
|
|
|
1405 }
|
|
|
1406
|
|
|
1407 /* ===================== Ddate_prototype ==================== */
|
|
|
1408
|
|
|
1409 class Ddate_prototype : Ddate
|
|
|
1410 {
|
|
|
1411 this(ThreadContext *tc)
|
|
|
1412 {
|
|
|
1413 super(tc.Dobject_prototype);
|
|
|
1414
|
|
|
1415 Dobject f = tc.Dfunction_prototype;
|
|
|
1416
|
|
|
1417 Put(TEXT_constructor, tc.Ddate_constructor, DontEnum);
|
|
|
1418
|
|
|
1419 static NativeFunctionData nfd[] =
|
|
|
1420 [
|
|
|
1421 { &TEXT_toString, &Ddate_prototype_toString, 0 },
|
|
|
1422 { &TEXT_toDateString, &Ddate_prototype_toDateString, 0 },
|
|
|
1423 { &TEXT_toTimeString, &Ddate_prototype_toTimeString, 0 },
|
|
|
1424 { &TEXT_valueOf, &Ddate_prototype_valueOf, 0 },
|
|
|
1425 { &TEXT_getTime, &Ddate_prototype_getTime, 0 },
|
|
|
1426 //{ &TEXT_getVarDate, &Ddate_prototype_getVarDate, 0 },
|
|
|
1427 { &TEXT_getYear, &Ddate_prototype_getYear, 0 },
|
|
|
1428 { &TEXT_getFullYear, &Ddate_prototype_getFullYear, 0 },
|
|
|
1429 { &TEXT_getUTCFullYear, &Ddate_prototype_getUTCFullYear, 0 },
|
|
|
1430 { &TEXT_getMonth, &Ddate_prototype_getMonth, 0 },
|
|
|
1431 { &TEXT_getUTCMonth, &Ddate_prototype_getUTCMonth, 0 },
|
|
|
1432 { &TEXT_getDate, &Ddate_prototype_getDate, 0 },
|
|
|
1433 { &TEXT_getUTCDate, &Ddate_prototype_getUTCDate, 0 },
|
|
|
1434 { &TEXT_getDay, &Ddate_prototype_getDay, 0 },
|
|
|
1435 { &TEXT_getUTCDay, &Ddate_prototype_getUTCDay, 0 },
|
|
|
1436 { &TEXT_getHours, &Ddate_prototype_getHours, 0 },
|
|
|
1437 { &TEXT_getUTCHours, &Ddate_prototype_getUTCHours, 0 },
|
|
|
1438 { &TEXT_getMinutes, &Ddate_prototype_getMinutes, 0 },
|
|
|
1439 { &TEXT_getUTCMinutes, &Ddate_prototype_getUTCMinutes, 0 },
|
|
|
1440 { &TEXT_getSeconds, &Ddate_prototype_getSeconds, 0 },
|
|
|
1441 { &TEXT_getUTCSeconds, &Ddate_prototype_getUTCSeconds, 0 },
|
|
|
1442 { &TEXT_getMilliseconds, &Ddate_prototype_getMilliseconds, 0 },
|
|
|
1443 { &TEXT_getUTCMilliseconds, &Ddate_prototype_getUTCMilliseconds, 0 },
|
|
|
1444 { &TEXT_getTimezoneOffset, &Ddate_prototype_getTimezoneOffset, 0 },
|
|
|
1445 { &TEXT_setTime, &Ddate_prototype_setTime, 1 },
|
|
|
1446 { &TEXT_setMilliseconds, &Ddate_prototype_setMilliseconds, 1 },
|
|
|
1447 { &TEXT_setUTCMilliseconds, &Ddate_prototype_setUTCMilliseconds, 1 },
|
|
|
1448 { &TEXT_setSeconds, &Ddate_prototype_setSeconds, 2 },
|
|
|
1449 { &TEXT_setUTCSeconds, &Ddate_prototype_setUTCSeconds, 2 },
|
|
|
1450 { &TEXT_setMinutes, &Ddate_prototype_setMinutes, 3 },
|
|
|
1451 { &TEXT_setUTCMinutes, &Ddate_prototype_setUTCMinutes, 3 },
|
|
|
1452 { &TEXT_setHours, &Ddate_prototype_setHours, 4 },
|
|
|
1453 { &TEXT_setUTCHours, &Ddate_prototype_setUTCHours, 4 },
|
|
|
1454 { &TEXT_setDate, &Ddate_prototype_setDate, 1 },
|
|
|
1455 { &TEXT_setUTCDate, &Ddate_prototype_setUTCDate, 1 },
|
|
|
1456 { &TEXT_setMonth, &Ddate_prototype_setMonth, 2 },
|
|
|
1457 { &TEXT_setUTCMonth, &Ddate_prototype_setUTCMonth, 2 },
|
|
|
1458 { &TEXT_setFullYear, &Ddate_prototype_setFullYear, 3 },
|
|
|
1459 { &TEXT_setUTCFullYear, &Ddate_prototype_setUTCFullYear, 3 },
|
|
|
1460 { &TEXT_setYear, &Ddate_prototype_setYear, 1 },
|
|
|
1461 { &TEXT_toLocaleString, &Ddate_prototype_toLocaleString, 0 },
|
|
|
1462 { &TEXT_toLocaleDateString, &Ddate_prototype_toLocaleDateString, 0 },
|
|
|
1463 { &TEXT_toLocaleTimeString, &Ddate_prototype_toLocaleTimeString, 0 },
|
|
|
1464 { &TEXT_toUTCString, &Ddate_prototype_toUTCString, 0 },
|
|
|
1465
|
|
|
1466 // Map toGMTString() onto toUTCString(), per ECMA 15.9.5.41
|
|
|
1467 { &TEXT_toGMTString, &Ddate_prototype_toUTCString, 0 },
|
|
|
1468 ];
|
|
|
1469
|
|
|
1470 DnativeFunction.init(this, nfd, 0);
|
|
|
1471 assert(proptable.get("toString", Value.calcHash("toString")));
|
|
|
1472 }
|
|
|
1473 }
|
|
|
1474
|
|
|
1475
|
|
|
1476 /* ===================== Ddate ==================== */
|
|
|
1477
|
|
|
1478 class Ddate : Dobject
|
|
|
1479 {
|
|
|
1480 this(d_number n)
|
|
|
1481 {
|
|
|
1482 super(Ddate.getPrototype());
|
|
|
1483 classname = TEXT_Date;
|
|
|
1484 value.putVnumber(n);
|
|
|
1485 }
|
|
|
1486
|
|
|
1487 this(d_time n)
|
|
|
1488 {
|
|
|
1489 super(Ddate.getPrototype());
|
|
|
1490 classname = TEXT_Date;
|
|
|
1491 value.putVtime(n);
|
|
|
1492 }
|
|
|
1493
|
|
|
1494 this(Dobject prototype)
|
|
|
1495 {
|
|
|
1496 super(prototype);
|
|
|
1497 classname = TEXT_Date;
|
|
|
1498 value.putVnumber(d_number.nan);
|
|
|
1499 }
|
|
|
1500
|
|
|
1501 static void init(ThreadContext *tc)
|
|
|
1502 {
|
|
|
1503 tc.Ddate_constructor = new Ddate_constructor(tc);
|
|
|
1504 tc.Ddate_prototype = new Ddate_prototype(tc);
|
|
|
1505
|
|
|
1506 tc.Ddate_constructor.Put(TEXT_prototype, tc.Ddate_prototype,
|
|
|
1507 DontEnum | DontDelete | ReadOnly);
|
|
|
1508
|
|
|
1509 assert(tc.Ddate_prototype.proptable.table.length != 0);
|
|
|
1510 }
|
|
|
1511
|
|
|
1512 static Dfunction getConstructor()
|
|
|
1513 {
|
|
|
1514 ThreadContext *tc = ThreadContext.getThreadContext();
|
|
|
1515 assert(tc);
|
|
|
1516 return tc.Ddate_constructor;
|
|
|
1517 }
|
|
|
1518
|
|
|
1519 static Dobject getPrototype()
|
|
|
1520 {
|
|
|
1521 ThreadContext *tc = ThreadContext.getThreadContext();
|
|
|
1522 assert(tc);
|
|
|
1523 return tc.Ddate_prototype;
|
|
|
1524 }
|
|
|
1525 }
|
|
|
1526
|
|
|
1527
|
