OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the AIT Austrian Institute of

  * Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.codegen.cadp;

import java.util.AbstractMap.SimpleEntry;

import java.util.ArrayList;

import java.util.Iterator;

/// <summary>

/// Knows how to construct a C-CADP statement from an AST-statement

/// (dumps out, e.g., named actions)

/// </summary>

public final class CadpStatement extends OoaStatementVisitor

{

	public final OoasCodeEmitter m_emitter = new OoasCodeEmitter();

	private final CadpActionInfo m_procInfo;

	private int m_statePosCount = 1;

	private static int m_debugPosCount = -1;

	private int m_blockCount;

	public int nondetAssignmentsToClose = 0;

	public int blockCount() { return m_blockCount; }

	public static String CallHelper(FunctionIdentifier fun, String helperName)

	{

		final StringBuilder paramStr = new StringBuilder("worklist");

		for (final ParameterIdentifier param : fun.parameter())

		{

			paramStr.append(", ");

			paramStr.append(String.format("%1$s", CadpIdentifier.GetIdentifierString(param)));

		}

		if (((FunctionType)fun.type()).returnType() != null)

		{

			paramStr.append(", ");

			paramStr.append(String.format("param_result"));

		}

		return String.format("%1$s(%2$s)", helperName, paramStr.toString());

	}

	public static String HelperFunctionHeader(FunctionIdentifier fun, String functionName)

	{

		final StringBuilder paramStr = new StringBuilder("struct STATE_LIST* worklist");

		for (final ParameterIdentifier param: fun.parameter())

		{

			//CadpType.EmitType(param.type);

			paramStr.append(", ");

			paramStr.append(String.format("%1$s %2$s", OoaCADPVisitor.DumpType(param.type()), CadpIdentifier.GetIdentifierString(param)));

		}

		if (((FunctionType)fun.type()).returnType() != null)

		{

			//CadpType.EmitType(((FunctionType)fun.type).returnType);

			paramStr.append(", ");

			paramStr.append(String.format("%1$s *param_result", OoaCADPVisitor.DumpType(((FunctionType)fun.type()).returnType())));

		}

		return String.format("struct STATE_LIST* %1$s (%2$s)", functionName, paramStr.toString());

	}

	@Override

	public  void visit(NondetBlock nondetBlock)

	{

		m_blockCount++;

		final int nondetBlocknum = m_blockCount;

		m_emitter.AppendLine("{ /* begin nodet-choice block */");

		m_emitter.AppendLine(String.format("struct STATE_LIST *nondetInitial_%1$s = %2$s;", nondetBlocknum, m_procInfo.toDoListString));

		m_emitter.AppendLine(String.format("struct STATE_LIST *nondetFinal_%1$s = NULL;", nondetBlocknum));

		for (final Statement s : nondetBlock.statements())

		{

			s.Accept(this);

			m_emitter.AppendLine("/* nondet-choice block: save result and reset initial states for next choice */");

			m_emitter.AppendLine(String.format("LIST_INSERT_LIST(%3$s,%4$s); %1$s = %2$s; %4$s = NULL;",

					m_procInfo.toDoListString,

					String.format("nondetInitial_%1$s", nondetBlocknum),

					String.format("nondetFinal_%1$s", nondetBlocknum),

					m_procInfo.doneListString));

		}

		m_emitter.AppendLine("");

		m_emitter.AppendLine(String.format("%1$s = %2$s; /* nondet-choice block end: save all reached final states */",

				m_procInfo.doneListString, String.format("nondetFinal_%1$s", nondetBlocknum)));

		m_emitter.AppendLine("} /* end nodet-choice block */");

	}

	@Override

	public  void visit(SeqBlock seqBlock)

