| /* |
| * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package jdk.nashorn.internal.parser; |
| |
| import static java.lang.Character.DECIMAL_DIGIT_NUMBER; |
| import static java.lang.Character.LOWERCASE_LETTER; |
| import static java.lang.Character.OTHER_PUNCTUATION; |
| import static java.lang.Character.SPACE_SEPARATOR; |
| import static java.lang.Character.UPPERCASE_LETTER; |
| |
| import java.util.HashMap; |
| import java.util.Locale; |
| |
| /** |
| * JavaScript date parser. This class first tries to parse a date string |
| * according to the extended ISO 8601 format specified in ES5 15.9.1.15. |
| * If that fails, it falls back to legacy mode in which it accepts a range |
| * of different formats. |
| * |
| * <p>This class is neither thread-safe nor reusable. Calling the |
| * <tt>parse()</tt> method more than once will yield undefined results.</p> |
| */ |
| public class DateParser { |
| |
| /** Constant for index position of parsed year value. */ |
| public final static int YEAR = 0; |
| /** Constant for index position of parsed month value. */ |
| public final static int MONTH = 1; |
| /** Constant for index position of parsed day value. */ |
| public final static int DAY = 2; |
| /** Constant for index position of parsed hour value. */ |
| public final static int HOUR = 3; |
| /** Constant for index position of parsed minute value. */ |
| public final static int MINUTE = 4; |
| /** Constant for index position of parsed second value. */ |
| public final static int SECOND = 5; |
| /** Constant for index position of parsed millisecond value. */ |
| public final static int MILLISECOND = 6; |
| /** Constant for index position of parsed time zone offset value. */ |
| public final static int TIMEZONE = 7; |
| |
| private enum Token { |
| UNKNOWN, NUMBER, SEPARATOR, PARENTHESIS, NAME, SIGN, END |
| } |
| |
| private final String string; |
| private final int length; |
| private final Integer[] fields; |
| private int pos = 0; |
| private Token token; |
| private int tokenLength; |
| private Name nameValue; |
| private int numValue; |
| private int currentField = YEAR; |
| private int yearSign = 0; |
| private boolean namedMonth = false; |
| |
| private final static HashMap<String,Name> names = new HashMap<>(); |
| |
| static { |
| addName("monday", Name.DAY_OF_WEEK, 0); |
| addName("tuesday", Name.DAY_OF_WEEK, 0); |
| addName("wednesday", Name.DAY_OF_WEEK, 0); |
| addName("thursday", Name.DAY_OF_WEEK, 0); |
| addName("friday", Name.DAY_OF_WEEK, 0); |
| addName("saturday", Name.DAY_OF_WEEK, 0); |
| addName("sunday", Name.DAY_OF_WEEK, 0); |
| addName("january", Name.MONTH_NAME, 1); |
| addName("february", Name.MONTH_NAME, 2); |
| addName("march", Name.MONTH_NAME, 3); |
| addName("april", Name.MONTH_NAME, 4); |
| addName("may", Name.MONTH_NAME, 5); |
| addName("june", Name.MONTH_NAME, 6); |
| addName("july", Name.MONTH_NAME, 7); |
| addName("august", Name.MONTH_NAME, 8); |
| addName("september", Name.MONTH_NAME, 9); |
| addName("october", Name.MONTH_NAME, 10); |
| addName("november", Name.MONTH_NAME, 11); |
| addName("december", Name.MONTH_NAME, 12); |
| addName("am", Name.AM_PM, 0); |
| addName("pm", Name.AM_PM, 12); |
| addName("z", Name.TIMEZONE_ID, 0); |
| addName("gmt", Name.TIMEZONE_ID, 0); |
| addName("ut", Name.TIMEZONE_ID, 0); |
| addName("utc", Name.TIMEZONE_ID, 0); |
| addName("est", Name.TIMEZONE_ID, -5 * 60); |
| addName("edt", Name.TIMEZONE_ID, -4 * 60); |
| addName("cst", Name.TIMEZONE_ID, -6 * 60); |
| addName("cdt", Name.TIMEZONE_ID, -5 * 60); |
| addName("mst", Name.TIMEZONE_ID, -7 * 60); |
| addName("mdt", Name.TIMEZONE_ID, -6 * 60); |
| addName("pst", Name.TIMEZONE_ID, -8 * 60); |
| addName("pdt", Name.TIMEZONE_ID, -7 * 60); |
| addName("t", Name.TIME_SEPARATOR, 0); |
| } |
| |
| /** |
| * Construct a new <tt>DateParser</tt> instance for parsing the given string. |
| * @param string the string to be parsed |
| */ |
| public DateParser(final String string) { |
| this.string = string; |
| this.length = string.length(); |
| this.fields = new Integer[TIMEZONE + 1]; |
| } |
| |
| /** |
| * Try parsing the given string as date according to the extended ISO 8601 format |
| * specified in ES5 15.9.1.15. Fall back to legacy mode if that fails. |
| * This method returns <tt>true</tt> if the string could be parsed. |
| * @return true if the string could be parsed as date |
| */ |
| public boolean parse() { |
| return parseEcmaDate() || parseLegacyDate(); |
| } |
| |
| /** |
| * Try parsing the date string according to the rules laid out in ES5 15.9.1.15. |
| * The date string must conform to the following format: |
| * |
| * <pre> [('-'|'+')yy]yyyy[-MM[-dd]][Thh:mm[:ss[.sss]][Z|(+|-)hh:mm]] </pre> |
| * |
| * <p>If the string does not contain a time zone offset, the <tt>TIMEZONE</tt> field |
| * is set to <tt>0</tt> (GMT).</p> |
| * @return true if string represents a valid ES5 date string. |
| */ |
| public boolean parseEcmaDate() { |
| |
| if (token == null) { |
| token = next(); |
| } |
| |
| while (token != Token.END) { |
| |
| switch (token) { |
| case NUMBER: |
| if (currentField == YEAR && yearSign != 0) { |
| // 15.9.1.15.1 Extended year must have six digits |
| if (tokenLength != 6) { |
| return false; |
| } |
| numValue *= yearSign; |
| } else if (!checkEcmaField(currentField, numValue)) { |
| return false; |
| } |
| if (!skipEcmaDelimiter()) { |
| return false; |
| } |
| if (currentField < TIMEZONE) { |
| set(currentField++, numValue); |
| } |
| break; |
| |
| case NAME: |
| if (nameValue == null) { |
| return false; |
| } |
| switch (nameValue.type) { |
| case Name.TIME_SEPARATOR: |
| if (currentField == YEAR || currentField > HOUR) { |
| return false; |
| } |
| currentField = HOUR; |
| break; |
| case Name.TIMEZONE_ID: |
| if (!nameValue.key.equals("z") || !setTimezone(nameValue.value, false)) { |
| return false; |
| } |
| break; |
| default: |
| return false; |
| } |
| break; |
| |
| case SIGN: |
| if (peek() == -1) { |
| // END after sign - wrong! |
| return false; |
| } |
| |
| if (currentField == YEAR) { |
| yearSign = numValue; |
| } else if (currentField < SECOND || !setTimezone(readTimeZoneOffset(), true)) { |
| // Note: Spidermonkey won't parse timezone unless time includes seconds and milliseconds |
| return false; |
| } |
| break; |
| |
| default: |
| return false; |
| } |
| token = next(); |
| } |
| |
| return patchResult(true); |
| } |
| |
| /** |
| * Try parsing the date using a fuzzy algorithm that can handle a variety of formats. |
| * |
| * <p>Numbers separated by <tt>':'</tt> are treated as time values, optionally followed by a |
| * millisecond value separated by <tt>'.'</tt>. Other number values are treated as date values. |
| * The exact sequence of day, month, and year values to apply is determined heuristically.</p> |
| * |
| * <p>English month names and selected time zone names as well as AM/PM markers are recognized |
| * and handled properly. Additionally, numeric time zone offsets such as <tt>(+|-)hh:mm</tt> or |
| * <tt>(+|-)hhmm</tt> are recognized. If the string does not contain a time zone offset |
| * the <tt>TIMEZONE</tt>field is left undefined, meaning the local time zone should be applied.</p> |
| * |
| * <p>English weekday names are recognized but ignored. All text in parentheses is ignored as well. |
| * All other text causes parsing to fail.</p> |
| * |
| * @return true if the string could be parsed |
| */ |
| public boolean parseLegacyDate() { |
| |
| if (yearSign != 0 || currentField > DAY) { |
| // we don't support signed years in legacy mode |
| return false; |
| } |
| if (token == null) { |
| token = next(); |
| } |
| |
| while (token != Token.END) { |
| |
| switch (token) { |
| case NUMBER: |
| if (skipDelimiter(':')) { |
| // A number followed by ':' is parsed as time |
| if (!setTimeField(numValue)) { |
| return false; |
| } |
| // consume remaining time tokens |
| do { |
| token = next(); |
| if (token != Token.NUMBER || !setTimeField(numValue)) { |
| return false; |
| } |
| } while (skipDelimiter(isSet(SECOND) ? '.' : ':')); |
| |
| } else { |
| // Parse as date token |
| if (!setDateField(numValue)) { |
| return false; |
| } |
| skipDelimiter('-'); |
| } |
| break; |
| |
| case NAME: |
| if (nameValue == null) { |
| return false; |
| } |
| switch (nameValue.type) { |
| case Name.AM_PM: |
| if (!setAmPm(nameValue.value)) { |
| return false; |
| } |
| break; |
| case Name.MONTH_NAME: |
| if (!setMonth(nameValue.value)) { |
| return false; |
| } |
| break; |
| case Name.TIMEZONE_ID: |
| if (!setTimezone(nameValue.value, false)) { |
| return false; |
| } |
| break; |
| case Name.TIME_SEPARATOR: |
| return false; |
| default: |
| break; |
| } |
| if (nameValue.type != Name.TIMEZONE_ID) { |
| skipDelimiter('-'); |
| } |
| break; |
| |
| case SIGN: |
| if (peek() == -1) { |
| // END after sign - wrong! |
| return false; |
| } |
| |
| if (!setTimezone(readTimeZoneOffset(), true)) { |
| return false; |
| } |
| break; |
| |
| case PARENTHESIS: |
| if (!skipParentheses()) { |
| return false; |
| } |
| break; |
| |
| case SEPARATOR: |
| break; |
| |
| default: |
| return false; |
| } |
| token = next(); |
| } |
| |
| return patchResult(false); |
| } |
| |
| /** |
| * Get the parsed date and time fields as an array of <tt>Integers</tt>. |
| * |
| * <p>If parsing was successful, all fields are guaranteed to be set except for the |
| * <tt>TIMEZONE</tt> field which may be <tt>null</tt>, meaning that local time zone |
| * offset should be applied.</p> |
| * |
| * @return the parsed date fields |
| */ |
| public Integer[] getDateFields() { |
| return fields; |
| } |
| |
| private boolean isSet(final int field) { |
| return fields[field] != null; |
| } |
| |
| private Integer get(final int field) { |
| return fields[field]; |
| } |
| |
| private void set(final int field, final int value) { |
| fields[field] = value; |
| } |
| |
| private int peek() { |
| return pos < length ? string.charAt(pos) : -1; |
| } |
| |
| // Skip delimiter if followed by a number. Used for ISO 8601 formatted dates |
| private boolean skipNumberDelimiter(final char c) { |
| if (pos < length - 1 && string.charAt(pos) == c |
| && Character.getType(string.charAt(pos + 1)) == DECIMAL_DIGIT_NUMBER) { |
| token = null; |
| pos++; |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean skipDelimiter(final char c) { |
| if (pos < length && string.charAt(pos) == c) { |
| token = null; |
| pos++; |
| return true; |
| } |
| return false; |
| } |
| |
| private Token next() { |
| if (pos >= length) { |
| tokenLength = 0; |
| return Token.END; |
| } |
| |
| final char c = string.charAt(pos); |
| |
| if (c > 0x80) { |
| tokenLength = 1; |
| pos++; |
| return Token.UNKNOWN; // We only deal with ASCII here |
| } |
| |
| final int type = Character.getType(c); |
| switch (type) { |
| case DECIMAL_DIGIT_NUMBER: |
| numValue = readNumber(6); |
| return Token.NUMBER; |
| case SPACE_SEPARATOR : |
| case OTHER_PUNCTUATION: |
| tokenLength = 1; |
| pos++; |
| return Token.SEPARATOR; |
| case UPPERCASE_LETTER: |
| case LOWERCASE_LETTER: |
| nameValue = readName(); |
| return Token.NAME; |
| default: |
| tokenLength = 1; |
| pos++; |
| switch (c) { |
| case '(': |
| return Token.PARENTHESIS; |
| case '-': |
| case '+': |
| numValue = c == '-' ? -1 : 1; |
| return Token.SIGN; |
| default: |
| return Token.UNKNOWN; |
| } |
| } |
| } |
| |
| private static boolean checkLegacyField(final int field, final int value) { |
| switch (field) { |
| case HOUR: |
| return isHour(value); |
| case MINUTE: |
| case SECOND: |
| return isMinuteOrSecond(value); |
| case MILLISECOND: |
| return isMillisecond(value); |
| default: |
| // skip validation on other legacy fields as we don't know what's what |
| return true; |
| } |
| } |
| |
| private boolean checkEcmaField(final int field, final int value) { |
| switch (field) { |
| case YEAR: |
| return tokenLength == 4; |
| case MONTH: |
| return tokenLength == 2 && isMonth(value); |
| case DAY: |
| return tokenLength == 2 && isDay(value); |
| case HOUR: |
| return tokenLength == 2 && isHour(value); |
| case MINUTE: |
| case SECOND: |
| return tokenLength == 2 && isMinuteOrSecond(value); |
| case MILLISECOND: |
| // we allow millisecond to be less than 3 digits |
| return tokenLength < 4 && isMillisecond(value); |
| default: |
| return true; |
| } |
| } |
| |
| private boolean skipEcmaDelimiter() { |
| switch (currentField) { |
| case YEAR: |
| case MONTH: |
| return skipNumberDelimiter('-') || peek() == 'T' || peek() == -1; |
| case DAY: |
| return peek() == 'T' || peek() == -1; |
| case HOUR: |
| case MINUTE: |
| return skipNumberDelimiter(':') || endOfTime(); |
| case SECOND: |
| return skipNumberDelimiter('.') || endOfTime(); |
| default: |
| return true; |
| } |
| } |
| |
| private boolean endOfTime() { |
| final int c = peek(); |
| return c == -1 || c == 'Z' || c == '-' || c == '+' || c == ' '; |
| } |
| |
| private static boolean isAsciiLetter(final char ch) { |
| return ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z'); |
| } |
| |
| private static boolean isAsciiDigit(final char ch) { |
| return '0' <= ch && ch <= '9'; |
| } |
| |
| private int readNumber(final int maxDigits) { |
| final int start = pos; |
| int n = 0; |
| final int max = Math.min(length, pos + maxDigits); |
| while (pos < max && isAsciiDigit(string.charAt(pos))) { |
| n = n * 10 + string.charAt(pos++) - '0'; |
| } |
| tokenLength = pos - start; |
| return n; |
| } |
| |
| private Name readName() { |
| final int start = pos; |
| final int limit = Math.min(pos + 3, length); |
| |
| // first read up to the key length |
| while (pos < limit && isAsciiLetter(string.charAt(pos))) { |
| pos++; |
| } |
| final String key = string.substring(start, pos).toLowerCase(Locale.ENGLISH); |
| final Name name = names.get(key); |
| // then advance to end of name |
| while (pos < length && isAsciiLetter(string.charAt(pos))) { |
| pos++; |
| } |
| |
| tokenLength = pos - start; |
| // make sure we have the full name or a prefix |
| if (name != null && name.matches(string, start, tokenLength)) { |
| return name; |
| } |
| return null; |
| } |
| |
| private int readTimeZoneOffset() { |
| final int sign = string.charAt(pos - 1) == '+' ? 1 : -1; |
| int offset = readNumber(2); |
| skipDelimiter(':'); |
| offset = offset * 60 + readNumber(2); |
| return sign * offset; |
| } |
| |
| private boolean skipParentheses() { |
| int parenCount = 1; |
| while (pos < length && parenCount != 0) { |
| final char c = string.charAt(pos++); |
| if (c == '(') { |
| parenCount++; |
| } else if (c == ')') { |
| parenCount--; |
| } |
| } |
| return true; |
| } |
| |
| private static int getDefaultValue(final int field) { |
| switch (field) { |
| case MONTH: |
| case DAY: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| private static boolean isDay(final int n) { |
| return 1 <= n && n <= 31; |
| } |
| |
| private static boolean isMonth(final int n) { |
| return 1 <= n && n <= 12; |
| } |
| |
| private static boolean isHour(final int n) { |
| return 0 <= n && n <= 24; |
| } |
| |
| private static boolean isMinuteOrSecond(final int n) { |
| return 0 <= n && n < 60; |
| } |
| |
| private static boolean isMillisecond(final int n) { |
| return 0<= n && n < 1000; |
| } |
| |
| private boolean setMonth(final int m) { |
| if (!isSet(MONTH)) { |
| namedMonth = true; |
| set(MONTH, m); |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean setDateField(final int n) { |
| for (int field = YEAR; field != HOUR; field++) { |
| if (!isSet(field)) { |
| // no validation on legacy date fields |
| set(field, n); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean setTimeField(final int n) { |
| for (int field = HOUR; field != TIMEZONE; field++) { |
| if (!isSet(field)) { |
| if (checkLegacyField(field, n)) { |
| set(field, n); |
| return true; |
| } |
| return false; |
| } |
| } |
| return false; |
| } |
| |
| private boolean setTimezone(final int offset, final boolean asNumericOffset) { |
| if (!isSet(TIMEZONE) || (asNumericOffset && get(TIMEZONE) == 0)) { |
| set(TIMEZONE, offset); |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean setAmPm(final int offset) { |
| if (!isSet(HOUR)) { |
| return false; |
| } |
| final int hour = get(HOUR); |
| if (hour >= 0 && hour <= 12) { |
| set(HOUR, hour + offset); |
| } |
| return true; |
| } |
| |
| private boolean patchResult(final boolean strict) { |
| // sanity checks - make sure we have something |
| if (!isSet(YEAR) && !isSet(HOUR)) { |
| return false; |
| } |
| if (isSet(HOUR) && !isSet(MINUTE)) { |
| return false; |
| } |
| // fill in default values for unset fields except timezone |
| for (int field = YEAR; field <= TIMEZONE; field++) { |
| if (get(field) == null) { |
| if (field == TIMEZONE && !strict) { |
| // We only use UTC as default timezone for dates parsed complying with |
| // the format specified in ES5 15.9.1.15. Otherwise the slot is left empty |
| // and local timezone is used. |
| continue; |
| } |
| final int value = getDefaultValue(field); |
| set(field, value); |
| } |
| } |
| |
| if (!strict) { |
| // swap year, month, and day if it looks like the right thing to do |
| if (isDay(get(YEAR))) { |
| final int d = get(YEAR); |
| set(YEAR, get(DAY)); |
| if (namedMonth) { |
| // d-m-y |
| set(DAY, d); |
| } else { |
| // m-d-y |
| final int d2 = get(MONTH); |
| set(MONTH, d); |
| set(DAY, d2); |
| } |
| } |
| // sanity checks now that we know what's what |
| if (!isMonth(get(MONTH)) || !isDay(get(DAY))) { |
| return false; |
| } |
| |
| // add 1900 or 2000 to year if it's between 0 and 100 |
| final int year = get(YEAR); |
| if (year >= 0 && year < 100) { |
| set(YEAR, year >= 50 ? 1900 + year : 2000 + year); |
| } |
| } else { |
| // 24 hour value is only allowed if all other time values are zero |
| if (get(HOUR) == 24 && |
| (get(MINUTE) != 0 || get(SECOND) != 0 || get(MILLISECOND) != 0)) { |
| return false; |
| } |
| } |
| |
| // set month to 0-based |
| set(MONTH, get(MONTH) - 1); |
| return true; |
| } |
| |
| private static void addName(final String str, final int type, final int value) { |
| final Name name = new Name(str, type, value); |
| names.put(name.key, name); |
| } |
| |
| private static class Name { |
| final String name; |
| final String key; |
| final int value; |
| final int type; |
| |
| final static int DAY_OF_WEEK = -1; |
| final static int MONTH_NAME = 0; |
| final static int AM_PM = 1; |
| final static int TIMEZONE_ID = 2; |
| final static int TIME_SEPARATOR = 3; |
| |
| Name(final String name, final int type, final int value) { |
| assert name != null; |
| assert name.equals(name.toLowerCase(Locale.ENGLISH)); |
| |
| this.name = name; |
| // use first three characters as lookup key |
| this.key = name.substring(0, Math.min(3, name.length())); |
| this.type = type; |
| this.value = value; |
| } |
| |
| public boolean matches(final String str, final int offset, final int len) { |
| return name.regionMatches(true, 0, str, offset, len); |
| } |
| |
| @Override |
| public String toString() { |
| return name; |
| } |
| } |
| |
| } |
