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

import java.util.ArrayList;

import java.util.Iterator;

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

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.statements.Assignment;

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

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

import org.momut.ooas.codegen.prolog.OoaPrologExpression;

import org.momut.ooas.codegen.prolog.OoaPrologIdentifier;

import org.momut.ooas.codegen.prolog.OoaPrologStatement;

import org.momut.ooas.codegen.prolog.OoaPrologType;

import org.momut.ooas.codegen.prolog.Scratchbook;

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

public class OoaPrologSymbolicStatement extends OoaPrologStatement

{

        public static class Factory extends OoaPrologStatement.Factory

        {

                @Override

                public /*override*/ OoaPrologStatement create(

                                OoaPrologExpression.Factory exprFactory,

                                OoaPrologIdentifier.Factory idFactory,

                                OoaPrologType.Factory typeFactory,

                                Scratchbook scratchbook)

                {

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

                }

        }

        @Override

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

        {

                if (assignment.nondetExpression() != null)

                        throw new NotImplementedException();

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

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

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

                while (aPlaceIt.hasNext())

                {

                        final Expression aPlace = aPlaceIt.next();

                        final Expression aValue = aValueIt.next();

                        final OoaPrologExpression prologPlace = createExpressionVisitor(true);

                        aPlace.Accept(prologPlace);

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

                        final 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

                                        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 (final String s: assignments)

                {

                        if (pos != 0)

                                m_emitter.Append(",");

                        pos++;

                        m_emitter.Append(s);

                }

        }

        @Override

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

        {

                int y = 0;

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

                {

                        m_emitter.Append(" [");

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

                        {

                                if (y != 0)

                                        m_emitter.AppendLine(", ");

                                else

                                        y++;

                                final OoaPrologType atype = createTypeVisitor();

                                sym.type().Accept(atype);

                                final OoaPrologIdentifier anIdent = createIdentifierVisitor();

                                sym.Accept(anIdent);

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

                        }

                        m_emitter.Append("]: ( ");

                }

                y = 0;

                for (final 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(")");

        }

        protected OoaPrologSymbolicStatement(

                        OoaPrologExpression.Factory exprFactory,

                        OoaPrologIdentifier.Factory idFactory,

                        OoaPrologType.Factory typeFactory,

                        Scratchbook scratchbook)

        {

                super (exprFactory, idFactory, typeFactory, scratchbook);

        }

}