ASTFactory.java

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

import java.io.File;
import java.util.ArrayList;

import edu.udel.cis.vsl.tass.ast.IF.ASTFactoryIF;
import edu.udel.cis.vsl.tass.ast.IF.ASTNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.ASTTransformerLoaderIF;
import edu.udel.cis.vsl.tass.ast.IF.FileNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.IdentifierNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.LabelNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.LabelReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.PairNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.ReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.RootNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.SequenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.SizeableNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.TypeDefinitionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.AbstractFunctionDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.BoundVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.FormalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.FunctionDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.GlobalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.LocalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.VariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.ArrayInitializerNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.AssignmentNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.BindingExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.BindingExpressionNodeIF.Quantifier;
import edu.udel.cis.vsl.tass.ast.IF.expression.CastNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.CharacterLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.DereferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.EnumElementReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.ExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FieldReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FunctionApplicationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FunctionInvocationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FunctionReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.IncrementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.IntegerLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.LHSExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.LiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.OperatorNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.OperatorNodeIF.AST_OPERATOR;
import edu.udel.cis.vsl.tass.ast.IF.expression.ProcessReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.PureExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.RealLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.SizeOfNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.StartOfNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.StringLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.StructInitializerNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.SubscriptNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.VariableReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.AssertStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.AssumeStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.BlockNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.BreakNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ContinueNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.DoUntilNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ExpressionStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ForLoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.GotoNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.IfThenElseStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.LoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.NoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.PragmaNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ReturnNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.StatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.SwitchStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.WhileLoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.ArrayTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.CompositeTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.EnumerationTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.FunctionTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.IntegerTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.PointerTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.RealTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.TypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.TypeReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.VectorTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.VoidTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.impl.declaration.AbstractFunctionDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.BoundVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.FormalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.FunctionDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.GlobalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.LocalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.ArrayInitializerNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.AssignmentNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.BindingExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.CastNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.CharacterLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.DereferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.EnumElementReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.FunctionInvocationNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.FunctionReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.IncrementNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.IntegerLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.OperatorNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.RealLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.StringLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.SubscriptNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.VariableReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.AssertStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.AssumeStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.BlockNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.BreakNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ContinueNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.DoUntilNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ExpressionStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ForLoopNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.FunctionApplicationNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.GotoNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.IfThenElseStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.NoopNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.PragmaNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ReturnNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.SwitchStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.WhileLoopNode;
import edu.udel.cis.vsl.tass.ast.impl.type.ArrayTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.BooleanTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.CharacterTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.CompositeTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.EnumerationTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.FunctionTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.IntegerTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.PointerTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.RealTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.TypeReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.type.VectorTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.VoidTypeNode;
import edu.udel.cis.vsl.tass.number.Numbers;
import edu.udel.cis.vsl.tass.number.IF.IntegerNumberIF;
import edu.udel.cis.vsl.tass.number.IF.RationalNumberIF;
import edu.udel.cis.vsl.tass.util.Pair;

/**
 * 
 * Leave one blank line after the decl section
 * 
 * Why so many TODOs still?
 * 
 * Reader: Stephen Siegel
 * 
 * @author Timothy Zirkel (zirkel)
 * @author Alex Stachnik (stachnik)
 * 
 */
public class ASTFactory implements ASTFactoryIF {

	private IdGenerator idGenerator = new IdGenerator();

	@Override
	public IdentifierNodeIF identifierNode(String name) {
		return new IdentifierNode(idGenerator.getId(), name);
	}

	@Override
	public LabelNodeIF labelNode(IdentifierNodeIF identifier,
			StatementNodeIF statement) {
		return new LabelNode(idGenerator.getId(), identifier, statement);
	}

	@Override
	public LabelNodeIF labelNode(IdentifierNodeIF identifier) {
		return labelNode(identifier, null);
	}

	@Override
	public LabelReferenceNodeIF labelReferenceNode(ASTNodeIF referent,
			IdentifierNodeIF identifier, LabelNodeIF reference) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ReferenceNodeIF referenceNode(ASTNodeIF referent,
			IdentifierNodeIF identifier) {
		return new ReferenceNode(idGenerator.getId(), identifier, referent);
	}

