Changeset 177820 in webkit for trunk/Source/JavaScriptCore/yarr/YarrPattern.cpp

Timestamp:

Dec 29, 2014, 6:59:25 PM (10 years ago)

Author:

[email protected]

Message:

Move JavaScriptCore/yarr to std::unique_ptr
​https://bugs.webkit.org/show_bug.cgi?id=139621

Reviewed by Anders Carlsson.

Final clean up OwnPtr|PassOwnPtr in JavaScriptCore/yarr.

• yarr/YarrInterpreter.cpp:

(JSC::Yarr::ByteCompiler::atomParenthesesSubpatternEnd):

• yarr/YarrInterpreter.h:

(JSC::Yarr::BytecodePattern::BytecodePattern):

• yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::opCompileParenthesesSubpattern):
(JSC::Yarr::YarrGenerator::opCompileParentheticalAssertion):
(JSC::Yarr::YarrGenerator::opCompileBody):

• yarr/YarrPattern.cpp:

(JSC::Yarr::CharacterClassConstructor::charClass):
(JSC::Yarr::YarrPatternConstructor::YarrPatternConstructor):
(JSC::Yarr::YarrPatternConstructor::reset):
(JSC::Yarr::YarrPatternConstructor::atomPatternCharacter):
(JSC::Yarr::YarrPatternConstructor::atomCharacterClassEnd):
(JSC::Yarr::YarrPatternConstructor::atomParenthesesSubpatternBegin):
(JSC::Yarr::YarrPatternConstructor::atomParentheticalAssertionBegin):
(JSC::Yarr::YarrPatternConstructor::copyDisjunction):
(JSC::Yarr::YarrPatternConstructor::checkForTerminalParentheses):
(JSC::Yarr::YarrPatternConstructor::optimizeDotStarWrappedExpressions):

• yarr/YarrPattern.h:

(JSC::Yarr::PatternDisjunction::addNewAlternative):
(JSC::Yarr::YarrPattern::newlineCharacterClass):
(JSC::Yarr::YarrPattern::digitsCharacterClass):
(JSC::Yarr::YarrPattern::spacesCharacterClass):
(JSC::Yarr::YarrPattern::wordcharCharacterClass):
(JSC::Yarr::YarrPattern::nondigitsCharacterClass):
(JSC::Yarr::YarrPattern::nonspacesCharacterClass):
(JSC::Yarr::YarrPattern::nonwordcharCharacterClass):

File:

• trunk/Source/JavaScriptCore/yarr/YarrPattern.cpp (modified) (11 diffs)

trunk/Source/JavaScriptCore/yarr/YarrPattern.cpp

@@ -176 +176 @@
     }
 
-    PassOwnPtr<CharacterClass> charClass()
-    {
-        OwnPtr<CharacterClass> characterClass = adoptPtr(new CharacterClass);
+    std::unique_ptr<CharacterClass> charClass()
+    {
+        auto characterClass = std::make_unique<CharacterClass>();
 
         characterClass->m_matches.swap(m_matches);
@@ -185 +185 @@
         characterClass->m_rangesUnicode.swap(m_rangesUnicode);
 
-        return characterClass.release();
+        return characterClass;
     }
 
@@ -275 +275 @@
         , m_invertParentheticalAssertion(false)
     {
-        OwnPtr<PatternDisjunction> body = adoptPtr(new PatternDisjunction);
+        auto body = std::make_unique<PatternDisjunction>();
         m_pattern.m_body = body.get();
         m_alternative = body->addNewAlternative();
-        m_pattern.m_disjunctions.append(body.release());
+        m_pattern.m_disjunctions.append(WTF::move(body));
     }
 
@@ -290 +290 @@
         m_characterClassConstructor.reset();
 
-        OwnPtr<PatternDisjunction> body = adoptPtr(new PatternDisjunction);
+        auto body = std::make_unique<PatternDisjunction>();
         m_pattern.m_body = body.get();
         m_alternative = body->addNewAlternative();
-        m_pattern.m_disjunctions.append(body.release());
+        m_pattern.m_disjunctions.append(WTF::move(body));
     }
     
