def new_binary(self, ast, op, param):
left = Node()
if hasattr(param, 'brack'):
param = param.brack
if hasattr(ast, "brack"):
left = ast.brack
else:
left.set(ast)
if isinstance(param, nodes.Binary) and param.params and isinstance(param.params[0], nodes.Array) and hasattr(
param.params[0].call_expr, 'brack'):
param = param.params[0].call_expr.brack
ast.set(nodes.Binary(op, [left, param]))
return True
def new_unary(self, ast, op, param):
opu = Node()
opu.set(op)
p = Node()
p.set(param)
ast.set(knodes.KUnary(opu, [p]))
return True
def for_decl_begin(self, current_block):
current_block.ref = Node()
current_block.ref.body = []
# new to link this fake body to other block
parent = self.rule_nodes.parents
if 'current_block' in parent:
current_block.ref.types = parent['current_block'].ref.types.new_child()
return True
def do_call(self, parser: BasicParser) -> Node:
if parser.begin_tag(self.tagname):
# subcontext
parser.push_rule_nodes()
res = self.pt(parser)
parser.pop_rule_nodes()
if res and parser.end_tag(self.tagname):
tag = parser.get_tag(self.tagname)
# no bindings, wrap it in a Node instance
if type(res) is bool:
res = Node()
# update node cache
parser.tag_node(self.tagname, res)
parser.rule_nodes[self.tagname] = res
# forward nodes
return res
return False
def eval_rule(self, name: str) -> Node:
"""Evaluate a rule by name."""
# context created by caller
self.rule_nodes['_'] = Node()
# TODO: other behavior for empty rules?
if name not in self.__class__._rules:
self.diagnostic.notify(
error.Severity.ERROR, "Unknown rule : %s" % name,
error.LocationInfo.from_stream(self._stream, is_error=True))
raise self.diagnostic
self._lastRule = name
rule_to_eval = self.__class__._rules[name]
# TODO: add packrat cache here, same rule - same pos == same res
res = rule_to_eval(self)
if res:
res = self.rule_nodes['_']
return res
def do_call(self, parser: BasicParser) -> Node:
parser.rule_nodes[self.tagname] = Node()
return True
def new_range(self, ast, expr):
begin = Node()
begin.set(ast)
ast.set(nodes.Range(nodes.Raw('...'), [begin, expr]))
return True
def new_binary(self, ast, op, param):
left = Node()
left.set(ast)
ast.set(knodes.KBinary(op, [left, param]))
return True
def new_ternary(self, ast, then_expr, else_expr):
cond = Node()
cond.set(ast)
ast.set(knodes.KTernary([], [cond, then_expr, else_expr]))
return True
def to_cast(self, ast, typename):
expr = Node()
expr.set(ast)
ast.set(knodes.KCast(knodes.KRaw('()'), [typename.ctype, expr]))
return True
def __init__(self):
"""
expr_type (None | type | ref(type) | array of type): The expression type
"""
Node.__init__(self)
self.expr_type = None