	{

		int loopcount = 0;

		final boolean haveNondeterminism = seqBlock.symbols().symbolList().size() > 0;

		final boolean splittingEnabled = m_procInfo.splitBlockSize > 0;

		final int blockNum = haveNondeterminism ? m_blockCount++ : m_blockCount;

		m_emitter.AppendLineIncIndent("{ /* begin seqblock */");

		if (haveNondeterminism)

		{

			m_blockCount++;

			m_emitter.AppendLine(String.format("struct STATE_LIST *seqInitial_%1$s = %2$s;", blockNum, m_procInfo.toDoListString));

			m_emitter.AppendLine(String.format("struct STATE_LIST *seqFinal_%1$s = NULL;", blockNum));

			for (final Identifier sym :seqBlock.symbols().symbolList())

			{

				CadpType.EmitType(sym.type());

				final CadpType atype = new CadpType();

				sym.type().Accept(atype);

				final CadpIdentifier anIdent = new CadpIdentifier(OoaCADPVisitor.StateVariablePrefix);

				sym.Accept(anIdent);

				m_emitter.AppendLine("/* local (free) variables of seq block */");

				m_emitter.AppendLine(String.format("      long long iterator_%1$s;", anIdent.toString()));

				m_emitter.AppendLine(String.format("      for (iterator_%1$s = %2$s; iterator_%1$s <= %3$s; iterator_%1$s++) {",

						anIdent.toString(), CadpType.GetMinVal(sym.type()), CadpType.GetMaxVal(sym.type())));

				m_emitter.AppendLine(String.format("      %1$s %2$s = %3$s%4$s(iterator_%2$s);",

						atype.ToString(), anIdent.toString(), CadpType.enumString, CadpIdentifier.GetIdentifierString(sym.type().identifier())));

				loopcount++;

			}

			if (!(seqBlock.filter() == null))

				throw new UnsupportedOperationException();

		}

		if (!splittingEnabled || seqBlock.statements().size() < m_procInfo.splitBlockSize)

		{

			// no splitting, write out to emitter

			int i = 0;

			for (final Statement s : seqBlock.statements())

			{

				if (i != 0)

				{

					m_emitter.AppendLine("/* sequential composition: all states reached need to go into todo list */");

					m_emitter.AppendLine(String.format("%1$s = %2$s; %2$s = NULL;", m_procInfo.toDoListString, m_procInfo.doneListString));

				}

				i++;

				s.Accept(this);

			}

		}

		else

		{

			// splitting, we will create functions that take at max. m_procInfo.splitBlockSize number of children

			int splitCount = 0;

			final Iterator<Statement> enumerator = seqBlock.statements().iterator();

			for (int elemCntr = 0; elemCntr < seqBlock.statements().size(); elemCntr++)

			{

				final CadpStatement stmnt = new CadpStatement(this);

				final Statement currentStatement = enumerator.next();

				currentStatement.Accept(stmnt);

				final boolean newSubGroup = elemCntr % m_procInfo.splitBlockSize == 0;

				if (newSubGroup)

				{

					splitCount++;

					final String helperName = String.format("%1$s_%2$s", m_procInfo.action.tokenText(), splitCount);

					// call the helper

					if (elemCntr > 0)

					{

						m_emitter.AppendLine("/* sequential composition: all states reached need to go into todo list */");

						m_emitter.AppendLine(String.format("%1$s = %2$s; %2$s = NULL;", m_procInfo.toDoListString, m_procInfo.doneListString));

					}

					m_emitter.AppendLine(String.format("%1$s = %2$s;", m_procInfo.doneListString, CallHelper(m_procInfo.action, helperName)));

					// make a header for the helper

					m_procInfo.m_helperMethods.AppendLine();

					m_procInfo.m_helperMethods.AppendLine(HelperFunctionHeader(m_procInfo.action, helperName));

					m_procInfo.m_helperMethods.IncIndent();

					m_procInfo.m_helperMethods.AppendLine("{");

					m_procInfo.m_helperMethods.AppendLine("struct STATE_LIST *newstatelist = NULL;");

				}

				if (!newSubGroup)

				{

					m_procInfo.m_helperMethods.AppendLine("/* sequential composition: all states reached need to go into todo list */");

					m_procInfo.m_helperMethods.AppendLine(String.format("%1$s = %2$s; %2$s = NULL;", m_procInfo.toDoListString, m_procInfo.doneListString));

				}

				m_procInfo.m_helperMethods.AppendLine(stmnt.toString());

				if ((elemCntr + 1) % m_procInfo.splitBlockSize == 0 || (elemCntr + 1) >= seqBlock.statements().size())

				{

					// close the helper

					m_procInfo.m_helperMethods.AppendLine(String.format("return %1$s;",m_procInfo.doneListString));

					m_procInfo.m_helperMethods.DecIndent();

					m_procInfo.m_helperMethods.AppendLine("}");

				}

			}

		}

		// we need to do some loop-calling here..

		if (haveNondeterminism)

		{

			m_emitter.AppendLine("/* save result state and reset initial state for next choice */");

			m_emitter.AppendLine(String.format("LIST_INSERT_LIST(%3$s,%4$s); %1$s = %2$s; %4$s = NULL;",

					m_procInfo.toDoListString,

					String.format("seqInitial_%1$s", blockNum),

					String.format("seqFinal_%1$s", blockNum),

					m_procInfo.doneListString));

			while (loopcount > 0)

			{

				m_emitter.AppendLine("      }");

				loopcount--;

			}

			m_emitter.AppendLine("/* all final states reached after the seq-block are on our done list */");

			m_emitter.AppendLine(String.format("%1$s = %2$s;", m_procInfo.doneListString, String.format("seqFinal_%1$s", blockNum)));

		}

		m_emitter.DecIndent();

		m_emitter.AppendLine("} /* end seqblock */");

	}

