#include <dateparser.h>

Inheritance diagram for v8::internal::DateParser:

Collaboration diagram for v8::internal::DateParser:

Classes
class	BASE_EMBEDDED

class	DateStringTokenizer

struct	DateToken

class	KeywordTable

Public Types
enum	{ YEAR , MONTH , DAY , HOUR , MINUTE , SECOND , MILLISECOND , UTC_OFFSET , OUTPUT_SIZE }

Static Public Member Functions
template<typename Char >
static bool	Parse (Vector< Char > str, FixedArray output, UnicodeCache cache)

Private Types
enum	KeywordType { INVALID , MONTH_NAME , TIME_ZONE_NAME , TIME_SEPARATOR , AM_PM }

Static Private Member Functions
static bool	Between (int x, int lo, int hi)

static int	ReadMilliseconds (DateToken number)

template<typename Char >
static DateParser::DateToken	ParseES5DateTime (DateStringTokenizer< Char > scanner, DayComposer day, TimeComposer time, TimeZoneComposer tz)

Static Private Attributes
static const int	kNone = kMaxInt

static const int	kMaxSignificantDigits = 9

Detailed Description

Definition at line 14 of file dateparser.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
YEAR
MONTH
DAY
HOUR
MINUTE
SECOND
MILLISECOND
UTC_OFFSET
OUTPUT_SIZE

Definition at line 30 of file dateparser.h.

        {
     YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, MILLISECOND, UTC_OFFSET, OUTPUT_SIZE
   };

◆ KeywordType

enum v8::internal::DateParser::KeywordType

private

Enumerator
INVALID
MONTH_NAME
TIME_ZONE_NAME
TIME_SEPARATOR
AM_PM

Definition at line 137 of file dateparser.h.

                    {
       INVALID, MONTH_NAME, TIME_ZONE_NAME, TIME_SEPARATOR, AM_PM
   };

Member Function Documentation

◆ Between()

static bool v8::internal::DateParser::Between	(	int	x,
		int	lo,
		int	hi
	)

inlinestaticprivate

Definition at line 36 of file dateparser.h.

                                                     {
     return static_cast<unsigned>(x - lo) <= static_cast<unsigned>(hi - lo);
   }

References v8::internal::hi, and v8::internal::lo.

