| /******************************************************************************* |
| * Copyright (c) 2013, 2018 CEA LIST and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * E.D.Willink(CEA LIST) - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ocl.examples.codegen.analyzer; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGBoxExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGCallExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGCatchExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGCollectionExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGCollectionPart; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGEcoreExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGGuardExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGIterationCallExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGOperationCallExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGOppositePropertyCallExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGPropertyCallExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGString; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGThrowExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGTypeId; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGUnboxExp; |
| import org.eclipse.ocl.examples.codegen.cgmodel.CGValuedElement; |
| import org.eclipse.ocl.pivot.BagType; |
| import org.eclipse.ocl.pivot.CollectionLiteralExp; |
| import org.eclipse.ocl.pivot.CollectionRange; |
| import org.eclipse.ocl.pivot.CollectionType; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.ExpressionInOCL; |
| import org.eclipse.ocl.pivot.IntegerLiteralExp; |
| import org.eclipse.ocl.pivot.Iteration; |
| import org.eclipse.ocl.pivot.LiteralExp; |
| import org.eclipse.ocl.pivot.LoopExp; |
| import org.eclipse.ocl.pivot.Operation; |
| import org.eclipse.ocl.pivot.OperationCallExp; |
| import org.eclipse.ocl.pivot.OppositePropertyCallExp; |
| import org.eclipse.ocl.pivot.OrderedSetType; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.PropertyCallExp; |
| import org.eclipse.ocl.pivot.RealLiteralExp; |
| import org.eclipse.ocl.pivot.SequenceType; |
| import org.eclipse.ocl.pivot.SetType; |
| import org.eclipse.ocl.pivot.StringLiteralExp; |
| import org.eclipse.ocl.pivot.TupleLiteralExp; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.TypeExp; |
| import org.eclipse.ocl.pivot.UnlimitedNaturalLiteralExp; |
| import org.eclipse.ocl.pivot.VariableDeclaration; |
| import org.eclipse.ocl.pivot.VariableExp; |
| import org.eclipse.ocl.pivot.ids.ClassId; |
| import org.eclipse.ocl.pivot.ids.CollectionTypeId; |
| import org.eclipse.ocl.pivot.ids.DataTypeId; |
| import org.eclipse.ocl.pivot.ids.ElementId; |
| import org.eclipse.ocl.pivot.ids.EnumerationId; |
| import org.eclipse.ocl.pivot.ids.EnumerationLiteralId; |
| import org.eclipse.ocl.pivot.ids.IdVisitor; |
| import org.eclipse.ocl.pivot.ids.LambdaTypeId; |
| import org.eclipse.ocl.pivot.ids.MapTypeId; |
| import org.eclipse.ocl.pivot.ids.NestedPackageId; |
| import org.eclipse.ocl.pivot.ids.NestedTypeId; |
| import org.eclipse.ocl.pivot.ids.NsURIPackageId; |
| import org.eclipse.ocl.pivot.ids.OclInvalidTypeId; |
| import org.eclipse.ocl.pivot.ids.OclVoidTypeId; |
| import org.eclipse.ocl.pivot.ids.OperationId; |
| import org.eclipse.ocl.pivot.ids.PackageId; |
| import org.eclipse.ocl.pivot.ids.PrimitiveTypeId; |
| import org.eclipse.ocl.pivot.ids.PropertyId; |
| import org.eclipse.ocl.pivot.ids.RootPackageId; |
| import org.eclipse.ocl.pivot.ids.TemplateBinding; |
| import org.eclipse.ocl.pivot.ids.TemplateParameterId; |
| import org.eclipse.ocl.pivot.ids.TemplateableTypeId; |
| import org.eclipse.ocl.pivot.ids.TuplePartId; |
| import org.eclipse.ocl.pivot.ids.TupleTypeId; |
| import org.eclipse.ocl.pivot.ids.TypeId; |
| import org.eclipse.ocl.pivot.ids.UnspecifiedId; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.Nameable; |
| import org.eclipse.ocl.pivot.utilities.PivotConstants; |
| import org.eclipse.ocl.pivot.values.CollectionValue; |
| import org.eclipse.ocl.pivot.values.IntegerRange; |
| import org.eclipse.ocl.pivot.values.IntegerValue; |
| import org.eclipse.ocl.pivot.values.InvalidValue; |
| import org.eclipse.ocl.pivot.values.RealValue; |
| |
| /** |
| * A NameManager provides suggestions for names and maintains caches of used names so that model elements are consistently |
| * named without collisions. |
| */ |
| public class NameManager |
| { |
| public static final String BAG_NAME_HINT_PREFIX = "BAG"; |
| public static final String COLLECTION_NAME_HINT_PREFIX = "COL"; |
| public static final String DEFAULT_NAME_PREFIX = "symbol"; |
| // public static final String ID_NAME_HINT_PREFIX = "TID"; |
| public static final String EXPRESSION_IN_OCL_NAME_HINT_PREFIX = PivotConstants.RESULT_NAME; |
| public static final String INTEGER_NAME_HINT_PREFIX = "INT_"; |
| public static final String INVALID_NAME_HINT_PREFIX = "IVE_"; |
| public static final String ITERATION_NAME_HINT_PREFIX = ""; |
| public static final String OPERATION_NAME_HINT_PREFIX = "OP_"; |
| public static final String OPERATION_CALL_EXP_NAME_HINT_PREFIX = ""; //"RES_"; |
| public static final String ORDERED_SET_NAME_HINT_PREFIX = "ORD"; |
| public static final String PROPERTY_NAME_HINT_PREFIX = ""; |
| public static final String REAL_NAME_HINT_PREFIX = "REA_"; |
| public static final String RANGE_NAME_HINT_PREFIX = "RNG"; |
| public static final String SEQUENCE_NAME_HINT_PREFIX = "SEQ"; |
| public static final String SET_NAME_HINT_PREFIX = "SET"; |
| public static final String STRING_NAME_HINT_PREFIX = "STR_"; |
| public static final int STRING_NAME_HINT_LIMIT = 64; |
| public static final String TUPLE_NAME_HINT_PREFIX = "TUP_"; |
| public static final String TYPE_NAME_HINT_PREFIX = "TYP_"; |
| public static final String VARIABLE_DECLARATION_NAME_HINT_PREFIX = ""; |
| |
| /** |
| * Names that will not be allocated to temporary variables. |
| * <p> |
| * This Set is public and unsynchronized. Clients may change it in arbitrary ways at their own risk. |
| * <p> |
| * It is strongly recommended that clients do no more than add additional names. |
| */ |
| public static final Set<@NonNull String> reservedJavaNames = new HashSet<>(); |
| { |
| reservedJavaNames.add("Boolean"); |
| reservedJavaNames.add("Character"); |
| reservedJavaNames.add("Class"); |
| reservedJavaNames.add("Double"); |
| reservedJavaNames.add("Float"); |
| reservedJavaNames.add("Integer"); |
| reservedJavaNames.add("List"); |
| reservedJavaNames.add("Long"); |
| reservedJavaNames.add("Map"); |
| reservedJavaNames.add("Package"); |
| reservedJavaNames.add("String"); |
| |
| reservedJavaNames.add("boolean"); |
| reservedJavaNames.add("byte"); |
| reservedJavaNames.add("char"); |
| reservedJavaNames.add("double"); |
| reservedJavaNames.add("float"); |
| reservedJavaNames.add("int"); |
| reservedJavaNames.add("long"); |
| reservedJavaNames.add("short"); |
| reservedJavaNames.add("void"); |
| |
| reservedJavaNames.add("abstract"); // FIXME Exploit CodeGenUtil.getJavaReservedWords() |
| reservedJavaNames.add("assert"); |
| reservedJavaNames.add("break"); |
| reservedJavaNames.add("case"); |
| reservedJavaNames.add("catch"); |
| reservedJavaNames.add("class"); |
| reservedJavaNames.add("const"); |
| reservedJavaNames.add("continue"); |
| reservedJavaNames.add("default"); |
| reservedJavaNames.add("do"); |
| reservedJavaNames.add("else"); |
| reservedJavaNames.add("enum"); |
| reservedJavaNames.add("extends"); |
| reservedJavaNames.add("final"); |
| reservedJavaNames.add("finally"); |
| reservedJavaNames.add("for"); |
| reservedJavaNames.add("goto"); |
| reservedJavaNames.add("if"); |
| reservedJavaNames.add("implements"); |
| reservedJavaNames.add("import"); |
| reservedJavaNames.add("instanceof"); |
| reservedJavaNames.add("interface"); |
| reservedJavaNames.add("native"); |
| reservedJavaNames.add("new"); |
| reservedJavaNames.add("package"); |
| reservedJavaNames.add("private"); |
| reservedJavaNames.add("protected"); |
| reservedJavaNames.add("public"); |
| reservedJavaNames.add("return"); |
| reservedJavaNames.add("static"); |
| reservedJavaNames.add("strictfp"); |
| reservedJavaNames.add("switch"); |
| reservedJavaNames.add("synchronized"); |
| reservedJavaNames.add("throw"); |
| reservedJavaNames.add("throws"); |
| reservedJavaNames.add("transient"); |
| reservedJavaNames.add("try"); |
| reservedJavaNames.add("volatile"); |
| reservedJavaNames.add("while"); |
| |
| reservedJavaNames.add("false"); |
| reservedJavaNames.add("null"); |
| reservedJavaNames.add("super"); |
| reservedJavaNames.add("this"); |
| reservedJavaNames.add("true"); |
| } |
| |
| public static @NonNull IdVisitor<@NonNull String> idVisitor = new IdVisitor<@NonNull String>() |
| { |
| @Override |
| public @NonNull String visitClassId(@NonNull ClassId id) { |
| return "CLSSid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitCollectionTypeId(@NonNull CollectionTypeId id) { |
| CollectionTypeId generalizedId = id.getGeneralizedId(); |
| String idPrefix; |
| if (generalizedId == TypeId.BAG) { |
| idPrefix = "BAG_"; |
| } |
| else if (generalizedId == TypeId.ORDERED_SET) { |
| idPrefix = "ORD_"; |
| } |
| else if (generalizedId == TypeId.SEQUENCE) { |
| idPrefix = "SEQ_"; |
| } |
| else if (generalizedId == TypeId.SET) { |
| idPrefix = "SET_"; |
| } |
| else { |
| idPrefix = "COL_"; |
| } |
| if (generalizedId == id) { |
| return idPrefix; |
| } |
| else { |
| return idPrefix + id.getElementTypeId().accept(this); |
| } |
| } |
| |
| @Override |
| public @NonNull String visitDataTypeId(@NonNull DataTypeId id) { |
| return "DATAid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitEnumerationId(@NonNull EnumerationId id) { |
| return "ENUMid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitEnumerationLiteralId(@NonNull EnumerationLiteralId id) { |
| return "ELITid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitInvalidId(@NonNull OclInvalidTypeId id) { |
| return "INVid"; |
| } |
| |
| @Override |
| public @NonNull String visitLambdaTypeId(@NonNull LambdaTypeId id) { |
| return "LAMBid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitMapTypeId(@NonNull MapTypeId id) { |
| MapTypeId generalizedId = id.getGeneralizedId(); |
| String idPrefix = "MAP_"; |
| if (generalizedId == id) { |
| return idPrefix; |
| } |
| else { |
| return idPrefix + id.getKeyTypeId().accept(this) + id.getValueTypeId().accept(this); |
| } |
| } |
| |
| @Override |
| public @NonNull String visitNestedPackageId(@NonNull NestedPackageId id) { |
| return "PACKid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitNsURIPackageId(@NonNull NsURIPackageId id) { |
| return "PACKid_" + id.getNsURI(); |
| } |
| |
| @Override |
| public @NonNull String visitNullId(@NonNull OclVoidTypeId id) { |
| return "NULLid"; |
| } |
| |
| @Override |
| public @NonNull String visitOperationId(@NonNull OperationId id) { |
| return "OPid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitPrimitiveTypeId(@NonNull PrimitiveTypeId id) { |
| return "PRIMid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitPropertyId(@NonNull PropertyId id) { |
| return "PROPid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitRootPackageId(@NonNull RootPackageId id) { |
| return "PACKid_" + id.getName(); |
| } |
| |
| @Override |
| public @NonNull String visitTemplateBinding(@NonNull TemplateBinding id) { |
| return "BINDid_"; |
| } |
| |
| @Override |
| public @NonNull String visitTemplateParameterId(@NonNull TemplateParameterId id) { |
| return "TMPLid_"; |
| } |
| |
| @Override |
| public @NonNull String visitTemplateableTypeId(@NonNull TemplateableTypeId id) { |
| return "TYPEid_"; |
| } |
| |
| @Override |
| public @NonNull String visitTuplePartId(@NonNull TuplePartId id) { |
| return "PARTid_"; |
| } |
| |
| @Override |
| public @NonNull String visitTupleTypeId(@NonNull TupleTypeId id) { |
| return "TUPLid_"; |
| } |
| |
| @Override |
| public @NonNull String visitUnspecifiedId(@NonNull UnspecifiedId id) { |
| return "UNSPid_"; |
| } |
| }; |
| |
| protected static void appendJavaCharacters(StringBuilder s, String string) { |
| for (int i = 0; i < string.length(); i++) { |
| char c = string.charAt(i); |
| if (Character.isJavaIdentifierPart(c)) { |
| s.append(c); |
| } |
| else { |
| s.append('_'); |
| } |
| } |
| } |
| |
| protected static void appendJavaCharacters(StringBuilder s, String string, int iMax) { |
| for (int i = 0; i < Math.min(iMax, string.length()); i++) { |
| char c = string.charAt(i); |
| if (Character.isJavaIdentifierPart(c)) { |
| s.append(c); |
| } |
| else { |
| s.append('_'); |
| } |
| } |
| } |
| |
| /** |
| * Return a valid Java identifier based on nameHint. hasPrefix may be true to indicate that the |
| * caller will supply an additional valid prefix relieving this routine of the need to avoid |
| * leading numeric characters. |
| * <p> |
| * This is not intended to be a reversible algorithm; just to provide something reasonably readable. |
| */ |
| private static @NonNull String getValidJavaIdentifier(@NonNull String nameHint, boolean hasPrefix, @Nullable Object anObject) { |
| if (nameHint.equals("<")) { |
| return("lt"); |
| } |
| else if (nameHint.equals("<=")) { |
| return("le"); |
| } |
| else if (nameHint.equals("=")) { |
| return("eq"); |
| } |
| else if (nameHint.equals("<>")) { |
| return("ne"); |
| } |
| else if (nameHint.equals(">=")) { |
| return("ge"); |
| } |
| else if (nameHint.equals(">")) { |
| return("gt"); |
| } |
| else if (nameHint.equals("+")) { |
| return("sum"); |
| } |
| else if (nameHint.equals("-")) { |
| return((anObject instanceof Operation) && ((Operation)anObject).getOwnedParameters().size() <= 0 ? "neg" : "diff"); |
| } |
| else if (nameHint.equals("*")) { |
| return("prod"); |
| } |
| else if (nameHint.equals("/")) { |
| return("quot"); |
| } |
| else if (nameHint.equals("1_")) { |
| return("_1"); |
| } |
| else if (nameHint.equals("2_")) { |
| return("_2"); |
| } |
| StringBuilder s = new StringBuilder(); |
| Character prefix = null; |
| int length = nameHint.length(); |
| for (int i = 0; i < length; i++) { |
| char c = nameHint.charAt(i); |
| if (((i == 0) && !hasPrefix) ? Character.isJavaIdentifierStart(c) : Character.isJavaIdentifierPart(c)) { |
| if (prefix != null) { |
| s.append(prefix); |
| prefix = null; |
| } |
| s.append(c); |
| } |
| else { |
| if (c == '*') { |
| s.append("_a"); |
| } |
| else if (c == ':') { |
| s.append("_c"); |
| } |
| else if (c == '.') { |
| if (prefix != null) { |
| s.append(prefix); |
| prefix = null; |
| } |
| } |
| else if (c == ')') { |
| s.append("_e"); |
| } |
| else if (c == '>') { |
| s.append("_g"); |
| } |
| else if (c == '<') { |
| s.append("_l"); |
| } |
| else if (c == '-') { |
| s.append("_m"); |
| } |
| else if (c == '(') { |
| s.append("_o"); |
| } |
| else if (c == '+') { |
| s.append("_p"); |
| } |
| else if (c == '=') { |
| s.append("_q"); |
| } |
| else if (c == '/') { |
| s.append("_s"); |
| } |
| else { |
| s.append('_' + Integer.toString(c)); |
| } |
| prefix = '_'; |
| } |
| } |
| return s.toString(); |
| } |
| |
| public class Context { |
| private final @Nullable Context context; // Pushed context |
| private final @NonNull Map<String, Object> name2object; // User of each name, null if name ambiguous |
| private final @NonNull Map<Object, String> object2name; // Unambiguous name for each object, null if not determined |
| private Map<String, Integer> name2counter; // Auto-generation counter for each colliding name |
| // private boolean frozen = false; // Set true once pushed |
| |
| public Context() { |
| this.context = null; |
| this.name2object = new HashMap<String, Object>(); |
| this.object2name = new HashMap<Object, String>(); |
| this.name2counter = null; |
| } |
| |
| public Context(@NonNull Context context) { |
| this.context = context; |
| this.name2object = new HashMap<String, Object>(context.name2object); |
| this.object2name = new HashMap<Object, String>(context.object2name); |
| this.name2counter = context.name2counter != null ? new HashMap<String, Integer>(context.name2counter) : null; |
| // context.frozen = true; |
| } |
| |
| public @NonNull Context createNestedContext() { |
| return new Context(this); |
| } |
| |
| public @NonNull Context getContext() { |
| return ClassUtil.nonNullState(context); |
| } |
| |
| protected @NonNull String getGlobalUniqueName(@Nullable Object anObject, @Nullable String... nameHints) { |
| if (context != null) { |
| return context.getGlobalUniqueName(anObject, nameHints); |
| } |
| else { |
| return getUniqueName(anObject, nameHints); |
| } |
| } |
| |
| public @NonNull String getSymbolName(@Nullable Object anObject, @Nullable String... nameHints) { |
| if ((nameHints != null) && (nameHints.length > 0) && (nameHints[0] != null)) { |
| return getUniqueName(anObject, nameHints); |
| } |
| else { |
| return getUniqueName(anObject, anObject != null ? getNameHint(anObject) : null); |
| } |
| } |
| |
| /** |
| * Return a unique name using some nameHints to suggest preferred names and allocate that name to anObject. |
| * <p> |
| * If anObject is non-null, any already allocated name is returned rather than allocating another name. |
| * <p> |
| * If anObject is null, the returned name is allocated to no object; not to the null value. |
| * <p> |
| * If nameHints is null a default name is generated. |
| * <p> |
| */ |
| public @NonNull String getUniqueName(@Nullable Object anObject, @Nullable String... nameHints) { |
| if ((anObject instanceof RealValue) && !(anObject instanceof InvalidValue)) { |
| anObject = ((RealValue)anObject).asNumber(); |
| } |
| if (anObject != null) { |
| String knownName = object2name.get(anObject); |
| if (knownName != null) { |
| return knownName; |
| } |
| } |
| String lastResort = null; |
| if (nameHints != null) { |
| for (String nameHint : nameHints) { |
| if (nameHint != null) { |
| String validHint = getValidJavaIdentifier(nameHint, false, anObject); |
| if (!reservedJavaNames.contains(validHint) || ((anObject instanceof CGValuedElement) && isNative((CGValuedElement)anObject))) { |
| if (anObject != null) { |
| Object oldElement = name2object.get(validHint); |
| if (oldElement == anObject) { |
| return validHint; |
| } |
| if ((oldElement == null) && !name2object.containsKey(validHint)) { |
| install(validHint, anObject); |
| return validHint; |
| } |
| else { |
| nameHint.toString(); |
| } |
| } |
| else { |
| if (!name2object.containsKey(validHint)) { |
| install(validHint, anObject); |
| return validHint; |
| } |
| } |
| if (lastResort == null) { |
| lastResort = validHint; |
| } |
| } |
| } |
| } |
| } |
| if (lastResort == null) { |
| lastResort = DEFAULT_NAME_PREFIX; |
| } |
| if (name2counter == null) { |
| name2counter = new HashMap<String, Integer>(); |
| } |
| Integer counter = name2counter.get(lastResort); |
| int count = counter != null ? counter : 0; |
| for ( ; true; count++) { |
| String attempt = lastResort + "_" + Integer.toString(count); |
| if (!name2object.containsKey(attempt)) { // Assumes that reserved names do not end in _ count |
| install(attempt, anObject); |
| name2counter.put(lastResort, ++count); |
| return attempt; |
| } |
| } |
| |
| } |
| |
| private void install(@NonNull String name, @Nullable Object anObject) { |
| //FIXME assert !frozen; |
| assert !(anObject instanceof RealValue) || (anObject instanceof InvalidValue); |
| name2object.put(name, anObject); |
| if (anObject != null) { |
| object2name.put(anObject, name); |
| } |
| } |
| |
| private boolean isNative(@NonNull CGValuedElement cgElement) { |
| TypeId asTypeId = cgElement.getASTypeId(); |
| if (asTypeId instanceof NestedTypeId) { |
| PackageId packageId = ((NestedTypeId)asTypeId).getParent(); |
| if ((packageId instanceof RootPackageId) && ((RootPackageId)packageId).getName().contains("://")) { // e.g. java:// |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Reserve name for use by anObject. If anObject is null, the reservation is for an unspecified object not for the null value. |
| * |
| public @NonNull String reserveName(@NonNull String name, @Nullable Object anObject) { |
| assert !frozen; |
| assert !(anObject instanceof RealValue); |
| String validJavaIdentifier = getUniqueName(anObject, getValidJavaIdentifier(name, true, anObject)); |
| Object oldElement = name2object.put(validJavaIdentifier, anObject); // FIXME redundant |
| assert (oldElement == null) || (oldElement == anObject); |
| return validJavaIdentifier; |
| } */ |
| |
| @Override |
| public @NonNull String toString() { |
| StringBuilder s = new StringBuilder(); |
| List<String> names = new ArrayList<>(name2object.keySet()); |
| Collections.sort(names); |
| for (String name : names) { |
| if (s.length() > 0) { |
| s.append("\n"); |
| } |
| s.append(name); |
| s.append(" = "); |
| s.append(name2object.get(name)); |
| } |
| return s.toString(); |
| } |
| } |
| |
| private @NonNull Context context = new Context(); |
| |
| public NameManager() {} |
| |
| public @NonNull Context createNestedContext() { |
| return new Context(context); |
| } |
| |
| public @NonNull String getExplicitName(@Nullable Object anObject) { |
| if (anObject == null) { |
| return "null"; |
| } |
| else if (anObject instanceof Boolean) { |
| return ((Boolean)anObject).booleanValue() ? "true" : "false"; |
| } |
| else { |
| return "<null-" + anObject.getClass().getSimpleName() + ">"; |
| } |
| } |
| |
| public @NonNull String getGlobalSymbolName(@Nullable Object anObject, @Nullable String... nameHints) { |
| if ((nameHints != null) && (nameHints.length > 0)) { |
| return getGlobalUniqueName(anObject, nameHints); |
| } |
| else { |
| return getGlobalUniqueName(anObject, anObject != null ? getNameHint(anObject) : null); |
| } |
| } |
| protected @NonNull String getGlobalUniqueName(@Nullable Object anObject, @Nullable String... nameHints) { |
| return context.getGlobalUniqueName(anObject, nameHints); |
| } |
| |
| protected String getIterationNameHint(@NonNull Iteration anIteration) { |
| @SuppressWarnings("null") @NonNull String string = anIteration.getName(); |
| return ITERATION_NAME_HINT_PREFIX + getValidJavaIdentifier(string, ITERATION_NAME_HINT_PREFIX.length() > 0, anIteration); |
| } |
| |
| protected String getKindHint(@NonNull String kind) { |
| if (TypeId.BAG_NAME.equals(kind)) { |
| return BAG_NAME_HINT_PREFIX; |
| } |
| else if (TypeId.ORDERED_SET_NAME.equals(kind)) { |
| return ORDERED_SET_NAME_HINT_PREFIX; |
| } |
| else if (TypeId.SEQUENCE_NAME.equals(kind)) { |
| return SEQUENCE_NAME_HINT_PREFIX; |
| } |
| else if (TypeId.SET_NAME.equals(kind)) { |
| return SET_NAME_HINT_PREFIX; |
| } |
| else { |
| return COLLECTION_NAME_HINT_PREFIX; |
| } |
| } |
| |
| /** |
| * Return a suggestion for the name of anObject. |
| * <p> |
| * The returned name is not guaranteed to be unique. Uniqueness is enforced when the hint is passed to getSymbolName(). |
| */ |
| public @Nullable String getNameHint(@NonNull Object anObject) { |
| if (anObject instanceof CGValuedElement) { |
| anObject = ((CGValuedElement)anObject).getNamedValue(); |
| } |
| if (anObject instanceof CollectionLiteralExp) { |
| Type type = ((CollectionLiteralExp)anObject).getType(); |
| return type != null ? getTypeNameHint(type) : null; |
| } |
| else if (anObject instanceof CollectionRange) { |
| return RANGE_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof CGCollectionPart) { |
| return RANGE_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof InvalidValue) { |
| return INVALID_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof CollectionValue) { |
| String kind = ((CollectionValue)anObject).getKind(); |
| return kind != null ? getKindHint(kind) : null; |
| } |
| else if (anObject instanceof CGCollectionExp) { |
| String kind = ((CGCollectionExp)anObject).getName(); |
| return kind != null ? getKindHint(kind) : null; |
| } |
| else if (anObject instanceof ElementId) { |
| String nameHint = ((ElementId)anObject).accept(idVisitor); |
| return nameHint; |
| } |
| else if (anObject instanceof ExpressionInOCL) { |
| return EXPRESSION_IN_OCL_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof IntegerLiteralExp) { |
| Number numberSymbol = ((IntegerLiteralExp)anObject).getIntegerSymbol(); |
| return numberSymbol != null ? getNumericNameHint(numberSymbol) : null; |
| } |
| else if (anObject instanceof IntegerRange) { |
| return RANGE_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof IntegerValue) { |
| Number numberSymbol = ((IntegerValue)anObject).asNumber(); |
| return getNumericNameHint(numberSymbol); |
| } |
| else if (anObject instanceof LoopExp) { |
| Iteration referredIteration = ((LoopExp)anObject).getReferredIteration(); |
| return referredIteration != null ? getIterationNameHint(referredIteration) : null; |
| } |
| else if (anObject instanceof Number) { |
| return getNumericNameHint((Number)anObject); |
| } |
| else if (anObject instanceof Operation) { |
| return getOperationNameHint((Operation)anObject); |
| } |
| else if (anObject instanceof OperationCallExp) { |
| Operation referredOperation = ((OperationCallExp)anObject).getReferredOperation(); |
| return referredOperation != null ? getOperationCallExpNameHint(referredOperation) : null; |
| } |
| else if (anObject instanceof OppositePropertyCallExp) { |
| Property referredOppositeProperty = ((OppositePropertyCallExp)anObject).getReferredProperty(); |
| Property referredProperty = referredOppositeProperty != null ? referredOppositeProperty.getOpposite() : null; |
| return referredProperty != null ? getPropertyNameHint(referredProperty) : null; |
| } |
| else if (anObject instanceof PropertyCallExp) { |
| Property referredProperty = ((PropertyCallExp)anObject).getReferredProperty(); |
| return referredProperty != null ? getPropertyNameHint(referredProperty) : null; |
| } |
| else if (anObject instanceof TupleLiteralExp) { |
| return TUPLE_NAME_HINT_PREFIX; |
| } |
| else if (anObject instanceof CGCallExp) { |
| if (anObject instanceof CGOppositePropertyCallExp) { |
| Property referredOppositeProperty = ((OppositePropertyCallExp)((CGOppositePropertyCallExp)anObject).getAst()).getReferredProperty(); |
| Property referredProperty = referredOppositeProperty != null ? referredOppositeProperty.getOpposite() : null; |
| return referredProperty != null ? getPropertyNameHint(referredProperty) : null; |
| } |
| else if (anObject instanceof CGPropertyCallExp) { |
| Property referredProperty = ((PropertyCallExp)((CGPropertyCallExp)anObject).getAst()).getReferredProperty(); |
| return referredProperty != null ? getPropertyNameHint(referredProperty) : null; |
| } |
| else if (anObject instanceof CGIterationCallExp) { |
| Iteration referredIteration = ((LoopExp)((CGIterationCallExp)anObject).getAst()).getReferredIteration(); |
| return referredIteration != null ? getIterationNameHint(referredIteration) : null; |
| } |
| else if (anObject instanceof CGOperationCallExp) { |
| Operation referredOperation = ((OperationCallExp)((CGOperationCallExp)anObject).getAst()).getReferredOperation(); |
| return referredOperation != null ? getOperationCallExpNameHint(referredOperation) : null; |
| } |
| else if (anObject instanceof CGBoxExp) { |
| return "BOXED_" + ((CGBoxExp)anObject).getSourceValue().getValueName(); |
| } |
| else if (anObject instanceof CGEcoreExp) { |
| return "ECORE_" + ((CGEcoreExp)anObject).getSourceValue().getValueName(); |
| } |
| else if (anObject instanceof CGUnboxExp) { |
| return "UNBOXED_" + ((CGUnboxExp)anObject).getSourceValue().getValueName(); |
| } |
| else if (anObject instanceof CGCatchExp) { |
| return "CAUGHT_" + ((CGCatchExp)anObject).getSourceValue().getValueName(); |
| } |
| else if (anObject instanceof CGGuardExp) { |
| return "GUARDED_" + ((CGGuardExp)anObject).getSourceValue().getValueName(); |
| } |
| else if (anObject instanceof CGThrowExp) { |
| return "THROWN_" + ((CGThrowExp)anObject).getSourceValue().getValueName(); |
| } |
| else { |
| return null; |
| } |
| } |
| else if (anObject instanceof RealLiteralExp) { |
| Number numberSymbol = ((RealLiteralExp)anObject).getRealSymbol(); |
| return numberSymbol != null ? getNumericNameHint(numberSymbol) : null; |
| } |
| else if (anObject instanceof RealValue) { |
| Number numberSymbol = ((RealValue)anObject).asNumber(); |
| return getNumericNameHint(numberSymbol); |
| } |
| else if (anObject instanceof String) { |
| return getStringNameHint((String)anObject); |
| } |
| else if (anObject instanceof CGString) { |
| String stringValue = ((CGString)anObject).getStringValue(); |
| return stringValue != null ? getStringNameHint(stringValue) : null; |
| } |
| else if (anObject instanceof StringLiteralExp) { |
| String stringSymbol = ((StringLiteralExp)anObject).getStringSymbol(); |
| return stringSymbol != null ? getStringNameHint(stringSymbol) : null; |
| } |
| else if (anObject instanceof Type) { |
| return getTypeNameHint((Type)anObject); |
| } |
| else if (anObject instanceof CGTypeId) { |
| Element type = ((CGTypeId)anObject).getAst(); |
| return (type instanceof Type) ? getTypeNameHint((Type) type) : null; |
| } |
| else if (anObject instanceof TypeExp) { |
| Type referredType = ((TypeExp)anObject).getType(); |
| return referredType != null ? getTypeNameHint(referredType) : null; |
| } |
| // else if (anObject instanceof TypeValue) { |
| // DomainType referredType = ((TypeValue)anObject).getInstanceType(); |
| // return getTypeNameHint(referredType); |
| // } |
| else if (anObject instanceof UnlimitedNaturalLiteralExp) { |
| Number numberSymbol = ((UnlimitedNaturalLiteralExp)anObject).getUnlimitedNaturalSymbol(); |
| return numberSymbol != null ? getNumericNameHint(numberSymbol) : null; |
| } |
| else if (anObject instanceof VariableExp) { |
| VariableDeclaration referredVariable = ((VariableExp)anObject).getReferredVariable(); |
| return referredVariable != null ? getVariableDeclarationNameHint(referredVariable) : null; |
| } |
| else if (anObject instanceof LiteralExp) { |
| return "literal"; |
| } |
| else if (anObject instanceof Nameable) { |
| String name = ((Nameable)anObject).getName(); |
| return name != null ? getValidJavaIdentifier(name, false, anObject) : null; |
| } |
| else { |
| return null; |
| } |
| } |
| |
| protected String getNumericNameHint(@NonNull Number aNumber) { |
| @SuppressWarnings("null") @NonNull String string = aNumber.toString(); |
| if ((aNumber instanceof BigInteger) || (aNumber instanceof Long) || (aNumber instanceof Integer) || (aNumber instanceof Short)) { |
| return INTEGER_NAME_HINT_PREFIX + string; |
| } |
| else if ((aNumber instanceof BigDecimal) || (aNumber instanceof Double) || (aNumber instanceof Float)) { |
| return REAL_NAME_HINT_PREFIX + getValidJavaIdentifier(string, REAL_NAME_HINT_PREFIX.length() > 0, aNumber); |
| } |
| else { |
| return null; |
| } |
| } |
| |
| protected String getOperationNameHint(@NonNull Operation anOperation) { |
| @SuppressWarnings("null") @NonNull String string = anOperation.toString(); |
| return OPERATION_NAME_HINT_PREFIX + getValidJavaIdentifier(string, OPERATION_NAME_HINT_PREFIX.length() > 0, anOperation); |
| } |
| |
| protected String getOperationCallExpNameHint(@NonNull Operation anOperation) { |
| @SuppressWarnings("null") @NonNull String string = anOperation.getName(); |
| return OPERATION_CALL_EXP_NAME_HINT_PREFIX + getValidJavaIdentifier(string, OPERATION_CALL_EXP_NAME_HINT_PREFIX.length() > 0, anOperation); |
| } |
| |
| protected String getPropertyNameHint(@NonNull Property aProperty) { |
| @SuppressWarnings("null") @NonNull String string = aProperty.getName(); |
| return PROPERTY_NAME_HINT_PREFIX + getValidJavaIdentifier(string, PROPERTY_NAME_HINT_PREFIX.length() > 0, aProperty); |
| } |
| |
| protected String getStringNameHint(@NonNull String aString) { |
| @NonNull String string = aString.length() > STRING_NAME_HINT_LIMIT ? aString.substring(0, STRING_NAME_HINT_LIMIT) : aString; |
| return STRING_NAME_HINT_PREFIX + getValidJavaIdentifier(string, STRING_NAME_HINT_PREFIX.length() > 0, aString); |
| } |
| |
| protected String getTypeNameHint(@NonNull Type aType) { |
| if (aType instanceof CollectionType) { |
| if (aType instanceof OrderedSetType) { |
| return ORDERED_SET_NAME_HINT_PREFIX; |
| } |
| else if (aType instanceof SetType) { |
| return SET_NAME_HINT_PREFIX; |
| } |
| else if (aType instanceof SequenceType) { |
| return SEQUENCE_NAME_HINT_PREFIX; |
| } |
| else if (aType instanceof BagType) { |
| return BAG_NAME_HINT_PREFIX; |
| } |
| else { |
| return COLLECTION_NAME_HINT_PREFIX; |
| } |
| } |
| @SuppressWarnings("null") @NonNull String string = aType.toString(); |
| return TYPE_NAME_HINT_PREFIX + getValidJavaIdentifier(string, TYPE_NAME_HINT_PREFIX.length() > 0, aType); |
| } |
| |
| protected String getVariableDeclarationNameHint(@NonNull VariableDeclaration aVariableDeclaration) { |
| String string = ClassUtil.nonNullModel(aVariableDeclaration.getName()); |
| return VARIABLE_DECLARATION_NAME_HINT_PREFIX + getValidJavaIdentifier(string, VARIABLE_DECLARATION_NAME_HINT_PREFIX.length() > 0, aVariableDeclaration); |
| } |
| |
| /** |
| * Reserve name for use by anObject. If anObject is null, the reservation is for an unspecified object not for the null value. |
| */ |
| public @NonNull String reserveName(@NonNull String name, @Nullable Object anObject) { |
| return context.getSymbolName(anObject, name); |
| } |
| } |