	@Override

	public  void visit(PrioBlock prioBlock)

	{

		m_blockCount++;

		final int prioBlocknum = m_blockCount;

		m_emitter.AppendLine("{ /* begin prioritized composition block */");

		m_emitter.AppendLine(String.format("struct STATE_LIST *prioInitial_%1$s = %2$s;", prioBlocknum, m_procInfo.toDoListString));

		m_emitter.AppendLine(String.format("struct STATE_LIST *prioFinal_%1$s = NULL;", prioBlocknum));

		for (final Statement s : prioBlock.statements())

		{

			s.Accept(this);

			m_emitter.AppendLine("/* prio block: save result and reset initial states for next choice */");

			m_emitter.AppendLine(String.format("%1$s = GetPrioritizedWorkList(prioInitial_%2$s, %3$s);",

					m_procInfo.toDoListString, prioBlocknum, m_procInfo.doneListString));

			m_emitter.AppendLine(String.format("LIST_INSERT_LIST(prioFinal_%1$s, %2$s);",

					prioBlocknum, m_procInfo.doneListString));

			m_emitter.AppendLine(String.format("if (%3$s == NULL) goto prioritizedCompositionExit_%2$s; else %1$s = NULL;",

					m_procInfo.doneListString, prioBlocknum, m_procInfo.toDoListString));

		}

		m_emitter.AppendLine("");

		m_emitter.AppendLine(String.format("prioritizedCompositionExit_%1$s:", prioBlocknum));

		m_emitter.AppendLine(String.format("%1$s = %2$s; /* prioritized composition block end: save all reached final states */",

				m_procInfo.doneListString, String.format("prioFinal_%1$s", prioBlocknum)));

		m_emitter.AppendLine("} /* end prioritized composition block */");

	}

	@Override

	public  void visit(GuardedCommand guardedCommand)

