Changeset 29825 in webkit for trunk/JavaScriptCore/kjs/nodes.h


Ignore:
Timestamp:
Jan 27, 2008, 4:14:24 PM (17 years ago)
Author:
[email protected]
Message:

Reviewed by Oliver Hunt.

Patch for ​http://bugs.webkit.org/show_bug.cgi?id=17025
nodes.h/cpp has been rolling around in the mud - lets hose it down

  • Rename member variables to use the m_ prefix.

(NOTE: Specific changed functions elided for space and clarity)

  • kjs/grammar.y:
  • kjs/nodes.cpp:
  • kjs/nodes.h:
  • kjs/nodes2string.cpp:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/nodes.h

    r29818 r29825  
    207207    int lastLine() const KJS_FAST_CALL { return m_lastLine; }
    208208    virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
    209     void pushLabel(const Identifier &id) KJS_FAST_CALL { ls.push(id); }
     209    void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_labelStack.push(ident); }
    210210    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    211211    virtual bool isEmptyStatement() const KJS_FAST_CALL { return false; }
    212212  protected:
    213     LabelStack ls;
     213    LabelStack m_labelStack;
    214214  private:
    215215    int m_lastLine;
    … …  
    316316  class ResolveNode : public ExpressionNode {
    317317  public:
    318     ResolveNode(const Identifier &s) KJS_FAST_CALL
    319         : ident(s)
     318    ResolveNode(const Identifier& ident) KJS_FAST_CALL
     319        : m_ident(ident)
    320320    {
    321321    }
    … …  
    324324    ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
    325325        : ExpressionNode(PlacementNewAdopt)
    326         , ident(PlacementNewAdopt)
     326        , m_ident(PlacementNewAdopt)
    327327    {
    328328    }
    … …  
    340340    virtual bool isLocation() const KJS_FAST_CALL { return true; }
    341341    virtual bool isResolveNode() const KJS_FAST_CALL { return true; }
    342     const Identifier& identifier() const KJS_FAST_CALL { return ident; }
     342    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
    343343
    344344  protected:
    345345    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    346     Identifier ident;
    347     size_t index; // Used by LocalVarAccessNode.
     346    Identifier m_ident;
     347    size_t m_index; // Used by LocalVarAccessNode.
    348348  };
    349349
    … …  
    355355    {
    356356        ASSERT(i != missingSymbolMarker());
    357         index = i;
     357        m_index = i;
    358358    }
    359359    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    368368  class ElementNode : public Node {
    369369  public:
    370     ElementNode(int e, ExpressionNode* n) KJS_FAST_CALL : elision(e), node(n) { }
    371     ElementNode(ElementNode* l, int e, ExpressionNode* n) KJS_FAST_CALL
    372       : elision(e), node(n) { l->next = this; }
     370    ElementNode(int elision, ExpressionNode* node) KJS_FAST_CALL
     371      : m_elision(elision), m_node(node) { }
     372    ElementNode(ElementNode* l, int elision, ExpressionNode* node) KJS_FAST_CALL
     373      : m_elision(elision), m_node(node) { l->m_next = this; }
    373374    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    374375    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    375376    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    376377
    377     PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return next.release(); }
     378    PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
    378379
    379380    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    381382  private:
    382383    friend class ArrayNode;
    383     ListRefPtr<ElementNode> next;
    384     int elision;
    385     RefPtr<ExpressionNode> node;
     384    ListRefPtr<ElementNode> m_next;
     385    int m_elision;
     386    RefPtr<ExpressionNode> m_node;
    386387  };
    387388
    388389  class ArrayNode : public ExpressionNode {
    389390  public:
    390     ArrayNode(int e) KJS_FAST_CALL : elision(e), opt(true) { }
    391     ArrayNode(ElementNode* ele) KJS_FAST_CALL
    392       : element(ele), elision(0), opt(false) { }
    393     ArrayNode(int eli, ElementNode* ele) KJS_FAST_CALL
    394       : element(ele), elision(eli), opt(true) { }
     391    ArrayNode(int e) KJS_FAST_CALL
     392      : m_elision(e), m_opt(true) { }
     393    ArrayNode(ElementNode* element) KJS_FAST_CALL
     394      : m_element(element), m_elision(0), m_opt(false) { }
     395    ArrayNode(int elision, ElementNode* element) KJS_FAST_CALL
     396      : m_element(element), m_elision(elision), m_opt(true) { }
    395397    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    396398    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    398400    virtual Precedence precedence() const { return PrecPrimary; }
    399401  private:
    400     RefPtr<ElementNode> element;
    401     int elision;
    402     bool opt;
     402    RefPtr<ElementNode> m_element;
     403    int m_elision;
     404    bool m_opt;
    403405  };
    404406
    … …  
    407409    enum Type { Constant, Getter, Setter };
    408410    PropertyNode(const Identifier& n, ExpressionNode* a, Type t) KJS_FAST_CALL
    409       : m_name(n), assign(a), type(t) { }
     411      : m_name(n), m_assign(a), m_type(t) { }
    410412    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    411413    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    418420    friend class PropertyListNode;
    419421    Identifier m_name;
    420     RefPtr<ExpressionNode> assign;
    421     Type type;
     422    RefPtr<ExpressionNode> m_assign;
     423    Type m_type;
    422424  };
    423425 
    424426  class PropertyListNode : public Node {
    425427  public:
    426     PropertyListNode(PropertyNode* n) KJS_FAST_CALL
    427       : node(n) { }
    428     PropertyListNode(PropertyNode* n, PropertyListNode* l) KJS_FAST_CALL
    429       : node(n) { l->next = this; }
     428    PropertyListNode(PropertyNode* node) KJS_FAST_CALL
     429      : m_node(node) { }
     430    PropertyListNode(PropertyNode* node, PropertyListNode* list) KJS_FAST_CALL
     431      : m_node(node) { list->m_next = this; }
    430432    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    431433    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    433435
    434436    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    435     PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
     437    PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
    436438
    437439  private:
    438440    friend class ObjectLiteralNode;
    439     RefPtr<PropertyNode> node;
    440     ListRefPtr<PropertyListNode> next;
     441    RefPtr<PropertyNode> m_node;
     442    ListRefPtr<PropertyListNode> m_next;
    441443  };
    442444
    … …  
    444446  public:
    445447    ObjectLiteralNode() KJS_FAST_CALL { }
    446     ObjectLiteralNode(PropertyListNode* l) KJS_FAST_CALL : list(l) { }
     448    ObjectLiteralNode(PropertyListNode* list) KJS_FAST_CALL : m_list(list) { }
    447449    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    448450    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    451453    virtual bool needsParensIfLeftmost() const { return true; }
    452454  private:
    453     RefPtr<PropertyListNode> list;
     455    RefPtr<PropertyListNode> m_list;
    454456  };
    455457
    456458  class BracketAccessorNode : public ExpressionNode {
    457459  public:
    458     BracketAccessorNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2) {}
     460    BracketAccessorNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     461      : m_base(base), m_subscript(subscript) { }
    459462    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    460463    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    468471    virtual bool isLocation() const KJS_FAST_CALL { return true; }
    469472    virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
    470     ExpressionNode* base() KJS_FAST_CALL { return expr1.get(); }
    471     ExpressionNode* subscript() KJS_FAST_CALL { return expr2.get(); }
     473    ExpressionNode* base() KJS_FAST_CALL { return m_base.get(); }
     474    ExpressionNode* subscript() KJS_FAST_CALL { return m_subscript.get(); }
    472475
    473476  private:
    474477    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    475     RefPtr<ExpressionNode> expr1;
    476     RefPtr<ExpressionNode> expr2;
     478    RefPtr<ExpressionNode> m_base;
     479    RefPtr<ExpressionNode> m_subscript;
    477480  };
    478481
    479482  class DotAccessorNode : public ExpressionNode {
    480483  public:
    481     DotAccessorNode(ExpressionNode* e, const Identifier& s) KJS_FAST_CALL : expr(e), ident(s) { }
     484    DotAccessorNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL : m_base(base), m_ident(ident) { }
    482485    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    483486    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    491494    virtual bool isLocation() const KJS_FAST_CALL { return true; }
    492495    virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; }
    493     ExpressionNode* base() const KJS_FAST_CALL { return expr.get(); }
    494     const Identifier& identifier() const KJS_FAST_CALL { return ident; }
     496    ExpressionNode* base() const KJS_FAST_CALL { return m_base.get(); }
     497    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
    495498
    496499  private:
    497500    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    498     RefPtr<ExpressionNode> expr;
    499     Identifier ident;
     501    RefPtr<ExpressionNode> m_base;
     502    Identifier m_ident;
    500503  };
    501504
    502505  class ArgumentListNode : public Node {
    503506  public:
    504     ArgumentListNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
    505     ArgumentListNode(ArgumentListNode* l, ExpressionNode* e) KJS_FAST_CALL
    506       : expr(e) { l->next = this; }
     507    ArgumentListNode(ExpressionNode* expr) KJS_FAST_CALL
     508      : m_expr(expr) { }
     509    ArgumentListNode(ArgumentListNode* listNode, ExpressionNode* expr) KJS_FAST_CALL
     510      : m_expr(expr) { listNode->m_next = this; }
    507511    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    508512    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    510514
    511515    void evaluateList(ExecState*, List&) KJS_FAST_CALL;
    512     PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
     516    PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
    513517
    514518  private:
    515519    friend class ArgumentsNode;
    516     ListRefPtr<ArgumentListNode> next;
    517     RefPtr<ExpressionNode> expr;
     520    ListRefPtr<ArgumentListNode> m_next;
     521    RefPtr<ExpressionNode> m_expr;
    518522  };
    519523
    … …  
    521525  public:
    522526    ArgumentsNode() KJS_FAST_CALL { }
    523     ArgumentsNode(ArgumentListNode* l) KJS_FAST_CALL
    524       : listNode(l) { }
     527    ArgumentsNode(ArgumentListNode* listNode) KJS_FAST_CALL
     528      : m_listNode(listNode) { }
    525529    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    526530    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    527531    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    528532
    529     void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (listNode) listNode->evaluateList(exec, list); }
    530 
    531   private:
    532     RefPtr<ArgumentListNode> listNode;
     533    void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (m_listNode) m_listNode->evaluateList(exec, list); }
     534
     535  private:
     536    RefPtr<ArgumentListNode> m_listNode;
    533537  };
    534538
    535539  class NewExprNode : public ExpressionNode {
    536540  public:
    537     NewExprNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
    538     NewExprNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
     541    NewExprNode(ExpressionNode* expr) KJS_FAST_CALL
     542      : m_expr(expr) { }
     543    NewExprNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
     544      : m_expr(expr), m_args(args) { }
    539545    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    540546    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    547553  private:
    548554    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    549     RefPtr<ExpressionNode> expr;
    550     RefPtr<ArgumentsNode> args;
     555    RefPtr<ExpressionNode> m_expr;
     556    RefPtr<ArgumentsNode> m_args;
    551557  };
    552558
    553559  class FunctionCallValueNode : public ExpressionNode {
    554560  public:
    555     FunctionCallValueNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
     561    FunctionCallValueNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
     562      : m_expr(expr), m_args(args) { }
    556563    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    557564    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    559566    virtual Precedence precedence() const { return PrecCall; }
    560567  private:
    561     RefPtr<ExpressionNode> expr;
    562     RefPtr<ArgumentsNode> args;
     568    RefPtr<ExpressionNode> m_expr;
     569    RefPtr<ArgumentsNode> m_args;
    563570  };
    564571
    565572  class FunctionCallResolveNode : public ExpressionNode {
    566573  public:
    567     FunctionCallResolveNode(const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL
    568         : ident(i)
    569         , args(a)
     574    FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
     575        : m_ident(ident)
     576        , m_args(args)
    570577    {
    571578    }
    … …  
    573580    FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
    574581        : ExpressionNode(PlacementNewAdopt)
    575         , ident(PlacementNewAdopt)
    576         , args(PlacementNewAdopt)
     582        , m_ident(PlacementNewAdopt)
     583        , m_args(PlacementNewAdopt)
    577584    {
    578585    }
    … …  
    589596  protected:
    590597    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    591     Identifier ident;
    592     RefPtr<ArgumentsNode> args;
    593     size_t index; // Used by LocalVarFunctionCallNode.
     598    Identifier m_ident;
     599    RefPtr<ArgumentsNode> m_args;
     600    size_t m_index; // Used by LocalVarFunctionCallNode.
    594601  };
    595602
    … …  
    600607    {
    601608        ASSERT(i != missingSymbolMarker());
    602         index = i;
     609        m_index = i;
    603610    }
    604611
    … …  
    614621  class FunctionCallBracketNode : public ExpressionNode {
    615622  public:
    616     FunctionCallBracketNode(ExpressionNode* b, ExpressionNode* s, ArgumentsNode* a) KJS_FAST_CALL : base(b), subscript(s), args(a) {}
     623    FunctionCallBracketNode(ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL
     624      : m_base(base), m_subscript(subscript), m_args(args) { }
    617625    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    618626    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    620628    virtual Precedence precedence() const { return PrecCall; }
    621629  protected:
    622     RefPtr<ExpressionNode> base;
    623     RefPtr<ExpressionNode> subscript;
    624     RefPtr<ArgumentsNode> args;
     630    RefPtr<ExpressionNode> m_base;
     631    RefPtr<ExpressionNode> m_subscript;
     632    RefPtr<ArgumentsNode> m_args;
    625633  };
    626634
    627635  class FunctionCallDotNode : public ExpressionNode {
    628636  public:
    629     FunctionCallDotNode(ExpressionNode* b, const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL : base(b), ident(i), args(a) {}
     637    FunctionCallDotNode(ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
     638      : m_base(base), m_ident(ident), m_args(args) { }
    630639    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    631640    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    638647  private:
    639648    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
    640     RefPtr<ExpressionNode> base;
    641     Identifier ident;
    642     RefPtr<ArgumentsNode> args;
     649    RefPtr<ExpressionNode> m_base;
     650    Identifier m_ident;
     651    RefPtr<ArgumentsNode> m_args;
    643652  };
    644653
    … …  
    746755  class PostfixBracketNode : public ExpressionNode {
    747756  public:
    748     PostfixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
     757    PostfixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     758      : m_base(base), m_subscript(subscript) { }
    749759    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    750760    virtual Precedence precedence() const { return PrecPostfix; }
    … …  
    756766  class PostIncBracketNode : public PostfixBracketNode {
    757767  public:
    758     PostIncBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
     768    PostIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     769      : PostfixBracketNode(base, subscript) { }
    759770    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    760771    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    763774  class PostDecBracketNode : public PostfixBracketNode {
    764775  public:
    765     PostDecBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
     776    PostDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     777      : PostfixBracketNode(base, subscript) { }
    766778    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    767779    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    770782    class PostfixDotNode : public ExpressionNode {
    771783  public:
    772     PostfixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
     784    PostfixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     785      : m_base(base), m_ident(ident) { }
    773786    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    774787    virtual Precedence precedence() const { return PrecPostfix; }
    … …  
    780793  class PostIncDotNode : public PostfixDotNode {
    781794  public:
    782     PostIncDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
     795    PostIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     796      : PostfixDotNode(base, ident) { }
    783797    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    784798    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    787801  class PostDecDotNode : public PostfixDotNode {
    788802  public:
    789     PostDecDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
     803    PostDecDotNode(ExpressionNode*  base, const Identifier& ident) KJS_FAST_CALL
     804      : PostfixDotNode(base, ident) { }
    790805    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    791806    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    794809  class PostfixErrorNode : public ExpressionNode {
    795810  public:
    796     PostfixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
     811    PostfixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
     812      : m_expr(expr), m_oper(oper) { }
    797813    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    798814    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    805821  class DeleteResolveNode : public ExpressionNode {
    806822  public:
    807     DeleteResolveNode(const Identifier& i) KJS_FAST_CALL : m_ident(i) {}
     823    DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL
     824        : m_ident(ident)
     825    {
     826    }
    808827    DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
    809828        : ExpressionNode(PlacementNewAdopt)
    … …  
    832851  class DeleteBracketNode : public ExpressionNode {
    833852  public:
    834     DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL : m_base(base), m_subscript(subscript) {}
     853    DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     854      : m_base(base), m_subscript(subscript) { }
    835855    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    836856    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    844864  class DeleteDotNode : public ExpressionNode {
    845865  public:
    846     DeleteDotNode(ExpressionNode* base, const Identifier& i) KJS_FAST_CALL : m_base(base), m_ident(i) {}
     866    DeleteDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     867      : m_base(base), m_ident(ident) { }
    847868    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    848869    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    856877  class DeleteValueNode : public ExpressionNode {
    857878  public:
    858     DeleteValueNode(ExpressionNode* e) KJS_FAST_CALL : m_expr(e) {}
     879    DeleteValueNode(ExpressionNode* expr) KJS_FAST_CALL
     880      : m_expr(expr) { }
    859881    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    860882    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    867889  class VoidNode : public ExpressionNode {
    868890  public:
    869     VoidNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
     891    VoidNode(ExpressionNode* expr) KJS_FAST_CALL
     892      : m_expr(expr) { }
    870893    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    871894    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    873896    virtual Precedence precedence() const { return PrecUnary; }
    874897  private:
    875     RefPtr<ExpressionNode> expr;
     898    RefPtr<ExpressionNode> m_expr;
    876899  };
    877900
    878901  class TypeOfResolveNode : public ExpressionNode {
    879902  public:
    880     TypeOfResolveNode(const Identifier &s) KJS_FAST_CALL
    881         : ExpressionNode(StringType), m_ident(s) {}
     903    TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL
     904        : ExpressionNode(StringType)
     905        , m_ident(ident)
     906    {
     907    }
    882908   
    883909    TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
    … …  
    927953  class PreIncResolveNode : public PrePostResolveNode {
    928954  public:
    929     PreIncResolveNode(const Identifier &s) KJS_FAST_CALL
    930         : PrePostResolveNode(s)
     955    PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL
     956        : PrePostResolveNode(ident)
    931957    {
    932958    }
    … …  
    969995  class PreDecResolveNode : public PrePostResolveNode {
    970996  public:
    971     PreDecResolveNode(const Identifier &s) KJS_FAST_CALL
    972         : PrePostResolveNode(s)
     997    PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL
     998        : PrePostResolveNode(ident)
    973999    {
    9741000    }
    … …  
    10111037  class PrefixBracketNode : public ExpressionNode {
    10121038  public:
    1013     PrefixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
    1014    
     1039    PrefixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     1040      : m_base(base), m_subscript(subscript) { }
     1041
    10151042    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    10161043    virtual Precedence precedence() const { return PrecUnary; }
    … …  
    10221049  class PreIncBracketNode : public PrefixBracketNode {
    10231050  public:
    1024     PreIncBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
     1051    PreIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     1052      : PrefixBracketNode(base, subscript) { }
    10251053    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10261054    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    10291057  class PreDecBracketNode : public PrefixBracketNode {
    10301058  public:
    1031     PreDecBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
     1059    PreDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
     1060      : PrefixBracketNode(base, subscript) { }
    10321061    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10331062    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    10361065  class PrefixDotNode : public ExpressionNode {
    10371066  public:
    1038     PrefixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
     1067    PrefixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     1068      : m_base(base), m_ident(ident) { }
    10391069    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    10401070    virtual Precedence precedence() const { return PrecPostfix; }
    … …  
    10461076  class PreIncDotNode : public PrefixDotNode {
    10471077  public:
    1048     PreIncDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
     1078    PreIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     1079      : PrefixDotNode(base, ident) { }
    10491080    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10501081    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    10531084  class PreDecDotNode : public PrefixDotNode {
    10541085  public:
    1055     PreDecDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
     1086    PreDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
     1087      : PrefixDotNode(base, ident) { }
    10561088    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10571089    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    10601092  class PrefixErrorNode : public ExpressionNode {
    10611093  public:
    1062     PrefixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
     1094    PrefixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
     1095      : m_expr(expr), m_oper(oper) { }
    10631096    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    10641097    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    10711104  class UnaryPlusNode : public ExpressionNode {
    10721105  public:
    1073     UnaryPlusNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), m_expr(e) {}
     1106    UnaryPlusNode(ExpressionNode* expr) KJS_FAST_CALL
     1107      : ExpressionNode(NumberType), m_expr(expr) { }
    10741108    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    10751109    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    10861120  class NegateNode : public ExpressionNode {
    10871121  public:
    1088     NegateNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
     1122    NegateNode(ExpressionNode* expr) KJS_FAST_CALL
     1123      : ExpressionNode(NumberType), m_expr(expr) { }
    10891124    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    10901125    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    10931128    virtual Precedence precedence() const { return PrecUnary; }
    10941129  private:
    1095     RefPtr<ExpressionNode> expr;
     1130    RefPtr<ExpressionNode> m_expr;
    10961131  };
    10971132
    10981133  class BitwiseNotNode : public ExpressionNode {
    10991134  public:
    1100     BitwiseNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
     1135    BitwiseNotNode(ExpressionNode* expr) KJS_FAST_CALL
     1136      : ExpressionNode(NumberType), m_expr(expr) { }
    11011137    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11021138    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11091145  private:
    11101146    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1111     RefPtr<ExpressionNode> expr;
     1147    RefPtr<ExpressionNode> m_expr;
    11121148  };
    11131149
    11141150  class LogicalNotNode : public ExpressionNode {
    11151151  public:
    1116     LogicalNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(BooleanType), expr(e) {}
     1152    LogicalNotNode(ExpressionNode* expr) KJS_FAST_CALL
     1153      : ExpressionNode(BooleanType), m_expr(expr) { }
    11171154    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11181155    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11211158    virtual Precedence precedence() const { return PrecUnary; }
    11221159  private:
    1123     RefPtr<ExpressionNode> expr;
     1160    RefPtr<ExpressionNode> m_expr;
    11241161  };
    11251162 
    11261163  class MultNode : public ExpressionNode {
    11271164  public:
    1128       MultNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1165      MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1166        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    11291167      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11301168      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11371175  private:
    11381176      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    1139       RefPtr<ExpressionNode> term1;
    1140       RefPtr<ExpressionNode> term2;
     1177      RefPtr<ExpressionNode> m_term1;
     1178      RefPtr<ExpressionNode> m_term2;
    11411179  };
    11421180 
    11431181  class DivNode : public ExpressionNode {
    11441182  public:
    1145       DivNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1183      DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1184        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    11461185      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11471186      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11531192  private:
    11541193      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    1155       RefPtr<ExpressionNode> term1;
    1156       RefPtr<ExpressionNode> term2;
     1194      RefPtr<ExpressionNode> m_term1;
     1195      RefPtr<ExpressionNode> m_term2;
    11571196  };
    11581197 
    11591198  class ModNode : public ExpressionNode {
    11601199  public:
    1161       ModNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1200      ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1201        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    11621202      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11631203      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11701210  private:
    11711211      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    1172       RefPtr<ExpressionNode> term1;
    1173       RefPtr<ExpressionNode> term2;
     1212      RefPtr<ExpressionNode> m_term1;
     1213      RefPtr<ExpressionNode> m_term2;
    11741214  };
    11751215
    11761216  class AddNode : public ExpressionNode {
    11771217  public:
    1178     AddNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     1218    AddNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1219      : m_term1(term1), m_term2(term2) { }
    11791220    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    11801221    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    11851226    virtual Precedence precedence() const { return PrecAdditive; }
    11861227  protected:
    1187     AddNode(ExpressionNode* t1, ExpressionNode* t2, JSType expectedReturn) KJS_FAST_CALL : ExpressionNode(expectedReturn), term1(t1), term2(t2) {}
    1188     RefPtr<ExpressionNode> term1;
    1189     RefPtr<ExpressionNode> term2;
     1228    AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn) KJS_FAST_CALL
     1229      : ExpressionNode(expectedReturn), m_term1(term1), m_term2(term2) { }
     1230    RefPtr<ExpressionNode> m_term1;
     1231    RefPtr<ExpressionNode> m_term2;
    11901232  private:
    11911233    ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    … …  
    11941236    class AddNumbersNode : public AddNode {
    11951237    public:
    1196         AddNumbersNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, NumberType) {}
     1238        AddNumbersNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1239          : AddNode(term1, term2, NumberType) { }
    11971240        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    11981241        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
    … …  
    12051248    class AddStringLeftNode : public AddNode {
    12061249    public:
    1207         AddStringLeftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
     1250        AddStringLeftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1251          : AddNode(term1, term2, StringType) { }
    12081252        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    12091253    };
    … …  
    12111255    class AddStringRightNode : public AddNode {
    12121256    public:
    1213         AddStringRightNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
     1257        AddStringRightNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1258          : AddNode(term1, term2, StringType) { }
    12141259        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    12151260    };
    … …  
    12171262    class AddStringsNode : public AddNode {
    12181263    public:
    1219         AddStringsNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
     1264        AddStringsNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1265          : AddNode(term1, term2, StringType) { }
    12201266        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    12211267    };
    … …  
    12231269  class SubNode : public ExpressionNode {
    12241270  public:
    1225       SubNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1271      SubNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1272        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    12261273      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    12271274      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    12331280  private:
    12341281      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
    1235       RefPtr<ExpressionNode> term1;
    1236       RefPtr<ExpressionNode> term2;
     1282      RefPtr<ExpressionNode> m_term1;
     1283      RefPtr<ExpressionNode> m_term2;
    12371284  };
    12381285
    12391286  class LeftShiftNode : public ExpressionNode {
    12401287  public:
    1241     LeftShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
    1242       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1288    LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1289      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    12431290    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    12441291    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    12501297  private:
    12511298    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1252     RefPtr<ExpressionNode> term1;
    1253     RefPtr<ExpressionNode> term2;
     1299    RefPtr<ExpressionNode> m_term1;
     1300    RefPtr<ExpressionNode> m_term2;
    12541301  };
    12551302
    12561303  class RightShiftNode : public ExpressionNode {
    12571304  public:
    1258     RightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
    1259       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1305    RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1306      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    12601307    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    12611308    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    12671314  private:
    12681315    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1269     RefPtr<ExpressionNode> term1;
    1270     RefPtr<ExpressionNode> term2;
     1316    RefPtr<ExpressionNode> m_term1;
     1317    RefPtr<ExpressionNode> m_term2;
    12711318  };
    12721319
    12731320  class UnsignedRightShiftNode : public ExpressionNode {
    12741321  public:
    1275     UnsignedRightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
    1276       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
     1322    UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
     1323      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
    12771324    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    12781325    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    12841331  private:
    12851332    ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
    1286     RefPtr<ExpressionNode> term1;
    1287     RefPtr<ExpressionNode> term2;
     1333    RefPtr<ExpressionNode> m_term1;
     1334    RefPtr<ExpressionNode> m_term2;
    12881335  };
    12891336
    12901337  class LessNode : public ExpressionNode {
    12911338  public:
    1292     LessNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1293       : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1339    LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1340      : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) {}
    12941341    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    12951342    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13001347    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    13011348  protected:
    1302     RefPtr<ExpressionNode> expr1;
    1303     RefPtr<ExpressionNode> expr2;
     1349    RefPtr<ExpressionNode> m_expr1;
     1350    RefPtr<ExpressionNode> m_expr2;
    13041351  };
    13051352
    13061353    class LessNumbersNode : public LessNode {
    13071354    public:
    1308         LessNumbersNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1309             : LessNode(e1, e2) {}
     1355        LessNumbersNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1356            : LessNode(expr1, expr2) { }
    13101357        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    13111358        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
    … …  
    13161363    class LessStringsNode : public LessNode {
    13171364    public:
    1318         LessStringsNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1319             : LessNode(e1, e2) {}
     1365        LessStringsNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1366            : LessNode(expr1, expr2) { }
    13201367        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    13211368        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
    … …  
    13271374  public:
    13281375    GreaterNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
    1329       expr1(e1), expr2(e2) {}
     1376      m_expr1(e1), m_expr2(e2) {}
    13301377    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    13311378    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13351382  private:
    13361383    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1337     RefPtr<ExpressionNode> expr1;
    1338     RefPtr<ExpressionNode> expr2;
     1384    RefPtr<ExpressionNode> m_expr1;
     1385    RefPtr<ExpressionNode> m_expr2;
    13391386  };
    13401387
    13411388  class LessEqNode : public ExpressionNode {
    13421389  public:
    1343     LessEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
    1344       expr1(e1), expr2(e2) {}
     1390    LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1391      : m_expr1(expr1), m_expr2(expr2) { }
    13451392    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    13461393    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13501397  private:
    13511398    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1352     RefPtr<ExpressionNode> expr1;
    1353     RefPtr<ExpressionNode> expr2;
     1399    RefPtr<ExpressionNode> m_expr1;
     1400    RefPtr<ExpressionNode> m_expr2;
    13541401  };
    13551402
    13561403  class GreaterEqNode : public ExpressionNode {
    13571404  public:
    1358     GreaterEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
    1359       expr1(e1), expr2(e2) {}
     1405    GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1406      : m_expr1(expr1), m_expr2(expr2) { }
    13601407    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    13611408    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13651412  private:
    13661413    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1367     RefPtr<ExpressionNode> expr1;
    1368     RefPtr<ExpressionNode> expr2;
     1414    RefPtr<ExpressionNode> m_expr1;
     1415    RefPtr<ExpressionNode> m_expr2;
    13691416  };
    13701417
    13711418    class InstanceOfNode : public ExpressionNode {
    13721419  public:
    1373     InstanceOfNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1374         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1420    InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1421        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    13751422    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    13761423    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13791426    virtual Precedence precedence() const { return PrecRelational; }
    13801427  private:
    1381     RefPtr<ExpressionNode> expr1;
    1382     RefPtr<ExpressionNode> expr2;
     1428    RefPtr<ExpressionNode> m_expr1;
     1429    RefPtr<ExpressionNode> m_expr2;
    13831430  };
    13841431
    13851432    class InNode : public ExpressionNode {
    13861433  public:
    1387     InNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
    1388       expr1(e1), expr2(e2) {}
     1434    InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1435      : m_expr1(expr1), m_expr2(expr2) { }
    13891436    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    13901437    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    13931440    virtual Precedence precedence() const { return PrecRelational; }
    13941441  private:
    1395     RefPtr<ExpressionNode> expr1;
    1396     RefPtr<ExpressionNode> expr2;
     1442    RefPtr<ExpressionNode> m_expr1;
     1443    RefPtr<ExpressionNode> m_expr2;
    13971444  };
    13981445
    13991446    class EqualNode : public ExpressionNode {
    14001447  public:
    1401     EqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1402         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1448    EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1449        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    14031450    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14041451    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14081455  private:
    14091456    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1410     RefPtr<ExpressionNode> expr1;
    1411     RefPtr<ExpressionNode> expr2;
     1457    RefPtr<ExpressionNode> m_expr1;
     1458    RefPtr<ExpressionNode> m_expr2;
    14121459  };
    14131460
    14141461    class NotEqualNode : public ExpressionNode {
    14151462  public:
    1416     NotEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1417         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1463    NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1464        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    14181465    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14191466    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14231470  private:
    14241471    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1425     RefPtr<ExpressionNode> expr1;
    1426     RefPtr<ExpressionNode> expr2;
     1472    RefPtr<ExpressionNode> m_expr1;
     1473    RefPtr<ExpressionNode> m_expr2;
    14271474  };
    14281475
    14291476    class StrictEqualNode : public ExpressionNode {
    14301477  public:
    1431     StrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1432         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1478    StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1479        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    14331480    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14341481    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14381485  private:
    14391486    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1440     RefPtr<ExpressionNode> expr1;
    1441     RefPtr<ExpressionNode> expr2;
     1487    RefPtr<ExpressionNode> m_expr1;
     1488    RefPtr<ExpressionNode> m_expr2;
    14421489  };
    14431490
    14441491    class NotStrictEqualNode : public ExpressionNode {
    14451492  public:
    1446     NotStrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1447         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1493    NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1494        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    14481495    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14491496    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14531500  private:
    14541501    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1455     RefPtr<ExpressionNode> expr1;
    1456     RefPtr<ExpressionNode> expr2;
     1502    RefPtr<ExpressionNode> m_expr1;
     1503    RefPtr<ExpressionNode> m_expr2;
    14571504  };
    14581505
    14591506    class BitAndNode : public ExpressionNode {
    14601507  public:
    1461     BitAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1462         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
     1508    BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1509        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
    14631510    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14641511    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14711518  private:
    14721519    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1473     RefPtr<ExpressionNode> expr1;
    1474     RefPtr<ExpressionNode> expr2;
     1520    RefPtr<ExpressionNode> m_expr1;
     1521    RefPtr<ExpressionNode> m_expr2;
    14751522  };
    14761523
    14771524    class BitOrNode : public ExpressionNode {
    14781525  public:
    1479     BitOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1480         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
     1526    BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1527        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
    14811528    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    14821529    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    14891536  private:
    14901537    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1491     RefPtr<ExpressionNode> expr1;
    1492     RefPtr<ExpressionNode> expr2;
    1493   };
    1494 
    1495     class BitXOrNode : public ExpressionNode {
    1496   public:
    1497     BitXOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1498         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
     1538    RefPtr<ExpressionNode> m_expr1;
     1539    RefPtr<ExpressionNode> m_expr2;
     1540  };
     1541
     1542  class BitXOrNode : public ExpressionNode {
     1543  public:
     1544    BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1545        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
    14991546    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    15001547    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    15071554  private:
    15081555    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
    1509     RefPtr<ExpressionNode> expr1;
    1510     RefPtr<ExpressionNode> expr2;
     1556    RefPtr<ExpressionNode> m_expr1;
     1557    RefPtr<ExpressionNode> m_expr2;
    15111558  };
    15121559
    15131560  /**
    1514    * expr1 && expr2, expr1 || expr2
     1561   * m_expr1 && m_expr2, m_expr1 || m_expr2
    15151562   */
    15161563    class LogicalAndNode : public ExpressionNode {
    15171564  public:
    1518     LogicalAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1519         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1565    LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1566        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    15201567    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    15211568    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    15251572  private:
    15261573    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1527     RefPtr<ExpressionNode> expr1;
    1528     RefPtr<ExpressionNode> expr2;
     1574    RefPtr<ExpressionNode> m_expr1;
     1575    RefPtr<ExpressionNode> m_expr2;
    15291576  };
    15301577 
    15311578    class LogicalOrNode : public ExpressionNode {
    15321579  public:
    1533     LogicalOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
    1534         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
     1580    LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1581        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
    15351582    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    15361583    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    15401587  private:
    15411588    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
    1542     RefPtr<ExpressionNode> expr1;
    1543     RefPtr<ExpressionNode> expr2;
     1589    RefPtr<ExpressionNode> m_expr1;
     1590    RefPtr<ExpressionNode> m_expr2;
    15441591  };
    15451592
    15461593  /**
    1547    * The ternary operator, "logical ? expr1 : expr2"
     1594   * The ternary operator, "m_logical ? m_expr1 : m_expr2"
    15481595   */
    1549     class ConditionalNode : public ExpressionNode {
    1550   public:
    1551     ConditionalNode(ExpressionNode*  l, ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
    1552       logical(l), expr1(e1), expr2(e2) {}
     1596  class ConditionalNode : public ExpressionNode {
     1597  public:
     1598    ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1599      : m_logical(logical), m_expr1(expr1), m_expr2(expr2) { }
    15531600    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    15541601    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    15601607    virtual Precedence precedence() const { return PrecConditional; }
    15611608  private:
    1562     RefPtr<ExpressionNode> logical;
    1563     RefPtr<ExpressionNode> expr1;
    1564     RefPtr<ExpressionNode> expr2;
    1565   };
    1566 
    1567     class ReadModifyResolveNode : public ExpressionNode {
    1568   public:
    1569     ReadModifyResolveNode(const Identifier &ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
     1609    RefPtr<ExpressionNode> m_logical;
     1610    RefPtr<ExpressionNode> m_expr1;
     1611    RefPtr<ExpressionNode> m_expr2;
     1612  };
     1613
     1614  class ReadModifyResolveNode : public ExpressionNode {
     1615  public:
     1616    ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
    15701617      : m_ident(ident)
    15711618      , m_oper(oper)
    15721619      , m_right(right)
    1573       {
    1574       }
     1620    {
     1621    }
    15751622
    15761623    ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
    … …  
    16151662  };
    16161663
    1617     class AssignResolveNode : public ExpressionNode {
    1618   public:
    1619      AssignResolveNode(const Identifier &ident, ExpressionNode* right) KJS_FAST_CALL
     1664  class AssignResolveNode : public ExpressionNode {
     1665  public:
     1666     AssignResolveNode(const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
    16201667      : m_ident(ident)
    16211668      , m_right(right)
    … …  
    16611708  };
    16621709
    1663     class ReadModifyBracketNode : public ExpressionNode {
    1664   public:
    1665     ReadModifyBracketNode(ExpressionNode*  base, ExpressionNode*  subscript, Operator oper, ExpressionNode* right) KJS_FAST_CALL
    1666       : m_base(base), m_subscript(subscript), m_oper(oper), m_right(right) {}
     1710  class ReadModifyBracketNode : public ExpressionNode {
     1711  public:
     1712    ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right) KJS_FAST_CALL
     1713      : m_base(base), m_subscript(subscript), m_oper(oper), m_right(right) { }
    16671714    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    16681715    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    16761723  };
    16771724
    1678     class AssignBracketNode : public ExpressionNode {
    1679   public:
    1680     AssignBracketNode(ExpressionNode*  base, ExpressionNode*  subscript, ExpressionNode* right) KJS_FAST_CALL
    1681       : m_base(base), m_subscript(subscript), m_right(right) {}
     1725  class AssignBracketNode : public ExpressionNode {
     1726  public:
     1727    AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right) KJS_FAST_CALL
     1728      : m_base(base), m_subscript(subscript), m_right(right) { }
    16821729    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    16831730    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    16901737  };
    16911738
    1692     class AssignDotNode : public ExpressionNode {
    1693   public:
    1694     AssignDotNode(ExpressionNode*  base, const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
    1695       : m_base(base), m_ident(ident), m_right(right) {}
     1739  class AssignDotNode : public ExpressionNode {
     1740  public:
     1741    AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
     1742      : m_base(base), m_ident(ident), m_right(right) { }
    16961743    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    16971744    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    17041751  };
    17051752
    1706     class ReadModifyDotNode : public ExpressionNode {
    1707   public:
    1708     ReadModifyDotNode(ExpressionNode*  base, const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL
    1709       : m_base(base), m_ident(ident), m_oper(oper), m_right(right) {}
     1753  class ReadModifyDotNode : public ExpressionNode {
     1754  public:
     1755    ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL
     1756      : m_base(base), m_ident(ident), m_oper(oper), m_right(right) { }
    17101757    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    17111758    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    17191766  };
    17201767
    1721     class AssignErrorNode : public ExpressionNode {
     1768  class AssignErrorNode : public ExpressionNode {
    17221769  public:
    17231770    AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
    1724       : m_left(left), m_oper(oper), m_right(right) {}
     1771      : m_left(left), m_oper(oper), m_right(right) { }
    17251772    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    17261773    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    17321779  };
    17331780
    1734     class CommaNode : public ExpressionNode {
    1735   public:
    1736     CommaNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2)
    1737     {
    1738         e1->optimizeForUnnecessaryResult();
     1781  class CommaNode : public ExpressionNode {
     1782  public:
     1783    CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
     1784        : m_expr1(expr1)
     1785        , m_expr2(expr2)
     1786    {
     1787        m_expr1->optimizeForUnnecessaryResult();
    17391788    }
    17401789    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    … …  
    17431792    virtual Precedence precedence() const { return PrecExpression; }
    17441793  private:
    1745     RefPtr<ExpressionNode> expr1;
    1746     RefPtr<ExpressionNode> expr2;
     1794    RefPtr<ExpressionNode> m_expr1;
     1795    RefPtr<ExpressionNode> m_expr2;
    17471796  };
    17481797
    17491798  class ConstDeclNode : public ExpressionNode {
    17501799  public:
    1751     ConstDeclNode(const Identifier& id, ExpressionNode* in) KJS_FAST_CALL;
     1800    ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL;
    17521801    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    17531802    virtual KJS::JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    … …  
    17551804    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17561805    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    1757     PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return next.release(); }
    1758 
    1759     Identifier ident;
    1760     ListRefPtr<ConstDeclNode> next;
    1761     RefPtr<ExpressionNode> init;
     1806    PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
     1807
     1808    Identifier m_ident;
     1809    ListRefPtr<ConstDeclNode> m_next;
     1810    RefPtr<ExpressionNode> m_init;
    17621811  private:
    17631812    void handleSlowCase(ExecState*, const ScopeChain&, JSValue*) KJS_FAST_CALL NEVER_INLINE;
    … …  
    17661815  class ConstStatementNode : public StatementNode {
    17671816  public:
    1768     ConstStatementNode(ConstDeclNode* l) KJS_FAST_CALL : next(l) { }
     1817    ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL
     1818      : m_next(next) { }
    17691819    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    17701820    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17711821    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17721822  private:
    1773     RefPtr<ConstDeclNode> next;
     1823    RefPtr<ConstDeclNode> m_next;
    17741824  };
    17751825
    … …  
    18081858  class ExprStatementNode : public StatementNode {
    18091859  public:
    1810     ExprStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
     1860    ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL
     1861      : m_expr(expr) { }
    18111862    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18121863    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18131864    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18141865  private:
    1815     RefPtr<ExpressionNode> expr;
     1866    RefPtr<ExpressionNode> m_expr;
    18161867  };
    18171868
    18181869  class VarStatementNode : public StatementNode {
    18191870  public:
    1820     VarStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
     1871    VarStatementNode(ExpressionNode* e) KJS_FAST_CALL : m_expr(e) { }
    18211872    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18221873    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18231874    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18241875  private:
    1825     RefPtr<ExpressionNode> expr;
     1876    RefPtr<ExpressionNode> m_expr;
    18261877  };
    18271878
    18281879  class IfNode : public StatementNode {
    18291880  public:
    1830     IfNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL
    1831       : m_condition(e), m_ifBlock(s) { }
     1881    IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL
     1882      : m_condition(condition), m_ifBlock(ifBlock) { }
    18321883    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18331884    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    … …  
    18401891    class IfElseNode : public IfNode {
    18411892    public:
    1842         IfElseNode(ExpressionNode* e, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
    1843             : IfNode(e, ifBlock), m_elseBlock(elseBlock) { }
     1893        IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
     1894            : IfNode(condtion, ifBlock), m_elseBlock(elseBlock) { }
    18441895        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18451896        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    … …  
    18511902  class DoWhileNode : public StatementNode {
    18521903  public:
    1853     DoWhileNode(StatementNode *s, ExpressionNode* e) KJS_FAST_CALL : statement(s), expr(e) { }
     1904    DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL
     1905      : m_statement(statement), m_expr(expr) { }
    18541906    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18551907    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18561908    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18571909  private:
    1858     RefPtr<StatementNode> statement;
    1859     RefPtr<ExpressionNode> expr;
     1910    RefPtr<StatementNode> m_statement;
     1911    RefPtr<ExpressionNode> m_expr;
    18601912  };
    18611913
    18621914  class WhileNode : public StatementNode {
    18631915  public:
    1864     WhileNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL : expr(e), statement(s) { }
     1916    WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
     1917      : m_expr(expr), m_statement(statement) { }
    18651918    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    18661919    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18671920    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18681921  private:
    1869     RefPtr<ExpressionNode> expr;
    1870     RefPtr<StatementNode> statement;
     1922    RefPtr<ExpressionNode> m_expr;
     1923    RefPtr<StatementNode> m_statement;
    18711924  };
    18721925
    18731926  class ForNode : public StatementNode {
    18741927  public:
    1875       ForNode(ExpressionNode* e1, ExpressionNode* e2, ExpressionNode* e3, StatementNode* s, bool e1WasVarDecl) KJS_FAST_CALL
    1876         : expr1(e1 ? e1 : new PlaceholderTrueNode)
    1877         , expr2(e2 ? e2 : new PlaceholderTrueNode)
    1878         , expr3(e3 ? e3 : new PlaceholderTrueNode)
    1879         , statement(s)
    1880         , expr1WasVarDecl(e1 && e1WasVarDecl)
    1881     {
    1882         ASSERT(expr1);
    1883         ASSERT(expr2);
    1884         ASSERT(expr3);
     1928      ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL
     1929        : m_expr1(expr1 ? expr1 : new PlaceholderTrueNode)
     1930        , m_expr2(expr2 ? expr2 : new PlaceholderTrueNode)
     1931        , m_expr3(expr3 ? expr3 : new PlaceholderTrueNode)
     1932        , m_statement(statement)
     1933        , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
     1934    {
     1935        ASSERT(m_expr1);
     1936        ASSERT(m_expr2);
     1937        ASSERT(m_expr3);
    18851938        ASSERT(statement);
    18861939
    1887         expr1->optimizeForUnnecessaryResult();
    1888         expr3->optimizeForUnnecessaryResult();
     1940        m_expr1->optimizeForUnnecessaryResult();
     1941        m_expr3->optimizeForUnnecessaryResult();
    18891942    }
    18901943
    … …  
    18931946    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18941947  private:
    1895     RefPtr<ExpressionNode> expr1;
    1896     RefPtr<ExpressionNode> expr2;
    1897     RefPtr<ExpressionNode> expr3;
    1898     RefPtr<StatementNode> statement;
    1899     bool expr1WasVarDecl;
     1948    RefPtr<ExpressionNode> m_expr1;
     1949    RefPtr<ExpressionNode> m_expr2;
     1950    RefPtr<ExpressionNode> m_expr3;
     1951    RefPtr<StatementNode> m_statement;
     1952    bool m_expr1WasVarDecl;
    19001953  };
    19011954
    19021955  class ForInNode : public StatementNode {
    19031956  public:
    1904     ForInNode(ExpressionNode*  l, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
    1905     ForInNode(const Identifier &i, ExpressionNode *in, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
     1957    ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
     1958    ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
    19061959    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19071960    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19081961    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19091962  private:
    1910     Identifier ident;
    1911     RefPtr<ExpressionNode> init;
    1912     RefPtr<ExpressionNode> lexpr;
    1913     RefPtr<ExpressionNode> expr;
    1914     RefPtr<StatementNode> statement;
    1915     bool identIsVarDecl;
     1963    Identifier m_ident;
     1964    RefPtr<ExpressionNode> m_init;
     1965    RefPtr<ExpressionNode> m_lexpr;
     1966    RefPtr<ExpressionNode> m_expr;
     1967    RefPtr<StatementNode> m_statement;
     1968    bool m_identIsVarDecl;
    19161969  };
    19171970
    … …  
    19191972  public:
    19201973    ContinueNode() KJS_FAST_CALL { }
    1921     ContinueNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
     1974    ContinueNode(const Identifier& ident) KJS_FAST_CALL
     1975      : m_ident(ident) { }
    19221976    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19231977    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19241978  private:
    1925     Identifier ident;
     1979    Identifier m_ident;
    19261980  };
    19271981
    … …  
    19291983  public:
    19301984    BreakNode() KJS_FAST_CALL { }
    1931     BreakNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
     1985    BreakNode(const Identifier& ident) KJS_FAST_CALL
     1986      : m_ident(ident) { }
    19321987    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19331988    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19341989  private:
    1935     Identifier ident;
     1990    Identifier m_ident;
    19361991  };
    19371992
    19381993  class ReturnNode : public StatementNode {
    19391994  public:
    1940     ReturnNode(ExpressionNode* v) KJS_FAST_CALL : value(v) {}
     1995    ReturnNode(ExpressionNode* value) KJS_FAST_CALL
     1996      : m_value(value) { }
    19411997    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19421998    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19431999    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19442000  private:
    1945     RefPtr<ExpressionNode> value;
     2001    RefPtr<ExpressionNode> m_value;
    19462002  };
    19472003
    19482004  class WithNode : public StatementNode {
    19492005  public:
    1950     WithNode(ExpressionNode* e, StatementNode* s) KJS_FAST_CALL : expr(e), statement(s) { }
     2006    WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
     2007      : m_expr(expr), m_statement(statement) { }
    19512008    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19522009    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19532010    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19542011  private:
    1955     RefPtr<ExpressionNode> expr;
    1956     RefPtr<StatementNode> statement;
     2012    RefPtr<ExpressionNode> m_expr;
     2013    RefPtr<StatementNode> m_statement;
    19572014  };
    19582015
    19592016  class LabelNode : public StatementNode {
    19602017  public:
    1961     LabelNode(const Identifier &l, StatementNode *s) KJS_FAST_CALL : label(l), statement(s) { }
     2018    LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL
     2019      : m_label(label), m_statement(statement) { }
    19622020    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19632021    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19642022    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19652023  private:
    1966     Identifier label;
    1967     RefPtr<StatementNode> statement;
     2024    Identifier m_label;
     2025    RefPtr<StatementNode> m_statement;
    19682026  };
    19692027
    19702028  class ThrowNode : public StatementNode {
    19712029  public:
    1972     ThrowNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
     2030    ThrowNode(ExpressionNode* expr) KJS_FAST_CALL
     2031      : m_expr(expr) { }
    19732032    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19742033    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19752034    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19762035  private:
    1977     RefPtr<ExpressionNode> expr;
     2036    RefPtr<ExpressionNode> m_expr;
    19782037  };
    19792038
    19802039  class TryNode : public StatementNode {
    19812040  public:
    1982     TryNode(StatementNode *b, const Identifier &e, StatementNode *c, StatementNode *f) KJS_FAST_CALL
    1983       : tryBlock(b), exceptionIdent(e), catchBlock(c), finallyBlock(f) { }
     2041    TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL
     2042      : m_tryBlock(tryBlock), m_exceptionIdent(exceptionIdent), m_catchBlock(catchBlock), m_finallyBlock(finallyBlock) { }
    19842043    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    19852044    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19862045    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19872046  private:
    1988     RefPtr<StatementNode> tryBlock;
    1989     Identifier exceptionIdent;
    1990     RefPtr<StatementNode> catchBlock;
    1991     RefPtr<StatementNode> finallyBlock;
    1992   };
    1993 
    1994     class ParameterNode : public Node {
    1995   public:
    1996     ParameterNode(const Identifier& i) KJS_FAST_CALL : id(i) { }
    1997     ParameterNode(ParameterNode* l, const Identifier& i) KJS_FAST_CALL
    1998       : id(i) { l->next = this; }
    1999     Identifier ident() KJS_FAST_CALL { return id; }
    2000     ParameterNode *nextParam() KJS_FAST_CALL { return next.get(); }
    2001     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    2002     PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return next.release(); }
     2047    RefPtr<StatementNode> m_tryBlock;
     2048    Identifier m_exceptionIdent;
     2049    RefPtr<StatementNode> m_catchBlock;
     2050    RefPtr<StatementNode> m_finallyBlock;
     2051  };
     2052
     2053  class ParameterNode : public Node {
     2054  public:
     2055    ParameterNode(const Identifier& ident) KJS_FAST_CALL
     2056      : m_ident(ident) { }
     2057    ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL
     2058      : m_ident(ident) { l->m_next = this; }
     2059    Identifier ident() KJS_FAST_CALL { return m_ident; }
     2060    ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); }
     2061    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     2062    PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
    20032063    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    20042064  private:
    20052065    friend class FuncDeclNode;
    20062066    friend class FuncExprNode;
    2007     Identifier id;
    2008     ListRefPtr<ParameterNode> next;
     2067    Identifier m_ident;
     2068    ListRefPtr<ParameterNode> m_next;
    20092069  };
    20102070
    … …  
    20772137  class FuncExprNode : public ExpressionNode {
    20782138  public:
    2079     FuncExprNode(const Identifier& i, FunctionBodyNode* b, ParameterNode* p = 0) KJS_FAST_CALL
    2080       : ident(i), param(p), body(b) { addParams(); }
     2139    FuncExprNode(const Identifier& ident, FunctionBodyNode* body, ParameterNode* parameter = 0) KJS_FAST_CALL
     2140      : m_ident(ident), m_parameter(parameter), m_body(body) { addParams(); }
    20812141    virtual JSValue *evaluate(ExecState*) KJS_FAST_CALL;
    20822142    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    20872147    // Used for streamTo
    20882148    friend class PropertyNode;
    2089     Identifier ident;
    2090     RefPtr<ParameterNode> param;
    2091     RefPtr<FunctionBodyNode> body;
     2149    Identifier m_ident;
     2150    RefPtr<ParameterNode> m_parameter;
     2151    RefPtr<FunctionBodyNode> m_body;
    20922152  };
    20932153
    20942154  class FuncDeclNode : public StatementNode {
    20952155  public:
    2096     FuncDeclNode(const Identifier& i, FunctionBodyNode* b) KJS_FAST_CALL
    2097       : ident(i), body(b) { addParams(); }
    2098     FuncDeclNode(const Identifier& i, ParameterNode* p, FunctionBodyNode* b) KJS_FAST_CALL
    2099       : ident(i), param(p), body(b) { addParams(); }
     2156    FuncDeclNode(const Identifier& ident, FunctionBodyNode* body) KJS_FAST_CALL
     2157      : m_ident(ident), m_body(body) { addParams(); }
     2158    FuncDeclNode(const Identifier& ident, ParameterNode* parameter, FunctionBodyNode* body) KJS_FAST_CALL
     2159      : m_ident(ident), m_parameter(parameter), m_body(body) { addParams(); }
    21002160    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    21012161    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    21022162    ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL;
    2103     Identifier ident;
     2163    Identifier m_ident;
    21042164  private:
    21052165    void addParams() KJS_FAST_CALL;
    2106     RefPtr<ParameterNode> param;
    2107     RefPtr<FunctionBodyNode> body;
    2108   };
    2109 
    2110     class CaseClauseNode : public Node {
    2111   public:
    2112       CaseClauseNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
     2166    RefPtr<ParameterNode> m_parameter;
     2167    RefPtr<FunctionBodyNode> m_body;
     2168  };
     2169
     2170  class CaseClauseNode : public Node {
     2171  public:
     2172      CaseClauseNode(ExpressionNode* e) KJS_FAST_CALL
     2173        : m_expr(e) { }
    21132174      CaseClauseNode(ExpressionNode* e, SourceElements* children) KJS_FAST_CALL
    2114       : expr(e) { if (children) children->releaseContentsIntoVector(m_children); }
     2175        : m_expr(e) { if (children) children->releaseContentsIntoVector(m_children); }
    21152176      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    21162177      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    … …  
    21212182
    21222183  private:
    2123       RefPtr<ExpressionNode> expr;
     2184      RefPtr<ExpressionNode> m_expr;
    21242185      StatementVector m_children;
    21252186  };
    21262187 
    2127     class ClauseListNode : public Node {
    2128   public:
    2129       ClauseListNode(CaseClauseNode* c) KJS_FAST_CALL : clause(c) { }
    2130       ClauseListNode(ClauseListNode* n, CaseClauseNode* c) KJS_FAST_CALL
    2131       : clause(c) { n->next = this; }
     2188  class ClauseListNode : public Node {
     2189  public:
     2190      ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL
     2191        : m_clause(clause) { }
     2192      ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL
     2193        : m_clause(clause) { clauseList->m_next = this; }
    21322194      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    2133       CaseClauseNode* getClause() const KJS_FAST_CALL { return clause.get(); }
    2134       ClauseListNode* getNext() const KJS_FAST_CALL { return next.get(); }
     2195      CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); }
     2196      ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); }
    21352197      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    2136       PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
     2198      PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
    21372199      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    21382200  private:
    21392201      friend class CaseBlockNode;
    2140       RefPtr<CaseClauseNode> clause;
    2141       ListRefPtr<ClauseListNode> next;
     2202      RefPtr<CaseClauseNode> m_clause;
     2203      ListRefPtr<ClauseListNode> m_next;
    21422204  };
    21432205 
    2144     class CaseBlockNode : public Node {
    2145   public:
    2146       CaseBlockNode(ClauseListNode* l1, CaseClauseNode* d, ClauseListNode* l2) KJS_FAST_CALL;
     2206  class CaseBlockNode : public Node {
     2207  public:
     2208      CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL;
    21472209      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    21482210      JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL;
    … …  
    21502212      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    21512213  private:
    2152       RefPtr<ClauseListNode> list1;
    2153       RefPtr<CaseClauseNode> def;
    2154       RefPtr<ClauseListNode> list2;
     2214      RefPtr<ClauseListNode> m_list1;
     2215      RefPtr<CaseClauseNode> m_defaultClause;
     2216      RefPtr<ClauseListNode> m_list2;
    21552217  };
    21562218 
    21572219  class SwitchNode : public StatementNode {
    21582220  public:
    2159       SwitchNode(ExpressionNode* e, CaseBlockNode *b) KJS_FAST_CALL : expr(e), block(b) { }
     2221      SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL
     2222        : m_expr(expr), m_block(block) { }
    21602223      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
    21612224      virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    21622225      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    21632226  private:
    2164       RefPtr<ExpressionNode> expr;
    2165       RefPtr<CaseBlockNode> block;
     2227      RefPtr<ExpressionNode> m_expr;
     2228      RefPtr<CaseBlockNode> m_block;
    21662229  };
    21672230
    … …  
    22062269  };
    22072270
    2208 } // namespace
    2209 
    2210 #endif
     2271} // namespace KJS
     2272
     2273#endif // NODES_H_
Note: See TracChangeset for help on using the changeset viewer.