diff options
Diffstat (limited to 'layout/style/nsCSSScanner.cpp')
| -rw-r--r-- | layout/style/nsCSSScanner.cpp | 1380 |
1 files changed, 1380 insertions, 0 deletions
diff --git a/layout/style/nsCSSScanner.cpp b/layout/style/nsCSSScanner.cpp new file mode 100644 index 000000000..771c8936b --- /dev/null +++ b/layout/style/nsCSSScanner.cpp @@ -0,0 +1,1380 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + + +/* tokenization of CSS style sheets */ + +#include "nsCSSScanner.h" +#include "nsStyleUtil.h" +#include "nsISupportsImpl.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/css/ErrorReporter.h" +#include "mozilla/Likely.h" +#include <algorithm> + +/* Character class tables and related helper functions. */ + +static const uint8_t IS_HEX_DIGIT = 0x01; +static const uint8_t IS_IDSTART = 0x02; +static const uint8_t IS_IDCHAR = 0x04; +static const uint8_t IS_URL_CHAR = 0x08; +static const uint8_t IS_HSPACE = 0x10; +static const uint8_t IS_VSPACE = 0x20; +static const uint8_t IS_SPACE = IS_HSPACE|IS_VSPACE; +static const uint8_t IS_STRING = 0x40; + +#define H IS_HSPACE +#define V IS_VSPACE +#define I IS_IDCHAR +#define J IS_IDSTART +#define U IS_URL_CHAR +#define S IS_STRING +#define X IS_HEX_DIGIT + +#define SH S|H +#define SU S|U +#define SUI S|U|I +#define SUIJ S|U|I|J +#define SUIX S|U|I|X +#define SUIJX S|U|I|J|X + +static const uint8_t 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, +}; + +static_assert(MOZ_ARRAY_LENGTH(gLexTable) == 128, + "gLexTable expected to cover all 128 ASCII characters"); + +#undef I +#undef J +#undef U +#undef S +#undef X +#undef SH +#undef SU +#undef SUI +#undef SUIJ +#undef SUIX +#undef SUIJX + +/** + * 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'. + */ +static inline bool +IsOpenCharClass(int32_t ch, uint8_t 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'. + */ +static inline bool +IsClosedCharClass(int32_t ch, uint8_t cls) { + return uint32_t(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. + */ +static inline bool +IsWhitespace(int32_t ch) { + return IsClosedCharClass(ch, IS_SPACE); +} + +/** + * True if 'ch' is horizontal whitespace, i.e. TAB or SPC. + */ +static inline bool +IsHorzSpace(int32_t 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. + */ +static inline bool +IsVertSpace(int32_t 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. + */ +static inline bool +IsIdentChar(int32_t 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.) + */ +static inline bool +IsIdentStart(int32_t ch) { + return IsOpenCharClass(ch, IS_IDSTART) || ch == 0; +} + +/** + * True if the two-character sequence aFirstChar+aSecondChar begins an + * identifier. + */ +static inline bool +StartsIdent(int32_t aFirstChar, int32_t aSecondChar) +{ + return IsIdentStart(aFirstChar) || + (aFirstChar == '-' && (aSecondChar == '-' || IsIdentStart(aSecondChar))); +} + +/** + * True if 'ch' is a decimal digit. + */ +static inline bool +IsDigit(int32_t ch) { + return (ch >= '0') && (ch <= '9'); +} + +/** + * True if 'ch' is a hexadecimal digit. + */ +static inline bool +IsHexDigit(int32_t ch) { + return IsClosedCharClass(ch, IS_HEX_DIGIT); +} + +/** + * Assuming that 'ch' is a decimal digit, return its numeric value. + */ +static inline uint32_t +DecimalDigitValue(int32_t ch) +{ + return ch - '0'; +} + +/** + * Assuming that 'ch' is a hexadecimal digit, return its numeric value. + */ +static inline uint32_t +HexDigitValue(int32_t 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. + */ +static inline nsCSSTokenType +MatchOperatorType(int32_t ch) +{ + switch (ch) { + case '~': return eCSSToken_Includes; + case '|': return eCSSToken_Dashmatch; + case '^': return eCSSToken_Beginsmatch; + case '$': return eCSSToken_Endsmatch; + case '*': return eCSSToken_Containsmatch; + default: return eCSSToken_Symbol; + } +} + +/* Out-of-line nsCSSToken methods. */ + +/** + * Append the textual representation of |this| to |aBuffer|. + */ +void +nsCSSToken::AppendToString(nsString& aBuffer) const +{ + switch (mType) { + case eCSSToken_Ident: + nsStyleUtil::AppendEscapedCSSIdent(mIdent, aBuffer); + break; + + case eCSSToken_AtKeyword: + aBuffer.Append('@'); + nsStyleUtil::AppendEscapedCSSIdent(mIdent, aBuffer); + break; + + case eCSSToken_ID: + case eCSSToken_Hash: + aBuffer.Append('#'); + nsStyleUtil::AppendEscapedCSSIdent(mIdent, aBuffer); + break; + + case eCSSToken_Function: + nsStyleUtil::AppendEscapedCSSIdent(mIdent, aBuffer); + aBuffer.Append('('); + break; + + case eCSSToken_URL: + case eCSSToken_Bad_URL: + aBuffer.AppendLiteral("url("); + if (mSymbol != char16_t(0)) { + nsStyleUtil::AppendEscapedCSSString(mIdent, aBuffer, mSymbol); + } else { + aBuffer.Append(mIdent); + } + if (mType == eCSSToken_URL) { + aBuffer.Append(char16_t(')')); + } + break; + + case eCSSToken_Number: + if (mIntegerValid) { + aBuffer.AppendInt(mInteger, 10); + } else { + aBuffer.AppendFloat(mNumber); + } + break; + + case eCSSToken_Percentage: + aBuffer.AppendFloat(mNumber * 100.0f); + aBuffer.Append(char16_t('%')); + break; + + case eCSSToken_Dimension: + if (mIntegerValid) { + aBuffer.AppendInt(mInteger, 10); + } else { + aBuffer.AppendFloat(mNumber); + } + nsStyleUtil::AppendEscapedCSSIdent(mIdent, aBuffer); + break; + + case eCSSToken_Bad_String: + nsStyleUtil::AppendEscapedCSSString(mIdent, aBuffer, mSymbol); + // remove the trailing quote character + aBuffer.Truncate(aBuffer.Length() - 1); + break; + + case eCSSToken_String: + nsStyleUtil::AppendEscapedCSSString(mIdent, aBuffer, mSymbol); + break; + + case eCSSToken_Symbol: + aBuffer.Append(mSymbol); + break; + + case eCSSToken_Whitespace: + aBuffer.Append(' '); + break; + + case eCSSToken_HTMLComment: + case eCSSToken_URange: + aBuffer.Append(mIdent); + break; + + case eCSSToken_Includes: + aBuffer.AppendLiteral("~="); + break; + case eCSSToken_Dashmatch: + aBuffer.AppendLiteral("|="); + break; + case eCSSToken_Beginsmatch: + aBuffer.AppendLiteral("^="); + break; + case eCSSToken_Endsmatch: + aBuffer.AppendLiteral("$="); + break; + case eCSSToken_Containsmatch: + aBuffer.AppendLiteral("*="); + break; + + default: + NS_ERROR("invalid token type"); + break; + } +} + +/* nsCSSScanner methods. */ + +nsCSSScanner::nsCSSScanner(const nsAString& aBuffer, uint32_t aLineNumber) + : mBuffer(aBuffer.BeginReading()) + , mOffset(0) + , mCount(aBuffer.Length()) + , mLineNumber(aLineNumber) + , mLineOffset(0) + , mTokenLineNumber(aLineNumber) + , mTokenLineOffset(0) + , mTokenOffset(0) + , mRecordStartOffset(0) + , mEOFCharacters(eEOFCharacters_None) + , mReporter(nullptr) + , mSVGMode(false) + , mRecording(false) + , mSeenBadToken(false) + , mSeenVariableReference(false) +{ + MOZ_COUNT_CTOR(nsCSSScanner); +} + +nsCSSScanner::~nsCSSScanner() +{ + MOZ_COUNT_DTOR(nsCSSScanner); +} + +void +nsCSSScanner::StartRecording() +{ + MOZ_ASSERT(!mRecording, "already started recording"); + mRecording = true; + mRecordStartOffset = mOffset; +} + +void +nsCSSScanner::StopRecording() +{ + MOZ_ASSERT(mRecording, "haven't started recording"); + mRecording = false; +} + +void +nsCSSScanner::StopRecording(nsString& aBuffer) +{ + MOZ_ASSERT(mRecording, "haven't started recording"); + mRecording = false; + aBuffer.Append(mBuffer + mRecordStartOffset, + mOffset - mRecordStartOffset); +} + +uint32_t +nsCSSScanner::RecordingLength() const +{ + MOZ_ASSERT(mRecording, "haven't started recording"); + return mOffset - mRecordStartOffset; +} + +#ifdef DEBUG +bool +nsCSSScanner::IsRecording() const +{ + return mRecording; +} +#endif + +nsDependentSubstring +nsCSSScanner::GetCurrentLine() const +{ + uint32_t end = mTokenOffset; + while (end < mCount && !IsVertSpace(mBuffer[end])) { + end++; + } + return nsDependentSubstring(mBuffer + mTokenLineOffset, + mBuffer + end); +} + +/** + * Return the raw UTF-16 code unit at position |mOffset + n| within + * the read buffer. If that is beyond the end of the buffer, returns + * -1 to indicate end of input. + */ +inline int32_t +nsCSSScanner::Peek(uint32_t n) +{ + if (mOffset + n >= mCount) { + return -1; + } + return mBuffer[mOffset + n]; +} + +/** + * Advance |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. + */ +inline void +nsCSSScanner::Advance(uint32_t n) +{ +#ifdef DEBUG + while (mOffset < mCount && n > 0) { + MOZ_ASSERT(!IsVertSpace(mBuffer[mOffset]), + "may not Advance() over a line boundary"); + mOffset++; + n--; + } +#else + if (mOffset + n >= mCount || mOffset + n < mOffset) + mOffset = mCount; + else + mOffset += n; +#endif +} + +/** + * Advance |mOffset| over a line boundary. + */ +void +nsCSSScanner::AdvanceLine() +{ + MOZ_ASSERT(IsVertSpace(mBuffer[mOffset]), + "may not AdvanceLine() over a horizontal character"); + // Advance over \r\n as a unit. + if (mBuffer[mOffset] == '\r' && mOffset + 1 < mCount && + mBuffer[mOffset+1] == '\n') + mOffset += 2; + else + mOffset += 1; + // 0 is a magical line number meaning that we don't know (i.e., script) + if (mLineNumber != 0) + mLineNumber++; + mLineOffset = mOffset; +} + +/** + * Back up |mOffset| over |n| code units. Backup(0) is a no-op. + * If |n| is greater than the distance to beginning of input, will + * silently stop at the beginning. May not be used to back up over a + * line boundary. + */ +void +nsCSSScanner::Backup(uint32_t n) +{ +#ifdef DEBUG + while (mOffset > 0 && n > 0) { + MOZ_ASSERT(!IsVertSpace(mBuffer[mOffset-1]), + "may not Backup() over a line boundary"); + mOffset--; + n--; + } +#else + if (mOffset < n) + mOffset = 0; + else + mOffset -= n; +#endif +} + +void +nsCSSScanner::SavePosition(nsCSSScannerPosition& aState) +{ + aState.mOffset = mOffset; + aState.mLineNumber = mLineNumber; + aState.mLineOffset = mLineOffset; + aState.mTokenLineNumber = mTokenLineNumber; + aState.mTokenLineOffset = mTokenLineOffset; + aState.mTokenOffset = mTokenOffset; + aState.mInitialized = true; +} + +void +nsCSSScanner::RestoreSavedPosition(const nsCSSScannerPosition& aState) +{ + MOZ_ASSERT(aState.mInitialized, "have not saved state"); + if (aState.mInitialized) { + mOffset = aState.mOffset; + mLineNumber = aState.mLineNumber; + mLineOffset = aState.mLineOffset; + mTokenLineNumber = aState.mTokenLineNumber; + mTokenLineOffset = aState.mTokenLineOffset; + mTokenOffset = aState.mTokenOffset; + } +} + +/** + * Skip over a sequence of whitespace characters (vertical or + * horizontal) starting at the current read position. + */ +void +nsCSSScanner::SkipWhitespace() +{ + for (;;) { + int32_t ch = Peek(); + if (!IsWhitespace(ch)) { // EOF counts as non-whitespace + break; + } + if (IsVertSpace(ch)) { + AdvanceLine(); + } else { + Advance(); + } + } +} + +/** + * Skip over one CSS comment starting at the current read position. + */ +void +nsCSSScanner::SkipComment() +{ + MOZ_ASSERT(Peek() == '/' && Peek(1) == '*', "should not have been called"); + Advance(2); + for (;;) { + int32_t ch = Peek(); + if (ch < 0) { + if (mReporter) + mReporter->ReportUnexpectedEOF("PECommentEOF"); + SetEOFCharacters(eEOFCharacters_Asterisk | eEOFCharacters_Slash); + return; + } + if (ch == '*') { + Advance(); + ch = Peek(); + if (ch < 0) { + if (mReporter) + mReporter->ReportUnexpectedEOF("PECommentEOF"); + SetEOFCharacters(eEOFCharacters_Slash); + return; + } + if (ch == '/') { + Advance(); + return; + } + } else if (IsVertSpace(ch)) { + AdvanceLine(); + } else { + 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. + */ +bool +nsCSSScanner::GatherEscape(nsString& aOutput, bool aInString) +{ + MOZ_ASSERT(Peek() == '\\', "should not have been called"); + int32_t ch = 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. + Advance(); + if (aInString) { + SetEOFCharacters(eEOFCharacters_DropBackslash); + } else { + aOutput.Append(UCS2_REPLACEMENT_CHAR); + 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. + Advance(); + 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 + Advance(2); + if (ch == 0) { + aOutput.Append(UCS2_REPLACEMENT_CHAR); + } else { + aOutput.Append(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. + Advance(); + uint32_t val = 0; + int i = 0; + do { + val = val * 16 + HexDigitValue(ch); + i++; + Advance(); + ch = 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 (MOZ_UNLIKELY(val == 0)) { + aOutput.Append(UCS2_REPLACEMENT_CHAR); + } else { + AppendUCS4ToUTF16(ENSURE_VALID_CHAR(val), aOutput); + } + + // Consume exactly one whitespace character after a + // hexadecimal escape sequence. + if (IsVertSpace(ch)) { + AdvanceLine(); + } else if (IsHorzSpace(ch)) { + 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. + */ +bool +nsCSSScanner::GatherText(uint8_t aClass, nsString& aText) +{ + // This is all of the character classes currently used with + // GatherText. If you have a need to use this function with a + // different class, go ahead and add it. + MOZ_ASSERT(aClass == IS_STRING || + aClass == IS_IDCHAR || + aClass == IS_URL_CHAR, + "possibly-inappropriate character class"); + + uint32_t start = mOffset; + bool inString = aClass == IS_STRING; + + for (;;) { + // Consume runs of unescaped characters in one go. + uint32_t n = mOffset; + while (n < mCount && IsOpenCharClass(mBuffer[n], aClass)) { + n++; + } + if (n > mOffset) { + aText.Append(&mBuffer[mOffset], n - mOffset); + mOffset = n; + } + if (n == mCount) { + break; + } + + int32_t ch = Peek(); + MOZ_ASSERT(!IsOpenCharClass(ch, aClass), + "should not have exited the inner loop"); + if (ch == 0) { + Advance(); + aText.Append(UCS2_REPLACEMENT_CHAR); + continue; + } + + if (ch != '\\') { + break; + } + if (!GatherEscape(aText, inString)) { + break; + } + } + + return 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. + */ +bool +nsCSSScanner::ScanIdent(nsCSSToken& aToken) +{ + if (MOZ_UNLIKELY(!GatherText(IS_IDCHAR, aToken.mIdent))) { + MOZ_ASSERT(Peek() == '\\', + "unexpected IsIdentStart character that did not begin an ident"); + aToken.mSymbol = Peek(); + Advance(); + return true; + } + + if (MOZ_LIKELY(Peek() != '(')) { + aToken.mType = eCSSToken_Ident; + return true; + } + + Advance(); + aToken.mType = eCSSToken_Function; + if (aToken.mIdent.LowerCaseEqualsLiteral("url")) { + NextURL(aToken); + } else if (aToken.mIdent.LowerCaseEqualsLiteral("var")) { + mSeenVariableReference = true; + } + return true; +} + +/** + * Scan an AtKeyword token. Also handles production of Symbol when + * an '@' is not followed by an identifier. + */ +bool +nsCSSScanner::ScanAtKeyword(nsCSSToken& aToken) +{ + MOZ_ASSERT(Peek() == '@', "should not have been called"); + + // Fall back for when '@' isn't followed by an identifier. + aToken.mSymbol = '@'; + Advance(); + + int32_t ch = Peek(); + if (StartsIdent(ch, Peek(1))) { + if (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. + */ +bool +nsCSSScanner::ScanHash(nsCSSToken& aToken) +{ + MOZ_ASSERT(Peek() == '#', "should not have been called"); + + // Fall back for when '#' isn't followed by identifier characters. + aToken.mSymbol = '#'; + Advance(); + + int32_t ch = Peek(); + if (IsIdentChar(ch) || ch == '\\') { + nsCSSTokenType type = + StartsIdent(ch, Peek(1)) ? eCSSToken_ID : eCSSToken_Hash; + aToken.mIdent.SetLength(0); + if (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 '-->'. + */ +bool +nsCSSScanner::ScanNumber(nsCSSToken& aToken) +{ + int32_t c = Peek(); +#ifdef DEBUG + { + int32_t c2 = Peek(1); + int32_t c3 = Peek(2); + MOZ_ASSERT(IsDigit(c) || + (IsDigit(c2) && (c == '.' || c == '+' || c == '-')) || + (IsDigit(c3) && (c == '+' || c == '-') && c2 == '.'), + "should not have been called"); + } +#endif + + // Sign of the mantissa (-1 or 1). + int32_t sign = c == '-' ? -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. + double 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). + double 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... + int32_t exponent = 0; + // Sign of the exponent. + int32_t expSign = 1; + + aToken.mHasSign = (c == '+' || c == '-'); + if (aToken.mHasSign) { + Advance(); + c = Peek(); + } + + bool gotDot = (c == '.'); + + if (!gotDot) { + // Scan the integer part of the mantissa. + MOZ_ASSERT(IsDigit(c), "should have been excluded by logic above"); + do { + intPart = 10*intPart + DecimalDigitValue(c); + Advance(); + c = Peek(); + } while (IsDigit(c)); + + gotDot = (c == '.') && IsDigit(Peek(1)); + } + + if (gotDot) { + // Scan the fractional part of the mantissa. + Advance(); + c = Peek(); + MOZ_ASSERT(IsDigit(c), "should have been excluded by logic above"); + // Power of ten by which we need to divide our next digit + double divisor = 10; + do { + fracPart += DecimalDigitValue(c) / divisor; + divisor *= 10; + Advance(); + c = Peek(); + } while (IsDigit(c)); + } + + bool gotE = false; + if (c == 'e' || c == 'E') { + int32_t expSignChar = Peek(1); + int32_t nextChar = Peek(2); + if (IsDigit(expSignChar) || + ((expSignChar == '-' || expSignChar == '+') && IsDigit(nextChar))) { + gotE = true; + if (expSignChar == '-') { + expSign = -1; + } + Advance(); // consumes the E + if (expSignChar == '-' || expSignChar == '+') { + Advance(); + c = nextChar; + } else { + c = expSignChar; + } + MOZ_ASSERT(IsDigit(c), "should have been excluded by logic above"); + do { + exponent = 10*exponent + DecimalDigitValue(c); + Advance(); + c = Peek(); + } while (IsDigit(c)); + } + } + + nsCSSTokenType 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. + double value = sign * (intPart + fracPart); + if (gotE) { + // Avoid multiplication of 0 by Infinity. + if (value != 0.0) { + // Explicitly cast expSign*exponent to double to avoid issues with + // overloaded pow() on Windows. + value *= pow(10.0, double(expSign * exponent)); + } + } else if (!gotDot) { + // Clamp values outside of integer range. + if (sign > 0) { + aToken.mInteger = int32_t(std::min(intPart, double(INT32_MAX))); + } else { + aToken.mInteger = int32_t(std::max(-intPart, double(INT32_MIN))); + } + aToken.mIntegerValid = true; + } + + nsString& ident = aToken.mIdent; + + // Check for Dimension and Percentage tokens. + if (c >= 0) { + if (StartsIdent(c, Peek(1))) { + if (GatherText(IS_IDCHAR, ident)) { + type = eCSSToken_Dimension; + } + } else if (c == '%') { + Advance(); + type = eCSSToken_Percentage; + value = value / 100.0f; + aToken.mIntegerValid = false; + } + } + MOZ_ASSERT(!IsNaN(value), "The value should not be NaN"); + 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()). + */ +bool +nsCSSScanner::ScanString(nsCSSToken& aToken) +{ + int32_t aStop = Peek(); + MOZ_ASSERT(aStop == '"' || aStop == '\'', "should not have been called"); + aToken.mType = eCSSToken_String; + aToken.mSymbol = char16_t(aStop); // Remember how it's quoted. + Advance(); + + for (;;) { + GatherText(IS_STRING, aToken.mIdent); + + int32_t ch = Peek(); + if (ch == -1) { + AddEOFCharacters(aStop == '"' ? eEOFCharacters_DoubleQuote : + eEOFCharacters_SingleQuote); + break; // EOF ends a string token with no error. + } + if (ch == aStop) { + Advance(); + break; + } + // Both " and ' are excluded from IS_STRING. + if (ch == '"' || ch == '\'') { + aToken.mIdent.Append(ch); + Advance(); + continue; + } + + mSeenBadToken = true; + aToken.mType = eCSSToken_Bad_String; + if (mReporter) + mReporter->ReportUnexpected("SEUnterminatedString", aToken); + 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. + */ +bool +nsCSSScanner::ScanURange(nsCSSToken& aResult) +{ + int32_t intro1 = Peek(); + int32_t intro2 = Peek(1); + int32_t ch = Peek(2); + + MOZ_ASSERT((intro1 == 'u' || intro1 == 'U') && + intro2 == '+' && + (IsHexDigit(ch) || ch == '?'), + "should not have been called"); + + aResult.mIdent.Append(intro1); + aResult.mIdent.Append(intro2); + Advance(2); + + bool valid = true; + bool haveQues = false; + uint32_t low = 0; + uint32_t high = 0; + int i = 0; + + do { + aResult.mIdent.Append(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++; + Advance(); + ch = Peek(); + } while (i < 6 && (IsHexDigit(ch) || ch == '?')); + + if (ch == '-' && IsHexDigit(Peek(1))) { + if (haveQues) { + valid = false; + } + + aResult.mIdent.Append(ch); + Advance(); + ch = Peek(); + high = 0; + i = 0; + do { + aResult.mIdent.Append(ch); + high = high*16 + HexDigitValue(ch); + + i++; + Advance(); + ch = Peek(); + } while (i < 6 && IsHexDigit(ch)); + } + + aResult.mInteger = low; + aResult.mInteger2 = high; + aResult.mIntegerValid = valid; + aResult.mType = eCSSToken_URange; + return true; +} + +#ifdef DEBUG +/* static */ void +nsCSSScanner::AssertEOFCharactersValid(uint32_t c) +{ + MOZ_ASSERT(c == eEOFCharacters_None || + c == eEOFCharacters_ReplacementChar || + c == eEOFCharacters_Slash || + c == (eEOFCharacters_Asterisk | + eEOFCharacters_Slash) || + c == eEOFCharacters_DoubleQuote || + c == eEOFCharacters_SingleQuote || + c == (eEOFCharacters_DropBackslash | + eEOFCharacters_DoubleQuote) || + c == (eEOFCharacters_DropBackslash | + eEOFCharacters_SingleQuote) || + c == eEOFCharacters_CloseParen || + c == (eEOFCharacters_ReplacementChar | + eEOFCharacters_CloseParen) || + c == (eEOFCharacters_DoubleQuote | + eEOFCharacters_CloseParen) || + c == (eEOFCharacters_SingleQuote | + eEOFCharacters_CloseParen) || + c == (eEOFCharacters_DropBackslash | + eEOFCharacters_DoubleQuote | + eEOFCharacters_CloseParen) || + c == (eEOFCharacters_DropBackslash | + eEOFCharacters_SingleQuote | + eEOFCharacters_CloseParen), + "invalid EOFCharacters value"); +} +#endif + +void +nsCSSScanner::SetEOFCharacters(uint32_t aEOFCharacters) +{ + mEOFCharacters = EOFCharacters(aEOFCharacters); +} + +void +nsCSSScanner::AddEOFCharacters(uint32_t aEOFCharacters) +{ + mEOFCharacters = EOFCharacters(mEOFCharacters | aEOFCharacters); +} + +static const char16_t kImpliedEOFCharacters[] = { + UCS2_REPLACEMENT_CHAR, '*', '/', '"', '\'', ')', 0 +}; + +/* static */ void +nsCSSScanner::AppendImpliedEOFCharacters(EOFCharacters aEOFCharacters, + nsAString& aResult) +{ + // First, ignore eEOFCharacters_DropBackslash. + uint32_t 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 char16_t* p = kImpliedEOFCharacters; *p && c; p++, c >>= 1) { + if (c & 1) { + aResult.Append(*p); + } + } + + MOZ_ASSERT(c == 0, "too many bits in mEOFCharacters"); +} + +/** + * 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. + */ +void +nsCSSScanner::NextURL(nsCSSToken& aToken) +{ + SkipWhitespace(); + + // aToken.mIdent may be "url" at this point; clear that out + aToken.mIdent.Truncate(); + + int32_t ch = Peek(); + // Do we have a string? + if (ch == '"' || ch == '\'') { + ScanString(aToken); + if (MOZ_UNLIKELY(aToken.mType == eCSSToken_Bad_String)) { + aToken.mType = eCSSToken_Bad_URL; + return; + } + MOZ_ASSERT(aToken.mType == eCSSToken_String, "unexpected token type"); + + } else { + // Otherwise, this is the start of a non-quoted url (which may be empty). + aToken.mSymbol = char16_t(0); + GatherText(IS_URL_CHAR, aToken.mIdent); + } + + // Consume trailing whitespace and then look for a close parenthesis. + SkipWhitespace(); + ch = Peek(); + // ch can be less than zero indicating EOF + if (MOZ_LIKELY(ch < 0 || ch == ')')) { + Advance(); + aToken.mType = eCSSToken_URL; + if (ch < 0) { + AddEOFCharacters(eEOFCharacters_CloseParen); + } + } else { + mSeenBadToken = true; + aToken.mType = eCSSToken_Bad_URL; + } +} + +/** + * 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. + */ +bool +nsCSSScanner::Next(nsCSSToken& aToken, nsCSSScannerExclude aSkip) +{ + int32_t ch; + + // do this here so we don't have to do it in dozens of other places + aToken.mIdent.Truncate(); + aToken.mType = eCSSToken_Symbol; + + for (;;) { + // Consume any number of comments, and possibly also whitespace tokens, + // in between other tokens. + mTokenOffset = mOffset; + mTokenLineOffset = mLineOffset; + mTokenLineNumber = mLineNumber; + + ch = Peek(); + if (IsWhitespace(ch)) { + SkipWhitespace(); + if (aSkip != eCSSScannerExclude_WhitespaceAndComments) { + aToken.mType = eCSSToken_Whitespace; + return true; + } + continue; // start again at the beginning + } + if (ch == '/' && !IsSVGMode() && Peek(1) == '*') { + SkipComment(); + if (aSkip == eCSSScannerExclude_None) { + aToken.mType = eCSSToken_Comment; + return true; + } + continue; // start again at the beginning + } + break; + } + + // EOF + if (ch < 0) { + return false; + } + + // 'u' could be UNICODE-RANGE or an identifier-family token + if (ch == 'u' || ch == 'U') { + int32_t c2 = Peek(1); + int32_t c3 = Peek(2); + if (c2 == '+' && (IsHexDigit(c3) || c3 == '?')) { + return ScanURange(aToken); + } + return ScanIdent(aToken); + } + + // identifier family + if (IsIdentStart(ch)) { + return ScanIdent(aToken); + } + + // number family + if (IsDigit(ch)) { + return ScanNumber(aToken); + } + + if (ch == '.' && IsDigit(Peek(1))) { + return ScanNumber(aToken); + } + + if (ch == '+') { + int32_t c2 = Peek(1); + if (IsDigit(c2) || (c2 == '.' && IsDigit(Peek(2)))) { + return ScanNumber(aToken); + } + } + + // '-' can start an identifier-family token, a number-family token, + // or an HTML-comment + if (ch == '-') { + int32_t c2 = Peek(1); + int32_t c3 = Peek(2); + if (IsIdentStart(c2) || (c2 == '-' && c3 != '>')) { + return ScanIdent(aToken); + } + if (IsDigit(c2) || (c2 == '.' && IsDigit(c3))) { + return ScanNumber(aToken); + } + if (c2 == '-' && c3 == '>') { + Advance(3); + aToken.mType = eCSSToken_HTMLComment; + aToken.mIdent.AssignLiteral("-->"); + return true; + } + } + + // the other HTML-comment token + if (ch == '<' && Peek(1) == '!' && Peek(2) == '-' && Peek(3) == '-') { + Advance(4); + aToken.mType = eCSSToken_HTMLComment; + aToken.mIdent.AssignLiteral("<!--"); + return true; + } + + // AT_KEYWORD + if (ch == '@') { + return ScanAtKeyword(aToken); + } + + // HASH + if (ch == '#') { + return ScanHash(aToken); + } + + // STRING + if (ch == '"' || ch == '\'') { + return ScanString(aToken); + } + + // Match operators: ~= |= ^= $= *= + nsCSSTokenType opType = MatchOperatorType(ch); + if (opType != eCSSToken_Symbol && Peek(1) == '=') { + aToken.mType = opType; + Advance(2); + return true; + } + + // Otherwise, a symbol (DELIM). + aToken.mSymbol = ch; + Advance(); + return true; +} + +/* nsCSSGridTemplateAreaScanner methods. */ + +nsCSSGridTemplateAreaScanner::nsCSSGridTemplateAreaScanner(const nsAString& aBuffer) + : mBuffer(aBuffer.BeginReading()) + , mOffset(0) + , mCount(aBuffer.Length()) +{ +} + +bool +nsCSSGridTemplateAreaScanner::Next(nsCSSGridTemplateAreaToken& aTokenResult) +{ + int32_t ch; + // Skip whitespace + do { + if (mOffset >= mCount) { + return false; + } + ch = mBuffer[mOffset]; + mOffset++; + } while (IsWhitespace(ch)); + + if (IsOpenCharClass(ch, IS_IDCHAR)) { + // Named cell token + uint32_t start = mOffset - 1; // offset of |ch| + while (mOffset < mCount && IsOpenCharClass(mBuffer[mOffset], IS_IDCHAR)) { + mOffset++; + } + aTokenResult.mName.Assign(&mBuffer[start], mOffset - start); + aTokenResult.isTrash = false; + } else if (ch == '.') { + // Null cell token + // Skip any other '.' + while (mOffset < mCount && mBuffer[mOffset] == '.') { + mOffset++; + } + aTokenResult.mName.Truncate(); + aTokenResult.isTrash = false; + } else { + // Trash token + aTokenResult.isTrash = true; + } + return true; +} |