Changeset 2290


Ignore:
Timestamp:
Jan 26, 2007, 1:53:31 AM (14 years ago)
Author:
roman
Message:

Lazy expansion of &N.

Location:
devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ConsoleMsgHandler.java

    r2279 r2290  
    1212                case Info:
    1313                        severity = "INFO";
     14                        break;
    1415                case Error:
    1516                        severity = "ERROR";
     17                        break;
    1618                case Warning:
    1719                        severity = "WARNING";
     20                        break;
    1821                default:
    19                         assert false;
    20                         severity = "UNKNOWN";
     22                        throw new IllegalArgumentException();
    2123                }
    2224                System.out.printf("%s(%d, %d): %s: ", pos.fileName, pos.line,
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FormatMatcher.java

    r2285 r2290  
    22
    33import java.util.ArrayDeque;
     4import java.util.ArrayList;
    45import java.util.Deque;
     6import java.util.List;
    57
    68import org.refal.plus.comp.TkAttributes.VarType;
     
    1921import org.refal.plus.comp.ast.AstWordSymbol;
    2022
    21 public class FormatMatcher {
    22 
    23         static Deque<AstTerm> expandTopLevel(AstExp astExp) {
    24                 Deque<AstTerm> terms = new ArrayDeque<AstTerm>();
    25                 for (AstTerm astTerm : astExp.termList) {
    26                         if (astTerm instanceof AstCall) {
    27                                 AstCall astCall = (AstCall) astTerm;
    28                                 if (astCall.funcDecl != null)
    29                                         terms.addAll(astCall.funcDecl.outFormat.termList);
    30                         } else if (astTerm instanceof AstRef) {
    31                                 AstRef astRef = (AstRef) astTerm;
    32                                 AstDecl astDecl = astRef.decl;
    33                                 if (astDecl instanceof AstConstBinding) {
    34                                         AstConstBinding astConstBinding = (AstConstBinding) astDecl;
    35                                         terms.addAll(astConstBinding.exp.termList);
    36                                 }
    37                                 else {
    38                                         terms.addLast(new AstRefSymbol(astRef));
    39                                 }
     23public final class FormatMatcher {
     24
     25        private static void addAllBefore(List<AstTerm> list, Deque<AstTerm> e) {
     26                int i = list.size();
     27                while (i > 0) {
     28                        i--;
     29                        e.addFirst(list.get(i));
     30                }
     31        }
     32
     33        static boolean covers(AstExp format, AstExp exp) {
     34                FormatMatcher matcher = new FormatMatcher(format, exp);
     35                return matcher.match();
     36        }
     37
     38        private static void expandFirstTerm(Deque<AstTerm> e) {
     39                AstTerm t = e.getFirst();
     40                List<AstTerm> list = expandTerm(t);
     41                if (list == null)
     42                        return;
     43                e.removeFirst();
     44                addAllBefore(list, e);
     45        }
     46
     47        private static void expandLastTerm(Deque<AstTerm> e) {
     48                AstTerm t = e.getLast();
     49                List<AstTerm> list = expandTerm(t);
     50                if (list == null)
     51                        return;
     52                e.removeLast();
     53                e.addAll(list);
     54        }
     55
     56        private static List<AstTerm> expandTerm(AstTerm astTerm) {
     57                if (astTerm instanceof AstCall) {
     58                        AstCall astCall = (AstCall) astTerm;
     59                        return astCall.funcDecl.outFormat.termList;
     60                } else if (astTerm instanceof AstRef) {
     61                        AstRef astRef = (AstRef) astTerm;
     62                        AstDecl astDecl = astRef.decl;
     63                        if (astDecl instanceof AstConstBinding) {
     64                                AstConstBinding astConstBinding = (AstConstBinding) astDecl;
     65                                return astConstBinding.exp.termList;
    4066                        } else {
    41                                 terms.add(astTerm);
    42                         }
    43                 }
    44                 return terms;
    45         }
    46 
    47         static boolean isHard(AstTerm t) {
     67                                List<AstTerm> list = new ArrayList<AstTerm>(1);
     68                                list.add(new AstRefSymbol(astRef));
     69                                return list;
     70                        }
     71                } else {
     72                        return null;
     73                }
     74        }
     75
     76        private static boolean hardCoversHard(AstTerm f, AstTerm e) {
     77                if (f instanceof AstSymbol) {
     78                        if (!(e instanceof AstSymbol))
     79                                return false;
     80                        else
     81                                return symbolCoversSymbol((AstSymbol) f, (AstSymbol) e);
     82                } else if (f instanceof AstParen) {
     83                        if (!(e instanceof AstParen))
     84                                return false;
     85                        else
     86                                return covers(((AstParen) f).exp, ((AstParen) e).exp);
     87                } else if (isVar(VarType.S, f)) {
     88                        return (e instanceof AstSymbol) || (isVar(VarType.S, e));
     89                } else if (isVar(VarType.T, f)) {
     90                        return true;
     91                } else {
     92                        throw new java.lang.IllegalArgumentException();
     93                }
     94        }
     95
     96        private static boolean isHard(AstTerm t) {
    4897                if (t instanceof AstSymbol)
    4998                        return true;
     
    57106        }
    58107
    59         static boolean isVar(VarType type, AstTerm astTerm) {
     108        private static boolean isTheSameRefAs(AstTerm f, AstTerm t) {
     109                if (f == t)
     110                        return true;
     111                if (t == null)
     112                        return false;
     113                if (f instanceof AstRef) {
     114                        return (t instanceof AstRef)
     115                                        && ((AstRef) f).decl == ((AstRef) t).decl;
     116                }
     117                return false;
     118        }
     119
     120        private static boolean isVar(VarType type, AstTerm astTerm) {
    60121                if (!(astTerm instanceof AstVar))
    61122                        return false;
     
    64125        }
    65126
    66         static boolean mayBeEmpty(Deque<AstTerm> e) {
    67                 for (AstTerm t : e) {
    68                         if (!isVar(VarType.E, t))
    69                                 return false;
    70                 }
    71                 return true;
    72         }
    73 
    74         static boolean symbolCoversSymbol(AstSymbol f, AstSymbol e) {
     127        private static boolean symbolCoversSymbol(AstSymbol f, AstSymbol e) {
    75128                if (f instanceof AstCharSymbol) {
    76129                        if (!(e instanceof AstCharSymbol))
     
    91144                        return ((AstWordSymbol) f).word.equals(((AstWordSymbol) e).word);
    92145                } else {
    93                         assert false;
    94                         return false;
    95                 }
    96         }
    97 
    98         static boolean hardCoversHard(AstTerm f, AstTerm e) {
    99                 if (f instanceof AstSymbol) {
    100                         if (!(e instanceof AstSymbol))
    101                                 return false;
    102                         else
    103                                 return symbolCoversSymbol((AstSymbol) f, (AstSymbol) e);
    104                 } else if (f instanceof AstParen) {
    105                         if (!(e instanceof AstParen))
    106                                 return false;
    107                         else
    108                                 return FormatMatcher.covers(((AstParen) f).exp, ((AstParen) e).exp);
    109                 } else if (isVar(VarType.S, f)) {
    110                         return (e instanceof AstSymbol) || (isVar(VarType.S, e));
    111                 } else if (isVar(VarType.T, f)) {
    112                         return true;
    113                 } else {
    114                         assert false;
    115                         return false;
    116                 }
    117         }
    118 
    119         static boolean covers(Deque<AstTerm> f, Deque<AstTerm> e) {
    120                 for (;;) {
    121                         if (f.isEmpty())
    122                                 break;
    123                         AstTerm firstF = f.getFirst();
     146                        throw new IllegalArgumentException();
     147                }
     148        }
     149
     150        final private Deque<AstTerm> exp;
     151
     152        final private Deque<AstTerm> format;
     153
     154        FormatMatcher(AstExp format, AstExp exp) {
     155                this.format = new ArrayDeque<AstTerm>(format.termList);
     156                this.exp = new ArrayDeque<AstTerm>(exp.termList);
     157        }
     158
     159        private boolean expIsEmpty() {
     160                for (;;) {
     161                        if (exp.isEmpty())
     162                                return true;
     163                        for (AstTerm t : exp) {
     164                                if (!(t instanceof AstCall) && !(t instanceof AstRef))
     165                                        return false;
     166                        }
     167                        expandFirstTerm(exp);
     168                }
     169        }
     170
     171        private boolean expMayBeEmpty() {
     172                for (;;) {
     173                        if (exp.isEmpty())
     174                                return true;
     175
     176                        if( isVar(VarType.E, exp.getFirst())){
     177                                exp.remove();
     178                                continue;
     179                        }
     180                       
     181                        for (AstTerm t : exp) {
     182                                if (!isExpandable(t) && !isVar(VarType.E, t))
     183                                        return false;
     184                        }
     185
     186                        if( isExpandable(exp.getFirst())) {
     187                                expandFirstTerm(exp);
     188                                continue;
     189                        }
     190                }
     191
     192        }
     193
     194        private boolean isExpandable(AstTerm t) {
     195                return (t instanceof AstCall) || (t instanceof AstRef);
     196        }
     197
     198        private boolean match() {
     199                for (;;) {
     200                        if (format.isEmpty())
     201                                break;
     202                        if (isTheSameRefAs(format.getFirst(), exp.peekFirst())) {
     203                                format.removeFirst();
     204                                exp.removeFirst();
     205                                continue;
     206                        }
     207                        if (format.getFirst() instanceof AstRef) {
     208                                expandFirstTerm(format);
     209                                continue;
     210                        }
     211                        if (isExpandable(exp.peekFirst())) {
     212                                expandFirstTerm(exp);
     213                                continue;
     214                        }
     215                        AstTerm firstF = format.getFirst();
    124216                        if (!isHard(firstF))
    125217                                break;
    126                         if (e.isEmpty())
    127                                 return false;
    128                         AstTerm firstE = e.getFirst();
     218                        if (exp.isEmpty())
     219                                return false;
     220                        AstTerm firstE = exp.getFirst();
    129221                        if (!hardCoversHard(firstF, firstE))
    130222                                return false;
    131                         f.removeFirst();
    132                         e.removeFirst();
    133                 }
    134        
    135                 for (;;) {
    136                         if (f.isEmpty())
    137                                 break;
    138                         AstTerm lastF = f.getLast();
     223                        format.removeFirst();
     224                        exp.removeFirst();
     225                }
     226
     227                for (;;) {
     228                        if (format.isEmpty())
     229                                break;
     230                        if (isTheSameRefAs(format.getLast(), exp.peekLast())) {
     231                                format.removeLast();
     232                                exp.removeLast();
     233                                continue;
     234                        }
     235                        if (format.getLast() instanceof AstRef) {
     236                                expandLastTerm(format);
     237                                continue;
     238                        }
     239                        if (isExpandable(exp.peekLast())) {
     240                                expandLastTerm(exp);
     241                                continue;
     242                        }
     243                        AstTerm lastF = format.getLast();
    139244                        if (!isHard(lastF))
    140245                                break;
    141                         if (e.isEmpty())
    142                                 return false;
    143                         AstTerm lastE = e.getLast();
     246                        if (exp.isEmpty())
     247                                return false;
     248                        AstTerm lastE = exp.getLast();
    144249                        if (!hardCoversHard(lastF, lastE))
    145250                                return false;
    146                         f.removeLast();
    147                         e.removeLast();
    148                 }
    149        
    150                 if (f.isEmpty())
    151                         return e.isEmpty();
    152        
    153                 assert f.size() == 1;
    154                 AstTerm fTerm = f.getFirst();
     251                        format.removeLast();
     252                        exp.removeLast();
     253                }
     254
     255                if (format.isEmpty())
     256                        return expIsEmpty();
     257
     258                assert format.size() == 1;
     259                AstTerm fTerm = format.getFirst();
    155260                assert fTerm instanceof AstVar;
    156261                AstVar fVar = (AstVar) fTerm;
    157262                if (fVar.type == VarType.V)
    158                         return !mayBeEmpty(e);
     263                        return !expMayBeEmpty();
    159264                assert fVar.type == VarType.E;
    160265                return true;
    161266        }
    162 
    163         static boolean covers(AstExp format, AstExp exp) {
    164                 return covers(expandTopLevel(format), expandTopLevel(exp));
    165         }
    166 
    167267}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgHandler.java

    r2279 r2290  
    1010
    1111        protected void updateCounters(MsgCode msgCode) {
    12                 if (msgCode.getSeverity() == MsgCode.Severity.Error)
    13                         errorCount++;
    1412                switch (msgCode.getSeverity()) {
    1513                case Info:
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstVar.java

    r2262 r2290  
    2424                        return VarType.V;
    2525                default:
    26                         assert false;
    27                         return null;
     26                        throw new IllegalArgumentException();
    2827                }
    2928        }
Note: See TracChangeset for help on using the changeset viewer.