	{

		String body;

		final CadpExpression expr = new CadpExpression(m_procInfo);

		final CadpStatement statement = new CadpStatement(this);

		guardedCommand.guard().Accept(expr);

		guardedCommand.body().Accept(statement);

		m_blockCount = statement.blockCount() + 1;

		body = String.format("%3$s if (%1$s) { LIST_INSERT_SINGLELIST(%2$s,elem); };", expr.toString(), m_procInfo.doneListString, expr.VariableDeclarations());

		m_emitter.AppendLineIncIndent("{");

		m_emitter.AppendLine("/* guarded command */");

		m_emitter.AppendLine(String.format("ITERATE_STATES(%1$s, %2$s );", m_procInfo.toDoListString, body));

		m_emitter.AppendLine(String.format("%1$s = %2$s; %2$s = NULL;", m_procInfo.toDoListString, m_procInfo.doneListString));

		m_emitter.AppendLine(String.format(" if (%1$s == NULL) goto guardedCommandExit_%2$s;", m_procInfo.toDoListString, OoaCADPVisitor.getUIntHashCode(guardedCommand)));

		m_emitter.AppendLineDecIndent("}");

		m_emitter.Append(statement.toString());

		m_emitter.AppendLine(String.format("guardedCommandExit_%2$s: %1$s = %1$s;", m_procInfo.toDoListString, OoaCADPVisitor.getUIntHashCode(guardedCommand)));

	}

	@Override

	public  void visit(Assignment assignment)

