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.ast;

import java.util.HashSet;

import java.util.IdentityHashMap;

import org.momut.ooas.ast.IAst;

import org.momut.ooas.ast.IAstVisitor;

import org.momut.ooas.ast.IScope;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.AnyType;

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

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

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

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.MapType;

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

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

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

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

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

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

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

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

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

import org.momut.ooas.parser.ParserState;

import org.momut.ooas.utils.exceptions.NotImplementedException;

import org.momut.ooas.utils.exceptions.OoasCompilerRuntimeException;

public class OoaAstEmitter<T> implements IAstVisitor {

        final IAstDuplicator<T> m_copier;

        final ParserState m_state;

        protected HashSet<Object> m_visited = new HashSet<Object>();

        final IdentityHashMap<Identifier,T> m_convertedIdentifiers;

        final IdentityHashMap<Type,T> m_convertedTypes;

        final IdentityHashMap<Expression,T> m_convertedExpressions;

        final IdentityHashMap<Statement,T> m_convertedStatements;

        final IdentityHashMap<IScope,T> m_convertedScopes;

        final IdentityHashMap<OoActionSystemInstance, T> m_convertedInstances;

        public OoaAstEmitter(ParserState aState, IAstDuplicator<T> copier) {

                m_copier = copier;

                m_state = aState;

                m_convertedIdentifiers = new IdentityHashMap<>();

                m_convertedTypes = new IdentityHashMap<>();

                m_convertedExpressions = new IdentityHashMap<>();

                m_convertedStatements = new IdentityHashMap<>();

                m_convertedScopes = new IdentityHashMap<>();

                m_convertedInstances = new IdentityHashMap<>();

        }

        @Override

        public String returnVisitorName() {

                return this.getClass().getName();

        }

        @Override

        public void done() {

        }

        protected final void VisitSub(IAst subElement, IAst parent)

        {

                if (subElement == null || m_visited.contains(subElement))

                        return;

                m_visited.add(subElement);

                subElement.Accept(this);

        }

        /**

         * Tells the underlying IAstDuplicator to create an

         * identifier T. Also checks for duplicate instantiations

         * @param id Identifier to map

         * @return some opaque T

         */

        private final T createIdentifier(Identifier id) {

                IdentifierKind kind = id.kind();

                if (id instanceof MainModule)

                        kind = IdentifierKind.MainModule;

                final int subOrd =  (id instanceof IdentifierList)

                                ? ((IdentifierList)id).listType().integerValue

                                : 0;

                final T result = m_copier.createIdentifier(kind, subOrd);

                if (m_convertedIdentifiers.put(id, result) != null)

                        throw new OoasCompilerRuntimeException("Identifier %s already has been copied.", id.toString());

                if (id instanceof IScope) {

                        if (m_convertedScopes.put((IScope)id, m_copier.castToIScope(result)) != null)

                                throw new OoasCompilerRuntimeException("Scope %s already has been copied.", id.toString());

                }

                return result;

        }

        private final T createType(Type type) {

                TypeKind kind = type.kind();

                if (type instanceof ValuedEnumType)

                        kind = TypeKind.ValuedEnumeratedType;

                final T result = m_copier.createType(kind);

                if (m_convertedTypes.put(type, result) != null)

                        throw new OoasCompilerRuntimeException("Type %s already has been copied.", type.toString());

                if (type instanceof IScope) {

                        if (m_convertedScopes.put((IScope)type, m_copier.castToIScope(result)) != null)

                                throw new OoasCompilerRuntimeException("Scope %s already has been copied.", type.toString());

                }

                return result;

        }

        private final T createExpression(Expression expression) {

                final int subOrd =  (expression instanceof LeafExpression)

                                ? ((LeafExpression)expression).valueType().integerValue

                                : 0;

                final T result = m_copier.createExpression(expression.kind(), subOrd);

                if (m_convertedExpressions.put(expression, result) != null)

                        throw new OoasCompilerRuntimeException("Expression %s already has been copied.", expression.toString());

                if (expression instanceof IScope) {

                        if (m_convertedScopes.put((IScope)expression, m_copier.castToIScope(result)) != null)

                                throw new OoasCompilerRuntimeException("Scope %s already has been copied.", expression.toString());

                }

                return result;

        }

        private final T createStatement(Statement statement) {

                final T result = m_copier.createStatement(statement.kind());

                if (m_convertedStatements.put(statement, result) != null)

                        throw new OoasCompilerRuntimeException("Statement %s already has been copied.", statement.toString());

                if (statement instanceof IScope) {

                        if (m_convertedScopes.put((IScope)statement, m_copier.castToIScope(result)) != null)

                                throw new OoasCompilerRuntimeException("Scope %s already has been copied.", statement.toString());

                }

                return result;

        }

        @Override

        public void visit(EnumIdentifier enumIdentifier)

        {

                final T id = createIdentifier(enumIdentifier);

                // create all referenced subs

                VisitSub(enumIdentifier.definingScope(), enumIdentifier);

                VisitSub(enumIdentifier.type(), enumIdentifier);

                // create the identifier and initialize it.

                m_copier.initEnumIdentifier(

                                id,

                                enumIdentifier.line(),

                                enumIdentifier.column(),

                                enumIdentifier.tokenText(),

                                m_convertedScopes.get(enumIdentifier.definingScope()),

                                m_convertedTypes.get(enumIdentifier.type()),

                                enumIdentifier.HaveValue(),

                                enumIdentifier.Value());

        }

