VariableDeclarationNode.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.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.ast.impl.ASTNode;

public class VariableDeclarationNode extends ASTNode implements VariableDeclarationNodeIF {

	private IdentifierNodeIF identifier;
	private TypeNodeIF type;
	private ExpressionNodeIF initializer = null;
	private boolean isConst;
	private boolean isVolatile;
	private boolean isRestrict;
	private StorageClass storageClass;
	
	public VariableDeclarationNode(long id) {
		super(id);
	}
	
	public VariableDeclarationNode(long id, IdentifierNodeIF identifier, TypeNodeIF type) {
		super(id);
		this.identifier = identifier;
		this.type = type;
	}

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

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

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

	@Override
	public IdentifierNodeIF identifier() {
		return identifier;
	}

	@Override
	public TypeNodeIF type() {
		return type;
	}

	@Override
	public ExpressionNodeIF initializer() {
		return initializer;
	}


	@Override
	public StorageClass storageClass() {
		return storageClass;
	}

	@Override
	public void setConst(boolean mIsConst) {
		isConst = mIsConst;
	}

	@Override
	public void setVolatile(boolean mIsVolatile) {
		isVolatile = mIsVolatile;
	}

	@Override
	public void setRestrict(boolean mIsRestrict) {
		isRestrict = mIsRestrict;
	}

	@Override
	public void setIdentifier(IdentifierNodeIF mIdentifier) {
		identifier = mIdentifier;
	}

	@Override
	public void setType(TypeNodeIF mType) {
		type = mType;
	}

	@Override
	public void setInitializer(ExpressionNodeIF initializer) {
		this.initializer = initializer;
	}

	@Override
	public void setStorageClass(StorageClass storageClass) {
		this.storageClass = storageClass;
	}
	
	@Override
	public int numChildren() {
		return 3;
	}
	
	/** 
	 * Children are:
	 * 0 : Name
	 * 1 : Type
	 * 2 : Initializer
	 */
	@Override
	public void setChild(int i, ASTNodeIF child) throws NoSuchElementException {
		switch (i) {
		case 0:
			this.identifier = (IdentifierNodeIF) child;
			break;
		case 1:
			this.type = (TypeNodeIF) child;
			break;
		case 2:
			this.initializer = (ExpressionNodeIF) child;
			break;
		default:
			throw new NoSuchElementException("Node " + id() + " does not have a child with index " + i + ".");
		}
	}
	
	@Override
	public ASTNodeIF child(int index) throws NoSuchElementException {
		switch (index) {
		case 0:
			return identifier;
		case 1:
			return type;
		case 2:
			return initializer;
		default:
			throw new NoSuchElementException("Node " + id() + " does not have a child with index " + index + ".");
		}
	}

	@Override
	protected String nodeType() {
		return "Variable Declaration";
	}
	
	@Override
	public String toString() {
		return super.toString()
			+ " isConst: " + isConst
			+ " isVolatile: " + isVolatile
			+ " isRestrict: " + isRestrict
			+ " storageClass: " + storageClass;
	}

    @Override
    public void toXml(String prefix, PrintWriter out,AbstractSyntaxTreeIF ast) {
		super.toXml(prefix,out,ast);
		
        out.println(prefix+"<vdn:uniqueVariableId>"+id()+"</vdn:uniqueVariableId>");
		
        out.println(prefix+"<vdn:name>");
        identifier.toXml(prefix+"  ",out,ast);
        out.println(prefix+"</vdn:name>");

        out.println(prefix+"<vdn:type>");
        type.toXml(prefix+"  ",out,ast);
        out.println(prefix+"</vdn:type>");

        if (initializer != null) {
            out.println(prefix+"<vdn:initializer>");
            initializer.toXml(prefix+"  ",out,ast);
            out.println(prefix+"</vdn:initializer>");
        }

        if (isConst) {
            out.println(prefix+"<vdn:isConst>"+isConst+"</vdn:isConst>");
        }

        if (isVolatile) {
            out.println(prefix+"<vdn:isVolatile>"+isVolatile+"</vdn:isVolatile>");
        }

        if (isRestrict) {
            out.println(prefix+"<vdn:isRestrict>"+isRestrict+"</vdn:isRestrict>");
        }

        if (storageClass != null) {
            out.println(prefix+
                        "<vdn:storageClass>"+
                        storageClass+
                        "</vdn:storageClass>");
        }
    }
}