Changeset 127654 in webkit


Ignore:
Timestamp:
Sep 5, 2012 4:00:29 PM (12 years ago)
Author:
barraclough@apple.com
Message:

Merge prefix/postfix nodes
​https://bugs.webkit.org/show_bug.cgi?id=95898

Reviewed by Geoff Garen.

Simplify the AST.
This will also mean we have access to m_subscriptHasAssignments when generating a prefix/postfix op applied to a bracket access.

  • bytecompiler/NodesCodegen.cpp:

(JSC::PostfixNode::emitResolve):

  • was PostfixResolveNode::emitBytecode

(JSC::PostfixNode::emitBracket):

  • was PostfixBracketNode::emitBytecode

(JSC::PostfixNode::emitDot):

  • was PostfixDotNode::emitBytecode

(JSC::PostfixNode::emitBytecode):

  • was PostfixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.

(JSC::PrefixNode::emitResolve):

  • was PrefixResolveNode::emitBytecode

(JSC::PrefixNode::emitBracket):

  • was PrefixBracketNode::emitBytecode

(JSC::PrefixNode::emitDot):

  • was PrefixDotNode::emitBytecode

(JSC::PrefixNode::emitBytecode):

  • was PrefixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
  • parser/ASTBuilder.h:

(JSC::ASTBuilder::makePrefixNode):

  • Just makes a PrefixNode!

(JSC::ASTBuilder::makePostfixNode):

  • Just makes a PostfixNode!
  • parser/NodeConstructors.h:

(JSC::PostfixNode::PostfixNode):

  • Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.

(JSC::PrefixNode::PrefixNode):

  • Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
  • parser/Nodes.h:

(PostfixNode):

  • Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.

(PrefixNode):

  • Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
