| /******************************************************************************* |
| * Copyright (c) 2004-2008 Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath and Daniel Varro |
| * All rights reserved. This program and the accompanying materials |
| * are made available under theterms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.viatra2.gtasm.interpreter.term.rules; |
| |
| |
| import org.eclipse.viatra2.core.IEntity; |
| import org.eclipse.viatra2.core.IModelElement; |
| import org.eclipse.viatra2.core.IRelation; |
| import org.eclipse.viatra2.gtasm.interpreter.exception.ViatraTransformationException; |
| import org.eclipse.viatra2.gtasm.interpreter.executionEnvironment.IExecutionEnvironment; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.enums.ValueKind; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.ModelElementQuery; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.Term; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.ArithmeticOperation; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.ConversionOperation; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.RelationalOperation; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.modelmanagement.queryFunctions.Multiplicity; |
| |
| /** |
| * This class is used to evaluate terms in the GTASM machine. |
| * |
| * @author Peter Pasztor, Akos Horvath |
| * |
| */ |
| |
| public class TermEvaluator { |
| private static TermEvaluator _instance = new TermEvaluator(); |
| |
| TermEvaluator() {} |
| |
| public static TermEvaluator getInstance() { |
| return _instance; |
| } |
| |
| /** |
| * Evaluates the given term |
| * |
| * @param org.eclipse.viatra2.gtasm.interpreter.executionEnvironment |
| * The execution environment on which the term has to be |
| * evaluated |
| * @param termToBeEvaluated |
| * The term to be evaluated |
| * @return The result of the term evaluation |
| * @throws ViatraTransformationException |
| */ |
| public Object evaluate(IExecutionEnvironment executionEnvironment, |
| Term termToBeEvaluated) throws ViatraTransformationException { |
| if (termToBeEvaluated instanceof ArithmeticOperation) { |
| // call the ArithmeticOperationEvaluator... |
| return (ArithmeticOperationEvaluator.getInstance().evaluate( |
| executionEnvironment, |
| termToBeEvaluated)); |
| } else if (termToBeEvaluated instanceof ConversionOperation) { |
| return ConversionOperationEvaluator.getInstance().evaluate( |
| executionEnvironment, termToBeEvaluated); |
| } else if (termToBeEvaluated instanceof RelationalOperation) { |
| return RelationalOperationEvaluator.getInstance().evaluate( |
| executionEnvironment, termToBeEvaluated); |
| } else if (termToBeEvaluated instanceof ModelElementQuery) { |
| return ModelElementQueryEvaluator.getInstance().evaluate( |
| executionEnvironment, termToBeEvaluated); |
| } else if (null == termToBeEvaluated) { |
| // TODO: this is a hack. The parser returns null instead |
| // ValueKind.UNDEF_LITERAL when finding an undef constant. |
| return ValueKind.UNDEF_LITERAL; |
| } else { |
| return BasicTermEvaluator.getInstance().evaluate( |
| executionEnvironment, termToBeEvaluated); |
| } |
| |
| } |
| |
| // /** |
| // * This method tries to convert a String to an arithmetic value. |
| // * |
| // * At first it tries to convert is to Integer, then it tries to convert it |
| // * to Double. If it fails, throws a TermEvaluatorException. |
| // * |
| // * @return Integer or Double according to the String itself. |
| // * @throws GTASMException |
| // */ |
| // public Object convertStringToArithmeticValue(String str) |
| // throws ViatraTransformationException { |
| // try { |
| // return new Integer(str); |
| // } catch (NumberFormatException e) { |
| // try { |
| // return new Double(str); |
| // } catch (NumberFormatException e1) { |
| // throw new TermInterpreterException("String \"" + str |
| // + "\" is not a valid arithmetic value!", null); |
| // } |
| // } |
| // } |
| |
| /** Returns true if the input Object o is a Native Java type, else false |
| * @param o The input object to be checked. |
| * @return |
| */ |
| public Boolean isASMNativeType(Object o) { |
| if (o instanceof String || o instanceof Integer || o instanceof Double |
| || o instanceof Boolean || o instanceof Multiplicity |
| || ValueKind.UNDEF_LITERAL.equals(o) |
| || o instanceof IModelElement) |
| return Boolean.TRUE; |
| |
| return Boolean.FALSE; |
| } |
| |
| |
| /**Returns the type of the input parameter in a serialized form |
| * @param obj The object whose type is returned |
| * @return The java type in serialized form. |
| */ |
| protected String convertToJavaType(Object obj){ |
| |
| if(obj == null) |
| return "null"; |
| |
| if(obj instanceof String) |
| return "String"; |
| if(obj instanceof Integer) |
| return "Integer"; |
| if(obj instanceof Double) |
| return "Double"; |
| if(obj instanceof Boolean) |
| return "Boolean"; |
| if(obj instanceof Multiplicity) |
| return "Multiplicity"; |
| if(ValueKind.UNDEF_LITERAL.equals(obj)) |
| return "UNDEF"; |
| if(obj instanceof IRelation) |
| return "Relation (ModelElement)"; |
| if(obj instanceof IEntity) |
| return "Entity (ModelElement)"; |
| if(obj instanceof JavaNativeValue) |
| return "JavaNativeValue"; |
| |
| return "unknown type"; |
| } |
| |
| /** Converts the input type to its corresponding Java type String |
| * @param type The type to be converted |
| * @return The java equivalent type |
| * @throws ViatraCompiledCompileTimeException |
| */ |
| public String convertValueKindtoJavaType(ValueKind type){ |
| |
| if(type == null) |
| return "null"; |
| |
| if(type.equals(ValueKind.BOOLEAN_LITERAL)) |
| return "Boolean"; |
| if(type.equals(ValueKind.DOUBLE_LITERAL)) |
| return "Double"; |
| if(type.equals(ValueKind.INTEGER_LITERAL)) |
| return "Integer"; |
| if(type.equals(ValueKind.MODELELEMENT_LITERAL)) |
| return "EObject"; |
| if(type.equals(ValueKind.MULTIPLICITY_LITERAL)) |
| return "[Multiplicity]"; |
| if(type.equals(ValueKind.STRING_LITERAL)) |
| return "String"; |
| // it is a ModelElement!! |
| if(type.equals(ValueKind.UNDEF_LITERAL)) |
| return "Object"; |
| |
| return "error: unknown type"; |
| } |
| } |