Changeset 143018 in webkit


Ignore:
Timestamp:
Feb 15, 2013 10:56:27 AM (11 years ago)
Author:
akling@apple.com
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):

Location:
trunk/Source/JavaScriptCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r142970 r143018  
     12013-02-15  Andreas Kling  <akling@apple.com>
     2
     3        Yarr: Use OwnPtr to make pattern/disjunction/character-class ownership clearer.
     4        <http://webkit.org/b/109218>
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        - Let classes that manage lifetime of other objects hold on to them with OwnPtr instead of raw pointers.
     9        - Placed some strategic Vector::shrinkToFit(), ::reserveInitialCapacity() and ::swap().
     10
     11        668 kB progression on Membuster3.
     12
     13        * yarr/YarrInterpreter.cpp:
     14        (JSC::Yarr::ByteCompiler::atomParenthesesSubpatternEnd):
     15        (JSC::Yarr::ByteCompiler::emitDisjunction):
     16        (ByteCompiler):
     17        * yarr/YarrInterpreter.h:
     18        (JSC::Yarr::BytecodePattern::BytecodePattern):
     19        (BytecodePattern):
     20        * yarr/YarrJIT.cpp:
     21        (JSC::Yarr::YarrGenerator::opCompileParenthesesSubpattern):
     22        (JSC::Yarr::YarrGenerator::opCompileParentheticalAssertion):
     23        (JSC::Yarr::YarrGenerator::opCompileBody):
     24        * yarr/YarrPattern.cpp:
     25        (JSC::Yarr::CharacterClassConstructor::charClass):
     26        (JSC::Yarr::YarrPatternConstructor::YarrPatternConstructor):
     27        (JSC::Yarr::YarrPatternConstructor::reset):
     28        (JSC::Yarr::YarrPatternConstructor::atomPatternCharacter):
     29        (JSC::Yarr::YarrPatternConstructor::atomCharacterClassEnd):
     30        (JSC::Yarr::YarrPatternConstructor::copyDisjunction):
     31        (JSC::Yarr::YarrPatternConstructor::setupDisjunctionOffsets):
     32        (JSC::Yarr::YarrPatternConstructor::checkForTerminalParentheses):
     33        (JSC::Yarr::YarrPatternConstructor::optimizeBOL):
     34        (JSC::Yarr::YarrPatternConstructor::containsCapturingTerms):
     35        (JSC::Yarr::YarrPatternConstructor::optimizeDotStarWrappedExpressions):
     36        * yarr/YarrPattern.h:
     37        (JSC::Yarr::PatternDisjunction::addNewAlternative):
     38        (PatternDisjunction):
     39        (YarrPattern):
     40        (JSC::Yarr::YarrPattern::reset):
     41        (JSC::Yarr::YarrPattern::newlineCharacterClass):
     42        (JSC::Yarr::YarrPattern::digitsCharacterClass):
     43        (JSC::Yarr::YarrPattern::spacesCharacterClass):
     44        (JSC::Yarr::YarrPattern::wordcharCharacterClass):
     45        (JSC::Yarr::YarrPattern::nondigitsCharacterClass):
     46        (JSC::Yarr::YarrPattern::nonspacesCharacterClass):
     47        (JSC::Yarr::YarrPattern::nonwordcharCharacterClass):
     48
    1492013-02-14  Geoffrey Garen  <ggaren@apple.com>
    250

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

    r140619 r143018  
    14561456};
    14571457
    1458 
    1459 
    14601458class ByteCompiler {
    14611459    struct ParenthesesStackEntry {
    … …  
    17131711
    17141712        unsigned numSubpatterns = lastSubpatternId - subpatternId + 1;
    1715         ByteDisjunction* parenthesesDisjunction = new ByteDisjunction(numSubpatterns, callFrameSize);
     1713        OwnPtr<ByteDisjunction> parenthesesDisjunction = adoptPtr(new ByteDisjunction(numSubpatterns, callFrameSize));
     1714
     1715        unsigned firstTermInParentheses = beginTerm + 1;
     1716        parenthesesDisjunction->terms.reserveInitialCapacity(endTerm - firstTermInParentheses + 2);
    17161717
    17171718        parenthesesDisjunction->terms.append(ByteTerm::SubpatternBegin());
    1718         for (unsigned termInParentheses = beginTerm + 1; termInParentheses < endTerm; ++termInParentheses)
     1719        for (unsigned termInParentheses = firstTermInParentheses; termInParentheses < endTerm; ++termInParentheses)
    17191720            parenthesesDisjunction->terms.append(m_bodyDisjunction->terms[termInParentheses]);
    17201721        parenthesesDisjunction->terms.append(ByteTerm::SubpatternEnd());
    … …  
    17221723        m_bodyDisjunction->terms.shrink(beginTerm);
    17231724
    1724         m_allParenthesesInfo.append(parenthesesDisjunction);
    1725         m_bodyDisjunction->terms.append(ByteTerm(ByteTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction, capture, inputPosition));
     1725        m_bodyDisjunction->terms.append(ByteTerm(ByteTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, inputPosition));
     1726        m_allParenthesesInfo.append(parenthesesDisjunction.release());
    17261727
    17271728        m_bodyDisjunction->terms[beginTerm].atom.quantityCount = quantityCount.unsafeGet();
    … …  
    18101811            unsigned currentCountAlreadyChecked = inputCountAlreadyChecked;
    18111812
    1812             PatternAlternative* alternative = disjunction->m_alternatives[alt];
     1813            PatternAlternative* alternative = disjunction->m_alternatives[alt].get();
    18131814
    18141815            if (alt) {
    … …  
    19211922    unsigned m_currentAlternativeIndex;
    19221923    Vector<ParenthesesStackEntry> m_parenthesesStack;
    1923     Vector<ByteDisjunction*> m_allParenthesesInfo;
     1924    Vector<OwnPtr<ByteDisjunction> > m_allParenthesesInfo;
    19241925};
    19251926

  • trunk/Source/JavaScriptCore/yarr/YarrInterpreter.h

    r127191 r143018  
    338338    WTF_MAKE_FAST_ALLOCATED;
    339339public:
    340     BytecodePattern(PassOwnPtr<ByteDisjunction> body, Vector<ByteDisjunction*> allParenthesesInfo, YarrPattern& pattern, BumpPointerAllocator* allocator)
     340    BytecodePattern(PassOwnPtr<ByteDisjunction> body, Vector<OwnPtr<ByteDisjunction> >& parenthesesInfoToAdopt, YarrPattern& pattern, BumpPointerAllocator* allocator)
    341341        : m_body(body)
    342342        , m_ignoreCase(pattern.m_ignoreCase)
    … …  
    344344        , m_allocator(allocator)
    345345    {
     346        m_body->terms.shrinkToFit();
     347
    346348        newlineCharacterClass = pattern.newlineCharacterClass();
    347349        wordcharCharacterClass = pattern.wordcharCharacterClass();
    348350
    349         m_allParenthesesInfo.append(allParenthesesInfo);
    350         m_userCharacterClasses.append(pattern.m_userCharacterClasses);
    351         // 'Steal' the YarrPattern's CharacterClasses!  We clear its
    352         // array, so that it won't delete them on destruction.  We'll
    353         // take responsibility for that.
    354         pattern.m_userCharacterClasses.clear();
    355     }
    356 
    357     ~BytecodePattern()
    358     {
    359         deleteAllValues(m_allParenthesesInfo);
    360         deleteAllValues(m_userCharacterClasses);
     351        m_allParenthesesInfo.swap(parenthesesInfoToAdopt);
     352        m_allParenthesesInfo.shrinkToFit();
     353
     354        m_userCharacterClasses.swap(pattern.m_userCharacterClasses);
     355        m_userCharacterClasses.shrinkToFit();
    361356    }
    362357
    … …  
    372367
    373368private:
    374     Vector<ByteDisjunction*> m_allParenthesesInfo;
    375     Vector<CharacterClass*> m_userCharacterClasses;
     369    Vector<OwnPtr<ByteDisjunction> > m_allParenthesesInfo;
     370    Vector<OwnPtr<CharacterClass> > m_userCharacterClasses;
    376371};
    377372

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

    r140594 r143018  
    23162316        m_ops.last().m_previousOp = notFound;
    23172317        m_ops.last().m_term = term;
    2318         Vector<PatternAlternative*>& alternatives =  term->parentheses.disjunction->m_alternatives;
     2318        Vector<OwnPtr<PatternAlternative> >& alternatives =  term->parentheses.disjunction->m_alternatives;
    23192319        for (unsigned i = 0; i < alternatives.size(); ++i) {
    23202320            size_t lastOpIndex = m_ops.size() - 1;
    23212321
    2322             PatternAlternative* nestedAlternative = alternatives[i];
     2322            PatternAlternative* nestedAlternative = alternatives[i].get();
    23232323            opCompileAlternative(nestedAlternative);
    23242324
    … …  
    23672367        m_ops.last().m_previousOp = notFound;
    23682368        m_ops.last().m_term = term;
    2369         Vector<PatternAlternative*>& alternatives =  term->parentheses.disjunction->m_alternatives;
     2369        Vector<OwnPtr<PatternAlternative> >& alternatives =  term->parentheses.disjunction->m_alternatives;
    23702370        for (unsigned i = 0; i < alternatives.size(); ++i) {
    23712371            size_t lastOpIndex = m_ops.size() - 1;
    23722372
    2373             PatternAlternative* nestedAlternative = alternatives[i];
     2373            PatternAlternative* nestedAlternative = alternatives[i].get();
    23742374            opCompileAlternative(nestedAlternative);
    23752375
    … …  
    24412441    void opCompileBody(PatternDisjunction* disjunction)
    24422442    {
    2443         Vector<PatternAlternative*>& alternatives = disjunction->m_alternatives;
     2443        Vector<OwnPtr<PatternAlternative> >& alternatives = disjunction->m_alternatives;
    24442444        size_t currentAlternativeIndex = 0;
    24452445
    … …  
    24512451            do {
    24522452                size_t lastOpIndex = m_ops.size() - 1;
    2453                 PatternAlternative* alternative = alternatives[currentAlternativeIndex];
     2453                PatternAlternative* alternative = alternatives[currentAlternativeIndex].get();
    24542454                opCompileAlternative(alternative);
    24552455
    … …  
    24862486        do {
    24872487            size_t lastOpIndex = m_ops.size() - 1;
    2488             PatternAlternative* alternative = alternatives[currentAlternativeIndex];
     2488            PatternAlternative* alternative = alternatives[currentAlternativeIndex].get();
    24892489            ASSERT(!alternative->onceThrough());
    24902490            opCompileAlternative(alternative);

  • 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) {

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

    r127191 r143018  
    2929
    3030#include <wtf/CheckedArithmetic.h>
     31#include <wtf/OwnPtr.h>
     32#include <wtf/PassOwnPtr.h>
    3133#include <wtf/RefCounted.h>
    3234#include <wtf/Vector.h>
    … …  
    276278    }
    277279   
    278     ~PatternDisjunction()
    279     {
    280         deleteAllValues(m_alternatives);
    281     }
    282 
    283280    PatternAlternative* addNewAlternative()
    284281    {
    285282        PatternAlternative* alternative = new PatternAlternative(this);
    286         m_alternatives.append(alternative);
     283        m_alternatives.append(adoptPtr(alternative));
    287284        return alternative;
    288285    }
    289286
    290     Vector<PatternAlternative*> m_alternatives;
     287    Vector<OwnPtr<PatternAlternative> > m_alternatives;
    291288    PatternAlternative* m_parent;
    292289    unsigned m_minimumSize;
    … …  
    319316    JS_EXPORT_PRIVATE YarrPattern(const String& pattern, bool ignoreCase, bool multiline, const char** error);
    320317
    321     ~YarrPattern()
    322     {
    323         deleteAllValues(m_disjunctions);
    324         deleteAllValues(m_userCharacterClasses);
    325     }
    326 
    327318    void reset()
    328319    {
    … …  
    341332        nonwordcharCached = 0;
    342333
    343         deleteAllValues(m_disjunctions);
    344334        m_disjunctions.clear();
    345         deleteAllValues(m_userCharacterClasses);
    346335        m_userCharacterClasses.clear();
    347336    }
    … …  
    355344    {
    356345        if (!newlineCached)
    357             m_userCharacterClasses.append(newlineCached = newlineCreate());
     346            m_userCharacterClasses.append(adoptPtr(newlineCached = newlineCreate()));
    358347        return newlineCached;
    359348    }
    … …  
    361350    {
    362351        if (!digitsCached)
    363             m_userCharacterClasses.append(digitsCached = digitsCreate());
     352            m_userCharacterClasses.append(adoptPtr(digitsCached = digitsCreate()));
    364353        return digitsCached;
    365354    }
    … …  
    367356    {
    368357        if (!spacesCached)
    369             m_userCharacterClasses.append(spacesCached = spacesCreate());
     358            m_userCharacterClasses.append(adoptPtr(spacesCached = spacesCreate()));
    370359        return spacesCached;
    371360    }
    … …  
    373362    {
    374363        if (!wordcharCached)
    375             m_userCharacterClasses.append(wordcharCached = wordcharCreate());
     364            m_userCharacterClasses.append(adoptPtr(wordcharCached = wordcharCreate()));
    376365        return wordcharCached;
    377366    }
    … …  
    379368    {
    380369        if (!nondigitsCached)
    381             m_userCharacterClasses.append(nondigitsCached = nondigitsCreate());
     370            m_userCharacterClasses.append(adoptPtr(nondigitsCached = nondigitsCreate()));
    382371        return nondigitsCached;
    383372    }
    … …  
    385374    {
    386375        if (!nonspacesCached)
    387             m_userCharacterClasses.append(nonspacesCached = nonspacesCreate());
     376            m_userCharacterClasses.append(adoptPtr(nonspacesCached = nonspacesCreate()));
    388377        return nonspacesCached;
    389378    }
    … …  
    391380    {
    392381        if (!nonwordcharCached)
    393             m_userCharacterClasses.append(nonwordcharCached = nonwordcharCreate());
     382            m_userCharacterClasses.append(adoptPtr(nonwordcharCached = nonwordcharCreate()));
    394383        return nonwordcharCached;
    395384    }
    … …  
    402391    unsigned m_maxBackReference;
    403392    PatternDisjunction* m_body;
    404     Vector<PatternDisjunction*, 4> m_disjunctions;
    405     Vector<CharacterClass*> m_userCharacterClasses;
     393    Vector<OwnPtr<PatternDisjunction>, 4> m_disjunctions;
     394    Vector<OwnPtr<CharacterClass> > m_userCharacterClasses;
    406395
    407396private:
Note: See TracChangeset for help on using the changeset viewer.