Changeset 38247 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
Nov 9, 2008, 5:04:30 PM (17 years ago)
Author:
Darin Adler
Message:

JavaScriptCore:

2008-11-09 Darin Adler <Darin Adler>

Reviewed by Sam Weinig and Maciej Stachowiak.
Includes some work done by Chris Brichford.

Test: fast/js/large-expressions.html

1) Code generation is recursive, so takes stack proportional to the complexity

of the source code expression. Fixed by setting an arbitrary recursion limit
of 10,000 nodes.

2) Destruction of the syntax tree was recursive. Fixed by introducing a

non-recursive mechanism for destroying the tree.

  • bytecompiler/CodeGenerator.cpp: (JSC::CodeGenerator::CodeGenerator): Initialize depth to 0. (JSC::CodeGenerator::emitThrowExpressionTooDeepException): Added. Emits the code to throw a "too deep" exception.
  • bytecompiler/CodeGenerator.h: (JSC::CodeGenerator::emitNode): Check depth and emit an exception if we exceed the maximum depth.
  • parser/Nodes.cpp: (JSC::NodeReleaser::releaseAllNodes): Added. To be called inside node destructors to avoid recursive calls to destructors for nodes inside this one. (JSC::NodeReleaser::release): Added. To be called inside releaseNodes functions. Also added releaseNodes functions and calls to releaseAllNodes inside destructors for each class derived from Node that has RefPtr to other nodes. (JSC::NodeReleaser::adopt): Added. Used by the release function. (JSC::NodeReleaser::adoptFunctionBodyNode): Added.
  • parser/Nodes.h: Added declarations of releaseNodes and destructors in all classes that needed it. Eliminated use of ListRefPtr and releaseNext, which are the two parts of an older solution to the non-recursive destruction problem that works only for lists, whereas the new solution works for other graphs. Changed ReverseBinaryOpNode to use BinaryOpNode as a base class to avoid some duplicated code.

LayoutTests:

2008-11-09 Alexey Proskuryakov <​[email protected]>

Reviewed by Darin Adler.

​https://bugs.webkit.org/show_bug.cgi?id=22104
Javascript URL percent encoding/decoding broken by some characters

  • fast/loader/javascript-url-encoding-2-expected.txt:
  • fast/loader/javascript-url-encoding-2.html:
