Grammar.y | searchcode

/opensource.apple.com/source/JavaScriptCore/JavaScriptCore-521/parser/Grammar.y

Large files files are truncated, but you can click here to view the full file

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Grammar.y</title>
<style type="text/css">
.enscript-comment { font-style: italic; color: rgb(178,34,34); }
.enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
.enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
.enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
.enscript-reference { font-weight: bold; color: rgb(95,158,160); }
.enscript-string { font-weight: bold; color: rgb(188,143,143); }
.enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
.enscript-type { font-weight: bold; color: rgb(34,139,34); }
.enscript-highlight { text-decoration: underline; color: 0; }
</style>
</head>
<body id="top">
<h1 style="margin:8px;" id="f1">Grammar.y&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
<hr/>
<div></div>
<pre>
%pure_parser

%{

/*
 *  Copyright (C) 1999-2000 Harri Porten (<a href="mailto:porten@kde.org">porten@kde.org</a>)
 *  Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
 *  Copyright (C) 2007 Eric Seidel &lt;<a href="mailto:eric@webkit.org">eric@webkit.org</a>&gt;
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include &quot;config.h&quot;

#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;
#include &quot;JSValue.h&quot;
#include &quot;JSObject.h&quot;
#include &quot;Nodes.h&quot;
#include &quot;Lexer.h&quot;
#include &quot;JSString.h&quot;
#include &quot;JSGlobalData.h&quot;
#include &quot;CommonIdentifiers.h&quot;
#include &quot;NodeInfo.h&quot;
#include &quot;Parser.h&quot;
#include &lt;wtf/MathExtras.h&gt;

#define YYMAXDEPTH 10000
#define YYENABLE_NLS 0

/* default values for bison */
#define YYDEBUG 0 // Set to 1 to debug a parse error.
#define jscyydebug 0 // Set to 1 to debug a parse error.
#if !PLATFORM(DARWIN)
    // avoid triggering warnings in older bison
#define YYERROR_VERBOSE
#endif

int jscyylex(void* lvalp, void* llocp, void* globalPtr);
int jscyyerror(const char*);
static inline bool allowAutomaticSemicolon(JSC::Lexer&amp;, int);

#define GLOBAL_DATA static_cast&lt;JSGlobalData*&gt;(globalPtr)
#define LEXER (GLOBAL_DATA-&gt;lexer)

#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon(*LEXER, yychar)) YYABORT; } while (0)
#define SET_EXCEPTION_LOCATION(node, start, divot, end) node-&gt;setExceptionSourceCode((divot), (divot) - (start), (end) - (divot))
#define DBG(l, s, e) (l)-&gt;setLoc((s).first_line, (e).last_line)

using namespace JSC;
using namespace std;

static ExpressionNode* makeAssignNode(void*, ExpressionNode* loc, Operator, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end);
static ExpressionNode* makePrefixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
static ExpressionNode* makePostfixNode(void*, ExpressionNode* expr, Operator, int start, int divot, int end);
static PropertyNode* makeGetterOrSetterPropertyNode(void*, const Identifier &amp;getOrSet, const Identifier&amp; name, ParameterNode*, FunctionBodyNode*, const SourceCode&amp;);
static ExpressionNodeInfo makeFunctionCallNode(void*, ExpressionNodeInfo func, ArgumentsNodeInfo, int start, int divot, int end);
static ExpressionNode* makeTypeOfNode(void*, ExpressionNode*);
static ExpressionNode* makeDeleteNode(void*, ExpressionNode*, int start, int divot, int end);
static ExpressionNode* makeNegateNode(void*, ExpressionNode*);
static NumberNode* makeNumberNode(void*, double);
static ExpressionNode* makeBitwiseNotNode(void*, ExpressionNode*);
static ExpressionNode* makeMultNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static ExpressionNode* makeDivNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static ExpressionNode* makeAddNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static ExpressionNode* makeSubNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static ExpressionNode* makeLeftShiftNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static ExpressionNode* makeRightShiftNode(void*, ExpressionNode*, ExpressionNode*, bool rightHasAssignments);
static StatementNode* makeVarStatementNode(void*, ExpressionNode*);
static ExpressionNode* combineVarInitializers(void*, ExpressionNode* list, AssignResolveNode* init);

#if COMPILER(MSVC)

#pragma warning(disable: 4065)
#pragma warning(disable: 4244)
#pragma warning(disable: 4702)

// At least some of the time, the declarations of malloc and free that bison
// generates are causing warnings. A way to avoid this is to explicitly define
// the macros so that bison doesn't try to declare malloc and free.
#define YYMALLOC malloc
#define YYFREE free

#endif

#define YYPARSE_PARAM globalPtr
#define YYLEX_PARAM globalPtr

template &lt;typename T&gt; NodeDeclarationInfo&lt;T&gt; createNodeDeclarationInfo(T node, ParserRefCountedData&lt;DeclarationStacks::VarStack&gt;* varDecls, 
                                                                       ParserRefCountedData&lt;DeclarationStacks::FunctionStack&gt;* funcDecls,
                                                                       CodeFeatures info,
                                                                       int numConstants) 
{
    ASSERT((info &amp; ~AllFeatures) == 0);
    NodeDeclarationInfo&lt;T&gt; result = {node, varDecls, funcDecls, info, numConstants};
    return result;
}

template &lt;typename T&gt; NodeInfo&lt;T&gt; createNodeInfo(T node, CodeFeatures info, int numConstants)
{
    ASSERT((info &amp; ~AllFeatures) == 0);
    NodeInfo&lt;T&gt; result = {node, info, numConstants};
    return result;
}

template &lt;typename T&gt; T mergeDeclarationLists(T decls1, T decls2) 
{
    // decls1 or both are null
    if (!decls1)
        return decls2;
    // only decls1 is non-null
    if (!decls2)
        return decls1;

    // Both are non-null
    decls1-&gt;data.append(decls2-&gt;data);
    
    // We manually release the declaration lists to avoid accumulating many many
    // unused heap allocated vectors
    decls2-&gt;ref();
    decls2-&gt;deref();
    return decls1;
}

static void appendToVarDeclarationList(void* globalPtr, ParserRefCountedData&lt;DeclarationStacks::VarStack&gt;*&amp; varDecls, const Identifier&amp; ident, unsigned attrs)
{
    if (!varDecls)
        varDecls = new ParserRefCountedData&lt;DeclarationStacks::VarStack&gt;(GLOBAL_DATA);

    varDecls-&gt;data.append(make_pair(ident, attrs));

}

static inline void appendToVarDeclarationList(void* globalPtr, ParserRefCountedData&lt;DeclarationStacks::VarStack&gt;*&amp; varDecls, ConstDeclNode* decl)
{
    unsigned attrs = DeclarationStacks::IsConstant;
    if (decl-&gt;m_init)
        attrs |= DeclarationStacks::HasInitializer;        
    appendToVarDeclarationList(globalPtr, varDecls, decl-&gt;m_ident, attrs);
}

%}

