1	// Copyright (C) 2021 The Qt Company Ltd.
2	// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4	#include "qv4dateobject_p.h"
5	#include "qv4runtime_p.h"
6	#include "qv4symbol_p.h"
7
8	#include <QtCore/QDebug>
9	#include <QtCore/QDateTime>
10	#include <QtCore/private/qlocaltime_p.h>
11	#include <QtCore/QStringList>
12	#include <QtCore/QTimeZone>
13
14	#include <wtf/MathExtras.h>
15
16	using namespace QV4;
17
18	static const double HoursPerDay = 24.0;
19	static const double MinutesPerHour = 60.0;
20	static const double SecondsPerMinute = 60.0;
21	static const double msPerSecond = 1000.0;
22	static const double msPerMinute = 60000.0;
23	static const double msPerHour = 3600000.0;
24	static const double msPerDay = 86400000.0;
25
26	static inline double TimeWithinDay(double t)
27	{
28	double r = ::fmod(x: t, y: msPerDay);
29	return (r >= 0) ? r : r + msPerDay;
30	}
31
32	static inline int HourFromTime(double t)
33	{
34	int r = int(::fmod(x: ::floor(x: t / msPerHour), y: HoursPerDay));
35	return (r >= 0) ? r : r + int(HoursPerDay);
36	}
37
38	static inline int MinFromTime(double t)
39	{
40	int r = int(::fmod(x: ::floor(x: t / msPerMinute), y: MinutesPerHour));
41	return (r >= 0) ? r : r + int(MinutesPerHour);
42	}
43
44	static inline int SecFromTime(double t)
45	{
46	int r = int(::fmod(x: ::floor(x: t / msPerSecond), y: SecondsPerMinute));
47	return (r >= 0) ? r : r + int(SecondsPerMinute);
48	}
49
50	static inline int msFromTime(double t)
51	{
52	int r = int(::fmod(x: t, y: msPerSecond));
53	return (r >= 0) ? r : r + int(msPerSecond);
54	}
55
56	static inline double Day(double t)
57	{
58	return ::floor(x: t / msPerDay);
59	}
60
61	static inline double DaysInYear(double y)
62	{
63	if (::fmod(x: y, y: 4))
64	return 365;
65
66	else if (::fmod(x: y, y: 100))
67	return 366;
68
69	else if (::fmod(x: y, y: 400))
70	return 365;
71
72	return 366;
73	}
74
75	static inline double DayFromYear(double y)
76	{
77	return 365 * (y - 1970)
78	+ ::floor(x: (y - 1969) / 4)
79	- ::floor(x: (y - 1901) / 100)
80	+ ::floor(x: (y - 1601) / 400);
81	}
82
83	static inline double TimeFromYear(double y)
84	{
85	return msPerDay * DayFromYear(y);
86	}
87
88	static inline double YearFromTime(double t)
89	{
90	int y = 1970;
91	y += (int) ::floor(x: t / (msPerDay * 365.2425));
92
93	double t2 = TimeFromYear(y);
94	return (t2 > t) ? y - 1 : ((t2 + msPerDay * DaysInYear(y)) <= t) ? y + 1 : y;
95	}
96
97	static inline bool InLeapYear(double t)
98	{
99	double x = DaysInYear(y: YearFromTime(t));
100	if (x == 365)
101	return 0;
102
103	Q_ASSERT(x == 366);
104	return 1;
105	}
106
107	static inline double DayWithinYear(double t)
108	{
109	return Day(t) - DayFromYear(y: YearFromTime(t));
110	}
111
112	static inline double MonthFromTime(double t)
113	{
114	double d = DayWithinYear(t);
115	double l = InLeapYear(t);
116
117	if (d < 31.0)
118	return 0;
119
120	else if (d < 59.0 + l)
121	return 1;
122
123	else if (d < 90.0 + l)
124	return 2;
125
126	else if (d < 120.0 + l)
127	return 3;
128
129	else if (d < 151.0 + l)
130	return 4;
131
132	else if (d < 181.0 + l)
133	return 5;
134
135	else if (d < 212.0 + l)
136	return 6;
137
138	else if (d < 243.0 + l)
139	return 7;
140
141	else if (d < 273.0 + l)
142	return 8;
143
144	else if (d < 304.0 + l)
145	return 9;
146
147	else if (d < 334.0 + l)
148	return 10;
149
150	else if (d < 365.0 + l)
151	return 11;
152
153	return qt_qnan(); // ### assert?
154	}
155
156	static inline double DateFromTime(double t)
157	{
158	int m = (int) QV4::Value::toInteger(d: MonthFromTime(t));
159	double d = DayWithinYear(t);
160	double l = InLeapYear(t);
161
162	switch (m) {
163	case 0: return d + 1.0;
164	case 1: return d - 30.0;
165	case 2: return d - 58.0 - l;
166	case 3: return d - 89.0 - l;
167	case 4: return d - 119.0 - l;
168	case 5: return d - 150.0 - l;
169	case 6: return d - 180.0 - l;
170	case 7: return d - 211.0 - l;
171	case 8: return d - 242.0 - l;
172	case 9: return d - 272.0 - l;
173	case 10: return d - 303.0 - l;
174	case 11: return d - 333.0 - l;
175	}
176
177	return qt_qnan(); // ### assert
178	}
179
180	static inline double WeekDay(double t)
181	{
182	double r = ::fmod (x: Day(t) + 4.0, y: 7.0);
183	return (r >= 0) ? r : r + 7.0;
184	}
185
186
187	static inline double MakeTime(double hour, double min, double sec, double ms)
188	{
189	if (!qIsFinite(d: hour) || !qIsFinite(d: min) || !qIsFinite(d: sec) || !qIsFinite(d: ms))
190	return qQNaN();
191	hour = QV4::Value::toInteger(d: hour);
192	min = QV4::Value::toInteger(d: min);
193	sec = QV4::Value::toInteger(d: sec);
194	ms = QV4::Value::toInteger(d: ms);
195	return ((hour * MinutesPerHour + min) * SecondsPerMinute + sec) * msPerSecond + ms;
196	}
197
198	static inline double DayFromMonth(double month, double leap)
199	{
200	switch ((int) month) {
201	case 0: return 0;
202	case 1: return 31.0;
203	case 2: return 59.0 + leap;
204	case 3: return 90.0 + leap;
205	case 4: return 120.0 + leap;
206	case 5: return 151.0 + leap;
207	case 6: return 181.0 + leap;
208	case 7: return 212.0 + leap;
209	case 8: return 243.0 + leap;
210	case 9: return 273.0 + leap;
211	case 10: return 304.0 + leap;
212	case 11: return 334.0 + leap;
213	}
214
215	return qt_qnan(); // ### assert?
216	}
217
218	static double MakeDay(double year, double month, double day)
219	{
220	if (!qIsFinite(d: year) || !qIsFinite(d: month) || !qIsFinite(d: day))
221	return qQNaN();
222	year = QV4::Value::toInteger(d: year);
223	month = QV4::Value::toInteger(d: month);
224	day = QV4::Value::toInteger(d: day);
225
226	year += ::floor(x: month / 12.0);
227
228	month = ::fmod(x: month, y: 12.0);
229	if (month < 0)
230	month += 12.0;
231
232	/* Quoting the spec:
233
234	Find a value t such that YearFromTime(t) is ym and MonthFromTime(t) is mn
235	and DateFromTime(t) is 1; but if this is not possible (because some
236	argument is out of range), return NaN.
237	*/
238	double first = DayFromYear(y: year);
239	/* Beware floating-point glitches: don't test the first millisecond of a
240	* year, month or day when we could test a moment firmly in the interior of
241	* the interval. A rounding glitch might give the first millisecond to the
242	* preceding interval.
243	*/
244	bool leap = InLeapYear(t: (first + 60) * msPerDay);
245
246	first += DayFromMonth(month, leap);
247	const double t = first * msPerDay + msPerDay / 2; // Noon on the first of the month
248	Q_ASSERT(Day(t) == first);
249	if (YearFromTime(t) != year || MonthFromTime(t) != month || DateFromTime(t) != 1) {
250	qWarning(msg: "Apparently out-of-range date %.0f-%02.0f-%02.0f", year, month, day);
251	return qt_qnan();
252	}
253	return first + day - 1;
254	}
255
256	static inline double MakeDate(double day, double time)
257	{
258	return day * msPerDay + time;
259	}
260
261	/*
262	ECMAScript specifies use of a fixed (current, standard) time-zone offset,
263	LocalTZA; and LocalTZA + DaylightSavingTA(t) is taken to be (see LocalTime and
264	UTC, following) local time's offset from UTC at time t. For simple zones,
265	DaylightSavingTA(t) is thus the DST offset applicable at date/time t; however,
266	if a zone has changed its standard offset, the only way to make LocalTime and
267	UTC (if implemented in accord with the spec) perform correct transformations
268	is to have DaylightSavingTA(t) correct for the zone's standard offset change
269	as well as its actual DST offset.
270
271	This means we have to treat any historical changes in the zone's standard
272	offset as DST perturbations, regardless of historical reality. (This shall
273	mean a whole day of DST offset for some zones, that have crossed the
274	international date line. This shall confuse client code.) The bug report
275	against the ECMAScript spec is https://github.com/tc39/ecma262/issues/725
276	and they've now changed the spec so that the following conforms to it ;^>
277	*/
278	static inline double DaylightSavingTA(double t, double localTZA) // t is a UTC time
279	{
280	return QLocalTime::getUtcOffset(atMSecsSinceEpoch: qint64(t)) * 1e3 - localTZA;
281	}
282
283	static inline double LocalTime(double t, double localTZA)
284	{
285	// Flawed, yet verbatim from the spec:
286	return t + localTZA + DaylightSavingTA(t, localTZA);
287	}
288
289	// The spec does note [*] that UTC and LocalTime are not quite mutually inverse.
290	// [*] http://www.ecma-international.org/ecma-262/7.0/index.html#sec-utc-t
291
292	static inline double UTC(double t, double localTZA)
293	{
294	// Flawed, yet verbatim from the spec:
295	return t - localTZA - DaylightSavingTA(t: t - localTZA, localTZA);
296	}
297
298	static inline double currentTime()
299	{
300	return QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();
301	}
302
303	static inline double TimeClip(double t)
304	{
305	if (!qt_is_finite(d: t) || fabs(x: t) > Date::MaxDateVal)
306	return qt_qnan();
307
308	// +0 looks weird, but is correct. See ES6 20.3.1.15. We must not return -0.
309	return QV4::Value::toInteger(d: t) + 0;
310	}
311
312	static inline double ParseString(const QString &s, double localTZA)
313	{
314	/*
315	First, try the format defined in ECMA 262's "Date Time String Format";
316	only if that fails, fall back to QDateTime for parsing
317
318	The defined string format is yyyy-MM-ddTHH:mm:ss.zzzt; the time (T and all
319	after it) may be omitted. In each part, the second and later components
320	are optional. There's an extended syntax for negative and large positive
321	years: ±yyyyyy; the leading sign, even when +, isn't optional. If month
322	(MM) or day (dd) is omitted, it is 01; if minute (mm) or second (ss) is
323	omitted, it's 00; if milliseconds (zzz) are omitted, they're 000.
324
325	When the time zone offset (t) is absent, date-only forms are interpreted as
326	indicating a UTC time and date-time forms are interpreted in local time.
327	*/
328
329	enum Format {
330	Year,
331	Month,
332	Day,
333	Hour,
334	Minute,
335	Second,
336	MilliSecond,
337	TimezoneHour,
338	TimezoneMinute,
339	Done
340	};
341
342	const QChar *ch = s.constData();
343	const QChar *end = ch + s.size();
344
345	uint format = Year;
346	int current = 0;
347	int currentSize = 0;
348	bool extendedYear = false;
349
350	int yearSign = 1;
351	int year = 0;
352	int month = 0;
353	int day = 1;
354	int hour = 0;
355	int minute = 0;
356	int second = 0;
357	int msec = 0;
358	int offsetSign = 1;
359	int offset = 0;
360	bool seenT = false;
361	bool seenZ = false; // Have seen zone, i.e. +HH:mm or literal Z.
362
363	bool error = false;
364	if (*ch == u'+' || *ch == u'-') {
365	extendedYear = true;
366	if (*ch == u'-')
367	yearSign = -1;
368	++ch;
369	}
370	for (; ch <= end && !error && format != Done; ++ch) {
371	if (*ch >= u'0' && *ch <= u'9') {
372	current *= 10;
373	current += ch->unicode() - u'0';
374	++currentSize;
375	} else { // other char, delimits field
376	switch (format) {
377	case Year:
378	year = current;
379	if (extendedYear)
380	error = (currentSize != 6);
381	else
382	error = (currentSize != 4);
383	break;
384	case Month:
385	month = current - 1;
386	error = (currentSize != 2) || month > 11;
387	break;
388	case Day:
389	day = current;
390	error = (currentSize != 2) || day > 31;
391	break;
392	case Hour:
393	hour = current;
394	error = (currentSize != 2) || hour > 24;
395	break;
396	case Minute:
397	minute = current;
398	error = (currentSize != 2) || minute >= 60;
399	break;
400	case Second:
401	second = current;
402	error = (currentSize != 2) || second > 60;
403	break;
404	case MilliSecond:
405	msec = current;
406	error = (currentSize != 3);
407	break;
408	case TimezoneHour:
409	Q_ASSERT(offset == 0 && !seenZ);
410	offset = current * 60;
411	error = (currentSize != 2) || current > 23;
412	seenZ = true;
413	break;
414	case TimezoneMinute:
415	offset += current;
416	error = (currentSize != 2) || current >= 60;
417	break;
418	}
419	if (*ch == u'T') {
420	if (format >= Hour)
421	error = true;
422	format = Hour;
423	seenT = true;
424	} else if (*ch == u'-') {
425	if (format < Day)
426	++format;
427	else if (format < Minute)
428	error = true;
429	else if (format >= TimezoneHour)
430	error = true;
431	else {
432	Q_ASSERT(offset == 0 && !seenZ);
433	offsetSign = -1;
434	format = TimezoneHour;
435	}
436	} else if (*ch == u':') {
437	if (format != Hour && format != Minute && format != TimezoneHour)
438	error = true;
439	++format;
440	} else if (*ch == u'.') {
441	if (format != Second)
442	error = true;
443	++format;
444	} else if (*ch == u'+') {
445	if (seenZ || format < Minute || format >= TimezoneHour)
446	error = true;
447	format = TimezoneHour;
448	} else if (*ch == u'Z') {
449	if (seenZ || format < Minute || format >= TimezoneHour)
450	error = true;
451	else
452	Q_ASSERT(offset == 0);
453	format = Done;
454	seenZ = true;
455	} else if (ch->unicode() == 0) {
456	format = Done;
457	}
458	current = 0;
459	currentSize = 0;
460	}
461	}
462
463	if (!error) {
464	double t = MakeDate(day: MakeDay(year: year * yearSign, month, day), time: MakeTime(hour, min: minute, sec: second, ms: msec));
465	if (seenZ)
466	t -= offset * offsetSign * 60 * 1000;
467	else if (seenT) // No zone specified, treat date-time as local time
468	t = UTC(t, localTZA);
469	// else: treat plain date as already in UTC
470	return TimeClip(t);
471	}
472
473	QDateTime dt = QDateTime::fromString(string: s, format: Qt::TextDate);
474	if (!dt.isValid())
475	dt = QDateTime::fromString(string: s, format: Qt::ISODate);
476	if (!dt.isValid())
477	dt = QDateTime::fromString(string: s, format: Qt::RFC2822Date);
478	if (!dt.isValid()) {
479	const QString formats[] = {
480	QStringLiteral("M/d/yyyy"),
481	QStringLiteral("M/d/yyyy hh:mm"),
482	QStringLiteral("M/d/yyyy hh:mm A"),
483
484	QStringLiteral("M/d/yyyy, hh:mm"),
485	QStringLiteral("M/d/yyyy, hh:mm A"),
486
487	QStringLiteral("MMM d yyyy"),
488	QStringLiteral("MMM d yyyy hh:mm"),
489	QStringLiteral("MMM d yyyy hh:mm:ss"),
490	QStringLiteral("MMM d yyyy, hh:mm"),
491	QStringLiteral("MMM d yyyy, hh:mm:ss"),
492
493	QStringLiteral("MMMM d yyyy"),
494	QStringLiteral("MMMM d yyyy hh:mm"),
495	QStringLiteral("MMMM d yyyy hh:mm:ss"),
496	QStringLiteral("MMMM d yyyy, hh:mm"),
497	QStringLiteral("MMMM d yyyy, hh:mm:ss"),
498
499	QStringLiteral("MMM d, yyyy"),
500	QStringLiteral("MMM d, yyyy hh:mm"),
501	QStringLiteral("MMM d, yyyy hh:mm:ss"),
502
503	QStringLiteral("MMMM d, yyyy"),
504	QStringLiteral("MMMM d, yyyy hh:mm"),
505	QStringLiteral("MMMM d, yyyy hh:mm:ss"),
506
507	QStringLiteral("d MMM yyyy"),
508	QStringLiteral("d MMM yyyy hh:mm"),
509	QStringLiteral("d MMM yyyy hh:mm:ss"),
510	QStringLiteral("d MMM yyyy, hh:mm"),
511	QStringLiteral("d MMM yyyy, hh:mm:ss"),
512
513	QStringLiteral("d MMMM yyyy"),
514	QStringLiteral("d MMMM yyyy hh:mm"),
515	QStringLiteral("d MMMM yyyy hh:mm:ss"),
516	QStringLiteral("d MMMM yyyy, hh:mm"),
517	QStringLiteral("d MMMM yyyy, hh:mm:ss"),
518
519	QStringLiteral("d MMM, yyyy"),
520	QStringLiteral("d MMM, yyyy hh:mm"),
521	QStringLiteral("d MMM, yyyy hh:mm:ss"),
522
523	QStringLiteral("d MMMM, yyyy"),
524	QStringLiteral("d MMMM, yyyy hh:mm"),
525	QStringLiteral("d MMMM, yyyy hh:mm:ss"),
526
527	// ISO 8601 and RFC 2822 with a GMT as prefix on its offset, or GMT as zone.
528	QStringLiteral("yyyy-MM-dd hh:mm:ss t"),
529	QStringLiteral("ddd, d MMM yyyy hh:mm:ss t"),
530	};
531
532	for (const QString &format : formats) {
533	dt = format.indexOf(s: QLatin1String("hh:mm")) < 0
534	? QDate::fromString(string: s, format).startOfDay(zone: QTimeZone::UTC)
535	: QDateTime::fromString(string: s, format); // as local time
536	if (dt.isValid())
537	break;
538	}
539	}
540	if (!dt.isValid())
541	return qt_qnan();
542	return TimeClip(t: dt.toMSecsSinceEpoch());
543	}
544
545	/*!
546	\internal
547
548	Converts the ECMA Date value \a t (in UTC form) to QDateTime
549	according to \a spec.
550	*/
551	static inline QDateTime ToDateTime(double t, QTimeZone zone)
552	{
553	if (std::isnan(x: t))
554	return QDateTime().toTimeZone(toZone: zone);
555	return QDateTime::fromMSecsSinceEpoch(msecs: t, timeZone: zone);
556	}
557
558	static inline QString ToString(double t, double localTZA)
559	{
560	if (std::isnan(x: t))
561	return QStringLiteral("Invalid Date");
562	QString str = ToDateTime(t, zone: QTimeZone::LocalTime).toString() + QLatin1String(" GMT");
563	double tzoffset = localTZA + DaylightSavingTA(t, localTZA);
564	if (tzoffset) {
565	int hours = static_cast<int>(::fabs(x: tzoffset) / 1000 / 60 / 60);
566	int mins = int(::fabs(x: tzoffset) / 1000 / 60) % 60;
567	str.append(c: QLatin1Char((tzoffset > 0) ? '+' : '-'));
568	if (hours < 10)
569	str.append(c: QLatin1Char('0'));
570	str.append(s: QString::number(hours));
571	if (mins < 10)
572	str.append(c: QLatin1Char('0'));
573	str.append(s: QString::number(mins));
574	}
575	return str;
576	}
577
578	static inline QString ToUTCString(double t)
579	{
580	if (std::isnan(x: t))
581	return QStringLiteral("Invalid Date");
582	return ToDateTime(t, zone: QTimeZone::UTC).toString();
583	}
584
585	static inline QString ToDateString(double t)
586	{
587	return ToDateTime(t, zone: QTimeZone::LocalTime).date().toString();
588	}
589
590	static inline QString ToTimeString(double t)
591	{
592	return ToDateTime(t, zone: QTimeZone::LocalTime).time().toString();
593	}
594
595	static inline QString ToLocaleString(double t)
596	{
597	return QLocale().toString(dateTime: ToDateTime(t, zone: QTimeZone::LocalTime), format: QLocale::ShortFormat);
598	}
599
600	static inline QString ToLocaleDateString(double t)
601	{
602	return QLocale().toString(date: ToDateTime(t, zone: QTimeZone::LocalTime).date(), format: QLocale::ShortFormat);
603	}
604
605	static inline QString ToLocaleTimeString(double t)
606	{
607	return QLocale().toString(time: ToDateTime(t, zone: QTimeZone::LocalTime).time(), format: QLocale::ShortFormat);
608	}
609
610	static double getLocalTZA()
611	{
612	return QLocalTime::getCurrentStandardUtcOffset() * 1e3;
613	}
614
615	DEFINE_OBJECT_VTABLE(DateObject);
616
617	quint64 Date::encode(double value)
618	{
619	if (std::isnan(x: value) || fabs(x: value) > MaxDateVal)
620	return InvalidDateVal;
621
622	// Do the addition in qint64. This way we won't overflow if value is negative
623	// and we will round value in the right direction.
624	// We know we can do this because we know we have more than one bit left in quint64.
625	const quint64 encoded = quint64(qint64(value) + qint64(MaxDateVal));
626
627	return encoded + Extra;
628	}
629
630	quint64 Date::encode(const QDateTime &dateTime)
631	{
632	return encode(value: dateTime.isValid() ? dateTime.toMSecsSinceEpoch() : qt_qnan());
633	}
634
635	void Date::init(double value)
636	{
637	storage = encode(value);
638	}
639
640	void Date::init(const QDateTime &when)
641	{
642	storage = encode(dateTime: when) | HasQDate | HasQTime;
643	}
644
645	void Date::init(QDate date)
646	{
647	storage = encode(dateTime: date.startOfDay(zone: QTimeZone::UTC)) | HasQDate;
648	}
649
650	void Date::init(QTime time, ExecutionEngine *engine)
651	{
652	if (!time.isValid()) {
653	storage = encode(value: qt_qnan()) | HasQTime;
654	return;
655	}
656
657	/* We have to chose a date on which to instantiate this time. All we really
658	* care about is that it round-trips back to the same time if we extract the
659	* time from it, which shall (via toQDateTime(), below) discard the date
660	* part. We need a date for which time-zone data is likely to be sane (so
661	* MakeDay(0, 0, 0) was a bad choice; 2 BC, December 31st is before
662	* time-zones were standardized), with no transition nearby in date.
663	* QDateTime ignores DST transitions before 1970, but even then zone
664	* transitions did happen; and DaylightSavingTA() will include DST, at odds
665	* with QDateTime. So pick a date since 1970 and prefer one when no zone
666	* was in DST. One such interval (according to the Olson database, at
667	* least) was 1971 March 15th to April 17th. Since converting a time to a
668	* date-time without specifying a date is foolish, let's use April Fools'
669	* day.
670	*/
671	static const double d = MakeDay(year: 1971, month: 3, day: 1);
672	double t = MakeTime(hour: time.hour(), min: time.minute(), sec: time.second(), ms: time.msec());
673	storage = encode(value: UTC(t: MakeDate(day: d, time: t), localTZA: engine->localTZA)) | HasQTime;
674	}
675
676	QDate Date::toQDate() const
677	{
678	return toQDateTime().date();
679	}
680
681	QTime Date::toQTime() const
682	{
683	return toQDateTime().time();
684	}
685
686	QDateTime Date::toQDateTime() const
687	{
688	return ToDateTime(t: operator double(), zone: QTimeZone::LocalTime);
689	}
690
691	QVariant Date::toVariant() const
692	{
693	switch (storage & (HasQDate | HasQTime)) {
694	case HasQDate:
695	return toQDate();
696	case HasQTime:
697	return toQTime();
698	case (HasQDate | HasQTime):
699	return toQDateTime();
700	default:
701	return QVariant();
702	}
703	}
704
705	QDateTime DateObject::toQDateTime() const
706	{
707	return d()->toQDateTime();
708	}
709
710	QString DateObject::toString() const
711	{
712	return ToString(t: d()->date(), localTZA: engine()->localTZA);
713	}
714
715	QString DateObject::dateTimeToString(const QDateTime &dateTime, ExecutionEngine *engine)
716	{
717	if (!dateTime.isValid())
718	return QStringLiteral("Invalid Date");
719	return ToString(t: TimeClip(t: dateTime.toMSecsSinceEpoch()), localTZA: engine->localTZA);
720	}
721
722	double DateObject::dateTimeToNumber(const QDateTime &dateTime)
723	{
724	if (!dateTime.isValid())
725	return qQNaN();
726	return TimeClip(t: dateTime.toMSecsSinceEpoch());
727	}
728
729	QDateTime DateObject::stringToDateTime(const QString &string, ExecutionEngine *engine)
730	{
731	return ToDateTime(t: ParseString(s: string, localTZA: engine->localTZA), zone: QTimeZone::LocalTime);
732	}
733
734	QDateTime DateObject::timestampToDateTime(double timestamp, QTimeZone zone)
735	{
736	return ToDateTime(t: timestamp, zone);
737	}
738
739	double DateObject::componentsToTimestamp(
740	double year, double month, double day, double hours,
741	double mins, double secs, double ms, ExecutionEngine *v4)
742	{
743	if (year >= 0 && year <= 99)
744	year += 1900;
745	const double t = MakeDate(day: MakeDay(year, month, day), time: MakeTime(hour: hours, min: mins, sec: secs, ms));
746	return UTC(t, localTZA: v4->localTZA);
747	}
748
749	QDate DateObject::dateTimeToDate(const QDateTime &dateTime)
750	{
751	// If the Date object was parse()d from a string with no time part
752	// or zone specifier it's really the UTC start of the relevant day,
753	// but it's here represented as a local time, which may fall in the
754	// preceding day. See QTBUG-92466 for the gory details.
755	const auto utc = dateTime.toUTC();
756	if (utc.date() != dateTime.date() && utc.addSecs(secs: -1).date() == dateTime.date())
757	return utc.date();
758
759	// This may, of course, be The Wrong Thing if the date was
760	// constructed as a full local date-time that happens to coincide
761	// with the start of a UTC day; however, that would be an odd value
762	// to give to something that, apparently, someone thinks belongs in
763	// a QDate.
764	return dateTime.date();
765	}
766
767	DEFINE_OBJECT_VTABLE(DateCtor);
768
769	void Heap::DateCtor::init(QV4::ExecutionEngine *engine)
770	{
771	Heap::FunctionObject::init(engine, QStringLiteral("Date"));
772	}
773
774	ReturnedValue DateCtor::virtualCallAsConstructor(const FunctionObject *that, const Value *argv, int argc, const Value *newTarget)
775	{
776	ExecutionEngine *v4 = that->engine();
777	double t = 0;
778
779	if (argc == 0)
780	t = currentTime();
781
782	else if (argc == 1) {
783	Scope scope(v4);
784	ScopedValue arg(scope, argv[0]);
785	if (DateObject *d = arg->as<DateObject>()) {
786	t = d->date();
787	} else {
788	arg = RuntimeHelpers::toPrimitive(value: arg, typeHint: PREFERREDTYPE_HINT);
789
790	if (String *s = arg->stringValue())
791	t = ParseString(s: s->toQString(), localTZA: v4->localTZA);
792	else
793	t = arg->toNumber();
794	}
795	}
796
797	else { // d.argc > 1
798	const double year = argv[0].toNumber();
799	const double month = argv[1].toNumber();
800	const double day = argc >= 3 ? argv[2].toNumber() : 1;
801	const double hours = argc >= 4 ? argv[3].toNumber() : 0;
802	const double mins = argc >= 5 ? argv[4].toNumber() : 0;
803	const double secs = argc >= 6 ? argv[5].toNumber() : 0;
804	const double ms = argc >= 7 ? argv[6].toNumber() : 0;
805	t = DateObject::componentsToTimestamp(year, month, day, hours, mins, secs, ms, v4);
806	}
807
808	ReturnedValue o = Encode(v4->newDateObject(dateTime: t));
809	if (!newTarget)
810	return o;
811	Scope scope(v4);
812	ScopedObject obj(scope, o);
813	obj->setProtoFromNewTarget(newTarget);
814	return obj->asReturnedValue();
815	}
816
817	ReturnedValue DateCtor::virtualCall(const FunctionObject *m, const Value *, const Value *, int)
818	{
819	ExecutionEngine *e = m->engine();
820	double t = currentTime();
821	return e->newString(s: ToString(t, localTZA: e->localTZA))->asReturnedValue();
822	}
823
824	void DatePrototype::init(ExecutionEngine *engine, Object *ctor)
825	{
826	Scope scope(engine);
827	ScopedObject o(scope);
828	ctor->defineReadonlyProperty(name: engine->id_prototype(), value: (o = this));
829	ctor->defineReadonlyConfigurableProperty(name: engine->id_length(), value: Value::fromInt32(i: 7));
830	engine->localTZA = getLocalTZA();
831
832	ctor->defineDefaultProperty(QStringLiteral("parse"), code: method_parse, argumentCount: 1);
833	ctor->defineDefaultProperty(QStringLiteral("UTC"), code: method_UTC, argumentCount: 7);
834	ctor->defineDefaultProperty(QStringLiteral("now"), code: method_now, argumentCount: 0);
835
836	defineDefaultProperty(QStringLiteral("constructor"), value: (o = ctor));
837	defineDefaultProperty(name: engine->id_toString(), code: method_toString, argumentCount: 0);
838	defineDefaultProperty(QStringLiteral("toDateString"), code: method_toDateString, argumentCount: 0);
839	defineDefaultProperty(QStringLiteral("toTimeString"), code: method_toTimeString, argumentCount: 0);
840	defineDefaultProperty(name: engine->id_toLocaleString(), code: method_toLocaleString, argumentCount: 0);
841	defineDefaultProperty(QStringLiteral("toLocaleDateString"), code: method_toLocaleDateString, argumentCount: 0);
842	defineDefaultProperty(QStringLiteral("toLocaleTimeString"), code: method_toLocaleTimeString, argumentCount: 0);
843	defineDefaultProperty(name: engine->id_valueOf(), code: method_valueOf, argumentCount: 0);
844	defineDefaultProperty(QStringLiteral("getTime"), code: method_getTime, argumentCount: 0);
845	defineDefaultProperty(QStringLiteral("getYear"), code: method_getYear, argumentCount: 0);
846	defineDefaultProperty(QStringLiteral("getFullYear"), code: method_getFullYear, argumentCount: 0);
847	defineDefaultProperty(QStringLiteral("getUTCFullYear"), code: method_getUTCFullYear, argumentCount: 0);
848	defineDefaultProperty(QStringLiteral("getMonth"), code: method_getMonth, argumentCount: 0);
849	defineDefaultProperty(QStringLiteral("getUTCMonth"), code: method_getUTCMonth, argumentCount: 0);
850	defineDefaultProperty(QStringLiteral("getDate"), code: method_getDate, argumentCount: 0);
851	defineDefaultProperty(QStringLiteral("getUTCDate"), code: method_getUTCDate, argumentCount: 0);
852	defineDefaultProperty(QStringLiteral("getDay"), code: method_getDay, argumentCount: 0);
853	defineDefaultProperty(QStringLiteral("getUTCDay"), code: method_getUTCDay, argumentCount: 0);
854	defineDefaultProperty(QStringLiteral("getHours"), code: method_getHours, argumentCount: 0);
855	defineDefaultProperty(QStringLiteral("getUTCHours"), code: method_getUTCHours, argumentCount: 0);
856	defineDefaultProperty(QStringLiteral("getMinutes"), code: method_getMinutes, argumentCount: 0);
857	defineDefaultProperty(QStringLiteral("getUTCMinutes"), code: method_getUTCMinutes, argumentCount: 0);
858	defineDefaultProperty(QStringLiteral("getSeconds"), code: method_getSeconds, argumentCount: 0);
859	defineDefaultProperty(QStringLiteral("getUTCSeconds"), code: method_getUTCSeconds, argumentCount: 0);
860	defineDefaultProperty(QStringLiteral("getMilliseconds"), code: method_getMilliseconds, argumentCount: 0);
861	defineDefaultProperty(QStringLiteral("getUTCMilliseconds"), code: method_getUTCMilliseconds, argumentCount: 0);
862	defineDefaultProperty(QStringLiteral("getTimezoneOffset"), code: method_getTimezoneOffset, argumentCount: 0);
863	defineDefaultProperty(QStringLiteral("setTime"), code: method_setTime, argumentCount: 1);
864	defineDefaultProperty(QStringLiteral("setMilliseconds"), code: method_setMilliseconds, argumentCount: 1);
865	defineDefaultProperty(QStringLiteral("setUTCMilliseconds"), code: method_setUTCMilliseconds, argumentCount: 1);
866	defineDefaultProperty(QStringLiteral("setSeconds"), code: method_setSeconds, argumentCount: 2);
867	defineDefaultProperty(QStringLiteral("setUTCSeconds"), code: method_setUTCSeconds, argumentCount: 2);
868	defineDefaultProperty(QStringLiteral("setMinutes"), code: method_setMinutes, argumentCount: 3);
869	defineDefaultProperty(QStringLiteral("setUTCMinutes"), code: method_setUTCMinutes, argumentCount: 3);
870	defineDefaultProperty(QStringLiteral("setHours"), code: method_setHours, argumentCount: 4);
871	defineDefaultProperty(QStringLiteral("setUTCHours"), code: method_setUTCHours, argumentCount: 4);
872	defineDefaultProperty(QStringLiteral("setDate"), code: method_setDate, argumentCount: 1);
873	defineDefaultProperty(QStringLiteral("setUTCDate"), code: method_setUTCDate, argumentCount: 1);
874	defineDefaultProperty(QStringLiteral("setMonth"), code: method_setMonth, argumentCount: 2);
875	defineDefaultProperty(QStringLiteral("setUTCMonth"), code: method_setUTCMonth, argumentCount: 2);
876	defineDefaultProperty(QStringLiteral("setYear"), code: method_setYear, argumentCount: 1);
877	defineDefaultProperty(QStringLiteral("setFullYear"), code: method_setFullYear, argumentCount: 3);
878	defineDefaultProperty(QStringLiteral("setUTCFullYear"), code: method_setUTCFullYear, argumentCount: 3);
879
880	// ES6: B.2.4.3 & 20.3.4.43:
881	// We have to use the *same object* for toUTCString and toGMTString
882	{
883	QString toUtcString(QStringLiteral("toUTCString"));
884	QString toGmtString(QStringLiteral("toGMTString"));
885	ScopedString us(scope, engine->newIdentifier(text: toUtcString));
886	ScopedString gs(scope, engine->newIdentifier(text: toGmtString));
887	ScopedFunctionObject toUtcGmtStringFn(scope, FunctionObject::createBuiltinFunction(engine, nameOrSymbol: us, code: method_toUTCString, argumentCount: 0));
888	defineDefaultProperty(name: us, value: toUtcGmtStringFn);
889	defineDefaultProperty(name: gs, value: toUtcGmtStringFn);
890	}
891
892	defineDefaultProperty(QStringLiteral("toISOString"), code: method_toISOString, argumentCount: 0);
893	defineDefaultProperty(QStringLiteral("toJSON"), code: method_toJSON, argumentCount: 1);
894	defineDefaultProperty(name: engine->symbol_toPrimitive(), code: method_symbolToPrimitive, argumentCount: 1, attributes: Attr_ReadOnly_ButConfigurable);
895	}
896
897	double DatePrototype::getThisDate(ExecutionEngine *v4, const Value *thisObject)
898	{
899	if (const DateObject *that = thisObject->as<DateObject>())
900	return that->date();
901	v4->throwTypeError();
902	return 0;
903	}
904
905	ReturnedValue DatePrototype::method_parse(const FunctionObject *f, const Value *, const Value *argv, int argc)
906	{
907	if (!argc)
908	return Encode(qt_qnan());
909	else
910	return Encode(ParseString(s: argv[0].toQString(), localTZA: f->engine()->localTZA));
911	}
912
913	ReturnedValue DatePrototype::method_UTC(const FunctionObject *f, const Value *, const Value *argv, int argc)
914	{
915	const int numArgs = argc;
916	if (numArgs < 1)
917	return Encode(qQNaN());
918	ExecutionEngine *e = f->engine();
919	double year = argv[0].toNumber();
920	if (e->hasException)
921	return Encode::undefined();
922	double month = numArgs >= 2 ? argv[1].toNumber() : 0;
923	if (e->hasException)
924	return Encode::undefined();
925	double day = numArgs >= 3 ? argv[2].toNumber() : 1;
926	if (e->hasException)
927	return Encode::undefined();
928	double hours = numArgs >= 4 ? argv[3].toNumber() : 0;
929	if (e->hasException)
930	return Encode::undefined();
931	double mins = numArgs >= 5 ? argv[4].toNumber() : 0;
932	if (e->hasException)
933	return Encode::undefined();
934	double secs = numArgs >= 6 ? argv[5].toNumber() : 0;
935	if (e->hasException)
936	return Encode::undefined();
937	double ms = numArgs >= 7 ? argv[6].toNumber() : 0;
938	if (e->hasException)
939	return Encode::undefined();
940	double iyear = QV4::Value::toInteger(d: year);
941	if (!qIsNaN(d: year) && iyear >= 0 && iyear <= 99)
942	year = 1900 + iyear;
943	double t = MakeDate(day: MakeDay(year, month, day),
944	time: MakeTime(hour: hours, min: mins, sec: secs, ms));
945	return Encode(TimeClip(t));
946	}
947
948	ReturnedValue DatePrototype::method_now(const FunctionObject *, const Value *, const Value *, int)
949	{
950	return Encode(currentTime());
951	}
952
953	ReturnedValue DatePrototype::method_toString(const FunctionObject *b, const Value *thisObject, const Value *, int)
954	{
955	ExecutionEngine *v4 = b->engine();
956	double t = getThisDate(v4, thisObject);
957	return Encode(v4->newString(s: ToString(t, localTZA: v4->localTZA)));
958	}
959
960	ReturnedValue DatePrototype::method_toDateString(const FunctionObject *b, const Value *thisObject, const Value *, int)
961	{
962	ExecutionEngine *v4 = b->engine();
963	double t = getThisDate(v4, thisObject);
964	return Encode(v4->newString(s: ToDateString(t)));
965	}
966
967	ReturnedValue DatePrototype::method_toTimeString(const FunctionObject *b, const Value *thisObject, const Value *, int)
968	{
969	ExecutionEngine *v4 = b->engine();
970	double t = getThisDate(v4, thisObject);
971	return Encode(v4->newString(s: ToTimeString(t)));
972	}
973
974	ReturnedValue DatePrototype::method_toLocaleString(const FunctionObject *b, const Value *thisObject, const Value *, int)
975	{
976	ExecutionEngine *v4 = b->engine();
977	double t = getThisDate(v4, thisObject);
978	return Encode(v4->newString(s: ToLocaleString(t)));
979	}
980
981	ReturnedValue DatePrototype::method_toLocaleDateString(const FunctionObject *b, const Value *thisObject, const Value *, int)
982	{
983	ExecutionEngine *v4 = b->engine();
984	double t = getThisDate(v4, thisObject);
985	return Encode(v4->newString(s: ToLocaleDateString(t)));
986	}
987
988	ReturnedValue DatePrototype::method_toLocaleTimeString(const FunctionObject *b, const Value *thisObject, const Value *, int)
989	{
990	ExecutionEngine *v4 = b->engine();
991	double t = getThisDate(v4, thisObject);
992	return Encode(v4->newString(s: ToLocaleTimeString(t)));
993	}
994
995	ReturnedValue DatePrototype::method_valueOf(const FunctionObject *b, const Value *thisObject, const Value *, int)
996	{
997	ExecutionEngine *v4 = b->engine();
998	double t = getThisDate(v4, thisObject);
999	return Encode(t);
1000	}
1001
1002	ReturnedValue DatePrototype::method_getTime(const FunctionObject *b, const Value *thisObject, const Value *, int)
1003	{
1004	ExecutionEngine *v4 = b->engine();
1005	double t = getThisDate(v4, thisObject);
1006	return Encode(t);
1007	}
1008
1009	ReturnedValue DatePrototype::method_getYear(const FunctionObject *b, const Value *thisObject, const Value *, int)
1010	{
1011	ExecutionEngine *v4 = b->engine();
1012	double t = getThisDate(v4, thisObject);
1013	if (!std::isnan(x: t))
1014	t = YearFromTime(t: LocalTime(t, localTZA: v4->localTZA)) - 1900;
1015	return Encode(t);
1016	}
1017
1018	ReturnedValue DatePrototype::method_getFullYear(const FunctionObject *b, const Value *thisObject, const Value *, int)
1019	{
1020	ExecutionEngine *v4 = b->engine();
1021	double t = getThisDate(v4, thisObject);
1022	if (!std::isnan(x: t))
1023	t = YearFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1024	return Encode(t);
1025	}
1026
1027	ReturnedValue DatePrototype::method_getUTCFullYear(const FunctionObject *b, const Value *thisObject, const Value *, int)
1028	{
1029	ExecutionEngine *v4 = b->engine();
1030	double t = getThisDate(v4, thisObject);
1031	if (!std::isnan(x: t))
1032	t = YearFromTime(t);
1033	return Encode(t);
1034	}
1035
1036	ReturnedValue DatePrototype::method_getMonth(const FunctionObject *b, const Value *thisObject, const Value *, int)
1037	{
1038	ExecutionEngine *v4 = b->engine();
1039	double t = getThisDate(v4, thisObject);
1040	if (!std::isnan(x: t))
1041	t = MonthFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1042	return Encode(t);
1043	}
1044
1045	ReturnedValue DatePrototype::method_getUTCMonth(const FunctionObject *b, const Value *thisObject, const Value *, int)
1046	{
1047	ExecutionEngine *v4 = b->engine();
1048	double t = getThisDate(v4, thisObject);
1049	if (!std::isnan(x: t))
1050	t = MonthFromTime(t);
1051	return Encode(t);
1052	}
1053
1054	ReturnedValue DatePrototype::method_getDate(const FunctionObject *b, const Value *thisObject, const Value *, int)
1055	{
1056	ExecutionEngine *v4 = b->engine();
1057	double t = getThisDate(v4, thisObject);
1058	if (!std::isnan(x: t))
1059	t = DateFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1060	return Encode(t);
1061	}
1062
1063	ReturnedValue DatePrototype::method_getUTCDate(const FunctionObject *b, const Value *thisObject, const Value *, int)
1064	{
1065	ExecutionEngine *v4 = b->engine();
1066	double t = getThisDate(v4, thisObject);
1067	if (!std::isnan(x: t))
1068	t = DateFromTime(t);
1069	return Encode(t);
1070	}
1071
1072	ReturnedValue DatePrototype::method_getDay(const FunctionObject *b, const Value *thisObject, const Value *, int)
1073	{
1074	ExecutionEngine *v4 = b->engine();
1075	double t = getThisDate(v4, thisObject);
1076	if (!std::isnan(x: t))
1077	t = WeekDay(t: LocalTime(t, localTZA: v4->localTZA));
1078	return Encode(t);
1079	}
1080
1081	ReturnedValue DatePrototype::method_getUTCDay(const FunctionObject *b, const Value *thisObject, const Value *, int)
1082	{
1083	ExecutionEngine *v4 = b->engine();
1084	double t = getThisDate(v4, thisObject);
1085	if (!std::isnan(x: t))
1086	t = WeekDay(t);
1087	return Encode(t);
1088	}
1089
1090	ReturnedValue DatePrototype::method_getHours(const FunctionObject *b, const Value *thisObject, const Value *, int)
1091	{
1092	ExecutionEngine *v4 = b->engine();
1093	double t = getThisDate(v4, thisObject);
1094	if (!std::isnan(x: t))
1095	t = HourFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1096	return Encode(t);
1097	}
1098
1099	ReturnedValue DatePrototype::method_getUTCHours(const FunctionObject *b, const Value *thisObject, const Value *, int)
1100	{
1101	ExecutionEngine *v4 = b->engine();
1102	double t = getThisDate(v4, thisObject);
1103	if (!std::isnan(x: t))
1104	t = HourFromTime(t);
1105	return Encode(t);
1106	}
1107
1108	ReturnedValue DatePrototype::method_getMinutes(const FunctionObject *b, const Value *thisObject, const Value *, int)
1109	{
1110	ExecutionEngine *v4 = b->engine();
1111	double t = getThisDate(v4, thisObject);
1112	if (!std::isnan(x: t))
1113	t = MinFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1114	return Encode(t);
1115	}
1116
1117	ReturnedValue DatePrototype::method_getUTCMinutes(const FunctionObject *b, const Value *thisObject, const Value *, int)
1118	{
1119	ExecutionEngine *v4 = b->engine();
1120	double t = getThisDate(v4, thisObject);
1121	if (!std::isnan(x: t))
1122	t = MinFromTime(t);
1123	return Encode(t);
1124	}
1125
1126	ReturnedValue DatePrototype::method_getSeconds(const FunctionObject *b, const Value *thisObject, const Value *, int)
1127	{
1128	ExecutionEngine *v4 = b->engine();
1129	double t = getThisDate(v4, thisObject);
1130	if (!std::isnan(x: t))
1131	t = SecFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1132	return Encode(t);
1133	}
1134
1135	ReturnedValue DatePrototype::method_getUTCSeconds(const FunctionObject *b, const Value *thisObject, const Value *, int)
1136	{
1137	ExecutionEngine *v4 = b->engine();
1138	double t = getThisDate(v4, thisObject);
1139	if (!std::isnan(x: t))
1140	t = SecFromTime(t);
1141	return Encode(t);
1142	}
1143
1144	ReturnedValue DatePrototype::method_getMilliseconds(const FunctionObject *b, const Value *thisObject, const Value *, int)
1145	{
1146	ExecutionEngine *v4 = b->engine();
1147	double t = getThisDate(v4, thisObject);
1148	if (!std::isnan(x: t))
1149	t = msFromTime(t: LocalTime(t, localTZA: v4->localTZA));
1150	return Encode(t);
1151	}
1152
1153	ReturnedValue DatePrototype::method_getUTCMilliseconds(const FunctionObject *b, const Value *thisObject, const Value *, int)
1154	{
1155	ExecutionEngine *v4 = b->engine();
1156	double t = getThisDate(v4, thisObject);
1157	if (!std::isnan(x: t))
1158	t = msFromTime(t);
1159	return Encode(t);
1160	}
1161
1162	ReturnedValue DatePrototype::method_getTimezoneOffset(const FunctionObject *b, const Value *thisObject, const Value *, int)
1163	{
1164	ExecutionEngine *v4 = b->engine();
1165	double t = getThisDate(v4, thisObject);
1166	if (!std::isnan(x: t))
1167	t = (t - LocalTime(t, localTZA: v4->localTZA)) / msPerMinute;
1168	return Encode(t);
1169	}
1170
1171	ReturnedValue DatePrototype::method_setTime(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1172	{
1173	ExecutionEngine *v4 = b->engine();
1174	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1175	if (!self)
1176	return v4->throwTypeError();
1177
1178	double t = argc ? argv[0].toNumber() : qt_qnan();
1179	if (v4->hasException)
1180	return QV4::Encode::undefined();
1181	self->setDate(t);
1182	return Encode(self->date());
1183	}
1184
1185	ReturnedValue DatePrototype::method_setMilliseconds(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1186	{
1187	ExecutionEngine *v4 = b->engine();
1188	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1189	if (!self)
1190	return v4->throwTypeError();
1191
1192	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1193	if (v4->hasException)
1194	return QV4::Encode::undefined();
1195	double ms = argc ? argv[0].toNumber() : qt_qnan();
1196	if (v4->hasException)
1197	return QV4::Encode::undefined();
1198	self->setDate(UTC(t: MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min: MinFromTime(t), sec: SecFromTime(t), ms)), localTZA: v4->localTZA));
1199	return Encode(self->date());
1200	}
1201
1202	ReturnedValue DatePrototype::method_setUTCMilliseconds(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1203	{
1204	ExecutionEngine *v4 = b->engine();
1205	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1206	if (!self)
1207	return v4->throwTypeError();
1208
1209	double t = self->date();
1210	if (v4->hasException)
1211	return QV4::Encode::undefined();
1212	double ms = argc ? argv[0].toNumber() : qt_qnan();
1213	if (v4->hasException)
1214	return QV4::Encode::undefined();
1215	self->setDate(MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min: MinFromTime(t), sec: SecFromTime(t), ms)));
1216	return Encode(self->date());
1217	}
1218
1219	ReturnedValue DatePrototype::method_setSeconds(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1220	{
1221	ExecutionEngine *v4 = b->engine();
1222	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1223	if (!self)
1224	return v4->throwTypeError();
1225
1226	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1227	if (v4->hasException)
1228	return QV4::Encode::undefined();
1229	double sec = argc ? argv[0].toNumber() : qt_qnan();
1230	if (v4->hasException)
1231	return QV4::Encode::undefined();
1232	double ms = (argc < 2) ? msFromTime(t) : argv[1].toNumber();
1233	if (v4->hasException)
1234	return QV4::Encode::undefined();
1235	t = UTC(t: MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min: MinFromTime(t), sec, ms)), localTZA: v4->localTZA);
1236	self->setDate(t);
1237	return Encode(self->date());
1238	}
1239
1240	ReturnedValue DatePrototype::method_setUTCSeconds(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1241	{
1242	ExecutionEngine *v4 = b->engine();
1243	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1244	if (!self)
1245	return v4->throwTypeError();
1246
1247	double t = self->date();
1248	double sec = argc ? argv[0].toNumber() : qt_qnan();
1249	double ms = (argc < 2) ? msFromTime(t) : argv[1].toNumber();
1250	t = MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min: MinFromTime(t), sec, ms));
1251	self->setDate(t);
1252	return Encode(self->date());
1253	}
1254
1255	ReturnedValue DatePrototype::method_setMinutes(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1256	{
1257	ExecutionEngine *v4 = b->engine();
1258	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1259	if (!self)
1260	return v4->throwTypeError();
1261
1262	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1263	if (v4->hasException)
1264	return QV4::Encode::undefined();
1265	double min = argc ? argv[0].toNumber() : qt_qnan();
1266	if (v4->hasException)
1267	return QV4::Encode::undefined();
1268	double sec = (argc < 2) ? SecFromTime(t) : argv[1].toNumber();
1269	if (v4->hasException)
1270	return QV4::Encode::undefined();
1271	double ms = (argc < 3) ? msFromTime(t) : argv[2].toNumber();
1272	if (v4->hasException)
1273	return QV4::Encode::undefined();
1274	t = UTC(t: MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min, sec, ms)), localTZA: v4->localTZA);
1275	self->setDate(t);
1276	return Encode(self->date());
1277	}
1278
1279	ReturnedValue DatePrototype::method_setUTCMinutes(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1280	{
1281	ExecutionEngine *v4 = b->engine();
1282	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1283	if (!self)
1284	return v4->throwTypeError();
1285
1286	double t = self->date();
1287	double min = argc ? argv[0].toNumber() : qt_qnan();
1288	double sec = (argc < 2) ? SecFromTime(t) : argv[1].toNumber();
1289	double ms = (argc < 3) ? msFromTime(t) : argv[2].toNumber();
1290	t = MakeDate(day: Day(t), time: MakeTime(hour: HourFromTime(t), min, sec, ms));
1291	self->setDate(t);
1292	return Encode(self->date());
1293	}
1294
1295	ReturnedValue DatePrototype::method_setHours(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1296	{
1297	ExecutionEngine *v4 = b->engine();
1298	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1299	if (!self)
1300	return v4->throwTypeError();
1301
1302	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1303	if (v4->hasException)
1304	return QV4::Encode::undefined();
1305	double hour = argc ? argv[0].toNumber() : qt_qnan();
1306	if (v4->hasException)
1307	return QV4::Encode::undefined();
1308	double min = (argc < 2) ? MinFromTime(t) : argv[1].toNumber();
1309	if (v4->hasException)
1310	return QV4::Encode::undefined();
1311	double sec = (argc < 3) ? SecFromTime(t) : argv[2].toNumber();
1312	if (v4->hasException)
1313	return QV4::Encode::undefined();
1314	double ms = (argc < 4) ? msFromTime(t) : argv[3].toNumber();
1315	if (v4->hasException)
1316	return QV4::Encode::undefined();
1317	t = UTC(t: MakeDate(day: Day(t), time: MakeTime(hour, min, sec, ms)), localTZA: v4->localTZA);
1318	self->setDate(t);
1319	return Encode(self->date());
1320	}
1321
1322	ReturnedValue DatePrototype::method_setUTCHours(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1323	{
1324	ExecutionEngine *v4 = b->engine();
1325	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1326	if (!self)
1327	return v4->throwTypeError();
1328
1329	double t = self->date();
1330	double hour = argc ? argv[0].toNumber() : qt_qnan();
1331	double min = (argc < 2) ? MinFromTime(t) : argv[1].toNumber();
1332	double sec = (argc < 3) ? SecFromTime(t) : argv[2].toNumber();
1333	double ms = (argc < 4) ? msFromTime(t) : argv[3].toNumber();
1334	t = MakeDate(day: Day(t), time: MakeTime(hour, min, sec, ms));
1335	self->setDate(t);
1336	return Encode(self->date());
1337	}
1338
1339	ReturnedValue DatePrototype::method_setDate(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1340	{
1341	ExecutionEngine *v4 = b->engine();
1342	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1343	if (!self)
1344	return v4->throwTypeError();
1345
1346	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1347	if (v4->hasException)
1348	return QV4::Encode::undefined();
1349	double date = argc ? argv[0].toNumber() : qt_qnan();
1350	if (v4->hasException)
1351	return QV4::Encode::undefined();
1352	t = UTC(t: MakeDate(day: MakeDay(year: YearFromTime(t), month: MonthFromTime(t), day: date), time: TimeWithinDay(t)), localTZA: v4->localTZA);
1353	self->setDate(t);
1354	return Encode(self->date());
1355	}
1356
1357	ReturnedValue DatePrototype::method_setUTCDate(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1358	{
1359	ExecutionEngine *v4 = b->engine();
1360	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1361	if (!self)
1362	return v4->throwTypeError();
1363
1364	double t = self->date();
1365	if (v4->hasException)
1366	return QV4::Encode::undefined();
1367	double date = argc ? argv[0].toNumber() : qt_qnan();
1368	if (v4->hasException)
1369	return QV4::Encode::undefined();
1370	t = MakeDate(day: MakeDay(year: YearFromTime(t), month: MonthFromTime(t), day: date), time: TimeWithinDay(t));
1371	self->setDate(t);
1372	return Encode(self->date());
1373	}
1374
1375	ReturnedValue DatePrototype::method_setMonth(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1376	{
1377	ExecutionEngine *v4 = b->engine();
1378	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1379	if (!self)
1380	return v4->throwTypeError();
1381
1382	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1383	if (v4->hasException)
1384	return QV4::Encode::undefined();
1385	double month = argc ? argv[0].toNumber() : qt_qnan();
1386	if (v4->hasException)
1387	return QV4::Encode::undefined();
1388	double date = (argc < 2) ? DateFromTime(t) : argv[1].toNumber();
1389	if (v4->hasException)
1390	return QV4::Encode::undefined();
1391	t = UTC(t: MakeDate(day: MakeDay(year: YearFromTime(t), month, day: date), time: TimeWithinDay(t)), localTZA: v4->localTZA);
1392	self->setDate(t);
1393	return Encode(self->date());
1394	}
1395
1396	ReturnedValue DatePrototype::method_setUTCMonth(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1397	{
1398	ExecutionEngine *v4 = b->engine();
1399	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1400	if (!self)
1401	return v4->throwTypeError();
1402
1403	double t = self->date();
1404	double month = argc ? argv[0].toNumber() : qt_qnan();
1405	double date = (argc < 2) ? DateFromTime(t) : argv[1].toNumber();
1406	t = MakeDate(day: MakeDay(year: YearFromTime(t), month, day: date), time: TimeWithinDay(t));
1407	self->setDate(t);
1408	return Encode(self->date());
1409	}
1410
1411	ReturnedValue DatePrototype::method_setYear(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1412	{
1413	ExecutionEngine *v4 = b->engine();
1414	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1415	if (!self)
1416	return v4->throwTypeError();
1417
1418	double t = self->date();
1419	if (std::isnan(x: t))
1420	t = 0;
1421	else
1422	t = LocalTime(t, localTZA: v4->localTZA);
1423	double year = argc ? argv[0].toNumber() : qt_qnan();
1424	double r;
1425	if (std::isnan(x: year)) {
1426	r = qt_qnan();
1427	} else {
1428	if ((QV4::Value::toInteger(d: year) >= 0) && (QV4::Value::toInteger(d: year) <= 99))
1429	year += 1900;
1430	r = MakeDay(year, month: MonthFromTime(t), day: DateFromTime(t));
1431	r = UTC(t: MakeDate(day: r, time: TimeWithinDay(t)), localTZA: v4->localTZA);
1432	}
1433	self->setDate(r);
1434	return Encode(self->date());
1435	}
1436
1437	ReturnedValue DatePrototype::method_setUTCFullYear(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1438	{
1439	ExecutionEngine *v4 = b->engine();
1440	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1441	if (!self)
1442	return v4->throwTypeError();
1443
1444	double t = self->date();
1445	double year = argc ? argv[0].toNumber() : qt_qnan();
1446	double month = (argc < 2) ? MonthFromTime(t) : argv[1].toNumber();
1447	double date = (argc < 3) ? DateFromTime(t) : argv[2].toNumber();
1448	t = MakeDate(day: MakeDay(year, month, day: date), time: TimeWithinDay(t));
1449	self->setDate(t);
1450	return Encode(self->date());
1451	}
1452
1453	ReturnedValue DatePrototype::method_setFullYear(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1454	{
1455	ExecutionEngine *v4 = b->engine();
1456	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1457	if (!self)
1458	return v4->throwTypeError();
1459
1460	double t = LocalTime(t: self->date(), localTZA: v4->localTZA);
1461	if (v4->hasException)
1462	return QV4::Encode::undefined();
1463	if (std::isnan(x: t))
1464	t = 0;
1465	double year = argc ? argv[0].toNumber() : qt_qnan();
1466	if (v4->hasException)
1467	return QV4::Encode::undefined();
1468	double month = (argc < 2) ? MonthFromTime(t) : argv[1].toNumber();
1469	if (v4->hasException)
1470	return QV4::Encode::undefined();
1471	double date = (argc < 3) ? DateFromTime(t) : argv[2].toNumber();
1472	if (v4->hasException)
1473	return QV4::Encode::undefined();
1474	t = UTC(t: MakeDate(day: MakeDay(year, month, day: date), time: TimeWithinDay(t)), localTZA: v4->localTZA);
1475	self->setDate(t);
1476	return Encode(self->date());
1477	}
1478
1479	ReturnedValue DatePrototype::method_toUTCString(const FunctionObject *b, const Value *thisObject, const Value *, int)
1480	{
1481	ExecutionEngine *v4 = b->engine();
1482	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1483	if (!self)
1484	return v4->throwTypeError();
1485
1486	double t = self->date();
1487	return Encode(v4->newString(s: ToUTCString(t)));
1488	}
1489
1490	static void addZeroPrefixedInt(QString &str, int num, int nDigits)
1491	{
1492	str.resize(size: str.size() + nDigits);
1493
1494	QChar *c = str.data() + str.size() - 1;
1495	while (nDigits) {
1496	*c = QChar(num % 10 + '0');
1497	num /= 10;
1498	--c;
1499	--nDigits;
1500	}
1501	}
1502
1503	ReturnedValue DatePrototype::method_toISOString(const FunctionObject *b, const Value *thisObject, const Value *, int)
1504	{
1505	ExecutionEngine *v4 = b->engine();
1506	DateObject *self = const_cast<DateObject *>(thisObject->as<DateObject>());
1507	if (!self)
1508	return v4->throwTypeError();
1509
1510	double t = self->date();
1511	if (!std::isfinite(x: t))
1512	RETURN_RESULT(v4->throwRangeError(*thisObject));
1513
1514	QString result;
1515	int year = (int)YearFromTime(t);
1516	if (year < 0 || year > 9999) {
1517	if (qAbs(t: year) >= 1000000)
1518	RETURN_RESULT(v4->throwRangeError(*thisObject));
1519	result += year < 0 ? QLatin1Char('-') : QLatin1Char('+');
1520	year = qAbs(t: year);
1521	addZeroPrefixedInt(str&: result, num: year, nDigits: 6);
1522	} else {
1523	addZeroPrefixedInt(str&: result, num: year, nDigits: 4);
1524	}
1525	result += QLatin1Char('-');
1526	addZeroPrefixedInt(str&: result, num: (int)MonthFromTime(t) + 1, nDigits: 2);
1527	result += QLatin1Char('-');
1528	addZeroPrefixedInt(str&: result, num: (int)DateFromTime(t), nDigits: 2);
1529	result += QLatin1Char('T');
1530	addZeroPrefixedInt(str&: result, num: HourFromTime(t), nDigits: 2);
1531	result += QLatin1Char(':');
1532	addZeroPrefixedInt(str&: result, num: MinFromTime(t), nDigits: 2);
1533	result += QLatin1Char(':');
1534	addZeroPrefixedInt(str&: result, num: SecFromTime(t), nDigits: 2);
1535	result += QLatin1Char('.');
1536	addZeroPrefixedInt(str&: result, num: msFromTime(t), nDigits: 3);
1537	result += QLatin1Char('Z');
1538
1539	return Encode(v4->newString(s: result));
1540	}
1541
1542	ReturnedValue DatePrototype::method_toJSON(const FunctionObject *b, const Value *thisObject, const Value *, int)
1543	{
1544	ExecutionEngine *v4 = b->engine();
1545	Scope scope(v4);
1546	ScopedObject O(scope, thisObject->toObject(e: v4));
1547	if (v4->hasException)
1548	return QV4::Encode::undefined();
1549
1550	ScopedValue tv(scope, RuntimeHelpers::toPrimitive(value: O, typeHint: NUMBER_HINT));
1551
1552	if (tv->isNumber() && !std::isfinite(x: tv->toNumber()))
1553	return Encode::null();
1554
1555	ScopedString s(scope, v4->newString(QStringLiteral("toISOString")));
1556	ScopedValue v(scope, O->get(name: s));
1557	FunctionObject *toIso = v->as<FunctionObject>();
1558
1559	if (!toIso)
1560	return v4->throwTypeError();
1561
1562	return checkedResult(v4, result: toIso->call(thisObject: O, argv: nullptr, argc: 0));
1563	}
1564
1565	ReturnedValue DatePrototype::method_symbolToPrimitive(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
1566	{
1567	ExecutionEngine *e = f->engine();
1568	if (!thisObject->isObject() || !argc || !argv->isString())
1569	return e->throwTypeError();
1570
1571	String *hint = argv->stringValue();
1572	PropertyKey id = hint->toPropertyKey();
1573	if (id == e->id_default()->propertyKey())
1574	hint = e->id_string();
1575	else if (id != e->id_string()->propertyKey() && id != e->id_number()->propertyKey())
1576	return e->throwTypeError();
1577
1578	return RuntimeHelpers::ordinaryToPrimitive(engine: e, object: static_cast<const Object *>(thisObject), typeHint: hint);
1579	}
1580
1581	void DatePrototype::timezoneUpdated(ExecutionEngine *e)
1582	{
1583	e->localTZA = getLocalTZA();
1584	}
1585