	{

		final OoaPrintVisitor pvis = new OoaPrintVisitor(null);

		assignment.Accept(pvis);

		m_emitter.AppendLine(String.format("{ /* assignment: %1$s */", pvis.toString().replace("/*", "").replace("*/", "")));

		m_emitter.AppendLine(String.format("struct STATE_LIST *elems = %1$s;", m_procInfo.toDoListString));

		m_emitter.AppendLine("CAESAR_TYPE_STATE newState = NULL;");

		m_emitter.AppendLine("CAESAR_TYPE_STATE oldState;");

		m_emitter.AppendLine("while (elems != NULL)");

		m_emitter.AppendLineIncIndent("{");

		m_emitter.AppendLine("oldState = (CAESAR_TYPE_STATE) elems->aState;");

		final ArrayList<SimpleEntry<String, UlyssesType>> nondetEnumerators = new ArrayList<>();

		if (assignment.symbols().symbolList().size() > 0)

		{

			for (final Identifier sym : assignment.symbols().symbolList())

			{

				final CadpType typevis = new CadpType();

				final CadpIdentifier idvis = new CadpIdentifier("oldState");

				sym.type().Accept(typevis);

				sym.Accept(idvis);

				m_emitter.AppendLine(String.format("%1$s %2$s; /* unbound in expression */", typevis.ToString(), idvis.toString()));

				nondetEnumerators.add(new SimpleEntry<String, UlyssesType>(idvis.toString(), sym.type()));

			}

		}

		if (assignment.nondetExpression() != null)

		{

			for (final SimpleEntry<String, UlyssesType> key : nondetEnumerators)

			{

				m_emitter.AppendLine(String.format("for (%1$s = %2$s; %1$s <= %3$s; %1$s++) ",

						key.getKey(), UlyssesType.Low(key.getValue()), UlyssesType.High(key.getValue())));

				m_emitter.AppendLineIncIndent("{");

			}

			final CadpExpression exprvis = new CadpExpression(new CadpActionInfo(null, -1, 0, "", "", "oldState"));

			assignment.nondetExpression().Accept(exprvis);

			m_emitter.AppendLine(String.format("if (%1$s)", exprvis.toString()));

		}

		m_emitter.AppendLine("{");

		m_emitter.AppendLine("/* setup new state */");

		m_emitter.AppendLine("CAESAR_CREATE_STATE(&newState);");

		m_emitter.AppendLine("memcpy(newState,oldState,CAESAR_SIZE_STATE());");

		m_emitter.AppendLine("newState->_hidden = 1;");

		m_emitter.AppendLine("newState->_predecessor = oldState;");

		m_emitter.AppendLine("struct STATE_LIST *newListElem;");

		m_emitter.AppendLine("LIST_CREATE(newListElem);");

		m_emitter.AppendLine("newListElem->aState = newState;");

		m_emitter.AppendLine("newState->_successors = NULL;");

		m_emitter.AppendLine(String.format("newState->_statenum = (char*)%1$s;", m_debugPosCount--));

		final Iterator<Expression> place = assignment.places().iterator();

		final Iterator<Expression> value = assignment.values().iterator();

		while (place.hasNext() && value.hasNext())

		{

			final Expression currValue = value.next();

			final Expression currPlace = place.next();

			CadpExpression vis = new CadpExpression(new CadpActionInfo(null, -1, 0, "", "", "oldState"));

			currValue.Accept(vis);

			final String from = vis.toString();

			final String fromdecls = vis.VariableDeclarations();

			vis = new CadpExpression(new CadpActionInfo(null, -1, 0, "", "", "newState"));

			currPlace.Accept(vis);

			final String to = vis.toString();

			/*if (to.Equals("param_result"))

                    to = "*param_result";*/

			m_emitter.AppendLine(vis.VariableDeclarations());

			m_emitter.AppendLine(fromdecls);

			m_emitter.AppendLine(String.format("%1$s = %2$s;", to, from));

			// code that checks wether we're in range..

			switch (currPlace.type().kind())

			{

			case IntType:

				final IntType placetype_int = (IntType)currPlace.type();

				m_emitter.AppendLine(String.format("/*Range of %3$s: %1$s..%2$s*/", placetype_int.rangeLow(), placetype_int.rangeHigh(), to));

				m_emitter.AppendLine(String.format("if (%1$s < %2$sLL || %1$s > %3$sLL)", to, placetype_int.rangeLow(), placetype_int.rangeHigh()));

				m_emitter.AppendLine(String.format("{CAESAR_DELETE(newState); free(newListElem); newListElem = NULL; goto rangeExit_%1$s;}", OoaCADPVisitor.getUIntHashCode(assignment)));

				break;

			case FloatType:

				final FloatType placetype_float = (FloatType)currPlace.type();

				m_emitter.AppendLine(String.format("/*Range of %3$s: %1$s..%2$s*/", placetype_float.low(), placetype_float.high(), to));

				m_emitter.AppendLine(String.format("if (%1$s < %2$s || %1$s > %3$s)", to, placetype_float.low(), placetype_float.high()));

				m_emitter.AppendLine(String.format("{CAESAR_DELETE(newState); free(newListElem); newListElem = NULL; goto rangeExit_%1$s;}", OoaCADPVisitor.getUIntHashCode(assignment)));

				break;

			default:

				m_emitter.AppendLine(String.format("if (CALC_INVALID == 1)"));

				m_emitter.AppendLine(String.format("{ CALC_INVALID = 0; CAESAR_DELETE(newState); free(newListElem); newListElem = NULL; goto rangeExit_%1$s;}", OoaCADPVisitor.getUIntHashCode(assignment)));

				break;

			}

		}

		m_emitter.AppendLine("LISTLIST_INSERT_LIST(ARGOS_ALL_STATES,newListElem);");

		m_emitter.AppendLine(String.format("rangeExit_%1$s:", OoaCADPVisitor.getUIntHashCode(assignment)));

		m_emitter.AppendLine(String.format("LIST_INSERT_SINGLELIST(%1$s,newListElem);", m_procInfo.doneListString));

		m_emitter.AppendLine("}");

		if (assignment.nondetExpression() != null)

			for (@SuppressWarnings("unused") final SimpleEntry<String, UlyssesType> key : nondetEnumerators)

				m_emitter.AppendLine("} /* closing nondet assignment for loop */");

		m_emitter.AppendLine("elems = elems->next;");

		m_emitter.AppendLineDecIndent("} /*while loop, iterating through all states*/");

		m_emitter.AppendLine("} /* end assignment*/");

	}

	@Override

	public  void visit(Call call)

