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

import java.util.HashSet;

import java.util.Iterator;

import org.momut.ooas.ast.AstNodeTypeEnum;

import org.momut.ooas.ast.IAst;

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

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

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

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

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

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

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

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

import org.momut.ooas.codegen.OoasCodeEmitter;

import org.momut.ooas.parser.SymbolTable;

import org.momut.ooas.visitors.OoaCompleteAstTraversalVisitor;

/// <summary>

/// Knows how to construct a C-CADP type from a UlyssesType

/// (only defined for basic types!)

/// </summary>

public final class CadpType extends OoaCompleteAstTraversalVisitor

{

        private static HashMap<String, Integer> m_typesizes;

        public static HashMap<String, Integer> sizeOfTypes() {return m_typesizes; }

        private final OoasCodeEmitter m_emitter = new OoasCodeEmitter();

//        private int m_typesize;

        public static final String constructorString = "constr_";

        public static final String destructorString = "destr_";

        public static final String lowString = "low_";

        public static final String highString = "count_";

        public static final String enumString = "enum_";

        public static final String printString = "print_";

        @Override

        public void visit(CharType charType)

        {

                m_emitter.Append("char");

//                m_typesize += m_typesizes.get("char");

        }

        @Override

        public  void visit(IntType intType)

        {

                m_emitter.Append("int");

//                m_typesize += m_typesizes.get("int");

        }

        @Override

        public  void visit(BoolType boolType)

        {

                m_emitter.Append("unsigned char");

//                m_typesize += m_typesizes.get("char");

        }

        @Override

        public  void visit(FloatType floatType)

        {

                m_emitter.Append("double");

//                m_typesize += m_typesizes.get("double");

        }

        @Override

        public  void visit(EnumType enumType)

        {

                m_emitter.Append("unsigned int");

//                m_typesize += m_typesizes.get("int");

        }

        @Override

        public  void visit(TupleType tupleType)

        {

                // we map a tuple to a struct

                m_emitter.Append(GetIdentifierString(tupleType.identifier()));

        }

        @Override

        public  void visit(ListType listType)

        {

                m_emitter.Append(GetIdentifierString(listType.identifier()));

        }

        @Override

        public  void visit(NullType nullType)

        {

                m_emitter.Append("int");

        }

        private static String GetIdentifierString(TypeIdentifier typeIdentifier)

        {

                return CadpIdentifier.GetIdentifierString(typeIdentifier);

        }

        @Override

        public  void visit(OoActionSystemType ooActionSystemType)

        {

                // output: pointer to jump table type

                m_emitter.Append(String.format("%s", CadpIdentifier.GetIdentifierString(ooActionSystemType.identifier())));

        }

        // the following types are not supported.

        @Override

        public  void visit(MapType mapType)

        {

                throw new UnsupportedOperationException();

        }

        @Override

        public  void visit(QrType qrType)

        {

                throw new UnsupportedOperationException();

        }

        @Override

        public  void visit(FunctionType functionType)

        {

                throw new UnsupportedOperationException();

        }

        @Override

        public  void visit(OpaqueType opaqueType)

        {

                throw new UnsupportedOperationException();

        }

        @Override

        protected  void VisitAstElement(IAst element, IAst parent)

        {

                if (element.nodeType() == AstNodeTypeEnum.type)

                        super.VisitAstElement(element, parent);

        }

        public  String ToString()

        {

                return m_emitter.toString();

        }

        public CadpType()

        {

                super(null);

        }

        public static String DumpType(UlyssesType atype)

        {

                final CadpType newtype = new CadpType();

                atype.Accept(newtype);

                return newtype.ToString();

        }

        private static HashSet<String> emittedTypes = new HashSet<String>();

        private static void EmitType(UlyssesType aType, OoasCodeEmitter emitter)

