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

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

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

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

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

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

import org.momut.ooas.codegen.OoasCodeEmitter;

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

import org.momut.ooas.visitors.OoaTypeVisitor;

public class OoaPrologType extends OoaTypeVisitor

{

        public static class Factory

        {

                public OoaPrologType create(OoaPrologIdentifier.Factory idFactory, Scratchbook scratchbook) { return new OoaPrologType(idFactory, scratchbook); }

        }

        protected final Scratchbook m_scratchbook;

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

        {

                final OoaPrologType ptype = new OoaPrologType(idFactory, scratchbook);

                final OoasCodeEmitter m_emitter = new OoasCodeEmitter();

                if (scratchbook.definedTypes().contains(aType))

                        return;

                scratchbook.definedTypes().add(aType);

                switch (aType.kind())

                {

                case OoActionSystemType:

                        aType.Accept(ptype);

                        final OoActionSystemType classtype = (OoActionSystemType)aType;

                        // m_emitter.Append(String.format("type( %s, X) :- member(X,[ 'null'", ptype.ToString()));

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

                        {

                                m_emitter.AppendLine(String.format("type( %s, nil).", ptype.toString()));

                        }

                        else

                        {

                                m_emitter.Append(String.format("type( %s, X) :- member(X,[null,", ptype.toString()));

                                boolean firste = true;

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

                                {

                                        if (firste)

                                                firste = false;

                                        else

                                                m_emitter.Append(", ");

                                        m_emitter.Append(String.format("'%s'", inst.Name));

                                }

                                firste = true;

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

                                        m_emitter.Append(", ");

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

                                {

                                        if (firste)

                                                firste = false;

                                        else

                                                m_emitter.Append(", ");

                                        m_emitter.Append(String.format("'%s'", inst.Name));

                                }

                                m_emitter.AppendLine("]).");

                        }

                        break;

                case EnumeratedType:

                        aType.Accept(ptype);

                        if (aType instanceof ValuedEnumType)

                        {

                                final ValuedEnumType venum = (ValuedEnumType)aType;

                                m_emitter.Append(String.format("type(%s, X) :- member(X,[", ptype.toString()));

                                boolean nocomma = true;

                                for (final Identifier val: venum.symbolTable().symbolList())

                                {

                                        final EnumIdentifier id = (EnumIdentifier)val;

                                        assert(id.HaveValue());

                                        if (nocomma)

                                                nocomma = false;

                                        else

                                                m_emitter.Append(", ");

                                        m_emitter.Append(id.Value());

                                }

                                m_emitter.AppendLine("]).");

                        }

                        else

                        {

                                final EnumType enumtype = (EnumType)aType;

                                m_emitter.AppendLine(String.format("type( %s, X) :- X in 0..%s, labeling([],[X]).", ptype.toString(), enumtype.listOfEnumSymbols().size() - 1));

                        }

                        break;

                case IntType:

                        aType.Accept(ptype);

                        final IntType inttype = (IntType)aType;

                        m_emitter.AppendLine(String.format("type( %s, X) :- X in %s..%s, labeling([],[X]).", ptype.toString().replace("-", ""), inttype.rangeLow(), inttype.rangeHigh()));

                        break;

                case FloatType:

                        throw new NotImplementedException();

                case Any:

                        break;

                case ListType:

                        final ListType listType = (ListType)aType;

                        aType.Accept(ptype);

                        m_emitter.Append(String.format("type( %s, ", ptype.toString()));

                        m_emitter.Append("[");

                        Boolean first = true;

                        final OoaPrologType pType = new OoaPrologType(idFactory, scratchbook);

                        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 MapType:

                        throw new NotImplementedException();

                case FunctionType:

                case OpaqueType:

                case Null:

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

                case TupleType:

                        final TupleType tupleType = (TupleType)aType;

                        aType.Accept(ptype);

                        m_emitter.Append(String.format("type( %s, ", ptype.toString()));

                        m_emitter.Append("[");

                        first = true;

                        for (final UlyssesType type: tupleType.innerTypes())

                        {

                                final OoaPrologType iType = new OoaPrologType(idFactory, scratchbook);

                                type.Accept(iType);

                                if (!first)

                                {

                                        m_emitter.Append(", ");

                                }

                                first = false;

                                m_emitter.Append(iType.toString());

                        }

                        m_emitter.AppendLine("]).");

                        break;

                case QrType:

                        aType.Accept(ptype);

                        final QrType qrtype = (QrType)aType;

                        final StringBuilder landmarks = new StringBuilder();

                        int cntr = 0;

                        for (final LandmarkIdentifier s: qrtype.landmarks())

                        {

                                if (cntr != 0)

                                        landmarks.append(", ");

                                else

                                        cntr++;

                                final OoaPrologIdentifier identifierVisitor = idFactory.create();

                                s.Accept(identifierVisitor);

                                landmarks.append(identifierVisitor.toString());

                        }

                        m_emitter.AppendLine(String.format("qspace( %s, [%s] ).", ptype.toString(), landmarks.toString()));

                        break;

                default:

                        throw new NotImplementedException();

                }

                scratchbook.typeDefinitions().append(m_emitter.toString());

        }

        private final OoasCodeEmitter m_emitter = new OoasCodeEmitter();

        private final OoaPrologIdentifier.Factory m_idFactory;

        public /*override*/ @Override

        void visit(CharType charType)

        {

                m_emitter.Append("char");

        }

        public /*override*/ @Override

        void visit(IntType intType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                intType.identifier().Accept(id);

                EmitType(intType, m_idFactory, m_scratchbook);

                m_emitter.Append(id.toString());

        }

        public /*override*/ @Override

        void visit(BoolType boolType)

        {

                m_emitter.Append("bool");

        }

        public /*override*/ @Override

        void visit(FloatType floatType)

        {

                throw new NotImplementedException();

        }

        public /*override*/ @Override

        void visit(EnumType enumType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                enumType.identifier().Accept(id);

                EmitType(enumType, m_idFactory, m_scratchbook);

                m_emitter.Append(id.toString());

        }

        public /*override*/ @Override

        void visit(ListType listType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                listType.identifier().Accept(id);

                EmitType(listType, m_idFactory, m_scratchbook);

                m_emitter.Append(id.toString());

        }

        public /*override*/ @Override

        void visit(MapType mapType)

        {

                throw new NotImplementedException();

        }

        public /*override*/ @Override

        void visit(QrType qrType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                qrType.identifier().Accept(id);

                m_emitter.Append(id.toString());

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

        }

        public /*override*/ @Override

        void visit(TupleType tupleType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                tupleType.identifier().Accept(id);

                EmitType(tupleType, m_idFactory, m_scratchbook);

                m_emitter.Append(id.toString());

        }

        public /*override*/ @Override

        void visit(FunctionType functionType)

        {

                throw new NotImplementedException();

        }

        public /*override*/ @Override

        void visit(OoActionSystemType ooActionSystemType)

        {

                final OoaPrologIdentifier id = m_idFactory.create();

                ooActionSystemType.identifier().Accept(id);

                m_emitter.Append(id.toString());

        }

        public /*override*/ @Override

        void visit(OpaqueType opaqueType)

        {

                throw new NotImplementedException();

        }

        @Override

        public /*override*/ String toString()

        {

                return m_emitter.toString();

        }

        public String GetInternalTypeDefinitions()

        {

                final OoasCodeEmitter result = new OoasCodeEmitter();

                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, Scratchbook scratchbook)

        {

                m_idFactory = idFactory;

                m_scratchbook = scratchbook;

        }

}