	@Override
	public RootNodeIF rootNode(FunctionDeclarationNodeIF mainFunction) {
		return new RootNode(idGenerator.getId(), mainFunction, null);
	}

	@Override
	public TypeDefinitionNodeIF typeDefinitionNode(IdentifierNodeIF name,
			TypeNodeIF type) {
		return new TypeDefinitionNode(idGenerator.getId(), name, type);
	}

	@Override
	public TypeNodeIF booleanTypeNode() {
		return new BooleanTypeNode(idGenerator.getId());
	}

	@Override
	public IntegerTypeNodeIF integerTypeNode() {
		// TODO Add parameters to indicate signedness and the type of int
		return new IntegerTypeNode(idGenerator.getId(), true,
				IntegerTypeNodeIF.IntType.INT);
	}

	@Override
	public RealTypeNodeIF realTypeNode() {
		// TODO Add parameters to indicate the type of the real
		return new RealTypeNode(idGenerator.getId(),
				RealTypeNodeIF.FloatType.DOUBLE);
	}

	@Override
	public TypeNodeIF characterTypeNode() {
		return new CharacterTypeNode(idGenerator.getId());
	}

	@Override
	public VoidTypeNodeIF voidTypeNode() {
		return new VoidTypeNode(idGenerator.getId());
	}

	@Override
	public ArrayTypeNodeIF arrayTypeNode(TypeNodeIF elementType) {
		return new ArrayTypeNode(idGenerator.getId(), elementType);
	}

	@Override
	public ArrayTypeNodeIF arrayTypeNode(TypeNodeIF elementType,
			ExpressionNodeIF extent) {
		return new ArrayTypeNode(idGenerator.getId(), elementType, extent);
	}

	@Override
	public VectorTypeNodeIF vectorTypeNode(TypeNodeIF elementType) {
		return new VectorTypeNode(idGenerator.getId(), elementType);
	}

	@Override
	public CompositeTypeNodeIF compositeTypeNode(IdentifierNodeIF name,
			SequenceNodeIF<PairNodeIF<IdentifierNodeIF, TypeNodeIF>> fields,
			boolean isUnion) {
		return new CompositeTypeNode(idGenerator.getId(), name, fields, isUnion);
	}

	@SuppressWarnings("unchecked")
	public CompositeTypeNodeIF compositeTypeNode(String name,
			ArrayList<Pair<String, TypeNodeIF>> fields, boolean isUnion) {
		SequenceNodeIF<PairNodeIF<IdentifierNodeIF, TypeNodeIF>> sequenceNode = null;
		int numFields = fields.size();
		CompositeTypeNodeIF result;

		assert numFields > 0;
		for (int i = 0; i < numFields; i++) {
			Pair<String, TypeNodeIF> field = fields.get(i);
			IdentifierNodeIF fieldIdentifierNode = identifierNode(field.left);
			TypeNodeIF fieldTypeNode = field.right;
			PairNodeIF<IdentifierNodeIF, TypeNodeIF> pairNode = pairNode(
					IdentifierNodeIF.class, TypeNodeIF.class);

			pairNode.setLeft(fieldIdentifierNode);
			pairNode.setRight(fieldTypeNode);
			if (i == 0)
				sequenceNode = (SequenceNodeIF<PairNodeIF<IdentifierNodeIF, TypeNodeIF>>) sequenceNode(pairNode
						.getClass());
			sequenceNode.addSequenceChild(pairNode);
		}
		result = compositeTypeNode(identifierNode(name), sequenceNode, isUnion);
		return result;
	}

	@Override
	public EnumerationTypeNodeIF enumerationTypeNode(
			SequenceNodeIF<PairNodeIF<IdentifierNodeIF, LiteralNodeIF>> types) {
		return new EnumerationTypeNode(idGenerator.getId(), types);
	}

	@Override
	public FunctionTypeNodeIF functionTypeNode(
			SequenceNodeIF<TypeNodeIF> inputTypes, TypeNodeIF outputType) {
		return new FunctionTypeNode(idGenerator.getId(), inputTypes, outputType);
	}

