def function_call(self, p):
return ast.functions.FunctionCall(
p.name_id,
pub,
arguments_const([]),
Location(p.name_id.position.sline, p.name_id.position.scol),
)
def expr(self, p):
self.logger.error(
errors.syntax_error,
f"Expected expression with operand '{p[1]}', found `{p.error.value}`",
Location(p.lineno, p.index),
)
return empty_node()
def variable_assign(self, p):
self.logger.error(
errors.syntax_error,
f"Expected ID, found `{p.error.value}`",
Location(p.lineno, p.index),
)
return empty_node()
def error(self, t):
self.logger.error(
errors.unrecognized_character_error,
f"Illegal character `{t.value[0]}`",
Location(t.lineno, t.index),
)
self.index += 1
def simple_import(self, p):
return ast.imports.Import(
p.namespace,
Location(
p.lineno,
p.index,
eline=p.namespace.position.sline,
ecol=p.namespace.position.scol,
),
)
def ret(self, p):
return ast.functions.Return(
p.expr,
Location(
p.lineno,
p.index,
eline=p.expr.position.sline,
ecol=p.expr.position.scol,
),
)
def function_definition(self, p):
block = p.block if "block" in p._namemap else p.expr
pub = True if "PUB" in p._namemap else False
return ast.functions.FunctionDefinition(
p.name_id,
pub,
arguments_const([]),
block,
Location(p.name_id.position.sline, p.name_id.position.scol),
)
def simple_import(self, p):
namespace = ast.primitives.Namespace(p.name_id, p.name_id.position)
return ast.imports.Import(
namespace,
Location(
p.lineno,
p.index,
eline=p.name_id.position.sline,
ecol=p.name_id.position.scol,
),
)
def variable_dec(self, p):
return ast.variables.VariableDec(
p.name_id,
p.type_id,
Location(
p.type_id.position.sline,
p.type_id.position.scol,
eline=p.name_id.position.sline,
ecol=p.name_id.position.scol,
),
)
def variable_assign(self, p):
return ast.variables.VariableAssign(
p.name_id,
p.expr,
Location(
p.name_id.position.sline,
p.name_id.position.scol,
eline=p.expr.position.sline,
ecol=p.expr.position.scol,
),
)
def namespace(self, p):
namespace = ast.primitives.Namespace(
p.name_id0,
Location(
p.name_id0.position.sline,
p.name_id0.position.scol,
eline=p.name_id1.position.sline,
ecol=p.name_id1.position.scol,
),
)
namespace.push(p.name_id1)
return namespace
def _codegen_FunctionDefinition(self, node, func):
old_symtab = copy.deepcopy(self.symtab)
self.symtab = {}
func.linkage = "private" if not node.public else "external"
entry_block = func.append_basic_block("entry")
self.builder = ir.IRBuilder(entry_block)
for i, arg in enumerate(func.args):
arg.name = node.arguments.positional_arguments.arguments[i].name
alloca = self.builder.alloca(
self._codegen(
node.arguments.positional_arguments.arguments[i].type),
name=arg.name,
)
self.builder.store(arg, alloca)
self.symtab[arg.name] = alloca
if node.block.__class__.__name__ == "Block":
for statement in node.block.statements:
if statement.__class__.__name__ == "Return" and node.return_none:
continue
self._codegen(statement)
if node.return_none:
self._codegen_Return(
dast.functions.Return(
dast.primitives.Integer(0, Location(0, 0)),
Location(0, 0)))
else:
self._codegen_Return(
dast.functions.Return(node.block, Location(0, 0)))
self.symtab = old_symtab
return func
def integer(self, p):
return ast.primitives.Integer(p.INT, Location(p.lineno, p.index))
def string(self, p):
return ast.primitives.String(p.STRING, Location(p.lineno, p.index))
def empty_node():
node = ast.node.Node()
node.position = Location(0, 0, eline=0, ecol=0)
return node
def ref_id(self, p):
return ast.primitives.RefID(p.ID, Location(p.lineno, p.index))
def name_id(self, p):
return ast.primitives.NameID(p.ID, Location(p.lineno, p.index))
def type_id(self, p):
return ast.primitives.Type(p.ID, Location(p.lineno, p.index))
def expr(self, p):
return ast.maths.Mod(
p.expr0,
p.expr1,
Location(p.expr0.position.sline, p.expr0.position.scol),
)
def expr(self, p):
return ast.maths.Neg(
p.expr, Location(p.expr.position.sline, p.expr.position.scol))
