Ignore:
Timestamp:
Feb 15, 2013, 10:56:27 AM (12 years ago)
Author:
[email protected]
Message:

Yarr: Use OwnPtr to make pattern/disjunction/character-class ownership clearer.
<​http://webkit.org/b/109218>

Reviewed by Benjamin Poulain.

  • Let classes that manage lifetime of other objects hold on to them with OwnPtr instead of raw pointers.
  • Placed some strategic Vector::shrinkToFit(), ::reserveInitialCapacity() and ::swap().

668 kB progression on Membuster3.

  • yarr/YarrInterpreter.cpp:

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

  • yarr/YarrInterpreter.h:

(JSC::Yarr::BytecodePattern::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::copyDisjunction):
(JSC::Yarr::YarrPatternConstructor::setupDisjunctionOffsets):
(JSC::Yarr::YarrPatternConstructor::checkForTerminalParentheses):
(JSC::Yarr::YarrPatternConstructor::optimizeBOL):
(JSC::Yarr::YarrPatternConstructor::containsCapturingTerms):
(JSC::Yarr::YarrPatternConstructor::optimizeDotStarWrappedExpressions):

  • yarr/YarrPattern.h:

(JSC::Yarr::PatternDisjunction::addNewAlternative):
(PatternDisjunction):
(YarrPattern):
(JSC::Yarr::YarrPattern::reset):
(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:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/yarr/YarrPattern.cpp

    r140594 r143018  
    176176    }
    177177
    178     CharacterClass* charClass()
    179     {
    180         CharacterClass* characterClass = new CharacterClass(0);
     178    PassOwnPtr<CharacterClass> charClass()
     179    {
     180        OwnPtr<CharacterClass> characterClass = adoptPtr(new CharacterClass(0));
    181181
    182182        characterClass->m_matches.swap(m_matches);
    … …  
    185185        characterClass->m_rangesUnicode.swap(m_rangesUnicode);
    186186
    187         return characterClass;
     187        return characterClass.release();
    188188    }
    189189
    … …  
    275275        , m_invertParentheticalAssertion(false)
    276276    {
    277         m_pattern.m_body = new PatternDisjunction();
    278         m_alternative = m_pattern.m_body->addNewAlternative();
    279         m_pattern.m_disjunctions.append(m_pattern.m_body);
     277        OwnPtr<PatternDisjunction> body = adoptPtr(new PatternDisjunction);
     278        m_pattern.m_body = body.get();
     279        m_alternative = body->addNewAlternative();
     280        m_pattern.m_disjunctions.append(body.release());
    280281    }
    281282
    … …  
    289290        m_characterClassConstructor.reset();
    290291
    291         m_pattern.m_body = new PatternDisjunction();
    292         m_alternative = m_pattern.m_body->addNewAlternative();
    293         m_pattern.m_disjunctions.append(m_pattern.m_body);
     292        OwnPtr<PatternDisjunction> body = adoptPtr(new PatternDisjunction);
     293        m_pattern.m_body = body.get();
     294        m_alternative = body->addNewAlternative();
     295        m_pattern.m_disjunctions.append(body.release());
    294296    }
    295297   
    … …  
    328330
    329331        m_characterClassConstructor.putUnicodeIgnoreCase(ch, info);
    330         CharacterClass* newCharacterClass = m_characterClassConstructor.charClass();
    331         m_pattern.m_userCharacterClasses.append(newCharacterClass);
    332         m_alternative->m_terms.append(PatternTerm(newCharacterClass, false));
     332        OwnPtr<CharacterClass> newCharacterClass = m_characterClassConstructor.charClass();
     333        m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), false));
     334        m_pattern.m_userCharacterClasses.append(newCharacterClass.release());
    333335    }
    334336
    … …  
    390392    void atomCharacterClassEnd()
    391393    {
    392         CharacterClass* newCharacterClass = m_characterClassConstructor.charClass();
    393         m_pattern.m_userCharacterClasses.append(newCharacterClass);
    394         m_alternative->m_terms.append(PatternTerm(newCharacterClass, m_invertCharacterClass));
     394        OwnPtr<CharacterClass> newCharacterClass = m_characterClassConstructor.charClass();
     395        m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), m_invertCharacterClass));
     396        m_pattern.m_userCharacterClasses.append(newCharacterClass.release());
    395397    }
    396398
    … …  
    401403            m_pattern.m_numSubpatterns++;
    402404
    403         PatternDisjunction* parenthesesDisjunction = new PatternDisjunction(m_alternative);
    404         m_pattern.m_disjunctions.append(parenthesesDisjunction);
    405         m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction, capture, false));
     405        OwnPtr<PatternDisjunction> parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative));
     406        m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, false));
    406407        m_alternative = parenthesesDisjunction->addNewAlternative();
     408        m_pattern.m_disjunctions.append(parenthesesDisjunction.release());
    407409    }
    408410
    409411    void atomParentheticalAssertionBegin(bool invert = false)
    410412    {
    411         PatternDisjunction* parenthesesDisjunction = new PatternDisjunction(m_alternative);
    412         m_pattern.m_disjunctions.append(parenthesesDisjunction);
    413         m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParentheticalAssertion, m_pattern.m_numSubpatterns + 1, parenthesesDisjunction, false, invert));
     413        OwnPtr<PatternDisjunction> parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative));
     414        m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParentheticalAssertion, m_pattern.m_numSubpatterns + 1, parenthesesDisjunction.get(), false, invert));
    414415        m_alternative = parenthesesDisjunction->addNewAlternative();
    415416        m_invertParentheticalAssertion = invert;
     417        m_pattern.m_disjunctions.append(parenthesesDisjunction.release());
    416418    }
    417419
    … …  
    478480    PatternDisjunction* copyDisjunction(PatternDisjunction* disjunction, bool filterStartsWithBOL = false)
    479481    {
    480         PatternDisjunction* newDisjunction = 0;
     482        OwnPtr<PatternDisjunction> newDisjunction;
    481483        for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) {
    482             PatternAlternative* alternative = disjunction->m_alternatives[alt];
     484            PatternAlternative* alternative = disjunction->m_alternatives[alt].get();
    483485            if (!filterStartsWithBOL || !alternative->m_startsWithBOL) {
    484486                if (!newDisjunction) {
    485                     newDisjunction = new PatternDisjunction();
     487                    newDisjunction = adoptPtr(new PatternDisjunction());
    486488                    newDisjunction->m_parent = disjunction->m_parent;
    487489                }
    488490                PatternAlternative* newAlternative = newDisjunction->addNewAlternative();
     491                newAlternative->m_terms.reserveInitialCapacity(alternative->m_terms.size());
    489492                for (unsigned i = 0; i < alternative->m_terms.size(); ++i)
    490493                    newAlternative->m_terms.append(copyTerm(alternative->m_terms[i], filterStartsWithBOL));
    … …  
    492495        }
    493496       
    494         if (newDisjunction)
    495             m_pattern.m_disjunctions.append(newDisjunction);
    496         return newDisjunction;
     497        if (!newDisjunction)
     498            return 0;
     499
     500        PatternDisjunction* copiedDisjunction = newDisjunction.get();
     501        m_pattern.m_disjunctions.append(newDisjunction.release());
     502        return copiedDisjunction;
    497503    }
    498504   
    … …  
    656662
    657663        for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) {
    658             PatternAlternative* alternative = disjunction->m_alternatives[alt];
     664            PatternAlternative* alternative = disjunction->m_alternatives[alt].get();
    659665            unsigned currentAlternativeCallFrameSize = setupAlternativeOffsets(alternative, initialCallFrameSize, initialInputPosition);
    660666            minimumInputSize = std::min(minimumInputSize, alternative->m_minimumSize);
    … …  
    691697            return;
    692698
    693         Vector<PatternAlternative*>& alternatives = m_pattern.m_body->m_alternatives;
     699        Vector<OwnPtr<PatternAlternative> >& alternatives = m_pattern.m_body->m_alternatives;
    694700        for (size_t i = 0; i < alternatives.size(); ++i) {
    695701            Vector<PatternTerm>& terms = alternatives[i]->m_terms;
    … …  
    726732            // Move alternatives from loopDisjunction to disjunction
    727733            for (unsigned alt = 0; alt < loopDisjunction->m_alternatives.size(); ++alt)
    728                 disjunction->m_alternatives.append(loopDisjunction->m_alternatives[alt]);
     734                disjunction->m_alternatives.append(loopDisjunction->m_alternatives[alt].release());
    729735               
    730736            loopDisjunction->m_alternatives.clear();
    … …  
    745751                PatternDisjunction* nestedDisjunction = term.parentheses.disjunction;
    746752                for (unsigned alt = 0; alt < nestedDisjunction->m_alternatives.size(); ++alt) {
    747                     if (containsCapturingTerms(nestedDisjunction->m_alternatives[alt], 0, nestedDisjunction->m_alternatives[alt]->m_terms.size() - 1))
     753                    if (containsCapturingTerms(nestedDisjunction->m_alternatives[alt].get(), 0, nestedDisjunction->m_alternatives[alt]->m_terms.size() - 1))
    748754                        return true;
    749755                }
    … …  
    761767    void optimizeDotStarWrappedExpressions()
    762768    {
    763         Vector<PatternAlternative*>& alternatives = m_pattern.m_body->m_alternatives;
     769        Vector<OwnPtr<PatternAlternative> >& alternatives = m_pattern.m_body->m_alternatives;
    764770        if (alternatives.size() != 1)
    765771            return;
    766772
    767         PatternAlternative* alternative = alternatives[0];
     773        PatternAlternative* alternative = alternatives[0].get();
    768774        Vector<PatternTerm>& terms = alternative->m_terms;
    769775        if (terms.size() >= 3) {
Note: See TracChangeset for help on using the changeset viewer.