Make date parser handle all ES5 Date Time Strings correctly.

src/dateparser.cc

-// Copyright 2008 the V8 project authors. All rights reserved.
+// Copyright 2011 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
 //       with the distribution.
@@ skipping 25 matching lines @@
   // Day and month defaults to 1.
   while (index_ < kSize) {
     comp_[index_++] = 1;
   }
 
   int year = 0;  // Default year is 0 (=> 2000) for KJS compatibility.
   int month = kNone;
   int day = kNone;
 
   if (named_month_ == kNone) {
-    if (index_ == 3 && !IsDay(comp_[0])) {
+    if (is_iso_date_ || (index_ == 3 && !IsDay(comp_[0]))) {
       // YMD
       year = comp_[0];
       month = comp_[1];
       day = comp_[2];
     } else {
       // MD(Y)
       month = comp_[0];
       day = comp_[1];
       if (index_ == 3) year = comp_[2];
     }
   } else {
     month = named_month_;
     if (index_ == 1) {
       // MD or DM
       day = comp_[0];
     } else if (!IsDay(comp_[0])) {
       // YMD, MYD, or YDM
       year = comp_[0];
       day = comp_[1];
     } else {
       // DMY, MDY, or DYM
       day = comp_[0];
       year = comp_[1];
     }
   }
 
-  if (Between(year, 0, 49)) year += 2000;
-  else if (Between(year, 50, 99)) year += 1900;
+  if (!is_iso_date_) {
+    if (Between(year, 0, 49)) year += 2000;
+    else if (Between(year, 50, 99)) year += 1900;
+  }
 
   if (!Smi::IsValid(year) || !IsMonth(month) || !IsDay(day)) return false;
 
   output->set(YEAR, Smi::FromInt(year));
   output->set(MONTH, Smi::FromInt(month - 1));  // 0-based
   output->set(DAY, Smi::FromInt(day));
   return true;
 }
 
 
@@ skipping 58 matching lines @@
   {'z', '\0', '\0', DateParser::TIME_ZONE_NAME, 0},
   {'g', 'm', 't', DateParser::TIME_ZONE_NAME, 0},
   {'c', 'd', 't', DateParser::TIME_ZONE_NAME, -5},
   {'c', 's', 't', DateParser::TIME_ZONE_NAME, -6},
   {'e', 'd', 't', DateParser::TIME_ZONE_NAME, -4},
   {'e', 's', 't', DateParser::TIME_ZONE_NAME, -5},
   {'m', 'd', 't', DateParser::TIME_ZONE_NAME, -6},
   {'m', 's', 't', DateParser::TIME_ZONE_NAME, -7},
   {'p', 'd', 't', DateParser::TIME_ZONE_NAME, -7},
   {'p', 's', 't', DateParser::TIME_ZONE_NAME, -8},
+  {'t', '\0', '\0', DateParser::TIME_SEPARATOR, 0},
   {'\0', '\0', '\0', DateParser::INVALID, 0},
 };
 
 
 // We could use perfect hashing here, but this is not a bottleneck.
 int DateParser::KeywordTable::Lookup(const uint32_t* pre, int len) {
   int i;
   for (i = 0; array[i][kTypeOffset] != INVALID; i++) {
     int j = 0;
     while (j < kPrefixLength &&
            pre[j] == static_cast<uint32_t>(array[i][j])) {
       j++;
     }
     // Check if we have a match and the length is legal.
     // Word longer than keyword is only allowed for month names.
     if (j == kPrefixLength &&
         (len <= kPrefixLength || array[i][kTypeOffset] == MONTH_NAME)) {
       return i;
     }
   }
   return i;
 }
 
 
+int DateParser::ReadMilliseconds(DateToken token) {
+  // 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 {
+      ASSERT(factor <= 100000000);  // factor won't overflow.
+      factor *= 10;
+      length--;
+    } while (length > 3);
+    number /= factor;
+  }
+  return number;
+}
+
+
 } }  // namespace v8::internal