	{

		final Expression ce = call.callExpression();

		String callstatement = "";

		/*for each state in the worklist..*/

		m_emitter.AppendLineIncIndent("{ /* begin named action call*/");

		m_emitter.AppendLine("struct STATE_LIST *callresult = NULL;");

		m_emitter.AppendLine(String.format("struct STATE_LIST *elem = %1$s;", m_procInfo.toDoListString));

		m_emitter.AppendLine("while(elem != NULL)");

		m_emitter.AppendLineIncIndent("{");

		m_emitter.AppendLine("struct STATE_LIST *next = elem->next;");

		final StringBuilder parameter = new StringBuilder("(CAESAR_TYPE_STATE)elem->aState");

		if (ce.kind() == ExpressionKind.Identifier)

			callstatement = ((IdentifierExpression)ce).identifier().tokenText();

		else if (ce.kind() == ExpressionKind.Call)

		{

			final CallExpression parens = (CallExpression)ce;

			final CadpExpression cadpexpr = new CadpExpression(m_procInfo);

			parens.child().Accept(cadpexpr);

			m_emitter.Append(cadpexpr.VariableDeclarations());

			callstatement = cadpexpr.toString();

			for (final Expression arg : parens.arguments())

			{

				parameter.append(", ");

				final CadpExpression paramexpr = new CadpExpression(m_procInfo);

				arg.Accept(paramexpr);

				m_emitter.AppendLine(paramexpr.VariableDeclarations());

				parameter.append(paramexpr.toString());

			}

			if (((FunctionType)parens.child().type()).returnType() != null)

			{

				final String tmpresult = String.format("detcallresult_%1$s", OoaCADPVisitor.getUIntHashCode(parens));

				m_emitter.AppendLine(String.format("%1$s %2$s;", CadpType.DumpType(((FunctionType)parens.child().type()).returnType()), tmpresult));

				parameter.append(String.format(", &(%1$s)", tmpresult));

			}

		}

		else if (ce.kind() == ExpressionKind.foldRL

				|| ce.kind() == ExpressionKind.foldLR)

		{

			// intermediate hack for map..

			final CallExpression callexpr = (CallExpression)((TernaryOperator)ce).left();

			final Expression alist = ((TernaryOperator)ce).right();

			final CadpExpression cadplist = new CadpExpression(m_procInfo);

			alist.Accept(cadplist);

			final String listname = Integer.toString(OoaCADPVisitor.getUIntHashCode(alist)) + Integer.toString(OoaCADPVisitor.getUIntHashCode(callexpr));

			//m_emitter.AppendLine("struct STATE_LIST *_map_tmp_result = elem;");

			m_emitter.AppendLine(String.format("%1$s list_%2$s = %3$s;",

					CadpType.DumpType(alist.type()), listname, cadplist.toString()));

			m_emitter.AppendLine(String.format("int list_iterator_%1$s;", listname));

			if (ce.kind() == ExpressionKind.foldLR)

				m_emitter.AppendLine(String.format("for (list_iterator_%1$s = 0; list_iterator_%1$s < list_%1$s.length; list_iterator_%1$s++) {", listname));

			else

				m_emitter.AppendLine(String.format("for (list_iterator_%1$s = list_%1$s.length - 1; list_iterator_%1$s >= 0 ; list_iterator_%1$s--) {", listname));

			m_emitter.AppendLine(String.format("%1$s list_elem%2$s = list_%2$s.elements[list_iterator_%2$s];", CadpType.DumpType(((ListType)alist.type()).innerType()),

					listname));

			final CadpExpression cadpexpr = new CadpExpression(m_procInfo);

			callexpr.child().Accept(cadpexpr);

			callstatement = cadpexpr.toString();

			for (final Expression arg: callexpr.arguments())

			{

				parameter.append(", ");

				final CadpExpression paramexpr = new CadpExpression(m_procInfo);

				arg.Accept(paramexpr);

				parameter.append(paramexpr.toString());

			}

			parameter.append(String.format(", list_elem%1$s", listname));

		}

		else

			throw new UnsupportedOperationException();

		m_emitter.AppendLine(String.format("callresult = %1$s(%2$s);", callstatement, parameter));

		if (ce.kind() == ExpressionKind.foldRL || ce.kind() == ExpressionKind.foldLR)

		{

			m_emitter.AppendLine("if (callresult == NULL) break; /*if function of map/fold not enabled - abort*/");

			m_emitter.AppendLine("if (callresult->next != NULL) { fprintf(stderr,\"\\nnon-deterministic fold/map not supported!\\n\");  CAESAR_TERMINATE(1); }");

			m_emitter.AppendLine("elem = callresult; }");

		}

		m_emitter.AppendLine(String.format("LIST_INSERT_LIST(%1$s, callresult);", m_procInfo.doneListString));

		m_emitter.AppendLine("elem = next;");

		m_emitter.AppendLineDecIndent("}");

		m_emitter.AppendLineDecIndent("} /* end named action call*/");

	}

