Changeset 14002


Ignore:
Timestamp:
Nov 8, 2019 2:48:29 PM (6 days ago)
Author:
jwedin
Message:

Merging dev-jw-2590 to trunk. #5865

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/Compiler/GenericCodeGen/src/jastadd/ExternalCEvalTag.jrag

    r11541 r14002  
    5050    }
    5151   
    52     /* Used when unit testing. Temp names will accumulate over all tests */
    53     private static final Map<String,String> unitTempMap = new HashMap<String,String>();
    54    
    5552    public  void generate(CodeStream str) {
    5653        if (ext == null) {
     
    5855            for (FExternalStmt ext : fClass.myExternals()) {
    5956                if (!ext.isConstructorStmt() && !ext.isDestructorStmt()) {
    60                     generate_wrap(str, ext, unitCgc, unitTempMap);
     57                    generate_wrap(str, ext, unitCgc, fClass.root().getUtilInterface().unitTempMap);
    6158                }
    6259            }
  • trunk/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r13980 r14002  
    530530     * @param count  it node counts should also be generated
    531531     */
    532     protected void dumpMemoryUseFile(ASTNode root, String type, boolean count) throws FileNotFoundException {
    533         dumpMemoryUseFile(root, type, type, count);
     532    protected void dumpMemoryUseFile(ASTNode root, UtilInterface util, String type, boolean count) throws FileNotFoundException {
     533        dumpMemoryUseFile(root, util, type, type, count);
    534534    }
    535535
     
    544544     * @param count  it node counts should also be generated
    545545     */
    546     protected void dumpMemoryUseFile(ASTNode root, String type, String name, boolean count)
     546    protected void dumpMemoryUseFile(ASTNode root, UtilInterface util, String type, String name, boolean count)
    547547            throws FileNotFoundException {
    548548        if (dumpMemoryUse) {
     
    553553            time = Math.round((System.currentTimeMillis() - time) / 1000.0);
    554554            if (count)
    555                 root.buildNodeCount();
     555                root.buildNodeCount(util.getBuildNodeCountMap());
    556556            log.debug(" Dumped tree in " + time + "s");
    557557        }
     
    560560    /**
    561561     * Save a dump of the node class counts of an AST (or several).
    562      *
     562     * This only seems to work when using an older jdk version.
     563     * We have verified that it works with jdk 8 but it doesn't seem to work properly with jdk 11.
    563564     * The dump will be saved in a file named <code>"node_count.txt"</code>.
    564565     */
    565     protected void dumpNodeCountFile()
     566    protected void dumpNodeCountFile(Root root)
    566567            throws IOException {
    567568        if (dumpMemoryUse) {
    568569            String file = "node_count.txt";
    569570            log.debug("Dumping node counts to '" + file + "'...");
    570             ASTNode.dumpNodeCount(file);
     571            root.dumpNodeCount(file, root.getUtilInterface());
    571572        }
    572573    }
     
    10861087        // build source tree
    10871088        SourceRoot sr = parseModelFromPaths(paths);
    1088         dumpMemoryUseFile(sr, "source", false);
     1089        dumpMemoryUseFile(sr, sr.getUtilInterface(), "source", false);
    10891090
    10901091        if (options.getBooleanOption("generate_html_diagnostics")) {
     
    10951096        InstClassDecl icl = instantiateModel(sr, cl, target);
    10961097       
    1097         dumpMemoryUseFile(sr, "source and instance", "instance", true);
     1098        dumpMemoryUseFile(sr, sr.getUtilInterface(), "source and instance", "instance", true);
    10981099       
    10991100        return icl;
     
    12221223        log.info("Flattening model...");
    12231224        icd.flattenInstClassDecl(fc);
    1224         dumpMemoryUseFile(fc, "flat", true);
    1225         dumpNodeCountFile();
     1225        dumpMemoryUseFile(fc, fc.root().getUtilInterface(), "flat", true);
     1226        dumpNodeCountFile(icd.root());
    12261227        icd = null;
    12271228        ASTNode.endStep("flatten()");
     
    12841285        ASTNode.endStep("prettyPrintFlat()");
    12851286       
    1286         dumpMemoryUseFile(fc, "transformed", false);
     1287        dumpMemoryUseFile(fc, fc.root().getUtilInterface(), "transformed", false);
    12871288       
    12881289        if (options.getBooleanOption("write_iteration_variables_to_file")) {
     
    20622063            if (target.getCodeGenFlag()) {
    20632064                generateCode(fc, target);
    2064                 dumpMemoryUseFile(fc, "generated", false);
     2065                dumpMemoryUseFile(fc, util, "generated", false);
    20652066            }
    20662067           
     
    24972498   
    24982499    private static ArrayList<TemplateContributor> CONTRIBUTORS;
    2499     private static LinkedHashSet<String> XML_TEMPLATES;
    2500     private static LinkedHashSet<String> C_HEADER_TEMPLATES;
    2501     private static LinkedHashSet<String> C_SOURCE_TEMPLATES;   
     2500    private LinkedHashSet<String> XML_TEMPLATES;
     2501    private LinkedHashSet<String> C_HEADER_TEMPLATES;
     2502    private LinkedHashSet<String> C_SOURCE_TEMPLATES;   
    25022503   
    25032504    public abstract static class TemplateContributor {
     
    26052606   
    26062607    private static ArrayList<ModuleContributor> CONTRIBUTORS = new ArrayList<>();
    2607     private static HashMap<Module, String> libraryNames = new HashMap<>();
     2608    private HashMap<Module, String> libraryNames = new HashMap<>();
    26082609   
    26092610    public abstract static class ModuleContributor {
  • trunk/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag

    r13732 r14002  
     1
    12aspect UtilInterface {
    23   
     
    5859            public void tearDown() {}
    5960        }
    60        
     61
    6162        private static LinkedList<Registrant> registrants = new LinkedList<>();
    6263        private static Registrant addRegistrant(Registrant registrant) {
     
    174175        }
    175176    }
     177
     178    /* Used when unit testing. */
     179    public final Map<String, String> UtilInterface.unitTempMap = new HashMap<>();
    176180}
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatAnnotations.jrag

    r13294 r14002  
    2828    public class FlatAnnotation extends GenericAnnotationNode<FlatAnnotation, FlatAnnotationProvider, FExp> {
    2929
    30         public static final FlatAnnotation AMBIGUOUS_ANNOTATION =  new FlatAnnotation(null, null, null);
    31 
     30        public static final FlatAnnotation AMBIGUOUS_ANNOTATION =  new FlatAnnotation();
     31
     32        /** Creates an unambiguous flat annotation.
     33         * See {@link GenericAnnotationNode#GenericAnnotationNode(String, AnnotationProvider, GenericAnnotationNode)}
     34         */
    3235        protected FlatAnnotation(String name, FlatAnnotationProvider node, FlatAnnotation parent) {
    3336            super(name, node, parent);
     37        }
     38
     39        /** Creates an ambiguous flat annotation.
     40         * See {@link GenericAnnotationNode#GenericAnnotationNode()}
     41         */
     42        protected FlatAnnotation() {
     43            super();
    3444        }
    3545
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/util/SrcAnnotations.jrag

    r13294 r14002  
    106106    public class SrcAnnotationNode extends GenericAnnotationNode<SrcAnnotationNode, SrcAnnotationProvider, SrcExp> {
    107107       
    108         public static final SrcAnnotationNode AMBIGUOUS_ANNOTATION =  new SrcAnnotationNode(null, null, null,
    109                 SrcAnnotationNode.defaultEvaluator());
     108        public static final SrcAnnotationNode AMBIGUOUS_ANNOTATION =  new SrcAnnotationNode();
    110109       
    111110        private Evaluator<SrcExp> evaluator;
    112        
    113         protected SrcAnnotationNode(String name, SrcAnnotationProvider node, SrcAnnotationNode parent,
    114                 Evaluator<SrcExp> evaluator) {
     111
     112        /** Creates an ambiguous source annotation.
     113         * See {@link GenericAnnotationNode#GenericAnnotationNode()}
     114         */
     115        protected SrcAnnotationNode() {
     116            super();
     117            this.evaluator = SrcAnnotationNode.defaultEvaluator();
     118        }
     119
     120        /** Creates a unambiguous source annotation.
     121         * See {@link GenericAnnotationNode#GenericAnnotationNode(String, AnnotationProvider, GenericAnnotationNode)}
     122         */
     123        protected SrcAnnotationNode(String name, SrcAnnotationProvider node, SrcAnnotationNode parent, Evaluator<SrcExp> evaluator) {
    115124            super(name, node, parent);
    116125            this.evaluator = evaluator;
  • trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/annotations/GenericAnnotationNode.java

    r13009 r14002  
    2525import java.util.Map;
    2626
     27import org.jmodelica.common.URIResolver;
    2728import org.jmodelica.common.URIResolver.URIException;
    2829import org.jmodelica.util.Criteria;
    29 import org.jmodelica.util.annotations.AnnotationProvider.SubAnnotationPair;
    3030import org.jmodelica.util.collections.FilteredIterable;
    3131import org.jmodelica.util.values.ConstValue;
     
    5555     */
    5656    public static final String VENDOR_NAME = "__Modelon";
    57 
    58     private String name;
    59     private N node;
    60     private final T parent;
    61 
    62     private volatile Collection<T> subNodes_cache;
    63     private volatile Map<String, T> subNodesNameMap_cache;
    64     private volatile boolean nodeWasSet = false;
    65     private volatile boolean subNodeNodeWasSet = false;
    66     private volatile T valueAnnotation_cache;
    67     private volatile boolean valueAnnotation_cacheComputed = false;
    68 
    69     /**
    70      * Constructor. <code>name</code> may be null, some nodes simply do not have a name.
     57    private final AnnotationStateManager state;
     58
     59    /**
     60     * Constructor to create an ambiguous annotation node.<br>
     61     * An ambiguous node created with this constructor is immutable.
     62     * That is, calling a state changing method on an unambiguous will not have any effect.
     63     * No state change will occur nor will any exception be thrown.
     64     */
     65    protected GenericAnnotationNode() {
     66        state = new AmbiguousAnnotationStateManager();
     67    }
     68
     69    /**
     70     * Constructor to create an unambiguous annotation node.<br>
     71     * <code>name</code> may be null, some nodes simply do not have a name.<br>
    7172     * <code>node</code> may only be null for the instances returned by
    7273     * {@link #ambiguousNode()} and nodes which don't exist yet.
    73      * 
     74     *
    7475     * @param name Name of the node, optionally null.
    7576     * @param node The node that this annotation node represent.
     77     * @param parent The parent of the node
     78     * @param ambiguous The ambiguity of the node.
    7679     */
    7780    protected GenericAnnotationNode(String name, N node, T parent) {
    78         this.parent = parent;
    79         setNode(name, node);
    80     }
    81 
    82    
    83     /**
     81        state = new MutableAnnotationStateManager(name, node, parent);
     82    }
     83
     84    /**
    8485     * This is an internal method, do not call it.
    8586     */
    8687    private void computeSubNodesCache() {
    87         if (isSubNodesCacheFresh()) {
    88             return;
    89         }
    90         if (subNodes_cache == null) {
    91             subNodes_cache = Collections.emptyList();
    92         }
    93         if (subNodesNameMap_cache == null) {
    94             subNodesNameMap_cache = Collections.emptyMap();
    95         }
    96 
    97         if(!nodeExists() || isAmbiguous()) {
    98             return;
    99         }
    100 
    101         List<T> subNodes = new ArrayList<T>();
    102         Map<String, List<T>> oldNodesMap = constructMapIncludingAmbiguous(subNodes_cache);
    103         Map<String, T> subNodesNameMap = new HashMap<String, T>();
    104         for (SubAnnotationPair<N> subNodePair : node.annotationSubNodes()) {
    105             String subNodeName = subNodePair.getAnnotationName();
    106             N subNodeNode = subNodePair.getAnnotationValue();
    107             T subNode = null;
    108            
    109             List<T> oldNodes = oldNodesMap.get(subNodeName);
    110             if (oldNodes != null) {
    111                 subNode = oldNodes.remove(0);
    112                 if (oldNodes.isEmpty()) {
    113                     oldNodesMap.remove(subNodeName);
    114                 }
    115             }
    116             createOrSetSubNodeAndAddToCaches(subNode, subNodeName, subNodeNode, subNodes, subNodesNameMap);
    117         }
    118 
    119         for(List<T> oldNodes : oldNodesMap.values()) {
    120             for(T oldNode: oldNodes) {
    121                 //TODO move the setting of the node field in the subnode to null to an explicit step
    122                 createOrSetSubNodeAndAddToCaches(oldNode, oldNode.name(), null, subNodes, subNodesNameMap);
    123             }
    124         }
    125         subNodes_cache = subNodes;
    126         subNodesNameMap_cache = subNodesNameMap;
    127         clearNodeWasSetFlags();
    128     }
    129 
    130     private T createOrSetSubNodeAndAddToCaches(T subNode, String subNodeName, N subNodeNode, Collection<T> subNodes, Map<String, T> subNodesNameMap) {
    131         if (subNode == null) {
    132             subNode = createNode(subNodeName, subNodeNode);
    133         } else {
    134             asGeneric(subNode).setNode(subNodeName, subNodeNode);
    135         }
    136         if (subNode != null) {
    137             addToCaches(subNodes, subNodesNameMap, subNode);
    138         }
    139         return subNode;
    140     }
    141 
    142     private void addToCaches(Collection<T> subNodes, Map<String, T> subNodesNameMap, T subNode) {
    143         subNodes.add(subNode);
    144         updateSubNodesNameMapCache(subNodesNameMap, subNode);
    145     }
    146 
    147     private void updateSubNodesNameMapCache(Map<String, T> subNodesNameMap, T subNode) {
    148         T previous = subNodesNameMap.put(subNode.name(), subNode);
    149         if (previous != null && previous.hasNode() && subNode.hasNode()) { // subNode goes from not ambiguous to ambiguous
    150             subNodesNameMap.put(subNode.name(), ambiguousNode());
    151         }
    152     }
    153 
    154     private T removeFromSubNodesNameMapCache(T subNode, Collection<T> subNodes, Map<String, T> subNodesNameMap) {
    155         T previous = subNodesNameMap.get(subNode.name());
    156         if (previous != null) {
    157             if (previous == ambiguousNode()) {
    158                 Map<String, List<T>> oldNodesMap = constructMapIncludingAmbiguous(filterExists(subNodes));
    159                 List<T> oldNodes = oldNodesMap.get(subNode.name());
    160                 if(oldNodes.size() == 2) { // subNode goes from ambiguous to not ambiguous
    161                     oldNodes.remove(subNode);
    162                     subNodesNameMap.put(subNode.name(), oldNodes.get(0));
    163                 }
    164             } else {
    165                 subNodesNameMap.remove(subNode.name());
    166             }
    167         }
    168         return previous;
    169     }
    170 
    171     /**
    172      * Computes a map that maps between name and node, the list is needed since
    173      * there may be multiple nodes with the same name, if that is the case,
    174      * then they are put in the list in the order that they are found!
    175      */
    176     private Map<String, List<T>> constructMapIncludingAmbiguous(Iterable<T> nodes) {
    177         if (nodes == null) {
    178             return Collections.emptyMap();
    179         }
    180         Map<String, List<T>> res = new LinkedHashMap<String, List<T>>();
    181         for (T node : nodes) {
    182             String name = node.name();
    183             List<T> withSameName = res.get(name);
    184             if (withSameName == null) {
    185                 withSameName = new ArrayList<T>(Collections.singletonList(node));
    186                 res.put(name, withSameName);
    187             } else if (withSameName.size() == 1) {
    188                 withSameName = new ArrayList<T>(withSameName);
    189                 withSameName.add(node);
    190                 res.put(name, withSameName);
    191             } else {
    192                 withSameName.add(node);
    193             }
    194         }
    195         return res;
     88        state.computeSubNodesCache();
     89    }
     90
     91    protected boolean isSubNodesCacheFresh() {
     92        return state.isSubNodesCacheFresh();
     93    }
     94
     95    protected boolean hasSubNodesCache() {
     96        return state.hasSubNodesCache();
     97    }
     98    /**
     99     * Sets the name and node of this GenericAnnotationNode. This is an internal method,
     100     * call {{@link #updateNode(String, AnnotationProvider)} instead.
     101     * @param newName The new name
     102     * @param node The new node
     103     */
     104    private void setNode(String newName, N node) {
     105        state.setNode(newName, node);
     106    }
     107
     108    private void setSubNodeNodeWasSet() {
     109        state.setSubNodeNodeWasSet();
    196110    }
    197111
     
    204118     */
    205119    private void updateSubNode(String newName, N newNode, T subNode) {
    206         removeFromSubNodesNameMapCache(subNode, subNodes_cache, subNodesNameMap_cache);
    207         asGeneric(subNode).setNode(newName, newNode);
    208         updateSubNodesNameMapCache(subNodesNameMap_cache, subNode);
    209     }
    210 
    211     protected boolean isSubNodesCacheFresh() {
    212         return !nodeWasSet && !subNodeNodeWasSet;
    213     }
    214 
    215     protected boolean hasSubNodesCache() {
    216         return subNodes_cache != null;
     120        state.updateSubNode(newName, newNode, subNode);
     121    }
     122
     123    private N createNodeForChild(GenericAnnotationNode<T, N, V> child) throws AnnotationEditException {
     124        return state.createNodeForChild(child);
    217125    }
    218126
     
    229137
    230138    T forPath(String[] paths, int currentIndex) {
    231         if (isAmbiguous()) {
    232             return ambiguousNode();
    233         }
    234         if (currentIndex == paths.length) {
    235             return self();
    236         }
    237         computeSubNodesCache();
    238         T subNode = subNodesNameMap_cache.get(paths[currentIndex]);
    239         if (subNode == null) {
    240             makeEmptySubNodesCacheMutable();
    241             subNode = createOrSetSubNodeAndAddToCaches(subNode, paths[currentIndex], null, subNodes_cache,
    242                     subNodesNameMap_cache);
    243         }
    244         return subNode.forPath(paths, currentIndex + 1);
    245     }
    246 
    247     private void makeEmptySubNodesCacheMutable() {
    248         if (subNodesNameMap_cache.isEmpty()) {
    249             subNodesNameMap_cache = new HashMap<String, T>();
    250         }
    251         if (subNodes_cache.isEmpty()) {
    252             subNodes_cache = new ArrayList<T>();
    253         }
    254     }
    255    
     139        return state.forPath(paths, currentIndex);
     140    }
     141
    256142    /**
    257143     * Returns reference to it self, but with correct type! This pattern
     
    282168     */
    283169    protected abstract T createNode(N node);
    284    
    285     private N createNodeForChild(GenericAnnotationNode<T, N, V> child) throws AnnotationEditException {
    286         if (child == valueAnnotation_cache) {
    287             // Trying to set the value annotation child
    288             throw new AnnotationEditException(this, "Not possible to set assign annotation value as annotation yet");
    289         }
    290         N res = node().addAnnotationSubNode(child.name());
    291         if (res == null) {
    292             throw new AnnotationEditException(child, "Unable to create sub node");
    293         }
    294         return res;
    295     }
    296 
    297     /**
    298      * Method for checking if this node has sub-nodes.
    299      *
    300      * @return true if this node has sub nodes, otherwise false.
    301      */
    302     public boolean hasSubNodes() {
    303         computeSubNodesCache();
    304         return !subNodes_cache.isEmpty();
    305     }
    306170
    307171    /**
     
    311175     */
    312176    public Iterable<T> subNodes() {
    313         computeSubNodesCache();
    314         return filterExists(subNodes_cache);
    315     }
    316 
    317     private Iterable<T> filterExists(Iterable<T> nodes) {
    318         return new FilteredIterable<T>(nodes, new Criteria<T>() {
    319 
    320             @Override
    321             public boolean test(T elem) {
    322                 return elem.nodeExists();
    323             }
    324 
    325         });
     177        return state.subNodes();
    326178    }
    327179
     
    333185     */
    334186    public N node() throws AnnotationEditException {
    335         if (!hasNode()) {
    336             if (parent == null) {
    337                 // This is a null pattern node without hope of creating
    338                 return null;
    339             }
    340             N node = asGeneric(parent()).createNodeForChild(this);
    341             updateNode(name(), node);
    342         }
    343         return node;
     187        return state.node();
    344188    }
    345189
     
    352196     */
    353197    protected N peekNode() {
    354         return node;
     198        return state.peekNode();
    355199    }
    356200
     
    362206     */
    363207    public String resolveURI(String str) throws URIException {
    364         if (node == null) {
    365             if (parent == null) {
    366                 return null; // We did our best, we cant do more
    367             }
    368             return parent.resolveURI(str);
    369         }
    370         return node.resolveURI(str);
     208        return state.resolveURI(str);
    371209    }
    372210   
     
    376214     */
    377215    public String name() {
    378         return name;
    379     }
    380    
     216        return state.name();
     217    }
     218
    381219    /**
    382220     * Updates the name and node of this GenericAnnotationNode.
     
    384222     * @param node The new node
    385223     */
    386     @SuppressWarnings("unchecked")
    387224    protected void updateNode(String newName, N node) {
    388         if (parent() != null && !name().equals(newName)) {
    389             asGeneric(parent()).updateSubNode(newName, node, (T) this);
    390         } else {
    391             setNode(newName, node);
    392         }
    393     }
    394     /**
    395      * Sets the name and node of this GenericAnnotationNode. This is an internal method,
    396      * call {{@link #updateNode(String, AnnotationProvider)} instead.
    397      * @param newName The new name
    398      * @param node The new node
    399      */
    400     private void setNode(String newName, N node) {
    401         // This is an internal method because it does not update the caches in the parent node.
    402         // it needs to be protected to be accessible from the parent node.
    403         disconnectFromNode();
    404         this.name = newName;
    405         this.node = node;
    406         setNodeWasSetFlags();
    407     }
    408 
    409     /**
    410      *
     225       state.updateNode(newName, node);
     226    }
     227
     228    /**
     229     *
    411230     * @return true if this node has a value, otherwise false
    412231     */
     
    420239     */
    421240    public V value() {
    422         if (!nodeExists() || isAmbiguous()) {
    423             return null;
    424         }
    425         return node().annotationValue();
     241        return state.value();
    426242    }
    427243
     
    435251     */
    436252    public void setValue(V newValue) throws AnnotationEditException {
    437         try {
    438             node().setAnnotationValue(newValue);
    439         } catch (FailedToSetAnnotationValueException e) {
    440             throw new AnnotationEditException(this, e);
    441         }
     253        state.setValue(newValue);
    442254    }
    443255
     
    450262     */
    451263    public T valueAsAnnotation() {
    452         if (!valueAnnotation_cacheComputed) {
    453             valueAnnotation_cacheComputed = true;
    454             if (isAmbiguous()) {
    455                 valueAnnotation_cache = ambiguousNode();
    456             } else if (nodeExists()) {
    457                 N annotationNode = valueAsProvider();
    458                 if (hasValue() && annotationNode == null) {
    459                     valueAnnotation_cache = null;
    460                 } else {
    461                     valueAnnotation_cache = createNode(annotationNode);
    462                 }
    463             } else {
    464                 valueAnnotation_cache = null;
    465             }
    466         }
    467         return valueAnnotation_cache;
     264        return state.valueAsAnnotation();
    468265    }
    469266
     
    473270     * annotation node.
    474271     *
    475      * @param value Value which can be an annotation node
    476272     * @return Provider which reflects the value as annotation node
    477273     */
     
    482278        StringBuilder sb = new StringBuilder();
    483279        try {
    484             toString(sb);
     280            state.toString(sb);
    485281        } catch (IOException e) {
    486282            // Not possible, sb.append() does not throw IOException...
     
    490286
    491287    public void toString(Appendable out) throws IOException {
    492         if (name() != null) {
    493             out.append(name());
    494         }
    495         if (hasSubNodes()) {
    496             boolean first = true;
    497             for (T subNode : subNodes()) {
    498                 if (first) {
    499                     out.append('(');
    500                 }
    501                 if (!first) {
    502                     out.append(", ");
    503                 }
    504                 first = false;
    505                 subNode.toString(out);
    506             }
    507             if (!first) {
    508                 out.append(')');
    509             }
    510         }
    511         if (hasValue()) {
    512             out.append('=');
    513             out.append(value().toString());
    514         }
     288        state.toString(out);
    515289    }
    516290
     
    524298
    525299    /**
    526      * This is an internal method, call {{@link #exists()} instead.
     300     * This is an internal method, call {{@link #nodeExists()} instead.
    527301     * @return true if this node is available.
    528302     */
    529303    protected boolean hasNode() {
    530         return isAmbiguous() || node != null;
     304        return state.hasNode();
    531305    }
    532306
     
    536310     */
    537311    public boolean nodeExists() {
    538         if (parent() != null) {
    539             asGeneric(parent()).computeSubNodesCache();
    540         }
    541         return hasNode();
     312        return state.nodeExists();
    542313    }
    543314
     
    556327     */
    557328    public boolean isEach() {
    558         return node().isEach();
     329        return state.isEach();
    559330    }
    560331
     
    565336     */
    566337    public boolean isFinal() {
    567         return node().isFinal();
     338        return state.isFinal();
    568339    }
    569340
     
    574345     */
    575346    protected T parent() {
    576         return parent;
     347        return state.parent();
    577348    }
    578349
     
    885656     */
    886657    protected void disconnectFromNode() {
    887         if (parent != null) {
    888             node = null;
     658        state.disconnectFromNode();
     659    }
     660
     661    public abstract class AnnotationStateManager {
     662
     663        protected abstract void computeSubNodesCache();
     664
     665        protected abstract boolean isFinal();
     666
     667        protected abstract boolean isEach();
     668
     669        protected abstract boolean isSubNodesCacheFresh();
     670
     671        protected abstract boolean hasSubNodesCache();
     672
     673        protected abstract void setNode(String newName, N node);
     674
     675        protected abstract void setSubNodeNodeWasSet();
     676
     677        protected abstract void updateSubNode(String newName, N newNode, T subNode);
     678
     679        protected abstract N createNodeForChild(GenericAnnotationNode<T,N,V> child);
     680
     681        protected abstract T forPath(String[] path, int i);
     682
     683        protected abstract Iterable<T> subNodes();
     684
     685        protected abstract N node();
     686
     687        protected abstract String resolveURI(String str) throws URIResolver.URIException ;
     688
     689        protected abstract N peekNode();
     690
     691        protected abstract String name();
     692
     693        protected abstract void disconnectFromNode();
     694
     695        protected abstract void updateNode(String newName, N node);
     696
     697        protected abstract V value();
     698
     699        protected abstract void setValue(V newValue);
     700
     701        protected abstract T valueAsAnnotation();
     702
     703        protected abstract void toString(Appendable out) throws IOException ;
     704
     705        protected abstract boolean hasNode();
     706
     707        protected abstract boolean nodeExists();
     708
     709        protected abstract T parent();
     710    }
     711
     712    public class AmbiguousAnnotationStateManager extends AnnotationStateManager {
     713
     714
     715        @Override
     716        protected void computeSubNodesCache() {
     717            // Do nothing
     718        }
     719
     720        @Override
     721        protected boolean isSubNodesCacheFresh() {
     722            return true;
     723        }
     724
     725        @Override
     726        protected boolean hasSubNodesCache() {
     727            return true;
     728        }
     729
     730        @Override
     731        protected void setNode(String newName, N node) {
     732            // Do nothing
     733        }
     734
     735        @Override
     736        protected void setSubNodeNodeWasSet() {
     737            // Do nothing
     738        }
     739
     740        @Override
     741        protected void updateSubNode(String newName, N newNode, T subNode) {
     742            // Do nothing
     743        }
     744
     745        @Override
     746        protected N createNodeForChild(GenericAnnotationNode<T, N, V> child) {
     747            return null;
     748        }
     749
     750        @Override
     751        protected T forPath(String[] path, int i) {
     752            return self();
     753        }
     754
     755        @Override
     756        protected Iterable<T> subNodes() {
     757            return Collections.emptyList();
     758        }
     759
     760        @Override
     761        protected N node() {
     762            return null;
     763        }
     764
     765        @Override
     766        protected String resolveURI(String str) throws URIException {
     767            return null;
     768        }
     769
     770        @Override
     771        protected N peekNode() {
     772            return null;
     773        }
     774
     775        @Override
     776        protected String name() {
     777            return null;
     778        }
     779
     780        @Override
     781        protected void disconnectFromNode() {
     782            // Do nothing
     783        }
     784
     785        @Override
     786        protected void updateNode(String newName, N node) {
     787            // Do nothing
     788        }
     789
     790        @Override
     791        protected V value() {
     792            return node().annotationValue();
     793        }
     794
     795        @Override
     796        protected void setValue(V newValue) {
     797            // Do nothing
     798        }
     799
     800        @Override
     801        protected T valueAsAnnotation() {
     802            return self();
     803        }
     804
     805        @Override
     806        protected void toString(Appendable out) throws IOException {
     807            // We don't have anything to append
     808        }
     809
     810        @Override
     811        protected boolean hasNode() {
     812            return true;
     813        }
     814
     815        @Override
     816        protected boolean nodeExists() {
     817            return true;
     818        }
     819
     820        @Override
     821        protected T parent() {
     822            return null;
     823        }
     824
     825        @Override
     826        protected boolean isFinal() {
     827            return false;
     828        }
     829
     830        @Override
     831        protected boolean isEach() {
     832            return false;
     833        }
     834    }
     835
     836    public class MutableAnnotationStateManager extends AnnotationStateManager {
     837
     838        private String name;
     839        private N node;
     840        private final T parent;
     841
     842        private Collection<T> subNodes_cache;
     843        private Map<String, T> subNodesNameMap_cache;
     844        private boolean nodeWasSet = false;
     845        private boolean subNodeNodeWasSet = false;
     846        private T valueAnnotation_cache;
     847        private boolean valueAnnotation_cacheComputed = false;
     848
     849        protected MutableAnnotationStateManager(String name, N node, T parent) {
     850            this.parent = parent;
     851            setNode(name, node);
     852        }
     853
     854        @Override
     855        protected void computeSubNodesCache() {
     856            if (isSubNodesCacheFresh()) {
     857                return;
     858            }
     859            if (subNodes_cache == null) {
     860                subNodes_cache = Collections.emptyList();
     861            }
     862            if (subNodesNameMap_cache == null) {
     863                subNodesNameMap_cache = Collections.emptyMap();
     864            }
     865
     866            if(!nodeExists()) {
     867                return;
     868            }
     869
     870            List<T> subNodes = new ArrayList<T>();
     871            Map<String, List<T>> oldNodesMap = constructMapIncludingAmbiguous(subNodes_cache);
     872            Map<String, T> subNodesNameMap = new HashMap<String, T>();
     873            for (AnnotationProvider.SubAnnotationPair<N> subNodePair : node.annotationSubNodes()) {
     874                String subNodeName = subNodePair.getAnnotationName();
     875                N subNodeNode = subNodePair.getAnnotationValue();
     876                T subNode = null;
     877
     878                List<T> oldNodes = oldNodesMap.get(subNodeName);
     879                if (oldNodes != null) {
     880                    subNode = oldNodes.remove(0);
     881                    if (oldNodes.isEmpty()) {
     882                        oldNodesMap.remove(subNodeName);
     883                    }
     884                }
     885                createOrSetSubNodeAndAddToCaches(subNode, subNodeName, subNodeNode, subNodes, subNodesNameMap);
     886            }
     887
     888            for(List<T> oldNodes : oldNodesMap.values()) {
     889                for(T oldNode: oldNodes) {
     890                    //TODO move the setting of the node field in the sub node to null to an explicit step
     891                    createOrSetSubNodeAndAddToCaches(oldNode, oldNode.name(), null, subNodes, subNodesNameMap);
     892                }
     893            }
     894            subNodes_cache = subNodes;
     895            subNodesNameMap_cache = subNodesNameMap;
     896            clearNodeWasSetFlags();
     897        }
     898
     899        private T createOrSetSubNodeAndAddToCaches(T subNode, String subNodeName, N subNodeNode, Collection<T> subNodes, Map<String, T> subNodesNameMap) {
     900            if (subNode == null) {
     901                subNode = createNode(subNodeName, subNodeNode);
     902            } else {
     903                asGeneric(subNode).setNode(subNodeName, subNodeNode);
     904            }
     905            if (subNode != null) {
     906                addToCaches(subNodes, subNodesNameMap, subNode);
     907            }
     908            return subNode;
     909        }
     910
     911        private void addToCaches(Collection<T> subNodes, Map<String, T> subNodesNameMap, T subNode) {
     912            subNodes.add(subNode);
     913            updateSubNodesNameMapCache(subNodesNameMap, subNode);
     914        }
     915
     916        private void updateSubNodesNameMapCache(Map<String, T> subNodesNameMap, T subNode) {
     917            T previous = subNodesNameMap.put(subNode.name(), subNode);
     918            if (previous != null && previous.hasNode() && subNode.hasNode()) { // subNode goes from not ambiguous to ambiguous
     919                subNodesNameMap.put(subNode.name(), ambiguousNode());
     920            }
     921        }
     922
     923        private T removeFromSubNodesNameMapCache(T subNode, Collection<T> subNodes, Map<String, T> subNodesNameMap) {
     924            T previous = subNodesNameMap.get(subNode.name());
     925            if (previous != null) {
     926                if (previous == ambiguousNode()) {
     927                    Map<String, List<T>> oldNodesMap = constructMapIncludingAmbiguous(filterExists(subNodes));
     928                    List<T> oldNodes = oldNodesMap.get(subNode.name());
     929                    if(oldNodes.size() == 2) { // subNode goes from ambiguous to not ambiguous
     930                        oldNodes.remove(subNode);
     931                        subNodesNameMap.put(subNode.name(), oldNodes.get(0));
     932                    }
     933                } else {
     934                    subNodesNameMap.remove(subNode.name());
     935                }
     936            }
     937            return previous;
     938        }
     939
     940        /**
     941         * Computes a map that maps between name and node, the list is needed since
     942         * there may be multiple nodes with the same name, if that is the case,
     943         * then they are put in the list in the order that they are found!
     944         */
     945        private Map<String, List<T>> constructMapIncludingAmbiguous(Iterable<T> nodes) {
     946            if (nodes == null) {
     947                return Collections.emptyMap();
     948            }
     949            Map<String, List<T>> res = new LinkedHashMap<String, List<T>>();
     950            for (T node : nodes) {
     951                String name = node.name();
     952                List<T> withSameName = res.get(name);
     953                if (withSameName == null) {
     954                    withSameName = new ArrayList<T>(Collections.singletonList(node));
     955                    res.put(name, withSameName);
     956                } else if (withSameName.size() == 1) {
     957                    withSameName = new ArrayList<T>(withSameName);
     958                    withSameName.add(node);
     959                    res.put(name, withSameName);
     960                } else {
     961                    withSameName.add(node);
     962                }
     963            }
     964            return res;
     965        }
     966
     967        @Override
     968        protected void updateSubNode(String newName, N newNode, T subNode) {
     969            removeFromSubNodesNameMapCache(subNode, subNodes_cache, subNodesNameMap_cache);
     970            asGeneric(subNode).setNode(newName, newNode);
     971            updateSubNodesNameMapCache(subNodesNameMap_cache, subNode);
     972        }
     973
     974        @Override
     975        protected boolean isSubNodesCacheFresh() {
     976            return !nodeWasSet && !subNodeNodeWasSet;
     977        }
     978
     979        @Override
     980        protected boolean hasSubNodesCache() {
     981            return subNodes_cache != null;
     982        }
     983
     984        @Override
     985        protected T forPath(String[] paths, int currentIndex) {
     986            if (currentIndex == paths.length) {
     987                return self();
     988            }
     989            computeSubNodesCache();
     990            T subNode = subNodesNameMap_cache.get(paths[currentIndex]);
     991            if (subNode == null) {
     992                makeEmptySubNodesCacheMutable();
     993                subNode = createOrSetSubNodeAndAddToCaches(subNode, paths[currentIndex], null, subNodes_cache,
     994                        subNodesNameMap_cache);
     995            }
     996            return subNode.forPath(paths, currentIndex + 1);
     997        }
     998
     999        private void makeEmptySubNodesCacheMutable() {
     1000            if (subNodesNameMap_cache.isEmpty()) {
     1001                subNodesNameMap_cache = new HashMap<String, T>();
     1002            }
     1003            if (subNodes_cache.isEmpty()) {
     1004                subNodes_cache = new ArrayList<T>();
     1005            }
     1006        }
     1007
     1008        @Override
     1009        protected N createNodeForChild(GenericAnnotationNode<T, N, V> child) throws AnnotationEditException {
     1010            if (child == valueAnnotation_cache) {
     1011                // Trying to set the value annotation child
     1012                throw new AnnotationEditException(GenericAnnotationNode.this, "Not possible to set assign annotation value as annotation yet");
     1013            }
     1014            N res = node().addAnnotationSubNode(child.name());
     1015            if (res == null) {
     1016                throw new AnnotationEditException(child, "Unable to create sub node");
     1017            }
     1018            return res;
     1019        }
     1020
     1021        private boolean hasSubNodes() {
     1022            computeSubNodesCache();
     1023            return !subNodes_cache.isEmpty();
     1024        }
     1025
     1026        @Override
     1027        protected Iterable<T> subNodes() {
     1028            computeSubNodesCache();
     1029            return filterExists(subNodes_cache);
     1030        }
     1031
     1032        private Iterable<T> filterExists(Iterable<T> nodes) {
     1033            return new FilteredIterable<T>(nodes, new Criteria<T>() {
     1034
     1035                @Override
     1036                public boolean test(T elem) {
     1037                    return elem.nodeExists();
     1038                }
     1039
     1040            });
     1041        }
     1042
     1043        @Override
     1044        protected N node() throws AnnotationEditException {
     1045            if (!hasNode()) {
     1046                if (parent == null) {
     1047                    // This is a null pattern node without hope of creating
     1048                    return null;
     1049                }
     1050                N node = asGeneric(parent()).createNodeForChild(GenericAnnotationNode.this);
     1051                updateNode(name(), node);
     1052            }
     1053            return node;
     1054        }
     1055
     1056        @Override
     1057        protected N peekNode() {
     1058            return node;
     1059        }
     1060
     1061        @Override
     1062        protected String resolveURI(String str) throws URIResolver.URIException {
     1063            if (node == null) {
     1064                if (parent == null) {
     1065                    return null; // We did our best, we cant do more
     1066                }
     1067                return parent.resolveURI(str);
     1068            }
     1069            return node.resolveURI(str);
     1070        }
     1071
     1072        @Override
     1073        protected String name() {
     1074            return name;
     1075        }
     1076
     1077        @SuppressWarnings("unchecked")
     1078        @Override
     1079        protected void updateNode(String newName, N node) {
     1080            if (parent() != null && !name().equals(newName)) {
     1081                asGeneric(parent()).updateSubNode(newName, node, (T) GenericAnnotationNode.this);
     1082            } else {
     1083                setNode(newName, node);
     1084            }
     1085        }
     1086
     1087        @Override
     1088        protected void setNode(String newName, N node) {
     1089            // This is an internal method because it does not update the caches in the parent node.
     1090            // it needs to be protected to be accessible from the parent node.
     1091            disconnectFromNode();
     1092            this.name = newName;
     1093            this.node = node;
    8891094            setNodeWasSetFlags();
    8901095        }
    891         if (subNodes_cache != null) {
    892             for (T t : subNodes_cache) {
    893                 t.disconnectFromNode();
    894             }
    895         }
    896     }
    897 
    898     private void setNodeWasSetFlags() {
    899         nodeWasSet = true;
    900         if (parent() != null) {
    901             asGeneric(parent()).setSubNodeNodeWasSet();
    902         }
    903     }
    904 
    905     private void setSubNodeNodeWasSet() {
    906         subNodeNodeWasSet = true;
    907     }
    908 
    909     private void clearNodeWasSetFlags() {
    910         nodeWasSet = false;
    911         subNodeNodeWasSet = false;
     1096
     1097        @Override
     1098        protected V value() {
     1099            if (!nodeExists()) {
     1100                return null;
     1101            }
     1102            return node().annotationValue();
     1103        }
     1104
     1105        @Override
     1106        protected void setValue(V newValue) throws AnnotationEditException {
     1107            try {
     1108                node().setAnnotationValue(newValue);
     1109            } catch (FailedToSetAnnotationValueException e) {
     1110                throw new AnnotationEditException(GenericAnnotationNode.this, e);
     1111            }
     1112        }
     1113
     1114        @Override
     1115        protected T valueAsAnnotation() {
     1116            if (!valueAnnotation_cacheComputed) {
     1117                valueAnnotation_cacheComputed = true;
     1118                if (nodeExists()) {
     1119                    N annotationNode = valueAsProvider();
     1120                    if (hasValue() && annotationNode == null) {
     1121                        valueAnnotation_cache = null;
     1122                    } else {
     1123                        valueAnnotation_cache = createNode(annotationNode);
     1124                    }
     1125                } else {
     1126                    valueAnnotation_cache = null;
     1127                }
     1128            }
     1129            return valueAnnotation_cache;
     1130        }
     1131
     1132        @Override
     1133        protected void toString(Appendable out) throws IOException {
     1134            if (name() != null) {
     1135                out.append(name());
     1136            }
     1137            if (hasSubNodes()) {
     1138                boolean first = true;
     1139                for (T subNode : subNodes()) {
     1140                    if (first) {
     1141                        out.append('(');
     1142                    }
     1143                    if (!first) {
     1144                        out.append(", ");
     1145                    }
     1146                    first = false;
     1147                    subNode.toString(out);
     1148                }
     1149                if (!first) {
     1150                    out.append(')');
     1151                }
     1152            }
     1153            if (hasValue()) {
     1154                out.append('=');
     1155                out.append(value().toString());
     1156            }
     1157        }
     1158
     1159        @Override
     1160        protected boolean hasNode() {
     1161            return node != null;
     1162        }
     1163
     1164        @Override
     1165        protected boolean nodeExists() {
     1166            if (parent() != null) {
     1167                asGeneric(parent()).computeSubNodesCache();
     1168            }
     1169            return hasNode();
     1170        }
     1171
     1172        @Override
     1173        protected T parent() {
     1174            return parent;
     1175        }
     1176
     1177        @Override
     1178        protected void disconnectFromNode() {
     1179            if (parent != null) {
     1180                node = null;
     1181                setNodeWasSetFlags();
     1182            }
     1183            if (subNodes_cache != null) {
     1184                for (T t : subNodes_cache) {
     1185                    t.disconnectFromNode();
     1186                }
     1187            }
     1188        }
     1189
     1190        private void setNodeWasSetFlags() {
     1191            nodeWasSet = true;
     1192            if (parent() != null) {
     1193                asGeneric(parent()).setSubNodeNodeWasSet();
     1194            }
     1195        }
     1196
     1197        @Override
     1198        protected void setSubNodeNodeWasSet() {
     1199            subNodeNodeWasSet = true;
     1200        }
     1201
     1202        private void clearNodeWasSetFlags() {
     1203            nodeWasSet = false;
     1204            subNodeNodeWasSet = false;
     1205        }
     1206
     1207        @Override
     1208        protected boolean isFinal() {
     1209            return node.isFinal();
     1210        }
     1211
     1212        @Override
     1213        protected boolean isEach() {
     1214            return node.isEach();
     1215        }
     1216
    9121217    }
    9131218
  • trunk/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/util/annotations/mock/DummyAnnotationNode.java

    r13009 r14002  
    11package org.jmodelica.util.annotations.mock;
    22
     3import org.jmodelica.util.annotations.AnnotationProvider;
    34import org.jmodelica.util.annotations.GenericAnnotationNode;
    45import org.jmodelica.util.values.Evaluable;
     
    67public class DummyAnnotationNode extends GenericAnnotationNode<DummyAnnotationNode, DummyAnnotProvider, Evaluable> {
    78
    8     private static DummyAnnotationNode ambiguousNode = new DummyAnnotationNode("Ambiguous", null, null);
     9    private static DummyAnnotationNode ambiguousNode = new DummyAnnotationNode();
     10
     11    /** Creates an unambiguous dummy annotation.
     12     * See {@link GenericAnnotationNode#GenericAnnotationNode(String, AnnotationProvider, GenericAnnotationNode)}
     13     */
    914    public DummyAnnotationNode(String name, DummyAnnotProvider node, DummyAnnotationNode parent) {
    1015        super(name, node, parent);
     16    }
     17
     18    /** Creates an ambiguous dummy annotation.
     19     * See {@link GenericAnnotationNode#GenericAnnotationNode()}
     20     */
     21    public DummyAnnotationNode() {
     22        super();
    1123    }
    1224
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/Profiling.jrag

    r12940 r14002  
    401401    }
    402402
    403     private static Map<Class,Counter> ASTNode.buildNodeCountMap = null;
    404 
    405     private static NodeCountExtra[] ASTNode.nodeCountExtra = new NodeCountExtra[] { };
    406 
    407     public interface NodeCountExtra {
    408         public void count(ASTNode n);
    409         public void printResult(CodeStream out);
    410     }
    411 
    412403    /**
    413404     * Output a list of the number of instances of each node class.
    414405     */
    415     public static void ASTNode.dumpNodeCount(String file)
     406    public void ASTNode.dumpNodeCount(String file, UtilInterface util)
    416407            throws IOException {
    417         ArrayList<Counter> list = new ArrayList<Counter>();
    418         list.addAll(buildNodeCountMap.values());
     408        ArrayList<ASTNodeCounter> list = new ArrayList<ASTNodeCounter>();
     409        list.addAll(util.getBuildNodeCountMap().values());
    419410        Collections.sort(list);
    420411        CodeStream out = new CodeStream(file);
    421         for (Counter c : list)
     412        for (ASTNodeCounter c : list)
    422413            out.println(c);
    423         for (NodeCountExtra nce : nodeCountExtra)
    424             nce.printResult(out);
    425414        out.close();
    426415    }
    427416
    428     public void ASTNode.buildNodeCount() {
    429         Profiler.clear();
    430         if (buildNodeCountMap == null)
    431             buildNodeCountMap = new HashMap<Class,Counter>();
    432         buildNodeCount(buildNodeCountMap);
    433         Profiler.clear();
    434     }
    435 
    436     private void ASTNode.buildNodeCount(Map<Class,Counter> map) {
     417    public void ASTNode.buildNodeCount(Map<Class,ASTNodeCounter> map) {
    437418        addToNodeCount(map, getClass(), Profiler.getNodeSize(this, false), Profiler.getNodeSize(this, true));
    438         for (NodeCountExtra nce : nodeCountExtra)
    439             nce.count(this);
    440419       
    441420        for (ASTNode n : profilingChildren())
     
    443422    }
    444423
    445     private void ASTNode.addToNodeCount(Map<Class,Counter> map, Class cls, long local, long deep) {
     424    private void ASTNode.addToNodeCount(Map<Class,ASTNodeCounter> map, Class cls, long local, long deep) {
    446425        if (map.containsKey(cls))
    447426            map.get(cls).inc(local, deep);
    448427        else
    449             map.put(cls, new Counter(cls.getSimpleName(), local, deep));
     428            map.put(cls, new ASTNodeCounter(cls.getSimpleName(), local, deep));
    450429        if (cls != ASTNode.class)
    451430            addToNodeCount(map, cls.getSuperclass(), local, deep);
    452431    }
    453432
    454     public class ASTNode {
    455         public static class Counter implements Comparable<Counter> {
    456             private int n;
    457             private long sizeLocal;
    458             private long sizeDeep;
    459             private String s;
    460            
    461             private static int l = 0;
    462             private static String fmt = null;
    463            
    464             public Counter(String name, long local, long deep) {
    465                 s = name;
    466                 sizeLocal = 0;
    467                 sizeDeep = 0;
    468                 n = 0;
    469                 if (s.length() > l)
    470                     l = s.length();
    471                 inc(local, deep);
    472             }
    473            
    474             public void inc(long local, long deep) {
    475                 n++;
    476                 sizeLocal += local;
    477                 sizeDeep += deep;
    478             }
    479            
    480             public int compareTo(Counter c) {
    481                 return c.n - n;
    482             }
    483            
    484             public String toString() {
    485                 if (fmt == null)
    486                     fmt = "%-" + l + "s : %9d (%8s / %8s)";
    487                 return String.format(fmt, s, n, ASTNode.formatMem(sizeDeep), ASTNode.formatMem(sizeLocal));
    488             }
     433    public class ASTNodeCounter implements Comparable<ASTNodeCounter> {
     434        private int n;
     435        private long sizeLocal;
     436        private long sizeDeep;
     437        private String s;
     438       
     439        private static int l = 0;
     440        private static String fmt = null;
     441       
     442        public ASTNodeCounter(String name, long local, long deep) {
     443            s = name;
     444            sizeLocal = 0;
     445            sizeDeep = 0;
     446            n = 0;
     447            if (s.length() > l)
     448                l = s.length();
     449            inc(local, deep);
     450        }
     451       
     452        public void inc(long local, long deep) {
     453            n++;
     454            sizeLocal += local;
     455            sizeDeep += deep;
     456        }
     457       
     458        public int compareTo(ASTNodeCounter c) {
     459            return c.n - n;
     460        }
     461       
     462        public String toString() {
     463            if (fmt == null)
     464                fmt = "%-" + l + "s : %9d (%8s / %8s)";
     465            return String.format(fmt, s, n, ASTNode.formatMem(sizeDeep), ASTNode.formatMem(sizeLocal));
     466        }
     467    }
     468
     469    public class UtilInterface {
     470        private Map<Class, ASTNodeCounter> buildNodeCountMap;
     471        public Map<Class, ASTNodeCounter> getBuildNodeCountMap() {
     472            if (buildNodeCountMap == null) {
     473                buildNodeCountMap = new HashMap<>();
     474            }
     475            return buildNodeCountMap;
    489476        }
    490477    }
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/structural/DynamicStates.jrag

    r13357 r14002  
    263263    public class IndexReductionBiPGraph {
    264264        public static class DSSet {
    265             private static Enumerator e = new Enumerator();
    266265            public final Set<IndexReductionEq> eqns = new LinkedHashSet<IndexReductionEq>();
    267266            public final Set<IndexReductionVar> vars = new LinkedHashSet<IndexReductionVar>();
    268             public final int id = e.next();
     267            public final int id;
    269268            public FExp[][] coefficients;
     269
     270            public DSSet(int id) {
     271                this.id = id;
     272            }
    270273           
    271274            public String toString() {
     
    309312                worklist.add(eqn);
    310313        }
     314
     315        Enumerator enumerator = new Enumerator();
    311316        while (!worklist.isEmpty()) {
    312317            IndexReductionEq eqn = worklist.poll();
     
    324329            DSSet set = dsLookup.get(eqn);
    325330            if (set == null)
    326                 set = new DSSet();
     331                set = new DSSet(enumerator.next());
    327332            Collection<IndexReductionEq> otherEqns = new ArrayList<IndexReductionEq>();
    328333            ASTNode.log.debug("    Path not found, set %d", set.id);
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/structural/Graphs.jadd

    r13444 r14002  
    11391139    private static class HomotopyContributor extends SCCContributor {
    11401140       
    1141         private static final Collection<? extends Object> memberSets = Arrays.asList("homotopy");
     1141        private static final Collection<? extends Object> memberSets = Collections.singleton("homotopy");
    11421142       
    11431143        @Override
     
    21742174   
    21752175    public abstract class AbstractBiPGraph {
    2176         private final static Enumerator visitEnumerator = new Enumerator(1);
     2176        private final Enumerator visitEnumerator = new Enumerator(1);
    21772177        public abstract class AugmentingPathAlgorithm<R> {
    21782178            private final R TRUE_VALUE;
Note: See TracChangeset for help on using the changeset viewer.