        {

                final String typename = CadpIdentifier.GetIdentifierString(aType.identifier());

                if (!emittedTypes.contains(typename))

                        switch (aType.kind())

                        {

                        case BoolType:

                                emittedTypes.add(typename);

                                EmitDefinition((BoolType)aType, emitter);

                                break;

                        case EnumeratedType:

                                emittedTypes.add(typename);

                                EmitDefinition((EnumType)aType, emitter);

                                break;

                        case FloatType:

                                emittedTypes.add(typename);

                                EmitDefinition((FloatType)aType, emitter);

                                break;

                        case IntType:

                                emittedTypes.add(typename);

                                EmitDefinition((IntType)aType, emitter);

                                break;

                        case MapType:

                                throw new UnsupportedOperationException();

                        case ListType:

                                emittedTypes.add(typename);

                                EmitDefinition((ListType)aType, emitter);

                                break;

                        case TupleType:

                                emittedTypes.add(typename);

                                EmitDefinition((TupleType)aType, emitter);

                                break;

                        case OoActionSystemType:

                                emittedTypes.add(typename);

                                EmitDefinition((OoActionSystemType)aType, emitter);

                                break;

                        case QrType:

                                throw new UnsupportedOperationException(); // does not make sense in CADP target.

                        case FunctionType:

                                emittedTypes.add(typename);

                                EmitDefinition((FunctionType)aType, emitter);

                                break;

                        case Null:

                        case Any:

                        case OpaqueType:

                                throw new UnsupportedOperationException(); // should throw invalid args exception

                        default:

                                throw new UnsupportedOperationException();

                        }

        }

        private static void EmitDefinition(FunctionType functionType, OoasCodeEmitter emitter)

        {

                final String typeName = CadpIdentifier.GetIdentifierString(functionType.identifier());

                final String decl = OoaCADPVisitor.FunctionHeader(functionType, String.format("(* %s)", typeName));

                m_functionForwardDefinitions.AppendLine(String.format("typedef %s;", decl));

        }

        private static void EmitDefinition(IntType intType, OoasCodeEmitter emitter)