        @Override

        public void visit(ConstantIdentifier constantIdentifier)

        {

                final T constId = createIdentifier(constantIdentifier);

                // make sure all the sub elements are created.

                VisitSub(constantIdentifier.definingScope(), constantIdentifier);

                VisitSub(constantIdentifier.type(), constantIdentifier);

                VisitSub(constantIdentifier.Value(), constantIdentifier);

                // create the identifier and initialize it.

                m_copier.initConstantIdentifier(

                                constId,

                                constantIdentifier.line(),

                                constantIdentifier.column(),

                                constantIdentifier.tokenText(),

                                m_convertedScopes.get(constantIdentifier.definingScope()),

                                m_convertedTypes.get(constantIdentifier.type()),

                                m_convertedExpressions.get(constantIdentifier.Value()));

        }

        @Override

        public void visit(AttributeIdentifier attributeIdentifier)

        {

                final T id = createIdentifier(attributeIdentifier);

                // make sure all the sub elements are created.

                VisitSub(attributeIdentifier.definingScope(), attributeIdentifier);

                VisitSub(attributeIdentifier.type(), attributeIdentifier);

                VisitSub(attributeIdentifier.initializer(), attributeIdentifier);

                // create the identifier and initialize it.

                m_copier.initAttributeIdentifier(

                                id,

                                attributeIdentifier.line(),

                                attributeIdentifier.column(),

                                attributeIdentifier.tokenText(),

                                m_convertedScopes.get(attributeIdentifier.definingScope()),

                                m_convertedTypes.get(attributeIdentifier.type()),

                                m_convertedExpressions.get(attributeIdentifier.initializer()),

                                attributeIdentifier.isStatic(),

                                attributeIdentifier.isControllable(),

                                attributeIdentifier.isObservable());

        }

        @Override

        public void visit(ExpressionVariableIdentifier expressionVariableIdentifier)

        {

                final T id = createIdentifier(expressionVariableIdentifier);

                // make sure all the sub elements are created.

                VisitSub(expressionVariableIdentifier.definingScope(), expressionVariableIdentifier);

                VisitSub(expressionVariableIdentifier.type(), expressionVariableIdentifier);

                // create the identifier and initialize it.

                m_copier.initExprVarIdentifier(

                                id,

                                expressionVariableIdentifier.line(),

                                expressionVariableIdentifier.column(),

                                expressionVariableIdentifier.tokenText(),

                                m_convertedScopes.get(expressionVariableIdentifier.definingScope()),

                                m_convertedTypes.get(expressionVariableIdentifier.type()),

                                expressionVariableIdentifier.initialized());

        }

        @Override

        public void visit(ParameterIdentifier parameterIdentifier)

        {

                final T id = createIdentifier(parameterIdentifier);

                // create sub elements.

                VisitSub(parameterIdentifier.definingScope(), parameterIdentifier);

                VisitSub(parameterIdentifier.type(), parameterIdentifier);

                // create the identifier and initialize it.

                m_copier.initParamIdentifier(

                                id,

                                parameterIdentifier.line(),

                                parameterIdentifier.column(),

                                parameterIdentifier.tokenText(),

                                m_convertedScopes.get(parameterIdentifier.definingScope()),

                                m_convertedTypes.get(parameterIdentifier.type()));

        }

        @Override

        public void visit(LocalVariableIdentifier localVariableIdentifier)

        {

                final T id = createIdentifier(localVariableIdentifier);

                // create sub elements.

                VisitSub(localVariableIdentifier.definingScope(), localVariableIdentifier);

                VisitSub(localVariableIdentifier.type(), localVariableIdentifier);

                // create the identifier and initialize it.

                m_copier.initLocalVarIdentifier(

                                id,

                                localVariableIdentifier.line(),

                                localVariableIdentifier.column(),

                                localVariableIdentifier.tokenText(),

                                m_convertedScopes.get(localVariableIdentifier.definingScope()),

                                m_convertedTypes.get(localVariableIdentifier.type()));

}

        @Override

        public void visit(TypeIdentifier typeIdentifier)

        {

                final T id = createIdentifier(typeIdentifier);

                // create sub elements.

                VisitSub(typeIdentifier.definingScope(), typeIdentifier);

                VisitSub(typeIdentifier.type(), typeIdentifier);

                // create the identifier and initialize it.

                m_copier.initTypeIdentifier(

                                id,

                                typeIdentifier.line(),

                                typeIdentifier.column(),

                                typeIdentifier.tokenText(),

                                m_convertedScopes.get(typeIdentifier.definingScope()),

                                m_convertedTypes.get(typeIdentifier.type()),

                                typeIdentifier.prefix);

        }

        @Override

        public void visit(SelfTypeIdentifier aself)

        {

                final T id = createIdentifier(aself);

                // create sub elements.

                VisitSub(aself.definingScope(), aself);

                VisitSub(aself.type(), aself);

                // create the identifier and initialize it. (selftypeid extends typeid..)

                m_copier.initSelfIdentifier(

                                id,

                                aself.line(),

                                aself.column(),

                                aself.tokenText(),

                                m_convertedScopes.get(aself.definingScope()),

                                m_convertedTypes.get(aself.type()),

                                aself.prefix);

        }

