Interpreter for a Python-like Language (ANTLR and Python)

Question

Code for grammar

grammar EpicLang;
Break : 'break';
Do : 'do';
Continue : 'continue';
Else : 'else';
Func : 'func';
For : 'for';
If : 'if';
Then : 'then';
Len : 'len';
NoneObj : 'none';
Print : 'print';
Return : 'return';
While : 'while';
TrueLiteral : 'true';
FalseLiteral : 'false';
// Lexer rules
LINE_COMMENT
 : '//' ~[\r\n]* -> skip;
NUMBER: [0-9]+;
SPACE: [ \t\n]+ -> skip;
VARIABLE: [a-zA-Z_][a-zA-Z0-9_]*;
// Parser rules
program: functionDecl* EOF;
block: '{' stmt* '}';
identifier: var=VARIABLE;
functionDecl: Func (name=VARIABLE) '(' (identifier (',' identifier)* )? ')' block;
stmt: block # BlockStmt
 | Print expr ';'# PrintStmt
 | Continue ';' # ContinueStmt
 | Break ';' # BreakStmt
 | Return expr? ';' # ReturnStmt
 | If expr Then stmt # IfStmt
 | If expr Then stmt Else stmt # IfElseStmt
 | For var=VARIABLE 'in' (lbound=expr) '..' (ubound=expr) Do stmt # ForStmt
 | While expr Do stmt # WhileStmt
 | (var=VARIABLE) '=' (rhs=expr) ';'# AssignStmt
 | expr '[' expr ']' '=' expr # AssignIdxStmt
 | expr ';' # SingleStmt
 | ';' # NullStmt
 ;
expr: (name=VARIABLE) '(' (expr (',' expr)*)? ')' # FuncCall
 | '(' expr ')' # ParenExpr
 | expr '[' expr ']' # IndexExpr
 | op=('+' | '-' | '!' | Len ) expr # UnaryExpr
 | expr op=('*' | '/' | '%' ) expr # BinExpr
 | expr op=('+' | '-') expr # BinExpr
 | expr op=('<' | '<=' | '>' | '>=' | '==' | '!=') expr #BinExpr
 | expr op=('&' | '|') expr #BinExpr
 | '[' (expr (',' expr)*)? ']' #ListExpr
 | TrueLiteral #TrueLiteral
 | FalseLiteral #FalseLiteral
 | num=NUMBER # NumExpr
 | var=VARIABLE # VarExpr
 | NoneObj # NoneExpr
 ;

Code for Interpreter

import sys
from antlr4 import FileStream, CommonTokenStream
from antlr4.error.ErrorListener import ErrorListener, ConsoleErrorListener
from EpicLangLexer import EpicLangLexer
from EpicLangParser import EpicLangParser
from EpicLangVisitor import EpicLangVisitor
class BreakException(Exception):
 pass
class ContinueException(Exception):
 pass
class ReturnException(Exception):
 pass
# handler for syntax errors
class ErrorHandler(ErrorListener):
 def syntaxError(self, *args):
 print('syntax error')
 sys.exit(0)
class FunctionVisitor(EpicLangVisitor):
 def __init__(self):
 self.vars = {}
 self.funcs = {}
 def visitFunctionDecl(self, ctx):
 name = ctx.name.text
 if name in self.funcs:
 print('runtime error')
 exit(0)
 params = ctx.identifier() if hasattr(ctx, 'identifier') else []
 params = [self.visit(x) for x in params]
 self.funcs[name] = (params, ctx.block())
 def visitIdentifier(self, ctx):
 return ctx.var.text