Location:
trunk/Source/JavaScriptCore
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r127648 r127654  
     12012-09-05  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Merge prefix/postfix nodes
     4        https://bugs.webkit.org/show_bug.cgi?id=95898
     5
     6        Reviewed by Geoff Garen.
     7
     8        Simplify the AST.
     9        This will also mean we have access to m_subscriptHasAssignments when generating a prefix/postfix op applied to a bracket access.
     10
     11        * bytecompiler/NodesCodegen.cpp:
     12        (JSC::PostfixNode::emitResolve):
     13            - was PostfixResolveNode::emitBytecode
     14        (JSC::PostfixNode::emitBracket):
     15            - was PostfixBracketNode::emitBytecode
     16        (JSC::PostfixNode::emitDot):
     17            - was PostfixDotNode::emitBytecode
     18        (JSC::PostfixNode::emitBytecode):
     19            - was PostfixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
     20        (JSC::PrefixNode::emitResolve):
     21            - was PrefixResolveNode::emitBytecode
     22        (JSC::PrefixNode::emitBracket):
     23            - was PrefixBracketNode::emitBytecode
     24        (JSC::PrefixNode::emitDot):
     25            - was PrefixDotNode::emitBytecode
     26        (JSC::PrefixNode::emitBytecode):
     27            - was PrefixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
     28        * parser/ASTBuilder.h:
     29        (JSC::ASTBuilder::makePrefixNode):
     30            - Just makes a PrefixNode!
     31        (JSC::ASTBuilder::makePostfixNode):
     32            - Just makes a PostfixNode!
     33        * parser/NodeConstructors.h:
     34        (JSC::PostfixNode::PostfixNode):
     35            - Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.
     36        (JSC::PrefixNode::PrefixNode):
     37            - Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
     38        * parser/Nodes.h:
     39        (PostfixNode):
     40            - Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.
     41        (PrefixNode):
     42            - Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
     43
    1442012-09-05  Mark Hahnenberg  <mhahnenberg@apple.com>
    245

  • trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

    r127647 r127654  
    591591}
    592592
    593 // ------------------------------ PostfixResolveNode ----------------------------------
     593// ------------------------------ PostfixNode ----------------------------------
    594594
    595595static RegisterID* emitPreIncOrDec(BytecodeGenerator& generator, RegisterID* srcDst, Operator oper)
    … …  
    605605}
    606606
    607 RegisterID* PostfixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    608 {
    609     ResolveResult resolveResult = generator.resolve(m_ident);
     607RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
     608{
     609    ASSERT(m_expr->isResolveNode());
     610    ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
     611    const Identifier& ident = resolve->identifier();
     612
     613    ResolveResult resolveResult = generator.resolve(ident);
    610614
    611615    if (RegisterID* local = resolveResult.local()) {
    … …  
    620624
    621625    if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
    622         RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, m_ident);
     626        RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, ident);
    623627        RegisterID* oldValue;
    624628        if (dst == generator.ignoredResult()) {
    … …  
    628632            oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    629633        }
    630         generator.emitPutStaticVar(resolveResult, m_ident, value.get());
     634        generator.emitPutStaticVar(resolveResult, ident, value.get());
    631635        return oldValue;
    632636    }
    … …  
    634638    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    635639    RefPtr<RegisterID> value = generator.newTemporary();
    636     RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), value.get(), resolveResult, m_ident);
     640    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), value.get(), resolveResult, ident);
    637641    RegisterID* oldValue;
    638642    if (dst == generator.ignoredResult()) {
    … …  
    642646        oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    643647    }
    644     generator.emitPutById(base.get(), m_ident, value.get());
     648    generator.emitPutById(base.get(), ident, value.get());
    645649    return oldValue;
    646650}
    647651
    648 // ------------------------------ PostfixBracketNode ----------------------------------
    649 
    650 RegisterID* PostfixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    651 {
    652     RefPtr<RegisterID> base = generator.emitNode(m_base);
    653     RefPtr<RegisterID> property = generator.emitNode(m_subscript);
    654 
    655     generator.emitExpressionInfo(divot() - m_subexpressionDivotOffset, startOffset() - m_subexpressionDivotOffset, m_subexpressionEndOffset);
     652RegisterID* PostfixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
     653{
     654    ASSERT(m_expr->isBracketAccessorNode());
     655    BracketAccessorNode* bracketAccessor = static_cast<BracketAccessorNode*>(m_expr);
     656    ExpressionNode* baseNode = bracketAccessor->base();
     657    ExpressionNode* subscript = bracketAccessor->subscript();
     658
     659    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     660    RefPtr<RegisterID> property = generator.emitNode(subscript);
     661
     662    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->startOffset(), bracketAccessor->endOffset());
    656663    RefPtr<RegisterID> value = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
    657664    RegisterID* oldValue;
    … …  
    670677}
    671678
    672 // ------------------------------ PostfixDotNode ----------------------------------
    673 
    674 RegisterID* PostfixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    675 {
    676     RefPtr<RegisterID> base = generator.emitNode(m_base);
    677 
    678     generator.emitExpressionInfo(divot() - m_subexpressionDivotOffset, startOffset() - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    679     RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), m_ident);
     679RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
     680{
     681    ASSERT(m_expr->isDotAccessorNode());
     682    DotAccessorNode* dotAccessor = static_cast<DotAccessorNode*>(m_expr);
     683    ExpressionNode* baseNode = dotAccessor->base();
     684    const Identifier& ident = dotAccessor->identifier();
     685
     686    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     687
     688    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->startOffset(), dotAccessor->endOffset());
     689    RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), ident);
    680690    RegisterID* oldValue;
    681691    if (dst == generator.ignoredResult()) {
    … …  
    689699    }
    690700    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    691     generator.emitPutById(base.get(), m_ident, value.get());
     701    generator.emitPutById(base.get(), ident, value.get());
    692702    return oldValue;
    693703}
    694704
    695 // ------------------------------ PostfixErrorNode -----------------------------------
    696 
    697 RegisterID* PostfixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    698 {
     705RegisterID* PostfixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
     706{
     707    if (m_expr->isResolveNode())
     708        return emitResolve(generator, dst);
     709
     710    if (m_expr->isBracketAccessorNode())
     711        return emitBracket(generator, dst);
     712
     713    if (m_expr->isDotAccessorNode())
     714        return emitDot(generator, dst);
     715
    699716    return emitThrowReferenceError(generator, m_operator == OpPlusPlus
    700717        ? "Postfix ++ operator applied to value that is not a reference."
    … …  
    788805}
    789806
    790 // ------------------------------ PrefixResolveNode ----------------------------------
    791 
    792 RegisterID* PrefixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    793 {
    794     ResolveResult resolveResult = generator.resolve(m_ident);
     807// ------------------------------ PrefixNode ----------------------------------
     808
     809RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
     810{
     811    ASSERT(m_expr->isResolveNode());
     812    ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
     813    const Identifier& ident = resolve->identifier();
     814
     815    ResolveResult resolveResult = generator.resolve(ident);
    795816    if (RegisterID* local = resolveResult.local()) {
    796817        if (resolveResult.isReadOnly()) {
    … …  
    807828
    808829    if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
    809         RefPtr<RegisterID> propDst = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, m_ident);
     830        RefPtr<RegisterID> propDst = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, ident);
    810831        emitPreIncOrDec(generator, propDst.get(), m_operator);
    811         generator.emitPutStaticVar(resolveResult, m_ident, propDst.get());
     832        generator.emitPutStaticVar(resolveResult, ident, propDst.get());
    812833        return generator.moveToDestinationIfNeeded(dst, propDst.get());
    813834    }
    … …  
    815836    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    816837    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    817     RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), propDst.get(), resolveResult, m_ident);
     838    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), propDst.get(), resolveResult, ident);
    818839    emitPreIncOrDec(generator, propDst.get(), m_operator);
    819     generator.emitPutById(base.get(), m_ident, propDst.get());
     840    generator.emitPutById(base.get(), ident, propDst.get());
    820841    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    821842}
    822843
    823 // ------------------------------ PrefixBracketNode ----------------------------------
    824 
    825 RegisterID* PrefixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    826 {
    827     RefPtr<RegisterID> base = generator.emitNode(m_base);
    828     RefPtr<RegisterID> property = generator.emitNode(m_subscript);
     844RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
     845{
     846    ASSERT(m_expr->isBracketAccessorNode());
     847    BracketAccessorNode* bracketAccessor = static_cast<BracketAccessorNode*>(m_expr);
     848    ExpressionNode* baseNode = bracketAccessor->base();
     849    ExpressionNode* subscript = bracketAccessor->subscript();
     850
     851    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     852    RefPtr<RegisterID> property = generator.emitNode(subscript);
    829853    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    830854
    831     generator.emitExpressionInfo(divot() + m_subexpressionDivotOffset, m_subexpressionStartOffset, endOffset() - m_subexpressionDivotOffset);
     855    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->startOffset(), bracketAccessor->endOffset());
    832856    RegisterID* value = generator.emitGetByVal(propDst.get(), base.get(), property.get());
    833857    if (m_operator == OpPlusPlus)
    … …  
    840864}
    841865
    842 // ------------------------------ PrefixDotNode ----------------------------------
    843 
    844 RegisterID* PrefixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    845 {
    846     RefPtr<RegisterID> base = generator.emitNode(m_base);
     866RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
     867{
     868    ASSERT(m_expr->isDotAccessorNode());
     869    DotAccessorNode* dotAccessor = static_cast<DotAccessorNode*>(m_expr);
     870    ExpressionNode* baseNode = dotAccessor->base();
     871    const Identifier& ident = dotAccessor->identifier();
     872
     873    RefPtr<RegisterID> base = generator.emitNode(baseNode);
    847874    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    848875
    849     generator.emitExpressionInfo(divot() + m_subexpressionDivotOffset, m_subexpressionStartOffset, endOffset() - m_subexpressionDivotOffset);
    850     RegisterID* value = generator.emitGetById(propDst.get(), base.get(), m_ident);
     876    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->startOffset(), dotAccessor->endOffset());
     877    RegisterID* value = generator.emitGetById(propDst.get(), base.get(), ident);
    851878    if (m_operator == OpPlusPlus)
    852879        generator.emitPreInc(value);
    … …  
    854881        generator.emitPreDec(value);
    855882    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    856     generator.emitPutById(base.get(), m_ident, value);
     883    generator.emitPutById(base.get(), ident, value);
    857884    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    858885}
    859886
    860 // ------------------------------ PrefixErrorNode -----------------------------------
    861 
    862 RegisterID* PrefixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    863 {
     887RegisterID* PrefixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
     888{
     889    if (m_expr->isResolveNode())
     890        return emitResolve(generator, dst);
     891
     892    if (m_expr->isBracketAccessorNode())
     893        return emitBracket(generator, dst);
     894
     895    if (m_expr->isDotAccessorNode())
     896        return emitDot(generator, dst);
     897
    864898    return emitThrowReferenceError(generator, m_operator == OpPlusPlus
    865899        ? "Prefix ++ operator applied to value that is not a reference."

  • trunk/Source/JavaScriptCore/parser/ASTBuilder.h

    r124729 r127654  
    944944ExpressionNode* ASTBuilder::makePrefixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator op, int start, int divot, int end)
    945945{
    946     if (!expr->isLocation())
    947         return new (m_globalData) PrefixErrorNode(location, op, divot, divot - start, end - divot);
    948 
    949     if (expr->isResolveNode()) {
    950         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    951         return new (m_globalData) PrefixResolveNode(location, resolve->identifier(), op, divot, divot - start, end - divot);
    952     }
    953     if (expr->isBracketAccessorNode()) {
    954         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    955         PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(location, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    956         node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
    957         return node;
    958     }
    959     ASSERT(expr->isDotAccessorNode());
    960     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    961     PrefixDotNode* node = new (m_globalData) PrefixDotNode(location, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    962     node->setSubexpressionInfo(dot->divot(), dot->startOffset());
    963     return node;
     946    return new (m_globalData) PrefixNode(location, expr, op, divot, divot - start, end - divot);
    964947}
    965948
    966949ExpressionNode* ASTBuilder::makePostfixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator op, int start, int divot, int end)
    967950{
    968     if (!expr->isLocation())
    969         return new (m_globalData) PostfixErrorNode(location, op, divot, divot - start, end - divot);
    970 
    971     if (expr->isResolveNode()) {
    972         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    973         return new (m_globalData) PostfixResolveNode(location, resolve->identifier(), op, divot, divot - start, end - divot);
    974     }
    975     if (expr->isBracketAccessorNode()) {
    976         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    977         PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(location, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    978         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    979         return node;
    980 
    981     }
    982     ASSERT(expr->isDotAccessorNode());
    983     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    984     PostfixDotNode* node = new (m_globalData) PostfixDotNode(location, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    985     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    986     return node;
     951    return new (m_globalData) PostfixNode(location, expr, op, divot, divot - start, end - divot);
    987952}
    988953

  • trunk/Source/JavaScriptCore/parser/NodeConstructors.h

    r124729 r127654  
    288288    }
    289289
    290     inline PrePostResolveNode::PrePostResolveNode(const JSTokenLocation& location, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
    291         : ExpressionNode(location, ResultType::numberType()) // could be reusable for pre?
    292         , ThrowableExpressionData(divot, startOffset, endOffset)
    293         , m_ident(ident)
    294     {
    295     }
    296 
    297     inline PostfixResolveNode::PostfixResolveNode(const JSTokenLocation& location, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    298         : PrePostResolveNode(location, ident, divot, startOffset, endOffset)
    299         , m_operator(oper)
    300     {
    301     }
    302 
    303     inline PostfixBracketNode::PostfixBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    304         : ExpressionNode(location)
    305         , ThrowableSubExpressionData(divot, startOffset, endOffset)
    306         , m_base(base)
    307         , m_subscript(subscript)
    308         , m_operator(oper)
    309     {
    310     }
    311 
    312     inline PostfixDotNode::PostfixDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    313         : ExpressionNode(location)
    314         , ThrowableSubExpressionData(divot, startOffset, endOffset)
    315         , m_base(base)
    316         , m_ident(ident)
    317         , m_operator(oper)
    318     {
    319     }
    320 
    321     inline PostfixErrorNode::PostfixErrorNode(const JSTokenLocation& location, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    322         : ExpressionNode(location)
    323         , ThrowableSubExpressionData(divot, startOffset, endOffset)
     290    inline PostfixNode::PostfixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     291        : ExpressionNode(location)
     292        , ThrowableExpressionData(divot, startOffset, endOffset)
     293        , m_expr(expr)
    324294        , m_operator(oper)
    325295    {
    … …  
    373343    }
    374344
    375     inline PrefixResolveNode::PrefixResolveNode(const JSTokenLocation& location, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    376         : PrePostResolveNode(location, ident, divot, startOffset, endOffset)
    377         , m_operator(oper)
    378     {
    379     }
    380 
    381     inline PrefixBracketNode::PrefixBracketNode(const JSTokenLocation& location, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     345    inline PrefixNode::PrefixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    382346        : ExpressionNode(location)
    383347        , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    384         , m_base(base)
    385         , m_subscript(subscript)
    386         , m_operator(oper)
    387     {
    388     }
    389 
    390     inline PrefixDotNode::PrefixDotNode(const JSTokenLocation& location, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    391         : ExpressionNode(location)
    392         , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    393         , m_base(base)
    394         , m_ident(ident)
    395         , m_operator(oper)
    396     {
    397     }
    398 
    399     inline PrefixErrorNode::PrefixErrorNode(const JSTokenLocation& location, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    400         : ExpressionNode(location)
    401         , ThrowableExpressionData(divot, startOffset, endOffset)
     348        , m_expr(expr)
    402349        , m_operator(oper)
    403350    {

  • trunk/Source/JavaScriptCore/parser/Nodes.h

    r127202 r127654  
    595595    };
    596596
    597     class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
    598     public:
    599         PrePostResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    600 
    601     protected:
     597    class PostfixNode : public ExpressionNode, public ThrowableExpressionData {
     598    public:
     599        PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     600
     601    private:
     602        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     603        virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
     604        virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
     605        virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
     606
     607        ExpressionNode* m_expr;
     608        Operator m_operator;
     609    };
     610
     611    class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     612    public:
     613        DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
     614
     615    private:
     616        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     617
    602618        const Identifier& m_ident;
    603619    };
    604620
    605     class PostfixResolveNode : public PrePostResolveNode {
    606     public:
    607         PostfixResolveNode(const JSTokenLocation&, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    608 
    609     private:
    610         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    611 
    612         Operator m_operator;
    613     };
    614 
    615     class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    616     public:
    617         PostfixBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     621    class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     622    public:
     623        DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
    618624
    619625    private:
    … …  
    622628        ExpressionNode* m_base;
    623629        ExpressionNode* m_subscript;
    624         Operator m_operator;
    625     };
    626 
    627     class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    628     public:
    629         PostfixDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     630    };
     631
     632    class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     633    public:
     634        DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    630635
    631636    private:
    … …  
    634639        ExpressionNode* m_base;
    635640        const Identifier& m_ident;
    636         Operator m_operator;
    637     };
    638 
    639     class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
    640     public:
    641         PostfixErrorNode(const JSTokenLocation&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    642 
    643     private:
    644         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    645 
    646         Operator m_operator;
    647     };
    648 
    649     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
    650     public:
    651         DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
     641    };
     642
     643    class DeleteValueNode : public ExpressionNode {
     644    public:
     645        DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
     646
     647    private:
     648        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     649
     650        ExpressionNode* m_expr;
     651    };
     652
     653    class VoidNode : public ExpressionNode {
     654    public:
     655        VoidNode(const JSTokenLocation&, ExpressionNode*);
     656
     657    private:
     658        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     659
     660        ExpressionNode* m_expr;
     661    };
     662
     663    class TypeOfResolveNode : public ExpressionNode {
     664    public:
     665        TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
     666
     667        const Identifier& identifier() const { return m_ident; }
    652668
    653669    private:
    … …  
    657673    };
    658674
    659     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
    660     public:
    661         DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
    662 
    663     private:
    664         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    665 
    666         ExpressionNode* m_base;
    667         ExpressionNode* m_subscript;
    668     };
    669 
    670     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
    671     public:
    672         DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    673 
    674     private:
    675         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    676 
    677         ExpressionNode* m_base;
    678         const Identifier& m_ident;
    679     };
    680 
    681     class DeleteValueNode : public ExpressionNode {
    682     public:
    683         DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
    684 
    685     private:
    686         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    687 
    688         ExpressionNode* m_expr;
    689     };
    690 
    691     class VoidNode : public ExpressionNode {
    692     public:
    693         VoidNode(const JSTokenLocation&, ExpressionNode*);
    694 
    695     private:
    696         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    697 
    698         ExpressionNode* m_expr;
    699     };
    700 
    701     class TypeOfResolveNode : public ExpressionNode {
    702     public:
    703         TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
    704 
    705         const Identifier& identifier() const { return m_ident; }
    706 
    707     private:
    708         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    709 
    710         const Identifier& m_ident;
    711     };
    712 
    713675    class TypeOfValueNode : public ExpressionNode {
    714676    public:
    … …  
    721683    };
    722684
    723     class PrefixResolveNode : public PrePostResolveNode {
    724     public:
    725         PrefixResolveNode(const JSTokenLocation&, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    726 
    727     private:
    728         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    729 
    730         Operator m_operator;
    731     };
    732 
    733     class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    734     public:
    735         PrefixBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    736 
    737     private:
    738         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    739 
    740         ExpressionNode* m_base;
    741         ExpressionNode* m_subscript;
    742         Operator m_operator;
    743     };
    744 
    745     class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    746     public:
    747         PrefixDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    748 
    749     private:
    750         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    751 
    752         ExpressionNode* m_base;
    753         const Identifier& m_ident;
    754         Operator m_operator;
    755     };
    756 
    757     class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
    758     public:
    759         PrefixErrorNode(const JSTokenLocation&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    760 
    761     private:
    762         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    763 
     685    class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     686    public:
     687        PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     688
     689    private:
     690        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     691        virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
     692        virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
     693        virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
     694
     695        ExpressionNode* m_expr;
    764696        Operator m_operator;
    765697    };
Note: See TracChangeset for help on using the changeset viewer.