        {

                final String typeName = GetIdentifierString(intType.identifier());

                emitter.AppendLine(String.format("typedef %s %s;", DumpType(intType), typeName));

                // low

                emitter.AppendLine(String.format("/*%s%s*/", lowString, typeName));

                emitter.Append(String.format("long long int %s%s (void) {", lowString, typeName));

                emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%s%s*/", highString, typeName));

                emitter.Append(String.format("long long int %s%s (void) { return %sLL; }", highString, typeName, ((long)intType.rangeHigh()) - intType.rangeLow() + 1));

                // enumerator

                emitter.AppendLine(String.format("/*%s%s*/", enumString, typeName));

                emitter.Append(String.format("%s %s%s (long long int value) { ", typeName, enumString, typeName));

                emitter.AppendLine(String.format("if (value >= %s%s()) { printf(\"Enum index out of range: %s\\n\"); abort();}", highString, typeName, typeName));

                emitter.Append(String.format("return (%s) (%sLL + value);", typeName, intType.rangeLow()));

                emitter.AppendLine("}");

                // print

                emitter.AppendLine(String.format("/*%s%s*/", printString, typeName));

                emitter.AppendLine(String.format("void %s%s (CAESAR_TYPE_FILE CAESAR_FILE, %s A_VALUE)", printString, typeName, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine("  fprintf(CAESAR_FILE,\"%d\",A_VALUE);");

                emitter.AppendLine("}");

        }

        private static void EmitDefinition(FloatType floatType, OoasCodeEmitter emitter)

        {

                final String typeName = GetIdentifierString(floatType.identifier());

                emitter.AppendLine(String.format("typedef %1$s %2$s;", DumpType(floatType), typeName));

                // low

                emitter.AppendLine(String.format("/*%1$s%2$s*/", lowString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%1$s%2$s*/", highString, typeName));

                final long count = (long) (((long)floatType.high() - (long)floatType.low()) / floatType.precision());

                emitter.Append(String.format("long long int %2$s%1$s (void) { return %3$sLL; }", typeName, highString, count));

                // enumerator

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                emitter.Append(String.format("%1$s %2$s%1$s (long long int value) { ", typeName, enumString));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                emitter.Append(String.format("return %1$sLL + (value * %2$s);", floatType.low(), floatType.precision()));

                emitter.AppendLine("}");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine("  fprintf(CAESAR_FILE,\"%lf\",A_VALUE);");

                emitter.AppendLine("}");

        }

        private static void EmitDefinition(EnumType enumType, OoasCodeEmitter emitter)

        {

                final String typeName = GetIdentifierString(enumType.identifier());

                emitter.AppendLine(String.format("typedef %1$s %2$s;", DumpType(enumType), typeName));

                // low

                emitter.AppendLine(String.format("/*%1$s%2$s*/", lowString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%1$s%2$s*/", highString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) { return %3$s; }", typeName, highString, enumType.listOfEnumSymbols().size()));

                if (enumType instanceof ValuedEnumType)

                        ValuedEnumType((ValuedEnumType)enumType, emitter, typeName);

                else

                        NormalEnumType(enumType, emitter, typeName);

        }

        private static void ValuedEnumType(ValuedEnumType enumType, OoasCodeEmitter emitter, String typeName)

        {

                // enumerator

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                emitter.AppendLine(String.format("%3$s %2$s%1$s (long long int value) { ", typeName, enumString, DumpType(enumType)));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                int i = 0;

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

                {

                        final EnumIdentifier id = (EnumIdentifier)sym;

                        emitter.AppendLine(String.format("if (value == %1$s) return (int) %2$s;", i++, id.Value()));

                }

                emitter.AppendLine("}");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                i = 0;

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

                {

                        final EnumIdentifier id = (EnumIdentifier)sym;

                        emitter.AppendLine(String.format("  if (A_VALUE == %1$s) fprintf(CAESAR_FILE,\"%2$s\");", id.Value(), id.tokenText()));

                }

                emitter.AppendLine("}");

        }

        private static void NormalEnumType(EnumType enumType, OoasCodeEmitter emitter, String typeName)

        {

                // enumerator

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                emitter.AppendLine(String.format("%3$s %2$s%1$s (long long int value) { ", typeName, enumString, DumpType(enumType)));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                emitter.AppendLine(String.format("return (int)value; /*enums are treated like ints*/"));

                emitter.AppendLine("}");

                // backtranslation of enum syms

                emitter.AppendLine(String.format(" /* backtranslation of enum %1$s */ ", typeName));

                emitter.Append(String.format("CAESAR_TYPE_STRING _%1$s_identifiers[%2$s] = {", typeName, enumType.listOfEnumSymbols().size()));

                int i = 0;

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

                {

                        if (i != 0)

                                emitter.Append(", ");

                        else

                                i++;

                        emitter.Append(String.format("\"%1$s\"", x.tokenText()));

                }

                emitter.AppendLine("};");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine(String.format("  fprintf(CAESAR_FILE,\"%%s\", _%1$s_identifiers[A_VALUE]);", typeName));

                emitter.AppendLine("}");

        }

        private static void EmitDefinition(BoolType boolType, OoasCodeEmitter emitter)

        {

                final String typeName = GetIdentifierString(boolType.identifier());

                emitter.AppendLine(String.format("typedef %1$s %2$s;", DumpType(boolType), typeName));

                // low

                emitter.AppendLine(String.format("/*%1$s%2$s*/", lowString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%1$s%2$s*/", highString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) { return 2; }", typeName, highString));

                // enumerator

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                emitter.Append(String.format("%1$s %2$s%1$s (long long int value) { ", typeName, enumString));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                emitter.Append("return (int) value;");

                emitter.AppendLine("}");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine(String.format("  fprintf(CAESAR_FILE,\"%%s\", A_VALUE ? \"true\" : \"false\");"));

                emitter.AppendLine("}");

        }

        /// <summary>

        /// Emits type definition for list

        /// </summary>

        private static void EmitDefinition(ListType alistType, OoasCodeEmitter result)

        {

                if (alistType.innerType().kind() != TypeKind.Null &&

                                !emittedTypes.contains(CadpIdentifier.GetIdentifierString(alistType.innerType().identifier())))

                        EmitType(alistType.innerType(), result);

                final OoasCodeEmitter emitter = new OoasCodeEmitter();

                final String typeName = GetIdentifierString(alistType.identifier()).replaceAll(" ", "_");

                // include a forward definition

                m_typeForwardDefinitions.AppendLine(String.format("typedef struct list_%1$s %1$s;", typeName));

                emitter.AppendLine("#ifdef WINDOWSPACK");

                emitter.AppendLine("#pragma pack(1)");

                emitter.AppendLine("#endif");

                emitter.AppendLine(String.format("struct list_%1$s { int length; %2$s elements[%3$s];} UNIXPACK /*%1$s, * p%1$s*/;"

                                , typeName, DumpType(alistType.innerType()), alistType.maxNumberOfElements() == 0 ? 1 : alistType.maxNumberOfElements()));

                emitter.AppendLine(String.format("#define MAX_%1$s %2$s", typeName, alistType.maxNumberOfElements()));

                emitter.AppendLine("");

                // -- constructor (non pointer)

                emitter.AppendLine(String.format("/*%1$s*/", constructorString));

                emitter.Append(String.format("%1$s %2$s%1$s (int length ", typeName, constructorString));

                final String internalType = DumpType(alistType.innerType());

                int i;

                for (i = 0; i < alistType.maxNumberOfElements(); i++)

                {

                        emitter.Append(", ");

                        emitter.Append(String.format("%1$s arg_%2$s", internalType, i));

                }

                emitter.AppendLineIncIndent(") {");

                emitter.AppendLine(String.format("%1$s result;", typeName));

                emitter.AppendLine(String.format(String.format("memset(&result,0,sizeof(%1$s));", typeName)));

                emitter.AppendLine("result.length = length;");

                for (i = 0; i < alistType.maxNumberOfElements(); i++)

                {

                        emitter.AppendLine(String.format("result.elements[%1$s] = arg_%1$s;", i));

                        /*do range checking on ints and floats*/

                        switch (alistType.innerType().kind())

                        {

                        case IntType:

                                final IntType placetype_int = (IntType)alistType.innerType();

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

                                emitter.AppendLine(String.format("if (arg_%1$s < %2$s || arg_%1$s > %3$s)", i, placetype_int.rangeLow(), placetype_int.rangeHigh()));

                                emitter.AppendLine(String.format("{CALC_INVALID = 1;}"));

                                break;

                        case FloatType:

                                final FloatType placetype_float = (FloatType)alistType.innerType();

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

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

                                emitter.AppendLine(String.format("{CALC_INVALID = 1;}"));

                                break;

                        default:

                                break;

                        }

                }

                emitter.AppendLine("return result;");

                emitter.AppendLineDecIndent("}");

                emitter.AppendLine("");

                emitter.AppendLine("");

                // low

                emitter.AppendLine(String.format("/*%1$s*/", lowString));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%1$s*/", highString));

                if (alistType.innerType().kind() == TypeKind.Null)

                        emitter.Append(String.format("int %2$s%1$s (void) { return 0; }", typeName, highString));

                else

                        emitter.Append(String.format("long long int %2$s%1$s (void) { return MAX_%1$s * %2$s%3$s(); }", typeName, highString, GetIdentifierString(alistType.innerType().identifier())));

                // enumerator

                //emitter.AppendLine(String.format("/*%1$s*/", enumString));

                //emitter.Append(String.format("%1$s %2$s%1$s (int value) { ", typeName, enumString));

                //emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                //emitter.AppendLine("abort();");

                //emitter.Append("return value;");

                //emitter.AppendLine("}");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine(String.format("  fprintf(CAESAR_FILE,\" [len: %%d \", A_VALUE.length);"));

                for (i = 0; i < alistType.maxNumberOfElements(); i++)

                {

                        emitter.AppendLine(String.format("if (A_VALUE.length > %1$s){", i));

                        emitter.AppendLine(String.format("fprintf(CAESAR_FILE,\" %1$s: \");", i));

                        emitter.AppendLine(String.format("%1$s%2$s (CAESAR_FILE, A_VALUE.elements[%3$s]);", printString, CadpIdentifier.GetIdentifierString(alistType.innerType().identifier()), i));

                        emitter.AppendLine("} /*if*/");

                }

                emitter.AppendLine("  fprintf(CAESAR_FILE,\"]\");");

                emitter.AppendLine("}");

                result.Append(emitter.toString());

        }

        private static void EmitDefinition(TupleType atupleType, OoasCodeEmitter result)

        {

                final String typeName = GetIdentifierString(atupleType.identifier());

                final OoasCodeEmitter emitter = new OoasCodeEmitter();

                // include a forward definition

                m_typeForwardDefinitions.AppendLine(String.format("typedef struct struct_%1$s %1$s;", typeName));

                emitter.AppendLine("#ifdef WINDOWSPACK");

                emitter.AppendLine("#pragma pack(1)");

                emitter.AppendLine("#endif");

                emitter.AppendLineIncIndent(String.format("struct struct_%1$s {", typeName));

                int i = 0;

                for (final UlyssesType it: atupleType.innerTypes())

                {

                        EmitType(it);

                        emitter.AppendLine(String.format("%1$s elem_%2$s;", DumpType(it), i));

                        i++;

                }

                emitter.AppendLineDecIndent(String.format("} UNIXPACK /*%1$s, * p%1$s*/;", typeName));

                emitter.AppendLine("");

                // -- constructor (non pointer)

                emitter.AppendLine(String.format("/*%1$s%2$s*/", constructorString, typeName));

                emitter.Append(String.format("%1$s %2$s%1$s (", typeName, constructorString));

                i = 0;

                for (final UlyssesType it: atupleType.innerTypes())

                {

                        if (!emittedTypes.contains(CadpIdentifier.GetIdentifierString(it.identifier())))

                                EmitType(it, result);

                        if (i != 0)

                                emitter.Append(",");

                        emitter.Append(String.format("%1$s arg_%2$s", DumpType(it), i));

                        i++;

                }

                emitter.AppendLineIncIndent(") {");

                emitter.AppendLine(String.format("%1$s result;", typeName));

                i = 0;

                for (final UlyssesType it:  atupleType.innerTypes())

                {

                        emitter.AppendLine(String.format("result.elem_%1$s = arg_%1$s;", i));

                        /*do range checking on ints and floats*/

                        switch (it.kind())

                        {

                        case IntType:

                                final IntType placetype_int = (IntType)it;

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

                                emitter.AppendLine(String.format("if (arg_%1$s < %2$s || arg_%1$s > %3$s)", i, placetype_int.rangeLow(), placetype_int.rangeHigh()));

                                emitter.AppendLine(String.format("{CALC_INVALID = 1;}"));

                                break;

                        case FloatType:

                                final FloatType placetype_float = (FloatType)it;

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

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

                                emitter.AppendLine(String.format("{CALC_INVALID = 1;}"));

                                break;

                        default:

                                break;

                        }

                        i++;

                }

                emitter.AppendLine("return result;");

                emitter.AppendLineDecIndent("}");

                emitter.AppendLine("");

                // low

                emitter.AppendLine(String.format("/*%1$s%2$s*/", lowString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                // high

                emitter.AppendLine(String.format("/*%1$s%2$s*/", highString, typeName));

                emitter.Append(String.format("long long int %2$s%1$s (void) { return ", typeName, highString));

                i = 0;

                for (final UlyssesType x : atupleType.innerTypes())

                {

                        if (i != 0)

                                emitter.Append(" * ");

                        else

                                i++;

                        emitter.Append(String.format("%2$s%1$s()", GetIdentifierString(x.identifier()), highString));

                }

                emitter.AppendLine("; }");

                // enumerator

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                emitter.Append(String.format("%1$s %2$s%1$s (long long int value) { ", typeName, enumString));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                emitter.Append(String.format("return %2$s%1$s (", typeName, constructorString));

                i = 0;

                final StringBuilder divisor = new StringBuilder("value");

                for (final UlyssesType it: atupleType.innerTypes())

                {

                        if (i != 0)

                                emitter.Append(",");

                        else i++;

                        emitter.Append(String.format("%2$s%1$s((%4$s) %% %3$s%1$s())", GetIdentifierString(it.identifier()), enumString, highString, divisor.toString()));

                        divisor.append(String.format(" / %2$s%1$s() ", GetIdentifierString(it.identifier()), highString));

                }

                emitter.AppendLine(");}");

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine(String.format("  fprintf(CAESAR_FILE,\" (\");"));

                final Iterator<UlyssesType> iter = atupleType.innerTypes().iterator();

                for (i = 0; i < atupleType.innerTypes().size(); i++)

                {

                        if (i != 0)

                                emitter.AppendLine("fprintf(CAESAR_FILE, \", \");");

                        emitter.AppendLine(String.format("%1$s%2$s (CAESAR_FILE, A_VALUE.elem_%3$s);", printString, CadpIdentifier.GetIdentifierString(iter.next().identifier()), i));

                }

                emitter.AppendLine("  fprintf(CAESAR_FILE,\")\");");

                emitter.AppendLine("}");

                emitter.AppendLine("");

                result.Append(emitter.toString());

        }

        public static String GetNullConstant(OoActionSystemType anActionSystem)

        {

                return String.format("NULL_%1$s", CadpIdentifier.GetIdentifierString(anActionSystem.identifier()));

        }

        private static void EmitObjectJumpTable(OoActionSystemType instance)

        {

                final OoasCodeEmitter emitter = new OoasCodeEmitter();

                final OoasCodeEmitter forwards = new OoasCodeEmitter();

                // emit null

                emitter.AppendLine(String.format("%1$s NULL_%2$s = {0, \"NULL_%2$s\"",

                                CadpIdentifier.GetIdentifierString(instance.identifier()),

                                CadpIdentifier.GetIdentifierString(instance.identifier())));

                emitter.AppendLine(", NULL");

                emitter.AppendLine("};");

                // emit standard jump table

                // emit objects

                for (final OoActionSystemInstance ooainstance: instance.objects())

                {

                        forwards.AppendLine(String.format("/* ==> Object %1$s <==*/", ooainstance.Name));

                        emitter.AppendLine(String.format("struct jump_%1$s methods_%2$s = {",

                                        CadpIdentifier.GetIdentifierString(instance.identifier()), ooainstance.Name));

                        int i = 0;

                        final SymbolTable allSyms = instance.getAllSymbols();

                        for (final Identifier sym : allSyms.symbolList())

                        {

                                if (sym.kind() == IdentifierKind.MethodIdentifier)

                                {

                                        if (i != 0)

                                                emitter.AppendLine(", ");

                                        // FIXME: this does not take the shortener into account...

                                        final String method = String.format("%s_%s", ooainstance.Name, ((FunctionIdentifier)sym).tokenText());

//                                        final String method = OoaObjectInstantiationVisitor.getInstanceFunctionName(ooainstance, (FunctionIdentifier)sym);

                                        final String methoddef = OoaCADPVisitor.FunctionHeader((FunctionIdentifier)sym, method);

                                        forwards.AppendLine(String.format("%1$s;", methoddef));

                                        emitter.Append(String.format("&%1$s", method));

                                        i++;

                                }

                        }

                        emitter.AppendLine();

                        emitter.AppendLine("};");

                        emitter.Append(String.format("%1$s %2$s = {1, \"%2$s\", & methods_%2$s",

                                        CadpIdentifier.GetIdentifierString(ooainstance.Type.identifier()), ooainstance.Name));

                        emitter.AppendLine("};");

                }

                // enumerator

                final String typeName = String.format("%1$s", CadpIdentifier.GetIdentifierString(instance.identifier()));

                emitter.AppendLine(String.format("/*%1$s%2$s*/", enumString, typeName));

                // extern defs.

                for (final OoActionSystemInstance inst: instance.derivedObjects())

                        emitter.AppendLine(String.format("extern %1$s %2$s;", CadpIdentifier.GetIdentifierString(inst.Type.identifier()),inst.Name));

                emitter.AppendLine(String.format("%1$s %2$s%1$s (long long int value) { ", typeName, enumString));

                m_functionForwardDefinitions.AppendLine(String.format("%1$s %2$s%1$s (long long int value);", typeName, enumString));

                emitter.AppendLine(String.format("if (value >= %2$s%1$s()) { printf(\"Enum index out of range: %1$s\\n\"); abort();}", typeName, highString));

                emitter.AppendLine(String.format("switch((int)value){"));

                emitter.AppendLine(String.format(" case 0 : return NULL_%1$s;", CadpIdentifier.GetIdentifierString(instance.identifier())));

                int u = 1;

                for (final OoActionSystemInstance inst: instance.objects())

                {

                        emitter.AppendLine(String.format("case %1$s:", u));

                        emitter.AppendLine(String.format("return %1$s;", inst.Name));

                        u++;

                }

                for (final OoActionSystemInstance inst: instance.derivedObjects())

                {

                        emitter.AppendLine(String.format("case %1$s:", u));

                        emitter.AppendLine(String.format("return *(%2$s*)&(%1$s);", inst.Name, typeName));

                        u++;

                }

                emitter.AppendLine("}");

                emitter.AppendLine("printf(\"bug during simulation:\\n     unknown object number\\n\"); CAESAR_TERMINATE(1);");

                emitter.AppendLine(String.format("return NULL_%1$s;", CadpIdentifier.GetIdentifierString(instance.identifier())));

                emitter.AppendLine("}");

                m_typeDefinitions.AppendLine(forwards.toString());

                m_typeDefinitions.AppendLine(emitter.toString());

        }

        private static void EmitDefinition(OoActionSystemType aClass, OoasCodeEmitter result)

        {

                /* ooa type gets translated into a jump table */

                final String typeName = String.format("%1$s", CadpIdentifier.GetIdentifierString(aClass.identifier()));

                final OoasCodeEmitter emitter = new OoasCodeEmitter();

                final OoasCodeEmitter classStructure = new OoasCodeEmitter();

                classStructure.AppendLine(String.format("/* jump table type for class %1$s */", aClass.identifier().tokenText()));

                classStructure.AppendLine(String.format("struct jump_%1$s {", typeName));

//                int i = 0;

                final SymbolTable allSyms = aClass.getAllSymbols();

                for (final Identifier sym: allSyms.symbolList())

                {

                        if (sym.kind() == IdentifierKind.MethodIdentifier)

                        {

                                final MethodIdentifier method = (MethodIdentifier)sym;

                                EmitType(method.type());

                                classStructure.AppendLine(String.format("%1$s %2$s;", CadpIdentifier.GetIdentifierString(method), method.tokenText()));

//                                i++;

                        }

                }

                classStructure.AppendLine("};");

                classStructure.AppendLine("#ifdef WINDOWSPACK");

                classStructure.AppendLine("#pragma pack(1)");

                classStructure.AppendLine("#endif");

                classStructure.AppendLineIncIndent(String.format("struct struct_%1$s {", typeName));

                classStructure.AppendLine("char __validinstance;");

                classStructure.AppendLine("char* __object_name;");

                classStructure.AppendLine(String.format("struct jump_%1$s *methods;", typeName));

                classStructure.AppendLineDecIndent(String.format("} UNIXPACK /*%1$s*/;", typeName));

                m_classTypeDefinitions.AppendLine(classStructure.toString());

                emitter.AppendLine("");

                // include a forward definition

                m_typeForwardDefinitions.AppendLine(String.format("typedef struct struct_%1$s %1$s;", typeName));

                // low

                emitter.AppendLine(String.format("/*%1$s%2$s*/", lowString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) {", typeName, lowString)); emitter.AppendLine("return 0; }");

                m_functionForwardDefinitions.AppendLine(String.format("int %2$s%1$s (void);", typeName, lowString));

                // high

                emitter.AppendLine(String.format("/*%1$s%2$s*/", highString, typeName));

                emitter.Append(String.format("int %2$s%1$s (void) { return %3$s; }", typeName, highString, aClass.objects().size() + 1 + aClass.derivedObjects().size()));

                m_functionForwardDefinitions.AppendLine(String.format("int %2$s%1$s (void);", typeName, highString));

                // print

                emitter.AppendLine(String.format("/*%1$s%2$s*/", printString, typeName));

                emitter.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE)", printString, typeName));

                emitter.AppendLine("{");

                emitter.AppendLine("  fprintf(CAESAR_FILE,\"object %s\", A_VALUE.__object_name);");

                emitter.AppendLine("}");

                m_functionForwardDefinitions.AppendLine(String.format("void %1$s%2$s (CAESAR_TYPE_FILE CAESAR_FILE, %2$s A_VALUE);", printString, typeName));

                result.Append(emitter.toString());

                EmitObjectJumpTable(aClass);

        }

        public static String GetMaxVal(UlyssesType atype)

        {

                return String.format(" (%2$s%1$s() - 1) ", GetIdentifierString(atype.identifier()), highString);

        }

        public static String GetMinVal(UlyssesType atype)

        {

                return String.format(" %2$s%1$s() ", GetIdentifierString(atype.identifier()), lowString);

        }

        public static String GetEnumVal(UlyssesType atype, String indexvar)

        {

                return String.format(" %2$s%1$s(%3$s)", GetIdentifierString(atype.identifier()), enumString, indexvar);

        }

        public static String GetEnumVal(UlyssesType atype)

        {

                return String.format(" %2$s%1$s", GetIdentifierString(atype.identifier()), enumString);

        }

        private static OoasCodeEmitter m_typeForwardDefinitions = new OoasCodeEmitter();

        private static OoasCodeEmitter m_functionForwardDefinitions = new OoasCodeEmitter();

        private static OoasCodeEmitter m_classTypeDefinitions = new OoasCodeEmitter();

        private static OoasCodeEmitter m_typeDefinitions = new OoasCodeEmitter();

        public static void EmitType(UlyssesType aType)

        {

                EmitType(aType, m_typeDefinitions);

        }

        public static String GetTypeDefintions()

        {

                final StringBuilder result = new StringBuilder();

                result.append(m_typeForwardDefinitions.toString());

                result.append(System.lineSeparator());

                result.append(m_functionForwardDefinitions.toString());

                result.append(System.lineSeparator());

                result.append(m_classTypeDefinitions.toString());

                result.append(System.lineSeparator());

                result.append(m_typeDefinitions.toString());

                result.append(System.lineSeparator());

                return result.toString();

        }

        public static boolean IsNumeric(UlyssesType ulyssesType)

        {

                switch (ulyssesType.kind())

                {

                case BoolType:

                case EnumeratedType:

                case FloatType:

                case IntType:

                        return true;

                default:

                        return false;

                }

        }

        static

        {

                // populate typesizes.

                m_typesizes = new HashMap<String, Integer>();

                m_typesizes.put("char", 1);

                m_typesizes.put("int", 4);

                m_typesizes.put("double", 8);

                m_typesizes.put("pointer", 4);

        }

        public static void AddTypeDefinition(String listStruct)

        {

                if (!emittedTypes.contains(listStruct))

                {

                        m_typeDefinitions.AppendLine(listStruct);

                        emittedTypes.add(listStruct);

                }

        }

}