OoasTools

/**

  *

  *                      OOAS Compiler (Deprecated)

  *

  * Copyright 2015, Institute for Software Technology, Graz University of

  * Technology. Portions are copyright 2015 by the AIT Austrian Institute

  * of Technology. All rights reserved.

  *

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

  *

  * Please notice that this version of the OOAS compiler is considered de-

  * precated. Only the Java version is maintained.

  *

  * Contributors:

  *               Willibald Krenn (TU Graz/AIT)

  *               Stefan Tiran (TU Graz/AIT)

  */

/*

 * Prolog Code Generator

 */

using System;

using System.Collections.Generic;

using System.Text;

using TUG.Mogentes.Codegen;

namespace TUG.Mogentes.Codegen.Prolog

{

    public class OoaPrologType : OoaTypeVisitor

    {

        public class Factory

        {

            public virtual OoaPrologType create(OoaPrologIdentifier.Factory idFactory) { return new OoaPrologType(idFactory); }

        }

        private static C5.HashBag<UlyssesType> definedTypes = new C5.HashBag<UlyssesType>();

        public static StringBuilder typeDefinitions = new StringBuilder();

        public static void EmitType(UlyssesType aType, OoaPrologIdentifier.Factory idFactory)

        {

            OoaPrologType ptype = new OoaPrologType(idFactory);

            OoaCodeEmitter m_emitter = new OoaCodeEmitter();

            if (definedTypes.Contains(aType))

                return;

            definedTypes.Add(aType);

            switch (aType.kind)

            {

                case TypeKind.OoActionSystemType:

                    aType.Accept(ptype);

                    OoActionSystemType classtype = (OoActionSystemType)aType;

                    // m_emitter.Append(String.Format("type( {0}, X) :- member(X,[ 'null'", ptype.ToString()));

                    if (classtype.objects.Count == 0 && classtype.derivedObjects.Count == 0)

                    {

                        m_emitter.AppendLine(String.Format("type( {0}, nil).", ptype.ToString()));

                    }

                    else

                    {

                        m_emitter.Append(String.Format("type( {0}, X) :- member(X,[", ptype.ToString()));

                        bool firste = true;

                        foreach (var inst in classtype.objects)

                        {

                            if (firste)

                                firste = false;

                            else

                                m_emitter.Append(", ");

                            m_emitter.Append(String.Format("'{0}'", inst.Name));

                        }

                        firste = true;

                        if (classtype.objects.Count > 0 && classtype.derivedObjects.Count > 0)

                            m_emitter.Append(", ");

                        foreach (var inst in classtype.derivedObjects)

                        {

                            if (firste)

                                firste = false;

                            else

                                m_emitter.Append(", ");

                            m_emitter.Append(String.Format("'{0}'", inst.Name));

                        }

                        m_emitter.AppendLine("]).");

                    }

                    break;

                case TypeKind.EnumeratedType:

                    aType.Accept(ptype);

                    if (aType is ValuedEnumType)

                    {

                        ValuedEnumType venum = (ValuedEnumType)aType;

                        m_emitter.Append(String.Format("type({0}, X) :- member(X,[", ptype.ToString()));

                        bool nocomma = true;

                        foreach (var val in venum.symbolTable.symbolList)

                        {

                            EnumIdentifier id = (EnumIdentifier)val;

                            System.Diagnostics.Debug.Assert(id.HaveValue);

                            if (nocomma)

                                nocomma = false;

                            else

                                m_emitter.Append(", ");

                            m_emitter.Append(id.Value);

                        }

                        m_emitter.AppendLine("]).");

                    }

                    else

                    {

                        EnumType enumtype = (EnumType)aType;

                        m_emitter.AppendLine(String.Format("type( {0}, X) :- X in 0..{1}, labeling([],[X]).", ptype.ToString(), enumtype.listOfEnumSymbols.Count - 1));

                    }

                    break;

                case TypeKind.IntType:

                    aType.Accept(ptype);

                    IntType inttype = (IntType)aType;

                    m_emitter.AppendLine(String.Format("type( {0}, X) :- X in {1}..{2}, labeling([],[X]).", ptype.ToString(), inttype.rangeLow, inttype.rangeHigh));

                    break;

                case TypeKind.FloatType:

                    throw new NotImplementedException();

                case TypeKind.Any:

                    break;

                case TypeKind.ListType:

                    ListType listType = (ListType)aType;

                    aType.Accept(ptype);

                    m_emitter.Append(String.Format("type( {0}, ", ptype.ToString()));

                    m_emitter.Append("[");

                    Boolean first = true;

                    OoaPrologType pType = new OoaPrologType(idFactory);

                    listType.innerType.Accept(pType);

                    for (int i = 0; i < listType.maxNumberOfElements; i++)

                    {

                        if (!first)

                        {

                            m_emitter.Append(", ");

                        }

                        first = false;

                        m_emitter.Append(pType.ToString());

                    }

                    m_emitter.AppendLine("]).");

                    break;

                case TypeKind.MapType:

                    throw new NotImplementedException();

                case TypeKind.FunctionType:

                case TypeKind.OpaqueType:

                case TypeKind.Null:

                    throw new NotImplementedException(); // must not hit this

                case TypeKind.TupleType:

                    TupleType tupleType = (TupleType)aType;

                    aType.Accept(ptype);

                    m_emitter.Append(String.Format("type( {0}, ", ptype.ToString()));

                    m_emitter.Append("[");

                    first = true;

                    foreach (var type in tupleType.innerTypes)

                    {

                        OoaPrologType iType = new OoaPrologType(idFactory);

                        type.Accept(iType);

                        if (!first)

                        {

                            m_emitter.Append(", ");

                        }

                        first = false;

                        m_emitter.Append(iType.ToString());

                    }

                    m_emitter.AppendLine("]).");

                    break;

                case TypeKind.QrType:

                    aType.Accept(ptype);

                    QrType qrtype = (QrType)aType;

                    StringBuilder landmarks = new StringBuilder();

                    int cntr = 0;

                    foreach (var s in qrtype.landmarks)

                    {

                        if (cntr != 0)

                            landmarks.Append(", ");

                        else

                            cntr++;

                        OoaPrologIdentifier identifierVisitor = idFactory.create();

                        s.Accept(identifierVisitor);

                        landmarks.Append(identifierVisitor.ToString());

                    }

                    m_emitter.AppendLine(String.Format("qspace( {0}, [{1}] ).", ptype.ToString(), landmarks.ToString()));

                    break;

                default:

                    throw new NotImplementedException();

            }

            typeDefinitions.Append(m_emitter.ToString());

        }

