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 java.util.ArrayList;

import java.util.Iterator;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.momut.ooas.codegen.OoasCodeEmitter;

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

import org.momut.ooas.visitors.OoaStatementVisitor;

public class OoaPrologStatement extends OoaStatementVisitor

{

        public static class Factory

        {

                public OoaPrologStatement create(

                                OoaPrologExpression.Factory exprFactory,

                                OoaPrologIdentifier.Factory idFactory,

                                OoaPrologType.Factory typeFactory,

                                Scratchbook scratchbook)

                {

                        return new OoaPrologStatement(exprFactory, idFactory, typeFactory, scratchbook);

                }

        }

        protected final Scratchbook m_scratchbook;

        protected OoasCodeEmitter m_emitter = new OoasCodeEmitter();

        @Override

        public /*override*/ void visit(NondetBlock nondetBlock)

        {

                int y = 0;

                for (Statement x: nondetBlock.statements())

                {

                        if (y != 0)

                                m_emitter.Append("; ");

                        else

                                y++;

                        m_emitter.Append("(");

                        VisitSub(x, nondetBlock);

                        m_emitter.Append(")");

                }

        }

        @Override

        public /*override*/ void visit(SeqBlock seqBlock)

        {

                int y = 0;

                if (seqBlock.symbols().symbolList().size() > 0)

                {

                        m_emitter.Append("([");

                        for (Identifier sym: seqBlock.symbols().symbolList())

                        {

                                if (y != 0)

                                        m_emitter.AppendLine(", ");

                                else

                                        y++;

                                OoaPrologType atype = createTypeVisitor();

                                sym.type().Accept(atype);

                                OoaPrologIdentifier anIdent = createIdentifierVisitor();

                                sym.Accept(anIdent);

                                m_emitter.Append(String.format("%s:%s", anIdent.toString(), atype.toString()));

                        }

                        m_emitter.Append("]: ");

                }

                y = 0;

                for (Statement x: seqBlock.statements())

                {

                        if (y != 0)

                                m_emitter.AppendLine(", ");

                        else

                                y++;

                        m_emitter.Append("(");

                        VisitSub(x, seqBlock);

                        m_emitter.Append(")");

                }

                if (seqBlock.symbols().symbolList().size() > 0)

                        m_emitter.Append(")");

        }

        @Override

        public /*override*/ void visit(PrioBlock prioBlock)

        {

                int y = 0;

                for (Statement x: prioBlock.statements())

                {

                        if (y != 0)

                                m_emitter.Append("// ");

                        else

                                y++;

                        m_emitter.Append("(");

                        VisitSub(x, prioBlock);

                        m_emitter.Append(")");

                }

        }

        @Override

        public /*override*/ void visit(GuardedCommand guardedCommand)

        {

                OoaPrologExpression expr = createExpressionVisitor();

                guardedCommand.guard().Accept(expr);

                m_emitter.AppendLineIncIndent(String.format("(%s%s) %s ",

                                expr.toString(),

                                expr.tmpVariables().get(0),

                                guardedCommand.isQualitative() ? "~>" : "=>"));

                m_emitter.AppendLineIncIndent("(");

                VisitSub(guardedCommand.body(), guardedCommand);

                m_emitter.DecIndent();

                m_emitter.AppendLine("");

                m_emitter.Append(")");

        }

        @Override

        public /*override*/ void visit(Assignment assignment)

        {

                if (assignment.nondetExpression() != null)

                        throw new NotImplementedException();

                Iterator<Expression> aPlaceIt = assignment.places().iterator();

                Iterator<Expression> aValueIt = assignment.values().iterator();

                ArrayList<String> assignments = new ArrayList<String>();

                while (aPlaceIt.hasNext())

                {

                        final Expression aPlace = aPlaceIt.next();

                        final Expression aValue = aValueIt.next();

                        OoaPrologExpression prologPlace = createExpressionVisitor(true);

                        aPlace.Accept(prologPlace);

                        assert(prologPlace.tmpVariables().size() == 1);

                        OoaPrologExpression prologValue = createExpressionVisitor();

                        aValue.Accept(prologValue);

                        assert(prologValue.tmpVariables().size() == 1);

                        m_emitter.Append(prologValue.toString());

                        if (aPlace.kind() == ExpressionKind.Access &&

                                        ((AccessExpression)aPlace).right().kind() == ExpressionKind.Identifier &&

                                        ((IdentifierExpression)((AccessExpression)aPlace).right()).identifier().kind() == IdentifierKind.AttributeIdentifier)

                        {

                                //access to attribute is always 'self.XY'...

                                assignments.add(String.format("%s := %s", prologPlace.tmpVariables().get(0), prologValue.tmpVariables().get(0)));

                        }

                        else

                                if (prologPlace.tmpVariables().get(0).equals("RESULT"))

                                        assignments.add(String.format("unify( RESULT = %s)", prologValue.tmpVariables().get(0)));

                                else if (aPlace.type().kind() == TypeKind.IntType)

                                        assignments.add(String.format("%s #= %s", prologPlace.tmpVariables().get(0), prologValue.tmpVariables().get(0)));

                                else

                                        assignments.add(String.format("%s = %s", prologPlace.tmpVariables().get(0), prologValue.tmpVariables().get(0)));

                        if (prologPlace.toString().length() > 0)

                        {

                                String place = prologPlace.toString();

                                place = place.trim();

                                if (place.endsWith(","))

                                        place = place.substring(0, place.length() - 1);

                                assignments.add(place);

                        }

                }

                int pos = 0;

                for (String s: assignments)

                {

                        if (pos != 0)

                                m_emitter.Append(",");

                        pos++;

                        m_emitter.Append(s);

                }

        }

        @Override

