AST.java

package edu.udel.cis.vsl.tass.front.minimp.ast.misc;

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import edu.udel.cis.vsl.tass.front.minimp.ast.declaration.ASTAbstractFunctionDeclaration;
import edu.udel.cis.vsl.tass.front.minimp.ast.declaration.ASTDeclarationIF;
import edu.udel.cis.vsl.tass.front.minimp.ast.declaration.ASTFunctionDeclaration;
import edu.udel.cis.vsl.tass.front.minimp.ast.expression.ASTExpressionIF;
import edu.udel.cis.vsl.tass.front.minimp.ast.statement.ASTStatementIF;
import edu.udel.cis.vsl.tass.front.minimp.ast.type.ASTTypeIF;

public class AST {

	private Collection<String> libraryNames;

	private Map<String, ASTDeclarationIF> globalVariableMap;

	private List<ASTFunctionDeclaration> functionList;

	private List<ASTAbstractFunctionDeclaration> abstractFunctionList;

	private List<ASTDeclarationIF> globalVariableList;

	private Map<String, ASTTypeIF> typeNameMap;

	private Map<String, ASTExpressionIF> constantMap = null;

	private Map<String, ASTFunctionDeclaration> functionMap = new LinkedHashMap<String, ASTFunctionDeclaration>();

	private Map<String, ASTAbstractFunctionDeclaration> abstractFunctionMap = new LinkedHashMap<String, ASTAbstractFunctionDeclaration>();

	public AST(Map<String, ASTDeclarationIF> varMap,
			List<ASTDeclarationIF> varList,
			List<ASTFunctionDeclaration> functionList) {
		this.globalVariableMap = varMap;
		this.globalVariableList = varList;
		this.functionList = functionList;
		this.abstractFunctionList = null;
		for (ASTFunctionDeclaration decl : functionList)
			functionMap.put(decl.getName().toString(), decl);
	}

	public AST(Collection<String> libraryNames,
			LinkedHashMap<String, ASTDeclarationIF> varMap,
			List<ASTDeclarationIF> varList,
			List<ASTFunctionDeclaration> functionList,
			List<ASTAbstractFunctionDeclaration> abstractFunctionList,
			Map<String, ASTTypeIF> typeNameMap,
			Map<String, ASTExpressionIF> constantMap) {
		this.libraryNames = libraryNames;
		this.globalVariableMap = varMap;
		this.globalVariableList = varList;
		this.functionList = functionList;
		this.abstractFunctionList = abstractFunctionList;
		this.typeNameMap = typeNameMap;
		this.constantMap = constantMap;
		for (ASTFunctionDeclaration decl : functionList)
			functionMap.put(decl.getName().toString(), decl);
		for (ASTAbstractFunctionDeclaration decl : abstractFunctionList)
			abstractFunctionMap.put(decl.getName().toString(), decl);
	}

	public AST(Map<String, ASTDeclarationIF> varMap,
			List<ASTDeclarationIF> varList,
			List<ASTFunctionDeclaration> functionList,
			List<ASTAbstractFunctionDeclaration> abstractFunctionList) {
		this.libraryNames = new LinkedList<String>();
		this.globalVariableMap = varMap;
		this.globalVariableList = varList;
		this.functionList = functionList;
		this.abstractFunctionList = abstractFunctionList;
	}

	public Collection<String> getLibraryNames() {
		return libraryNames;
	}

	public Map<String, ASTDeclarationIF> getGlobalVariableMap() {
		return globalVariableMap;
	}

	public List<ASTFunctionDeclaration> getFunctionList() {
		return this.functionList;
	}

	public List<ASTAbstractFunctionDeclaration> getAbstractFunctionList() {
		return this.abstractFunctionList;
	}

	public Map<String, ASTTypeIF> getTypeNameMap() {
		return this.typeNameMap;
	}

	public List<ASTDeclarationIF> getGlobalVariableList() {
		return this.globalVariableList;
	}

	public Map<String, ASTExpressionIF> getConstantMap() {
		return this.constantMap;
	}

	public ASTStatementIF getStatement(String functionName, String label) {
		for (ASTFunctionDeclaration decl : this.functionList) {
			if (decl.getName().toString().equals(functionName)) {
				return decl.getStatement(label);
			}
		}
		return null;
	}

	public boolean hasVariable(ASTIdentifier functionName,
			ASTIdentifier variableName) {
		for (ASTFunctionDeclaration decl : this.functionList) {
			if (decl.getName().toString().equals(functionName.toString())) {
				if (decl.getBody().getLocalVariableMap().containsKey(
						variableName.toString())) {
					return true;
				}
			}
		}
		if (this.globalVariableMap.containsKey(variableName.toString())) {
			return true;
		}
		return false;
	}

	public ASTDeclarationIF getVariable(ASTIdentifier functionName,
			ASTIdentifier variableName) {
		for (ASTFunctionDeclaration decl : this.functionList) {
			if (decl.getName().toString().equals(functionName.toString())) {
				if (decl.getBody().getLocalVariableMap().containsKey(
						variableName.toString())) {
					return decl.getBody().getLocalVariable(
							variableName.toString());
				}
			}
		}
		return this.globalVariableMap.get(variableName.toString());
	}

	public boolean hasFunction(String name) {
		for (ASTFunctionDeclaration decl : this.functionList) {
			if (decl.getName().toString().equals(name)) {
				return true;
			}
		}
		return false;
	}

	public ASTFunctionDeclaration getFunction(String name) {
		return functionMap.get(name);
	}

	public ASTAbstractFunctionDeclaration getAbstractFunction(String name) {
		return abstractFunctionMap.get(name);
	}

	public String toString() {
		String result = "Beginning program: \n";
		if (globalVariableMap != null) {
			result += "Begin global variables:\n";
			for (ASTDeclarationIF decl : globalVariableMap.values()) {
				result += decl.toString() + "\n";
			}
			result += "End global variables\n";
		}
		result += "Begin functions:\n";
		for (ASTFunctionDeclaration decl : functionList) {
			result += decl.toString() + "\n";
		}
		result += "End functions.\n Program ended.\n";
		return result;
	}

}