Changeset 47263 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
Aug 13, 2009, 5:58:06 PM (16 years ago)
Author:
Darin Adler
Message:

Too much use of void* in Grammar.y
​https://bugs.webkit.org/show_bug.cgi?id=28287

Patch by Darin Adler <Darin Adler> on 2009-08-13
Reviewed by George Staikos.

  • parser/Grammar.y: Changed all the helper functions to

take a JSGlobalData* instead of a void*. A couple formatting
tweaks that I missed when breaking this into pieces.

Location:
trunk/JavaScriptCore
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r47262 r47263  
     12009-08-13  Darin Adler  <[email protected]>
     2
     3        Reviewed by George Staikos.
     4
     5        Too much use of void* in Grammar.y
     6        https://bugs.webkit.org/show_bug.cgi?id=28287
     7
     8        * parser/Grammar.y: Changed all the helper functions to
     9        take a JSGlobalData* instead of a void*. A couple formatting
     10        tweaks that I missed when breaking this into pieces.
     11
    1122009-08-13  Darin Adler  <[email protected]>
    213

  • trunk/JavaScriptCore/parser/Grammar.y

    r47262 r47263  
    6060using namespace std;
    6161
    62 static ExpressionNode* makeAssignNode(void*, ExpressionNode* loc, Operator, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end);
    63 static ExpressionNode* makePrefixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
    64 static ExpressionNode* makePostfixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
    65 static PropertyNode* makeGetterOrSetterPropertyNode(void*, const Identifier &getOrSet, const Identifier& name, ParameterNode*, FunctionBodyNode*, const SourceCode&);
    66 static ExpressionNodeInfo makeFunctionCallNode(void*, ExpressionNodeInfo func, ArgumentsNodeInfo, int start, int divot, int end);
    67 static ExpressionNode* makeTypeOfNode(void*, ExpressionNode*);
    68 static ExpressionNode* makeDeleteNode(void*, ExpressionNode*, int start, int divot, int end);
    69 static ExpressionNode* makeNegateNode(void*, ExpressionNode*);
    70 static NumberNode* makeNumberNode(void*, double);
    71 static ExpressionNode* makeBitwiseNotNode(void*, ExpressionNode*);
    72 static ExpressionNode* makeMultNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    73 static ExpressionNode* makeDivNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    74 static ExpressionNode* makeAddNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    75 static ExpressionNode* makeSubNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    76 static ExpressionNode* makeLeftShiftNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    77 static ExpressionNode* makeRightShiftNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
    78 static StatementNode* makeVarStatementNode(void*, ExpressionNode*);
    79 static ExpressionNode* combineCommaNodes(void*, ExpressionNode* list, ExpressionNode* init);
     62static ExpressionNode* makeAssignNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
     63static ExpressionNode* makePrefixNode(JSGlobalData*, ExpressionNode*, Operator, int start, int divot, int end);
     64static ExpressionNode* makePostfixNode(JSGlobalData*, ExpressionNode*, Operator, int start, int divot, int end);
     65static PropertyNode* makeGetterOrSetterPropertyNode(JSGlobalData*, const Identifier& getOrSet, const Identifier& name, ParameterNode*, FunctionBodyNode*, const SourceCode&);
     66static ExpressionNodeInfo makeFunctionCallNode(JSGlobalData*, ExpressionNodeInfo function, ArgumentsNodeInfo, int start, int divot, int end);
     67static ExpressionNode* makeTypeOfNode(JSGlobalData*, ExpressionNode*);
     68static ExpressionNode* makeDeleteNode(JSGlobalData*, ExpressionNode*, int start, int divot, int end);
     69static ExpressionNode* makeNegateNode(JSGlobalData*, ExpressionNode*);
     70static NumberNode* makeNumberNode(JSGlobalData*, double);
     71static ExpressionNode* makeBitwiseNotNode(JSGlobalData*, ExpressionNode*);
     72static ExpressionNode* makeMultNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     73static ExpressionNode* makeDivNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     74static ExpressionNode* makeAddNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     75static ExpressionNode* makeSubNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     76static ExpressionNode* makeLeftShiftNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     77static ExpressionNode* makeRightShiftNode(JSGlobalData*, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     78static StatementNode* makeVarStatementNode(JSGlobalData*, ExpressionNode*);
     79static ExpressionNode* combineCommaNodes(JSGlobalData*, ExpressionNode* list, ExpressionNode* init);
    8080
    8181#if COMPILER(MSVC)
    … …  
    126126}
    127127
    128 static void appendToVarDeclarationList(void* globalPtr, ParserArenaData<DeclarationStacks::VarStack>*& varDecls, const Identifier& ident, unsigned attrs)
     128static void appendToVarDeclarationList(JSGlobalData* globalData, ParserArenaData<DeclarationStacks::VarStack>*& varDecls, const Identifier& ident, unsigned attrs)
    129129{
    130130    if (!varDecls)
    131         varDecls = new (GLOBAL_DATA) ParserArenaData<DeclarationStacks::VarStack>;
     131        varDecls = new (globalData) ParserArenaData<DeclarationStacks::VarStack>;
    132132
    133133    varDecls->data.append(make_pair(ident, attrs));
    … …  
    135135}
    136136
    137 static inline void appendToVarDeclarationList(void* globalPtr, ParserArenaData<DeclarationStacks::VarStack>*& varDecls, ConstDeclNode* decl)
     137static inline void appendToVarDeclarationList(JSGlobalData* globalData, ParserArenaData<DeclarationStacks::VarStack>*& varDecls, ConstDeclNode* decl)
    138138{
    139139    unsigned attrs = DeclarationStacks::IsConstant;
    140140    if (decl->hasInitializer())
    141141        attrs |= DeclarationStacks::HasInitializer;       
    142     appendToVarDeclarationList(globalPtr, varDecls, decl->ident(), attrs);
     142    appendToVarDeclarationList(globalData, varDecls, decl->ident(), attrs);
    143143}
    144144
    … …  
    325325  | STRING ':' AssignmentExpr           { $$ = createNodeInfo<PropertyNode*>(new (GLOBAL_DATA) PropertyNode(GLOBAL_DATA, *$1, $3.m_node, PropertyNode::Constant), $3.m_features, $3.m_numConstants); }
    326326  | NUMBER ':' AssignmentExpr           { $$ = createNodeInfo<PropertyNode*>(new (GLOBAL_DATA) PropertyNode(GLOBAL_DATA, $1, $3.m_node, PropertyNode::Constant), $3.m_features, $3.m_numConstants); }
    327   | IDENT IDENT '(' ')' OPENBRACE FunctionBody CLOSEBRACE    { $$ = createNodeInfo<PropertyNode*>(makeGetterOrSetterPropertyNode(globalPtr, *$1, *$2, 0, $6, GLOBAL_DATA->lexer->sourceCode($5, $7, @5.first_line)), ClosureFeature, 0); setStatementLocation($6, @5, @7); if (!$$.m_node) YYABORT; }
     327  | IDENT IDENT '(' ')' OPENBRACE FunctionBody CLOSEBRACE    { $$ = createNodeInfo<PropertyNode*>(makeGetterOrSetterPropertyNode(GLOBAL_DATA, *$1, *$2, 0, $6, GLOBAL_DATA->lexer->sourceCode($5, $7, @5.first_line)), ClosureFeature, 0); setStatementLocation($6, @5, @7); if (!$$.m_node) YYABORT; }
    328328  | IDENT IDENT '(' FormalParameterList ')' OPENBRACE FunctionBody CLOSEBRACE
    329329                                                             {
    330                                                                  $$ = createNodeInfo<PropertyNode*>(makeGetterOrSetterPropertyNode(globalPtr, *$1, *$2, $4.m_node.head, $7, GLOBAL_DATA->lexer->sourceCode($6, $8, @6.first_line)), $4.m_features | ClosureFeature, 0);
     330                                                                 $$ = createNodeInfo<PropertyNode*>(makeGetterOrSetterPropertyNode(GLOBAL_DATA, *$1, *$2, $4.m_node.head, $7, GLOBAL_DATA->lexer->sourceCode($6, $8, @6.first_line)), $4.m_features | ClosureFeature, 0);
    331331                                                                 if ($4.m_features & ArgumentsFeature)
    332332                                                                     $7->setUsesArguments();
    … …  
    442442
    443443CallExpr:
    444     MemberExpr Arguments                { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
    445   | CallExpr Arguments                  { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     444    MemberExpr Arguments                { $$ = makeFunctionCallNode(GLOBAL_DATA, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     445  | CallExpr Arguments                  { $$ = makeFunctionCallNode(GLOBAL_DATA, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
    446446  | CallExpr '[' Expr ']'               { BracketAccessorNode* node = new (GLOBAL_DATA) BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features & AssignFeature);
    447447                                          setExceptionLocation(node, @1.first_column, @1.last_column, @4.last_column);
    … …  
    454454
    455455CallExprNoBF:
    456     MemberExprNoBF Arguments            { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
    457   | CallExprNoBF Arguments              { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     456    MemberExprNoBF Arguments            { $$ = makeFunctionCallNode(GLOBAL_DATA, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
     457  | CallExprNoBF Arguments              { $$ = makeFunctionCallNode(GLOBAL_DATA, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
    458458  | CallExprNoBF '[' Expr ']'           { BracketAccessorNode* node = new (GLOBAL_DATA) BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features & AssignFeature);
    459459                                          setExceptionLocation(node, @1.first_column, @1.last_column, @4.last_column);
    … …  
    11011101
    11021102CaseClausesOpt:
    1103 /* nothing */                       { $$.m_node.head = 0; $$.m_node.tail = 0; $$.m_varDeclarations = 0; $$.m_funcDeclarations = 0; $$.m_features = 0; $$.m_numConstants = 0; }
     1103  /* nothing */                         { $$.m_node.head = 0; $$.m_node.tail = 0; $$.m_varDeclarations = 0; $$.m_funcDeclarations = 0; $$.m_features = 0; $$.m_numConstants = 0; }
    11041104  | CaseClauses
    11051105;
    … …  
    18351835%%
    18361836
    1837 static ExpressionNode* makeAssignNode(void* globalPtr, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
     1837#undef GLOBAL_DATA
     1838
     1839static ExpressionNode* makeAssignNode(JSGlobalData* globalData, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
    18381840{
    18391841    if (!loc->isLocation())
    1840         return new (GLOBAL_DATA) AssignErrorNode(GLOBAL_DATA, loc, op, expr, divot, divot - start, end - divot);
     1842        return new (globalData) AssignErrorNode(globalData, loc, op, expr, divot, divot - start, end - divot);
    18411843
    18421844    if (loc->isResolveNode()) {
    18431845        ResolveNode* resolve = static_cast<ResolveNode*>(loc);
    18441846        if (op == OpEqual) {
    1845             AssignResolveNode* node = new (GLOBAL_DATA) AssignResolveNode(GLOBAL_DATA, resolve->identifier(), expr, exprHasAssignments);
     1847            AssignResolveNode* node = new (globalData) AssignResolveNode(globalData, resolve->identifier(), expr, exprHasAssignments);
    18461848            setExceptionLocation(node, start, divot, end);
    18471849            return node;
    18481850        } else
    1849             return new (GLOBAL_DATA) ReadModifyResolveNode(GLOBAL_DATA, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     1851            return new (globalData) ReadModifyResolveNode(globalData, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    18501852    }
    18511853    if (loc->isBracketAccessorNode()) {
    18521854        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
    18531855        if (op == OpEqual)
    1854             return new (GLOBAL_DATA) AssignBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
     1856            return new (globalData) AssignBracketNode(globalData, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
    18551857        else {
    1856             ReadModifyBracketNode* node = new (GLOBAL_DATA) ReadModifyBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
     1858            ReadModifyBracketNode* node = new (globalData) ReadModifyBracketNode(globalData, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
    18571859            node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    18581860            return node;
    … …  
    18621864    DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
    18631865    if (op == OpEqual)
    1864         return new (GLOBAL_DATA) AssignDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
    1865 
    1866     ReadModifyDotNode* node = new (GLOBAL_DATA) ReadModifyDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     1866        return new (globalData) AssignDotNode(globalData, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
     1867
     1868    ReadModifyDotNode* node = new (globalData) ReadModifyDotNode(globalData, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    18671869    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    18681870    return node;
    18691871}
    18701872
    1871 static ExpressionNode* makePrefixNode(void* globalPtr, ExpressionNode* expr, Operator op, int start, int divot, int end)
     1873static ExpressionNode* makePrefixNode(JSGlobalData* globalData, ExpressionNode* expr, Operator op, int start, int divot, int end)
    18721874{
    18731875    if (!expr->isLocation())
    1874         return new (GLOBAL_DATA) PrefixErrorNode(GLOBAL_DATA, expr, op, divot, divot - start, end - divot);
     1876        return new (globalData) PrefixErrorNode(globalData, expr, op, divot, divot - start, end - divot);
    18751877   
    18761878    if (expr->isResolveNode()) {
    18771879        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1878         return new (GLOBAL_DATA) PrefixResolveNode(GLOBAL_DATA, resolve->identifier(), op, divot, divot - start, end - divot);
     1880        return new (globalData) PrefixResolveNode(globalData, resolve->identifier(), op, divot, divot - start, end - divot);
    18791881    }
    18801882    if (expr->isBracketAccessorNode()) {
    18811883        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1882         PrefixBracketNode* node = new (GLOBAL_DATA) PrefixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     1884        PrefixBracketNode* node = new (globalData) PrefixBracketNode(globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    18831885        node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
    18841886        return node;
    … …  
    18861888    ASSERT(expr->isDotAccessorNode());
    18871889    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1888     PrefixDotNode* node = new (GLOBAL_DATA) PrefixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     1890    PrefixDotNode* node = new (globalData) PrefixDotNode(globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    18891891    node->setSubexpressionInfo(dot->divot(), dot->startOffset());
    18901892    return node;
    18911893}
    18921894
    1893 static ExpressionNode* makePostfixNode(void* globalPtr, ExpressionNode* expr, Operator op, int start, int divot, int end)
     1895static ExpressionNode* makePostfixNode(JSGlobalData* globalData, ExpressionNode* expr, Operator op, int start, int divot, int end)
    18941896{
    18951897    if (!expr->isLocation())
    1896         return new (GLOBAL_DATA) PostfixErrorNode(GLOBAL_DATA, expr, op, divot, divot - start, end - divot);
     1898        return new (globalData) PostfixErrorNode(globalData, expr, op, divot, divot - start, end - divot);
    18971899   
    18981900    if (expr->isResolveNode()) {
    18991901        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1900         return new (GLOBAL_DATA) PostfixResolveNode(GLOBAL_DATA, resolve->identifier(), op, divot, divot - start, end - divot);
     1902        return new (globalData) PostfixResolveNode(globalData, resolve->identifier(), op, divot, divot - start, end - divot);
    19011903    }
    19021904    if (expr->isBracketAccessorNode()) {
    19031905        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1904         PostfixBracketNode* node = new (GLOBAL_DATA) PostfixBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     1906        PostfixBracketNode* node = new (globalData) PostfixBracketNode(globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    19051907        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    19061908        return node;
    … …  
    19091911    ASSERT(expr->isDotAccessorNode());
    19101912    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1911     PostfixDotNode* node = new (GLOBAL_DATA) PostfixDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     1913    PostfixDotNode* node = new (globalData) PostfixDotNode(globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    19121914    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    19131915    return node;
    19141916}
    19151917
    1916 static ExpressionNodeInfo makeFunctionCallNode(void* globalPtr, ExpressionNodeInfo func, ArgumentsNodeInfo args, int start, int divot, int end)
     1918static ExpressionNodeInfo makeFunctionCallNode(JSGlobalData* globalData, ExpressionNodeInfo func, ArgumentsNodeInfo args, int start, int divot, int end)
    19171919{
    19181920    CodeFeatures features = func.m_features | args.m_features;
    19191921    int numConstants = func.m_numConstants + args.m_numConstants;
    19201922    if (!func.m_node->isLocation())
    1921         return createNodeInfo<ExpressionNode*>(new (GLOBAL_DATA) FunctionCallValueNode(GLOBAL_DATA, func.m_node, args.m_node, divot, divot - start, end - divot), features, numConstants);
     1923        return createNodeInfo<ExpressionNode*>(new (globalData) FunctionCallValueNode(globalData, func.m_node, args.m_node, divot, divot - start, end - divot), features, numConstants);
    19221924    if (func.m_node->isResolveNode()) {
    19231925        ResolveNode* resolve = static_cast<ResolveNode*>(func.m_node);
    19241926        const Identifier& identifier = resolve->identifier();
    1925         if (identifier == GLOBAL_DATA->propertyNames->eval)
    1926             return createNodeInfo<ExpressionNode*>(new (GLOBAL_DATA) EvalFunctionCallNode(GLOBAL_DATA, args.m_node, divot, divot - start, end - divot), EvalFeature | features, numConstants);
    1927         return createNodeInfo<ExpressionNode*>(new (GLOBAL_DATA) FunctionCallResolveNode(GLOBAL_DATA, identifier, args.m_node, divot, divot - start, end - divot), features, numConstants);
     1927        if (identifier == globalData->propertyNames->eval)
     1928            return createNodeInfo<ExpressionNode*>(new (globalData) EvalFunctionCallNode(globalData, args.m_node, divot, divot - start, end - divot), EvalFeature | features, numConstants);
     1929        return createNodeInfo<ExpressionNode*>(new (globalData) FunctionCallResolveNode(globalData, identifier, args.m_node, divot, divot - start, end - divot), features, numConstants);
    19281930    }
    19291931    if (func.m_node->isBracketAccessorNode()) {
    19301932        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func.m_node);
    1931         FunctionCallBracketNode* node = new (GLOBAL_DATA) FunctionCallBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), args.m_node, divot, divot - start, end - divot);
     1933        FunctionCallBracketNode* node = new (globalData) FunctionCallBracketNode(globalData, bracket->base(), bracket->subscript(), args.m_node, divot, divot - start, end - divot);
    19321934        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    19331935        return createNodeInfo<ExpressionNode*>(node, features, numConstants);
    … …  
    19361938    DotAccessorNode* dot = static_cast<DotAccessorNode*>(func.m_node);
    19371939    FunctionCallDotNode* node;
    1938     if (dot->identifier() == GLOBAL_DATA->propertyNames->call)
    1939         node = new (GLOBAL_DATA) CallFunctionCallDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
    1940     else if (dot->identifier() == GLOBAL_DATA->propertyNames->apply)
    1941         node = new (GLOBAL_DATA) ApplyFunctionCallDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
     1940    if (dot->identifier() == globalData->propertyNames->call)
     1941        node = new (globalData) CallFunctionCallDotNode(globalData, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
     1942    else if (dot->identifier() == globalData->propertyNames->apply)
     1943        node = new (globalData) ApplyFunctionCallDotNode(globalData, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
    19421944    else
    1943         node = new (GLOBAL_DATA) FunctionCallDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
     1945        node = new (globalData) FunctionCallDotNode(globalData, dot->base(), dot->identifier(), args.m_node, divot, divot - start, end - divot);
    19441946    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    19451947    return createNodeInfo<ExpressionNode*>(node, features, numConstants);
    19461948}
    19471949
    1948 static ExpressionNode* makeTypeOfNode(void* globalPtr, ExpressionNode* expr)
     1950static ExpressionNode* makeTypeOfNode(JSGlobalData* globalData, ExpressionNode* expr)
    19491951{
    19501952    if (expr->isResolveNode()) {
    19511953        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1952         return new (GLOBAL_DATA) TypeOfResolveNode(GLOBAL_DATA, resolve->identifier());
     1954        return new (globalData) TypeOfResolveNode(globalData, resolve->identifier());
    19531955    }
    1954     return new (GLOBAL_DATA) TypeOfValueNode(GLOBAL_DATA, expr);
    1955 }
    1956 
    1957 static ExpressionNode* makeDeleteNode(void* globalPtr, ExpressionNode* expr, int start, int divot, int end)
     1956    return new (globalData) TypeOfValueNode(globalData, expr);
     1957}
     1958
     1959static ExpressionNode* makeDeleteNode(JSGlobalData* globalData, ExpressionNode* expr, int start, int divot, int end)
    19581960{
    19591961    if (!expr->isLocation())
    1960         return new (GLOBAL_DATA) DeleteValueNode(GLOBAL_DATA, expr);
     1962        return new (globalData) DeleteValueNode(globalData, expr);
    19611963    if (expr->isResolveNode()) {
    19621964        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    1963         return new (GLOBAL_DATA) DeleteResolveNode(GLOBAL_DATA, resolve->identifier(), divot, divot - start, end - divot);
     1965        return new (globalData) DeleteResolveNode(globalData, resolve->identifier(), divot, divot - start, end - divot);
    19641966    }
    19651967    if (expr->isBracketAccessorNode()) {
    19661968        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    1967         return new (GLOBAL_DATA) DeleteBracketNode(GLOBAL_DATA, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
     1969        return new (globalData) DeleteBracketNode(globalData, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
    19681970    }
    19691971    ASSERT(expr->isDotAccessorNode());
    19701972    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    1971     return new (GLOBAL_DATA) DeleteDotNode(GLOBAL_DATA, dot->base(), dot->identifier(), divot, divot - start, end - divot);
    1972 }
    1973 
    1974 static PropertyNode* makeGetterOrSetterPropertyNode(void* globalPtr, const Identifier& getOrSet, const Identifier& name, ParameterNode* params, FunctionBodyNode* body, const SourceCode& source)
     1973    return new (globalData) DeleteDotNode(globalData, dot->base(), dot->identifier(), divot, divot - start, end - divot);
     1974}
     1975
     1976static PropertyNode* makeGetterOrSetterPropertyNode(JSGlobalData* globalData, const Identifier& getOrSet, const Identifier& name, ParameterNode* params, FunctionBodyNode* body, const SourceCode& source)
    19751977{
    19761978    PropertyNode::Type type;
    … …  
    19811983    else
    19821984        return 0;
    1983     return new (GLOBAL_DATA) PropertyNode(GLOBAL_DATA, name, new (GLOBAL_DATA) FuncExprNode(GLOBAL_DATA, GLOBAL_DATA->propertyNames->nullIdentifier, body, source, params), type);
    1984 }
    1985 
    1986 static ExpressionNode* makeNegateNode(void* globalPtr, ExpressionNode* n)
     1985    return new (globalData) PropertyNode(globalData, name, new (globalData) FuncExprNode(globalData, globalData->propertyNames->nullIdentifier, body, source, params), type);
     1986}
     1987
     1988static ExpressionNode* makeNegateNode(JSGlobalData* globalData, ExpressionNode* n)
    19871989{
    19881990    if (n->isNumber()) {
    … …  
    19951997    }
    19961998
    1997     return new (GLOBAL_DATA) NegateNode(GLOBAL_DATA, n);
    1998 }
    1999 
    2000 static NumberNode* makeNumberNode(void* globalPtr, double d)
    2001 {
    2002     return new (GLOBAL_DATA) NumberNode(GLOBAL_DATA, d);
    2003 }
    2004 
    2005 static ExpressionNode* makeBitwiseNotNode(void* globalPtr, ExpressionNode* expr)
     1999    return new (globalData) NegateNode(globalData, n);
     2000}
     2001
     2002static NumberNode* makeNumberNode(JSGlobalData* globalData, double d)
     2003{
     2004    return new (globalData) NumberNode(globalData, d);
     2005}
     2006
     2007static ExpressionNode* makeBitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr)
    20062008{
    20072009    if (expr->isNumber())
    2008         return makeNumberNode(globalPtr, ~toInt32(static_cast<NumberNode*>(expr)->value()));
    2009     return new (GLOBAL_DATA) BitwiseNotNode(GLOBAL_DATA, expr);
    2010 }
    2011 
    2012 static ExpressionNode* makeMultNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2010        return makeNumberNode(globalData, ~toInt32(static_cast<NumberNode*>(expr)->value()));
     2011    return new (globalData) BitwiseNotNode(globalData, expr);
     2012}
     2013
     2014static ExpressionNode* makeMultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20132015{
    20142016    expr1 = expr1->stripUnaryPlus();
    … …  
    20162018
    20172019    if (expr1->isNumber() && expr2->isNumber())
    2018         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
     2020        return makeNumberNode(globalData, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
    20192021
    20202022    if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
    2021         return new (GLOBAL_DATA) UnaryPlusNode(GLOBAL_DATA, expr2);
     2023        return new (globalData) UnaryPlusNode(globalData, expr2);
    20222024
    20232025    if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
    2024         return new (GLOBAL_DATA) UnaryPlusNode(GLOBAL_DATA, expr1);
    2025 
    2026     return new (GLOBAL_DATA) MultNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
    2027 }
    2028 
    2029 static ExpressionNode* makeDivNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2026        return new (globalData) UnaryPlusNode(globalData, expr1);
     2027
     2028    return new (globalData) MultNode(globalData, expr1, expr2, rightHasAssignments);
     2029}
     2030
     2031static ExpressionNode* makeDivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20302032{
    20312033    expr1 = expr1->stripUnaryPlus();
    … …  
    20332035
    20342036    if (expr1->isNumber() && expr2->isNumber())
    2035         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
    2036     return new (GLOBAL_DATA) DivNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
    2037 }
    2038 
    2039 static ExpressionNode* makeAddNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2037        return makeNumberNode(globalData, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
     2038    return new (globalData) DivNode(globalData, expr1, expr2, rightHasAssignments);
     2039}
     2040
     2041static ExpressionNode* makeAddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20402042{
    20412043    if (expr1->isNumber() && expr2->isNumber())
    2042         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
    2043     return new (GLOBAL_DATA) AddNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
    2044 }
    2045 
    2046 static ExpressionNode* makeSubNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2044        return makeNumberNode(globalData, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
     2045    return new (globalData) AddNode(globalData, expr1, expr2, rightHasAssignments);
     2046}
     2047
     2048static ExpressionNode* makeSubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20472049{
    20482050    expr1 = expr1->stripUnaryPlus();
    … …  
    20502052
    20512053    if (expr1->isNumber() && expr2->isNumber())
    2052         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
    2053     return new (GLOBAL_DATA) SubNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
    2054 }
    2055 
    2056 static ExpressionNode* makeLeftShiftNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2054        return makeNumberNode(globalData, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
     2055    return new (globalData) SubNode(globalData, expr1, expr2, rightHasAssignments);
     2056}
     2057
     2058static ExpressionNode* makeLeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20572059{
    20582060    if (expr1->isNumber() && expr2->isNumber())
    2059         return makeNumberNode(globalPtr, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    2060     return new (GLOBAL_DATA) LeftShiftNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
    2061 }
    2062 
    2063 static ExpressionNode* makeRightShiftNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     2061        return makeNumberNode(globalData, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
     2062    return new (globalData) LeftShiftNode(globalData, expr1, expr2, rightHasAssignments);
     2063}
     2064
     2065static ExpressionNode* makeRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    20642066{
    20652067    if (expr1->isNumber() && expr2->isNumber())
    2066         return makeNumberNode(globalPtr, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    2067     return new (GLOBAL_DATA) RightShiftNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
     2068        return makeNumberNode(globalData, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
     2069    return new (globalData) RightShiftNode(globalData, expr1, expr2, rightHasAssignments);
    20682070}
    20692071
    20702072// Called by yyparse on error.
    2071 int yyerror(const char *)
     2073int yyerror(const char*)
    20722074{
    20732075    return 1;
    … …  
    20802082}
    20812083
    2082 static ExpressionNode* combineCommaNodes(void* globalPtr, ExpressionNode* list, ExpressionNode* init)
     2084static ExpressionNode* combineCommaNodes(JSGlobalData* globalData, ExpressionNode* list, ExpressionNode* init)
    20832085{
    20842086    if (!list)
    … …  
    20882090        return list;
    20892091    }
    2090     return new (GLOBAL_DATA) CommaNode(GLOBAL_DATA, list, init);
     2092    return new (globalData) CommaNode(globalData, list, init);
    20912093}
    20922094
    … …  
    20942096// statements (which later get stripped out), because the actual
    20952097// declaration work is hoisted up to the start of the function body
    2096 static StatementNode* makeVarStatementNode(void* globalPtr, ExpressionNode* expr)
     2098static StatementNode* makeVarStatementNode(JSGlobalData* globalData, ExpressionNode* expr)
    20972099{
    20982100    if (!expr)
    2099         return new (GLOBAL_DATA) EmptyStatementNode(GLOBAL_DATA);
    2100     return new (GLOBAL_DATA) VarStatementNode(GLOBAL_DATA, expr);
    2101 }
    2102 
    2103 #undef GLOBAL_DATA
     2101        return new (globalData) EmptyStatementNode(globalData);
     2102    return new (globalData) VarStatementNode(globalData, expr);
     2103}
Note: See TracChangeset for help on using the changeset viewer.