Changeset 173120 in webkit for trunk/Source/JavaScriptCore/parser

Timestamp:

Aug 29, 2014, 2:33:30 PM (11 years ago)

Author:

[email protected]

Message:

JavaScriptCore: Use ASCIILiteral where possible
​https://bugs.webkit.org/show_bug.cgi?id=136179

Patch by Joseph Pecoraro <Joseph Pecoraro> on 2014-08-29
Reviewed by Michael Saboff.

Source/JavaScriptCore:

General string / character related changes. Use ASCIILiteral where
possible, jsNontrivialString where possible, and replace string
literals with character literals in some places.

No new tests, no changes to functionality.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::nameForRegister):

• bytecompiler/NodesCodegen.cpp:

(JSC::PostfixNode::emitBytecode):
(JSC::PrefixNode::emitBytecode):
(JSC::AssignErrorNode::emitBytecode):
(JSC::ForInNode::emitMultiLoopBytecode):
(JSC::ForOfNode::emitBytecode):
(JSC::ObjectPatternNode::toString):

• dfg/DFGFunctionWhitelist.cpp:

(JSC::DFG::FunctionWhitelist::contains):

• dfg/DFGOperations.cpp:

(JSC::DFG::newTypedArrayWithSize):
(JSC::DFG::newTypedArrayWithOneArgument):

• inspector/ConsoleMessage.cpp:

(Inspector::ConsoleMessage::addToFrontend):

• inspector/InspectorBackendDispatcher.cpp:

(Inspector::InspectorBackendDispatcher::dispatch):

• inspector/ScriptCallStackFactory.cpp:

(Inspector::extractSourceInformationFromException):

• inspector/scripts/codegen/generator_templates.py:
• interpreter/StackVisitor.cpp:

(JSC::StackVisitor::Frame::functionName):
(JSC::StackVisitor::Frame::sourceURL):

• jit/JITOperations.cpp:
• jsc.cpp:

(functionDescribeArray):
(functionRun):
(functionLoad):
(functionReadFile):
(functionCheckSyntax):
(functionTransferArrayBuffer):
(runWithScripts):
(runInteractive):

• parser/Lexer.cpp:

(JSC::Lexer<T>::invalidCharacterMessage):
(JSC::Lexer<T>::parseString):
(JSC::Lexer<T>::parseStringSlowCase):
(JSC::Lexer<T>::lex):

• profiler/Profile.cpp:

(JSC::Profile::Profile):

• runtime/Arguments.cpp:

(JSC::argumentsFuncIterator):

• runtime/ArrayPrototype.cpp:

(JSC::performSlowSort):
(JSC::arrayProtoFuncSort):

• runtime/ExceptionHelpers.cpp:

(JSC::createError):
(JSC::createInvalidParameterError):
(JSC::createNotAConstructorError):
(JSC::createNotAFunctionError):
(JSC::createNotAnObjectError):
(JSC::createErrorForInvalidGlobalAssignment):

• runtime/FunctionPrototype.cpp:

(JSC::insertSemicolonIfNeeded):

• runtime/JSArray.cpp:

(JSC::JSArray::defineOwnProperty):
(JSC::JSArray::pop):
(JSC::JSArray::push):

• runtime/JSArrayBufferConstructor.cpp:

(JSC::JSArrayBufferConstructor::finishCreation):

• runtime/JSArrayBufferPrototype.cpp:

(JSC::arrayBufferProtoFuncSlice):

• runtime/JSDataView.cpp:

(JSC::JSDataView::create):

• runtime/JSDataViewPrototype.cpp:

(JSC::getData):
(JSC::setData):

• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::reset):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncProtoSetter):

• runtime/JSPromiseConstructor.cpp:

(JSC::JSPromiseConstructor::finishCreation):

• runtime/LiteralParser.cpp:

(JSC::LiteralParser<CharType>::Lexer::lex):
(JSC::LiteralParser<CharType>::Lexer::lexString):
(JSC::LiteralParser<CharType>::parse):

• runtime/LiteralParser.h:

(JSC::LiteralParser::getErrorMessage):

• runtime/TypeSet.cpp:

(JSC::TypeSet::seenTypes):
(JSC::TypeSet::displayName):
(JSC::TypeSet::allPrimitiveTypeNames):
(JSC::StructureShape::propertyHash):
(JSC::StructureShape::stringRepresentation):

Source/WTF:

• wtf/text/WTFString.cpp:

(asciiDebug):

File:

• trunk/Source/JavaScriptCore/parser/Lexer.cpp (modified) (14 diffs)

trunk/Source/JavaScriptCore/parser/Lexer.cpp

@@ -507 +507 @@
     switch (m_current) {
     case 0:
-        return "Invalid character: '\\0'";
+        return ASCIILiteral("Invalid character: '\\0'");
     case 10:
-        return "Invalid character: '\\n'";
+        return ASCIILiteral("Invalid character: '\\n'");
     case 11:
-        return "Invalid character: '\\v'";
+        return ASCIILiteral("Invalid character: '\\v'");
     case 13:
-        return "Invalid character: '\\r'";
+        return ASCIILiteral("Invalid character: '\\r'");
     case 35:
-        return "Invalid character: '#'";
+        return ASCIILiteral("Invalid character: '#'");
     case 64:
-        return "Invalid character: '@'";
+        return ASCIILiteral("Invalid character: '@'");
     case 96:
-        return "Invalid character: '`'";
+        return ASCIILiteral("Invalid character: '`'");
     default:
-        return String::format("Invalid character '\\u%04u'", static_cast<unsigned>(m_current)).impl();
+        return String::format("Invalid character '\\u%04u'", static_cast<unsigned>(m_current));
     }
 }