%union {
    int                 intValue;
    double              doubleValue;
    Identifier*         ident;

    // expression subtrees
    ExpressionNodeInfo  expressionNode;
    FuncDeclNodeInfo    funcDeclNode;
    PropertyNodeInfo    propertyNode;
    ArgumentsNodeInfo   argumentsNode;
    ConstDeclNodeInfo   constDeclNode;
    CaseBlockNodeInfo   caseBlockNode;
    CaseClauseNodeInfo  caseClauseNode;
    FuncExprNodeInfo    funcExprNode;

    // statement nodes
    StatementNodeInfo   statementNode;
    FunctionBodyNode*   functionBodyNode;
    ProgramNode*        programNode;

    SourceElementsInfo  sourceElements;
    PropertyListInfo    propertyList;
    ArgumentListInfo    argumentList;
    VarDeclListInfo     varDeclList;
    ConstDeclListInfo   constDeclList;
    ClauseListInfo      clauseList;
    ElementListInfo     elementList;
    ParameterListInfo   parameterList;

    Operator            op;
}

%start Program

/* literals */
%token NULLTOKEN TRUETOKEN FALSETOKEN

/* keywords */
%token BREAK CASE DEFAULT FOR NEW VAR CONSTTOKEN CONTINUE
%token FUNCTION RETURN VOIDTOKEN DELETETOKEN
%token IF THISTOKEN DO WHILE INTOKEN INSTANCEOF TYPEOF
%token SWITCH WITH RESERVED
%token THROW TRY CATCH FINALLY
%token DEBUGGER