        @Override

        public void visit(MethodIdentifier methodIdentifier)

        {

                final T id = createIdentifier(methodIdentifier);

                // create sub elements.

                VisitSub(methodIdentifier.definingScope(), methodIdentifier);

                VisitSub(methodIdentifier.type(), methodIdentifier);

                for (final Identifier sym: methodIdentifier.symbolTable().symbolList())

                        VisitSub(sym, methodIdentifier);

                for (final ParameterIdentifier par: methodIdentifier.parameter())

                        VisitSub(par, methodIdentifier);

                VisitSub(methodIdentifier.body(), methodIdentifier);

                // create the identifier and initialize it.

                final T symbolTable = m_copier.createSymbolTable();

                for (final Identifier sym: methodIdentifier.symbolTable().symbolList())

                        m_copier.addIdentifierToSymbolTable(symbolTable, m_convertedIdentifiers.get(sym));

                final T parameterList = m_copier.createParameterList();

                for (final ParameterIdentifier par: methodIdentifier.parameter())

                        m_copier.addParameterIdentifierToList(parameterList, m_convertedIdentifiers.get(par));

                m_copier.initMethodIdentifier(

                                id,

                                methodIdentifier.line(),

                                methodIdentifier.column(),

                                methodIdentifier.tokenText(),

                                m_convertedScopes.get(methodIdentifier.definingScope()),

                                m_convertedTypes.get(methodIdentifier.type()),

                                methodIdentifier.prefix,

                                parameterList,

                                symbolTable,

                                m_convertedStatements.get(methodIdentifier.body()));

        }

        @Override

        public void visit(NamedActionIdentifier namedActionIdentifier)

        {

                final T id = createIdentifier(namedActionIdentifier);

                // create sub elements.

                VisitSub(namedActionIdentifier.definingScope(), namedActionIdentifier);

                VisitSub(namedActionIdentifier.type(), namedActionIdentifier);

                for (final Identifier sym : namedActionIdentifier.symbolTable().symbolList())

                        VisitSub(sym, namedActionIdentifier);

                for (final ParameterIdentifier par: namedActionIdentifier.parameter())

                        VisitSub(par, namedActionIdentifier);

                VisitSub(namedActionIdentifier.body(), namedActionIdentifier);

                // create the identifier and initialize it.

                final T symbolTable = m_copier.createSymbolTable();

                for (final Identifier sym: namedActionIdentifier.symbolTable().symbolList())

                        m_copier.addIdentifierToSymbolTable(symbolTable, m_convertedIdentifiers.get(sym));

                final T parameterList = m_copier.createParameterList();

                for (final ParameterIdentifier par: namedActionIdentifier.parameter())

                        m_copier.addParameterIdentifierToList(parameterList, m_convertedIdentifiers.get(par));

                m_copier.initMethodIdentifier(

                                id,

                                namedActionIdentifier.line(),

                                namedActionIdentifier.column(),

                                namedActionIdentifier.tokenText(),

                                m_convertedScopes.get(namedActionIdentifier.definingScope()),

                                m_convertedTypes.get(namedActionIdentifier.type()),

                                namedActionIdentifier.prefix,

                                parameterList,

                                symbolTable,

                                m_convertedStatements.get(namedActionIdentifier.body()));

        }

        @Override

        public void visit(Module module)

        {

                final T id = createIdentifier(module);

                VisitSub(module.definingScope(), module);

                VisitSub(module.type(), module);

                for (final Identifier sym: module.symbolTable().symbolList())

                        VisitSub(sym, module);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier sym: module.symbolTable().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(sym));

