187879a25a
- Sped up allocation of Arguments object. Review URL: http://codereview.chromium.org/8098 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@567 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
266 lines
8.6 KiB
C++
266 lines
8.6 KiB
C++
// 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
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include "v8.h"
|
|
|
|
#include "dateparser.h"
|
|
|
|
namespace v8 { namespace internal {
|
|
|
|
|
|
bool DateParser::Parse(String* str, FixedArray* out) {
|
|
ASSERT(out->length() == OUTPUT_SIZE);
|
|
|
|
InputReader 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 no number read yet.
|
|
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 no number read yet.
|
|
return false;
|
|
} else {
|
|
// Ignore other characters.
|
|
in.Next();
|
|
}
|
|
}
|
|
return day.Write(out) && time.Write(out) && tz.Write(out);
|
|
}
|
|
|
|
|
|
bool DateParser::DayComposer::Write(FixedArray* output) {
|
|
int year = 0; // Default year is 0 (=> 2000) for KJS compatibility.
|
|
int month = kNone;
|
|
int day = kNone;
|
|
|
|
if (named_month_ == kNone) {
|
|
if (index_ < 2) return false;
|
|
if (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) return false;
|
|
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 (!Smi::IsValid(year) || !IsMonth(month) || !IsDay(day)) return false;
|
|
|
|
output->set(YEAR,
|
|
Smi::FromInt(year),
|
|
SKIP_WRITE_BARRIER);
|
|
output->set(MONTH,
|
|
Smi::FromInt(month - 1),
|
|
SKIP_WRITE_BARRIER); // 0-based
|
|
output->set(DAY,
|
|
Smi::FromInt(day),
|
|
SKIP_WRITE_BARRIER);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DateParser::TimeComposer::Write(FixedArray* output) {
|
|
// All time slots default to 0
|
|
while (index_ < kSize) {
|
|
comp_[index_++] = 0;
|
|
}
|
|
|
|
int& hour = comp_[0];
|
|
int& minute = comp_[1];
|
|
int& second = comp_[2];
|
|
|
|
if (hour_offset_ != kNone) {
|
|
if (!IsHour12(hour)) return false;
|
|
hour %= 12;
|
|
hour += hour_offset_;
|
|
}
|
|
|
|
if (!IsHour(hour) || !IsMinute(minute) || !IsSecond(second)) return false;
|
|
|
|
output->set(HOUR,
|
|
Smi::FromInt(hour),
|
|
SKIP_WRITE_BARRIER);
|
|
output->set(MINUTE,
|
|
Smi::FromInt(minute),
|
|
SKIP_WRITE_BARRIER);
|
|
output->set(SECOND,
|
|
Smi::FromInt(second),
|
|
SKIP_WRITE_BARRIER);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DateParser::TimeZoneComposer::Write(FixedArray* output) {
|
|
if (sign_ != kNone) {
|
|
if (hour_ == kNone) hour_ = 0;
|
|
if (minute_ == kNone) minute_ = 0;
|
|
int total_seconds = sign_ * (hour_ * 3600 + minute_ * 60);
|
|
if (!Smi::IsValid(total_seconds)) return false;
|
|
output->set(UTC_OFFSET,
|
|
Smi::FromInt(total_seconds),
|
|
SKIP_WRITE_BARRIER);
|
|
} else {
|
|
output->set(UTC_OFFSET,
|
|
Heap::null_value(),
|
|
SKIP_WRITE_BARRIER);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
const int8_t
|
|
DateParser::KeywordTable::array[][DateParser::KeywordTable::kEntrySize] = {
|
|
{'j', 'a', 'n', DateParser::MONTH_NAME, 1},
|
|
{'f', 'e', 'b', DateParser::MONTH_NAME, 2},
|
|
{'m', 'a', 'r', DateParser::MONTH_NAME, 3},
|
|
{'a', 'p', 'r', DateParser::MONTH_NAME, 4},
|
|
{'m', 'a', 'y', DateParser::MONTH_NAME, 5},
|
|
{'j', 'u', 'n', DateParser::MONTH_NAME, 6},
|
|
{'j', 'u', 'l', DateParser::MONTH_NAME, 7},
|
|
{'a', 'u', 'g', DateParser::MONTH_NAME, 8},
|
|
{'s', 'e', 'p', DateParser::MONTH_NAME, 9},
|
|
{'o', 'c', 't', DateParser::MONTH_NAME, 10},
|
|
{'n', 'o', 'v', DateParser::MONTH_NAME, 11},
|
|
{'d', 'e', 'c', DateParser::MONTH_NAME, 12},
|
|
{'a', 'm', '\0', DateParser::AM_PM, 0},
|
|
{'p', 'm', '\0', DateParser::AM_PM, 12},
|
|
{'u', 't', '\0', DateParser::TIME_ZONE_NAME, 0},
|
|
{'u', 't', 'c', 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},
|
|
{'\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;
|
|
}
|
|
|
|
|
|
} } // namespace v8::internal
|