	@Override

	public  void visit(SkipStatement skipStatement)

	{

		m_emitter.AppendLine("{ /* skip */");

		m_emitter.AppendLine(String.format("struct STATE_LIST *elems = %1$s;", m_procInfo.toDoListString));

		m_emitter.AppendLine("CAESAR_TYPE_STATE newState = NULL;");

		m_emitter.AppendLine("CAESAR_TYPE_STATE oldState;");

		m_emitter.AppendLine("while (elems != NULL)");

		m_emitter.AppendLineIncIndent("{");

		m_emitter.AppendLine("oldState = (CAESAR_TYPE_STATE) elems->aState;");

		m_emitter.AppendLine("{");

		m_emitter.AppendLine("/* setup new state */");

		m_emitter.AppendLine("CAESAR_CREATE_STATE(&newState);");

		m_emitter.AppendLine("memcpy(newState,oldState,CAESAR_SIZE_STATE());");

		m_emitter.AppendLine("newState->_hidden = 1;");

		m_emitter.AppendLine("newState->_predecessor = oldState;");

		m_emitter.AppendLine("struct STATE_LIST *newListElem;");

		m_emitter.AppendLine("LIST_CREATE(newListElem);");

		m_emitter.AppendLine("newListElem->aState = newState;");

		m_emitter.AppendLine("newState->_successors = NULL;");

		m_emitter.AppendLine(String.format("newState->_statenum = (char*)%1$s;", m_debugPosCount--));

		m_emitter.AppendLine("LISTLIST_INSERT_LIST(ARGOS_ALL_STATES,newListElem);");

		m_emitter.AppendLine(String.format("LIST_INSERT_SINGLELIST(%1$s,newListElem);", m_procInfo.doneListString));

		m_emitter.AppendLine("}");

		m_emitter.AppendLine("elems = elems->next;");

		m_emitter.AppendLineDecIndent("} /*while loop, iterating through all states*/");

		m_emitter.AppendLine("} /* end skip*/");

	}

	@Override

	public  void visit(AbortStatement abortStatement)

	{

		throw new UnsupportedOperationException();

	}

	@Override

	public  void visit(KillStatement killStatement)

	{

		throw new UnsupportedOperationException();

	}

	@Override

	public  String toString()

	{

		return m_emitter.toString();

	}

	public CadpStatement(CadpActionInfo aProcInfo)

	{

		super();

		if (aProcInfo == null)

			throw new IllegalArgumentException();

		m_procInfo = aProcInfo;

		m_blockCount = 0;

	}

	public CadpStatement(CadpActionInfo aProcInfo, boolean labelHiddenStates)

	{

		this(aProcInfo);

		//m_labelHiddenStates = labelHiddenStates;

	}

	public CadpStatement(CadpStatement toCopy)

	{

		super();

		m_procInfo = toCopy.m_procInfo;

		m_blockCount = toCopy.m_blockCount;

		m_statePosCount = toCopy.m_statePosCount;

		//m_labelHiddenStates = toCopy.m_labelHiddenStates;

	}

}