Location:
trunk/JavaScriptCore
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r38238 r38247  
     12008-11-09  Darin Adler  <[email protected]>
     2
     3        Reviewed by Sam Weinig and Maciej Stachowiak.
     4        Includes some work done by Chris Brichford.
     5
     6        - fix https://bugs.webkit.org/show_bug.cgi?id=14886
     7          Stack overflow due to deeply nested parse tree doing repeated string concatentation
     8
     9        Test: fast/js/large-expressions.html
     10
     11        1) Code generation is recursive, so takes stack proportional to the complexity
     12           of the source code expression. Fixed by setting an arbitrary recursion limit
     13           of 10,000 nodes.
     14
     15        2) Destruction of the syntax tree was recursive. Fixed by introducing a
     16           non-recursive mechanism for destroying the tree.
     17
     18        * bytecompiler/CodeGenerator.cpp:
     19        (JSC::CodeGenerator::CodeGenerator): Initialize depth to 0.
     20        (JSC::CodeGenerator::emitThrowExpressionTooDeepException): Added. Emits the code
     21        to throw a "too deep" exception.
     22        * bytecompiler/CodeGenerator.h:
     23        (JSC::CodeGenerator::emitNode): Check depth and emit an exception if we exceed
     24        the maximum depth.
     25
     26        * parser/Nodes.cpp:
     27        (JSC::NodeReleaser::releaseAllNodes): Added. To be called inside node destructors
     28        to avoid recursive calls to destructors for nodes inside this one.
     29        (JSC::NodeReleaser::release): Added. To be called inside releaseNodes functions.
     30        Also added releaseNodes functions and calls to releaseAllNodes inside destructors
     31        for each class derived from Node that has RefPtr to other nodes.
     32        (JSC::NodeReleaser::adopt): Added. Used by the release function.
     33        (JSC::NodeReleaser::adoptFunctionBodyNode): Added.
     34
     35        * parser/Nodes.h: Added declarations of releaseNodes and destructors in all classes
     36        that needed it. Eliminated use of ListRefPtr and releaseNext, which are the two parts
     37        of an older solution to the non-recursive destruction problem that works only for
     38        lists, whereas the new solution works for other graphs. Changed ReverseBinaryOpNode
     39        to use BinaryOpNode as a base class to avoid some duplicated code.
     40
    1412008-11-08  Kevin Ollivier  <[email protected]>
    242       

  • trunk/JavaScriptCore/bytecompiler/CodeGenerator.cpp

    r38230 r38247  
    208208    , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
    209209    , m_lastOpcodeID(op_end)
     210    , m_emitNodeDepth(0)
    210211{
    211212    if (m_shouldEmitDebugHooks)
    … …  
    284285    , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
    285286    , m_lastOpcodeID(op_end)
     287    , m_emitNodeDepth(0)
    286288{
    287289    if (m_shouldEmitDebugHooks)
    … …  
    354356    , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
    355357    , m_lastOpcodeID(op_end)
     358    , m_emitNodeDepth(0)
    356359{
    357360    if (m_shouldEmitDebugHooks)
    … …  
    16771680}
    16781681
     1682RegisterID* CodeGenerator::emitThrowExpressionTooDeepException()
     1683{
     1684    // It would be nice to do an even better job of identifying exactly where the expression is.
     1685    // And we could make the caller pass the node pointer in, if there was some way of getting
     1686    // that from an arbitrary node. However, calling emitExpressionInfo without any useful data
     1687    // is still good enough to get us an accurate line number.
     1688    emitExpressionInfo(0, 0, 0);
     1689    RegisterID* exception = emitNewError(newTemporary(), SyntaxError, jsString(globalData(), "Expression too deep"));
     1690    emitThrow(exception);
     1691    return exception;
     1692}
     1693
    16791694} // namespace JSC

  • trunk/JavaScriptCore/bytecompiler/CodeGenerator.h

    r38219 r38247  
    166166                m_codeBlock->lineInfo.append(info);
    167167            }
    168             return n->emitCode(*this, dst);
     168            if (m_emitNodeDepth >= s_maxEmitNodeDepth)
     169                return emitThrowExpressionTooDeepException();
     170            ++m_emitNodeDepth;
     171            RegisterID* r = n->emitCode(*this, dst);
     172            --m_emitNodeDepth;
     173            return r;
    169174        }
    170175
    … …  
    400405        bool canOptimizeNonLocals() { return (m_codeType == FunctionCode) && !m_dynamicScopeDepth && !m_codeBlock->usesEval; }
    401406
     407        RegisterID* emitThrowExpressionTooDeepException();
     408
    402409        bool m_shouldEmitDebugHooks;
    403410        bool m_shouldEmitProfileHooks;
    … …  
    445452        static bool s_dumpsGeneratedCode;
    446453#endif
     454
     455        unsigned m_emitNodeDepth;
     456
     457        static const unsigned s_maxEmitNodeDepth = 10000;
    447458    };
    448459

  • trunk/JavaScriptCore/parser/Nodes.cpp

    r38205 r38247  
    5151namespace JSC {
    5252
    53 // ------------------------------ Node -----------------------------------------
     53static void substitute(UString& string, const UString& substring) JSC_FAST_CALL;
     54
     55// ------------------------------ NodeReleaser --------------------------------
     56
     57class NodeReleaser : Noncopyable {
     58public:
     59    // Call this function inside the destructor of a class derived from Node.
     60    // This will traverse the tree below this node, destroying all of those nodes,
     61    // but without relying on recursion.
     62    static void releaseAllNodes(ParserRefCounted* root);
     63
     64    // Call this on each node in a the releaseNodes virtual function.
     65    // It gives the node to the NodeReleaser, which will then release the
     66    // node later at the end of the releaseAllNodes process.
     67    template <typename T> void release(RefPtr<T>& node) { if (node) adopt(node.release()); }
     68    void release(RefPtr<FunctionBodyNode>& node) { if (node) adoptFunctionBodyNode(node); }
     69
     70private:
     71    NodeReleaser() { }
     72    ~NodeReleaser() { }
     73
     74    void adopt(PassRefPtr<ParserRefCounted>);
     75    void adoptFunctionBodyNode(RefPtr<FunctionBodyNode>&);
     76
     77    typedef Vector<RefPtr<ParserRefCounted> > NodeReleaseVector;
     78    OwnPtr<NodeReleaseVector> m_vector;
     79};
     80
     81void NodeReleaser::releaseAllNodes(ParserRefCounted* root)
     82{
     83    ASSERT(root);
     84    NodeReleaser releaser;
     85    root->releaseNodes(releaser);
     86    if (!releaser.m_vector)
     87        return;
     88    // Note: The call to release.m_vector->size() is intentionally inside
     89    // the loop, since calls to releaseNodes are expected to increase the size.
     90    for (size_t i = 0; i < releaser.m_vector->size(); ++i) {
     91        ParserRefCounted* node = (*releaser.m_vector)[i].get();
     92        if (node->hasOneRef())
     93            node->releaseNodes(releaser);
     94    }
     95}
     96
     97void NodeReleaser::adopt(PassRefPtr<ParserRefCounted> node)
     98{
     99    ASSERT(node);
     100    if (!node->hasOneRef())
     101        return;
     102    if (!m_vector)
     103        m_vector.set(new NodeReleaseVector);
     104    m_vector->append(node);
     105}
     106
     107void NodeReleaser::adoptFunctionBodyNode(RefPtr<FunctionBodyNode>& functionBodyNode)
     108{
     109    // This sidesteps a problem where if you assign a PassRefPtr<FunctionBodyNode>
     110    // to a PassRefPtr<Node> we leave the two reference counts (FunctionBodyNode
     111    // and ParserRefCounted) unbalanced. It would be nice to fix this problem in
     112    // a cleaner way -- perhaps we could remove the FunctionBodyNode reference
     113    // count at some point.
     114    RefPtr<Node> node = functionBodyNode;
     115    functionBodyNode = 0;
     116    adopt(node.release());
     117}
     118
     119// ------------------------------ ParserRefCounted -----------------------------------------
    54120
    55121#ifndef NDEBUG
    … …  
    74140    parserRefCountedCounter.decrement();
    75141#endif
     142}
     143
     144void ParserRefCounted::releaseNodes(NodeReleaser&)
     145{
    76146}
    77147
    … …  
    141211}
    142212
     213// ------------------------------ Node --------------------------------
     214
    143215Node::Node(JSGlobalData* globalData)
    144216    : ParserRefCounted(globalData)
    … …  
    147219}
    148220
    149 static void substitute(UString& string, const UString& substring) JSC_FAST_CALL;
     221// ------------------------------ ThrowableExpressionData --------------------------------
     222
    150223static void substitute(UString& string, const UString& substring)
    151224{
    … …  
    276349}
    277350
     351// ------------------------------ ElementNode ------------------------------------
     352
     353ElementNode::~ElementNode()
     354{
     355    NodeReleaser::releaseAllNodes(this);
     356}
     357
     358void ElementNode::releaseNodes(NodeReleaser& releaser)
     359{
     360    releaser.release(m_next);
     361    releaser.release(m_node);
     362}
     363
    278364// ------------------------------ ArrayNode ------------------------------------
     365
     366ArrayNode::~ArrayNode()
     367{
     368    NodeReleaser::releaseAllNodes(this);
     369}
     370
     371void ArrayNode::releaseNodes(NodeReleaser& releaser)
     372{
     373    releaser.release(m_element);
     374}
    279375
    280376RegisterID* ArrayNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    309405}
    310406
     407// ------------------------------ PropertyNode ----------------------------
     408
     409PropertyNode::~PropertyNode()
     410{
     411    NodeReleaser::releaseAllNodes(this);
     412}
     413
     414void PropertyNode::releaseNodes(NodeReleaser& releaser)
     415{
     416    releaser.release(m_assign);
     417}
     418
    311419// ------------------------------ ObjectLiteralNode ----------------------------
     420
     421ObjectLiteralNode::~ObjectLiteralNode()
     422{
     423    NodeReleaser::releaseAllNodes(this);
     424}
     425
     426void ObjectLiteralNode::releaseNodes(NodeReleaser& releaser)
     427{
     428    releaser.release(m_list);
     429}
    312430
    313431RegisterID* ObjectLiteralNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    322440
    323441// ------------------------------ PropertyListNode -----------------------------
     442
     443PropertyListNode::~PropertyListNode()
     444{
     445    NodeReleaser::releaseAllNodes(this);
     446}
     447
     448void PropertyListNode::releaseNodes(NodeReleaser& releaser)
     449{
     450    releaser.release(m_node);
     451    releaser.release(m_next);
     452}
    324453
    325454RegisterID* PropertyListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    355484// ------------------------------ BracketAccessorNode --------------------------------
    356485
     486BracketAccessorNode::~BracketAccessorNode()
     487{
     488    NodeReleaser::releaseAllNodes(this);
     489}
     490
     491void BracketAccessorNode::releaseNodes(NodeReleaser& releaser)
     492{
     493    releaser.release(m_base);
     494    releaser.release(m_subscript);
     495}
     496
    357497RegisterID* BracketAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    358498{
    … …  
    365505// ------------------------------ DotAccessorNode --------------------------------
    366506
     507DotAccessorNode::~DotAccessorNode()
     508{
     509    NodeReleaser::releaseAllNodes(this);
     510}
     511
     512void DotAccessorNode::releaseNodes(NodeReleaser& releaser)
     513{
     514    releaser.release(m_base);
     515}
     516
    367517RegisterID* DotAccessorNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    368518{
    … …  
    374524// ------------------------------ ArgumentListNode -----------------------------
    375525
     526ArgumentListNode::~ArgumentListNode()
     527{
     528    NodeReleaser::releaseAllNodes(this);
     529}
     530
     531void ArgumentListNode::releaseNodes(NodeReleaser& releaser)
     532{
     533    releaser.release(m_next);
     534    releaser.release(m_expr);
     535}
     536
    376537RegisterID* ArgumentListNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    377538{
    … …  
    380541}
    381542
     543// ------------------------------ ArgumentsNode -----------------------------
     544
     545ArgumentsNode::~ArgumentsNode()
     546{
     547    NodeReleaser::releaseAllNodes(this);
     548}
     549
     550void ArgumentsNode::releaseNodes(NodeReleaser& releaser)
     551{
     552    releaser.release(m_listNode);
     553}
     554
    382555// ------------------------------ NewExprNode ----------------------------------
     556
     557NewExprNode::~NewExprNode()
     558{
     559    NodeReleaser::releaseAllNodes(this);
     560}
     561
     562void NewExprNode::releaseNodes(NodeReleaser& releaser)
     563{
     564    releaser.release(m_expr);
     565    releaser.release(m_args);
     566}
    383567
    384568RegisterID* NewExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    386570    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    387571    return generator.emitConstruct(generator.finalDestination(dst), func.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
     572}
     573
     574// ------------------------------ EvalFunctionCallNode ----------------------------------
     575
     576EvalFunctionCallNode::~EvalFunctionCallNode()
     577{
     578    NodeReleaser::releaseAllNodes(this);
     579}
     580
     581void EvalFunctionCallNode::releaseNodes(NodeReleaser& releaser)
     582{
     583    releaser.release(m_args);
    388584}
    389585
    … …  
    396592}
    397593
     594// ------------------------------ FunctionCallValueNode ----------------------------------
     595
     596FunctionCallValueNode::~FunctionCallValueNode()
     597{
     598    NodeReleaser::releaseAllNodes(this);
     599}
     600
     601void FunctionCallValueNode::releaseNodes(NodeReleaser& releaser)
     602{
     603    releaser.release(m_expr);
     604    releaser.release(m_args);
     605}
     606
    398607RegisterID* FunctionCallValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    399608{
    400609    RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
    401610    return generator.emitCall(generator.finalDestination(dst), func.get(), 0, m_args.get(), m_divot, m_startOffset, m_endOffset);
     611}
     612
     613// ------------------------------ FunctionCallResolveNode ----------------------------------
     614
     615FunctionCallResolveNode::~FunctionCallResolveNode()
     616{
     617    NodeReleaser::releaseAllNodes(this);
     618}
     619
     620void FunctionCallResolveNode::releaseNodes(NodeReleaser& releaser)
     621{
     622    releaser.release(m_args);
    402623}
    403624
    … …  
    423644}
    424645
     646// ------------------------------ FunctionCallBracketNode ----------------------------------
     647
     648FunctionCallBracketNode::~FunctionCallBracketNode()
     649{
     650    NodeReleaser::releaseAllNodes(this);
     651}
     652
     653void FunctionCallBracketNode::releaseNodes(NodeReleaser& releaser)
     654{
     655    releaser.release(m_base);
     656    releaser.release(m_subscript);
     657    releaser.release(m_args);
     658}
     659
    425660RegisterID* FunctionCallBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    426661{
    … …  
    430665    RefPtr<RegisterID> function = generator.emitGetByVal(generator.newTemporary(), base.get(), property);
    431666    return generator.emitCall(generator.finalDestination(dst, base.get()), function.get(), base.get(), m_args.get(), m_divot, m_startOffset, m_endOffset);
     667}
     668
     669// ------------------------------ FunctionCallDotNode ----------------------------------
     670
     671FunctionCallDotNode::~FunctionCallDotNode()
     672{
     673    NodeReleaser::releaseAllNodes(this);
     674}
     675
     676void FunctionCallDotNode::releaseNodes(NodeReleaser& releaser)
     677{
     678    releaser.release(m_base);
     679    releaser.release(m_args);
    432680}
    433681
    … …  
    498746// ------------------------------ PostfixBracketNode ----------------------------------
    499747
     748PostfixBracketNode::~PostfixBracketNode()
     749{
     750    NodeReleaser::releaseAllNodes(this);
     751}
     752
     753void PostfixBracketNode::releaseNodes(NodeReleaser& releaser)
     754{
     755    releaser.release(m_base);
     756    releaser.release(m_subscript);
     757}
     758
    500759RegisterID* PostfixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    501760{
    … …  
    522781// ------------------------------ PostfixDotNode ----------------------------------
    523782
     783PostfixDotNode::~PostfixDotNode()
     784{
     785    NodeReleaser::releaseAllNodes(this);
     786}
     787
     788void PostfixDotNode::releaseNodes(NodeReleaser& releaser)
     789{
     790    releaser.release(m_base);
     791}
     792
    524793RegisterID* PostfixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    525794{
    … …  
    545814// ------------------------------ PostfixErrorNode -----------------------------------
    546815
     816PostfixErrorNode::~PostfixErrorNode()
     817{
     818    NodeReleaser::releaseAllNodes(this);
     819}
     820
     821void PostfixErrorNode::releaseNodes(NodeReleaser& releaser)
     822{
     823    releaser.release(m_expr);
     824}
     825
    547826RegisterID* PostfixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    548827{
    … …  
    564843// ------------------------------ DeleteBracketNode -----------------------------------
    565844
     845DeleteBracketNode::~DeleteBracketNode()
     846{
     847    NodeReleaser::releaseAllNodes(this);
     848}
     849
     850void DeleteBracketNode::releaseNodes(NodeReleaser& releaser)
     851{
     852    releaser.release(m_base);
     853    releaser.release(m_subscript);
     854}
     855
    566856RegisterID* DeleteBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    567857{
    … …  
    575865// ------------------------------ DeleteDotNode -----------------------------------
    576866
     867DeleteDotNode::~DeleteDotNode()
     868{
     869    NodeReleaser::releaseAllNodes(this);
     870}
     871
     872void DeleteDotNode::releaseNodes(NodeReleaser& releaser)
     873{
     874    releaser.release(m_base);
     875}
     876
    577877RegisterID* DeleteDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    578878{
    … …  
    585885// ------------------------------ DeleteValueNode -----------------------------------
    586886
     887DeleteValueNode::~DeleteValueNode()
     888{
     889    NodeReleaser::releaseAllNodes(this);
     890}
     891
     892void DeleteValueNode::releaseNodes(NodeReleaser& releaser)
     893{
     894    releaser.release(m_expr);
     895}
     896
    587897RegisterID* DeleteValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    588898{
    … …  
    594904
    595905// ------------------------------ VoidNode -------------------------------------
     906
     907VoidNode::~VoidNode()
     908{
     909    NodeReleaser::releaseAllNodes(this);
     910}
     911
     912void VoidNode::releaseNodes(NodeReleaser& releaser)
     913{
     914    releaser.release(m_expr);
     915}
    596916
    597917RegisterID* VoidNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    623943
    624944// ------------------------------ TypeOfValueNode -----------------------------------
     945
     946TypeOfValueNode::~TypeOfValueNode()
     947{
     948    NodeReleaser::releaseAllNodes(this);
     949}
     950
     951void TypeOfValueNode::releaseNodes(NodeReleaser& releaser)
     952{
     953    releaser.release(m_expr);
     954}
    625955
    626956RegisterID* TypeOfValueNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    669999
    6701000// ------------------------------ PrefixBracketNode ----------------------------------
     1001
     1002PrefixBracketNode::~PrefixBracketNode()
     1003{
     1004    NodeReleaser::releaseAllNodes(this);
     1005}
     1006
     1007void PrefixBracketNode::releaseNodes(NodeReleaser& releaser)
     1008{
     1009    releaser.release(m_base);
     1010    releaser.release(m_subscript);
     1011}
    6711012
    6721013RegisterID* PrefixBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    6891030// ------------------------------ PrefixDotNode ----------------------------------
    6901031
     1032PrefixDotNode::~PrefixDotNode()
     1033{
     1034    NodeReleaser::releaseAllNodes(this);
     1035}
     1036
     1037void PrefixDotNode::releaseNodes(NodeReleaser& releaser)
     1038{
     1039    releaser.release(m_base);
     1040}
     1041
    6911042RegisterID* PrefixDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    6921043{
    … …  
    7071058// ------------------------------ PrefixErrorNode -----------------------------------
    7081059
     1060PrefixErrorNode::~PrefixErrorNode()
     1061{
     1062    NodeReleaser::releaseAllNodes(this);
     1063}
     1064
     1065void PrefixErrorNode::releaseNodes(NodeReleaser& releaser)
     1066{
     1067    releaser.release(m_expr);
     1068}
     1069
    7091070RegisterID* PrefixErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    7101071{
    … …  
    7131074
    7141075// ------------------------------ Unary Operation Nodes -----------------------------------
     1076
     1077UnaryOpNode::~UnaryOpNode()
     1078{
     1079    NodeReleaser::releaseAllNodes(this);
     1080}
     1081
     1082void UnaryOpNode::releaseNodes(NodeReleaser& releaser)
     1083{
     1084    releaser.release(m_expr);
     1085}
    7151086
    7161087RegisterID* UnaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    7211092
    7221093// ------------------------------ Binary Operation Nodes -----------------------------------
     1094
     1095BinaryOpNode::~BinaryOpNode()
     1096{
     1097    NodeReleaser::releaseAllNodes(this);
     1098}
     1099
     1100void BinaryOpNode::releaseNodes(NodeReleaser& releaser)
     1101{
     1102    releaser.release(m_expr1);
     1103    releaser.release(m_expr2);
     1104}
    7231105
    7241106RegisterID* BinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    7831165}
    7841166
    785 // ------------------------------ Binary Logical Nodes ----------------------------
     1167// ------------------------------ LogicalOpNode ----------------------------
     1168
     1169LogicalOpNode::~LogicalOpNode()
     1170{
     1171    NodeReleaser::releaseAllNodes(this);
     1172}
     1173
     1174void LogicalOpNode::releaseNodes(NodeReleaser& releaser)
     1175{
     1176    releaser.release(m_expr1);
     1177    releaser.release(m_expr2);
     1178}
    7861179
    7871180RegisterID* LogicalOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    8031196// ------------------------------ ConditionalNode ------------------------------
    8041197
     1198ConditionalNode::~ConditionalNode()
     1199{
     1200    NodeReleaser::releaseAllNodes(this);
     1201}
     1202
     1203void ConditionalNode::releaseNodes(NodeReleaser& releaser)
     1204{
     1205    releaser.release(m_logical);
     1206    releaser.release(m_expr1);
     1207    releaser.release(m_expr2);
     1208}
     1209
    8051210RegisterID* ConditionalNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    8061211{
    … …  
    8241229
    8251230// ------------------------------ ReadModifyResolveNode -----------------------------------
     1231
     1232ReadModifyResolveNode::~ReadModifyResolveNode()
     1233{
     1234    NodeReleaser::releaseAllNodes(this);
     1235}
     1236
     1237void ReadModifyResolveNode::releaseNodes(NodeReleaser& releaser)
     1238{
     1239    releaser.release(m_right);
     1240}
    8261241
    8271242// FIXME: should this be moved to be a method on CodeGenerator?
    … …  
    9151330// ------------------------------ AssignResolveNode -----------------------------------
    9161331
     1332AssignResolveNode::~AssignResolveNode()
     1333{
     1334    NodeReleaser::releaseAllNodes(this);
     1335}
     1336
     1337void AssignResolveNode::releaseNodes(NodeReleaser& releaser)
     1338{
     1339    releaser.release(m_right);
     1340}
     1341
    9171342RegisterID* AssignResolveNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9181343{
    … …  
    9461371// ------------------------------ AssignDotNode -----------------------------------
    9471372
     1373AssignDotNode::~AssignDotNode()
     1374{
     1375    NodeReleaser::releaseAllNodes(this);
     1376}
     1377
     1378void AssignDotNode::releaseNodes(NodeReleaser& releaser)
     1379{
     1380    releaser.release(m_base);
     1381    releaser.release(m_right);
     1382}
     1383
    9481384RegisterID* AssignDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9491385{
    … …  
    9581394// ------------------------------ ReadModifyDotNode -----------------------------------
    9591395
     1396ReadModifyDotNode::~ReadModifyDotNode()
     1397{
     1398    NodeReleaser::releaseAllNodes(this);
     1399}
     1400
     1401void ReadModifyDotNode::releaseNodes(NodeReleaser& releaser)
     1402{
     1403    releaser.release(m_base);
     1404    releaser.release(m_right);
     1405}
     1406
    9601407RegisterID* ReadModifyDotNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9611408{
    … …  
    9731420// ------------------------------ AssignErrorNode -----------------------------------
    9741421
     1422AssignErrorNode::~AssignErrorNode()
     1423{
     1424    NodeReleaser::releaseAllNodes(this);
     1425}
     1426
     1427void AssignErrorNode::releaseNodes(NodeReleaser& releaser)
     1428{
     1429    releaser.release(m_left);
     1430    releaser.release(m_right);
     1431}
     1432
    9751433RegisterID* AssignErrorNode::emitCode(CodeGenerator& generator, RegisterID*)
    9761434{
    … …  
    9791437
    9801438// ------------------------------ AssignBracketNode -----------------------------------
     1439
     1440AssignBracketNode::~AssignBracketNode()
     1441{
     1442    NodeReleaser::releaseAllNodes(this);
     1443}
     1444
     1445void AssignBracketNode::releaseNodes(NodeReleaser& releaser)
     1446{
     1447    releaser.release(m_base);
     1448    releaser.release(m_subscript);
     1449    releaser.release(m_right);
     1450}
    9811451
    9821452RegisterID* AssignBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    9921462}
    9931463
     1464// ------------------------------ ReadModifyBracketNode -----------------------------------
     1465
     1466ReadModifyBracketNode::~ReadModifyBracketNode()
     1467{
     1468    NodeReleaser::releaseAllNodes(this);
     1469}
     1470
     1471void ReadModifyBracketNode::releaseNodes(NodeReleaser& releaser)
     1472{
     1473    releaser.release(m_base);
     1474    releaser.release(m_subscript);
     1475    releaser.release(m_right);
     1476}
     1477
    9941478RegisterID* ReadModifyBracketNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    9951479{
    … …  
    10101494// ------------------------------ CommaNode ------------------------------------
    10111495
     1496CommaNode::~CommaNode()
     1497{
     1498    NodeReleaser::releaseAllNodes(this);
     1499}
     1500
     1501void CommaNode::releaseNodes(NodeReleaser& releaser)
     1502{
     1503    releaser.release(m_expr1);
     1504    releaser.release(m_expr2);
     1505}
     1506
    10121507RegisterID* CommaNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    10131508{
    … …  
    10161511}
    10171512
    1018 // ------------------------------ ConstDeclNode ----------------------------------
     1513// ------------------------------ ConstDeclNode ------------------------------------
     1514
     1515ConstDeclNode::~ConstDeclNode()
     1516{
     1517    NodeReleaser::releaseAllNodes(this);
     1518}
     1519
     1520void ConstDeclNode::releaseNodes(NodeReleaser& releaser)
     1521{
     1522    releaser.release(m_next);
     1523    releaser.release(m_init);
     1524}
    10191525
    10201526ConstDeclNode::ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* init)
    … …  
    10521558// ------------------------------ ConstStatementNode -----------------------------
    10531559
     1560ConstStatementNode::~ConstStatementNode()
     1561{
     1562    NodeReleaser::releaseAllNodes(this);
     1563}
     1564
     1565void ConstStatementNode::releaseNodes(NodeReleaser& releaser)
     1566{
     1567    releaser.release(m_next);
     1568}
     1569
    10541570RegisterID* ConstStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
    10551571{
    … …  
    10831599// ------------------------------ BlockNode ------------------------------------
    10841600
     1601BlockNode::~BlockNode()
     1602{
     1603    NodeReleaser::releaseAllNodes(this);
     1604}
     1605
     1606void BlockNode::releaseNodes(NodeReleaser& releaser)
     1607{
     1608    size_t size = m_children.size();
     1609    for (size_t i = 0; i < size; ++i)
     1610        releaser.release(m_children[i]);
     1611}
     1612
    10851613BlockNode::BlockNode(JSGlobalData* globalData, SourceElements* children)
    10861614    : StatementNode(globalData)
    … …  
    11201648// ------------------------------ VarStatementNode ----------------------------
    11211649
     1650VarStatementNode::~VarStatementNode()
     1651{
     1652    NodeReleaser::releaseAllNodes(this);
     1653}
     1654
     1655void VarStatementNode::releaseNodes(NodeReleaser& releaser)
     1656{
     1657    releaser.release(m_expr);
     1658}
     1659
    11221660RegisterID* VarStatementNode::emitCode(CodeGenerator& generator, RegisterID*)
    11231661{
    … …  
    11281666// ------------------------------ IfNode ---------------------------------------
    11291667
     1668IfNode::~IfNode()
     1669{
     1670    NodeReleaser::releaseAllNodes(this);
     1671}
     1672
     1673void IfNode::releaseNodes(NodeReleaser& releaser)
     1674{
     1675    releaser.release(m_condition);
     1676    releaser.release(m_ifBlock);
     1677}
     1678
    11301679RegisterID* IfNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    11311680{
    … …  
    11411690    generator.emitLabel(afterThen.get());
    11421691
    1143     // FIXME: This should return the last statement exectuted so that it can be returned as a Completion
     1692    // FIXME: This should return the last statement executed so that it can be returned as a Completion.
    11441693    return 0;
     1694}
     1695
     1696// ------------------------------ IfElseNode ---------------------------------------
     1697
     1698IfElseNode::~IfElseNode()
     1699{
     1700    NodeReleaser::releaseAllNodes(this);
     1701}
     1702
     1703void IfElseNode::releaseNodes(NodeReleaser& releaser)
     1704{
     1705    releaser.release(m_elseBlock);
     1706    IfNode::releaseNodes(releaser);
    11451707}
    11461708
    … …  
    11681730    generator.emitLabel(afterElse.get());
    11691731
    1170     // FIXME: This should return the last statement exectuted so that it can be returned as a Completion
     1732    // FIXME: This should return the last statement executed so that it can be returned as a Completion.
    11711733    return 0;
    11721734}
    11731735
    11741736// ------------------------------ DoWhileNode ----------------------------------
     1737
     1738DoWhileNode::~DoWhileNode()
     1739{
     1740    NodeReleaser::releaseAllNodes(this);
     1741}
     1742
     1743void DoWhileNode::releaseNodes(NodeReleaser& releaser)
     1744{
     1745    releaser.release(m_statement);
     1746    releaser.release(m_expr);
     1747}
    11751748
    11761749RegisterID* DoWhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    11991772// ------------------------------ WhileNode ------------------------------------
    12001773
     1774WhileNode::~WhileNode()
     1775{
     1776    NodeReleaser::releaseAllNodes(this);
     1777}
     1778
     1779void WhileNode::releaseNodes(NodeReleaser& releaser)
     1780{
     1781    releaser.release(m_expr);
     1782    releaser.release(m_statement);
     1783}
     1784
    12011785RegisterID* WhileNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    12021786{
    … …  
    12251809
    12261810// ------------------------------ ForNode --------------------------------------
     1811
     1812ForNode::~ForNode()
     1813{
     1814    NodeReleaser::releaseAllNodes(this);
     1815}
     1816
     1817void ForNode::releaseNodes(NodeReleaser& releaser)
     1818{
     1819    releaser.release(m_expr1);
     1820    releaser.release(m_expr2);
     1821    releaser.release(m_expr3);
     1822    releaser.release(m_statement);
     1823}
    12271824
    12281825RegisterID* ForNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    12641861
    12651862// ------------------------------ ForInNode ------------------------------------
     1863
     1864ForInNode::~ForInNode()
     1865{
     1866    NodeReleaser::releaseAllNodes(this);
     1867}
     1868
     1869void ForInNode::releaseNodes(NodeReleaser& releaser)
     1870{
     1871    releaser.release(m_init);
     1872    releaser.release(m_lexpr);
     1873    releaser.release(m_expr);
     1874    releaser.release(m_statement);
     1875}
    12661876
    12671877ForInNode::ForInNode(JSGlobalData* globalData, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
    … …  
    13881998// ------------------------------ ReturnNode -----------------------------------
    13891999
     2000ReturnNode::~ReturnNode()
     2001{
     2002    NodeReleaser::releaseAllNodes(this);
     2003}
     2004
     2005void ReturnNode::releaseNodes(NodeReleaser& releaser)
     2006{
     2007    releaser.release(m_value);
     2008}
     2009
    13902010RegisterID* ReturnNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    13912011{
    … …  
    14072027// ------------------------------ WithNode -------------------------------------
    14082028
     2029WithNode::~WithNode()
     2030{
     2031    NodeReleaser::releaseAllNodes(this);
     2032}
     2033
     2034void WithNode::releaseNodes(NodeReleaser& releaser)
     2035{
     2036    releaser.release(m_expr);
     2037    releaser.release(m_statement);
     2038}
     2039
    14092040RegisterID* WithNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    14102041{
    … …  
    14172048}
    14182049
     2050// ------------------------------ CaseClauseNode --------------------------------
     2051
     2052CaseClauseNode::~CaseClauseNode()
     2053{
     2054    NodeReleaser::releaseAllNodes(this);
     2055}
     2056
     2057void CaseClauseNode::releaseNodes(NodeReleaser& releaser)
     2058{
     2059    releaser.release(m_expr);
     2060}
     2061
     2062// ------------------------------ ClauseListNode --------------------------------
     2063
     2064ClauseListNode::~ClauseListNode()
     2065{
     2066    NodeReleaser::releaseAllNodes(this);
     2067}
     2068
     2069void ClauseListNode::releaseNodes(NodeReleaser& releaser)
     2070{
     2071    releaser.release(m_clause);
     2072    releaser.release(m_next);
     2073}
     2074
    14192075// ------------------------------ CaseBlockNode --------------------------------
     2076
     2077CaseBlockNode::~CaseBlockNode()
     2078{
     2079    NodeReleaser::releaseAllNodes(this);
     2080}
     2081
     2082void CaseBlockNode::releaseNodes(NodeReleaser& releaser)
     2083{
     2084    releaser.release(m_list1);
     2085    releaser.release(m_defaultClause);
     2086    releaser.release(m_list2);
     2087}
     2088
    14202089enum SwitchKind {
    14212090    SwitchUnset = 0,
    … …  
    15612230// ------------------------------ SwitchNode -----------------------------------
    15622231
     2232SwitchNode::~SwitchNode()
     2233{
     2234    NodeReleaser::releaseAllNodes(this);
     2235}
     2236
     2237void SwitchNode::releaseNodes(NodeReleaser& releaser)
     2238{
     2239    releaser.release(m_expr);
     2240    releaser.release(m_block);
     2241}
     2242
    15632243RegisterID* SwitchNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    15642244{
    … …  
    15742254// ------------------------------ LabelNode ------------------------------------
    15752255
     2256LabelNode::~LabelNode()
     2257{
     2258    NodeReleaser::releaseAllNodes(this);
     2259}
     2260
     2261void LabelNode::releaseNodes(NodeReleaser& releaser)
     2262{
     2263    releaser.release(m_statement);
     2264}
     2265
    15762266RegisterID* LabelNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    15772267{
    … …  
    15872277
    15882278// ------------------------------ ThrowNode ------------------------------------
     2279
     2280ThrowNode::~ThrowNode()
     2281{
     2282    NodeReleaser::releaseAllNodes(this);
     2283}
     2284
     2285void ThrowNode::releaseNodes(NodeReleaser& releaser)
     2286{
     2287    releaser.release(m_expr);
     2288}
    15892289
    15902290RegisterID* ThrowNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    15992299
    16002300// ------------------------------ TryNode --------------------------------------
     2301
     2302TryNode::~TryNode()
     2303{
     2304    NodeReleaser::releaseAllNodes(this);
     2305}
     2306
     2307void TryNode::releaseNodes(NodeReleaser& releaser)
     2308{
     2309    releaser.release(m_tryBlock);
     2310    releaser.release(m_catchBlock);
     2311    releaser.release(m_finallyBlock);
     2312}
    16012313
    16022314RegisterID* TryNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    … …  
    16582370}
    16592371
     2372// ------------------------------ ParameterNode -----------------------------
     2373
     2374ParameterNode::~ParameterNode()
     2375{
     2376    NodeReleaser::releaseAllNodes(this);
     2377}
     2378
     2379void ParameterNode::releaseNodes(NodeReleaser& releaser)
     2380{
     2381    releaser.release(m_next);
     2382}
    16602383
    16612384// ------------------------------ ScopeNode -----------------------------
    … …  
    17372460FunctionBodyNode::~FunctionBodyNode()
    17382461{
    1739     if (m_parameters)
    1740         fastFree(m_parameters);
     2462    ASSERT(!m_refCount);
     2463    fastFree(m_parameters);
    17412464}
    17422465
    … …  
    18432566// ------------------------------ FuncDeclNode ---------------------------------
    18442567
     2568FuncDeclNode::~FuncDeclNode()
     2569{
     2570    NodeReleaser::releaseAllNodes(this);
     2571}
     2572
     2573void FuncDeclNode::releaseNodes(NodeReleaser& releaser)
     2574{
     2575    releaser.release(m_parameter);
     2576    releaser.release(m_body);
     2577}
     2578
    18452579JSFunction* FuncDeclNode::makeFunction(ExecState* exec, ScopeChainNode* scopeChain)
    18462580{
    … …  
    18542588
    18552589// ------------------------------ FuncExprNode ---------------------------------
     2590
     2591FuncExprNode::~FuncExprNode()
     2592{
     2593    NodeReleaser::releaseAllNodes(this);
     2594}
     2595
     2596void FuncExprNode::releaseNodes(NodeReleaser& releaser)
     2597{
     2598    releaser.release(m_parameter);
     2599    releaser.release(m_body);
     2600}
    18562601
    18572602RegisterID* FuncExprNode::emitCode(CodeGenerator& generator, RegisterID* dst)

  • trunk/JavaScriptCore/parser/Nodes.h

    r38209 r38247  
    3636#include "SymbolTable.h"
    3737#include "RegExp.h"
    38 #include <wtf/ListRefPtr.h>
    3938#include <wtf/MathExtras.h>
    4039#include <wtf/OwnPtr.h>
    … …  
    5655    class EvalCodeBlock;
    5756    class JSFunction;
     57    class NodeReleaser;
    5858    class ProgramCodeBlock;
    5959    class PropertyListNode;
    … …  
    136136
    137137    public:
     138        // Nonrecursive destruction.
     139        virtual void releaseNodes(NodeReleaser&);
     140
    138141        void ref() JSC_FAST_CALL;
    139142        void deref() JSC_FAST_CALL;
    … …  
    191194        virtual Precedence precedence() const = 0;
    192195        virtual bool needsParensIfLeftmost() const { return false; }
    193        
     196
    194197    protected:
    195198        int m_line;
    … …  
    478481        Identifier m_ident;
    479482        int32_t m_startOffset;
    480        
    481483    };
    482484
    … …  
    498500        }
    499501
     502        virtual ~ElementNode();
     503        virtual void releaseNodes(NodeReleaser&);
     504
    500505        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    501506        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    505510
    506511        ElementNode* next() { return m_next.get(); }
    507         PassRefPtr<ElementNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    508 
    509     private:
    510         ListRefPtr<ElementNode> m_next;
     512
     513    private:
     514        RefPtr<ElementNode> m_next;
    511515        int m_elision;
    512516        RefPtr<ExpressionNode> m_node;
    … …  
    537541        {
    538542        }
     543
     544        virtual ~ArrayNode();
     545        virtual void releaseNodes(NodeReleaser&);
    539546
    540547        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    561568        }
    562569
     570        virtual ~PropertyNode();
     571        virtual void releaseNodes(NodeReleaser&);
     572
    563573        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    564574        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    … …  
    588598        }
    589599
     600        virtual ~PropertyListNode();
     601        virtual void releaseNodes(NodeReleaser&);
     602
    590603        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    591604        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    592605        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    593 
    594         PassRefPtr<PropertyListNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    595606
    596607    private:
    597608        friend class ObjectLiteralNode;
    598609        RefPtr<PropertyNode> m_node;
    599         ListRefPtr<PropertyListNode> m_next;
     610        RefPtr<PropertyListNode> m_next;
    600611    };
    601612
    … …  
    612623        {
    613624        }
     625
     626        virtual ~ObjectLiteralNode();
     627        virtual void releaseNodes(NodeReleaser&);
    614628
    615629        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    631645        {
    632646        }
     647
     648        virtual ~BracketAccessorNode();
     649        virtual void releaseNodes(NodeReleaser&);
    633650
    634651        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    657674        }
    658675
     676        virtual ~DotAccessorNode();
     677        virtual void releaseNodes(NodeReleaser&);
     678
    659679        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    660680        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    686706        }
    687707
     708        virtual ~ArgumentListNode();
     709        virtual void releaseNodes(NodeReleaser&);
     710
    688711        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    689712        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    690713        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    691714
    692         PassRefPtr<ArgumentListNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    693 
    694         ListRefPtr<ArgumentListNode> m_next;
     715        RefPtr<ArgumentListNode> m_next;
    695716        RefPtr<ExpressionNode> m_expr;
    696717    };
    … …  
    709730        }
    710731
     732        virtual ~ArgumentsNode();
     733        virtual void releaseNodes(NodeReleaser&);
     734
    711735        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    712736        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    … …  
    730754        }
    731755
     756        virtual ~NewExprNode();
     757        virtual void releaseNodes(NodeReleaser&);
     758
    732759        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    733760
    … …  
    748775        {
    749776        }
     777
     778        virtual ~EvalFunctionCallNode();
     779        virtual void releaseNodes(NodeReleaser&);
    750780
    751781        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    767797        }
    768798
     799        virtual ~FunctionCallValueNode();
     800        virtual void releaseNodes(NodeReleaser&);
     801
    769802        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    770803        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    785818        {
    786819        }
     820
     821        virtual ~FunctionCallResolveNode();
     822        virtual void releaseNodes(NodeReleaser&);
    787823
    788824        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    809845        }
    810846
     847        virtual ~FunctionCallBracketNode();
     848        virtual void releaseNodes(NodeReleaser&);
     849
    811850        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    812851        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    830869        }
    831870
     871        virtual ~FunctionCallDotNode();
     872        virtual void releaseNodes(NodeReleaser&);
     873
    832874        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    833875        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    880922        }
    881923
     924        virtual ~PostfixBracketNode();
     925        virtual void releaseNodes(NodeReleaser&);
     926
    882927        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    883928        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    901946        }
    902947
     948        virtual ~PostfixDotNode();
     949        virtual void releaseNodes(NodeReleaser&);
     950
    903951        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    904952        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    921969        }
    922970
     971        virtual ~PostfixErrorNode();
     972        virtual void releaseNodes(NodeReleaser&);
     973
    923974        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    924975        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    9581009        }
    9591010
     1011        virtual ~DeleteBracketNode();
     1012        virtual void releaseNodes(NodeReleaser&);
     1013
    9601014        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    9611015
    … …  
    9781032        }
    9791033
     1034        virtual ~DeleteDotNode();
     1035        virtual void releaseNodes(NodeReleaser&);
     1036
    9801037        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    9811038
    … …  
    9961053        }
    9971054
     1055        virtual ~DeleteValueNode();
     1056        virtual void releaseNodes(NodeReleaser&);
     1057
    9981058        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    9991059
    … …  
    10121072        {
    10131073        }
     1074
     1075        virtual ~VoidNode();
     1076        virtual void releaseNodes(NodeReleaser&);
    10141077
    10151078        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    10491112        {
    10501113        }
     1114
     1115        virtual ~TypeOfValueNode();
     1116        virtual void releaseNodes(NodeReleaser&);
    10511117
    10521118        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    10871153        }
    10881154
     1155        virtual ~PrefixBracketNode();
     1156        virtual void releaseNodes(NodeReleaser&);
     1157
    10891158        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    10901159        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    11081177        }
    11091178
     1179        virtual ~PrefixDotNode();
     1180        virtual void releaseNodes(NodeReleaser&);
     1181
    11101182        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    11111183        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    11281200        }
    11291201
     1202        virtual ~PrefixErrorNode();
     1203        virtual void releaseNodes(NodeReleaser&);
     1204
    11301205        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    11311206        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    11501225        {
    11511226        }
     1227
     1228        virtual ~UnaryOpNode();
     1229        virtual void releaseNodes(NodeReleaser&);
    11521230
    11531231        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    12261304        }
    12271305
     1306        virtual ~BinaryOpNode();
     1307        virtual void releaseNodes(NodeReleaser&);
     1308
    12281309        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    12291310        virtual OpcodeID opcode() const JSC_FAST_CALL = 0;
    … …  
    12351316    };
    12361317
    1237     class ReverseBinaryOpNode : public ExpressionNode {
     1318    class ReverseBinaryOpNode : public BinaryOpNode {
    12381319    public:
    12391320        ReverseBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1240             : ExpressionNode(globalData)
    1241             , m_expr1(expr1)
    1242             , m_expr2(expr2)
    1243             , m_rightHasAssignments(rightHasAssignments)
     1321            : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    12441322        {
    12451323        }
    12461324
    12471325        ReverseBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1248             : ExpressionNode(globalData, type)
    1249             , m_expr1(expr1)
    1250             , m_expr2(expr2)
    1251             , m_rightHasAssignments(rightHasAssignments)
    1252         {
    1253         }
    1254 
    1255         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1256         virtual OpcodeID opcode() const JSC_FAST_CALL = 0;
    1257 
    1258     protected:
    1259         RefPtr<ExpressionNode> m_expr1;
    1260         RefPtr<ExpressionNode> m_expr2;
    1261         bool m_rightHasAssignments;
     1326            : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments)
     1327        {
     1328        }
     1329
     1330        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    12621331    };
    12631332
    … …  
    15441613        }
    15451614
     1615        virtual ~LogicalOpNode();
     1616        virtual void releaseNodes(NodeReleaser&);
     1617
    15461618        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    15471619        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    15661638        {
    15671639        }
     1640
     1641        virtual ~ConditionalNode();
     1642        virtual void releaseNodes(NodeReleaser&);
    15681643
    15691644        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    15891664        }
    15901665
     1666        virtual ~ReadModifyResolveNode();
     1667        virtual void releaseNodes(NodeReleaser&);
     1668
    15911669        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    15921670
    … …  
    16111689        {
    16121690        }
     1691
     1692        virtual ~AssignResolveNode();
     1693        virtual void releaseNodes(NodeReleaser&);
    16131694
    16141695        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    16381719        }
    16391720
     1721        virtual ~ReadModifyBracketNode();
     1722        virtual void releaseNodes(NodeReleaser&);
     1723
    16401724        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    16411725
    … …  
    16651749        }
    16661750
     1751        virtual ~AssignBracketNode();
     1752        virtual void releaseNodes(NodeReleaser&);
     1753
    16671754        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    16681755
    … …  
    16891776        {
    16901777        }
     1778
     1779        virtual ~AssignDotNode();
     1780        virtual void releaseNodes(NodeReleaser&);
    16911781
    16921782        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    17141804        }
    17151805
     1806        virtual ~ReadModifyDotNode();
     1807        virtual void releaseNodes(NodeReleaser&);
     1808
    17161809        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17171810
    … …  
    17381831        }
    17391832
     1833        virtual ~AssignErrorNode();
     1834        virtual void releaseNodes(NodeReleaser&);
     1835
    17401836        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17411837        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    17571853        }
    17581854
     1855        virtual ~CommaNode();
     1856        virtual void releaseNodes(NodeReleaser&);
     1857
    17591858        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17601859        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    17791878        ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in) JSC_FAST_CALL;
    17801879
     1880        virtual ~ConstDeclNode();
     1881        virtual void releaseNodes(NodeReleaser&);
     1882
    17811883        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    17821884        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    1783         PassRefPtr<ConstDeclNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    17841885
    17851886        Identifier m_ident;
    1786         ListRefPtr<ConstDeclNode> m_next;
     1887        RefPtr<ConstDeclNode> m_next;
    17871888        RefPtr<ExpressionNode> m_init;
    17881889       
    … …  
    17991900        }
    18001901
     1902        virtual ~ConstStatementNode();
     1903        virtual void releaseNodes(NodeReleaser&);
     1904
    18011905        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    18021906       
    … …  
    18281932        BlockNode(JSGlobalData*, SourceElements* children) JSC_FAST_CALL;
    18291933
     1934        virtual ~BlockNode();
     1935        virtual void releaseNodes(NodeReleaser&);
     1936
    18301937        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    18311938        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    18341941
    18351942        virtual bool isBlock() const JSC_FAST_CALL { return true; }
     1943
    18361944    protected:
    18371945        StatementVector m_children;
    … …  
    18861994        }
    18871995       
     1996        virtual ~VarStatementNode();
     1997        virtual void releaseNodes(NodeReleaser&);
     1998
    18881999        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    18892000
    … …  
    19032014        }
    19042015
     2016        virtual ~IfNode();
     2017        virtual void releaseNodes(NodeReleaser&);
     2018
    19052019        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    19062020        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    19182032        {
    19192033        }
     2034
     2035        virtual ~IfElseNode();
     2036        virtual void releaseNodes(NodeReleaser&);
    19202037
    19212038        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    19352052        }
    19362053
     2054        virtual ~DoWhileNode();
     2055        virtual void releaseNodes(NodeReleaser&);
     2056
    19372057        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    19382058        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    19392059
    19402060        virtual bool isLoop() const JSC_FAST_CALL { return true; }
     2061
    19412062    private:
    19422063        RefPtr<StatementNode> m_statement;
    … …  
    19532074        }
    19542075
     2076        virtual ~WhileNode();
     2077        virtual void releaseNodes(NodeReleaser&);
     2078
    19552079        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    19562080        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    19572081
    19582082        virtual bool isLoop() const JSC_FAST_CALL { return true; }
     2083
    19592084    private:
    19602085        RefPtr<ExpressionNode> m_expr;
    … …  
    19752100        }
    19762101
     2102        virtual ~ForNode();
     2103        virtual void releaseNodes(NodeReleaser&);
     2104
    19772105        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    19782106        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    19792107
    19802108        virtual bool isLoop() const JSC_FAST_CALL { return true; }
     2109
    19812110    private:
    19822111        RefPtr<ExpressionNode> m_expr1;
    … …  
    19922121        ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset) JSC_FAST_CALL;
    19932122       
     2123        virtual ~ForInNode();
     2124        virtual void releaseNodes(NodeReleaser&);
     2125
    19942126        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    19952127        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    19962128
    19972129        virtual bool isLoop() const JSC_FAST_CALL { return true; }
     2130
    19982131    private:
    19992132        Identifier m_ident;
    … …  
    20532186        }
    20542187
     2188        virtual ~ReturnNode();
     2189        virtual void releaseNodes(NodeReleaser&);
     2190
    20552191        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    20562192        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    20722208        }
    20732209
     2210        virtual ~WithNode();
     2211        virtual void releaseNodes(NodeReleaser&);
     2212
    20742213        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    20752214        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    20912230        }
    20922231
     2232        virtual ~LabelNode();
     2233        virtual void releaseNodes(NodeReleaser&);
     2234
    20932235        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    20942236        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    … …  
    21062248        {
    21072249        }
     2250
     2251        virtual ~ThrowNode();
     2252        virtual void releaseNodes(NodeReleaser&);
    21082253
    21092254        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    21252270        }
    21262271
     2272        virtual ~TryNode();
     2273        virtual void releaseNodes(NodeReleaser&);
     2274
    21272275        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    21282276
    … …  
    21512299        }
    21522300
     2301        virtual ~ParameterNode();
     2302        virtual void releaseNodes(NodeReleaser&);
     2303
    21532304        Identifier ident() JSC_FAST_CALL { return m_ident; }
    21542305        ParameterNode *nextParam() JSC_FAST_CALL { return m_next.get(); }
    21552306        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    2156         PassRefPtr<ParameterNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    21572307        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    21582308
    … …  
    21612311        friend class FuncExprNode;
    21622312        Identifier m_ident;
    2163         ListRefPtr<ParameterNode> m_next;
     2313        RefPtr<ParameterNode> m_next;
    21642314    };
    21652315
    … …  
    23252475        }
    23262476
     2477        virtual ~FuncExprNode();
     2478        virtual void releaseNodes(NodeReleaser&);
     2479
    23272480        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    23282481        JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
    … …  
    23522505        }
    23532506
     2507        virtual ~FuncDeclNode();
     2508        virtual void releaseNodes(NodeReleaser&);
     2509
    23542510        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    23552511
    … …  
    23822538        }
    23832539
     2540        virtual ~CaseClauseNode();
     2541        virtual void releaseNodes(NodeReleaser&);
     2542
    23842543        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    23852544        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    … …  
    24082567        }
    24092568
     2569        virtual ~ClauseListNode();
     2570        virtual void releaseNodes(NodeReleaser&);
     2571
    24102572        CaseClauseNode* getClause() const JSC_FAST_CALL { return m_clause.get(); }
    24112573        ClauseListNode* getNext() const JSC_FAST_CALL { return m_next.get(); }
    24122574        virtual void streamTo(SourceStream&) const JSC_FAST_CALL;
    2413         PassRefPtr<ClauseListNode> releaseNext() JSC_FAST_CALL { return m_next.release(); }
    24142575        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    24152576
    … …  
    24172578        friend class CaseBlockNode;
    24182579        RefPtr<CaseClauseNode> m_clause;
    2419         ListRefPtr<ClauseListNode> m_next;
     2580        RefPtr<ClauseListNode> m_next;
    24202581    };
    24212582
    … …  
    24302591        }
    24312592
     2593        virtual ~CaseBlockNode();
     2594        virtual void releaseNodes(NodeReleaser&);
     2595
    24322596        RegisterID* emitCodeForBlock(CodeGenerator&, RegisterID* input, RegisterID* dst = 0) JSC_FAST_CALL;
    24332597
    … …  
    24512615        }
    24522616
     2617        virtual ~SwitchNode();
     2618        virtual void releaseNodes(NodeReleaser&);
     2619
    24532620        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    24542621
Note: See TracChangeset for help on using the changeset viewer.