@@ -1027 +1027 @@
                 shift();
                 if (!isASCIIHexDigit(m_current) || !isASCIIHexDigit(peek(1))) {
-                    m_lexErrorMessage = "\\x can only be followed by a hex character sequence";
+                    m_lexErrorMessage = ASCIILiteral("\\x can only be followed by a hex character sequence");
                     return (atEnd() || (isASCIIHexDigit(m_current) && (m_code + 1 == m_codeEnd))) ? StringUnterminated : StringCannotBeParsed;
                 }
@@ -1092 +1092 @@
                 shift();
                 if (!isASCIIHexDigit(m_current) || !isASCIIHexDigit(peek(1))) {
-                    m_lexErrorMessage = "\\x can only be followed by a hex character sequence";
+                    m_lexErrorMessage = ASCIILiteral("\\x can only be followed by a hex character sequence");
                     return StringCannotBeParsed;
                 }
@@ -1110 +1110 @@
                         record16('u');
                 } else {
-                    m_lexErrorMessage = "\\u can only be followed by a Unicode character sequence";
+                    m_lexErrorMessage = ASCIILiteral("\\u can only be followed by a Unicode character sequence");
                     return character.valueType() == UnicodeHexValue::IncompleteHex ? StringUnterminated : StringCannotBeParsed;
                 }
@@ -1118 +1118 @@
                 shift();
                 if (character1 != '0' || isASCIIDigit(m_current)) {
-                    m_lexErrorMessage = "The only valid numeric escape in strict mode is '\\0'";
+                    m_lexErrorMessage = ASCIILiteral("The only valid numeric escape in strict mode is '\\0'");
                     return StringCannotBeParsed;
                 }
@@ -1148 +1148 @@
                 shift();
             } else {
-                m_lexErrorMessage = "Unterminated string constant";
+                m_lexErrorMessage = ASCIILiteral("Unterminated string constant");
                 return StringUnterminated;
             }
@@ -1161 +1161 @@
             // New-line or end of input is not allowed
             if (atEnd() || isLineTerminator(m_current)) {
-                m_lexErrorMessage = "Unexpected EOF";
+                m_lexErrorMessage = ASCIILiteral("Unexpected EOF");
                 return atEnd() ? StringUnterminated : StringCannotBeParsed;
             }
@@ -1523 +1523 @@
             if (parseMultilineComment())
                 goto start;
-            m_lexErrorMessage = "Multiline comment was not closed properly";
+            m_lexErrorMessage = ASCIILiteral("Multiline comment was not closed properly");
             token = UNTERMINATED_MULTILINE_COMMENT_ERRORTOK;
             goto returnError;
@@ -1649 +1649 @@
         if ((m_current | 0x20) == 'x') {
             if (!isASCIIHexDigit(peek(1))) {
-                m_lexErrorMessage = "No hexadecimal digits after '0x'";
+                m_lexErrorMessage = ASCIILiteral("No hexadecimal digits after '0x'");
                 token = INVALID_HEX_NUMBER_ERRORTOK;
                 goto returnError;
@@ -1655 +1655 @@
             parseHex(tokenData->doubleValue);
             if (isIdentStart(m_current)) {
-                m_lexErrorMessage = "No space between hexadecimal literal and identifier";
+                m_lexErrorMessage = ASCIILiteral("No space between hexadecimal literal and identifier");
                 token = INVALID_HEX_NUMBER_ERRORTOK;
                 goto returnError;
@@ -1666 +1666 @@
         record8('0');
         if (strictMode && isASCIIDigit(m_current)) {
-            m_lexErrorMessage = "Decimal integer literals with a leading zero are forbidden in strict mode";
+            m_lexErrorMessage = ASCIILiteral("Decimal integer literals with a leading zero are forbidden in strict mode");
             token = INVALID_OCTAL_NUMBER_ERRORTOK;
             goto returnError;
@@ -1686 +1686 @@
                 if ((m_current | 0x20) == 'e') {
                     if (!parseNumberAfterExponentIndicator()) {
-                        m_lexErrorMessage = "Non-number found after exponent indicator";
+                        m_lexErrorMessage = ASCIILiteral("Non-number found after exponent indicator");
                         token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
                         goto returnError;
@@ -1699 +1699 @@
         // No identifiers allowed directly after numeric literal, e.g. "3in" is bad.
         if (UNLIKELY(isIdentStart(m_current))) {
-            m_lexErrorMessage = "At least one digit must occur after a decimal point";
+            m_lexErrorMessage = ASCIILiteral("At least one digit must occur after a decimal point");
             token = atEnd() ? UNTERMINATED_NUMERIC_LITERAL_ERRORTOK : INVALID_NUMERIC_LITERAL_ERRORTOK;
             goto returnError;
@@ -1750 +1750 @@
     default:
         RELEASE_ASSERT_NOT_REACHED();
-        m_lexErrorMessage = "Internal Error";
+        m_lexErrorMessage = ASCIILiteral("Internal Error");
         token = ERRORTOK;
         goto returnError;