Ast.java

package compiler.ast; 

import java.io.*;
import compiler.parser.*;
import compiler.lib.*;

import org.antlr.v4.runtime.tree.*;

public class Ast{
	
	private CC4Parser parser;
	private PrintWriter output;
	private Debug d;
	
	public Ast(CC4Parser p){
		parser = p;
		output = parser.output();
		d = new Debug(Constants.AST);
	}
	
	public void start() throws IOException{
		ParseTree tree = parser.parse();
		
		d.p("debugging: ast");
		output.println("stage: ast");
		
		AstVisitor visitor = new AstVisitor();
		Root root = (Root)visitor.visit(tree);
		
		root.print();
	}
	
	public PrintWriter output(){
		return output;
	}
}

AstVisitor.java

package compiler.ast;

import java.util.List;
import org.antlr.v4.runtime.tree.TerminalNode;
import compiler.parser.DecafParser;
import compiler.parser.DecafParserBaseVisitor;

public class AstVisitor extends DecafParserBaseVisitor<Node>{
	
	@Override
	public Node visitLine(DecafParser.LineContext ctx){
		Root root = new Root();
		List<DecafParser.ExpContext> list = ctx.exp();
		
		for(DecafParser.ExpContext e : list){
			root.add(visit(e));
		}
		return root;
	}
	
	@Override
	public Node visitInt(DecafParser.IntContext ctx){
		return new IntLiteral(ctx.INTEGER().getText());
	}
	
	@Override
	public Node visitFloat(DecafParser.FloatContext ctx){
		return new FloatLiteral(ctx.FLOAT().getText());
	}
	
	@Override
	public Node visitParen(DecafParser.ParenContext ctx){
		return visit(ctx.exp());
	}
	
	@Override
	public Node visitPlusMinus(DecafParser.PlusMinusContext ctx){
		TerminalNode op = ctx.MINUS() == null ? ctx.PLUS() : ctx.MINUS();
		return new BinOp(op.getText(), visit(ctx.exp(0)), visit(ctx.exp(1)));
	}
	
	@Override
	public Node visitTimesDiv(DecafParser.TimesDivContext ctx){
		TerminalNode op = ctx.DIV() == null ? ctx.TIMES() : ctx.DIV();
		return new BinOp(op.getText(), visit(ctx.exp(0)), visit(ctx.exp(1)));
	}
}

BinOp.java

package compiler.ast;

public class BinOp extends Node{
	private String operator;
	private Node left;
	private Node right;
	
	public BinOp(String op, Node l, Node r){
		operator = op;
		left = l;
		right = r;
	}
	
	public void print(String padding){
		System.out.println(padding + operator);
		left.print(padding + "\t");
		right.print(padding + "\t");
	}
} 

FloatLiteral.java

package compiler.ast;

public class FloatLiteral extends Node{
	private float value;
	
	public FloatLiteral(String v){
		value = Float.parseFloat(v);
	}
	
	public void print(String padding){
		System.out.println(padding + value);
	}
}

IntLiteral.java

package compiler.ast;

public class IntLiteral extends Node{
	private int value;
	
	public IntLiteral(String v){
		value = Integer.parseInt(v);
	}
	
	public void print(String padding){
		System.out.println(padding + value);
	}
}

Node.java

package compiler.ast;

public abstract class Node{
	public abstract void print(String padding);
} 

Parser.g

parser grammar Parser;

options{
  tokenVocab = Lexer;
}

@parser::header{
  package compiler.parser;
}

list		:	(exp SEMI)*			# line
		;

exp		:	exp (TIMES | DIV) exp		# timesDiv
		|	exp (PLUS | MINUS) exp		# plusMinus
		|	LPAREN exp RPAREN		# paren
		|	INTEGER				# int
		|	FLOAT				# float
		;

Root.java

package compiler.ast;

import java.util.List;
import java.util.LinkedList;

public class Root extends Node{
	private List<Node> list;
	
	public Root(){
		list = new LinkedList<Node>();
	}
	
	public void add(Node node){
		list.add(node);
	}
	
	public void print(String padding){
		for(Node n : list){
			System.out.println("exp ->");
			n.print(padding + "\t");
		}
	}
	
	public void print(){
		print("");
	}
}