/* give an if without an else higher precedence than an else to resolve the ambiguity */
%nonassoc IF_WITHOUT_ELSE
%nonassoc ELSE

/* punctuators */
%token EQEQ NE                     /* == and != */
%token STREQ STRNEQ                /* === and !== */
%token LE GE                       /* &lt; and &gt; */
%token OR AND                      /* || and &amp;&amp; */
%token PLUSPLUS MINUSMINUS         /* ++ and --  */
%token LSHIFT                      /* &lt;&lt; */
%token RSHIFT URSHIFT              /* &gt;&gt; and &gt;&gt;&gt; */
%token PLUSEQUAL MINUSEQUAL        /* += and -= */
%token MULTEQUAL DIVEQUAL          /* *= and /= */
%token LSHIFTEQUAL                 /* &lt;&lt;= */
%token RSHIFTEQUAL URSHIFTEQUAL    /* &gt;&gt;= and &gt;&gt;&gt;= */
%token ANDEQUAL MODEQUAL           /* &amp;= and %= */
%token XOREQUAL OREQUAL            /* ^= and |= */
%token &lt;intValue&gt; OPENBRACE        /* { (with char offset) */
%token &lt;intValue&gt; CLOSEBRACE        /* { (with char offset) */

/* terminal types */
%token &lt;doubleValue&gt; NUMBER
%token &lt;ident&gt; IDENT STRING

/* automatically inserted semicolon */
%token AUTOPLUSPLUS AUTOMINUSMINUS

/* non-terminal types */
%type &lt;expressionNode&gt;  Literal ArrayLiteral

%type &lt;expressionNode&gt;  PrimaryExpr PrimaryExprNoBrace
%type &lt;expressionNode&gt;  MemberExpr MemberExprNoBF /* BF =&gt; brace or function */
%type &lt;expressionNode&gt;  NewExpr NewExprNoBF
%type &lt;expressionNode&gt;  CallExpr CallExprNoBF
%type &lt;expressionNode&gt;  LeftHandSideExpr LeftHandSideExprNoBF
%type &lt;expressionNode&gt;  PostfixExpr PostfixExprNoBF
%type &lt;expressionNode&gt;  UnaryExpr UnaryExprNoBF UnaryExprCommon
%type &lt;expressionNode&gt;  MultiplicativeExpr MultiplicativeExprNoBF
%type &lt;expressionNode&gt;  AdditiveExpr AdditiveExprNoBF
%type &lt;expressionNode&gt;  ShiftExpr ShiftExprNoBF
%type &lt;expressionNode&gt;  RelationalExpr RelationalExprNoIn RelationalExprNoBF
%type &lt;expressionNode&gt;  EqualityExpr EqualityExprNoIn EqualityExprNoBF
%type &lt;expressionNode&gt;  BitwiseANDExpr BitwiseANDExprNoIn BitwiseANDExprNoBF
%type &lt;expressionNode&gt;  BitwiseXORExpr BitwiseXORExprNoIn BitwiseXORExprNoBF
%type &lt;expressionNode&gt;  BitwiseORExpr BitwiseORExprNoIn BitwiseORExprNoBF
%type &lt;expressionNode&gt;  LogicalANDExpr LogicalANDExprNoIn LogicalANDExprNoBF
%type &lt;expressionNode&gt;  LogicalORExpr LogicalORExprNoIn LogicalORExprNoBF
%type &lt;expressionNode&gt;  ConditionalExpr ConditionalExprNoIn ConditionalExprNoBF
%type &lt;expressionNode&gt;  AssignmentExpr AssignmentExprNoIn AssignmentExprNoBF
%type &lt;expressionNode&gt;  Expr ExprNoIn ExprNoBF

%type &lt;expressionNode&gt;  ExprOpt ExprNoInOpt

%type &lt;statementNode&gt;   Statement Block
%type &lt;statementNode&gt;   VariableStatement ConstStatement EmptyStatement ExprStatement
%type &lt;statementNode&gt;   IfStatement IterationStatement ContinueStatement
%type &lt;statementNode&gt;   BreakStatement ReturnStatement WithStatement
%type &lt;statementNode&gt;   SwitchStatement LabelledStatement
%type &lt;statementNode&gt;   ThrowStatement TryStatement
%type &lt;statementNode&gt;   DebuggerStatement

