GlobalVariableDeclarationNode.java

package edu.udel.cis.vsl.tass.ast.impl.declaration;

import java.io.PrintWriter;
import java.util.NoSuchElementException;

import edu.udel.cis.vsl.tass.ast.IF.ASTNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.AbstractSyntaxTreeIF;
import edu.udel.cis.vsl.tass.ast.IF.IdentifierNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.GlobalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.VariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.ExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.TypeNodeIF;
import edu.udel.cis.vsl.tass.model.IF.SyntaxException;

public class GlobalVariableDeclarationNode extends VariableDeclarationNode
		implements GlobalVariableDeclarationNodeIF {

	private boolean isDefinition;
	private VariableDeclarationNodeIF definition;
	private boolean isInput;
	private boolean isOutput;
	private boolean isShared;
	private ExpressionNodeIF inputAssumption;
	
	public GlobalVariableDeclarationNode(long id) {
		super(id);
	}
	
	public GlobalVariableDeclarationNode(long id, IdentifierNodeIF identifier,
			TypeNodeIF type) {
		super(id, identifier, type);
	}

	@Override
	public boolean isDefinition() {
		return isDefinition;
	}

	@Override
	public VariableDeclarationNodeIF definition() {
		return definition;
	}

	@Override
	public boolean isInput() {
		return isInput;
	}

	@Override
	public boolean isOutput() {
		return isOutput;
	}

	@Override
	public boolean isShared() {
		return isShared;
	}

	@Override
	public void setIsDefinition(boolean isDefinition) {
		this.isDefinition = isDefinition;
	}

	@Override
	public void setDefinition(VariableDeclarationNodeIF definition) {
		this.definition = definition;
	}

	@Override
	public void setIsInput(boolean isInput) {
		this.isInput = isInput;
	}

	@Override
	public void setIsOutput(boolean isOutput) {
		this.isOutput = isOutput;
	}

	@Override
	public void setIsShared(boolean isShared) {
		this.isShared = isShared;
	}
	
	@Override
	public int numChildren() {
		return 4;
	}

	@Override
	@SuppressWarnings("fallthrough")
	public void setChild(int i, ASTNodeIF child) throws NoSuchElementException {
		switch (i) {
		case 0:
			//Fallthrough
		case 1:
			//Fallthrough
		case 2:
			super.setChild(i,child);
			break;
		case 3:
			definition = (VariableDeclarationNodeIF) child;
			break;
		default:
			throw new NoSuchElementException("Node " + id() + " does not have a child with index " + i + ".");
		}
	}
	
	@Override
	@SuppressWarnings("fallthrough")
	public ASTNodeIF child(int index) throws NoSuchElementException {
		switch (index) {
		case 0:
			//Fallthrough
		case 1:
			//Fallthrough
		case 2:
			return super.child(index);
		case 3:
			return definition;
		default:
			throw new NoSuchElementException("Node " + id() + " does not have a child with index " + index + ".");
		}
	}

	@Override
	protected String nodeType() {
		return "Global Variable Declaration";
	}
	
	@Override
	public String toString() {
		return super.toString()
			+ " isShared: " + isShared
			+ " isOutput: " + isOutput
			+ " isInput: " + isInput
			+ " isDefinition: " + isDefinition;
	}

	@Override
	public void toXml(String prefix, PrintWriter out,AbstractSyntaxTreeIF ast) {
		super.toXml(prefix,out,ast);
		if (!isDefinition) {
			assert definition != null;
			out.println(prefix+"<gvdn:definitionRef>"+
						definition.id()+"</gvdn:definitionRef>");
		} else {
			out.println(prefix+"<gvdn:isDefinition />");
		}
		if (isInput) {
			out.println(prefix+"<gvdn:isInput />");
		}
		if (isOutput) {
			out.println(prefix+"<gvdn:isOutput />");
		}
		if (isShared) {
			out.println(prefix+"<gvdn:isShared />");
		}
	}

	@Override
	public ExpressionNodeIF inputAssumption() throws SyntaxException {
		if (!isInput) {
			throw new SyntaxException(this, "Only input variables can have assumptions");
		}
		return inputAssumption;
	}

	@Override
	public void setInputAssumption(ExpressionNodeIF inputAssumption) {
		this.inputAssumption = inputAssumption;
	}
}