# Copyright (c) 2020 ARM Limited
# All rights reserved.
#
# The license below extends only to copyright in the software and shall
# not be construed as granting a license to any other intellectual
# property including but not limited to intellectual property relating
# to a hardware implementation of the functionality of the software
# licensed hereunder.  You may use the software subject to the license
# terms below provided that you ensure that this notice is replicated
# unmodified and in its entirety in all distributions of the software,
# modified or unmodified, in source code or in binary form.
#
# Copyright (c) 2009 The Hewlett-Packard Development Company
# Copyright (c) 2017 Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import os.path
import re
import sys

from m5.util import code_formatter
from m5.util.grammar import Grammar, ParseError

import slicc.ast as ast
import slicc.util as util
from slicc.symbols import SymbolTable

class SLICC(Grammar):
    def __init__(self, filename, base_dir, verbose=False, traceback=False, **kwargs):
        self.protocol = None
        self.traceback = traceback
        self.verbose = verbose
        self.symtab = SymbolTable(self)
        self.base_dir = base_dir

        try:
            self.decl_list = self.parse_file(filename, **kwargs)
        except ParseError as e:
            if not self.traceback:
                sys.exit(str(e))
            raise

    def currentLocation(self):
        return util.Location(self.current_source, self.current_line,
                             no_warning=not self.verbose)

    def codeFormatter(self, *args, **kwargs):
        code = code_formatter(*args, **kwargs)
        code['protocol'] = self.protocol
        return code

    def process(self):
        self.decl_list.generate()

    def writeCodeFiles(self, code_path, includes):
        self.symtab.writeCodeFiles(code_path, includes)

    def writeHTMLFiles(self, html_path):
        self.symtab.writeHTMLFiles(html_path)

    def files(self):
        f = set(['Types.hh'])

        f |= self.decl_list.files()

        return f

    t_ignore = '\t '

    # C or C++ comment (ignore)
    def t_c_comment(self, t):
        r'/\*(.|\n)*?\*/'
        t.lexer.lineno += t.value.count('\n')

    def t_cpp_comment(self, t):
        r'//.*'

    # Define a rule so we can track line numbers
    def t_newline(self, t):
        r'\n+'
        t.lexer.lineno += len(t.value)

    reserved = {
        'protocol' : 'PROTOCOL',
        'include' : 'INCLUDE',
        'global' : 'GLOBAL',
        'machine' : 'MACHINE',
        'in_port' : 'IN_PORT',
        'out_port' : 'OUT_PORT',
        'action' : 'ACTION',
        'transition' : 'TRANS',
        'structure' : 'STRUCT',
        'external_type' : 'EXTERN_TYPE',
        'enumeration' : 'ENUM',
        'state_declaration' : 'STATE_DECL',
        'peek' : 'PEEK',
        'stall_and_wait' : 'STALL_AND_WAIT',
        'enqueue' : 'ENQUEUE',
        'check_allocate' : 'CHECK_ALLOCATE',
        'check_next_cycle' : 'CHECK_NEXT_CYCLE',
        'check_stop_slots' : 'CHECK_STOP_SLOTS',
        'check_on_cache_probe' : 'CHECK_PROBE',
        'static_cast' : 'STATIC_CAST',
        'if' : 'IF',
        'is_valid' : 'IS_VALID',
        'is_invalid' : 'IS_INVALID',
        'else' : 'ELSE',
        'return' : 'RETURN',
        'void' : 'VOID',
        'new' : 'NEW',
        'OOD' : 'OOD',
        'defer_enqueueing' : 'DEFER_ENQUEUEING',
    }

    literals = ':[]{}(),='

    tokens = [ 'EQ', 'NE', 'LT', 'GT', 'LE', 'GE',
               'LEFTSHIFT', 'RIGHTSHIFT',
               'NOT', 'AND', 'OR',
               'PLUS', 'DASH', 'STAR', 'SLASH', 'MOD',
               'INCR', 'DECR',
               'DOUBLE_COLON', 'SEMI',
               'ASSIGN', 'DOT',
               'IDENT', 'LIT_BOOL', 'FLOATNUMBER', 'NUMBER', 'STRING',
               'AMP', 'CONST' ]
    tokens += reserved.values()

    t_EQ = r'=='
    t_NE = r'!='
    t_LT = r'<'
    t_GT = r'>'
    t_LE = r'<='
    t_GE = r'>='
    t_LEFTSHIFT = r'<<'
    t_RIGHTSHIFT = r'>>'
    t_NOT = r'!'
    t_AND = r'&&'
    t_OR = r'\|\|'
    t_PLUS = r'\+'
    t_DASH = r'-'
    t_STAR = r'\*'
    t_AMP = r'&'
    t_CONST = r'const'
    t_SLASH = r'/'
    t_MOD = r'%'
    t_DOUBLE_COLON = r'::'
    t_SEMI = r';'
    t_ASSIGN = r':='
    t_DOT = r'\.'
    t_INCR = r'\+\+'
    t_DECR = r'--'

    precedence = (
        ('left', 'INCR', 'DECR'),
        ('left', 'OR'),
        ('left', 'AND'),
        ('left', 'EQ', 'NE'),
        ('left', 'LT', 'GT', 'LE', 'GE'),
        ('left', 'RIGHTSHIFT', 'LEFTSHIFT'),
        ('left', 'PLUS', 'DASH'),
        ('left', 'STAR', 'SLASH', 'MOD'),
        ('right', 'NOT', 'UMINUS'),
    )

    def t_IDENT(self, t):
        r'[a-zA-Z_][a-zA-Z_0-9]*'
        if t.value == 'true':
            t.type = 'LIT_BOOL'
            t.value = True
            return t

        if t.value == 'false':
            t.type = 'LIT_BOOL'
            t.value = False
            return t

        # Check for reserved words
        t.type = self.reserved.get(t.value, 'IDENT')
        return t

    def t_FLOATNUMBER(self, t):
        '[0-9]+[.][0-9]+'
        try:
            t.value = float(t.value)
        except ValueError:
            raise ParseError("Illegal float", t)
        return t

    def t_NUMBER(self, t):
        r'[0-9]+'
        try:
            t.value = int(t.value)
        except ValueError:
            raise ParseError("Illegal number", t)
        return t

    def t_STRING1(self, t):
        r'\"[^"\n]*\"'
        t.type = 'STRING'
        t.value = t.value[1:-1]
        return t

    def t_STRING2(self, t):
        r"\'[^'\n]*\'"
        t.type = 'STRING'
        t.value = t.value[1:-1]
        return t

    def p_file(self, p):
        "file : decls"
        p[0] = p[1]

    def p_empty(self, p):
        "empty :"

    def p_decls(self, p):
        "decls : declsx"
        p[0] = ast.DeclListAST(self, p[1])

    def p_declsx__list(self, p):
        "declsx : decl declsx"
        if isinstance(p[1], ast.DeclListAST):
            decls = p[1].decls
        elif p[1] is None:
            decls = []
        else:
            decls = [ p[1] ]
        p[0] = decls + p[2]

    def p_declsx__none(self, p):
        "declsx : empty"
        p[0] = []

    def p_decl__protocol(self, p):
        "decl : PROTOCOL STRING SEMI"
        if self.protocol:
            msg = "Protocol can only be set once! Error at %s:%s\n" % \
                (self.current_source, self.current_line)
            raise ParseError(msg)
        self.protocol = p[2]
        p[0] = None

    def p_decl__include(self, p):
        "decl : INCLUDE STRING SEMI"
        dirname = os.path.dirname(self.current_source)
        if os.path.exists(os.path.join(dirname, p[2])):
            filename = os.path.join(dirname, p[2])
        else:
            filename = os.path.join(self.base_dir, p[2])
        p[0] = self.parse_file(filename)

    def p_decl__machine0(self, p):
        "decl : MACHINE '(' enumeration ')' ':' obj_decls '{' decls '}'"
        p[0] = ast.MachineAST(self, p[3], [], p[7], p[9])

    def p_decl__machine1(self, p):
        "decl : MACHINE '(' enumeration pairs ')' ':' obj_decls '{' decls '}'"
        p[0] = ast.MachineAST(self, p[3], p[4], p[7], p[9])

    def p_decl__action(self, p):
        "decl : ACTION '(' ident pairs ')' statements"
        p[0] = ast.ActionDeclAST(self, p[3], p[4], p[6])

    def p_decl__in_port(self, p):
        "decl : IN_PORT '(' ident ',' type ',' var pairs ')' statements"
        p[0] = ast.InPortDeclAST(self, p[3], p[5], p[7], p[8], p[10])

    def p_decl__out_port(self, p):
        "decl : OUT_PORT '(' ident ',' type ',' var pairs ')' SEMI"
        p[0] = ast.OutPortDeclAST(self, p[3], p[5], p[7], p[8])

    def p_decl__trans0(self, p):
        "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents"
        p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], p[7], p[9])

    def p_decl__trans1(self, p):
        "decl : TRANS '(' idents ',' idents ')' idents"
        p[0] = ast.TransitionDeclAST(self, [], p[3], p[5], None, p[7])

    def p_decl__trans2(self, p):
        "decl : TRANS '(' idents ',' idents ',' ident_or_star ')' idents idents"
        p[0] = ast.TransitionDeclAST(self, p[9], p[3], p[5], p[7], p[10])

    def p_decl__trans3(self, p):
        "decl : TRANS '(' idents ',' idents ')' idents idents"
        p[0] = ast.TransitionDeclAST(self, p[7], p[3], p[5], None, p[8])

    def p_decl__extern0(self, p):
        "decl : EXTERN_TYPE '(' type pairs ')' SEMI"
        p[4]["external"] = "yes"
        p[0] = ast.TypeDeclAST(self, p[3], p[4], [])

    def p_decl__global(self, p):
        "decl : GLOBAL '(' type pairs ')' '{' type_members '}'"
        p[4]["global"] = "yes"
        p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])

    def p_decl__struct(self, p):
        "decl : STRUCT '(' type pairs ')' '{' type_members '}'"
        p[0] = ast.TypeDeclAST(self, p[3], p[4], p[7])

    def p_decl__enum(self, p):
        "decl : ENUM '(' type pairs ')' '{' type_enums   '}'"
        p[4]["enumeration"] = "yes"
        p[0] = ast.EnumDeclAST(self, p[3], p[4], p[7])

    def p_decl__state_decl(self, p):
        "decl : STATE_DECL '(' type pairs ')' '{' type_states   '}'"
        p[4]["enumeration"] = "yes"
        p[4]["state_decl"] = "yes"
        p[0] = ast.StateDeclAST(self, p[3], p[4], p[7])

    # Type fields
    def p_obj_decls__list(self, p):
        "obj_decls : obj_decl obj_decls"
        p[0] = [ p[1] ] + p[2]

    def p_obj_decls__empty(self, p):
        "obj_decls : empty"
        p[0] = []

    def p_type_members__list(self, p):
        "type_members : type_member type_members"
        p[0] = [ p[1] ] + p[2]

    def p_type_members__empty(self, p):
        "type_members : empty"
        p[0] = []

    def p_type_member__0(self, p):
        """type_member : obj_decl
                       | func_decl
                       | func_def"""
        p[0] = p[1]

    # Member / Variable declarations
    def p_decl__obj_decl(self, p):
        "decl : obj_decl"
        p[0] = p[1]

    def p_obj_decl__0(self, p):
        "obj_decl : type ident pairs SEMI"
        p[0] = ast.ObjDeclAST(self, p[1], p[2], p[3], None, False)

    def p_obj_decl__1(self, p):
        "obj_decl : type STAR ident pairs SEMI"
        p[0] = ast.ObjDeclAST(self, p[1], p[3], p[4], None, True)

    def p_obj_decl__2(self, p):
        "obj_decl : type ident ASSIGN expr SEMI"
        p[0] = ast.ObjDeclAST(self, p[1], p[2], ast.PairListAST(self), p[4],
                False)

    def p_obj_decl__3(self, p):
        "obj_decl : type STAR ident ASSIGN expr SEMI"
        p[0] = ast.ObjDeclAST(self, p[1], p[3], ast.PairListAST(self), p[5],
                True)

    # Function definition and declaration
    def p_decl__func_decl(self, p):
        "decl : func_decl"
        p[0] = p[1]

    def p_func_decl__0(self, p):
        """func_decl :  void ident '(' params ')' pairs SEMI
                | type ident '(' params ')' pairs SEMI"""
        p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)

    def p_func_decl__1(self, p):
        """func_decl :  void ident '(' types ')' pairs SEMI
                | type ident '(' types ')' pairs SEMI"""
        p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], None)

    def p_decl__func_def(self, p):
        "decl : func_def"
        p[0] = p[1]

    def p_func_def__0(self, p):
        """func_def : void ident '(' params ')' pairs statements
            | type ident '(' params ')' pairs statements"""
        p[0] = ast.FuncDeclAST(self, p[1], p[2], p[4], p[6], p[7])

    # Enum fields
    def p_type_enums__list(self, p):
        "type_enums : type_enum type_enums"
        p[0] = [ p[1] ] + p[2]

    def p_type_enums__empty(self, p):
        "type_enums : empty"
        p[0] = []

    def p_type_enum(self, p):
        "type_enum : ident pairs SEMI"
        p[0] = ast.TypeFieldEnumAST(self, p[1], p[2])

    # States
    def p_type_states__list(self, p):
        "type_states : type_state type_states"
        p[0] = [ p[1] ] + p[2]

    def p_type_states__empty(self, p):
        "type_states : empty"
        p[0] = []

    def p_type_state(self, p):
        "type_state : ident ',' enumeration pairs SEMI"
        p[0] = ast.TypeFieldStateAST(self, p[1], p[3], p[4])

    # Formal Param
    def p_params__many(self, p):
        "params : param ',' params"
        p[0] = [ p[1] ] + p[3]

    def p_params__one(self, p):
        "params : param"
        p[0] = [ p[1] ]

    def p_params__none(self, p):
        "params : empty"
        p[0] = []

    def p_param(self, p):
        "param : type ident"
        p[0] = ast.FormalParamAST(self, p[1], p[2])

    def p_param__pointer(self, p):
        "param : type STAR ident"
        p[0] = ast.FormalParamAST(self, p[1], p[3], None, "PTR")

    def p_param__ref(self, p):
        "param : type AMP ident"
        p[0] = ast.FormalParamAST(self, p[1], p[3], None, "REF")

    def p_param__const_ref(self, p):
        "param : CONST type AMP ident"
        p[0] = ast.FormalParamAST(self, p[1], p[3], None, "CONST_REF")

    def p_param__pointer_default(self, p):
        "param : type STAR ident ASSIGN STRING"
        p[0] = ast.FormalParamAST(self, p[1], p[3], p[5], "PTR")

    def p_param__default_number(self, p):
        "param : type ident ASSIGN NUMBER"
        p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])

    def p_param__default_bool(self, p):
        "param : type ident ASSIGN LIT_BOOL"
        p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])

    def p_param__default_string(self, p):
        "param : type ident ASSIGN STRING"
        p[0] = ast.FormalParamAST(self, p[1], p[2], p[4])

    # Type
    def p_types__multiple(self, p):
        "types : type ',' types"
        p[0] = [ p[1] ] + p[3]

    def p_types__one(self, p):
        "types : type"
        p[0] = [ p[1] ]

    def p_types__empty(self, p):
        "types : empty"
        p[0] = []

    def p_typestr__multi(self, p):
        "typestr : typestr DOUBLE_COLON ident"
        p[0] = '%s::%s' % (p[1], p[3])

    def p_typestr__single(self, p):
        "typestr : ident"
        p[0] = p[1]

    def p_type__one(self, p):
        "type : typestr"
        p[0] = ast.TypeAST(self, p[1])

    def p_void(self, p):
        "void : VOID"
        p[0] = ast.TypeAST(self, p[1])

    # Idents and lists
    def p_idents__braced(self, p):
        "idents : '{' identx '}'"
        p[0] = p[2]

    def p_idents__bare(self, p):
        "idents : ident"
        p[0] = [ p[1] ]

    def p_identx__multiple_1(self, p):
        """identx : ident SEMI identx
                  | ident ',' identx"""
        p[0] = [ p[1] ] + p[3]

    def p_identx__multiple_2(self, p):
        "identx : ident identx"
        p[0] = [ p[1] ] + p[2]

    def p_identx__single(self, p):
        "identx : empty"
        p[0] = [ ]

    def p_ident(self, p):
        "ident : IDENT"
        p[0] = p[1]

    def p_ident_or_star(self, p):
        """ident_or_star : ident
                         | STAR"""
        p[0] = p[1]

    # Pair and pair lists
    def p_pairs__list(self, p):
        "pairs : ',' pairsx"
        p[0] = p[2]

    def p_pairs__empty(self, p):
        "pairs : empty"
        p[0] = ast.PairListAST(self)

    def p_pairsx__many(self, p):
        "pairsx : pair ',' pairsx"
        p[0] = p[3]
        p[0].addPair(p[1])

    def p_pairsx__one(self, p):
        "pairsx : pair"
        p[0] = ast.PairListAST(self)
        p[0].addPair(p[1])

    def p_pair__assign(self, p):
        """pair : ident '=' STRING
                | ident '=' ident
                | ident '=' NUMBER"""
        p[0] = ast.PairAST(self, p[1], p[3])

    def p_pair__literal(self, p):
        "pair : STRING"
        p[0] = ast.PairAST(self, "short", p[1])

    # Below are the rules for action descriptions
    def p_statements__inner(self, p):
        "statements : '{' statements_inner '}'"
        p[0] = ast.StatementListAST(self, p[2])

    def p_statements__none(self, p):
        "statements : '{' '}'"
        p[0] = ast.StatementListAST(self, [])

    def p_statements_inner__many(self, p):
        "statements_inner : statement statements_inner"
        p[0] = [ p[1] ] + p[2]

    def p_statements_inner__one(self, p):
        "statements_inner : statement"
        p[0] = [ p[1] ]

    def p_exprs__multiple(self, p):
        "exprs : expr ',' exprs"
        p[0] = [ p[1] ] + p[3]

    def p_exprs__one(self, p):
        "exprs : expr"
        p[0] = [ p[1] ]

    def p_exprs__empty(self, p):
        "exprs : empty"""
        p[0] = []

    def p_statement__expression(self, p):
        "statement : expr SEMI"
        p[0] = ast.ExprStatementAST(self, p[1])

    def p_statement__assign(self, p):
        "statement : expr ASSIGN expr SEMI"
        p[0] = ast.AssignStatementAST(self, p[1], p[3])

    def p_statement__enqueue(self, p):
        "statement : ENQUEUE '(' var ',' type ')' statements"
        p[0] = ast.EnqueueStatementAST(self, p[3], p[5], None, p[7])

    def p_statement__enqueue_latency(self, p):
        "statement : ENQUEUE '(' var ',' type ',' expr ')' statements"
        p[0] = ast.EnqueueStatementAST(self, p[3], p[5], p[7], p[9])

    def p_statement__defer_enqueueing(self, p):
        "statement : DEFER_ENQUEUEING '(' var ',' type ')' statements"
        p[0] = ast.DeferEnqueueingStatementAST(self, p[3], p[5], p[7])

    def p_statement__stall_and_wait(self, p):
        "statement : STALL_AND_WAIT '(' var ',' var ')' SEMI"
        p[0] = ast.StallAndWaitStatementAST(self, p[3], p[5])

    def p_statement__peek(self, p):
        "statement : PEEK '(' var ',' type pairs ')' statements"
        p[0] = ast.PeekStatementAST(self, p[3], p[5], p[6], p[8], "peek")

    def p_statement__check_allocate(self, p):
        "statement : CHECK_ALLOCATE '(' var ')' SEMI"
        p[0] = ast.CheckAllocateStatementAST(self, p[3])

    def p_statement__check_next_cycle(self, p):
        "statement : CHECK_NEXT_CYCLE '(' ')' SEMI"
        p[0] = ast.CheckNextCycleAST(self)

    def p_statement__check_stop(self, p):
        "statement : CHECK_STOP_SLOTS '(' var ',' STRING ',' STRING ')' SEMI"
        p[0] = ast.CheckStopStatementAST(self, p[3], p[5], p[7])

    def p_statement__check_probe(self, p):
        "statement : CHECK_PROBE '(' var ',' var ')' SEMI"
        p[0] = ast.CheckProbeStatementAST(self, p[3], p[5])

    def p_statement__return(self, p):
        "statement : RETURN expr SEMI"
        p[0] = ast.ReturnStatementAST(self, p[2])

    def p_statement__if(self, p):
        "statement : if_statement"
        p[0] = p[1]

    def p_if_statement__if(self, p):
        "if_statement : IF '(' expr ')' statements"
        p[0] = ast.IfStatementAST(self, p[3], p[5], None)

    def p_if_statement__if_else(self, p):
        "if_statement : IF '(' expr ')' statements ELSE statements"
        p[0] = ast.IfStatementAST(self, p[3], p[5], p[7])

    def p_statement__if_else_if(self, p):
        "if_statement : IF '(' expr ')' statements ELSE if_statement"
        p[0] = ast.IfStatementAST(self, p[3], p[5],
                                  ast.StatementListAST(self, p[7]))

    def p_expr__static_cast(self, p):
        "aexpr : STATIC_CAST '(' type ',' expr ')'"
        p[0] = ast.StaticCastAST(self, p[3], "ref", p[5])

    def p_expr__static_cast_ptr(self, p):
        "aexpr : STATIC_CAST '(' type ',' STRING ',' expr ')'"
        p[0] = ast.StaticCastAST(self, p[3], p[5], p[7])

    def p_expr__var(self, p):
        "aexpr : var"
        p[0] = p[1]

    def p_expr__localvar(self, p):
        "aexpr : type ident"
        p[0] = ast.LocalVariableAST(self, p[1], p[2])

    def p_expr__literal(self, p):
        "aexpr : literal"
        p[0] = p[1]

    def p_expr__enumeration(self, p):
        "aexpr : enumeration"
        p[0] = p[1]

    def p_expr__func_call(self, p):
        "aexpr : ident '(' exprs ')'"
        p[0] = ast.FuncCallExprAST(self, p[1], p[3])

    def p_expr__new(self, p):
        "aexpr : NEW type"
        p[0] = ast.NewExprAST(self, p[2])

    def p_expr__null(self, p):
        "aexpr : OOD"
        p[0] = ast.OodAST(self)

    def p_expr__member(self, p):
        "aexpr : aexpr DOT ident"
        p[0] = ast.MemberExprAST(self, p[1], p[3])

    def p_expr__member_method_call(self, p):
        "aexpr : aexpr DOT ident '(' exprs ')'"
        p[0] = ast.MemberMethodCallExprAST(self, p[1],
                    ast.FuncCallExprAST(self, p[3], p[5]))

    def p_expr__member_method_call_lookup(self, p):
        "aexpr : aexpr '[' exprs ']'"
        p[0] = ast.MemberMethodCallExprAST(self, p[1],
                    ast.FuncCallExprAST(self, "lookup", p[3]))

    def p_expr__class_method_call(self, p):
        "aexpr : type DOUBLE_COLON ident '(' exprs ')'"
        p[0] = ast.ClassMethodCallExprAST(self, p[1],
                    ast.FuncCallExprAST(self, p[3], p[5]))

    def p_expr__aexpr(self, p):
        "expr : aexpr"
        p[0] = p[1]

    def p_expr__binary_op(self, p):
        """expr : expr STAR  expr
                | expr SLASH expr
                | expr MOD   expr
                | expr PLUS  expr
                | expr DASH  expr
                | expr LT    expr
                | expr GT    expr
                | expr LE    expr
                | expr GE    expr
                | expr EQ    expr
                | expr NE    expr
                | expr AND   expr
                | expr OR    expr
                | expr RIGHTSHIFT expr
                | expr LEFTSHIFT  expr"""
        p[0] = ast.InfixOperatorExprAST(self, p[1], p[2], p[3])

    # FIXME - unary not
    def p_expr__unary_op(self, p):
        """expr : NOT expr
                | INCR expr
                | DECR expr
                | DASH expr %prec UMINUS"""
        p[0] = ast.PrefixOperatorExprAST(self, p[1], p[2])

    def p_expr__parens(self, p):
        "aexpr : '(' expr ')'"
        p[0] = p[2]

    def p_expr__is_valid_ptr(self, p):
        "aexpr : IS_VALID '(' var ')'"
        p[0] = ast.IsValidPtrExprAST(self, p[3], True)

    def p_expr__is_invalid_ptr(self, p):
        "aexpr : IS_INVALID '(' var ')'"
        p[0] = ast.IsValidPtrExprAST(self, p[3], False)

    def p_literal__string(self, p):
        "literal : STRING"
        p[0] = ast.LiteralExprAST(self, p[1], "std::string")

    def p_literal__number(self, p):
        "literal : NUMBER"
        p[0] = ast.LiteralExprAST(self, p[1], "int")

    def p_literal__float(self, p):
        "literal : FLOATNUMBER"
        p[0] = ast.LiteralExprAST(self, p[1], "int")

    def p_literal__bool(self, p):
        "literal : LIT_BOOL"
        p[0] = ast.LiteralExprAST(self, p[1], "bool")

    def p_enumeration(self, p):
        "enumeration : ident ':' ident"
        p[0] = ast.EnumExprAST(self, ast.TypeAST(self, p[1]), p[3])

    def p_var(self, p):
        "var : ident"
        p[0] = ast.VarExprAST(self, p[1])