%type &lt;expressionNode&gt;  Initializer InitializerNoIn
%type &lt;statementNode&gt;   FunctionDeclaration
%type &lt;funcExprNode&gt;    FunctionExpr
%type &lt;functionBodyNode&gt;  FunctionBody
%type &lt;sourceElements&gt;  SourceElements
%type &lt;parameterList&gt;   FormalParameterList
%type &lt;op&gt;              AssignmentOperator
%type &lt;argumentsNode&gt;   Arguments
%type &lt;argumentList&gt;    ArgumentList
%type &lt;varDeclList&gt;     VariableDeclarationList VariableDeclarationListNoIn
%type &lt;constDeclList&gt;   ConstDeclarationList
%type &lt;constDeclNode&gt;   ConstDeclaration
%type &lt;caseBlockNode&gt;   CaseBlock
%type &lt;caseClauseNode&gt;  CaseClause DefaultClause
%type &lt;clauseList&gt;      CaseClauses CaseClausesOpt
%type &lt;intValue&gt;        Elision ElisionOpt
%type &lt;elementList&gt;     ElementList
%type &lt;propertyNode&gt;    Property
%type &lt;propertyList&gt;    PropertyList
%%

// FIXME: There are currently two versions of the grammar in this file, the normal one, and the NoNodes version used for
// lazy recompilation of FunctionBodyNodes.  We should move to generating the two versions from a script to avoid bugs.
// In the mean time, make sure to make any changes to the grammar in both versions.

Literal:
    NULLTOKEN                           { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NullNode(GLOBAL_DATA), 0, 1); }
  | TRUETOKEN                           { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BooleanNode(GLOBAL_DATA, true), 0, 1); }
  | FALSETOKEN                          { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BooleanNode(GLOBAL_DATA, false), 0, 1); }
  | NUMBER                              { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeNumberNode(GLOBAL_DATA, $1), 0, 1); }
  | STRING                              { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new StringNode(GLOBAL_DATA, *$1), 0, 1); }
  | '/' /* regexp */                    {
                                            Lexer&amp; l = *LEXER;
                                            if (!l.scanRegExp())
                                                YYABORT;
                                            RegExpNode* node = new RegExpNode(GLOBAL_DATA, l.pattern(), l.flags());
                                            int size = l.pattern().size() + 2; // + 2 for the two /'s
                                            SET_EXCEPTION_LOCATION(node, @1.first_column, @1.first_column + size, @1.first_column + size);
                                            $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, 0, 0);
                                        }
  | DIVEQUAL /* regexp with /= */       {
                                            Lexer&amp; l = *LEXER;
                                            if (!l.scanRegExp())
                                                YYABORT;
                                            RegExpNode* node = new RegExpNode(GLOBAL_DATA, &quot;=&quot; + l.pattern(), l.flags());
                                            int size = l.pattern().size() + 2; // + 2 for the two /'s
                                            SET_EXCEPTION_LOCATION(node, @1.first_column, @1.first_column + size, @1.first_column + size);
                                            $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, 0, 0);
                                        }
;

Property:
    IDENT ':' AssignmentExpr            { $$ = createNodeInfo&lt;PropertyNode*&gt;(new PropertyNode(GLOBAL_DATA, *$1, $3.m_node, PropertyNode::Constant), $3.m_features, $3.m_numConstants); }
  | STRING ':' AssignmentExpr           { $$ = createNodeInfo&lt;PropertyNode*&gt;(new PropertyNode(GLOBAL_DATA, *$1, $3.m_node, PropertyNode::Constant), $3.m_features, $3.m_numConstants); }
  | NUMBER ':' AssignmentExpr           { $$ = createNodeInfo&lt;PropertyNode*&gt;(new PropertyNode(GLOBAL_DATA, Identifier(GLOBAL_DATA, UString::from($1)), $3.m_node, PropertyNode::Constant), $3.m_features, $3.m_numConstants); }
  | IDENT IDENT '(' ')' OPENBRACE FunctionBody CLOSEBRACE    { $$ = createNodeInfo&lt;PropertyNode*&gt;(makeGetterOrSetterPropertyNode(globalPtr, *$1, *$2, 0, $6, LEXER-&gt;sourceCode($5, $7, @5.first_line)), ClosureFeature, 0); DBG($6, @5, @7); if (!$$.m_node) YYABORT; }
  | IDENT IDENT '(' FormalParameterList ')' OPENBRACE FunctionBody CLOSEBRACE
                                                             {
                                                                 $$ = createNodeInfo&lt;PropertyNode*&gt;(makeGetterOrSetterPropertyNode(globalPtr, *$1, *$2, $4.m_node.head, $7, LEXER-&gt;sourceCode($6, $8, @6.first_line)), $4.m_features | ClosureFeature, 0); 
                                                                 if ($4.m_features &amp; ArgumentsFeature)
                                                                     $7-&gt;setUsesArguments(); 
                                                                 DBG($7, @6, @8); 
                                                                 if (!$$.m_node) 
                                                                     YYABORT; 
                                                             }