Referenced by v8::internal::DateParser::BASE_EMBEDDED< Char >::IsDay(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsHour(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsHour12(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsMillisecond(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsMinute(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsMonth(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsSecond(), and ParseES5DateTime().

Here is the caller graph for this function:

◆ Parse()

template<typename Char >

bool v8::internal::DateParser::Parse	(	Vector< Char >	str,
		FixedArray *	output,
		UnicodeCache *	cache
	)

static

Definition at line 14 of file dateparser-inl.h.

                                                     {
   DCHECK(out->length() >= OUTPUT_SIZE);
   InputReader<Char> in(unicode_cache, str);
   DateStringTokenizer<Char> scanner(&in);
   TimeZoneComposer tz;
   TimeComposer time;
   DayComposer day;
  
   // Specification:
   // Accept ES5 ISO 8601 date-time-strings or legacy dates compatible
   // with Safari.
   // 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 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 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 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(':')) {
         if (scanner.SkipSymbol(':')) {
           // n + "::"
           if (!time.IsEmpty()) return false;
           time.Add(n);
           time.Add(0);
         } else {
           // n + ":"
           if (!time.Add(n)) return false;
           if (scanner.Peek().IsSymbol('.')) scanner.Next();
         }
       } else if (scanner.SkipSymbol('.') && time.IsExpecting(n)) {
         time.Add(n);
         if (!scanner.Peek().IsNumber()) return false;
         int n = ReadMilliseconds(scanner.Next());
         if (n < 0) return false;
         time.AddFinal(n);
       } else if (tz.IsExpecting(n)) {
         tz.SetAbsoluteMinute(n);
       } else if (time.IsExpecting(n)) {
         time.AddFinal(n);
         // Require end, white space, "Z", "+" or "-" immediately after
         // finalizing time.
         DateToken peek = scanner.Peek();
         if (!peek.IsEndOfInput() &&
             !peek.IsWhiteSpace() &&
             !peek.IsKeywordZ() &&
             !peek.IsAsciiSign()) return false;
       } else {
         if (!day.Add(n)) return false;
         scanner.SkipSymbol('-');
       }
     } else if (token.IsKeyword()) {
       // Parse a "word" (sequence of chars. >= 'A').
       KeywordType type = token.keyword_type();
       int value = token.keyword_value();
       if (type == AM_PM && !time.IsEmpty()) {
         time.SetHourOffset(value);
       } else if (type == MONTH_NAME) {
         day.SetNamedMonth(value);
         scanner.SkipSymbol('-');
       } else if (type == TIME_ZONE_NAME && has_read_number) {
         tz.Set(value);
       } else {
         // Garbage words are illegal if a number has been read.
         if (has_read_number) return false;
         // The first number has to be separated from garbage words by
         // whitespace or other separators.
         if (scanner.Peek().IsNumber()) return false;
       }
     } else if (token.IsAsciiSign() && (tz.IsUTC() || !time.IsEmpty())) {
       // Parse UTC offset (only after UTC or time).
       tz.SetSign(token.ascii_sign());
       // The following number may be empty.
       int n = 0;
       if (scanner.Peek().IsNumber()) {
         n = scanner.Next().number();
       }
       has_read_number = true;
  
       if (scanner.Peek().IsSymbol(':')) {
         tz.SetAbsoluteHour(n);
         tz.SetAbsoluteMinute(kNone);
       } else {
         tz.SetAbsoluteHour(n / 100);
         tz.SetAbsoluteMinute(n % 100);
       }
     } else if ((token.IsAsciiSign() || token.IsSymbol(')')) &&
                has_read_number) {
       // Extra sign or ')' is illegal if a number has been read.
       return false;
     } else {
       // Ignore other characters and whitespace.
     }
   }
  
   return day.Write(out) && time.Write(out) && tz.Write(out);
 }

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ParseES5DateTime()

template<typename Char >

DateParser::DateToken v8::internal::DateParser::ParseES5DateTime	(	DateStringTokenizer< Char > *	scanner,
		DayComposer *	day,
		TimeComposer *	time,
		TimeZoneComposer *	tz
	)

staticprivate

Definition at line 198 of file dateparser-inl.h.

                           {
   DCHECK(day->IsEmpty());
   DCHECK(time->IsEmpty());
   DCHECK(tz->IsEmpty());
  
   // Parse mandatory date string: [('-'|'+')yy]yyyy[':'MM[':'DD]]
   if (scanner->Peek().IsAsciiSign()) {
     // Keep the sign token, so we can pass it back to the legacy
     // parser if we don't use it.
     DateToken sign_token = scanner->Next();
     if (!scanner->Peek().IsFixedLengthNumber(6)) return sign_token;
     int sign = sign_token.ascii_sign();
     int year = scanner->Next().number();
     if (sign < 0 && year == 0) return sign_token;
     day->Add(sign * year);
   } else if (scanner->Peek().IsFixedLengthNumber(4)) {
     day->Add(scanner->Next().number());
   } else {
     return scanner->Next();
   }
   if (scanner->SkipSymbol('-')) {
     if (!scanner->Peek().IsFixedLengthNumber(2) ||
         !DayComposer::IsMonth(scanner->Peek().number())) return scanner->Next();
     day->Add(scanner->Next().number());
     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 {
     // 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) ||
         !TimeComposer::IsMinute(scanner->Peek().number()) ||
         (hour_is_24 && scanner->Peek().number() > 0)) {
       return DateToken::Invalid();
     }
     time->Add(scanner->Next().number());
     if (scanner->SkipSymbol(':')) {
       if (!scanner->Peek().IsFixedLengthNumber(2) ||
           !TimeComposer::IsSecond(scanner->Peek().number()) ||
           (hour_is_24 && scanner->Peek().number() > 0)) {
         return DateToken::Invalid();
       }
       time->Add(scanner->Next().number());
       if (scanner->SkipSymbol('.')) {
         if (!scanner->Peek().IsNumber() ||
             (hour_is_24 && scanner->Peek().number() > 0)) {
           return DateToken::Invalid();
         }
         // Allow more or less than the mandated three digits.
         time->Add(ReadMilliseconds(scanner->Next()));
       }
     }
     // Check for optional timezone designation: 'Z' | ('+'|'-')hh':'mm
     if (scanner->Peek().IsKeywordZ()) {
       scanner->Next();
       tz->Set(0);
     } else if (scanner->Peek().IsSymbol('+') ||
                scanner->Peek().IsSymbol('-')) {
       tz->SetSign(scanner->Next().symbol() == '+' ? 1 : -1);
       if (scanner->Peek().IsFixedLengthNumber(4)) {
         // hhmm extension syntax.
         int hourmin = scanner->Next().number();
         int hour = hourmin / 100;
         int min = hourmin % 100;
         if (!TimeComposer::IsHour(hour) || !TimeComposer::IsMinute(min)) {
           return DateToken::Invalid();
         }
         tz->SetAbsoluteHour(hour);
         tz->SetAbsoluteMinute(min);
       } else {
         // hh:mm standard syntax.
         if (!scanner->Peek().IsFixedLengthNumber(2) ||
             !TimeComposer::IsHour(scanner->Peek().number())) {
           return DateToken::Invalid();
         }
         tz->SetAbsoluteHour(scanner->Next().number());
         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 ES5 Date Time String. Default to UTC if no TZ given.
   if (tz->IsEmpty()) tz->Set(0);
   day->set_iso_date();
   return DateToken::EndOfInput();
 }

Referenced by Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadMilliseconds()

int v8::internal::DateParser::ReadMilliseconds ( DateToken number )

staticprivate

Definition at line 159 of file dateparser.cc.

                                                 {
   // Read first three significant digits of the original numeral,
   // as inferred from the value and the number of digits.
   // I.e., use the number of digits to see if there were
   // leading zeros.
   int number = token.number();
   int length = token.length();
   if (length < 3) {
     // Less than three digits. Multiply to put most significant digit
     // in hundreds position.
     if (length == 1) {
       number *= 100;
     } else if (length == 2) {
       number *= 10;
     }
   } else if (length > 3) {
     if (length > kMaxSignificantDigits) length = kMaxSignificantDigits;
     // More than three digits. Divide by 10^(length - 3) to get three
     // most significant digits.
     int factor = 1;
     do {
       DCHECK(factor <= 100000000);  // factor won't overflow.
       factor *= 10;
       length--;
     } while (length > 3);
     number /= factor;
   }
   return number;
 }

References DCHECK, kMaxSignificantDigits, v8::internal::DateParser::DateToken::length(), and v8::internal::DateParser::DateToken::number().

Referenced by Parse(), and ParseES5DateTime().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ kMaxSignificantDigits

const int v8::internal::DateParser::kMaxSignificantDigits = 9

staticprivate

Definition at line 45 of file dateparser.h.

Referenced by ReadMilliseconds(), and v8::internal::DateParser::BASE_EMBEDDED< Char >::ReadUnsignedNumeral().

◆ kNone

const int v8::internal::DateParser::kNone = kMaxInt

staticprivate

Definition at line 41 of file dateparser.h.

Referenced by v8::internal::DateParser::BASE_EMBEDDED< Char >::IsEmpty(), v8::internal::DateParser::BASE_EMBEDDED< Char >::IsExpecting(), and Parse().

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/dateparser.h
/mnt/V8SourceCode/src/dateparser-inl.h
/mnt/V8SourceCode/src/dateparser.cc

Classes

Public Types

Static Public Member Functions

Private Types

Static Private Member Functions

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ KeywordType

Member Function Documentation

◆ Between()

◆ Parse()

◆ ParseES5DateTime()

◆ ReadMilliseconds()

Member Data Documentation

◆ kMaxSignificantDigits

◆ kNone