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

import java.util.ArrayList;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.momut.ooas.ast.expressions.QValConstructor.QValDeriv;

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

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

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

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

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

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

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

import org.momut.ooas.codegen.OoasCodeEmitter;

import org.momut.ooas.utils.UnsignedHelper;

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

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

import org.momut.ooas.visitors.OoaExpressionVisitor;

public final class JavaExpression extends OoaExpressionVisitor

{

        private final OoasCodeEmitter m_emitter = new OoasCodeEmitter();

        private final Scratchbook m_data;

        private final StringBuilder m_helpers;

        private String GetIdentifierString(String anIdentifier)

        {

                return JavaIdentifier.GetIdentifierString(anIdentifier);

        }

        public ArrayList<ObjectConstructor> constructors() { return m_data.m_constructors; }

        // following calls must not happen

        @Override

        public void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression)

        {

                throw new OoasCompilerRuntimeException();

        }

        @Override

        public void visit(CallExpression callExpression)

        {

                throw new OoasCompilerRuntimeException();

//                System.Diagnostics.Debug.Assert(false);

        }

        // we need to map all other things to Java constructs

        private String OperatorString(Expression expression)

        {

                switch (expression.kind())

                {

                case abs:    // T_ABS:

                case card:   // T_CARD:

                case dom:    // T_DOM:

                case range:  // T_RNG:

                case merge:  // T_MERGE:

                case len:    // T_LEN:

                case elems:  // T_ELEMS:

                case head:   // T_HEAD:

                case tail:   // T_TAIL:

                case conc:   // T_CONC:

                case inds:   // T_INDS:

                case dinter: // T_DINTER:

                case dunion: // T_DUNION:

                case domresby:   // T_DOMRESBY:

                case domresto:   // T_DOMRESTO:

                case rngresby:   // T_RNGRESBY:

                case rngresto:   // T_RNGRESTO:

                case inter:  // T_INTER:

                case union:  // T_UNION:

                case diff:   // T_DIFF:

                case munion: // T_MUNION:

                case seqmod_mapoverride: // T_SEQMOD_MAPOVERRIDE:

                case subset:

                case elemin:

                case notelemin:

                case implies:    // T_IMPLIES:

                case biimplies:  // T_BIIMPLIES:

                case Primed:

                        throw new NotImplementedException();

                case div:    // T_DIV:

                        return "/";

                case idiv:   // T_IDIV:

                        return "/";

                case mod:    // T_MOD:

                        return "%";

                case prod:   // T_PROD:

                        return "*";

                case sum:    // T_SUM:

                        return "+";

                case minus:  // T_MINUS:

                        return "-";

                case less:

                        return "<";

                case lessequal:

                        return "<=";

                case greater:

                        return ">";

                case greaterequal:

                        return ">=";

                case equal:

                        return "==";

                case notequal:

                        return "!=";

                case and:    // T_AND:

                        return "&&";

                case or:     // T_OR:

                        return "||";

                case not:

                        return "!";

                case Cast:

                        final JavaType ctype = new JavaType();

                        expression.type().Accept(ctype);

                        return String.format("(%s)", ctype.toString());

                default:

                        return expression.kind().name(); //Enum.GetName(typeof(ExpressionKind), expression.kind);

                }

        }

        @Override

        public <T> void visit(ValueExpression<T> valueExpression)

        {

                if (valueExpression.value() == null)

                        m_emitter.Append("null");

                else if (valueExpression.m_clazz.equals(Boolean.class))

                        m_emitter.Append(valueExpression.value().toString().toLowerCase());

                else

                        m_emitter.Append(valueExpression.value().toString());

        }

        @Override

        public void visit(IdentifierExpression identifierExpression)

        {

                if (identifierExpression.identifier().kind() == IdentifierKind.LandmarkIdentifier)

                {

                        final LandmarkIdentifier lmid = (LandmarkIdentifier)identifierExpression.identifier();

                        final QrType qr = (QrType)lmid.type();

                        m_emitter.Append(qr.landmarks().indexOf(lmid));

                        return;

                }

                if (identifierExpression.identifier().kind() == IdentifierKind.EnumIdentifier)

                {

                        m_emitter.Append(GetIdentifierString(((EnumIdentifier)identifierExpression.identifier()).type().identifier().tokenText()));

                        m_emitter.Append(".");

                }

                m_emitter.Append(GetIdentifierString(identifierExpression.identifier().tokenText()));

        }

        @Override

        public void visit(TypeExpression typeExpression)

        {

                if (typeExpression.type().kind() != TypeKind.QrType &&

                                typeExpression.type().kind() != TypeKind.EnumeratedType)

                        m_emitter.Append(GetIdentifierString(typeExpression.type().identifier().tokenText()));

        }

        @Override

        public void visit(ObjectConstructor objectConstructor)

        {

                final int num = m_data.m_constructors.size();

                m_data.m_constructors.add(objectConstructor);

                if (objectConstructor.givenObjectName() != null)

                        m_emitter.Append(String.format("new %s(this,%s,\"%s\")",

                                        GetIdentifierString(objectConstructor.type().identifier().tokenText()),

                                        num,

                                        objectConstructor.givenObjectName()));

                else

                        m_emitter.Append(String.format("new %s(this,%s)",

                                        GetIdentifierString(objectConstructor.type().identifier().tokenText()),

                                        num));

        }

        @Override

        public void visit(ListConstructor listConstructor)

        {

                if (listConstructor.hasComprehension())

                {

                        final String helpername = String.format("list_constr_helper_%s", UnsignedHelper.toString(listConstructor.hashCode()));

                        m_emitter.Append(String.format("%s(new org.momut.ooas.codegen.java.runtime.CustomList<Object>())",

                                        helpername));

                        final OoasCodeEmitter helperEmitter = new OoasCodeEmitter();

                        helperEmitter.AppendLine(String.format(

                                        "public org.momut.ooas.codegen.java.runtime.CustomList<Object> %s (org.momut.ooas.codegen.java.runtime.CustomList<Object> newList){",

                                        helpername));

                        for (final Identifier sym: listConstructor.comprehensionVariables().symbolList())

                        {

                                final JavaType atype = new JavaType();

                                sym.type().Accept(atype);

                                if (sym.type().IsNumeric())

                                        helperEmitter.AppendLine(String.format("for (%s %s = %s; %s <= %s; %s++) {",

                                                        atype.toString(),

                                                        JavaIdentifier.GetIdentifierString(sym.tokenText()),

                                                        UlyssesType.Low(sym.type()),

                                                        JavaIdentifier.GetIdentifierString(sym.tokenText()),

                                                        UlyssesType.High(sym.type()),

                                                        JavaIdentifier.GetIdentifierString(sym.tokenText())));

                                else

                                        throw new NotImplementedException();

                        }

                        final StringBuilder helperhelper = new StringBuilder();

                        String guardexpr = "true";

                        if (listConstructor.comprehension() != null)

                        {

                                final JavaExpression expr = new JavaExpression(helperhelper, m_data);

                                listConstructor.comprehension().Accept(expr);

                                guardexpr = expr.toString();

                        }

                        final JavaExpression expr2 = new JavaExpression(helperhelper, m_data);

                        listConstructor.elements().get(0).Accept(expr2);

                        helperEmitter.AppendLine(String.format("if (%s) {", guardexpr));

                        helperEmitter.AppendLine(String.format("newList.Add(%s);", expr2.toString()));

                        helperEmitter.AppendLine("}");

                        final int count = listConstructor.comprehensionVariables().symbolList().size();

                        for (int i = 0; i< count; i++)

                                helperEmitter.AppendLine("}");

                        helperEmitter.AppendLineIncIndent("return newList;");

                        helperEmitter.AppendLine("}");

                        m_helpers.append(helperEmitter.toString());

                        m_helpers.append(helperhelper.toString());

                }

                else

                {

                        m_emitter.Append("new org.momut.ooas.codegen.java.runtime.CustomList<Object>(");

                        int i = 0;

                        if (listConstructor.elements().size() > 0)

                        {

                                m_emitter.Append("new Object[] { ");

                                for (final Expression x: listConstructor.elements())

                                {

                                        if (i != 0)

                                                m_emitter.Append(",");

                                        else

                                                i++;

                                        x.Accept(this);

                                }

                                m_emitter.Append(" }");

                        }

                        m_emitter.Append(")");

                }

        }

        @Override

        public void visit(SetConstructor setConstructor)

        {

                throw new NotImplementedException();

        }

        @Override

        public void visit(MapConstructor mapConstructor)

        {

                throw new NotImplementedException();

        }

        @Override

        public void visit(TupleConstructor tupleConstructor)

        {

                m_emitter.Append(String.format("new %s(", GetIdentifierString(tupleConstructor.tupleType().tokenText())));

                int i = 0;

                for (final Expression arg: tupleConstructor.values())

                {

                        if (i != 0)

                                m_emitter.Append(",");

                        else

                                i++;

                        arg.Accept(this);

                }

                m_emitter.Append(")");

        }

        @Override

        public void visit(QValConstructor qValConstructor)

        {

                final StringBuilder helpers = new StringBuilder();

                String landmarkOne = "null";

                if (qValConstructor.value().length >= 1 && qValConstructor.value()[0] != null)

                {

                        final JavaExpression lndmrk1 = new JavaExpression(helpers, m_data);

                        qValConstructor.value()[0].Accept(lndmrk1);

                        landmarkOne = lndmrk1.toString();

                }

                String landmarkTwo = "null";

                if (qValConstructor.value().length >= 2 && qValConstructor.value()[1] != null)

                {

                        final JavaExpression lndmrk = new JavaExpression(helpers, m_data);

                        qValConstructor.value()[1].Accept(lndmrk);

                        landmarkTwo = lndmrk.toString();

                }

                String derivation = "null";

                if (qValConstructor.valueDeriv() != QValDeriv.DonTCare)

                {

                        derivation = Integer.toString(qValConstructor.valueDeriv().ordinal());

                        //derivation = Enum.Format(typeof(QValDeriv), qValConstructor.valueDeriv, "d");

                }

                m_helpers.append(helpers.toString());

                m_emitter.Append(String.format("new QualitativeValue(%s,%s,%s)", landmarkOne, landmarkTwo, derivation));

        }

        @Override

        public void visit(AccessExpression accessExpression)

        {

                if (accessExpression.left().type().kind() != TypeKind.QrType &&

                                accessExpression.left().type().kind() != TypeKind.EnumeratedType)

                {

                        // enums and qr types are directly (statically) converted to nums...

                        VisitSub(accessExpression.left(), accessExpression);

                        m_emitter.Append(".");

                }

                VisitSub(accessExpression.right(), accessExpression);

        }

        @Override

        public void visit(BinaryOperator binaryOperator)

        {

                m_emitter.Append("(");

                VisitSub(binaryOperator.left(), binaryOperator);

                m_emitter.Append(") ");

                m_emitter.Append(OperatorString(binaryOperator));

                m_emitter.Append(" (");

                VisitSub(binaryOperator.right(), binaryOperator);

                m_emitter.Append(")");

        }

        @Override

        public void visit(TernaryOperator ternaryOperator)

        {

                m_emitter.Append("(");

                VisitSub(ternaryOperator.left(), ternaryOperator);

                m_emitter.Append(" ? ");

                VisitSub(ternaryOperator.mid(), ternaryOperator);

                m_emitter.Append(" : ");

                VisitSub(ternaryOperator.right(), ternaryOperator);

                m_emitter.Append(")");

        }

        @Override

        public void visit(TupleMapAccessExpression tupleMapAccessExpression)

        {

                throw new NotImplementedException();

        }

        @Override

        public void visit(ForallQuantifier quantifier)

        {

                throw new NotImplementedException();

        }

        @Override

        public void visit(ExistsQuantifier quantifier)

        {

                throw new NotImplementedException();

        }

        @Override

        public void visit(UnaryOperator unaryOperator)

        {

                m_emitter.Append(" ");

                m_emitter.Append(OperatorString(unaryOperator));

                m_emitter.Append("(");

                VisitSub(unaryOperator.child(), unaryOperator);

                m_emitter.Append(")");

        }

        @Override

        public String toString()

        {

                return m_emitter.toString();

        }

        public JavaExpression(StringBuilder helpers, Scratchbook data)

        {

                super ();

                m_helpers = helpers;

                m_data = data;

        }

}