	@Override
	public PointerTypeNodeIF pointerTypeNode(TypeNodeIF baseType) {
		return new PointerTypeNode(idGenerator.getId(), baseType);
	}

	@Override
	public TypeReferenceNodeIF typeReferenceNode(TypeDefinitionNodeIF referent) {
		return new TypeReferenceNode(0, referent.identifier().name(), referent);
	}

	@Override
	public BoundVariableDeclarationNodeIF boundVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type,
			BindingExpressionNodeIF containingExpression) {
		return new BoundVariableDeclarationNode(idGenerator.getId(), name,
				type, containingExpression);
	}

	@Override
	public FormalVariableDeclarationNodeIF formalVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type,
			FunctionDeclarationNodeIF function) {
		return new FormalVariableDeclarationNode(idGenerator.getId(), name,
				type, function);
	}

	@Override
	public FormalVariableDeclarationNodeIF formalVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type) {
		return formalVariableDeclarationNode(name, type, null);
	}

	@Override
	public FunctionDeclarationNodeIF functionDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF outputType,
			SequenceNodeIF<FormalVariableDeclarationNodeIF> formals,
			BlockNodeIF body) {
		return new FunctionDeclarationNode(idGenerator.getId(), name,
				outputType, formals, body);
	}

	@Override
	public AbstractFunctionDeclarationNodeIF abstractFunctionDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF outputType,
			SequenceNodeIF<FormalVariableDeclarationNodeIF> formals,
			int continuity, int boundedness) {
		return new AbstractFunctionDeclarationNode(idGenerator.getId(), name,
				outputType, formals, continuity, boundedness);
	}

	@Override
	public GlobalVariableDeclarationNodeIF globalVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type) {
		return new GlobalVariableDeclarationNode(idGenerator.getId(), name,
				type);
	}

	@Override
	public LocalVariableDeclarationNodeIF localVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type, BlockNodeIF block) {
		return new LocalVariableDeclarationNode(idGenerator.getId(), name,
				type, block);
	}

	@Override
	public LocalVariableDeclarationNodeIF localVariableDeclarationNode(
			IdentifierNodeIF name, TypeNodeIF type) {
		return localVariableDeclarationNode(name, type, null);
	}

	@Override
	public AssertStatementNodeIF assertStatementNode(ExpressionNodeIF predicate) {
		return new AssertStatementNode(idGenerator.getId(), predicate);
	}

	@Override
	public AssumeStatementNodeIF assumeStatementNode(ExpressionNodeIF predicate) {
		return new AssumeStatementNode(idGenerator.getId(), predicate);
	}

	@Override
	public BlockNodeIF blockNode(
			SequenceNodeIF<VariableDeclarationNodeIF> variables,
			SequenceNodeIF<StatementNodeIF> statements) {
		return new BlockNode(idGenerator.getId(), variables, statements);
	}

	@Override
	public BreakNodeIF breakNode(StatementNodeIF targetLocation,
			LoopNodeIF loopLocation) {
		return new BreakNode(idGenerator.getId(), targetLocation, loopLocation);
	}

	@Override
	public ContinueNodeIF continueNode(LoopNodeIF loopLocation) {
		return new ContinueNode(idGenerator.getId(), loopLocation);
	}

	@Override
	public DoUntilNodeIF doUntilNode(StatementNodeIF body,
			ExpressionNodeIF condition) {
		return new DoUntilNode(idGenerator.getId(), body, condition);
	}

	@Override
	public ForLoopNodeIF forLoopNode(StatementNodeIF body,
			StatementNodeIF initializer, ExpressionNodeIF condition,
			StatementNodeIF incrementer) {
		return new ForLoopNode(idGenerator.getId(), body, initializer,
				condition, incrementer);
	}

	@Override
	public GotoNodeIF gotoNode(LabelReferenceNodeIF label) {
		return new GotoNode(idGenerator.getId(), label);
	}

	@Override
	public IfThenElseStatementNodeIF ifThenElseStatementNode(
			ExpressionNodeIF condition, StatementNodeIF trueBranch,
			StatementNodeIF falseBranch) {
		return new IfThenElseStatementNode(idGenerator.getId(), condition,
				trueBranch, falseBranch);
	}

	@Override
	public NoopNodeIF noopNode(SequenceNodeIF<LabelNodeIF> labels) {
		NoopNodeIF noop = new NoopNode(idGenerator.getId());
		noop.setLabels(labels);
		return noop;
	}

	@Override
	public PragmaNodeIF pragmaNode(StringLiteralNodeIF string) {
		return new PragmaNode(idGenerator.getId(), string);
	}

	@Override
	public ReturnNodeIF returnNodeIF(ExpressionNodeIF expression) {
		return new ReturnNode(idGenerator.getId(), expression);
	}

	@Override
	public SwitchStatementNodeIF switchStatementNode(
			ExpressionNodeIF expression,
			SequenceNodeIF<PairNodeIF<ExpressionNodeIF, LabelReferenceNodeIF>> cases,
			LabelReferenceNodeIF defaultCase, StatementNodeIF body) {
		return new SwitchStatementNode(idGenerator.getId(), expression, cases,
				defaultCase, body);
	}

	@Override
	public WhileLoopNodeIF whileLoopNode(StatementNodeIF body,
			ExpressionNodeIF condition) {
		return new WhileLoopNode(idGenerator.getId(), body, condition);
	}

	/* Expressions */

	@Override
	public ArrayInitializerNodeIF arrayInitializerNode(
			SequenceNodeIF<ExpressionNodeIF> elements) {
		return new ArrayInitializerNode(idGenerator.getId(), elements);
	}

	@Override
	public AssignmentNodeIF assignmentNode(LHSExpressionNodeIF lhs,
			ExpressionNodeIF rhs) {
		return new AssignmentNode(idGenerator.getId(), lhs, rhs);
	}

	@Override
	public BindingExpressionNodeIF bindingExpressionNode(Quantifier quantifier,
			BoundVariableDeclarationNodeIF boundVariable,
			PureExpressionNodeIF constraint, PureExpressionNodeIF expression) {
		return new BindingExpressionNode(idGenerator.getId(), quantifier,
				boundVariable, constraint, expression);
	}

	@Override
	public CastNodeIF castNode(TypeNodeIF newType, ExpressionNodeIF expression) {
		return new CastNode(idGenerator.getId(), newType, expression);
	}

	@Override
	public CharacterLiteralNodeIF characterLiteralNode(IdentifierNodeIF name,
			TypeNodeIF type, char characterValue) {
		return new CharacterLiteralNode(idGenerator.getId(), name, type,
				characterValue);
	}

	@Override
	public DereferenceNodeIF dereferenceNode(ExpressionNodeIF pointerExpression) {
		return new DereferenceNode(idGenerator.getId(), pointerExpression);
	}

	@Override
	public EnumElementReferenceNodeIF enumElementReferenceNode(
			IdentifierNodeIF name, TypeNodeIF type,
			PairNodeIF<IdentifierNodeIF, LiteralNodeIF> referent) {
		return new EnumElementReferenceNode(idGenerator.getId(), name, type,
				referent);
	}

	@Override
	public FunctionApplicationNodeIF functionApplicationNode(
			ExpressionNodeIF function,
			SequenceNodeIF<ExpressionNodeIF> arguments) {
		return new FunctionApplicationNode(idGenerator.getId(), function,
				arguments);
	}

	@Override
	public FunctionInvocationNodeIF functionInvocationNode(
			ExpressionNodeIF function,
			SequenceNodeIF<ExpressionNodeIF> arguments) {
		return new FunctionInvocationNode(idGenerator.getId(), function,
				arguments);
	}

	@Override
	public FunctionReferenceNodeIF functionReferenceNode(
			FunctionDeclarationNodeIF referent) {
		return new FunctionReferenceNode(idGenerator.getId(), referent);
	}

	@Override
	public FunctionReferenceNodeIF functionReferenceNode() {
		return functionReferenceNode(null);
	}

	@Override
	public IncrementNodeIF incrementNode(LHSExpressionNodeIF lhs,
			boolean prefix, boolean increment) {
		IncrementNodeIF node = new IncrementNode(idGenerator.getId(), lhs);
		node.setPrefix(prefix);
		node.setIncrement(increment);
		return node;
	}

	@Override
	public IntegerLiteralNodeIF integerLiteralNode(IdentifierNodeIF name,
			TypeNodeIF type, IntegerNumberIF integerValue) {
		return new IntegerLiteralNode(idGenerator.getId(), name, type,
				integerValue);
	}

	@Override
	public IntegerLiteralNodeIF integerLiteralNode(IdentifierNodeIF name,
			TypeNodeIF type, Integer integerValue) {
		return integerLiteralNode(name, type,
				Numbers.REAL_FACTORY.integer(integerValue));
	}

	@Override
	public OperatorNodeIF operatorNode(AST_OPERATOR operator,
			ExpressionNodeIF child0) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public OperatorNodeIF operatorNode(AST_OPERATOR operator,
			ExpressionNodeIF child0, ExpressionNodeIF child1) {
		return new OperatorNode(idGenerator.getId(), operator, child0, child1);
	}

	@Override
	public OperatorNodeIF operatorNode(AST_OPERATOR operator,
			ExpressionNodeIF child0, ExpressionNodeIF child1,
			ExpressionNodeIF child2) {
		return new OperatorNode(idGenerator.getId(), operator, child0, child1,
				child2);
	}

	@Override
	public OperatorNodeIF operatorNode(AST_OPERATOR operator,
			ExpressionNodeIF[] children) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ProcessReferenceNodeIF processReferenceNode(ExpressionNodeIF pid,
			VariableReferenceNodeIF variable, FunctionReferenceNodeIF function) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public RealLiteralNodeIF realLiteralNode(IdentifierNodeIF name,
			TypeNodeIF type, RationalNumberIF realValue) {
		return new RealLiteralNode(idGenerator.getId(), name, type, realValue);
	}

	@Override
	public SizeOfNodeIF sizeOfNode(SizeableNodeIF object) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public StartOfNodeIF startOfNode(PureExpressionNodeIF arrayExpression) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public StringLiteralNodeIF stringLiteralNode(IdentifierNodeIF name,
			TypeNodeIF type, String stringValue) {
		return new StringLiteralNode(idGenerator.getId(), name, type,
				stringValue);
	}

	@Override
	public StructInitializerNodeIF structInitializerNode(
			SequenceNodeIF<PairNodeIF<FieldReferenceNodeIF, ExpressionNodeIF>> elements) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public SubscriptNodeIF subscriptNode(ExpressionNodeIF arrayExpression,
			ExpressionNodeIF indexExpression) {
		return new SubscriptNode(idGenerator.getId(), arrayExpression,
				indexExpression);
	}

	@Override
	public VariableReferenceNodeIF variableReferenceNode(
			VariableDeclarationNodeIF referent, IdentifierNodeIF identifier) {
		return new VariableReferenceNode(idGenerator.getId(), referent,
				identifier);
	}

	@Override
	public VariableReferenceNodeIF variableReferenceNode() {
		return variableReferenceNode(null, null);
	}

	@Override
	public ASTTransformerLoaderIF loader() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public <T extends ASTNodeIF> SequenceNodeIF<T> sequenceNode(Class<T> type) {
		return new SequenceNode<T>(idGenerator.getId());
	}

	@Override
	public <S extends ASTNodeIF, T extends ASTNodeIF> PairNodeIF<S, T> pairNode(
			Class<S> first, Class<T> second) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public FileNodeIF fileNode(File file, boolean isSystem, String contents) {
            return new FileNode(idGenerator.getId(),file, isSystem, contents);
	}

	@Override
	public FieldReferenceNodeIF fieldReferenceNode(LHSExpressionNodeIF struct,
			IdentifierNodeIF field) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ExpressionStatementNodeIF expressionStatement(
			ExpressionNodeIF expression) {
		return new ExpressionStatementNode(idGenerator.getId(), expression);
	}

}