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;

import org.momut.ooas.ast.expressions.CallExpression;

import org.momut.ooas.ast.expressions.Expression;

import org.momut.ooas.ast.expressions.ExpressionKind;

import org.momut.ooas.ast.expressions.IdentifierExpression;

import org.momut.ooas.ast.expressions.TernaryOperator;

import org.momut.ooas.ast.identifiers.FunctionIdentifier;

import org.momut.ooas.ast.identifiers.Identifier;

import org.momut.ooas.ast.identifiers.ParameterIdentifier;

import org.momut.ooas.ast.statements.AbortStatement;

import org.momut.ooas.ast.statements.Assignment;

import org.momut.ooas.ast.statements.Call;

import org.momut.ooas.ast.statements.GuardedCommand;

import org.momut.ooas.ast.statements.KillStatement;

import org.momut.ooas.ast.statements.NondetBlock;

import org.momut.ooas.ast.statements.PrioBlock;

import org.momut.ooas.ast.statements.SeqBlock;

import org.momut.ooas.ast.statements.SkipStatement;

import org.momut.ooas.ast.statements.Statement;

import org.momut.ooas.ast.types.FloatType;

import org.momut.ooas.ast.types.FunctionType;

import org.momut.ooas.ast.types.IntType;

import org.momut.ooas.ast.types.ListType;

import org.momut.ooas.ast.types.Type;

import org.momut.ooas.codegen.OoasCodeEmitter;

import org.momut.ooas.visitors.OoaPrintVisitor;

import org.momut.ooas.visitors.OoaStatementVisitor;

/// <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, Type>> 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, Type>(idvis.toString(), sym.type()));

                        }

                }

                if (assignment.nondetExpression() != null)

                {

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

                        {

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

                                                key.getKey(), Type.Low(key.getValue()), Type.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, Type> 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;

        }

}