src/dateparser.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_DATEPARSER_H_
   6 #define V8_DATEPARSER_H_
   7
   8 #include "src/allocation.h"
   9 #include "src/char-predicates.h"
  10 #include "src/scanner.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15 class DateParser : public AllStatic {
  16  public:
  17   // Parse the string as a date. If parsing succeeds, return true after
  18   // filling out the output array as follows (all integers are Smis):
  19   // [0]: year
  20   // [1]: month (0 = Jan, 1 = Feb, ...)
  21   // [2]: day
  22   // [3]: hour
  23   // [4]: minute
  24   // [5]: second
  25   // [6]: millisecond
  26   // [7]: UTC offset in seconds, or null value if no timezone specified
  27   // If parsing fails, return false (content of output array is not defined).
  28   template <typename Char>
  29   static bool Parse(Vector<Char> str, FixedArray* output, UnicodeCache* cache);
  30
  31   enum {
  32     YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, MILLISECOND, UTC_OFFSET, OUTPUT_SIZE
  33   };
  34
  35  private:
  36   // Range testing
  37   static inline bool Between(int x, int lo, int hi) {
  38     return static_cast<unsigned>(x - lo) <= static_cast<unsigned>(hi - lo);
  39   }
  40
  41   // Indicates a missing value.
  42   static const int kNone = kMaxInt;
  43
  44   // Maximal number of digits used to build the value of a numeral.
  45   // Remaining digits are ignored.
  46   static const int kMaxSignificantDigits = 9;
  47
  48   // InputReader provides basic string parsing and character classification.
  49   template <typename Char>
  50   class InputReader BASE_EMBEDDED {
  51    public:
  52     InputReader(UnicodeCache* unicode_cache, Vector<Char> s)
  53         : index_(0),
  54           buffer_(s),
  55           unicode_cache_(unicode_cache) {
  56       Next();
  57     }
  58
  59     int position() { return index_; }
  60
  61     // Advance to the next character of the string.
  62     void Next() {
  63       ch_ = (index_ < buffer_.length()) ? buffer_[index_] : 0;
  64       index_++;
  65     }
  66
  67     // Read a string of digits as an unsigned number. Cap value at
  68     // kMaxSignificantDigits, but skip remaining digits if the numeral
  69     // is longer.
  70     int ReadUnsignedNumeral() {
  71       int n = 0;
  72       int i = 0;
  73       while (IsAsciiDigit()) {
  74         if (i < kMaxSignificantDigits) n = n * 10 + ch_ - '0';
  75         i++;
  76         Next();
  77       }
  78       return n;
  79     }
  80
  81     // Read a word (sequence of chars. >= 'A'), fill the given buffer with a
  82     // lower-case prefix, and pad any remainder of the buffer with zeroes.
  83     // Return word length.
  84     int ReadWord(uint32_t* prefix, int prefix_size) {
  85       int len;
  86       for (len = 0; IsAsciiAlphaOrAbove(); Next(), len++) {
  87         if (len < prefix_size) prefix[len] = AsciiAlphaToLower(ch_);
  88       }
  89       for (int i = len; i < prefix_size; i++) prefix[i] = 0;
  90       return len;
  91     }
  92
  93     // The skip methods return whether they actually skipped something.
  94     bool Skip(uint32_t c) {
  95       if (ch_ == c) {
  96         Next();
  97         return true;
  98       }
  99       return false;
 100     }
 101
 102     inline bool SkipWhiteSpace();
 103     inline bool SkipParentheses();
 104
 105     // Character testing/classification. Non-ASCII digits are not supported.
 106     bool Is(uint32_t c) const { return ch_ == c; }
 107     bool IsEnd() const { return ch_ == 0; }
 108     bool IsAsciiDigit() const { return IsDecimalDigit(ch_); }
 109     bool IsAsciiAlphaOrAbove() const { return ch_ >= 'A'; }
 110     bool IsAsciiSign() const { return ch_ == '+' || ch_ == '-'; }
 111
 112     // Return 1 for '+' and -1 for '-'.
 113     int GetAsciiSignValue() const { return 44 - static_cast<int>(ch_); }
 114
 115    private:
 116     int index_;
 117     Vector<Char> buffer_;
 118     uint32_t ch_;
 119     UnicodeCache* unicode_cache_;
 120   };
 121
 122   enum KeywordType {
 123       INVALID, MONTH_NAME, TIME_ZONE_NAME, TIME_SEPARATOR, AM_PM
 124   };
 125
 126   struct DateToken {
 127    public:
 128     bool IsInvalid() { return tag_ == kInvalidTokenTag; }
 129     bool IsUnknown() { return tag_ == kUnknownTokenTag; }
 130     bool IsNumber() { return tag_ == kNumberTag; }
 131     bool IsSymbol() { return tag_ == kSymbolTag; }
 132     bool IsWhiteSpace() { return tag_ == kWhiteSpaceTag; }
 133     bool IsEndOfInput() { return tag_ == kEndOfInputTag; }
 134     bool IsKeyword() { return tag_ >= kKeywordTagStart; }
 135
 136     int length() { return length_; }
 137
 138     int number() {
 139       DCHECK(IsNumber());
 140       return value_;
 141     }
 142     KeywordType keyword_type() {
 143       DCHECK(IsKeyword());
 144       return static_cast<KeywordType>(tag_);
 145     }
 146     int keyword_value() {
 147       DCHECK(IsKeyword());
 148       return value_;
 149     }
 150     char symbol() {
 151       DCHECK(IsSymbol());
 152       return static_cast<char>(value_);
 153     }
 154     bool IsSymbol(char symbol) {
 155       return IsSymbol() && this->symbol() == symbol;
 156     }
 157     bool IsKeywordType(KeywordType tag) {
 158       return tag_ == tag;
 159     }
 160     bool IsFixedLengthNumber(int length) {
 161       return IsNumber() && length_ == length;
 162     }
 163     bool IsAsciiSign() {
 164       return tag_ == kSymbolTag && (value_ == '-' || value_ == '+');
 165     }
 166     int ascii_sign() {
 167       DCHECK(IsAsciiSign());
 168       return 44 - value_;
 169     }
 170     bool IsKeywordZ() {
 171       return IsKeywordType(TIME_ZONE_NAME) && length_ == 1 && value_ == 0;
 172     }
 173     bool IsUnknown(int character) {
 174       return IsUnknown() && value_ == character;
 175     }
 176     // Factory functions.
 177     static DateToken Keyword(KeywordType tag, int value, int length) {
 178       return DateToken(tag, length, value);
 179     }
 180     static DateToken Number(int value, int length) {
 181       return DateToken(kNumberTag, length, value);
 182     }
 183     static DateToken Symbol(char symbol) {
 184       return DateToken(kSymbolTag, 1, symbol);
 185     }
 186     static DateToken EndOfInput() {
 187       return DateToken(kEndOfInputTag, 0, -1);
 188     }
 189     static DateToken WhiteSpace(int length) {
 190       return DateToken(kWhiteSpaceTag, length, -1);
 191     }
 192     static DateToken Unknown() {
 193       return DateToken(kUnknownTokenTag, 1, -1);
 194     }
 195     static DateToken Invalid() {
 196       return DateToken(kInvalidTokenTag, 0, -1);
 197     }
 198
 199    private:
 200     enum TagType {
 201       kInvalidTokenTag = -6,
 202       kUnknownTokenTag = -5,
 203       kWhiteSpaceTag = -4,
 204       kNumberTag = -3,
 205       kSymbolTag = -2,
 206       kEndOfInputTag = -1,
 207       kKeywordTagStart = 0
 208     };
 209     DateToken(int tag, int length, int value)
 210         : tag_(tag),
 211           length_(length),
 212           value_(value) { }
 213
 214     int tag_;
 215     int length_;  // Number of characters.
 216     int value_;
 217   };
 218
 219   template <typename Char>
 220   class DateStringTokenizer {
 221    public:
 222     explicit DateStringTokenizer(InputReader<Char>* in)
 223         : in_(in), next_(Scan()) { }
 224     DateToken Next() {
 225       DateToken result = next_;
 226       next_ = Scan();
 227       return result;
 228     }
 229
 230     DateToken Peek() {
 231       return next_;
 232     }
 233     bool SkipSymbol(char symbol) {
 234       if (next_.IsSymbol(symbol)) {
 235         next_ = Scan();
 236         return true;
 237       }
 238       return false;
 239     }
 240
 241    private:
 242     DateToken Scan();
 243
 244     InputReader<Char>* in_;
 245     DateToken next_;
 246   };
 247
 248   static int ReadMilliseconds(DateToken number);
 249
 250   // KeywordTable maps names of months, time zones, am/pm to numbers.
 251   class KeywordTable : public AllStatic {
 252    public:
 253     // Look up a word in the keyword table and return an index.
 254     // 'pre' contains a prefix of the word, zero-padded to size kPrefixLength
 255     // and 'len' is the word length.
 256     static int Lookup(const uint32_t* pre, int len);
 257     // Get the type of the keyword at index i.
 258     static KeywordType GetType(int i) {
 259       return static_cast<KeywordType>(array[i][kTypeOffset]);
 260     }
 261     // Get the value of the keyword at index i.
 262     static int GetValue(int i) { return array[i][kValueOffset]; }
 263
 264     static const int kPrefixLength = 3;
 265     static const int kTypeOffset = kPrefixLength;
 266     static const int kValueOffset = kTypeOffset + 1;
 267     static const int kEntrySize = kValueOffset + 1;
 268     static const int8_t array[][kEntrySize];
 269   };
 270
 271   class TimeZoneComposer BASE_EMBEDDED {
 272    public:
 273     TimeZoneComposer() : sign_(kNone), hour_(kNone), minute_(kNone) {}
 274     void Set(int offset_in_hours) {
 275       sign_ = offset_in_hours < 0 ? -1 : 1;
 276       hour_ = offset_in_hours * sign_;
 277       minute_ = 0;
 278     }
 279     void SetSign(int sign) { sign_ = sign < 0 ? -1 : 1; }
 280     void SetAbsoluteHour(int hour) { hour_ = hour; }
 281     void SetAbsoluteMinute(int minute) { minute_ = minute; }
 282     bool IsExpecting(int n) const {
 283       return hour_ != kNone && minute_ == kNone && TimeComposer::IsMinute(n);
 284     }
 285     bool IsUTC() const { return hour_ == 0 && minute_ == 0; }
 286     bool Write(FixedArray* output);
 287     bool IsEmpty() { return hour_ == kNone; }
 288    private:
 289     int sign_;
 290     int hour_;
 291     int minute_;
 292   };
 293
 294   class TimeComposer BASE_EMBEDDED {
 295    public:
 296     TimeComposer() : index_(0), hour_offset_(kNone) {}
 297     bool IsEmpty() const { return index_ == 0; }
 298     bool IsExpecting(int n) const {
 299       return (index_ == 1 && IsMinute(n)) ||
 300              (index_ == 2 && IsSecond(n)) ||
 301              (index_ == 3 && IsMillisecond(n));
 302     }
 303     bool Add(int n) {
 304       return index_ < kSize ? (comp_[index_++] = n, true) : false;
 305     }
 306     bool AddFinal(int n) {
 307       if (!Add(n)) return false;
 308       while (index_ < kSize) comp_[index_++] = 0;
 309       return true;
 310     }
 311     void SetHourOffset(int n) { hour_offset_ = n; }
 312     bool Write(FixedArray* output);
 313
 314     static bool IsMinute(int x) { return Between(x, 0, 59); }
 315     static bool IsHour(int x) { return Between(x, 0, 23); }
 316     static bool IsSecond(int x) { return Between(x, 0, 59); }
 317
 318    private:
 319     static bool IsHour12(int x) { return Between(x, 0, 12); }
 320     static bool IsMillisecond(int x) { return Between(x, 0, 999); }
 321
 322     static const int kSize = 4;
 323     int comp_[kSize];
 324     int index_;
 325     int hour_offset_;
 326   };
 327
 328   class DayComposer BASE_EMBEDDED {
 329    public:
 330     DayComposer() : index_(0), named_month_(kNone), is_iso_date_(false) {}
 331     bool IsEmpty() const { return index_ == 0; }
 332     bool Add(int n) {
 333       if (index_ < kSize) {
 334         comp_[index_] = n;
 335         index_++;
 336         return true;
 337       }
 338       return false;
 339     }
 340     void SetNamedMonth(int n) { named_month_ = n; }
 341     bool Write(FixedArray* output);
 342     void set_iso_date() { is_iso_date_ = true; }
 343     static bool IsMonth(int x) { return Between(x, 1, 12); }
 344     static bool IsDay(int x) { return Between(x, 1, 31); }
 345
 346    private:
 347     static const int kSize = 3;
 348     int comp_[kSize];
 349     int index_;
 350     int named_month_;
 351     // If set, ensures that data is always parsed in year-month-date order.
 352     bool is_iso_date_;
 353   };
 354
 355   // Tries to parse an ES6 Date Time String. Returns the next token
 356   // to continue with in the legacy date string parser. If parsing is
 357   // complete, returns DateToken::EndOfInput(). If terminally unsuccessful,
 358   // returns DateToken::Invalid(). Otherwise parsing continues in the
 359   // legacy parser.
 360   template <typename Char>
 361   static DateParser::DateToken ParseES6DateTime(
 362       DateStringTokenizer<Char>* scanner,
 363       DayComposer* day,
 364       TimeComposer* time,
 365       TimeZoneComposer* tz);
 366 };
 367
 368
 369 } }  // namespace v8::internal
 370
 371 #endif  // V8_DATEPARSER_H_