diff options
Diffstat (limited to '')
| -rw-r--r-- | devtools/shared/css/lexer.js | 1522 |
1 files changed, 1522 insertions, 0 deletions
diff --git a/devtools/shared/css/lexer.js b/devtools/shared/css/lexer.js new file mode 100644 index 0000000000..18e78717d1 --- /dev/null +++ b/devtools/shared/css/lexer.js @@ -0,0 +1,1522 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// A CSS Lexer. This file is a bit unusual -- it is a more or less +// direct translation of layout/style/nsCSSScanner.cpp and +// layout/style/CSSLexer.cpp into JS. This implemented the +// CSSLexer.webidl interface, and the intent is to try to keep it in +// sync with changes to the platform CSS lexer. Due to this goal, +// this file violates some naming conventions and consequently locally +// disables some eslint rules. + +/* eslint-disable camelcase, mozilla/no-aArgs, no-else-return, complexity */ + +"use strict"; + +// White space of any kind. No value fields are used. Note that +// comments do *not* count as white space; comments separate tokens +// but are not themselves tokens. +const eCSSToken_Whitespace = "whitespace"; // +// A comment. +const eCSSToken_Comment = "comment"; // /*...*/ + +// Identifier-like tokens. mIdent is the text of the identifier. +// The difference between ID and Hash is: if the text after the # +// would have been a valid Ident if the # hadn't been there, the +// scanner produces an ID token. Otherwise it produces a Hash token. +// (This distinction is required by css3-selectors.) +const eCSSToken_Ident = "ident"; // word +const eCSSToken_Function = "function"; // word( +const eCSSToken_AtKeyword = "at"; // @word +const eCSSToken_ID = "id"; // #word +const eCSSToken_Hash = "hash"; // #0word + +// Numeric tokens. mNumber is the floating-point value of the +// number, and mHasSign indicates whether there was an explicit sign +// (+ or -) in front of the number. If mIntegerValid is true, the +// number had the lexical form of an integer, and mInteger is its +// integer value. Lexically integer values outside the range of a +// 32-bit signed number are clamped to the maximum values; mNumber +// will indicate a 'truer' value in that case. Percentage tokens +// are always considered not to be integers, even if their numeric +// value is integral (100% => mNumber = 1.0). For Dimension +// tokens, mIdent holds the text of the unit. +const eCSSToken_Number = "number"; // 1 -5 +2e3 3.14159 7.297352e-3 +const eCSSToken_Dimension = "dimension"; // 24px 8.5in +const eCSSToken_Percentage = "percentage"; // 85% 1280.4% + +// String-like tokens. In all cases, mIdent holds the text +// belonging to the string, and mSymbol holds the delimiter +// character, which may be ', ", or zero (only for unquoted URLs). +// Bad_String and Bad_URL tokens are emitted when the closing +// delimiter or parenthesis was missing. +const eCSSToken_String = "string"; // 'foo bar' "foo bar" +const eCSSToken_Bad_String = "bad_string"; // 'foo bar +const eCSSToken_URL = "url"; // url(foobar) url("foo bar") +const eCSSToken_Bad_URL = "bad_url"; // url(foo + +// Any one-character symbol. mSymbol holds the character. +const eCSSToken_Symbol = "symbol"; // . ; { } ! * + +// Match operators. These are single tokens rather than pairs of +// Symbol tokens because css3-selectors forbids the presence of +// comments between the two characters. No value fields are used; +// the token type indicates which operator. +const eCSSToken_Includes = "includes"; // ~= +const eCSSToken_Dashmatch = "dashmatch"; // |= +const eCSSToken_Beginsmatch = "beginsmatch"; // ^= +const eCSSToken_Endsmatch = "endsmatch"; // $= +const eCSSToken_Containsmatch = "containsmatch"; // *= + +// Unicode-range token: currently used only in @font-face. +// The lexical rule for this token includes several forms that are +// semantically invalid. Therefore, mIdent always holds the +// complete original text of the token (so we can print it +// accurately in diagnostics), and mIntegerValid is true iff the +// token is semantically valid. In that case, mInteger holds the +// lowest value included in the range, and mInteger2 holds the +// highest value included in the range. +const eCSSToken_URange = "urange"; // U+007e U+01?? U+2000-206F + +// HTML comment delimiters, ignored as a unit when they appear at +// the top level of a style sheet, for compatibility with websites +// written for compatibility with pre-CSS browsers. This token type +// subsumes the css2.1 CDO and CDC tokens, which are always treated +// the same by the parser. mIdent holds the text of the token, for +// diagnostics. +const eCSSToken_HTMLComment = "htmlcomment"; // <!-- --> + +const eEOFCharacters_None = 0x0000; + +// to handle \<EOF> inside strings +const eEOFCharacters_DropBackslash = 0x0001; + +// to handle \<EOF> outside strings +const eEOFCharacters_ReplacementChar = 0x0002; + +// to close comments +const eEOFCharacters_Asterisk = 0x0004; +const eEOFCharacters_Slash = 0x0008; + +// to close double-quoted strings +const eEOFCharacters_DoubleQuote = 0x0010; + +// to close single-quoted strings +const eEOFCharacters_SingleQuote = 0x0020; + +// to close URLs +const eEOFCharacters_CloseParen = 0x0040; + +// Bridge the char/string divide. +const APOSTROPHE = "'".charCodeAt(0); +const ASTERISK = "*".charCodeAt(0); +const CARRIAGE_RETURN = "\r".charCodeAt(0); +const CIRCUMFLEX_ACCENT = "^".charCodeAt(0); +const COMMERCIAL_AT = "@".charCodeAt(0); +const DIGIT_NINE = "9".charCodeAt(0); +const DIGIT_ZERO = "0".charCodeAt(0); +const DOLLAR_SIGN = "$".charCodeAt(0); +const EQUALS_SIGN = "=".charCodeAt(0); +const EXCLAMATION_MARK = "!".charCodeAt(0); +const FULL_STOP = ".".charCodeAt(0); +const GREATER_THAN_SIGN = ">".charCodeAt(0); +const HYPHEN_MINUS = "-".charCodeAt(0); +const LATIN_CAPITAL_LETTER_E = "E".charCodeAt(0); +const LATIN_CAPITAL_LETTER_U = "U".charCodeAt(0); +const LATIN_SMALL_LETTER_E = "e".charCodeAt(0); +const LATIN_SMALL_LETTER_U = "u".charCodeAt(0); +const LEFT_PARENTHESIS = "(".charCodeAt(0); +const LESS_THAN_SIGN = "<".charCodeAt(0); +const LINE_FEED = "\n".charCodeAt(0); +const NUMBER_SIGN = "#".charCodeAt(0); +const PERCENT_SIGN = "%".charCodeAt(0); +const PLUS_SIGN = "+".charCodeAt(0); +const QUESTION_MARK = "?".charCodeAt(0); +const QUOTATION_MARK = '"'.charCodeAt(0); +const REVERSE_SOLIDUS = "\\".charCodeAt(0); +const RIGHT_PARENTHESIS = ")".charCodeAt(0); +const SOLIDUS = "/".charCodeAt(0); +const TILDE = "~".charCodeAt(0); +const VERTICAL_LINE = "|".charCodeAt(0); + +const UCS2_REPLACEMENT_CHAR = 0xfffd; + +const kImpliedEOFCharacters = [ + UCS2_REPLACEMENT_CHAR, + ASTERISK, + SOLIDUS, + QUOTATION_MARK, + APOSTROPHE, + RIGHT_PARENTHESIS, + 0, +]; + +// +const ARGS_LENGTH_MAX = 500 * 1000; + +/** + * Several methods in this helper can reach the 500000 limit for arguments in + * Firefox, see Bug 1414361. + * + * This will apply the provided method, on the provided scope with an array of + * arguments which can exceed the 500k limit supported by Firefox. + * + * In practice, the arguments array will be split in several chunks of 500k + * items maximum and each chunk will be applied separately. + * + * !! Note that if you are expecting to use the return value of the method, here + * we will return an array of each return value for each chunk. It will be up to + * the consumer to decide how to combine the results into a meaningful final + * result !! + * + * @param {Function} method + * The method to apply. + * @param {*} scope + * The scope ("this") to use when applying the method. + * @param {Array} args + * The array of arguments to apply. + * + * @returns {Array} + * The array of return values, one item for each chunk that had to be + * created. + */ +function safeApply(method, scope, args) { + let i = 0; + const res = []; + const length = args.length; + while (i < length) { + const _start = i; + i += ARGS_LENGTH_MAX; + res.push(method.apply(scope, args.slice(_start, i))); + } + return res; +} + +/** + * Ensure that the character is valid. If it is valid, return it; + * otherwise, return the replacement character. + * + * @param {Number} c the character to check + * @return {Number} the character or its replacement + */ +function ensureValidChar(c) { + if (c >= 0x00110000 || (c & 0xfff800) == 0xd800) { + // Out of range or a surrogate. + return UCS2_REPLACEMENT_CHAR; + } + return c; +} + +/** + * Turn a string into an array of character codes. + * + * @param {String} str the input string + * @return {Array} an array of character codes, one per character in + * the input string. + */ +function stringToCodes(str) { + // This is a hot path, and using a simple for loop is faster than any other mean (e.g. + // Array#map ). + const charCodes = []; + for (let i = 0; i < str.length; i++) { + charCodes.push(str.charCodeAt(i)); + } + return charCodes; +} + +const IS_HEX_DIGIT = 0x01; +const IS_IDSTART = 0x02; +const IS_IDCHAR = 0x04; +const IS_URL_CHAR = 0x08; +const IS_HSPACE = 0x10; +const IS_VSPACE = 0x20; +const IS_SPACE = IS_HSPACE | IS_VSPACE; +const IS_STRING = 0x40; + +const H = IS_HSPACE; +const V = IS_VSPACE; +const I = IS_IDCHAR; +const J = IS_IDSTART; +const U = IS_URL_CHAR; +const S = IS_STRING; +const X = IS_HEX_DIGIT; + +const SH = S | H; +const SU = S | U; +const SUI = S | U | I; +const SUIJ = S | U | I | J; +const SUIX = S | U | I | X; +const SUIJX = S | U | I | J | X; + +/* eslint-disable indent, indent-legacy, no-multi-spaces, comma-spacing, spaced-comment */ +const gLexTable = [ + // 00 01 02 03 04 05 06 07 + 0, + S, + S, + S, + S, + S, + S, + S, + // 08 TAB LF 0B FF CR 0E 0F + S, + SH, + V, + S, + V, + V, + S, + S, + // 10 11 12 13 14 15 16 17 + S, + S, + S, + S, + S, + S, + S, + S, + // 18 19 1A 1B 1C 1D 1E 1F + S, + S, + S, + S, + S, + S, + S, + S, + //SPC ! " # $ % & ' + SH, + SU, + 0, + SU, + SU, + SU, + SU, + 0, + // ( ) * + , - . / + S, + S, + SU, + SU, + SU, + SUI, + SU, + SU, + // 0 1 2 3 4 5 6 7 + SUIX, + SUIX, + SUIX, + SUIX, + SUIX, + SUIX, + SUIX, + SUIX, + // 8 9 : ; < = > ? + SUIX, + SUIX, + SU, + SU, + SU, + SU, + SU, + SU, + // @ A B C D E F G + SU, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJ, + // H I J K L M N O + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + // P Q R S T U V W + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + // X Y Z [ \ ] ^ _ + SUIJ, + SUIJ, + SUIJ, + SU, + J, + SU, + SU, + SUIJ, + // ` a b c d e f g + SU, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJX, + SUIJ, + // h i j k l m n o + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + // p q r s t u v w + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + SUIJ, + // x y z { | } ~ 7F + SUIJ, + SUIJ, + SUIJ, + SU, + SU, + SU, + SU, + S, +]; +/* eslint-enable indent, indent-legacy, no-multi-spaces, comma-spacing, spaced-comment */ + +/** + * True if 'ch' is in character class 'cls', which should be one of + * the constants above or some combination of them. All characters + * above U+007F are considered to be in 'cls'. EOF is never in 'cls'. + */ +function IsOpenCharClass(ch, cls) { + return ch >= 0 && (ch >= 128 || (gLexTable[ch] & cls) != 0); +} + +/** + * True if 'ch' is in character class 'cls', which should be one of + * the constants above or some combination of them. No characters + * above U+007F are considered to be in 'cls'. EOF is never in 'cls'. + */ +function IsClosedCharClass(ch, cls) { + return ch >= 0 && ch < 128 && (gLexTable[ch] & cls) != 0; +} + +/** + * True if 'ch' is CSS whitespace, i.e. any of the ASCII characters + * TAB, LF, FF, CR, or SPC. + */ +function IsWhitespace(ch) { + return IsClosedCharClass(ch, IS_SPACE); +} + +/** + * True if 'ch' is horizontal whitespace, i.e. TAB or SPC. + */ +function IsHorzSpace(ch) { + return IsClosedCharClass(ch, IS_HSPACE); +} + +/** + * True if 'ch' is vertical whitespace, i.e. LF, FF, or CR. Vertical + * whitespace requires special handling when consumed, see AdvanceLine. + */ +function IsVertSpace(ch) { + return IsClosedCharClass(ch, IS_VSPACE); +} + +/** + * True if 'ch' is a character that can appear in the middle of an identifier. + * This includes U+0000 since it is handled as U+FFFD, but for purposes of + * GatherText it should not be included in IsOpenCharClass. + */ +function IsIdentChar(ch) { + return IsOpenCharClass(ch, IS_IDCHAR) || ch == 0; +} + +/** + * True if 'ch' is a character that by itself begins an identifier. + * This includes U+0000 since it is handled as U+FFFD, but for purposes of + * GatherText it should not be included in IsOpenCharClass. + * (This is a subset of IsIdentChar.) + */ +function IsIdentStart(ch) { + return IsOpenCharClass(ch, IS_IDSTART) || ch == 0; +} + +/** + * True if the two-character sequence aFirstChar+aSecondChar begins an + * identifier. + */ +function StartsIdent(aFirstChar, aSecondChar) { + return ( + IsIdentStart(aFirstChar) || + (aFirstChar == HYPHEN_MINUS && + (aSecondChar == HYPHEN_MINUS || IsIdentStart(aSecondChar))) + ); +} + +/** + * True if 'ch' is a decimal digit. + */ +function IsDigit(ch) { + return ch >= DIGIT_ZERO && ch <= DIGIT_NINE; +} + +/** + * True if 'ch' is a hexadecimal digit. + */ +function IsHexDigit(ch) { + return IsClosedCharClass(ch, IS_HEX_DIGIT); +} + +/** + * Assuming that 'ch' is a decimal digit, return its numeric value. + */ +function DecimalDigitValue(ch) { + return ch - DIGIT_ZERO; +} + +/** + * Assuming that 'ch' is a hexadecimal digit, return its numeric value. + */ +function HexDigitValue(ch) { + if (IsDigit(ch)) { + return DecimalDigitValue(ch); + } else { + // Note: c&7 just keeps the low three bits which causes + // upper and lower case alphabetics to both yield their + // "relative to 10" value for computing the hex value. + return (ch & 0x7) + 9; + } +} + +/** + * If 'ch' can be the first character of a two-character match operator + * token, return the token type code for that token, otherwise return + * eCSSToken_Symbol to indicate that it can't. + */ +function MatchOperatorType(ch) { + switch (ch) { + case TILDE: + return eCSSToken_Includes; + case VERTICAL_LINE: + return eCSSToken_Dashmatch; + case CIRCUMFLEX_ACCENT: + return eCSSToken_Beginsmatch; + case DOLLAR_SIGN: + return eCSSToken_Endsmatch; + case ASTERISK: + return eCSSToken_Containsmatch; + default: + return eCSSToken_Symbol; + } +} + +function Scanner(buffer) { + this.mBuffer = buffer || ""; + this.mOffset = 0; + this.mCount = this.mBuffer.length; + this.mLineNumber = 1; + this.mLineOffset = 0; + this.mTokenLineOffset = 0; + this.mTokenOffset = 0; + this.mTokenLineNumber = 1; + this.mEOFCharacters = eEOFCharacters_None; +} + +Scanner.prototype = { + /** + * The line number of the most recently returned token. Line + * numbers are 0-based. + */ + get lineNumber() { + return this.mTokenLineNumber - 1; + }, + + /** + * The column number of the most recently returned token. Column + * numbers are 0-based. + */ + get columnNumber() { + return this.mTokenOffset - this.mTokenLineOffset; + }, + + /** + * When EOF is reached, the last token might be unterminated in some + * ways. This method takes an input string and appends the needed + * terminators. In particular: + * + * 1. If EOF occurs mid-string, this will append the correct quote. + * 2. If EOF occurs in a url token, this will append the close paren. + * 3. If EOF occurs in a comment this will append the comment closer. + * + * A trailing backslash might also have been present in the input + * string. This is handled in different ways, depending on the + * context and arguments. + * + * If preserveBackslash is true, then the existing backslash at the + * end of inputString is preserved, and a new backslash is appended. + * That is, the input |\| is transformed to |\\|, and the + * input |'\| is transformed to |'\\'|. + * + * Otherwise, preserveBackslash is false: + * If the backslash appears in a string context, then the trailing + * backslash is dropped from inputString. That is, |"\| is + * transformed to |""|. + * If the backslash appears outside of a string context, then + * U+FFFD is appended. That is, |\| is transformed to a string + * with two characters: backslash followed by U+FFFD. + * + * Passing false for preserveBackslash makes the result conform to + * the CSS Syntax specification. However, passing true may give + * somewhat more intuitive behavior. + * + * @param inputString the input string + * @param preserveBackslash how to handle trailing backslashes + * @return the input string with the termination characters appended + */ + performEOFFixup(aInputString, aPreserveBackslash) { + let result = aInputString; + + let eofChars = this.mEOFCharacters; + + if ( + aPreserveBackslash && + (eofChars & + (eEOFCharacters_DropBackslash | eEOFCharacters_ReplacementChar)) != + 0 + ) { + eofChars &= ~( + eEOFCharacters_DropBackslash | eEOFCharacters_ReplacementChar + ); + result += "\\"; + } + + if ( + (eofChars & eEOFCharacters_DropBackslash) != 0 && + !!result.length && + result.endsWith("\\") + ) { + result = result.slice(0, -1); + } + + const extra = []; + this.AppendImpliedEOFCharacters(eofChars, extra); + const asString = String.fromCharCode.apply(null, extra); + + return result + asString; + }, + + /** + * Return the next token, or null at EOF. + * + * The token object is described by the following WebIDL definition: + * + * dictionary CSSToken { + * // The token type. + * CSSTokenType tokenType = "whitespace"; + * + * // Offset of the first character of the token. + * unsigned long startOffset = 0; + * // Offset of the character after the final character of the token. + * // This is chosen so that the offsets can be passed to |substring| + * // to yield the exact contents of the token. + * unsigned long endOffset = 0; + * + * // If the token is a number, percentage, or dimension, this holds + * // the value. This is not present for other token types. + * double number; + * // If the token is a number, percentage, or dimension, this is true + * // iff the number had an explicit sign. This is not present for + * // other token types. + * boolean hasSign; + * // If the token is a number, percentage, or dimension, this is true + * // iff the number was specified as an integer. This is not present + * // for other token types. + * boolean isInteger; + * + * // Text associated with the token. This is not present for all + * // token types. In particular it is: + * // + * // Token type Meaning + * // =============================== + * // ident The identifier. + * // function The function name. Note that the "(" is part + * // of the token but is not present in |text|. + * // at The word. + * // id The word. + * // hash The word. + * // dimension The dimension. + * // string The string contents after escape processing. + * // bad_string Ditto. + * // url The URL after escape processing. + * // bad_url Ditto. + * // symbol The symbol text. + * DOMString text; + * }; + */ + nextToken() { + const token = {}; + if (!this.Next(token)) { + return null; + } + + const resultToken = {}; + resultToken.tokenType = token.mType; + resultToken.startOffset = this.mTokenOffset; + resultToken.endOffset = this.mOffset; + const constructText = () => { + return safeApply(String.fromCharCode, null, token.mIdent).join(""); + }; + + switch (token.mType) { + case eCSSToken_Whitespace: + break; + + case eCSSToken_Ident: + case eCSSToken_Function: + case eCSSToken_AtKeyword: + case eCSSToken_ID: + case eCSSToken_Hash: + resultToken.text = constructText(); + break; + + case eCSSToken_Dimension: + resultToken.text = constructText(); + /* Fall through. */ + case eCSSToken_Number: + case eCSSToken_Percentage: + resultToken.number = token.mNumber; + resultToken.hasSign = token.mHasSign; + resultToken.isInteger = token.mIntegerValid; + break; + + case eCSSToken_String: + case eCSSToken_Bad_String: + case eCSSToken_URL: + case eCSSToken_Bad_URL: + resultToken.text = constructText(); + /* Don't bother emitting the delimiter, as it is readily extracted + from the source string when needed. */ + break; + + case eCSSToken_Symbol: + resultToken.text = String.fromCharCode(token.mSymbol); + break; + + case eCSSToken_Includes: + case eCSSToken_Dashmatch: + case eCSSToken_Beginsmatch: + case eCSSToken_Endsmatch: + case eCSSToken_Containsmatch: + case eCSSToken_URange: + break; + + case eCSSToken_Comment: + case eCSSToken_HTMLComment: + /* The comment text is easily extracted from the source string, + and is rarely useful. */ + break; + } + + return resultToken; + }, + + /** + * Return the raw UTF-16 code unit at position |this.mOffset + n| within + * the read buffer. If that is beyond the end of the buffer, returns + * -1 to indicate end of input. + */ + Peek(n = 0) { + if (this.mOffset + n >= this.mCount) { + return -1; + } + return this.mBuffer.charCodeAt(this.mOffset + n); + }, + + /** + * Advance |this.mOffset| over |n| code units. Advance(0) is a no-op. + * If |n| is greater than the distance to end of input, will silently + * stop at the end. May not be used to advance over a line boundary; + * AdvanceLine() must be used instead. + */ + Advance(n = 1) { + if (this.mOffset + n >= this.mCount || this.mOffset + n < this.mOffset) { + this.mOffset = this.mCount; + } else { + this.mOffset += n; + } + }, + + /** + * Advance |this.mOffset| over a line boundary. + */ + AdvanceLine() { + // Advance over \r\n as a unit. + if ( + this.mBuffer.charCodeAt(this.mOffset) == CARRIAGE_RETURN && + this.mOffset + 1 < this.mCount && + this.mBuffer.charCodeAt(this.mOffset + 1) == LINE_FEED + ) { + this.mOffset += 2; + } else { + this.mOffset += 1; + } + // 0 is a magical line number meaning that we don't know (i.e., script) + if (this.mLineNumber != 0) { + this.mLineNumber++; + } + this.mLineOffset = this.mOffset; + }, + + /** + * Skip over a sequence of whitespace characters (vertical or + * horizontal) starting at the current read position. + */ + SkipWhitespace() { + for (;;) { + const ch = this.Peek(); + if (!IsWhitespace(ch)) { + // EOF counts as non-whitespace + break; + } + if (IsVertSpace(ch)) { + this.AdvanceLine(); + } else { + this.Advance(); + } + } + }, + + /** + * Skip over one CSS comment starting at the current read position. + */ + SkipComment() { + this.Advance(2); + for (;;) { + let ch = this.Peek(); + if (ch < 0) { + this.SetEOFCharacters(eEOFCharacters_Asterisk | eEOFCharacters_Slash); + return; + } + if (ch == ASTERISK) { + this.Advance(); + ch = this.Peek(); + if (ch < 0) { + this.SetEOFCharacters(eEOFCharacters_Slash); + return; + } + if (ch == SOLIDUS) { + this.Advance(); + return; + } + } else if (IsVertSpace(ch)) { + this.AdvanceLine(); + } else { + this.Advance(); + } + } + }, + + /** + * If there is a valid escape sequence starting at the current read + * position, consume it, decode it, append the result to |aOutput|, + * and return true. Otherwise, consume nothing, leave |aOutput| + * unmodified, and return false. If |aInString| is true, accept the + * additional form of escape sequence allowed within string-like tokens. + */ + GatherEscape(aOutput, aInString) { + let ch = this.Peek(1); + if (ch < 0) { + // If we are in a string (or a url() containing a string), we want to drop + // the backslash on the floor. Otherwise, we want to treat it as a U+FFFD + // character. + this.Advance(); + if (aInString) { + this.SetEOFCharacters(eEOFCharacters_DropBackslash); + } else { + aOutput.push(UCS2_REPLACEMENT_CHAR); + this.SetEOFCharacters(eEOFCharacters_ReplacementChar); + } + return true; + } + if (IsVertSpace(ch)) { + if (aInString) { + // In strings (and in url() containing a string), escaped + // newlines are completely removed, to allow splitting over + // multiple lines. + this.Advance(); + this.AdvanceLine(); + return true; + } + // Outside of strings, backslash followed by a newline is not an escape. + return false; + } + + if (!IsHexDigit(ch)) { + // "Any character (except a hexadecimal digit, linefeed, carriage + // return, or form feed) can be escaped with a backslash to remove + // its special meaning." -- CSS2.1 section 4.1.3 + this.Advance(2); + if (ch == 0) { + aOutput.push(UCS2_REPLACEMENT_CHAR); + } else { + aOutput.push(ch); + } + return true; + } + + // "[at most six hexadecimal digits following a backslash] stand + // for the ISO 10646 character with that number, which must not be + // zero. (It is undefined in CSS 2.1 what happens if a style sheet + // does contain a character with Unicode codepoint zero.)" + // -- CSS2.1 section 4.1.3 + + // At this point we know we have \ followed by at least one + // hexadecimal digit, therefore the escape sequence is valid and we + // can go ahead and consume the backslash. + this.Advance(); + let val = 0; + let i = 0; + do { + val = val * 16 + HexDigitValue(ch); + i++; + this.Advance(); + ch = this.Peek(); + } while (i < 6 && IsHexDigit(ch)); + + // "Interpret the hex digits as a hexadecimal number. If this + // number is zero, or is greater than the maximum allowed + // codepoint, return U+FFFD REPLACEMENT CHARACTER" -- CSS Syntax + // Level 3 + if (val == 0) { + aOutput.push(UCS2_REPLACEMENT_CHAR); + } else { + aOutput.push(ensureValidChar(val)); + } + + // Consume exactly one whitespace character after a + // hexadecimal escape sequence. + if (IsVertSpace(ch)) { + this.AdvanceLine(); + } else if (IsHorzSpace(ch)) { + this.Advance(); + } + return true; + }, + + /** + * Consume a run of "text" beginning with the current read position, + * consisting of characters in the class |aClass| (which must be a + * suitable argument to IsOpenCharClass) plus escape sequences. + * Append the text to |aText|, after decoding escape sequences. + * + * Returns true if at least one character was appended to |aText|, + * false otherwise. + */ + GatherText(aClass, aText) { + const start = this.mOffset; + const inString = aClass == IS_STRING; + + for (;;) { + // Consume runs of unescaped characters in one go. + let n = this.mOffset; + while ( + n < this.mCount && + IsOpenCharClass(this.mBuffer.charCodeAt(n), aClass) + ) { + n++; + } + if (n > this.mOffset) { + const codes = stringToCodes(this.mBuffer.slice(this.mOffset, n)); + safeApply(Array.prototype.push, aText, codes); + this.mOffset = n; + } + if (n == this.mCount) { + break; + } + + const ch = this.Peek(); + if (ch == 0) { + this.Advance(); + aText.push(UCS2_REPLACEMENT_CHAR); + continue; + } + + if (ch != REVERSE_SOLIDUS) { + break; + } + if (!this.GatherEscape(aText, inString)) { + break; + } + } + + return this.mOffset > start; + }, + + /** + * Scan an Ident token. This also handles Function and URL tokens, + * both of which begin indistinguishably from an identifier. It can + * produce a Symbol token when an apparent identifier actually led + * into an invalid escape sequence. + */ + ScanIdent(aToken) { + if (!this.GatherText(IS_IDCHAR, aToken.mIdent)) { + aToken.mSymbol = this.Peek(); + this.Advance(); + return true; + } + + if (this.Peek() != LEFT_PARENTHESIS) { + aToken.mType = eCSSToken_Ident; + return true; + } + + this.Advance(); + aToken.mType = eCSSToken_Function; + + const asString = String.fromCharCode.apply(null, aToken.mIdent); + if (asString.toLowerCase() === "url") { + this.NextURL(aToken); + } + return true; + }, + + /** + * Scan an AtKeyword token. Also handles production of Symbol when + * an '@' is not followed by an identifier. + */ + ScanAtKeyword(aToken) { + // Fall back for when '@' isn't followed by an identifier. + aToken.mSymbol = COMMERCIAL_AT; + this.Advance(); + + const ch = this.Peek(); + if (StartsIdent(ch, this.Peek(1))) { + if (this.GatherText(IS_IDCHAR, aToken.mIdent)) { + aToken.mType = eCSSToken_AtKeyword; + } + } + return true; + }, + + /** + * Scan a Hash token. Handles the distinction between eCSSToken_ID + * and eCSSToken_Hash, and handles production of Symbol when a '#' + * is not followed by identifier characters. + */ + ScanHash(aToken) { + // Fall back for when '#' isn't followed by identifier characters. + aToken.mSymbol = NUMBER_SIGN; + this.Advance(); + + const ch = this.Peek(); + if (IsIdentChar(ch) || ch == REVERSE_SOLIDUS) { + const type = StartsIdent(ch, this.Peek(1)) + ? eCSSToken_ID + : eCSSToken_Hash; + aToken.mIdent.length = 0; + if (this.GatherText(IS_IDCHAR, aToken.mIdent)) { + aToken.mType = type; + } + } + + return true; + }, + + /** + * Scan a Number, Percentage, or Dimension token (all of which begin + * like a Number). Can produce a Symbol when a '.' is not followed by + * digits, or when '+' or '-' are not followed by either a digit or a + * '.' and then a digit. Can also produce a HTMLComment when it + * encounters '-->'. + */ + ScanNumber(aToken) { + let c = this.Peek(); + + // Sign of the mantissa (-1 or 1). + const sign = c == HYPHEN_MINUS ? -1 : 1; + // Absolute value of the integer part of the mantissa. This is a double so + // we don't run into overflow issues for consumers that only care about our + // floating-point value while still being able to express the full int32_t + // range for consumers who want integers. + let intPart = 0; + // Fractional part of the mantissa. This is a double so that when + // we convert to float at the end we'll end up rounding to nearest + // float instead of truncating down (as we would if fracPart were + // a float and we just effectively lost the last several digits). + let fracPart = 0; + // Absolute value of the power of 10 that we should multiply by + // (only relevant for numbers in scientific notation). Has to be + // a signed integer, because multiplication of signed by unsigned + // converts the unsigned to signed, so if we plan to actually + // multiply by expSign... + let exponent = 0; + // Sign of the exponent. + let expSign = 1; + + aToken.mHasSign = c == PLUS_SIGN || c == HYPHEN_MINUS; + if (aToken.mHasSign) { + this.Advance(); + c = this.Peek(); + } + + let gotDot = c == FULL_STOP; + + if (!gotDot) { + // Scan the integer part of the mantissa. + do { + intPart = 10 * intPart + DecimalDigitValue(c); + this.Advance(); + c = this.Peek(); + } while (IsDigit(c)); + + gotDot = c == FULL_STOP && IsDigit(this.Peek(1)); + } + + if (gotDot) { + // Scan the fractional part of the mantissa. + this.Advance(); + c = this.Peek(); + // Power of ten by which we need to divide our next digit + let divisor = 10; + do { + fracPart += DecimalDigitValue(c) / divisor; + divisor *= 10; + this.Advance(); + c = this.Peek(); + } while (IsDigit(c)); + } + + let gotE = false; + if (c == LATIN_SMALL_LETTER_E || c == LATIN_CAPITAL_LETTER_E) { + const expSignChar = this.Peek(1); + const nextChar = this.Peek(2); + if ( + IsDigit(expSignChar) || + ((expSignChar == HYPHEN_MINUS || expSignChar == PLUS_SIGN) && + IsDigit(nextChar)) + ) { + gotE = true; + if (expSignChar == HYPHEN_MINUS) { + expSign = -1; + } + this.Advance(); // consumes the E + if (expSignChar == HYPHEN_MINUS || expSignChar == PLUS_SIGN) { + this.Advance(); + c = nextChar; + } else { + c = expSignChar; + } + do { + exponent = 10 * exponent + DecimalDigitValue(c); + this.Advance(); + c = this.Peek(); + } while (IsDigit(c)); + } + } + + let type = eCSSToken_Number; + + // Set mIntegerValid for all cases (except %, below) because we need + // it for the "2n" in :nth-child(2n). + aToken.mIntegerValid = false; + + // Time to reassemble our number. + // Do all the math in double precision so it's truncated only once. + let value = sign * (intPart + fracPart); + if (gotE) { + // Explicitly cast expSign*exponent to double to avoid issues with + // overloaded pow() on Windows. + value *= Math.pow(10.0, expSign * exponent); + } else if (!gotDot) { + // Clamp values outside of integer range. + if (sign > 0) { + aToken.mInteger = Math.min(intPart, Number.MAX_SAFE_INTEGER); + } else { + aToken.mInteger = Math.max(-intPart, Number.MIN_SAFE_INTEGER); + } + aToken.mIntegerValid = true; + } + + const ident = aToken.mIdent; + + // Check for Dimension and Percentage tokens. + if (c >= 0) { + if (StartsIdent(c, this.Peek(1))) { + if (this.GatherText(IS_IDCHAR, ident)) { + type = eCSSToken_Dimension; + } + } else if (c == PERCENT_SIGN) { + this.Advance(); + type = eCSSToken_Percentage; + value = value / 100.0; + aToken.mIntegerValid = false; + } + } + aToken.mNumber = value; + aToken.mType = type; + return true; + }, + + /** + * Scan a string constant ('foo' or "foo"). Will always produce + * either a String or a Bad_String token; the latter occurs when the + * close quote is missing. Always returns true (for convenience in Next()). + */ + ScanString(aToken) { + const aStop = this.Peek(); + aToken.mType = eCSSToken_String; + aToken.mSymbol = aStop; // Remember how it's quoted. + this.Advance(); + + for (;;) { + this.GatherText(IS_STRING, aToken.mIdent); + + const ch = this.Peek(); + if (ch == -1) { + this.AddEOFCharacters( + aStop == QUOTATION_MARK + ? eEOFCharacters_DoubleQuote + : eEOFCharacters_SingleQuote + ); + break; // EOF ends a string token with no error. + } + if (ch == aStop) { + this.Advance(); + break; + } + // Both " and ' are excluded from IS_STRING. + if (ch == QUOTATION_MARK || ch == APOSTROPHE) { + aToken.mIdent.push(ch); + this.Advance(); + continue; + } + + aToken.mType = eCSSToken_Bad_String; + break; + } + return true; + }, + + /** + * Scan a unicode-range token. These match the regular expression + * + * u\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})? + * + * However, some such tokens are "invalid". There are three valid forms: + * + * u+[0-9a-f]{x} 1 <= x <= 6 + * u+[0-9a-f]{x}\?{y} 1 <= x+y <= 6 + * u+[0-9a-f]{x}-[0-9a-f]{y} 1 <= x <= 6, 1 <= y <= 6 + * + * All unicode-range tokens have their text recorded in mIdent; valid ones + * are also decoded into mInteger and mInteger2, and mIntegerValid is set. + * Note that this does not validate the numeric range, only the syntactic + * form. + */ + ScanURange(aResult) { + const intro1 = this.Peek(); + const intro2 = this.Peek(1); + let ch = this.Peek(2); + + aResult.mIdent.push(intro1); + aResult.mIdent.push(intro2); + this.Advance(2); + + let valid = true; + let haveQues = false; + let low = 0; + let high = 0; + let i = 0; + + do { + aResult.mIdent.push(ch); + if (IsHexDigit(ch)) { + if (haveQues) { + valid = false; // All question marks should be at the end. + } + low = low * 16 + HexDigitValue(ch); + high = high * 16 + HexDigitValue(ch); + } else { + haveQues = true; + low = low * 16 + 0x0; + high = high * 16 + 0xf; + } + + i++; + this.Advance(); + ch = this.Peek(); + } while (i < 6 && (IsHexDigit(ch) || ch == QUESTION_MARK)); + + if (ch == HYPHEN_MINUS && IsHexDigit(this.Peek(1))) { + if (haveQues) { + valid = false; + } + + aResult.mIdent.push(ch); + this.Advance(); + ch = this.Peek(); + high = 0; + i = 0; + do { + aResult.mIdent.push(ch); + high = high * 16 + HexDigitValue(ch); + + i++; + this.Advance(); + ch = this.Peek(); + } while (i < 6 && IsHexDigit(ch)); + } + + aResult.mInteger = low; + aResult.mInteger2 = high; + aResult.mIntegerValid = valid; + aResult.mType = eCSSToken_URange; + return true; + }, + + SetEOFCharacters(aEOFCharacters) { + this.mEOFCharacters = aEOFCharacters; + }, + + AddEOFCharacters(aEOFCharacters) { + this.mEOFCharacters = this.mEOFCharacters | aEOFCharacters; + }, + + AppendImpliedEOFCharacters(aEOFCharacters, aResult) { + // First, ignore eEOFCharacters_DropBackslash. + let c = aEOFCharacters >> 1; + + // All of the remaining EOFCharacters bits represent appended characters, + // and the bits are in the order that they need appending. + for (const p of kImpliedEOFCharacters) { + if (c & 1) { + aResult.push(p); + } + c >>= 1; + } + }, + + /** + * Consume the part of an URL token after the initial 'url('. Caller + * is assumed to have consumed 'url(' already. Will always produce + * either an URL or a Bad_URL token. + * + * Exposed for use by nsCSSParser::ParseMozDocumentRule, which applies + * the special lexical rules for URL tokens in a nonstandard context. + */ + NextURL(aToken) { + this.SkipWhitespace(); + + // aToken.mIdent may be "url" at this point; clear that out + aToken.mIdent.length = 0; + + let hasString = false; + let ch = this.Peek(); + // Do we have a string? + if (ch == QUOTATION_MARK || ch == APOSTROPHE) { + this.ScanString(aToken); + if (aToken.mType == eCSSToken_Bad_String) { + aToken.mType = eCSSToken_Bad_URL; + return; + } + hasString = true; + } else { + // Otherwise, this is the start of a non-quoted url (which may be empty). + aToken.mSymbol = 0; + this.GatherText(IS_URL_CHAR, aToken.mIdent); + } + + // Consume trailing whitespace and then look for a close parenthesis. + this.SkipWhitespace(); + ch = this.Peek(); + // ch can be less than zero indicating EOF + if (ch < 0 || ch == RIGHT_PARENTHESIS) { + this.Advance(); + aToken.mType = eCSSToken_URL; + if (ch < 0) { + this.AddEOFCharacters(eEOFCharacters_CloseParen); + } + } else { + aToken.mType = eCSSToken_Bad_URL; + if (!hasString) { + // Consume until before the next right parenthesis, which follows + // how <bad-url-token> is consumed in CSS Syntax 3 spec. + // Note that, we only do this when "url(" is not followed by a + // string, because in the spec, "url(" followed by a string is + // handled as a url function rather than a <url-token>, so the + // rest of content before ")" should be consumed in balance, + // which will be done by the parser. + // The closing ")" is not consumed here. It is left to the parser + // so that the parser can handle both cases. + do { + if (IsVertSpace(ch)) { + this.AdvanceLine(); + } else { + this.Advance(); + } + ch = this.Peek(); + } while (ch >= 0 && ch != RIGHT_PARENTHESIS); + } + } + }, + + /** + * Primary scanner entry point. Consume one token and fill in + * |aToken| accordingly. Will skip over any number of comments first, + * and will also skip over rather than return whitespace and comment + * tokens, depending on the value of |aSkip|. + * + * Returns true if it successfully consumed a token, false if EOF has + * been reached. Will always advance the current read position by at + * least one character unless called when already at EOF. + */ + Next(aToken, aSkip) { + // do this here so we don't have to do it in dozens of other places + aToken.mIdent = []; + aToken.mType = eCSSToken_Symbol; + + this.mTokenOffset = this.mOffset; + this.mTokenLineOffset = this.mLineOffset; + this.mTokenLineNumber = this.mLineNumber; + + const ch = this.Peek(); + if (IsWhitespace(ch)) { + this.SkipWhitespace(); + aToken.mType = eCSSToken_Whitespace; + return true; + } + if ( + ch == SOLIDUS && // !IsSVGMode() && + this.Peek(1) == ASTERISK + ) { + this.SkipComment(); + aToken.mType = eCSSToken_Comment; + return true; + } + + // EOF + if (ch < 0) { + return false; + } + + // 'u' could be UNICODE-RANGE or an identifier-family token + if (ch == LATIN_SMALL_LETTER_U || ch == LATIN_CAPITAL_LETTER_U) { + const c2 = this.Peek(1); + const c3 = this.Peek(2); + if (c2 == PLUS_SIGN && (IsHexDigit(c3) || c3 == QUESTION_MARK)) { + return this.ScanURange(aToken); + } + return this.ScanIdent(aToken); + } + + // identifier family + if (IsIdentStart(ch)) { + return this.ScanIdent(aToken); + } + + // number family + if (IsDigit(ch)) { + return this.ScanNumber(aToken); + } + + if (ch == FULL_STOP && IsDigit(this.Peek(1))) { + return this.ScanNumber(aToken); + } + + if (ch == PLUS_SIGN) { + const c2 = this.Peek(1); + if (IsDigit(c2) || (c2 == FULL_STOP && IsDigit(this.Peek(2)))) { + return this.ScanNumber(aToken); + } + } + + // HYPHEN_MINUS can start an identifier-family token, a number-family token, + // or an HTML-comment + if (ch == HYPHEN_MINUS) { + const c2 = this.Peek(1); + const c3 = this.Peek(2); + if (IsIdentStart(c2) || (c2 == HYPHEN_MINUS && c3 != GREATER_THAN_SIGN)) { + return this.ScanIdent(aToken); + } + if (IsDigit(c2) || (c2 == FULL_STOP && IsDigit(c3))) { + return this.ScanNumber(aToken); + } + if (c2 == HYPHEN_MINUS && c3 == GREATER_THAN_SIGN) { + this.Advance(3); + aToken.mType = eCSSToken_HTMLComment; + aToken.mIdent = stringToCodes("-->"); + return true; + } + } + + // the other HTML-comment token + if ( + ch == LESS_THAN_SIGN && + this.Peek(1) == EXCLAMATION_MARK && + this.Peek(2) == HYPHEN_MINUS && + this.Peek(3) == HYPHEN_MINUS + ) { + this.Advance(4); + aToken.mType = eCSSToken_HTMLComment; + aToken.mIdent = stringToCodes("<!--"); + return true; + } + + // AT_KEYWORD + if (ch == COMMERCIAL_AT) { + return this.ScanAtKeyword(aToken); + } + + // HASH + if (ch == NUMBER_SIGN) { + return this.ScanHash(aToken); + } + + // STRING + if (ch == QUOTATION_MARK || ch == APOSTROPHE) { + return this.ScanString(aToken); + } + + // Match operators: ~= |= ^= $= *= + const opType = MatchOperatorType(ch); + if (opType != eCSSToken_Symbol && this.Peek(1) == EQUALS_SIGN) { + aToken.mType = opType; + this.Advance(2); + return true; + } + + // Otherwise, a symbol (DELIM). + aToken.mSymbol = ch; + this.Advance(); + return true; + }, +}; + +/** + * Create and return a new CSS lexer. + * + * @param {String} input the CSS text to lex + * @return {CSSLexer} the new lexer + */ +function getCSSLexer(input) { + return new Scanner(input); +} + +exports.getCSSLexer = getCSSLexer; |