                m_copier.initModule(

                                id,

                                module.line(),

                                module.column(),

                                module.tokenText(),

                                m_convertedScopes.get(module.definingScope()),

                                m_convertedTypes.get(module.type()),

                                module.prefix,

                                symTab);

        }

        /**

         * Emit the main module. Notice that even though we run the

         * Instantiation Visitor, we DO NOT emit the flattened AS here

         * but the normal classes etc. That said, we include the information

         * about the instantiated objects (how many etc..)

         */

        @Override

        public void visit(MainModule mainModule)

        {

                m_visited.add(mainModule);

                final T id = createIdentifier(mainModule);

                VisitSub(mainModule.definingScope(), mainModule);

                VisitSub(mainModule.type(), mainModule);

                for (final Identifier sym: mainModule.symbolTable().symbolList())

                        VisitSub(sym, mainModule);

                VisitSub(mainModule.systemDescription(), mainModule);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier sym: mainModule.symbolTable().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(sym));

                m_copier.initMainModule(

                                id,

                                mainModule.line(),

                                mainModule.column(),

                                mainModule.tokenText(),

                                m_convertedScopes.get(mainModule.definingScope()),

                                m_convertedTypes.get(mainModule.type()),

                                mainModule.prefix,

                                symTab,

                                m_convertedIdentifiers.get(mainModule.systemDescription()));

                m_copier.setMainModule(mainModule, id);

        }

        @Override

        public void visit(NondetIdentifierList nondetIdentifierList)

        {

                final T idList = createIdentifier(nondetIdentifierList);

//                VisitSub(nondetIdentifierList.definingScope(), nondetIdentifierList);

//                VisitSub(nondetIdentifierList.type(), nondetIdentifierList);

                for (final Identifier id: nondetIdentifierList.identifiers())

                        VisitSub(id, nondetIdentifierList);

                for (final Identifier id: nondetIdentifierList.identifiers())

                        m_copier.addIdentifierToBlock(idList, m_convertedIdentifiers.get(id));

        }

        @Override

        public void visit(SeqIdentifierList seqIdentifierList)

        {

                final T idList = createIdentifier(seqIdentifierList);

//                VisitSub(nondetIdentifierList.definingScope(), nondetIdentifierList);

//                VisitSub(nondetIdentifierList.type(), nondetIdentifierList);

                for (final Identifier id: seqIdentifierList.identifiers())

                        VisitSub(id, seqIdentifierList);

                for (final Identifier id: seqIdentifierList.identifiers())

                        m_copier.addIdentifierToBlock(idList, m_convertedIdentifiers.get(id));

        }

        @Override

        public void visit(PrioIdentifierList prioIdentifierList)

        {

                final T idList = createIdentifier(prioIdentifierList);

//                VisitSub(nondetIdentifierList.definingScope(), nondetIdentifierList);

//                VisitSub(nondetIdentifierList.type(), nondetIdentifierList);

                for (final Identifier id: prioIdentifierList.identifiers())

                        VisitSub(id, prioIdentifierList);

                for (final Identifier id: prioIdentifierList.identifiers())

                        m_copier.addIdentifierToBlock(idList, m_convertedIdentifiers.get(id));

        }

        @Override

        public void visit(UnspecIdentifierList unspecIdentifierList)

        {

                final T idList = createIdentifier(unspecIdentifierList);

//                VisitSub(nondetIdentifierList.definingScope(), nondetIdentifierList);

//                VisitSub(nondetIdentifierList.type(), nondetIdentifierList);

                for (final Identifier id: unspecIdentifierList.identifiers())

                        VisitSub(id, unspecIdentifierList);

                for (final Identifier id: unspecIdentifierList.identifiers())

                        m_copier.addIdentifierToBlock(idList, m_convertedIdentifiers.get(id));

        }

        @Override

        public void visit(IntType intType)

        {

                final T type = createType(intType);

                final Identifier id = intType.identifier();

                VisitSub(id, intType);

                m_copier.initIntType(

                                type,

                                m_convertedIdentifiers.get(id),

                                intType.isAnonymousType(),

                                intType.rangeLow(),

                                intType.rangeHigh());

        }

        @Override

        public void visit(BoolType boolType)

        {

                final T type = createType(boolType);

                final Identifier id = boolType.identifier();

                VisitSub(id, boolType);

                m_copier.initBoolType(

                                type,

                                m_convertedIdentifiers.get(id),

                                boolType.isAnonymousType());

        }

        @Override

        public void visit(EnumType enumType)

        {

                final T type = createType(enumType);

                final Identifier id = enumType.identifier();

                VisitSub(id, enumType);

                for (final Identifier sym: enumType.listOfEnumSymbols())

                        VisitSub(sym, enumType);

                // initialize

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier sym: enumType.listOfEnumSymbols())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(sym));

                // FIXME: fix the visitor to have a separate method for ValuedEnumTypes..

                if (enumType instanceof ValuedEnumType) {

                        final ValuedEnumType t = (ValuedEnumType) enumType;

                        VisitSub(t.getIntType(), t);

                        m_copier.initValuedEnumType(

                                        type,

                                        m_convertedIdentifiers.get(id),

                                        enumType.isAnonymousType(),

                                        symTab,

                                        m_convertedTypes.get(t.getIntType()));

                } else

                        m_copier.initEnumType(

                                type,

                                m_convertedIdentifiers.get(id),

                                enumType.isAnonymousType(),

                                symTab);

        }

        @Override

        public void visit(ListType listType)

        {

                final T type = createType(listType);

                final Identifier id = listType.identifier();

                VisitSub(id, listType);

                VisitSub(listType.innerType(), listType);

                m_copier.initListType(

                                type,

                                m_convertedIdentifiers.get(id),

                                listType.isAnonymousType(),

                                m_convertedTypes.get(listType.innerType()),

                                listType.maxNumberOfElements());

        }

        @Override

        public void visit(MetaType metaType)

        {

                final T type = createType(metaType);

                final Identifier id = metaType.identifier();

                VisitSub(id, metaType);

                VisitSub(metaType.Type(), metaType);

                m_copier.initMetaType(

                                type,

                                m_convertedIdentifiers.get(id),

                                metaType.isAnonymousType(),

                                m_convertedTypes.get(metaType.Type()));

        }

        @Override

        public void visit(TupleType tupleType)

        {

                final T type = createType(tupleType);

                final Identifier id = tupleType.identifier();

                VisitSub(id, tupleType);

                for (final Type t: tupleType.innerTypes())

                        VisitSub(t, tupleType);

                final T list = m_copier.createTypeList();

                for (final Type t: tupleType.innerTypes())

                        m_copier.addTypeToList(list, m_convertedTypes.get(t));

                m_copier.initTupleType(

                                type,

                                m_convertedIdentifiers.get(id),

                                tupleType.isAnonymousType(),

                                list);

        }

        @Override

        public void visit(FunctionType functionType)

        {

                final T type = createType(functionType);

                final Identifier id = functionType.identifier();

                VisitSub(id, functionType);

                for (final Type a: functionType.parameter())

                        VisitSub(a, functionType);

                VisitSub(functionType.returnType(), functionType);

                final T list = m_copier.createTypeList();

                for (final Type t: functionType.parameter())

                        m_copier.addTypeToList(list, m_convertedTypes.get(t));

                m_copier.initFunctionType(

                                type,

                                m_convertedIdentifiers.get(id),

                                functionType.isAnonymousType(),

                                list,

                                m_convertedTypes.get(functionType.returnType()),

                                functionType.functionType().integerValue,

                                functionType.isPureFunction());

                        // we ignore the isMiracleSafe property here.

        }

        private void convertActionSystemInstance(OoActionSystemInstance i, IAst ooActionSystemType) {

                if (i == null || m_convertedInstances.containsKey(i))

                        return;

                final T instance = m_copier.createActionSystemInstance();

                m_convertedInstances.put(i, instance);

                VisitSub(i.Type, ooActionSystemType);

                convertActionSystemInstance(i.ParentObject, ooActionSystemType);

                m_copier.initActionSystemInstance(

                                instance,

                                m_convertedTypes.get(i.Type),

                                i.Name,

                                i.numberOfCreatedObjects,

                                m_convertedInstances.get(i.ParentObject));

        }

        @Override

        public void visit(OoActionSystemType ooActionSystemType)

        {

                final T type = createType(ooActionSystemType);

                final Identifier id = ooActionSystemType.identifier();

                VisitSub(id, ooActionSystemType);

                for (final Identifier s: ooActionSystemType.symbols().symbolList())

                        VisitSub(s, ooActionSystemType);

                VisitSub(ooActionSystemType.doOdBlock(), ooActionSystemType);

                VisitSub(ooActionSystemType.baseType(), ooActionSystemType);

                for (final OoActionSystemInstance i: ooActionSystemType.objects())

                        convertActionSystemInstance(i, ooActionSystemType);

                for (final OoActionSystemInstance i: ooActionSystemType.derivedObjects())

                        convertActionSystemInstance(i, ooActionSystemType);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier s: ooActionSystemType.symbols().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(s));

                final T objectsList = m_copier.createActionSystemInstanceList();

                for (final OoActionSystemInstance i: ooActionSystemType.objects())

                        m_copier.addActionSystemInstanceToList(objectsList, m_convertedInstances.get(i));

                final T derivedObjectsList = m_copier.createActionSystemInstanceList();

                for (final OoActionSystemInstance i: ooActionSystemType.derivedObjects())

                        m_copier.addActionSystemInstanceToList(objectsList, m_convertedInstances.get(i));

                m_copier.initActionSystemType(

                                type,

                                m_convertedIdentifiers.get(id),

                                ooActionSystemType.isAnonymousType(),

                                m_convertedTypes.get(ooActionSystemType.baseType()),

                                m_convertedScopes.get(ooActionSystemType.GetParentScope()),

                                m_convertedStatements.get(ooActionSystemType.doOdBlock()),

                                symTab,

                                objectsList,

                                derivedObjectsList,

                                ooActionSystemType.autoConstruction(),

                                ooActionSystemType.isInSystemDescription());

        }

        @Override

        public void visit(NullType nullType)

        {

                final T type = createType(nullType);

                final Identifier id = nullType.identifier();

                VisitSub(id, nullType);

                m_copier.initNullType(

                                type,

                                m_convertedIdentifiers.get(id),

                                nullType.isAnonymousType());

        }

        // Statements..

        @Override

        public void visit(SkipStatement skipStatement)

        {

                m_copier.initSkipStatement(

                                createStatement(skipStatement),

                                skipStatement.line(),

                                skipStatement.pos());

        }

        @Override

        public void visit(BreakStatement breakStatement)

        {

                m_copier.initBreakStatement(

                                createStatement(breakStatement),

                                breakStatement.line(),

                                breakStatement.pos());

        }

        @Override

        public void visit(AbortStatement abortStatement)

        {

                m_copier.initAbortStatement(

                                createStatement(abortStatement),

                                abortStatement.line(),

                                abortStatement.pos());

        }

        @Override

        public void visit(NondetBlock nondetBlock)

        {

                final T stmt = createStatement(nondetBlock);

                // make sure all elements are allocated

                VisitSub(nondetBlock.GetParentScope(), nondetBlock);

                for (final Identifier id: nondetBlock.symbols().symbolList())

                        VisitSub(id, nondetBlock);

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

                        VisitSub(stmnt, nondetBlock);

                // assemble data and initialize the block

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier id: nondetBlock.symbols().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(id));

                final T stmtList = m_copier.createStatementList();

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

                        m_copier.addStatementToList(stmtList, m_convertedStatements.get(stmnt));

                m_copier.initNondetBlock(

                                stmt,

                                nondetBlock.line(),

                                nondetBlock.pos(),

                                symTab,

                                stmtList,

                                m_convertedScopes.get(nondetBlock.GetParentScope()));

        }

        @Override

        public void visit(SeqBlock seqBlock)

        {

                final T stmt = createStatement(seqBlock);

                // make sure all elements are allocated

                VisitSub(seqBlock.GetParentScope(), seqBlock);

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

                        VisitSub(id, seqBlock);

                if (seqBlock.filter() != null)

                        VisitSub(seqBlock.filter(), seqBlock);

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

                        VisitSub(stmnt, seqBlock);

                // assemble data and initialize the block

                final T symTab = m_copier.createSymbolTable();

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

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(id));

                final T stmtList = m_copier.createStatementList();

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

                        m_copier.addStatementToList(stmtList, m_convertedStatements.get(stmnt));

                m_copier.initSeqBlock(

                                stmt,

                                seqBlock.line(),

                                seqBlock.pos(),

                                symTab,

                                stmtList,

                                m_convertedScopes.get(seqBlock.GetParentScope()),

                                m_convertedExpressions.get(seqBlock.filter()));

        }

        @Override

        public void visit(PrioBlock prioBlock)

        {

                final T stmt = createStatement(prioBlock);

                // make sure all elements are allocated

                VisitSub(prioBlock.GetParentScope(), prioBlock);

                for (final Identifier id: prioBlock.symbols().symbolList())

                        VisitSub(id, prioBlock);

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

                        VisitSub(stmnt, prioBlock);

                // assemble data and initialize the block

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier id: prioBlock.symbols().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(id));

                final T stmtList = m_copier.createStatementList();

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

                        m_copier.addStatementToList(stmtList, m_convertedStatements.get(stmnt));

                m_copier.initPrioBlock(

                                stmt,

                                prioBlock.line(),

                                prioBlock.pos(),

                                symTab,

                                stmtList,

                                m_convertedScopes.get(prioBlock.GetParentScope()));

        }

        @Override

        public void visit(GuardedCommand guardedCommand)

        {

                final T stmt = createStatement(guardedCommand);

                // make sure all elements are allocated

                VisitSub(guardedCommand.GetParentScope(), guardedCommand);

                VisitSub(guardedCommand.guard(), guardedCommand);

                VisitSub(guardedCommand.body(), guardedCommand);

                m_copier.initGuardedCommand(

                                stmt,

                                guardedCommand.line(),

                                guardedCommand.pos(),

                                m_convertedScopes.get(guardedCommand.GetParentScope()),

                                m_convertedExpressions.get(guardedCommand.guard()),

                                m_convertedStatements.get(guardedCommand.body()));

        }

        @Override

        public void visit(Assignment assignment)

        {

                final T stmt = createStatement(assignment);

                // make sure all elements are allocated

                VisitSub(assignment.GetParentScope(), assignment);

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

                        VisitSub(id, assignment);

                for (final Expression vexp: assignment.places())

                        VisitSub(vexp, assignment);

                for (final Expression expr: assignment.values())

                        VisitSub(expr, assignment);

                VisitSub(assignment.nondetExpression(), assignment);

                final T symTab = m_copier.createSymbolTable();

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

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(id));

                final T places = m_copier.createExpressionList();

                for (final Expression vexp: assignment.places())

                        m_copier.addExpressionToList(places,m_convertedExpressions.get(vexp));

                final T values = m_copier.createExpressionList();

                for (final Expression expr: assignment.values())

                        m_copier.addExpressionToList(values,m_convertedExpressions.get(expr));

                m_copier.initAssignment(

                                stmt,

                                assignment.line(),

                                assignment.pos(),

                                m_convertedScopes.get(assignment.GetParentScope()),

                                m_convertedExpressions.get(assignment.nondetExpression()),

                                places,

                                values,

                                symTab);

        }

        @Override

        public void visit(Call call)

        {

                final T stmt = createStatement(call);

                // make sure all elements are allocated

                VisitSub(call.callExpression(), call);

                m_copier.initCall(

                                stmt,

                                call.line(),

                                call.pos(),

                                m_convertedExpressions.get(call.callExpression()));

        }

        // Expressions

        private final class ExprData {

                public final T typeRef;

                public final T callTargetsIdentifierListRef;

                public final T symbTabRef;

                public final int line;

                public final int pos;

                public ExprData(T type, T callTgts, T symbTabRef, int line, int pos) {

                        typeRef = type;

                        callTargetsIdentifierListRef = callTgts;

                        this.symbTabRef = symbTabRef;

                        this.line = line;

                        this.pos = pos;

                }

        }

        private ExprData visitBasicExpression(Expression e) {

                final T list = m_copier.createIdentifierList();

                final T symTab = m_copier.createSymbolTable();

                VisitSub(e.type(), e);

                for (final FunctionIdentifier i: e.callTargets())

                        VisitSub(i, e);

                if (e.freeVariables() != null) {

                        for (final Identifier id: e.freeVariables().symbolList())

                                VisitSub(id, e);

                        for (final Identifier id: e.freeVariables().symbolList())

                                m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(id));

                }

                for (final FunctionIdentifier i: e.callTargets())

                        m_copier.addIdentifierToList(list, m_convertedIdentifiers.get(i));

                return new ExprData(m_convertedTypes.get(e.type()), list, symTab,

                                e.line(), e.pos());

        }

        @Override

        public void visit(TypeExpression typeExpression)

        {

                final T expr = createExpression(typeExpression);

                final ExprData d = visitBasicExpression(typeExpression);

                VisitSub(typeExpression.referredType(), typeExpression);

                m_copier.initTypeExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedTypes.get(typeExpression.referredType()));

        }

        @Override

        public void visit(IdentifierExpression identifierExpression)

        {

                final T expr = createExpression(identifierExpression);

                final ExprData d = visitBasicExpression(identifierExpression);

                VisitSub(identifierExpression.identifier(), identifierExpression);

                m_copier.initIdentifierExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedIdentifiers.get(identifierExpression.identifier()),

                                identifierExpression.isSelf());

        }

        @Override

        public void visit(UnaryOperator unaryOperator)

        {

                final T expr = createExpression(unaryOperator);

                final ExprData d = visitBasicExpression(unaryOperator);

                VisitSub(unaryOperator.child(), unaryOperator);

                m_copier.initUnaryExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(unaryOperator.child()));

        }

        @Override

        public void visit(BinaryOperator binaryOperator)

        {

                final T expr = createExpression(binaryOperator);

                final ExprData d = visitBasicExpression(binaryOperator);

                VisitSub(binaryOperator.left(), binaryOperator);

                VisitSub(binaryOperator.right(), binaryOperator);

                m_copier.initBinaryExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(binaryOperator.left()),

                                m_convertedExpressions.get(binaryOperator.right()));

        }

        @Override

        public void visit(TernaryOperator ternaryOperator)

        {

                final T expr = createExpression(ternaryOperator);

                final ExprData d = visitBasicExpression(ternaryOperator);

                VisitSub(ternaryOperator.left(), ternaryOperator);

                VisitSub(ternaryOperator.mid(), ternaryOperator);

                VisitSub(ternaryOperator.right(), ternaryOperator);

                VisitSub(ternaryOperator.definingScope(), ternaryOperator);

                m_copier.initTernaryExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(ternaryOperator.left()),

                                m_convertedExpressions.get(ternaryOperator.mid()),

                                m_convertedExpressions.get(ternaryOperator.right()),

                                m_convertedScopes.get(ternaryOperator.definingScope()));

        }

        @Override

        public <U>void visit(ValueExpression<U> valueExpression)

        {

                final T expr = createExpression(valueExpression);

                final ExprData d = visitBasicExpression(valueExpression);

                switch (valueExpression.valueType()) {

                case integer:

                        @SuppressWarnings("unchecked")

                        final int value = ((ValueExpression<Integer>) valueExpression).value();

                        m_copier.initIntValueExpression(

                                        expr,

                                        d.line,

                                        d.pos,

                                        d.typeRef,

                                        d.callTargetsIdentifierListRef,

                                        d.symbTabRef,

                                        value);

                        break;

                case bool:

                        @SuppressWarnings("unchecked")

                        final boolean bvalue = ((ValueExpression<Boolean>) valueExpression).value();

                        m_copier.initBoolValueExpression(

                                        expr,

                                        d.line,

                                        d.pos,

                                        d.typeRef,

                                        d.callTargetsIdentifierListRef,

                                        d.symbTabRef,

                                        bvalue);

                        break;

                case reference:

                        @SuppressWarnings("unchecked")

                        final Object ovalue = ((ValueExpression<Object>) valueExpression).value();

                        if (ovalue != null)

                                throw new NotImplementedException();

                        m_copier.initNullValueExpression(

                                        expr,

                                        d.line,

                                        d.pos,

                                        d.typeRef,

                                        d.callTargetsIdentifierListRef,

                                        d.symbTabRef);

                        break;

                case qval:

                case real:

                case chr:

                        throw new NotImplementedException();

                case identifier:

                case complex:

                case type:

                case unset:

                default:

                        throw new IllegalArgumentException();

                }

        }

        @Override

        public void visit(ListConstructor listConstructor)

        {

                final T expr = createExpression(listConstructor);

                final ExprData d = visitBasicExpression(listConstructor);

                for (final Identifier lvar: listConstructor.comprehensionVariables().symbolList())

                        VisitSub(lvar, listConstructor);

                for (final Expression elems: listConstructor.elements())

                        VisitSub(elems, listConstructor);

                VisitSub(listConstructor.comprehension(), listConstructor);

                VisitSub(listConstructor.GetParentScope(), listConstructor);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier lvar: listConstructor.comprehensionVariables().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(lvar));

                final T exprList = m_copier.createExpressionList();

                for (final Expression elems: listConstructor.elements())

                        m_copier.addExpressionToList(exprList, m_convertedExpressions.get(elems));

                m_copier.initListConstructor(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                exprList,

                                symTab,

                                m_convertedScopes.get(listConstructor.GetParentScope()),

                                m_convertedExpressions.get(listConstructor.comprehension()),

                                listConstructor.hasComprehension());

        }

        @Override

        public void visit(SetConstructor setConstructor)

        {

                final T expr = createExpression(setConstructor);

                final ExprData d = visitBasicExpression(setConstructor);

                for (final Identifier svar: setConstructor.comprehensionVariables().symbolList())

                        VisitSub(svar, setConstructor);

                for (final Expression elems: setConstructor.items())

                        VisitSub(elems, setConstructor);

                VisitSub(setConstructor.comprehension(), setConstructor);

                VisitSub(setConstructor.GetParentScope(), setConstructor);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier lvar: setConstructor.comprehensionVariables().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(lvar));

                final T exprList = m_copier.createExpressionList();

                for (final Expression elems: setConstructor.items())

                        m_copier.addExpressionToList(exprList, m_convertedExpressions.get(elems));

                m_copier.initSetConstructor(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                exprList,

                                symTab,

                                m_convertedScopes.get(setConstructor.GetParentScope()),

                                m_convertedExpressions.get(setConstructor.comprehension()),

                                setConstructor.hasComprehension());

        }

        @Override

        public void visit(TupleConstructor tupleConstructor)

        {

                final T expr = createExpression(tupleConstructor);

                final ExprData d = visitBasicExpression(tupleConstructor);

                for (final Expression elem: tupleConstructor.values())

                        VisitSub(elem, tupleConstructor);

                VisitSub(tupleConstructor.tupleType(), tupleConstructor);

                final T exprList = m_copier.createExpressionList();

                for (final Expression elems: tupleConstructor.values())

                        m_copier.addExpressionToList(exprList, m_convertedExpressions.get(elems));

                m_copier.initTupleConstructor(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                exprList,

                                m_convertedIdentifiers.get(tupleConstructor.tupleType()),

                                tupleConstructor.isMatcher());

        }

        @Override

        public void visit(AccessExpression accessExpression)

        {

                final T expr = createExpression(accessExpression);

                final ExprData d = visitBasicExpression(accessExpression);

                VisitSub(accessExpression.left(), accessExpression);

                VisitSub(accessExpression.right(), accessExpression);

                m_copier.initAccessExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(accessExpression.left()),

                                m_convertedExpressions.get(accessExpression.right()));

        }

        @Override

        public void visit(TupleMapAccessExpression tupleMapAccessExpression)

        {

                final T expr = createExpression(tupleMapAccessExpression);

                final ExprData d = visitBasicExpression(tupleMapAccessExpression);

                VisitSub(tupleMapAccessExpression.argument(), tupleMapAccessExpression);

                VisitSub(tupleMapAccessExpression.child(), tupleMapAccessExpression);

                m_copier.initTupleMapAccessExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(tupleMapAccessExpression.child()),

                                m_convertedExpressions.get(tupleMapAccessExpression.argument()));

        }

        @Override

        public void visit(CallExpression callExpression)

        {

                final T expr = createExpression(callExpression);

                final ExprData d = visitBasicExpression(callExpression);

                VisitSub(callExpression.child(), callExpression);

                VisitSub(callExpression.scope(), callExpression);

                final T exprList = m_copier.createExpressionList();

                if (callExpression.arguments() != null) {

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

                                VisitSub(arg, callExpression);

                        for (final Expression elems: callExpression.arguments())

                                m_copier.addExpressionToList(exprList, m_convertedExpressions.get(elems));

                }

                m_copier.initCallExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(callExpression.child()),

                                exprList,

                                m_convertedScopes.get(callExpression.scope()));

        }

        private void visitQuantifierExpression(Quantifier quantifier)

        {

                final T expr = createExpression(quantifier);

                final ExprData d = visitBasicExpression(quantifier);

                for (final Identifier lvar: quantifier.symbols().symbolList())

                        VisitSub(lvar, quantifier);

                VisitSub(quantifier.child(), quantifier);

                VisitSub(quantifier.GetParentScope(), quantifier);

                final T symTab = m_copier.createSymbolTable();

                for (final Identifier lvar: quantifier.symbols().symbolList())

                        m_copier.addIdentifierToSymbolTable(symTab, m_convertedIdentifiers.get(lvar));

                m_copier.initQuantifierExpression(

                                expr,

                                d.line,

                                d.pos,

                                d.typeRef,

                                d.callTargetsIdentifierListRef,

                                d.symbTabRef,

                                m_convertedExpressions.get(quantifier.child()),

                                symTab,

                                m_convertedScopes.get(quantifier.GetParentScope()));

        }

        @Override

        public void visit(ForallQuantifier quantifier)

        {

                visitQuantifierExpression(quantifier);

        }

        @Override

        public void visit(ExistsQuantifier quantifier)

        {

                visitQuantifierExpression(quantifier);

        }

        @Override

        public void visit(ObjectConstructor objectConstructor)

        {

                final T expr = createExpression(objectConstructor);

                final ExprData d = visitBasicExpression(objectConstructor);

                for (final OoActionSystemInstance i: objectConstructor.instances())

                        convertActionSystemInstance(i, objectConstructor);

                final T instanceList = m_copier.createActionSystemInstanceList();

                for (final OoActionSystemInstance i: objectConstructor.instances())

                        m_copier.addActionSystemInstanceToList(instanceList, m_convertedInstances.get(i));

                m_copier.initObjectConstructor(

                                expr,

                                d.line,

                                d.pos,