Version 4.6.85.28 (cherry-pick)

src/dateparser-inl.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_DATEPARSER_INL_H_
 #define V8_DATEPARSER_INL_H_
 
 #include "src/char-predicates-inl.h"
 #include "src/dateparser.h"
 
 namespace v8 {
 namespace internal {
 
 template <typename Char>
 bool DateParser::Parse(Vector<Char> str,
                        FixedArray* out,
                        UnicodeCache* unicode_cache) {
   DCHECK(out->length() >= OUTPUT_SIZE);
   InputReader<Char> in(unicode_cache, str);
   DateStringTokenizer<Char> scanner(&in);
   TimeZoneComposer tz;
   TimeComposer time;
   DayComposer day;
 
   // Specification:
-  // Accept ES6 ISO 8601 date-time-strings or legacy dates compatible
+  // Accept ES5 ISO 8601 date-time-strings or legacy dates compatible
   // with Safari.
-  // ES6 ISO 8601 dates:
+  // ES5 ISO 8601 dates:
   //   [('-'|'+')yy]yyyy[-MM[-DD]][THH:mm[:ss[.sss]][Z|(+|-)hh:mm]]
   //   where yyyy is in the range 0000..9999 and
   //         +/-yyyyyy is in the range -999999..+999999 -
   //           but -000000 is invalid (year zero must be positive),
   //         MM is in the range 01..12,
   //         DD is in the range 01..31,
   //         MM and DD defaults to 01 if missing,,
   //         HH is generally in the range 00..23, but can be 24 if mm, ss
   //           and sss are zero (or missing), representing midnight at the
   //           end of a day,
   //         mm and ss are in the range 00..59,
   //         sss is in the range 000..999,
   //         hh is in the range 00..23,
   //         mm, ss, and sss default to 00 if missing, and
-  //         timezone defaults to local time if missing.
+  //         timezone defaults to Z if missing
+  //           (following Safari, ISO actually demands local time).
   //  Extensions:
   //   We also allow sss to have more or less than three digits (but at
   //   least one).
   //   We allow hh:mm to be specified as hhmm.
   // Legacy dates:
   //  Any unrecognized word before the first number is ignored.
   //  Parenthesized text is ignored.
   //  An unsigned number followed by ':' is a time value, and is
   //  added to the TimeComposer. A number followed by '::' adds a second
   //  zero as well. A number followed by '.' is also a time and must be
   //  followed by milliseconds.
   //  Any other number is a date component and is added to DayComposer.
   //  A month name (or really: any word having the same first three letters
   //  as a month name) is recorded as a named month in the Day composer.
   //  A word recognizable as a time-zone is recorded as such, as is
   //  '(+|-)(hhmm|hh:)'.
   //  Legacy dates don't allow extra signs ('+' or '-') or umatched ')'
   //  after a number has been read (before the first number, any garbage
   //  is allowed).
   // Intersection of the two:
   //  A string that matches both formats (e.g. 1970-01-01) will be
-  //  parsed as an ES6 date-time string.
-  //  After a valid "T" has been read while scanning an ES6 datetime string,
+  //  parsed as an ES5 date-time string - which means it will default
+  //  to UTC time-zone. That's unavoidable if following the ES5
+  //  specification.
+  //  After a valid "T" has been read while scanning an ES5 datetime string,
   //  the input can no longer be a valid legacy date, since the "T" is a
   //  garbage string after a number has been read.
 
-  // First try getting as far as possible with as ES6 Date Time String.
-  DateToken next_unhandled_token = ParseES6DateTime(&scanner, &day, &time, &tz);
+  // First try getting as far as possible with as ES5 Date Time String.
+  DateToken next_unhandled_token = ParseES5DateTime(&scanner, &day, &time, &tz);
   if (next_unhandled_token.IsInvalid()) return false;
   bool has_read_number = !day.IsEmpty();
   // If there's anything left, continue with the legacy parser.
   for (DateToken token = next_unhandled_token;
        !token.IsEndOfInput();
        token = scanner.Next()) {
     if (token.IsNumber()) {
       has_read_number = true;
       int n = token.number();
       if (scanner.SkipSymbol(':')) {
@@ skipping 104 matching lines @@
   }
   if (in_->SkipParentheses()) {
     return DateToken::Unknown();
   }
   in_->Next();
   return DateToken::Unknown();
 }
 
 
 template <typename Char>
-DateParser::DateToken DateParser::ParseES6DateTime(
+DateParser::DateToken DateParser::ParseES5DateTime(
     DateStringTokenizer<Char>* scanner,
     DayComposer* day,
     TimeComposer* time,
     TimeZoneComposer* tz) {
   DCHECK(day->IsEmpty());
   DCHECK(time->IsEmpty());
   DCHECK(tz->IsEmpty());
 
   // Parse mandatory date string: [('-'|'+')yy]yyyy[':'MM[':'DD]]
   if (scanner->Peek().IsAsciiSign()) {
@@ skipping 17 matching lines @@
     if (scanner->SkipSymbol('-')) {
       if (!scanner->Peek().IsFixedLengthNumber(2) ||
           !DayComposer::IsDay(scanner->Peek().number())) return scanner->Next();
       day->Add(scanner->Next().number());
     }
   }
   // Check for optional time string: 'T'HH':'mm[':'ss['.'sss]]Z
   if (!scanner->Peek().IsKeywordType(TIME_SEPARATOR)) {
     if (!scanner->Peek().IsEndOfInput()) return scanner->Next();
   } else {
-    // ES6 Date Time String time part is present.
+    // ES5 Date Time String time part is present.
     scanner->Next();
     if (!scanner->Peek().IsFixedLengthNumber(2) ||
         !Between(scanner->Peek().number(), 0, 24)) {
       return DateToken::Invalid();
     }
     // Allow 24:00[:00[.000]], but no other time starting with 24.
     bool hour_is_24 = (scanner->Peek().number() == 24);
     time->Add(scanner->Next().number());
     if (!scanner->SkipSymbol(':')) return DateToken::Invalid();
     if (!scanner->Peek().IsFixedLengthNumber(2) ||
@@ skipping 45 matching lines @@
         if (!scanner->SkipSymbol(':')) return DateToken::Invalid();
         if (!scanner->Peek().IsFixedLengthNumber(2) ||
             !TimeComposer::IsMinute(scanner->Peek().number())) {
           return DateToken::Invalid();
         }
         tz->SetAbsoluteMinute(scanner->Next().number());
       }
     }
     if (!scanner->Peek().IsEndOfInput()) return DateToken::Invalid();
   }
-  // Successfully parsed ES6 Date Time String.
+  // Successfully parsed ES5 Date Time String. Default to UTC if no TZ given.
+  if (tz->IsEmpty()) tz->Set(0);
   day->set_iso_date();
   return DateToken::EndOfInput();
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DATEPARSER_INL_H_