;

PropertyList:
    Property                            { $$.m_node.head = new PropertyListNode(GLOBAL_DATA, $1.m_node); 
                                          $$.m_node.tail = $$.m_node.head;
                                          $$.m_features = $1.m_features;
                                          $$.m_numConstants = $1.m_numConstants; }
  | PropertyList ',' Property           { $$.m_node.head = $1.m_node.head;
                                          $$.m_node.tail = new PropertyListNode(GLOBAL_DATA, $3.m_node, $1.m_node.tail);
                                          $$.m_features = $1.m_features | $3.m_features;
                                          $$.m_numConstants = $1.m_numConstants + $3.m_numConstants; }
;

PrimaryExpr:
    PrimaryExprNoBrace
  | OPENBRACE CLOSEBRACE                             { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ObjectLiteralNode(GLOBAL_DATA), 0, 0); }
  | OPENBRACE PropertyList CLOSEBRACE                { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ObjectLiteralNode(GLOBAL_DATA, $2.m_node.head), $2.m_features, $2.m_numConstants); }
  /* allow extra comma, see <a href="http://bugs.webkit.org/show_bug.cgi?id=5939">http://bugs.webkit.org/show_bug.cgi?id=5939</a> */
  | OPENBRACE PropertyList ',' CLOSEBRACE            { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ObjectLiteralNode(GLOBAL_DATA, $2.m_node.head), $2.m_features, $2.m_numConstants); }
;

PrimaryExprNoBrace:
    THISTOKEN                           { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ThisNode(GLOBAL_DATA), ThisFeature, 0); }
  | Literal
  | ArrayLiteral
  | IDENT                               { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ResolveNode(GLOBAL_DATA, *$1, @1.first_column), (*$1 == GLOBAL_DATA-&gt;propertyNames-&gt;arguments) ? ArgumentsFeature : 0, 0); }
  | '(' Expr ')'                        { $$ = $2; }
;

ArrayLiteral:
    '[' ElisionOpt ']'                  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ArrayNode(GLOBAL_DATA, $2), 0, $2 ? 1 : 0); }
  | '[' ElementList ']'                 { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ArrayNode(GLOBAL_DATA, $2.m_node.head), $2.m_features, $2.m_numConstants); }
  | '[' ElementList ',' ElisionOpt ']'  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ArrayNode(GLOBAL_DATA, $4, $2.m_node.head), $2.m_features, $4 ? $2.m_numConstants + 1 : $2.m_numConstants); }
;

ElementList:
    ElisionOpt AssignmentExpr           { $$.m_node.head = new ElementNode(GLOBAL_DATA, $1, $2.m_node);
                                          $$.m_node.tail = $$.m_node.head;
                                          $$.m_features = $2.m_features;
                                          $$.m_numConstants = $2.m_numConstants; }
  | ElementList ',' ElisionOpt AssignmentExpr
                                        { $$.m_node.head = $1.m_node.head;
                                          $$.m_node.tail = new ElementNode(GLOBAL_DATA, $1.m_node.tail, $3, $4.m_node);
                                          $$.m_features = $1.m_features | $4.m_features;
                                          $$.m_numConstants = $1.m_numConstants + $4.m_numConstants; }
;

ElisionOpt:
    /* nothing */                       { $$ = 0; }
  | Elision
;

Elision:
    ','                                 { $$ = 1; }
  | Elision ','                         { $$ = $1 + 1; }
;

