Changeset 245697 in webkit


Ignore:
Timestamp:
May 23, 2019 11:07:49 AM (5 years ago)
Author:
Ross Kirsling
Message:

Lexer<T>::parseDecimal ought to ASSERT isASCIIDigit
​https://bugs.webkit.org/show_bug.cgi?id=198156

Reviewed by Keith Miller.

  • parser/Lexer.cpp:

(JSC::Lexer<T>::parseDecimal):
Add ASSERT -- apparently the issue with doing so earlier was simply
that m_current can be anything at all when m_buffer8 is non-empty.

(JSC::Lexer<T>::lexWithoutClearingLineTerminator):
Clean up a few things in the vicinity of r245655:

  • fix token enum values in a couple of error cases added in the last patch
  • add UNLIKELY for existing error cases that forgot to use it
  • simplify some control flow
Location:
trunk/Source/JavaScriptCore
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r245681 r245697  
     12019-05-23  Ross Kirsling  <ross.kirsling@sony.com>
     2
     3        Lexer<T>::parseDecimal ought to ASSERT isASCIIDigit
     4        https://bugs.webkit.org/show_bug.cgi?id=198156
     5
     6        Reviewed by Keith Miller.
     7
     8        * parser/Lexer.cpp:
     9        (JSC::Lexer<T>::parseDecimal):
     10        Add ASSERT -- apparently the issue with doing so earlier was simply
     11        that m_current can be anything at all when m_buffer8 is non-empty.
     12
     13        (JSC::Lexer<T>::lexWithoutClearingLineTerminator):
     14        Clean up a few things in the vicinity of r245655:
     15         - fix token enum values in a couple of error cases added in the last patch
     16         - add UNLIKELY for existing error cases that forgot to use it
     17         - simplify some control flow
     18
    1192019-05-23  Adrian Perez de Castro  <aperez@igalia.com>
    220

  • trunk/Source/JavaScriptCore/parser/Lexer.cpp

    r245655 r245697  
    16791679ALWAYS_INLINE auto Lexer<T>::parseDecimal() -> Optional<NumberParseResult>
    16801680{
     1681    ASSERT(isASCIIDigit(m_current) || m_buffer8.size());
     1682
    16811683    // Optimization: most decimal values fit into 4 bytes.
    16821684    uint32_t decimalValue = 0;
    … …  
    21972199        if (UNLIKELY(!parseNumberAfterDecimalPoint())) {
    21982200            m_lexErrorMessage = "Non-number found after decimal point"_s;
    2199             token = INVALID_NUMERIC_LITERAL_ERRORTOK;
     2201            token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
    22002202            goto returnError;
    22012203        }
    22022204        token = DOUBLE;
    2203         if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
    2204             if (!parseNumberAfterExponentIndicator()) {
    2205                 m_lexErrorMessage = "Non-number found after exponent indicator"_s;
    2206                 token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
    2207                 goto returnError;
    2208             }
     2205        if (UNLIKELY(isASCIIAlphaCaselessEqual(m_current, 'e') && !parseNumberAfterExponentIndicator())) {
     2206            m_lexErrorMessage = "Non-number found after exponent indicator"_s;
     2207            token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
     2208            goto returnError;
    22092209        }
    22102210        size_t parsedLength;
    … …  
    22232223        shift();
    22242224        if (isASCIIAlphaCaselessEqual(m_current, 'x')) {
    2225             if (!isASCIIHexDigit(peek(1))) {
     2225            if (UNLIKELY(!isASCIIHexDigit(peek(1)))) {
    22262226                m_lexErrorMessage = "No hexadecimal digits after '0x'"_s;
    22272227                token = UNTERMINATED_HEX_NUMBER_ERRORTOK;
    … …  
    22442244            }
    22452245
    2246             if (isIdentStart(m_current)) {
     2246            if (UNLIKELY(isIdentStart(m_current))) {
    22472247                m_lexErrorMessage = "No space between hexadecimal literal and identifier"_s;
    22482248                token = UNTERMINATED_HEX_NUMBER_ERRORTOK;
    … …  
    22552255        }
    22562256        if (isASCIIAlphaCaselessEqual(m_current, 'b')) {
    2257             if (!isASCIIBinaryDigit(peek(1))) {
     2257            if (UNLIKELY(!isASCIIBinaryDigit(peek(1)))) {
    22582258                m_lexErrorMessage = "No binary digits after '0b'"_s;
    22592259                token = UNTERMINATED_BINARY_NUMBER_ERRORTOK;
    … …  
    22762276            }
    22772277
    2278             if (isIdentStart(m_current)) {
     2278            if (UNLIKELY(isIdentStart(m_current))) {
    22792279                m_lexErrorMessage = "No space between binary literal and identifier"_s;
    22802280                token = UNTERMINATED_BINARY_NUMBER_ERRORTOK;
    … …  
    22882288
    22892289        if (isASCIIAlphaCaselessEqual(m_current, 'o')) {
    2290             if (!isASCIIOctalDigit(peek(1))) {
     2290            if (UNLIKELY(!isASCIIOctalDigit(peek(1)))) {
    22912291                m_lexErrorMessage = "No octal digits after '0o'"_s;
    22922292                token = UNTERMINATED_OCTAL_NUMBER_ERRORTOK;
    … …  
    23092309            }
    23102310
    2311             if (isIdentStart(m_current)) {
     2311            if (UNLIKELY(isIdentStart(m_current))) {
    23122312                m_lexErrorMessage = "No space between octal literal and identifier"_s;
    23132313                token = UNTERMINATED_OCTAL_NUMBER_ERRORTOK;
    … …  
    23272327
    23282328        record8('0');
    2329         if (strictMode && isASCIIDigit(m_current)) {
     2329        if (UNLIKELY(strictMode && isASCIIDigit(m_current))) {
    23302330            m_lexErrorMessage = "Decimal integer literals with a leading zero are forbidden in strict mode"_s;
    23312331            token = UNTERMINATED_OCTAL_NUMBER_ERRORTOK;
    … …  
    23432343        if (LIKELY(token != INTEGER && token != DOUBLE)) {
    23442344            auto parseNumberResult = parseDecimal();
    2345             if (parseNumberResult && WTF::holds_alternative<double>(*parseNumberResult)) {
    2346                 tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
    2347                 token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
    2348             } else {
    2349                 if (parseNumberResult) {
    2350                     ASSERT(WTF::get<const Identifier*>(*parseNumberResult));
     2345            if (parseNumberResult) {
     2346                if (WTF::holds_alternative<double>(*parseNumberResult)) {
     2347                    tokenData->doubleValue = WTF::get<double>(*parseNumberResult);
     2348                    token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
     2349                } else {
    23512350                    token = BIGINT;
    23522351                    shift();
    23532352                    tokenData->bigIntString = WTF::get<const Identifier*>(*parseNumberResult);
    23542353                    tokenData->radix = 10;
    2355                 } else {
    2356                     token = INTEGER;
    2357                     if (m_current == '.') {
    2358                         shift();
    2359                         if (UNLIKELY(isASCIIDigit(m_current) && !parseNumberAfterDecimalPoint())) {
    2360                             m_lexErrorMessage = "Non-number found after decimal point"_s;
    2361                             token = INVALID_NUMERIC_LITERAL_ERRORTOK;
    2362                             goto returnError;
    2363                         }
    2364                         token = DOUBLE;
     2354                }
     2355            } else {
     2356                token = INTEGER;
     2357                if (m_current == '.') {
     2358                    shift();
     2359                    if (UNLIKELY(isASCIIDigit(m_current) && !parseNumberAfterDecimalPoint())) {
     2360                        m_lexErrorMessage = "Non-number found after decimal point"_s;
     2361                        token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
     2362                        goto returnError;
    23652363                    }
    2366                     if (isASCIIAlphaCaselessEqual(m_current, 'e')) {
    2367                         if (!parseNumberAfterExponentIndicator()) {
    2368                             m_lexErrorMessage = "Non-number found after exponent indicator"_s;
    2369                             token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
    2370                             goto returnError;
    2371                         }
    2372                     }
    2373                     size_t parsedLength;
    2374                     tokenData->doubleValue = parseDouble(m_buffer8.data(), m_buffer8.size(), parsedLength);
    2375                     if (token == INTEGER)
    2376                         token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
     2364                    token = DOUBLE;
    23772365                }
     2366                if (UNLIKELY(isASCIIAlphaCaselessEqual(m_current, 'e') && !parseNumberAfterExponentIndicator())) {
     2367                    m_lexErrorMessage = "Non-number found after exponent indicator"_s;
     2368                    token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
     2369                    goto returnError;
     2370                }
     2371                size_t parsedLength;
     2372                tokenData->doubleValue = parseDouble(m_buffer8.data(), m_buffer8.size(), parsedLength);
     2373                if (token == INTEGER)
     2374                    token = tokenTypeForIntegerLikeToken(tokenData->doubleValue);
    23782375            }
    23792376        }
Note: See TracChangeset for help on using the changeset viewer.