Made Date parser work on flat strings instead of arbitrary ones.

src/dateparser.h

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_DATEPARSER_H_
 #define V8_DATEPARSER_H_
 
 #include "scanner.h"
 
 namespace v8 { namespace internal {
 
-
 class DateParser : public AllStatic {
  public:
 
   // Parse the string as a date. If parsing succeeds, return true after
   // filling out the output array as follows (all integers are Smis):
   // [0]: year
   // [1]: month (0 = Jan, 1 = Feb, ...)
   // [2]: day
   // [3]: hour
   // [4]: minute
   // [5]: second
   // [6]: UTC offset in seconds, or null value if no timezone specified
   // If parsing fails, return false (content of output array is not defined).
-  static bool Parse(String* str, FixedArray* output);
+  template <typename Char>
+  static bool Parse(Vector<Char> str, FixedArray* output);
 
   enum {YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, UTC_OFFSET, OUTPUT_SIZE};
 
  private:
   // Range testing
-  static bool Between(int x, int lo, int hi) { return x >= lo && x <= hi; }
+  static inline bool Between(int x, int lo, int hi) {
+    return static_cast<unsigned>(x - lo) <= static_cast<unsigned>(hi - lo);
+  }
   // Indicates a missing value.
   static const int kNone = kMaxInt;
 
   // InputReader provides basic string parsing and character classification.
+  template <typename Char>
   class InputReader BASE_EMBEDDED {
    public:
-    explicit InputReader(String* s) : buffer_(s), has_read_number_(false) {
+    explicit InputReader(Vector<Char> s)
+        : index_(0),
+          buffer_(s),
+          has_read_number_(false) {
       Next();
     }
 
     // Advance to the next character of the string.
-    void Next() { ch_ = buffer_.has_more() ? buffer_.GetNext() : 0; }
+    void Next() { ch_ = (index_ < buffer_.length()) ? buffer_[index_++] : 0; }
 
     // Read a string of digits as an unsigned number (cap just below kMaxInt).
     int ReadUnsignedNumber() {
       has_read_number_ = true;
       int n;
       for (n = 0; IsAsciiDigit() && n < kMaxInt / 10 - 1; Next()) {
         n = n * 10 + ch_ - '0';
       }
       return n;
     }
@@ skipping 39 matching lines @@
     int GetAsciiSignValue() const { return 44 - static_cast<int>(ch_); }
 
     // Indicates whether any (possibly empty!) numbers have been read.
     bool HasReadNumber() const { return has_read_number_; }
 
    private:
     // If current character is in 'A'-'Z' or 'a'-'z', return its lower-case.
     // Else, return something outside of 'A'-'Z' and 'a'-'z'.
     uint32_t GetAsciiAlphaLower() const { return ch_ | 32; }
 
-    StringInputBuffer buffer_;
+    int index_;
+    Vector<Char> buffer_;
     bool has_read_number_;
     uint32_t ch_;
   };
 
   enum KeywordType { INVALID, MONTH_NAME, TIME_ZONE_NAME, AM_PM };
 
   // KeywordTable maps names of months, time zones, am/pm to numbers.
   class KeywordTable : public AllStatic {
    public:
     // Look up a word in the keyword table and return an index.
@@ skipping 80 matching lines @@
     static bool IsDay(int x) { return Between(x, 1, 31); }
 
     static const int kSize = 3;
     int comp_[kSize];
     int index_;
     int named_month_;
   };
 };
 
 
+template <typename Char>

[Erik Corry, 2009/03/17 13:09:01]

Since the templates force us to move this to a .h file we should probably move
it to an -inl.h file.

+bool DateParser::Parse(Vector<Char> str, FixedArray* out) {
+  ASSERT(out->length() == OUTPUT_SIZE);
+  InputReader<Char> in(str);
+  TimeZoneComposer tz;
+  TimeComposer time;
+  DayComposer day;
+
+  while (!in.IsEnd()) {
+    if (in.IsAsciiDigit()) {
+      // Parse a number (possibly with 1 or 2 trailing colons).
+      int n = in.ReadUnsignedNumber();
+      if (in.Skip(':')) {
+        if (in.Skip(':')) {
+          // n + "::"
+          if (!time.IsEmpty()) return false;
+          time.Add(n);
+          time.Add(0);
+        } else {
+          // n + ":"
+          if (!time.Add(n)) return false;
+        }
+      } else if (tz.IsExpecting(n)) {
+        tz.SetAbsoluteMinute(n);
+      } else if (time.IsExpecting(n)) {
+        time.AddFinal(n);
+        // Require end or white space immediately after finalizing time.
+        if (!in.IsEnd() && !in.SkipWhiteSpace()) return false;
+      } else {
+        if (!day.Add(n)) return false;
+        in.Skip('-');  // Ignore suffix '-' for year, month, or day.
+      }
+    } else if (in.IsAsciiAlphaOrAbove()) {
+      // Parse a "word" (sequence of chars. >= 'A').
+      uint32_t pre[KeywordTable::kPrefixLength];
+      int len = in.ReadWord(pre, KeywordTable::kPrefixLength);
+      int index = KeywordTable::Lookup(pre, len);
+      KeywordType type = KeywordTable::GetType(index);
+
+      if (type == AM_PM && !time.IsEmpty()) {
+        time.SetHourOffset(KeywordTable::GetValue(index));
+      } else if (type == MONTH_NAME) {
+        day.SetNamedMonth(KeywordTable::GetValue(index));
+        in.Skip('-');  // Ignore suffix '-' for month names
+      } else if (type == TIME_ZONE_NAME && in.HasReadNumber()) {
+        tz.Set(KeywordTable::GetValue(index));
+      } else {
+        // Garbage words are illegal if a number has been read.
+        if (in.HasReadNumber()) return false;
+      }
+    } else if (in.IsAsciiSign() && (tz.IsUTC() || !time.IsEmpty())) {
+      // Parse UTC offset (only after UTC or time).
+      tz.SetSign(in.GetAsciiSignValue());
+      in.Next();
+      int n = in.ReadUnsignedNumber();
+      if (in.Skip(':')) {
+        tz.SetAbsoluteHour(n);
+        tz.SetAbsoluteMinute(kNone);
+      } else {
+        tz.SetAbsoluteHour(n / 100);
+        tz.SetAbsoluteMinute(n % 100);
+      }
+    } else if (in.Is('(')) {
+      // Ignore anything from '(' to a matching ')' or end of string.
+      in.SkipParentheses();
+    } else if ((in.IsAsciiSign() || in.Is(')')) && in.HasReadNumber()) {
+      // Extra sign or ')' is illegal if a number has been read.
+      // TODO(lrn) Is this correct?

[Erik Corry, 2009/03/17 13:09:01]

I should be possible to find the answer to this and write a test that verifies
it.

+      return false;
+    } else {
+      // Ignore other characters.
+      in.Next();
+    }
+  }
+  return day.Write(out) && time.Write(out) && tz.Write(out);
+}
+
 } }  // namespace v8::internal
 
 #endif  // V8_DATEPARSER_H_