MemberExpr:
    PrimaryExpr
  | FunctionExpr                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;($1.m_node, $1.m_features, $1.m_numConstants); }
  | MemberExpr '[' Expr ']'             { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); 
                                        }
  | MemberExpr '.' IDENT                { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features, $1.m_numConstants);
                                        }
  | NEW MemberExpr Arguments            { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $2.m_features | $3.m_features, $2.m_numConstants + $3.m_numConstants);
                                        }
;

MemberExprNoBF:
    PrimaryExprNoBrace
  | MemberExprNoBF '[' Expr ']'         { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); 
                                        }
  | MemberExprNoBF '.' IDENT            { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features, $1.m_numConstants);
                                        }
  | NEW MemberExpr Arguments            { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node, $3.m_node);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $2.m_features | $3.m_features, $2.m_numConstants + $3.m_numConstants);
                                        }
;

NewExpr:
    MemberExpr
  | NEW NewExpr                         { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $2.m_features, $2.m_numConstants); 
                                        }
;

NewExprNoBF:
    MemberExprNoBF
  | NEW NewExpr                         { NewExprNode* node = new NewExprNode(GLOBAL_DATA, $2.m_node);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @2.last_column, @2.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $2.m_features, $2.m_numConstants);
                                        }
;

CallExpr:
    MemberExpr Arguments                { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
  | CallExpr Arguments                  { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
  | CallExpr '[' Expr ']'               { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); 
                                        }
  | CallExpr '.' IDENT                  { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features, $1.m_numConstants); }
;

CallExprNoBF:
    MemberExprNoBF Arguments            { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
  | CallExprNoBF Arguments              { $$ = makeFunctionCallNode(globalPtr, $1, $2, @1.first_column, @1.last_column, @2.last_column); }
  | CallExprNoBF '[' Expr ']'           { BracketAccessorNode* node = new BracketAccessorNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @4.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); 
                                        }
  | CallExprNoBF '.' IDENT              { DotAccessorNode* node = new DotAccessorNode(GLOBAL_DATA, $1.m_node, *$3);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @1.last_column, @3.last_column);
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features, $1.m_numConstants); 
                                        }
;

Arguments:
    '(' ')'                             { $$ = createNodeInfo&lt;ArgumentsNode*&gt;(new ArgumentsNode(GLOBAL_DATA), 0, 0); }
  | '(' ArgumentList ')'                { $$ = createNodeInfo&lt;ArgumentsNode*&gt;(new ArgumentsNode(GLOBAL_DATA, $2.m_node.head), $2.m_features, $2.m_numConstants); }
;

ArgumentList:
    AssignmentExpr                      { $$.m_node.head = new ArgumentListNode(GLOBAL_DATA, $1.m_node);
                                          $$.m_node.tail = $$.m_node.head;
                                          $$.m_features = $1.m_features;
                                          $$.m_numConstants = $1.m_numConstants; }
  | ArgumentList ',' AssignmentExpr     { $$.m_node.head = $1.m_node.head;
                                          $$.m_node.tail = new ArgumentListNode(GLOBAL_DATA, $1.m_node.tail, $3.m_node);
                                          $$.m_features = $1.m_features | $3.m_features;
                                          $$.m_numConstants = $1.m_numConstants + $3.m_numConstants; }
;

LeftHandSideExpr:
    NewExpr
  | CallExpr
;

LeftHandSideExprNoBF:
    NewExprNoBF
  | CallExprNoBF
;

PostfixExpr:
    LeftHandSideExpr
  | LeftHandSideExpr PLUSPLUS           { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus, @1.first_column, @1.last_column, @2.last_column), $1.m_features | AssignFeature, $1.m_numConstants); }
  | LeftHandSideExpr MINUSMINUS         { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus, @1.first_column, @1.last_column, @2.last_column), $1.m_features | AssignFeature, $1.m_numConstants); }
;

PostfixExprNoBF:
    LeftHandSideExprNoBF
  | LeftHandSideExprNoBF PLUSPLUS       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePostfixNode(GLOBAL_DATA, $1.m_node, OpPlusPlus, @1.first_column, @1.last_column, @2.last_column), $1.m_features | AssignFeature, $1.m_numConstants); }
  | LeftHandSideExprNoBF MINUSMINUS     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePostfixNode(GLOBAL_DATA, $1.m_node, OpMinusMinus, @1.first_column, @1.last_column, @2.last_column), $1.m_features | AssignFeature, $1.m_numConstants); }
;

