def p_class_def(p): """ class_def : CLASS TYPE INHERITS TYPE OCUR feature_list CCUR | CLASS TYPE OCUR feature_list CCUR """ if len(p) == 8: p[0] = ast.ClassDeclarationNode(p[2], p[6], p[4]) p[0].parent_pos = (p.lineno(4), find_column(p.lexer.lexdata, p.lexpos(4))) else: p[0] = ast.ClassDeclarationNode(p[2], p[4]) p[0].set_pos(p.lineno(2), find_column(p.lexer.lexdata, p.lexpos(2)))
def p_param_list(p): """ param_list : ID COLON TYPE COMMA param_list | ID COLON TYPE """ param = ast.ParamNode(p[1], p[3]) param.set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) param.type_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3))) if len(p) == 6: p[0] = [param] + p[5] elif len(p) == 4: p[0] = [param]
def p_attr_def(p): """ attr_def : ID COLON TYPE ASSIGN expr | ID COLON TYPE """ if len(p) == 6: p[0] = ast.AttrDeclarationNode(p[1], p[3], p[5]) p[0].expr_pos = p[5].pos else: p[0] = ast.AttrDeclarationNode(p[1], p[3]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) p[0].type_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3)))
def p_func_def(p): """ func_def : ID OPAR param_list CPAR COLON TYPE OCUR expr CCUR | ID OPAR CPAR COLON TYPE OCUR expr CCUR """ if len(p) == 10: p[0] = ast.FuncDeclarationNode(p[1], p[3], p[6], p[8]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) p[0].type_pos = (p.lineno(6), find_column(p.lexer.lexdata, p.lexpos(6))) else: p[0] = ast.FuncDeclarationNode(p[1], [], p[5], p[7]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) p[0].type_pos = (p.lineno(5), find_column(p.lexer.lexdata, p.lexpos(5)))
def p_case_list(p): """ case_list : ID COLON TYPE ARROW expr SEMI case_list | ID COLON TYPE ARROW expr SEMI """ branch = ast.CaseBranchNode(p[1], p[3], p[5]) branch.set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) branch.type_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3))) if len(p) == 8: p[0] = [branch] + p[7] else: p[0] = [branch]
def p_expr_int(p): """ expr : INT """ p[0] = ast.IntegerNode(p[1]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_id(p): """ expr : ID """ p[0] = ast.VariableNode(p[1]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_func_call(p): """ expr : ID OPAR expr_list CPAR | expr DOT ID OPAR expr_list CPAR | expr AT TYPE DOT ID OPAR expr_list CPAR """ if len(p) == 5: p[0] = ast.CallNode(p[1], p[3]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) elif len(p) == 7: p[0] = ast.CallNode(p[3], p[5], p[1]) p[0].set_pos(p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3))) else: p[0] = ast.CallNode(p[5], p[7], p[1], p[3]) p[0].set_pos(p.lineno(5), find_column(p.lexer.lexdata, p.lexpos(5))) p[0].parent_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3)))
def p_expr_comp(p): """ expr : COMP expr """ p[0] = ast.ComplementNode(p[2]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_binary_op(p): """ expr : expr PLUS expr | expr MINUS expr | expr STAR expr | expr DIV expr | expr LESS expr | expr LEQ expr | expr EQ expr """ if p[2] == '+': p[0] = ast.PlusNode(p[1], p[2], p[3]) elif p[2] == '-': p[0] = ast.MinusNode(p[1], p[2], p[3]) elif p[2] == '/': p[0] = ast.DivNode(p[1], p[2], p[3]) elif p[2] == '*': p[0] = ast.StarNode(p[1], p[2], p[3]) elif p[2] == '<': p[0] = ast.LessThanNode(p[1], p[2], p[3]) elif p[2] == '<=': p[0] = ast.LessEqualNode(p[1], p[2], p[3]) else: p[0] = ast.EqualNode(p[1], p[2], p[3]) p[0].set_pos(p.lineno(2), find_column(p.lexer.lexdata, p.lexpos(2)))
def p_expr_case(p): """ expr : CASE expr OF case_list ESAC """ p[0] = ast.CaseNode(p[2], p[4]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_let(p): """ expr : LET decl_list IN expr """ p[0] = ast.LetNode(p[2], p[4]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_block(p): """ expr : OCUR block CCUR """ p[0] = ast.BlockNode(p[2]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_while(p): """ expr : WHILE expr LOOP expr POOL """ p[0] = ast.WhileNode(p[2], p[4]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_if(p): """ expr : IF expr THEN expr ELSE expr FI """ p[0] = ast.ConditionalNode(p[2], p[4], p[6]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_string(p): """ expr : STRING """ p[0] = ast.StringNode(p[1]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_bool(p): """ expr : BOOL """ p[0] = ast.BooleanNode(p[1]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_new(p): """ expr : NEW TYPE """ p[0] = ast.InstantiateNode(p[2]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_isvoid(p): """ expr : ISVOID expr """ p[0] = ast.IsVoidNode(p[2]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_not(p): """ expr : NOT expr """ p[0] = ast.NegationNode(p[2]) p[0].set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1)))
def p_expr_assign(p): """ expr : ID ASSIGN expr """ p[0] = ast.AssignNode(p[1], p[3]) p[0].set_pos(p.lineno(2), find_column(p.lexer.lexdata, p.lexpos(2)))
def p_decl_list(p): """ decl_list : ID COLON TYPE ASSIGN expr COMMA decl_list | ID COLON TYPE COMMA decl_list | ID COLON TYPE ASSIGN expr | ID COLON TYPE """ if len(p) > 4 and p[4] == '<-': declaration = ast.LetDeclarationNode(p[1], p[3], p[5]) declaration.type_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3))) declaration.expr_pos = p[5].pos declaration.set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) if len(p) == 8: p[0] = [declaration] + p[7] else: p[0] = [declaration] else: declaration = ast.LetDeclarationNode(p[1], p[3]) declaration.type_pos = (p.lineno(3), find_column(p.lexer.lexdata, p.lexpos(3))) declaration.set_pos(p.lineno(1), find_column(p.lexer.lexdata, p.lexpos(1))) if len(p) == 6: p[0] = [declaration] + p[5] else: p[0] = [declaration]
def t_COMM_eof(t: lex.LexToken): line, col = t.lexer.lineno, find_column(t.lexer.lexdata, t.lexpos) errors.append(err.EOF_COMM % (line, col))
def t_STR_error(t: lex.LexToken): t.lexer.skip(1) line, col = t.lexer.lineno, find_column(t.lexer.lexdata, t.lexpos) errors.append(err.EOF_STR % (line, col))
def t_STR_newline(t: lex.LexToken): line, col = t.lexer.lineno, find_column(t.lexer.lexdata, t.lexpos) errors.append(err.UNT_STR % (line, col)) t.lexer.lineno += len(t.value) t.lexer.pop_state()
def t_error(t: lex.LexToken): t.lexer.skip(1) line, col = t.lexer.lineno, find_column(t.lexer.lexdata, t.lexpos) errors.append(err.LEX_ERROR % (line, col, t.value[0]))
def p_error(p): if p: line, col = p.lineno, find_column(p.lexer.lexdata, p.lexpos) errors.append(err.SYN_ERROR % (line, col, p.value)) else: errors.append(err.SYN_EOF)