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); } 