UnaryExprCommon:
    DELETETOKEN UnaryExpr               { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeDeleteNode(GLOBAL_DATA, $2.m_node, @1.first_column, @2.last_column, @2.last_column), $2.m_features, $2.m_numConstants); }
  | VOIDTOKEN UnaryExpr                 { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new VoidNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants + 1); }
  | TYPEOF UnaryExpr                    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeTypeOfNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants); }
  | PLUSPLUS UnaryExpr                  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_features | AssignFeature, $2.m_numConstants); }
  | AUTOPLUSPLUS UnaryExpr              { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePrefixNode(GLOBAL_DATA, $2.m_node, OpPlusPlus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_features | AssignFeature, $2.m_numConstants); }
  | MINUSMINUS UnaryExpr                { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_features | AssignFeature, $2.m_numConstants); }
  | AUTOMINUSMINUS UnaryExpr            { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makePrefixNode(GLOBAL_DATA, $2.m_node, OpMinusMinus, @1.first_column, @2.first_column + 1, @2.last_column), $2.m_features | AssignFeature, $2.m_numConstants); }
  | '+' UnaryExpr                       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new UnaryPlusNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants); }
  | '-' UnaryExpr                       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeNegateNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants); }
  | '~' UnaryExpr                       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeBitwiseNotNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants); }
  | '!' UnaryExpr                       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalNotNode(GLOBAL_DATA, $2.m_node), $2.m_features, $2.m_numConstants); }

UnaryExpr:
    PostfixExpr
  | UnaryExprCommon
;

UnaryExprNoBF:
    PostfixExprNoBF
  | UnaryExprCommon
;

MultiplicativeExpr:
    UnaryExpr
  | MultiplicativeExpr '*' UnaryExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeMultNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | MultiplicativeExpr '/' UnaryExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeDivNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | MultiplicativeExpr '%' UnaryExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ModNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

MultiplicativeExprNoBF:
    UnaryExprNoBF
  | MultiplicativeExprNoBF '*' UnaryExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeMultNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | MultiplicativeExprNoBF '/' UnaryExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeDivNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | MultiplicativeExprNoBF '%' UnaryExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ModNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