class GoatVisitor(EpicLangVisitor):
 def __init__(self, variables=None, funcs=None):
 self.variables = variables or {}
 self.funcs = funcs or {}
 self.retval = None
 def visitBlock(self, ctx):
 for stmt in ctx.stmt():
 self.visit(stmt)
 def visitPrintStmt(self, ctx):
 print(self.visit(ctx.expr()))
 def visitBinExpr(self, ctx):
 left = self.visit(ctx.expr()[0])
 right = self.visit(ctx.expr()[1])
 if type(left) != type(right):
 print('runtime error')
 exit(0)
 op = {
 '+': lambda a, b: a + b,
 '-': lambda a, b: a - b,
 '*': lambda a, b: a * b,
 '/': lambda a, b: a // b,
 '%': lambda a, b: a % b,
 '&' : lambda a, b: a & b,
 '|' : lambda a, b: a | b,
 '<' : lambda a, b: a < b,
 '<=' : lambda a, b: a <= b,
 '>' : lambda a, b: a > b,
 '>=' : lambda a, b: a >= b,
 '==' : lambda a, b: a == b,
 '!=' : lambda a, b: a != b
 }
 try:
 return op[ctx.op.text](left, right)
 except (TypeError, ValueError, ZeroDivisionError):
 print('runtime error')
 exit(0)
 def visitUnaryExpr(self, ctx):
 op = {
 '+' : lambda x: x,
 '-' : lambda x: -x,
 '!' : lambda x: not x,
 'len' : len
 }
 try:
 return op[ctx.op.text](self.visit(ctx.expr()))
 except (TypeError, ValueError, ZeroDivisionError):
 print('runtime error')
 exit(0)
 def visitParenExpr(self, ctx):
 return self.visit(ctx.expr())
 def visitNumExpr(self, ctx):
 return int(ctx.num.text)
 def visitTrueLiteral(self, ctx):
 return True
 def visitFalseLiteral(self, ctx):
 return False
 def visitIfStmt(self, ctx):
 cond = self.visit(ctx.expr())
 if not isinstance(cond, bool):
 print('runtime error')
 exit(0)
 if cond:
 self.visit(ctx.stmt())
 def visitIfElseStmt(self, ctx):
 cond = self.visit(ctx.expr())
 if not isinstance(cond, bool):
 print('runtime error')
 exit(0)
 if cond:
 self.visit(ctx.stmt()[0])
 else:
 self.visit(ctx.stmt()[1])
 def visitWhileStmt(self, ctx):
 while True:
 cond = self.visit(ctx.expr())
 if not isinstance(cond, bool):
 print('runtime error')
 exit(0)
 if not cond:
 break
 try:
 self.visit(ctx.stmt())
 except BreakException:
 break
 except ContinueException:
 continue
 def visitBreakStmt(self, ctx):
 raise BreakException()
 def visitContinueStmt(self, ctx):
 raise ContinueException()
 def visitNoneObj(self, ctx):
 return None
 def visitFuncCall(self, ctx):
 fname = ctx.name.text
 if fname not in self.funcs:
 print('runtime error')
 exit(0)
 (formal_parameters, function_body) = self.funcs[fname]
 actual_parameters = []
 if ctx.expr():
 actual_parameters = [self.visit(param) for param in ctx.expr()]
 if len(actual_parameters) != len(formal_parameters):
 print('runtime error')
 exit(0)
 stack_frame = dict(zip(formal_parameters, actual_parameters))
 visitor = GoatVisitor(stack_frame, self.funcs)
 try:
 visitor.visit(function_body)
 except BreakException:
 print('runtime error')
 exit(0)
 except ContinueException:
 print('runtime error')
 exit(0)
 except ReturnException:
 pass
 return visitor.retval
 def visitReturnStmt(self, ctx):
 x = ctx.expr()
 if x:
 self.retval = self.visit(x)
 raise ReturnException
 def visitForStmt(self, ctx):
 var = ctx.var.text
 lbound = self.visit(ctx.lbound)
 ubound = self.visit(ctx.ubound)
 if (not isinstance(lbound, int)) or (not isinstance(ubound, int)):
 print("runtime error")
 exit(0)
 need_restore = False
 if var in self.variables:
 need_restore = True
 restore_val = self.variables[var]
 for i in range(lbound, ubound):
 self.variables[var] = i
 try:
 self.visit(ctx.stmt())
 except BreakException:
 break
 except ContinueException:
 continue
 if need_restore:
 self.variables[var] = restore_val
 def visitListExpr(self, ctx):
 return [self.visit(x) for x in ctx.expr()] if ctx.expr() else []
 def visitIndexExpr(self, ctx):
 base = self.visit(ctx.expr()[0])
 idx = self.visit(ctx.expr()[1])
 try:
 return base[idx]
 except (TypeError, ValueError, IndexError):
 print("runtime error")
 exit(0)
 def visitVarExpr(self, ctx):
 var = ctx.var.text
 try:
 return self.variables[var]
 except KeyError:
 print("runtime error")
 exit(0)
 def visitAssignStmt(self, ctx):
 var = ctx.var.text
 self.variables[var] = self.visit(ctx.rhs)
 def visitAssignIdxStmt(self, ctx):
 base = self.visit(ctx.expr()[0])
 idx = self.visit(ctx.expr()[1])
 rhs = self.visit(ctx.expr()[2])
 try:
 base[idx] = rhs
 except (TypeError, ValueError, IndexError):
 print("runtime error")
 exit(0)
def main():
 # create input stream
 in_stream = FileStream(sys.argv[1])
 # create a lexer
 lexer = EpicLangLexer(in_stream)
 # add error handling for our lexer
 lexer.addErrorListener(ErrorHandler())
 lexer.removeErrorListener(ConsoleErrorListener.INSTANCE)
 # create a parser with the lexer as an input
 stream = CommonTokenStream(lexer)
 parser = EpicLangParser(stream)
 # add error handling for our parser
 parser.addErrorListener(ErrorHandler())
 parser.removeErrorListener(ConsoleErrorListener.INSTANCE)
 # use the parser to obtain an abstract syntax tree
 tree = parser.program()
 visitor = FunctionVisitor()
 visitor.visit(tree)
 if ('main' not in visitor.funcs) or (visitor.funcs['main'][0]):
 print("runtime error")
 exit(0)
 visitor2 = GoatVisitor({}, visitor.funcs)
 try:
 visitor2.visit(visitor.funcs['main'][1])
 except BreakException:
 print("runtime error")
 exit(0)
 except ContinueException:
 print("runtime error")
if __name__ == "__main__":
 main()

Example program:

func main() {
 count = 500;
 is_prime = [false, false];
 while len(is_prime) < count do
 is_prime = is_prime + [true];
 for i in 2..count do {
 if !is_prime[i] then continue;
 j = i*i;
 while j < count do {
 is_prime[j] = false;
 j = j + i;
 }
 }
 primes = [];
 for i in 0..count do {
 if is_prime[i] then
 primes = primes + [i];
 }
 print(primes);
}

• ggorlen: Sample code for the language would be helpful.
• Dean Menezes: github.com/menezesd/epic-lang/tree/master/tests