Changeset 9628


Ignore:
Timestamp:
Feb 10, 2017 11:21:55 AM (3 years ago)
Author:
Zimon Kuhs
Message:

#5284

Removed all list rewrites.

Removed most of the standard list rewrites in if-equation elimination and rewrite as well.

Location:
trunk/Compiler
Files:
3 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/Arrays.jrag

    r9596 r9628  
    747747    }
    748748
     749    syn boolean FExp.isIntegerLiteral()         = false;
     750    eq FIntegerLitExp.isIntegerLiteral()        = true;
     751
    749752    syn boolean FExp.isIntegerLiteral(int v)    = false;
    750753    eq FIntegerLitExp.isIntegerLiteral(int v)   = getValue() == v;
    751 
    752     syn boolean FExp.isIntegerLiteral()         = false;
    753     eq FIntegerLitExp.isIntegerLiteral()        = true;
    754754 
     755    syn boolean FExp.isRealLiteral()            = false;
     756    eq FRealLitExp.isRealLiteral()              = true;
     757
     758    syn boolean FExp.isRealLiteral(double v)    = false;
     759    eq FRealLitExp.isRealLiteral(double v)      = getValue() == v;
     760   
     761    syn boolean FExp.isZeroLiteral()  = isIntegerLiteral(0);
     762    eq FRealLitExp.isZeroLiteral()    = isRealLiteral(0.0);
     763
     764    eq FArray.isZeroLiteral() {
     765        for (FExp e : getFExps()) {
     766            if (!e.isZeroLiteral()) {
     767                return false;
     768            }
     769        }
     770        return true;
     771    }
     772
    755773    eq FLinspace.size() {
    756774        MutableSize s = new MutableSize(ndims());
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/errorcheck/ContentsCheck.jadd

    r9555 r9628  
    487487    syn boolean FIfWhenEquation.elseIsBalancedAssignments() =
    488488        assignedSet().equals(getElse().assignedSet()) && getElse().isBalancedAssignments();
    489    
    490     inh boolean FIfEquation.isTopWhenIfEquation();
    491     eq ASTNode.getChild().isTopWhenIfEquation()        = true;
    492     eq FIfWhenEquation.getElse().isTopWhenIfEquation() = false;
    493    
     489
     490    inh boolean FIfEquation.isTopWhenIfEquation();
     491    eq FClass.getChild().isTopWhenIfEquation()              = true;
     492    eq InstClassDecl.getChild().isTopWhenIfEquation()       = true;
     493    eq FIfWhenElseEquation.getChild().isTopWhenIfEquation() = true;
     494    eq FIfWhenEquation.getElse().isTopWhenIfEquation()      = false;
     495
    494496    syn boolean FIfWhenElseEquation.hasOnlyFixedParamTests() = true;
    495497    eq FIfWhenEquation.hasOnlyFixedParamTests()              = getTest().variability().fixedParameterOrLess()
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/source/InitialTransformations.jrag

    r8027 r9628  
    199199        return l;
    200200    }
    201    
     201
    202202    // For preserved formatting.
    203203    Composition FullClassDecl.originalComposition;
    204    
     204
    205205    /**
    206206     * Extract elements from Composition and add to a FullClassDecl.
    207207     */
    208208    public void Composition.extractElementsTo(FullClassDecl fcd) {
    209         fcd.originalComposition = this;
    210 
    211         for (Clause cl : getClauses())
    212             cl.addToFullClassDecl(fcd);
    213        
    214         if (hasExternalClause())
    215             fcd.setExternalClause(getExternalClause());
    216     }
    217    
     209        fcd.originalComposition = this;
     210
     211        for (Clause cl : getClauses()) {
     212            cl.addToFullClassDecl(fcd);
     213        }
     214
     215        if (hasExternalClause()) {
     216            fcd.setExternalClause(getExternalClause());
     217        }
     218    }
     219
     220    /**
     221     * Adds a clause element to a full class declaration.
     222     * <p>
     223     * This translates parsed elements to source elements.
     224     *
     225     * @param fcd
     226     *          The {@link FullClassDecl} instance in which to put the source elements.
     227     */
     228
    218229    public void Clause.addToFullClassDecl(FullClassDecl fcd) {}
    219    
     230
    220231    public void ComponentDecl.addToFullClassDecl(FullClassDecl fcd) {
    221232        if (hasRedeclare()) {
     
    226237        }
    227238    }
    228    
     239
    229240    public void Algorithm.addToFullClassDecl(FullClassDecl fcd) {
    230         Algorithm algo = new Algorithm(getInitialOpt(), new List());
    231         for (Statement stmt : getStatements())
    232             stmt.addToFullClassDecl(fcd, algo);
    233         fcd.addAlgorithm(algo);
    234     }
    235    
     241        Algorithm algo = new Algorithm(getInitialOpt(), new List());
     242        for (Statement stmt : getStatements())
     243            stmt.addToFullClassDecl(fcd, algo);
     244        fcd.addAlgorithm(algo);
     245    }
     246
    236247    public void Statement.addToFullClassDecl(FullClassDecl fcd, Algorithm algo) {
    237         algo.addStatement(this);
    238     }
    239    
     248        algo.addStatement(this);
     249    }
     250
    240251    public void AlgorithmAnnotation.addToFullClassDecl(FullClassDecl fcd, Algorithm algo) {
    241         getAnnotation().setLocationNoTree(getAnnotation(), this);
    242         fcd.setAnnotation(getAnnotation());
    243     }
    244    
     252        getAnnotation().setLocationNoTree(getAnnotation(), this);
     253        fcd.setAnnotation(getAnnotation());
     254    }
     255
    245256    public void ExtendsClause.addToFullClassDecl(FullClassDecl fcd) {
    246         fcd.addSuper(this);
    247     }
    248    
     257        fcd.addSuper(this);
     258    }
     259
    249260    public void ClassDecl.addToFullClassDecl(FullClassDecl fcd) {
    250261        // TODO: add redeclared to ElementModifications instead of class list
    251         fcd.addClassDecl(this);
    252     }
    253    
     262        fcd.addClassDecl(this);
     263    }
     264
    254265    public void ImportClause.addToFullClassDecl(FullClassDecl fcd) {
    255266        fcd.addImport(this);
    256267    }
    257    
     268
    258269    public void EquationClause.addToFullClassDecl(FullClassDecl fcd) {
    259270        for (AbstractEquation equ : getAbstractEquations())
    260             equ.addToFullClassDecl(fcd);
    261     }
    262    
     271            equ.addToFullClassDecl(fcd);
     272    }
     273
    263274    public void AbstractEquation.addToFullClassDecl(FullClassDecl fcd) {
    264275        fcd.addEquation(this);
    265276    }
    266    
    267     /**
    268      * Rewrite the PN_ExtendsClause to a ExtendsClause including visibility info
     277
     278    public void PublicElementList.addToFullClassDecl(FullClassDecl fcd) {
     279        for (Element elem : getElements()) {
     280            elem.addToFullClassDecl(fcd);
     281        }
     282    }
     283
     284    public void ProtectedElementList.addToFullClassDecl(FullClassDecl fcd) {
     285        for (Element elem : getElements()) {
     286            elem.addToFullClassDecl(fcd);
     287        }
     288    }
     289
     290    public void ComponentClause.addToFullClassDecl(FullClassDecl fcd) {
     291        java.util.List<SiblingComponentDecl> siblings = getNumName() > 1 ? new ArrayList<SiblingComponentDecl>() : null;
     292
     293        for (int i = 0; i < getNumName(); ++i) {
     294            PN_ComponentDecl name = getName(i);
     295            ComponentDecl decl = asComponentDecl(name, siblings);
     296            decl.setLocationNoTree(i == 0 ? this : name);
     297            decl.addToFullClassDecl(fcd);
     298        }
     299    }
     300
     301    /**
     302     * Rewrite the {@link PN_ExtendsClause} to an {@link ExtendsClause}, including visibility info.
    269303     */
    270304    rewrite PN_ExtendsClause {
     
    274308                                     getClassModificationOpt(),
    275309                                     getAnnotationOpt());
    276        
     310
    277311            e.setLocationNoTree(this);
    278312            return e;
     
    281315 
    282316    /**
    283      * Rewrite the PN_ComponentClause to a ComponentClause including
    284      * visibility information.
     317     * Rewrite the {@link PN_ComponentClause} to a {@link ComponentClause} including visibility information.
    285318     */
    286319    rewrite PN_ComponentClause {
    287320        to ComponentClause {
    288321            List l = new List();
    289          
     322
    290323            for(int i=0;i<getNumName();i++) {
    291324                if (getName(i)!=null) l.add(getName(i));
    292325            }
    293          
     326
    294327            ComponentClause c = new ComponentClause(getRedeclareOpt(),
    295328                                                    getFinalOpt(),
     
    307340                                                    getComment());
    308341            c.setLocationNoTree(this);
    309             //log.debug("PN_ComponentClause->ComponentClause.getStart() = "+c.getStart());
     342            // log.debug("PN_ComponentClause->ComponentClause.getStart() = " + c.getStart());
    310343            return c;
    311344        }
    312345    }
    313    
     346
     347    /**
     348     * Rewrite a component clause to a source component declaration.
     349     */
     350    rewrite ComponentClause {
     351             when (getNumName() == 1)
     352             to ComponentDecl {
     353                     ComponentDecl cd = asComponentDecl(getName(0), null);
     354                     cd.setLocationNoTree(this);
     355                     return cd;
     356             }
     357     }
     358
     359    /**
     360     * Rewrite a parsed component redeclaration to a source component redeclaration.
     361     */
    314362     rewrite PN_ComponentRedeclare {
    315363        to ComponentRedeclare {
    316            ComponentRedeclare c = new ComponentRedeclare(getEachOpt(),getFinalOpt(), getName(), (ComponentDecl)getBaseComponentDecl());
     364           ComponentRedeclare c = new ComponentRedeclare(getEachOpt(), getFinalOpt(), getName(),
     365                   (ComponentDecl) getBaseComponentDecl());
    317366           c.setLocationNoTree(this);
    318367           return c;
    319368        }
    320369    }   
    321    
    322    
    323     /**
    324      * Eliminate the PublicElementList nodes. Creation of a new list
    325      * is essential to trigger re-writes in the children.
    326      */
    327     rewrite PublicElementList in Composition.getClause() {
    328         to List {
    329             List l = new List();
    330             List el = getElementList();
    331             for(int i=0;i<el.getNumChild();i++)
    332                 if (el.getChild(i)!=null) l.add(el.getChild(i));
    333             return l.add(new PN_DummyClause());
    334         }
    335     }
    336  
    337     /**
    338      * Eliminate the ProtectedElementList nodes Creation of a new list
    339      * is essential to trigger re-writes in the children.
    340      */
    341     rewrite ProtectedElementList in Composition.getClause() {
    342         to List {
    343             List l = new List();
    344             List el = getElementList();
    345                 for(int i=0;i<el.getNumChild();i++)
    346                     if (el.getChild(i)!=null) l.add(el.getChild(i));
    347             return l.add(new PN_DummyClause());
    348         }
    349     }
    350  
    351     /**
    352      * Transform ComponentClauses to ComponentDecls
    353      */
    354     rewrite ComponentClause in Composition.getClause() {
    355         to List {
    356             List l = new List();
    357             java.util.List<SiblingComponentDecl> siblings = null;
    358             if (getNumName() > 1)
    359                 siblings = new ArrayList();
    360             for (PN_ComponentDecl name : getNames()) {
    361                 ComponentDecl c = asComponentDecl(name, siblings);
    362                 if (l.getNumChild() == 0)
    363                     c.setLocationNoTree(this);
    364                 else
    365                     c.setLocationNoTree(name);
    366                 l.add(c);
    367             }
    368             return l;
    369         }
    370     }
    371    
    372     rewrite ComponentClause {
    373         when (getNumName()==1)
    374         to ComponentDecl {
    375             ComponentDecl cd = asComponentDecl(getName(0), null);
    376             cd.setLocationNoTree(this);
    377             return cd;
    378         }
    379     }
    380    
    381     private ComponentDecl ComponentClause.asComponentDecl(PN_ComponentDecl name, java.util.List<SiblingComponentDecl> siblings) {
    382         // Move all ArraySubscripts to the declaration
    383         List as;
    384         if (name.hasVarArraySubscripts())
    385             as = name.getVarArraySubscripts().getSubscriptList();
    386         else
    387             as = new List();
    388 
    389         if (hasTypeArraySubscripts())
    390             for (int i=0;i<getTypeArraySubscripts().getNumSubscript();i++)
    391                 as.add(getTypeArraySubscripts().getSubscript(i));
    392         ComponentDecl c;
    393         if (siblings == null) {
    394             c = new ComponentDecl();
    395         } else {
    396             SiblingComponentDecl sc = new SiblingComponentDecl();
    397             sc.setSiblings(siblings);
    398             siblings.add(sc);
    399             c = sc;
    400         }
    401         c.setRedeclareOpt(getRedeclareOpt().fullCopy());
    402         c.setFinalOpt(getFinalOpt().fullCopy());
    403         c.setInnerOpt(getInnerOpt().fullCopy());
    404         c.setOuterOpt(getOuterOpt().fullCopy());
    405         c.setReplaceableOpt(getReplaceableOpt().fullCopy());
    406         c.setTypePrefixFlowOpt(getTypePrefixFlowOpt().fullCopy());
    407         c.setTypePrefixVariabilityOpt(getTypePrefixVariabilityOpt().fullCopy());
    408         c.setTypePrefixInputOutputOpt(getTypePrefixInputOutputOpt().fullCopy());
    409         c.setClassName(getClassName().fullCopy());
    410         c.setVisibilityType(getVisibilityType().fullCopy());
    411         c.setName(name.getName());
    412         if (as.getNumChild() > 0)
    413             c.setVarArraySubscripts(new ArraySubscripts(as));
    414         c.setModificationOpt(name.getModificationOpt());
    415         c.setConditionalAttributeOpt(name.getConditionalAttributeOpt());
    416         c.setComment(name.getComment());
    417         c.setConstrainingClauseOpt( getConstrainingClauseOpt().fullCopy());
    418         c.setCCComment(getComment());
    419         c.setLocationNoTree(this, this, name);
    420         return c;
    421     }
    422 
     370
     371    /**
     372     * Returns a component declaration instance corresponding to the parsed component clause.
     373     *
     374     * @param name
     375     *          The parsed declaration of the component.
     376     * @param siblings
     377     *          The component's sibling components.
     378     */
     379    public ComponentDecl ComponentClause.asComponentDecl(PN_ComponentDecl name,
     380            java.util.List<SiblingComponentDecl> siblings) {
     381
     382        List<Subscript> as = name.hasVarArraySubscripts() ? name.getVarArraySubscripts().getSubscriptList() :
     383                new List<Subscript>();
     384
     385        if (hasTypeArraySubscripts()) {
     386            for (int i = 0; i < getTypeArraySubscripts().getNumSubscript(); i++) {
     387                as.add(getTypeArraySubscripts().getSubscript(i));
     388            }
     389        }
     390
     391        ComponentDecl c = null;
     392        if (siblings == null) {
     393            c = new ComponentDecl();
     394        } else {
     395            SiblingComponentDecl sc = new SiblingComponentDecl();
     396            sc.setSiblings(siblings);
     397            siblings.add(sc);
     398            c = sc;
     399        }
     400
     401        if (as.getNumChild() > 0) {
     402            c.setVarArraySubscripts(new ArraySubscripts(as));
     403        }
     404
     405        c.setRedeclareOpt(getRedeclareOpt().fullCopy());
     406        c.setFinalOpt(getFinalOpt().fullCopy());
     407        c.setInnerOpt(getInnerOpt().fullCopy());
     408        c.setOuterOpt(getOuterOpt().fullCopy());
     409        c.setReplaceableOpt(getReplaceableOpt().fullCopy());
     410        c.setTypePrefixFlowOpt(getTypePrefixFlowOpt().fullCopy());
     411        c.setTypePrefixVariabilityOpt(getTypePrefixVariabilityOpt().fullCopy());
     412        c.setTypePrefixInputOutputOpt(getTypePrefixInputOutputOpt().fullCopy());
     413        c.setClassName(getClassName().fullCopy());
     414        c.setVisibilityType(getVisibilityType().fullCopy());
     415        c.setName(name.getName());
     416        c.setModificationOpt(name.getModificationOpt());
     417        c.setConditionalAttributeOpt(name.getConditionalAttributeOpt());
     418        c.setComment(name.getComment());
     419        c.setConstrainingClauseOpt( getConstrainingClauseOpt().fullCopy());
     420        c.setCCComment(getComment());
     421        c.setLocationNoTree(this, this, name);
     422
     423        return c;
     424    }
    423425
    424426    rewrite ComponentModification {
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/util/Util.jrag

    r9609 r9628  
    262262aspect NodeMethods {
    263263
     264    /**
     265     * Implementing {@link ASTNode#iterator()} is required as of JastAdd 2.2.0.
     266     */
    264267    public class ASTNode<T extends ASTNode> implements Iterable<T> {
    265268        @Override
     
    388391        return dump() + ": '" + getComponentDecl().getClassName().qualifiedName() + " " + getComponentDecl().getName().getID() + "'";
    389392    }
    390    
    391    
    392     public class List {
    393        
     393
     394    public class List {
     395
    394396        /**
    395397         * Creates a new ArrayList containing all the elements in this list, in the same order.
     
    537539        }
    538540       
     541    }
     542
     543}
     544
     545/**
     546 * Utility methods.
     547 */
     548aspect Utility {
     549
     550    /**
     551     * Utility methods available from every class.
     552     */
     553    public class ASTNode {
     554        /**
     555         * Returns the intersection of two sets.
     556         *
     557         * @param a
     558         *          A set.
     559         * @param b
     560         *          A set.
     561         * @return
     562         *          A set containing elements that exist in both {@code a} and {@code b}.
     563         */
     564        public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
     565            // TODO: use runtime type of a instead - problematic if it is something like HashMap.KeySet.
     566            Set<T> res = new HashSet<T>();
     567            res.addAll(a);
     568            res.retainAll(b);
     569            return res;
     570        }
     571
     572        /**
     573         * Short-hand method for sorting a collection.
     574         *
     575         * @param elems
     576         *          The elements to sort.
     577         * @param cmp
     578         *          The {@link Comparator} to use when calculating the ordering of {@code elems}.
     579         */
     580        public static <T> ArrayList<T> toSortedList(Collection<T> elems, Comparator<? super T> cmp) {
     581            ArrayList<T> res = new ArrayList<T>(elems.size());
     582            res.addAll(elems);
     583            Collections.sort(res, cmp);
     584            return res;
     585        }
     586
    539587    }
    540588
  • trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/munkres/IntegerCost.java

    r8627 r9628  
    6565        for (int j = 0; j < values.length; j++) {
    6666            costs[j] = new IntegerCost[values[j].length];
    67             for (int i = 0; i < values.length; i++)
     67            for (int i = 0; i < values[j].length; i++)
    6868                costs[j][i] = new IntegerCost(values[j][i]);
    6969        }
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/TransformCanonical.jrag

    r9620 r9628  
    8383     */
    8484    public void FClass.transformCanonicalBase() {
    85         for (Transformation t : getTransformations())
     85        for (Transformation t : getTransformations()) {
    8686            t.apply();
     87        }
    8788    }
    8889
     
    22962297            && getLeft().asFIdUseExp().myFV() == getRight().asFIdUseExp().myFV()
    22972298            && !getLeft().asFIdUseExp().myFV().isUnknown();
    2298    
    2299 }
    2300 
    2301 aspect IfEquations {
    2302 
    2303     /*
    2304      *  TODO: We shouldn't need this now that scalarization can do this anyway.
    2305      *        Just removing it and making obviously necessary changes causes lots of tests to fail.
    2306      */
    2307 
    2308     /*
    2309      * First rewrite those if equations that has constant or stuctural parameter test
    2310      * by evaluating the expressions and eliminating unreachable branches.
    2311      */
    2312    
    2313     public class FClass {
    2314         public class enableIfEquationElimination extends Transformation {
    2315             // Depends on MakeReinitedVarsStates when invoked after scalarize
    2316            
    2317             public void perform() {
    2318                 enableIfEquationElimination();
    2319                
    2320                 // Workaround for JastAdd bug
    2321                 setFInitialEquationList(cleanEmptyElse(getFInitialEquations()));
    2322                 setFAbstractEquationList(cleanEmptyElse(getFAbstractEquations()));
    2323                
    2324                 // Remove orphaned temporaries
    2325                 flushAllRecursive();
    2326                 removeUnusedTemporaries();
    2327             }
    2328         }
    2329     }
    2330 
    2331     public void ASTNode.enableIfEquationElimination() {
    2332         for (ASTNode n : this)
    2333             n.enableIfEquationElimination();
    2334     }
    2335    
    2336     public void FIfEquation.enableIfEquationElimination() {
    2337         super.enableIfEquationElimination();
    2338         eliminateIfEquation = true;
    2339         is$Final = false;
    2340     }
    2341    
    2342     public void FIfExp.enableIfEquationElimination() {
    2343         super.enableIfEquationElimination();
    2344         eliminateIfEquation = true;
    2345         is$Final = false;
    2346     }
    2347    
    2348     private boolean FIfEquation.eliminateIfEquation = false;
    2349     private boolean FIfExp.eliminateIfEquation = false;
    2350 
    2351     syn boolean FIfEquation.shouldEliminateIf() = getTest().isConstantExp();
    2352    
    2353     rewrite FIfEquation {
    2354         when (eliminateIfEquation) to FIfWhenElseEquation {
    2355             eliminateIfEquation = false;
    2356            
    2357             if (shouldEliminateIf()) {
    2358                 try {
    2359                     if (getTest().ceval().booleanValue())
    2360                         return new FElseEquation(getType(), getFAbstractEquations());
    2361                     else if (hasElse())
    2362                         return getElse();
    2363                     else
    2364                         return new FElseEquation(getType(), new List());
    2365                 } catch (ConstantEvaluationException e) {}
    2366             }
    2367            
    2368             return this;
    2369         }   
    2370     }
    2371    
    2372     rewrite FIfExp {
    2373         when (eliminateIfEquation) to FExp {
    2374             eliminateIfEquation = false;
    2375            
    2376             try {
    2377                 if (getIfExp().isConstantExp())
    2378                     return getIfExp().ceval().booleanValue() ? getThenExp() : getElseExp();
    2379             } catch (ConstantEvaluationException e) {}
    2380            
    2381             return this;
    2382         }
    2383     }
    2384 
    2385     rewrite FElseEquation in FClass.getFInitialEquation() {
    2386         when (getNumFAbstractEquation() > 0) to List getFAbstractEquations();
    2387     }   
    2388    
    2389     rewrite FElseEquation in FClass.getFParameterEquation() {
    2390         when (getNumFAbstractEquation() > 0) to List getFAbstractEquations();
    2391     }
    2392    
    2393     rewrite FElseEquation in FClass.getFAbstractEquation() {
    2394         when (getNumFAbstractEquation() > 0) to List getFAbstractEquations();
    2395     }   
    2396    
    2397     rewrite FElseEquation in FIfWhenElseEquation.getFAbstractEquation() {
    2398         when (getNumFAbstractEquation() > 0) to List getFAbstractEquations();
    2399     }   
    2400            
    2401     rewrite FElseEquation in FForClauseE.getFAbstractEquation() {
    2402         when (getNumFAbstractEquation() > 0) to List getFAbstractEquations();
    2403     }
    2404 
    2405     /*
    2406      * After we have eliminated if equations with constant (and possibly parameter)
    2407      * test expressions, then all if equations must be balanced, so we can rewrite to
    2408      * a list of residual equations with if expressions.
    2409      */
    2410 
    2411     public void ASTNode.enableIfEquationRewrite() {
    2412         for (ASTNode n : this)
    2413             n.enableIfEquationRewrite();
    2414     }
    2415 
    2416     public class FClass {
    2417         public class enableIfEquationRewrite extends Transformation {
    2418             public void perform() {
    2419                 enableIfEquationRewrite();
    2420                 checkIfEquationCompliance();
    2421             }
    2422         }
    2423     }
    2424    
    2425     public void FIfEquation.enableIfEquationRewrite() {
    2426         super.enableIfEquationRewrite();
    2427         rewriteIfEquation = true;
    2428         is$Final = false;
    2429     }
    2430    
    2431     private boolean FIfEquation.rewriteIfEquation = false;
    2432    
    2433     public void ASTNode.checkIfEquationCompliance() {
    2434         for (ASTNode n : this)
    2435             n.checkIfEquationCompliance();
    2436     }
    2437    
    2438     public void FIfEquation.checkIfEquationCompliance() {
    2439         int numAssigned = referencedFVariablesInLHS().size();
    2440         int numEqs = numScalarEquations();
    2441         if (numAssigned != numEqs)
    2442             compliance("If equations that has non-parameter tests and contains function calls using multiple " +
    2443                     "outputs must assign the same variables in all branches");
    2444     }
    2445 
    2446     syn Map<FAbstractVariable,FEquation> FIfWhenElseEquation.assignmentEquationMap() {
    2447         calcAssignmentEquations();
    2448         return assignmentEquationMap;
    2449     }
    2450    
    2451     syn Set<FEquation> FIfWhenElseEquation.nonAssignmentEquationSet() {
    2452         calcAssignmentEquations();
    2453         return nonAssignmentEquationSet;
    2454     }
    2455    
    2456     syn Set<FAbstractEquation> FIfWhenElseEquation.nonFEquationSet() {
    2457         calcAssignmentEquations();
    2458         return nonFEquationSet;
    2459     }
    2460    
    2461     private Map<FAbstractVariable,FEquation> FIfWhenElseEquation.assignmentEquationMap = null;
    2462     private Set<FEquation> FIfWhenElseEquation.nonAssignmentEquationSet = null;
    2463     private Set<FAbstractEquation> FIfWhenElseEquation.nonFEquationSet = null;
    2464    
    2465     private void FIfWhenElseEquation.calcAssignmentEquations() {
    2466         if (assignmentEquationMap == null || nonAssignmentEquationSet == null || nonFEquationSet == null) {
    2467             assignmentEquationMap = new HashMap<FAbstractVariable,FEquation>();
    2468             nonAssignmentEquationSet = new HashSet<FEquation>();
    2469             nonFEquationSet = new HashSet<FAbstractEquation>();
    2470             for (FAbstractEquation eqn : getFAbstractEquations()) {
    2471                 if (eqn instanceof FEquation) {
    2472                     FEquation feqn = (FEquation) eqn;
    2473                     FAbstractVariable var = feqn.assignedFV();
    2474                     if (var != null && !assignmentEquationMap.containsKey(var))
    2475                         assignmentEquationMap.put(var, feqn);
    2476                     else
    2477                         nonAssignmentEquationSet.add(feqn);
    2478                 } else {
    2479                     nonFEquationSet.add(eqn);
    2480                 }
    2481             }
    2482         }
    2483     }
    2484    
    2485 
    2486     syn FExp FAbstractEquation.createResidualExp() = null;
    2487     eq FEquation.createResidualExp() {
    2488         if (getLeft().isZeroLiteral())
    2489             return getRight().fullCopy();
    2490         if (getRight().isZeroLiteral())
    2491             return getLeft().fullCopy();
    2492         return new FSubExp(getLeft().fullCopy(), getRight().fullCopy());
    2493     }
    2494    
    2495     // TODO: move to better suited source file
    2496     syn boolean FExp.isZeroLiteral()  = false;
    2497     eq FIntegerLitExp.isZeroLiteral() = getValue() == 0;
    2498     eq FRealLitExp.isZeroLiteral()    = getValue() == 0.0;
    2499     eq FArray.isZeroLiteral() {
    2500         for (FExp e : getFExps())
    2501             if (!e.isZeroLiteral())
    2502                 return false;
    2503         return true;
    2504     }
    2505    
    2506     syn FExp FAbstractEquation.assignmentExp() = null;
    2507     eq FEquation.assignmentExp() =
    2508         isAssignmentEqn() ? getRight() : null; 
    2509    
    2510 
    2511    
    2512     public static List<FAbstractEquation> ASTNode.cleanEmptyElse(List<FAbstractEquation> oldList) {
    2513         List<FAbstractEquation> newList = new List<FAbstractEquation>();
    2514         for (FAbstractEquation eqn : oldList)
    2515             if (!(eqn instanceof FElseEquation))
    2516                 newList.add(eqn);
    2517         return newList;
    2518     }
    2519    
    2520     public void FIfWhenElseEquation.cleanEmptyElse() {
    2521         setFAbstractEquationList(cleanEmptyElse(getFAbstractEquations()));
    2522     }
    2523    
    2524     public void FIfWhenEquation.cleanEmptyElse() {
    2525         super.cleanEmptyElse();
    2526         if (hasElse())
    2527             getElse().cleanEmptyElse();
    2528     }
    2529    
    2530     // TODO: Move to util
    2531     public class ASTNode {
    2532        
    2533         public static <K, V> Set<V> valuesOfUnNamedKeys(Map<K, V> map, Set<K> namedKeys) {
    2534             Set<V> res = new HashSet<V>();
    2535             for (Map.Entry<K,V> e : map.entrySet())
    2536                 if (!namedKeys.contains(e.getKey()))
    2537                     res.add(e.getValue());
    2538             return res;
    2539         }
    2540        
    2541         public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
    2542             // TODO: use runtime type of a instead - problematic if it is something like HashMap.KeySet
    2543             Set<T> res = new HashSet<T>();
    2544             res.addAll(a);
    2545             res.retainAll(b);
    2546             return res;
    2547         }
    2548        
    2549         public static <T> ArrayList<T> toSortedList(Collection<T> elems, Comparator<? super T> cmp) {
    2550             ArrayList<T> res = new ArrayList<T>(elems.size());
    2551             res.addAll(elems);
    2552             Collections.sort(res, cmp);
    2553             return res;
    2554         }
    2555        
    2556     }
    2557    
    2558     protected static ArrayList<FEquation> FIfEquation.unmatchedEquations(
    2559             FIfWhenElseEquation ifEqn, Set<FAbstractVariable> varsInBoth) {
    2560         Set<FEquation> unMatchedAssign =
    2561             valuesOfUnNamedKeys(ifEqn.assignmentEquationMap(), varsInBoth);
    2562         unMatchedAssign.addAll(ifEqn.nonAssignmentEquationSet());
    2563         return toSortedList(unMatchedAssign, CHILD_ORDER_COMPARATOR);
    2564     }
    2565    
    2566     private int[][] FIfEquation.matchEquationsMinimizeIncidences(ArrayList<FEquation> left, ArrayList<FEquation> right) {
    2567         int nl = left.size();
    2568         int nr = right.size();
    2569         if (nl == 0 || nr == 0)
    2570             return new int[0][0];
    2571         int[][] weights = new int[nl][nr];
    2572         for (int i = 0; i < nl; i++) {
    2573             for (int j = 0; j < nr; j++) {
    2574                 Set<String> rightVars = right.get(j).referencedVariablesAsStrings();
    2575                 weights[i][j] = rightVars.size();
    2576                 for (String var : left.get(i).referencedVariablesAsStrings())
    2577                     weights[i][j] += rightVars.contains(var) ? -1 : 1;
    2578             }
    2579         }
    2580         return new DenseMunkresProblem(IntegerCost.create(weights)).solve();
    2581     }
    2582    
    2583     private void FIfEquation.sortOutMatchedEquations(ArrayList<FEquation> eqns, int[][] match, int col,
    2584             ArrayList<FEquation> matched, List<FAbstractEquation> remaining) {
    2585         int n = eqns.size();
    2586         boolean used[] = new boolean[n];
    2587         for (int i = 0; i < match.length; i++) {
    2588             matched.add(eqns.get(match[i][col]));
    2589             used[match[i][col]] = true;
    2590         }
    2591         for (int i = 0; i < n; i++)
    2592             if (!used[i])
    2593                 remaining.add(eqns.get(i));
    2594     }
    2595 
    2596     syn List FIfEquation.createIfExpEquationList() {
    2597         List<FAbstractEquation> l = new List<FAbstractEquation>();
    2598        
    2599         // Generate equations for assignment equations that can be matched
    2600         Set<FAbstractVariable> varsInBoth = assignmentEquationMap().keySet();
    2601         if (hasElse())
    2602             varsInBoth = intersection(varsInBoth, getElse().assignmentEquationMap().keySet());
    2603         for (FAbstractVariable v : toSortedList(varsInBoth, FAbstractVariable.NAME_COMPARATOR)) {
    2604             FExp left = assignmentEquationMap().get(v).assignmentExp().fullCopy();
    2605             FExp right = getElse().assignmentEquationMap().get(v).assignmentExp().fullCopy();
    2606             FIfExp ifExp = new FIfExp(getTest().fullCopy(), left, right);
    2607             FEquation e = new FEquation(getType().fullCopy(), v.createUseExp(), ifExp);
    2608             if (isWhen()) {
    2609                 ifExp.setWhen();
    2610                 e.setWhen();
    2611             }
    2612             l.add(e);
    2613         }
    2614        
    2615         // Find equations to match up among remaining FEquations based on indices
    2616         ArrayList<FEquation> unmatchedLeft = unmatchedEquations(this, varsInBoth);
    2617         ArrayList<FEquation> unmatchedRight;
    2618         if (hasElse())
    2619             unmatchedRight = unmatchedEquations(getElse(), varsInBoth);
    2620         else
    2621             unmatchedRight = new ArrayList<FEquation>();
    2622        
    2623         int[][] match = matchEquationsMinimizeIncidences(unmatchedLeft, unmatchedRight);
    2624        
    2625         // Sort remaining equations into those that should remain in if equation and those that should become residual eqns
    2626         // Left side
    2627         ArrayList<FEquation> residualLeft = new ArrayList<FEquation>();
    2628         List<FAbstractEquation> keepLeft = new List<FAbstractEquation>();
    2629         sortOutMatchedEquations(unmatchedLeft, match, 0, residualLeft, keepLeft);
    2630         keepLeft.addAll(toSortedList(nonFEquationSet(), CHILD_ORDER_COMPARATOR));
    2631         // Right side
    2632         ArrayList<FEquation> residualRight = new ArrayList<FEquation>();
    2633         List<FAbstractEquation> keepRight = new List<FAbstractEquation>();
    2634         sortOutMatchedEquations(unmatchedRight, match, 1, residualRight, keepRight);
    2635         if (hasElse())
    2636             keepRight.addAll(toSortedList(getElse().nonFEquationSet(), CHILD_ORDER_COMPARATOR));
    2637        
    2638         // Generate residual equations
    2639         for (FEquation[] eqs : new ParallelIterable<FEquation>(new FEquation[2], true, residualLeft, residualRight)) {
    2640             FExp left = eqs[0].createResidualExp();
    2641             FExp right = eqs[1].createResidualExp();
    2642             FIfExp ifExp = new FIfExp(getTest().fullCopy(), left, right);
    2643             l.add(new FEquation(getType().fullCopy(), eqs[0].type().zeroLiteral(), ifExp));
    2644         }
    2645        
    2646         // Generate new if equation with remaining equations
    2647         FIfEquation e;
    2648         if (keepLeft.getNumChild() > 0) {
    2649             Opt<FIfWhenElseEquation> elseOpt = new Opt<FIfWhenElseEquation>();
    2650             if (keepRight.getNumChild() > 0)
    2651                 elseOpt.addChild(new FElseEquation(getType().fullCopy(), keepRight));
    2652             e = new FIfEquation(getType().fullCopy(), keepLeft, getTest(), elseOpt);
    2653             copyFlagsTo(e);
    2654             l.add(e);
    2655         } else if (keepRight.getNumChild() > 0) {
    2656             e = new FIfEquation(getType().fullCopy(), keepRight, new FNotExp(getTest()), new Opt());
    2657             copyFlagsTo(e);
    2658             l.add(e);
    2659         }
    2660        
    2661         return l;
    2662     }
    2663    
    2664     public void FIfEquation.copyFlagsTo(FIfEquation e) {
    2665         if (isTempAssign()) {
    2666             e.setIsTempAssign();
    2667         }
    2668         if (isWhen()) {
    2669             e.setWhen();
    2670         }
    2671     }
    2672    
    2673     syn boolean FAbstractEquation.allowGlobalOnIfRewrite() = false;
    2674     eq FFunctionCallEquation.allowGlobalOnIfRewrite()      = getNumLeft() > 0;
    2675    
    2676     rewrite FIfEquation {
    2677         when (rewriteIfEquation)
    2678         to FElseEquation new FElseEquation(getType(), createIfExpEquationList());
    2679     }
    26802299
    26812300}
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/VariabilityPropagation.jrag

    r9440 r9628  
    670670        }
    671671    }
    672    
     672
    673673    public void FPartialFunctionCall.enableConstantFolding() {
    674674        for (ASTNode n : this)
    675675            n.enableConstantFolding();
    676676    }
    677    
    678     public void FIfExp.enableConstantFolding() {
    679         super.enableConstantFolding();
     677
     678    public void FIfExp.enableConstantFolding() {
     679        super.enableConstantFolding();
    680680        if (!constantFoldingEnabled && getIfExp().variability().knownParameterOrLess()) {
    681             eliminateIfEquation = true;
    682             is$Final = false;
    683         }
    684     }
    685    
     681            rewriteIfExp = true;
     682            is$Final = false;
     683        }
     684    }
     685
     686    private boolean FIfExp.rewriteIfExp = false;
     687
     688    rewrite FIfExp {
     689        when (rewriteIfExp) to FExp {
     690            rewriteIfExp = false;
     691
     692            try {
     693                if (getIfExp().isConstantExp()) {
     694                    return getIfExp().ceval().booleanValue() ? getThenExp() : getElseExp();
     695                }
     696            } catch (ConstantEvaluationException e) {}
     697                return this;
     698            }
     699    }
     700
    686701    public void FAbstractExp.enableConstantFolding() {
    687702        if (variability().knownParameterOrLess()) {
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/TransformCanonicalTests.mo

    r9530 r9628  
    45164516      end if;
    45174517
    4518     annotation(__JModelica(UnitTesting(tests={
    4519         TransformCanonicalTestCase(
    4520             name="IfEqu16",
    4521             description="Nestled if equations with mixed assignment equations and non-assignment equations",
    4522             flatModel="
     4518  annotation(__JModelica(UnitTesting(tests={
     4519    TransformCanonicalTestCase(
     4520      name="IfEqu16",
     4521      description="Nested if equations with mixed assignment equations and non-assignment equations",
     4522      flatModel="
    45234523fclass TransformCanonicalTests.IfEqu16
    45244524 Real x;
Note: See TracChangeset for help on using the changeset viewer.