        public /*override*/ void visit(Call call)

        {

                Expression ce = call.callExpression();

                String callstatement = "";

                StringBuilder parameter = new StringBuilder();

                boolean hideCall = false;

                if (ce.kind() == ExpressionKind.Identifier)

                        callstatement = ((IdentifierExpression)ce).identifier().tokenText();

                else if (ce.kind() == ExpressionKind.Call)

                {

                        CallExpression parens = (CallExpression)ce;

                        OoaPrologExpression prologexpr = createExpressionVisitor();

                        parens.child().Accept(prologexpr);

                        if (parens.child().kind() == ExpressionKind.Identifier &&

                                        ((IdentifierExpression)parens.child()).identifier().kind() == IdentifierKind.NamedActionIdentifier)

                        {

                                // we need to hide internal actions

                                NamedActionIdentifier namedactionid = (NamedActionIdentifier)((IdentifierExpression)parens.child()).identifier();

                                hideCall = ((FunctionType)namedactionid.type()).functionType() == FunctionTypeEnum.Internal;

                        }

                        m_emitter.Append(prologexpr.toString());

                        callstatement = prologexpr.tmpVariables().get(0);

                        int i = 0;

                        for (Expression arg: parens.arguments())

                        {

                                if (i != 0)

                                        parameter.append(", ");

                                else

                                        i++;

                                OoaPrologExpression paramexpr = createExpressionVisitor();

                                arg.Accept(paramexpr);

                                m_emitter.Append(paramexpr.toString());

                                parameter.append(paramexpr.tmpVariables().get(0));

                        }

                }

                else

                        throw new NotImplementedException();

                if (hideCall)

                        m_emitter.Append("i(");

                if (parameter.length() > 0)

                        m_emitter.AppendLine(String.format("%s(%s)", callstatement, parameter));

                else

                        m_emitter.AppendLine(String.format("%s", callstatement, parameter));

                if (hideCall)

                        m_emitter.Append(")");

        }

        @Override

        public /*override*/ void visit(SkipStatement skipStatement)

        {

                m_emitter.Append("skip");

        }

        @Override

        public /*override*/ void visit(AbortStatement abortStatement)

        {

                throw new NotImplementedException();

        }

        @Override

        public /*override*/ void visit(KillStatement killStatement)

        {

                throw new NotImplementedException();

        }

        @Override

        public /*override*/ void visit(QualitativeConstraintStatement qalitativeConstraintStatement)

        {

                if (qalitativeConstraintStatement.tag)

                {

                        m_emitter.Append("% observable assignment in actionhead");

                        return;

                }

                OoaPrologIdentifier id1 = createIdentifierVisitor();

                OoaPrologIdentifier id2 = createIdentifierVisitor();

                OoaPrologIdentifier id3 = createIdentifierVisitor();

                switch (qalitativeConstraintStatement.operation())

                {

                case Deriv:

                        qalitativeConstraintStatement.variable0().Accept(id1);

                        qalitativeConstraintStatement.variable1().Accept(id2);

                        m_emitter.Append(String.format("%s := dt %s", id1.toString(), id2.toString()));

                        break;

                case Diff:

                        qalitativeConstraintStatement.variable0().Accept(id1);

                        qalitativeConstraintStatement.variable1().Accept(id2);

                        qalitativeConstraintStatement.variable2().Accept(id3);

                        m_emitter.Append(String.format("%s := %s - %s", id1.toString(), id2.toString(), id3.toString()));

                        break;

                case Equal:

                        qalitativeConstraintStatement.variable0().Accept(id1);

                        qalitativeConstraintStatement.variable1().Accept(id2);

                        m_emitter.Append(String.format("%s := %s", id1.toString(), id2.toString()));

                        break;

                case Prod:

                        qalitativeConstraintStatement.variable0().Accept(id1);

                        qalitativeConstraintStatement.variable1().Accept(id2);

                        qalitativeConstraintStatement.variable2().Accept(id3);

                        m_emitter.Append(String.format("%s := %s * %s", id1.toString(), id2.toString(), id3.toString()));

                        break;

                case Sum:

                        qalitativeConstraintStatement.variable0().Accept(id1);

                        qalitativeConstraintStatement.variable1().Accept(id2);

                        qalitativeConstraintStatement.variable2().Accept(id3);

                        m_emitter.Append(String.format("%s := %s + %s", id1.toString(), id2.toString(), id3.toString()));

                        break;

                default:

                        throw new NotImplementedException();

                }

        }

        @Override

        public /*override*/ String toString()

        {

                return m_emitter.toString();

        }

        protected OoaPrologExpression createExpressionVisitor() { return m_exprFactory.create(m_idFactory, m_typeFactory, m_scratchbook); }

        protected OoaPrologExpression createExpressionVisitor(boolean lhs) { return m_exprFactory.create(m_idFactory, m_typeFactory, m_scratchbook, lhs); }

        protected OoaPrologIdentifier createIdentifierVisitor() { return m_idFactory.create(); }

        protected OoaPrologType createTypeVisitor() { return m_typeFactory.create(m_idFactory, m_scratchbook); }

        private final OoaPrologExpression.Factory m_exprFactory;

        private final OoaPrologIdentifier.Factory m_idFactory;

        private final OoaPrologType.Factory m_typeFactory;

        protected OoaPrologStatement(

                        OoaPrologExpression.Factory exprFactory,

                        OoaPrologIdentifier.Factory idFactory,

                        OoaPrologType.Factory typeFactory,

                        Scratchbook scratchbook)

        {

                super();

                m_exprFactory = exprFactory;

                m_idFactory = idFactory;

                m_typeFactory = typeFactory;

                m_scratchbook = scratchbook;

        }

}