@@ -330 +330 @@
 
         m_characterClassConstructor.putUnicodeIgnoreCase(ch, info);
-        OwnPtr<CharacterClass> newCharacterClass = m_characterClassConstructor.charClass();
+        auto newCharacterClass = m_characterClassConstructor.charClass();
         m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), false));
-        m_pattern.m_userCharacterClasses.append(newCharacterClass.release());
+        m_pattern.m_userCharacterClasses.append(WTF::move(newCharacterClass));
     }
 
@@ -392 +392 @@
     void atomCharacterClassEnd()
     {
-        OwnPtr<CharacterClass> newCharacterClass = m_characterClassConstructor.charClass();
+        auto newCharacterClass = m_characterClassConstructor.charClass();
         m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), m_invertCharacterClass));
-        m_pattern.m_userCharacterClasses.append(newCharacterClass.release());
+        m_pattern.m_userCharacterClasses.append(WTF::move(newCharacterClass));
     }
 
@@ -403 +403 @@
             m_pattern.m_numSubpatterns++;
 
-        OwnPtr<PatternDisjunction> parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative));
+        auto parenthesesDisjunction = std::make_unique<PatternDisjunction>(m_alternative);
         m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, false));
         m_alternative = parenthesesDisjunction->addNewAlternative();
-        m_pattern.m_disjunctions.append(parenthesesDisjunction.release());
+        m_pattern.m_disjunctions.append(WTF::move(parenthesesDisjunction));
     }
 
     void atomParentheticalAssertionBegin(bool invert = false)
     {
-        OwnPtr<PatternDisjunction> parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative));
+        auto parenthesesDisjunction = std::make_unique<PatternDisjunction>(m_alternative);
         m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParentheticalAssertion, m_pattern.m_numSubpatterns + 1, parenthesesDisjunction.get(), false, invert));
         m_alternative = parenthesesDisjunction->addNewAlternative();
         m_invertParentheticalAssertion = invert;
-        m_pattern.m_disjunctions.append(parenthesesDisjunction.release());
+        m_pattern.m_disjunctions.append(WTF::move(parenthesesDisjunction));
     }
 
@@ -480 +480 @@
     PatternDisjunction* copyDisjunction(PatternDisjunction* disjunction, bool filterStartsWithBOL = false)
     {
-        OwnPtr<PatternDisjunction> newDisjunction;
+        std::unique_ptr<PatternDisjunction> newDisjunction;
         for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) {
             PatternAlternative* alternative = disjunction->m_alternatives[alt].get();
             if (!filterStartsWithBOL || !alternative->m_startsWithBOL) {
                 if (!newDisjunction) {
-                    newDisjunction = adoptPtr(new PatternDisjunction());
+                    newDisjunction = std::make_unique<PatternDisjunction>();
                     newDisjunction->m_parent = disjunction->m_parent;
                 }
@@ -499 +499 @@
 
         PatternDisjunction* copiedDisjunction = newDisjunction.get();
-        m_pattern.m_disjunctions.append(newDisjunction.release());
+        m_pattern.m_disjunctions.append(WTF::move(newDisjunction));
         return copiedDisjunction;
     }
@@ -699 +699 @@
             return;
 
-        Vector<OwnPtr<PatternAlternative>>& alternatives = m_pattern.m_body->m_alternatives;
+        Vector<std::unique_ptr<PatternAlternative>>& alternatives = m_pattern.m_body->m_alternatives;
         for (size_t i = 0; i < alternatives.size(); ++i) {
             Vector<PatternTerm>& terms = alternatives[i]->m_terms;
@@ -769 +769 @@
     void optimizeDotStarWrappedExpressions()
     {
-        Vector<OwnPtr<PatternAlternative>>& alternatives = m_pattern.m_body->m_alternatives;
+        Vector<std::unique_ptr<PatternAlternative>>& alternatives = m_pattern.m_body->m_alternatives;
         if (alternatives.size() != 1)
             return;