AdditiveExpr:
    MultiplicativeExpr
  | AdditiveExpr '+' MultiplicativeExpr { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeAddNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | AdditiveExpr '-' MultiplicativeExpr { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeSubNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

AdditiveExprNoBF:
    MultiplicativeExprNoBF
  | AdditiveExprNoBF '+' MultiplicativeExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeAddNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | AdditiveExprNoBF '-' MultiplicativeExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeSubNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

ShiftExpr:
    AdditiveExpr
  | ShiftExpr LSHIFT AdditiveExpr       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeLeftShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | ShiftExpr RSHIFT AdditiveExpr       { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeRightShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | ShiftExpr URSHIFT AdditiveExpr      { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new UnsignedRightShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

ShiftExprNoBF:
    AdditiveExprNoBF
  | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeLeftShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = createNodeInfo&lt;ExpressionNode*&gt;(makeRightShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new UnsignedRightShiftNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

RelationalExpr:
    ShiftExpr
  | RelationalExpr '&lt;' ShiftExpr        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExpr '&gt;' ShiftExpr        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExpr LE ShiftExpr         { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExpr GE ShiftExpr         { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExpr INSTANCEOF ShiftExpr { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column);  
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExpr INTOKEN ShiftExpr    { InNode* node = new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column);  
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

RelationalExprNoIn:
    ShiftExpr
  | RelationalExprNoIn '&lt;' ShiftExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoIn '&gt;' ShiftExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoIn LE ShiftExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoIn GE ShiftExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoIn INSTANCEOF ShiftExpr
                                        { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column);  
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

RelationalExprNoBF:
    ShiftExprNoBF
  | RelationalExprNoBF '&lt;' ShiftExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoBF '&gt;' ShiftExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoBF LE ShiftExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LessEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoBF GE ShiftExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new GreaterEqNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoBF INSTANCEOF ShiftExpr
                                        { InstanceOfNode* node = new InstanceOfNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column);  
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | RelationalExprNoBF INTOKEN ShiftExpr 
                                        { InNode* node = new InNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature);
                                          SET_EXCEPTION_LOCATION(node, @1.first_column, @3.first_column, @3.last_column);  
                                          $$ = createNodeInfo&lt;ExpressionNode*&gt;(node, $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

EqualityExpr:
    RelationalExpr
  | EqualityExpr EQEQ RelationalExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new EqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExpr NE RelationalExpr      { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExpr STREQ RelationalExpr   { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new StrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExpr STRNEQ RelationalExpr  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotStrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

EqualityExprNoIn:
    RelationalExprNoIn
  | EqualityExprNoIn EQEQ RelationalExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new EqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoIn NE RelationalExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoIn STREQ RelationalExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new StrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoIn STRNEQ RelationalExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotStrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

EqualityExprNoBF:
    RelationalExprNoBF
  | EqualityExprNoBF EQEQ RelationalExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new EqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoBF NE RelationalExpr  { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoBF STREQ RelationalExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new StrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
  | EqualityExprNoBF STRNEQ RelationalExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new NotStrictEqualNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseANDExpr:
    EqualityExpr
  | BitwiseANDExpr '&amp;' EqualityExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitAndNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseANDExprNoIn:
    EqualityExprNoIn
  | BitwiseANDExprNoIn '&amp;' EqualityExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitAndNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseANDExprNoBF:
    EqualityExprNoBF
  | BitwiseANDExprNoBF '&amp;' EqualityExpr { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitAndNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseXORExpr:
    BitwiseANDExpr
  | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitXOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseXORExprNoIn:
    BitwiseANDExprNoIn
  | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitXOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseXORExprNoBF:
    BitwiseANDExprNoBF
  | BitwiseXORExprNoBF '^' BitwiseANDExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitXOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseORExpr:
    BitwiseXORExpr
  | BitwiseORExpr '|' BitwiseXORExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseORExprNoIn:
    BitwiseXORExprNoIn
  | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

BitwiseORExprNoBF:
    BitwiseXORExprNoBF
  | BitwiseORExprNoBF '|' BitwiseXORExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new BitOrNode(GLOBAL_DATA, $1.m_node, $3.m_node, $3.m_features &amp; AssignFeature), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalANDExpr:
    BitwiseORExpr
  | LogicalANDExpr AND BitwiseORExpr    { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalAnd), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalANDExprNoIn:
    BitwiseORExprNoIn
  | LogicalANDExprNoIn AND BitwiseORExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalAnd), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalANDExprNoBF:
    BitwiseORExprNoBF
  | LogicalANDExprNoBF AND BitwiseORExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalAnd), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalORExpr:
    LogicalANDExpr
  | LogicalORExpr OR LogicalANDExpr     { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalOr), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalORExprNoIn:
    LogicalANDExprNoIn
  | LogicalORExprNoIn OR LogicalANDExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalOr), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

LogicalORExprNoBF:
    LogicalANDExprNoBF
  | LogicalORExprNoBF OR LogicalANDExpr { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new LogicalOpNode(GLOBAL_DATA, $1.m_node, $3.m_node, OpLogicalOr), $1.m_features | $3.m_features, $1.m_numConstants + $3.m_numConstants); }
;

ConditionalExpr:
    LogicalORExpr
  | LogicalORExpr '?' AssignmentExpr ':' AssignmentExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ConditionalNode(GLOBAL_DATA, $1.m_node, $3.m_node, $5.m_node), $1.m_features | $3.m_features | $5.m_features, $1.m_numConstants + $3.m_numConstants + $5.m_numConstants); }
;

ConditionalExprNoIn:
    LogicalORExprNoIn
  | LogicalORExprNoIn '?' AssignmentExprNoIn ':' AssignmentExprNoIn
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ConditionalNode(GLOBAL_DATA, $1.m_node, $3.m_node, $5.m_node), $1.m_features | $3.m_features | $5.m_features, $1.m_numConstants + $3.m_numConstants + $5.m_numConstants); }
;

ConditionalExprNoBF:
    LogicalORExprNoBF
  | LogicalORExprNoBF '?' AssignmentExpr ':' AssignmentExpr
                                        { $$ = createNodeInfo&lt;ExpressionNode*&gt;(new ConditionalNode(GLOBAL_DATA, $1.m_node, $3.m_node, $5.…
Large files files are truncated, but you can click here to view the full file