Unify regular expression notation as RegExp

clover2123 · bbrto21 · commit a96f39f0e679 · 2020-08-24T14:04:52.000+09:00
Signed-off-by: HyukWoo Park &lt;hyukwoo.park@samsung.com&gt;
diff --git a/src/codecache/CodeCacheReaderWriter.cpp b/src/codecache/CodeCacheReaderWriter.cpp
@@ -433,8 +433,8 @@ void CodeCacheWriter::storeByteCodeStream(ByteCodeBlock* block)
                 STORE_ATOMICSTRING_RELOC(m_propertyName);
                 break;
             }
-            case LoadRegexpOpcode: {
-                LoadRegexp* bc = (LoadRegexp*)currentCode;
+            case LoadRegExpOpcode: {
+                LoadRegExp* bc = (LoadRegExp*)currentCode;
 
                 String* bodyString = bc->m_body;
                 String* optionString = bc->m_option;
@@ -785,8 +785,8 @@ void CodeCacheReader::loadByteCodeStream(Context* context, ByteCodeBlock* block)
 
         InterpretedCodeBlock* codeBlock = block->codeBlock();
 
-        // mark for LoadRegexp bytecode
-        bool bodyStringForLoadRegexp = true;
+        // mark for LoadRegExp bytecode
+        bool bodyStringForLoadRegExp = true;
 
         for (size_t i = 0; i < relocInfoVector.size(); i++) {
             ByteCodeRelocInfo& info = relocInfoVector[i];
@@ -890,20 +890,20 @@ void CodeCacheReader::loadByteCodeStream(Context* context, ByteCodeBlock* block)
                 LOAD_ATOMICSTRING_RELOC(m_propertyName);
                 break;
             }
-            case LoadRegexpOpcode: {
-                LoadRegexp* bc = (LoadRegexp*)currentCode;
+            case LoadRegExpOpcode: {
+                LoadRegExp* bc = (LoadRegExp*)currentCode;
 
                 String* bodyString = bc->m_body;
                 String* optionString = bc->m_option;
 
-                if (bodyStringForLoadRegexp) {
+                if (bodyStringForLoadRegExp) {
                     ASSERT(info.dataOffset < stringLiteralData.size());
                     bc->m_body = stringLiteralData[info.dataOffset];
-                    bodyStringForLoadRegexp = false;
+                    bodyStringForLoadRegExp = false;
                 } else {
                     ASSERT(info.dataOffset < stringLiteralData.size());
                     bc->m_option = stringLiteralData[info.dataOffset];
-                    bodyStringForLoadRegexp = true;
+                    bodyStringForLoadRegExp = true;
                 }
                 break;
             }
diff --git a/src/interpreter/ByteCode.h b/src/interpreter/ByteCode.h
@@ -118,7 +118,7 @@ struct GlobalVariableAccessCacheItem;
     F(MarkEnumerateKey, 2, 0)                               \
     F(IteratorOperation, 0, 0)                              \
     F(GetMethod, 0, 0)                                      \
-    F(LoadRegexp, 1, 0)                                     \
+    F(LoadRegExp, 1, 0)                                     \
     F(WithOperation, 0, 0)                                  \
     F(ObjectDefineGetterSetter, 0, 0)                       \
     F(CallFunctionComplexCase, 0, 0)                        \
@@ -2231,10 +2231,10 @@ class GetMethod : public ByteCode {
 #endif
 };
 
-class LoadRegexp : public ByteCode {
+class LoadRegExp : public ByteCode {
 public:
-    LoadRegexp(const ByteCodeLOC& loc, const size_t registerIndex, String* body, String* opt)
-        : ByteCode(Opcode::LoadRegexpOpcode, loc)
+    LoadRegExp(const ByteCodeLOC& loc, const size_t registerIndex, String* body, String* opt)
+        : ByteCode(Opcode::LoadRegExpOpcode, loc)
         , m_registerIndex(registerIndex)
         , m_body(body)
         , m_option(opt)
diff --git a/src/interpreter/ByteCodeGenerator.cpp b/src/interpreter/ByteCodeGenerator.cpp
@@ -342,8 +342,8 @@ void ByteCodeGenerator::relocateByteCode(ByteCodeBlock* block)
             ASSIGN_STACKINDEX_IF_NEEDED(cd->m_registerIndex, stackBase, stackBaseWillBe, stackVariableSize);
             break;
         }
-        case LoadRegexpOpcode: {
-            LoadRegexp* cd = (LoadRegexp*)currentCode;
+        case LoadRegExpOpcode: {
+            LoadRegExp* cd = (LoadRegExp*)currentCode;
             ASSIGN_STACKINDEX_IF_NEEDED(cd->m_registerIndex, stackBase, stackBaseWillBe, stackVariableSize);
             break;
         }
diff --git a/src/interpreter/ByteCodeInterpreter.cpp b/src/interpreter/ByteCodeInterpreter.cpp
@@ -1148,12 +1148,12 @@ Value ByteCodeInterpreter::interpret(ExecutionState* state, ByteCodeBlock* byteC
             NEXT_INSTRUCTION();
         }
 
-        DEFINE_OPCODE(LoadRegexp)
+        DEFINE_OPCODE(LoadRegExp)
             :
         {
-            LoadRegexp* code = (LoadRegexp*)programCounter;
+            LoadRegExp* code = (LoadRegExp*)programCounter;
             registerFile[code->m_registerIndex] = new RegExpObject(*state, code->m_body, code->m_option);
-            ADD_PROGRAM_COUNTER(LoadRegexp);
+            ADD_PROGRAM_COUNTER(LoadRegExp);
             NEXT_INSTRUCTION();
         }
 
diff --git a/src/parser/Lexer.cpp b/src/parser/Lexer.cpp
@@ -1721,7 +1721,7 @@ void Scanner::scanRegExp(Scanner::ScannerResult* token)
     result.body = body;
     result.flags = flags;
     token->setResult(Token::RegularExpressionToken, this->lineNumber, this->lineStart, start, this->index);
-    token->valueRegexp = result;
+    token->valueRegExp = result;
 }
 
 // ECMA-262 11.6.2.1 Keywords
diff --git a/src/parser/Lexer.h b/src/parser/Lexer.h
@@ -260,7 +260,7 @@ class Scanner {
             , lineStart(0)
             , start(0)
             , end(0)
-            , valueRegexp()
+            , valueRegExp()
         {
         }
 
@@ -286,7 +286,7 @@ class Scanner {
             ScannerSourceStringView valueStringLiteralData;
             double valueNumber;
             ScanTemplateResult* valueTemplate;
-            ScanRegExpResult valueRegexp;
+            ScanRegExpResult valueRegExp;
             KeywordKind valueKeywordKind;
         };
 
diff --git a/src/parser/ast/RegExpLiteralNode.h b/src/parser/ast/RegExpLiteralNode.h
@@ -41,7 +41,7 @@ class RegExpLiteralNode : public Node {
     {
         codeBlock->m_stringLiteralData.pushBack(m_body);
         codeBlock->m_stringLiteralData.pushBack(m_flag);
-        codeBlock->pushCode(LoadRegexp(ByteCodeLOC(m_loc.index), dstRegister, m_body, m_flag), context, this);
+        codeBlock->pushCode(LoadRegExp(ByteCodeLOC(m_loc.index), dstRegister, m_body, m_flag), context, this);
     }
 
 private:
diff --git a/src/parser/esprima_cpp/esprima.cpp b/src/parser/esprima_cpp/esprima.cpp
@@ -1097,7 +1097,7 @@ class Parser {
                 ALLOC_TOKEN(token);
                 this->nextRegexToken(token);
                 // raw = this->getTokenRaw(token);
-                return this->finalize(node, builder.createRegExpLiteralNode(token->valueRegexp.body, token->valueRegexp.flags));
+                return this->finalize(node, builder.createRegExpLiteralNode(token->valueRegExp.body, token->valueRegExp.flags));
             }
             default: {
                 ALLOC_TOKEN(token);
diff --git a/src/runtime/Object.cpp b/src/runtime/Object.cpp
@@ -93,7 +93,7 @@ ObjectRareData::ObjectRareData(Object* obj)
     m_isArrayObjectLengthWritable = true;
     m_isSpreadArrayObject = false;
     m_shouldUpdateEnumerateObject = false;
-    m_hasNonWritableLastIndexRegexpObject = false;
+    m_hasNonWritableLastIndexRegExpObject = false;
     m_arrayObjectFastModeBufferExpandCount = 0;
     m_extraData = nullptr;
     m_internalSlot = nullptr;
diff --git a/src/runtime/Object.h b/src/runtime/Object.h
@@ -49,7 +49,7 @@ struct ObjectRareData : public PointerValue {
     bool m_isArrayObjectLengthWritable : 1;
     bool m_isSpreadArrayObject : 1;
     bool m_shouldUpdateEnumerateObject : 1; // used only for Array Object when ArrayObject::deleteOwnProperty called
-    bool m_hasNonWritableLastIndexRegexpObject : 1;
+    bool m_hasNonWritableLastIndexRegExpObject : 1;
     uint8_t m_arrayObjectFastModeBufferExpandCount : 8;
     void* m_extraData;
     Object* m_prototype;
diff --git a/src/runtime/RegExpObject.cpp b/src/runtime/RegExpObject.cpp
@@ -195,7 +195,7 @@ void RegExpObject::initWithOption(ExecutionState& state, String* source, Option
 
 void RegExpObject::setLastIndex(ExecutionState& state, const Value& v)
 {
-    if (UNLIKELY(hasRareData() && rareData()->m_hasNonWritableLastIndexRegexpObject && (m_option & (Option::Sticky | Option::Global)))) {
+    if (UNLIKELY(hasRareData() && rareData()->m_hasNonWritableLastIndexRegExpObject && (m_option & (Option::Sticky | Option::Global)))) {
         Object::throwCannotWriteError(state, ObjectStructurePropertyName(state.context()->staticStrings().lastIndex));
     }
     m_lastIndex = v;
@@ -206,9 +206,9 @@ bool RegExpObject::defineOwnProperty(ExecutionState& state, const ObjectProperty
     bool returnValue = Object::defineOwnProperty(state, P, desc);
     if (!P.isUIntType() && returnValue && P.objectStructurePropertyName() == ObjectStructurePropertyName(state.context()->staticStrings().lastIndex)) {
         if (!structure()->readProperty((size_t)ESCARGOT_OBJECT_BUILTIN_PROPERTY_NUMBER).m_descriptor.isWritable()) {
-            ensureRareData()->m_hasNonWritableLastIndexRegexpObject = true;
+            ensureRareData()->m_hasNonWritableLastIndexRegExpObject = true;
         } else {
-            ensureRareData()->m_hasNonWritableLastIndexRegexpObject = false;
+            ensureRareData()->m_hasNonWritableLastIndexRegExpObject = false;
         }
     }
     return returnValue;

Original file line number	Diff line number	Diff line change
`@@ -342,8 +342,8 @@ void ByteCodeGenerator::relocateByteCode(ByteCodeBlock* block)`
`342`	`342`	`ASSIGN_STACKINDEX_IF_NEEDED(cd->m_registerIndex, stackBase, stackBaseWillBe, stackVariableSize);`
`343`	`343`	`break;`
`344`	`344`	`}`
`345`		`- case LoadRegexpOpcode: {`
`346`		`- LoadRegexp* cd = (LoadRegexp*)currentCode;`
	`345`	`+ case LoadRegExpOpcode: {`
	`346`	`+ LoadRegExp* cd = (LoadRegExp*)currentCode;`
`347`	`347`	`ASSIGN_STACKINDEX_IF_NEEDED(cd->m_registerIndex, stackBase, stackBaseWillBe, stackVariableSize);`
`348`	`348`	`break;`
`349`	`349`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1148,12 +1148,12 @@ Value ByteCodeInterpreter::interpret(ExecutionState* state, ByteCodeBlock* byteC`
`1148`	`1148`	`NEXT_INSTRUCTION();`
`1149`	`1149`	`}`
`1150`	`1150`
`1151`		`- DEFINE_OPCODE(LoadRegexp)`
	`1151`	`+ DEFINE_OPCODE(LoadRegExp)`
`1152`	`1152`	`:`
`1153`	`1153`	`{`
`1154`		`- LoadRegexp* code = (LoadRegexp*)programCounter;`
	`1154`	`+ LoadRegExp* code = (LoadRegExp*)programCounter;`
`1155`	`1155`	`registerFile[code->m_registerIndex] = new RegExpObject(*state, code->m_body, code->m_option);`
`1156`		`- ADD_PROGRAM_COUNTER(LoadRegexp);`
	`1156`	`+ ADD_PROGRAM_COUNTER(LoadRegExp);`
`1157`	`1157`	`NEXT_INSTRUCTION();`
`1158`	`1158`	`}`
`1159`	`1159`
Original file line number	Diff line number	Diff line change
`@@ -1721,7 +1721,7 @@ void Scanner::scanRegExp(Scanner::ScannerResult* token)`
`1721`	`1721`	`result.body = body;`
`1722`	`1722`	`result.flags = flags;`
`1723`	`1723`	`token->setResult(Token::RegularExpressionToken, this->lineNumber, this->lineStart, start, this->index);`
`1724`		`- token->valueRegexp = result;`
	`1724`	`+ token->valueRegExp = result;`
`1725`	`1725`	`}`
`1726`	`1726`
`1727`	`1727`	`// ECMA-262 11.6.2.1 Keywords`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ class RegExpLiteralNode : public Node {`
`41`	`41`	`{`
`42`	`42`	`codeBlock->m_stringLiteralData.pushBack(m_body);`
`43`	`43`	`codeBlock->m_stringLiteralData.pushBack(m_flag);`
`44`		`- codeBlock->pushCode(LoadRegexp(ByteCodeLOC(m_loc.index), dstRegister, m_body, m_flag), context, this);`
	`44`	`+ codeBlock->pushCode(LoadRegExp(ByteCodeLOC(m_loc.index), dstRegister, m_body, m_flag), context, this);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -1097,7 +1097,7 @@ class Parser {`
`1097`	`1097`	`ALLOC_TOKEN(token);`
`1098`	`1098`	`this->nextRegexToken(token);`
`1099`	`1099`	`// raw = this->getTokenRaw(token);`
`1100`		`- return this->finalize(node, builder.createRegExpLiteralNode(token->valueRegexp.body, token->valueRegexp.flags));`
	`1100`	`+ return this->finalize(node, builder.createRegExpLiteralNode(token->valueRegExp.body, token->valueRegExp.flags));`
`1101`	`1101`	`}`
`1102`	`1102`	`default: {`
`1103`	`1103`	`ALLOC_TOKEN(token);`