        private OoaCodeEmitter m_emitter = new OoaCodeEmitter();

        private OoaPrologIdentifier.Factory m_idFactory;

        public override void visit(CharType charType)

        {

            m_emitter.Append("char");

        }

        public override void visit(IntType intType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            intType.identifier.Accept(id);

            EmitType(intType, m_idFactory);

            m_emitter.Append(id.ToString());

        }

        public override void visit(BoolType boolType)

        {

            m_emitter.Append("bool");

        }

        public override void visit(FloatType floatType)

        {

            throw new NotImplementedException();

        }

        public override void visit(EnumType enumType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            enumType.identifier.Accept(id);

            EmitType(enumType, m_idFactory);

            m_emitter.Append(id.ToString());

        }

        public override void visit(ListType listType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            listType.identifier.Accept(id);

            EmitType(listType, m_idFactory);

            m_emitter.Append(id.ToString());

        }

        public override void visit(MapType mapType)

        {

            throw new NotImplementedException();

        }

        public override void visit(QrType qrType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            qrType.identifier.Accept(id);

            m_emitter.Append(id.ToString());

            // m_emitter.Append(qrType.identifier.tokenText.ToLower());

        }

        public override void visit(TupleType tupleType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            tupleType.identifier.Accept(id);

            EmitType(tupleType, m_idFactory);

            m_emitter.Append(id.ToString());

        }

        public override void visit(FunctionType functionType)

        {

            throw new NotImplementedException();

        }

        public override void visit(OoActionSystemType ooActionSystemType)

        {

            OoaPrologIdentifier id = m_idFactory.create();

            ooActionSystemType.identifier.Accept(id);

            m_emitter.Append(id.ToString());

        }

        public override void visit(OpaqueType opaqueType)

        {

            throw new NotImplementedException();

        }

        public override string ToString()

        {

            return m_emitter.ToString();

        }

        public virtual string GetInternalTypeDefinitions()

        {

            OoaCodeEmitter result = new OoaCodeEmitter();

            result.AppendLine("type(bool, X) :- member(X,[fail,true]).");

            result.AppendLine("type(char, X) :- X in 0..255, labeling([],[X]).");

            return result.ToString();

        }

        protected OoaPrologType(OoaPrologIdentifier.Factory idFactory)

        {

            m_idFactory = idFactory;

        }

    }

}