Changeset 2264


Ignore:
Timestamp:
Jan 22, 2007, 1:16:16 AM (14 years ago)
Author:
roman
Message:

Format Checker

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

Legend:

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

    r2262 r2264  
    2828import org.refal.plus.comp.ast.AstPatternAlt;
    2929import org.refal.plus.comp.ast.AstRef;
     30import org.refal.plus.comp.ast.AstRefSymbol;
    3031import org.refal.plus.comp.ast.AstResultExp;
    3132import org.refal.plus.comp.ast.AstSentence;
     
    173174        }
    174175
     176        public void visit(AstRefSymbol astRefSymbol, Integer e) {
     177                throw new UnsupportedOperationException();
     178        }
     179
    175180        public void visit(AstSentence astSentence, Integer e) {
    176181                throw new UnsupportedOperationException();
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FormatChecker.java

    r2262 r2264  
    11package org.refal.plus.comp;
    22
     3import java.util.LinkedList;
     4
     5import org.refal.plus.comp.TkAttributes.VarType;
    36import org.refal.plus.comp.ast.AstAlt;
    47import org.refal.plus.comp.ast.AstAltMatch;
     
    2831import org.refal.plus.comp.ast.AstPatternAlt;
    2932import org.refal.plus.comp.ast.AstRef;
     33import org.refal.plus.comp.ast.AstRefSymbol;
    3034import org.refal.plus.comp.ast.AstResultExp;
    3135import org.refal.plus.comp.ast.AstSentence;
     36import org.refal.plus.comp.ast.AstSymbol;
     37import org.refal.plus.comp.ast.AstTerm;
     38import org.refal.plus.comp.ast.AstTopNode;
    3239import org.refal.plus.comp.ast.AstTraceAll;
    3340import org.refal.plus.comp.ast.AstTrap;
     
    3845public class FormatChecker implements VisitorWithEnv<AstExp> {
    3946
     47        private final MsgHandler msgHandler;
     48
     49        public FormatChecker(final MsgHandler msgHandler) {
     50                this.msgHandler = msgHandler;
     51        }
     52
     53        private static LinkedList<AstTerm> expandTopLevel(AstExp astExp) {
     54                LinkedList<AstTerm> list = new LinkedList<AstTerm>();
     55                for (AstTerm astTerm : astExp.termList) {
     56                        if (astTerm instanceof AstCall) {
     57                                AstCall astCall = (AstCall) astTerm;
     58                                if (astCall.funcDecl != null)
     59                                        list.addAll(astCall.funcDecl.outFormat.termList);
     60                        } else {
     61                                list.add(astTerm);
     62                        }
     63                }
     64                return list;
     65        }
     66
     67        private static boolean isVar(VarType type, AstTerm astTerm) {
     68                if (!(astTerm instanceof AstVar))
     69                        return false;
     70                AstVar astVar = (AstVar) astTerm;
     71                return astVar.type == type;
     72        }
     73
     74        private static boolean isHard(AstTerm t) {
     75                if (t instanceof AstSymbol)
     76                        return true;
     77                if (t instanceof AstParen)
     78                        return true;
     79                if (t instanceof AstVar) {
     80                        AstVar v = (AstVar) t;
     81                        return v.type == VarType.S || v.type == VarType.T;
     82                }
     83                return false;
     84        }
     85
     86        private static boolean symbolCoversSymbol(AstSymbol f, AstSymbol e) {
     87                if (f instanceof AstCharSymbol) {
     88                        if (!(e instanceof AstCharSymbol))
     89                                return false;
     90                        return ((AstCharSymbol) f).character == ((AstCharSymbol) e).character;
     91                } else if (f instanceof AstNumberSymbol) {
     92                        if (!(e instanceof AstNumberSymbol))
     93                                return false;
     94                        return ((AstNumberSymbol) f).bigInteger
     95                                        .equals(((AstNumberSymbol) e).bigInteger);
     96                } else if (f instanceof AstRefSymbol) {
     97                        if (!(e instanceof AstRefSymbol))
     98                                return false;
     99                        return ((AstRefSymbol) f).decl == ((AstRefSymbol) e).decl;
     100                } else if (f instanceof AstWordSymbol) {
     101                        if (!(e instanceof AstWordSymbol))
     102                                return false;
     103                        return ((AstWordSymbol) f).word.equals(((AstWordSymbol) e).word);
     104                } else {
     105                        assert false;
     106                        return false;
     107                }
     108        }
     109
     110        private static boolean hardCoversHard(AstTerm f, AstTerm e) {
     111                if (f instanceof AstSymbol) {
     112                        if (!(e instanceof AstSymbol))
     113                                return false;
     114                        else
     115                                return symbolCoversSymbol((AstSymbol) f, (AstSymbol) e);
     116                } else if (f instanceof AstParen) {
     117                        if (!(e instanceof AstParen))
     118                                return false;
     119                        else
     120                                return covers(((AstParen) f).exp, ((AstParen) e).exp);
     121                } else if (isVar(VarType.S, f)) {
     122                        return (e instanceof AstSymbol) || (isVar(VarType.S, e));
     123                } else if (isVar(VarType.T, f)) {
     124                        return true;
     125                } else {
     126                        assert false;
     127                        return false;
     128                }
     129        }
     130
     131        private static boolean mayBeEmpty(LinkedList<AstTerm> e) {
     132                for (AstTerm t : e) {
     133                        if (!isVar(VarType.E, t))
     134                                return false;
     135                }
     136                return true;
     137        }
     138
     139        private static boolean covers(LinkedList<AstTerm> f, LinkedList<AstTerm> e) {
     140                for (;;) {
     141                        if (f.isEmpty())
     142                                break;
     143                        AstTerm firstF = f.getFirst();
     144                        if (!isHard(firstF))
     145                                break;
     146                        if (e.isEmpty())
     147                                return false;
     148                        AstTerm firstE = e.getFirst();
     149                        if (!hardCoversHard(firstF, firstE))
     150                                return false;
     151                        f.removeFirst();
     152                        e.removeFirst();
     153                }
     154
     155                for (;;) {
     156                        if (f.isEmpty())
     157                                break;
     158                        AstTerm lastF = f.getLast();
     159                        if (!isHard(lastF))
     160                                break;
     161                        if (e.isEmpty())
     162                                return false;
     163                        AstTerm lastE = e.getLast();
     164                        if (!hardCoversHard(lastF, lastE))
     165                                return false;
     166                        f.removeLast();
     167                        e.removeLast();
     168                }
     169
     170                if (f.isEmpty())
     171                        return e.isEmpty();
     172
     173                assert f.size() == 1;
     174                AstTerm fTerm = f.getFirst();
     175                assert fTerm instanceof AstVar;
     176                AstVar fVar = (AstVar) fTerm;
     177                if (fVar.type == VarType.V)
     178                        return !mayBeEmpty(e);
     179                assert fVar.type == VarType.E;
     180                return true;
     181        }
     182
     183        private static boolean covers(AstExp format, AstExp exp) {
     184                return covers(expandTopLevel(format), expandTopLevel(exp));
     185        }
     186
     187        private void checkFormat(AstExp format, AstExp exp) {
     188                if (!covers(format, exp)) {
     189                        msgHandler.send(exp.pos, MsgCode.FormatMismatch);
     190                }
     191        }
     192
    40193        public void visit(AstAlt astAlt, AstExp e) {
    41                 for( AstPath astPath : astAlt.pathList ) {
     194                for (AstPath astPath : astAlt.pathList) {
    42195                        astPath.accept(this, e);
    43196                }
     
    45198
    46199        public void visit(AstAltMatch astAltMatch, AstExp e) {
    47                 // TODO Auto-generated method stub
    48                
     200                astAltMatch.patternAlt.accept(this, e);
    49201        }
    50202
    51203        public void visit(AstCall astCall, AstExp e) {
    52                 throw new UnsupportedOperationException();
     204                astCall.arg.accept(this, null);
     205                if (astCall.funcDecl != null)
     206                        checkFormat(astCall.funcDecl.inFormat, astCall.arg);
    53207        }
    54208
    55209        public void visit(AstCharSymbol astCharSymbol, AstExp e) {
    56                 throw new UnsupportedOperationException();
    57210        }
    58211
     
    61214
    62215        public void visit(AstCut astCut, AstExp e) {
    63                 // TODO Auto-generated method stub
    64                
     216                astCut.path.accept(this, e);
    65217        }
    66218
    67219        public void visit(AstCutAll astCutAll, AstExp e) {
    68                 // TODO Auto-generated method stub
    69                
     220                astCutAll.path.accept(this, e);
    70221        }
    71222
    72223        public void visit(AstError astError, AstExp e) {
    73                 // TODO Auto-generated method stub
    74                
     224                return;
    75225        }
    76226
    77227        public void visit(AstExp astExp, AstExp e) {
    78                 throw new UnsupportedOperationException();
     228                for (AstTerm astTerm : astExp.termList) {
     229                        astTerm.accept(this, null);
     230                }
     231
    79232        }
    80233
    81234        public void visit(AstFail astFail, AstExp e) {
    82                 // TODO Auto-generated method stub
    83                
     235                return;
    84236        }
    85237
    86238        public void visit(AstFence astFence, AstExp e) {
    87                 // TODO Auto-generated method stub
    88                
     239                astFence.path.accept(this, e);
    89240        }
    90241
     
    93244
    94245        public void visit(AstFuncDef astFuncDef, AstExp e) {
    95                 // TODO Auto-generated method stub
    96                
     246                AstFuncDecl decl = astFuncDef.funcDecl;
     247                if (decl == null)
     248                        return;
     249                for (AstSentence astSentence : astFuncDef.body.sentenceList) {
     250                        checkFormat(decl.inFormat, astSentence.pattern.exp);
     251                }
     252                astFuncDef.body.accept(this, decl.outFormat);
    97253        }
    98254
    99255        public void visit(AstImplem astImplem, AstExp e) {
    100                 // TODO Auto-generated method stub
    101                
     256                for (AstTopNode astTopNode : astImplem.topNodes)
     257                        astTopNode.accept(this, null);
    102258        }
    103259
     
    107263
    108264        public void visit(AstIter astIter, AstExp e) {
    109                 // TODO Auto-generated method stub
    110                
     265                astIter.source1.accept(this, astIter.target);
     266                astIter.source2.accept(this, astIter.target);
     267                astIter.rest.accept(this, e);
    111268        }
    112269
    113270        public void visit(AstLet astLet, AstExp e) {
    114                 // TODO Auto-generated method stub
    115                
     271                astLet.source.accept(this, astLet.target);
     272                astLet.rest.accept(this, e);
    116273        }
    117274
    118275        public void visit(AstMatch astMatch, AstExp e) {
    119                 // TODO Auto-generated method stub
    120                
     276                astMatch.sentence.accept(this, e);
    121277        }
    122278
    123279        public void visit(AstName astName, AstExp e) {
    124                 throw new UnsupportedOperationException();
    125280        }
    126281
    127282        public void visit(AstNot astNot, AstExp e) {
    128                 // TODO Auto-generated method stub
    129                
     283                astNot.source.accept(this, new AstExp());
     284                astNot.rest.accept(this, e);
    130285        }
    131286
    132287        public void visit(AstNumberSymbol astNumberSymbol, AstExp e) {
    133                 throw new UnsupportedOperationException();
    134288        }
    135289
     
    138292
    139293        public void visit(AstParen astParen, AstExp e) {
    140                 throw new UnsupportedOperationException();
     294                astParen.exp.accept(this, null);
    141295        }
    142296
     
    146300
    147301        public void visit(AstPatternAlt astPatternAlt, AstExp e) {
    148                 // TODO Auto-generated method stub
    149                
     302                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     303                        astSentence.accept(this, e);
     304                }
    150305        }
    151306
    152307        public void visit(AstRef astRef, AstExp e) {
    153                 throw new UnsupportedOperationException();
     308        }
     309
     310        public void visit(AstRefSymbol astRefSymbol, AstExp e) {
    154311        }
    155312
    156313        public void visit(AstResultExp astResultExp, AstExp e) {
    157                 // TODO Auto-generated method stub
    158                
     314                checkFormat(e, astResultExp.exp);
    159315        }
    160316
    161317        public void visit(AstSentence astSentence, AstExp e) {
    162                 throw new UnsupportedOperationException();
     318                astSentence.rest.accept(this, e);
    163319        }
    164320
     
    167323
    168324        public void visit(AstTrap astTrap, AstExp e) {
    169                 // TODO Auto-generated method stub
    170                
     325                astTrap.path.accept(this, e);
     326                astTrap.patternAlt.accept(this, e);
    171327        }
    172328
    173329        public void visit(AstVar astVar, AstExp e) {
    174                 throw new UnsupportedOperationException();
    175330        }
    176331
    177332        public void visit(AstWordSymbol astWordSymbol, AstExp e) {
    178                 throw new UnsupportedOperationException();
    179333        }
    180334
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgCode.java

    r2255 r2264  
    1111        ExceptionThrown(Severity.Error, "Exception thrown: %s"), //
    1212        ExpectedConstructs(Severity.Error, "Expected constructs: %s"), //
     13        FormatMismatch(Severity.Error, "Format mismatch"), //
    1314        Function_X_IsNotDeclared(Severity.Error, "Function %s is not declared"), //
    1415        InvalidCharacter(Severity.Error, "Invalid character"), //
     
    3637        Variable_X_IsNotDefined(Severity.Error, "Variable %s is not defined"), //
    3738        WrongSyntax(Severity.Error, "Wrong syntax"), //
    38         X_IsNotAFunction(Severity.Error, "%s is not a function");
     39        X_IsNotAFunction(Severity.Error, "%s is not a function") //
     40        ;
    3941
    4042        public static enum Severity {
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/NameChecker.java

    r2253 r2264  
    3232import org.refal.plus.comp.ast.AstPatternAlt;
    3333import org.refal.plus.comp.ast.AstRef;
     34import org.refal.plus.comp.ast.AstRefSymbol;
    3435import org.refal.plus.comp.ast.AstResultExp;
    3536import org.refal.plus.comp.ast.AstSentence;
     
    6263
    6364        private void expandNames(AstExp astExp) {
    64                 ArrayList<AstTerm> termList = astExp.astTermList;
     65                ArrayList<AstTerm> termList = astExp.termList;
    6566
    6667                int i = termList.size();
     
    6869                        i--;
    6970                        AstExp exp = getNameExpansion(termList.get(i));
    70                         if (exp != null){
     71                        if (exp != null) {
    7172                                termList.remove(i);
    72                                 termList.addAll(i, exp.astTermList);
     73                                termList.addAll(i, exp.termList);
    7374                        }
    7475                }
     
    9495                        return null;
    9596                AstRef astRef = (AstRef) astTerm;
    96                 if (!(astRef.decl instanceof AstConstBinding))
    97                         return null;
    98                 return ((AstConstBinding) astRef.decl).exp;
     97                if (astRef.decl instanceof AstConstBinding)
     98                        return ((AstConstBinding) astRef.decl).exp;
     99                else {
     100                        return new AstExp(new AstRefSymbol(astRef));
     101                }
    99102        }
    100103
     
    136139
    137140        public void visit(AstExp astExp) {
    138                 for (AstTerm astTerm : astExp.astTermList)
     141                for (AstTerm astTerm : astExp.termList)
    139142                        astTerm.accept(this);
    140143                expandNames(astExp);
     
    150153
    151154        public void visit(AstFuncDecl astFuncDecl) {
     155                astFuncDecl.inFormat.accept(this);
     156                astFuncDecl.outFormat.accept(this);
    152157                bindName(astFuncDecl, MsgCode.DuplicateDeclarationOfTheName_X);
    153158        }
     
    165170                        msgHandler.send(astName.pos,
    166171                                        MsgCode.DuplicateDefinitionOfTheFunction_X, identifier);
    167                 else
     172                else {
    168173                        astFuncDecl.funcDef = astFuncDef;
    169 
     174                        astFuncDef.funcDecl = astFuncDecl;
     175                }
    170176        }
    171177
     
    250256        }
    251257
     258        public void visit(AstRefSymbol astRefSymbol) {
     259                throw new UnsupportedOperationException();
     260        }
     261
    252262        public void visit(AstResultExp astResultExp) {
    253263                astResultExp.exp.accept(this);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/Parser.java

    r2255 r2264  
    507507                        return false;
    508508                AstResultExp astResultExp = (AstResultExp) astPath;
    509                 return astResultExp.exp.astTermList.isEmpty();
     509                return astResultExp.exp.termList.isEmpty();
    510510        }
    511511
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableCollector.java

    r2250 r2264  
    2929import org.refal.plus.comp.ast.AstPatternAlt;
    3030import org.refal.plus.comp.ast.AstRef;
     31import org.refal.plus.comp.ast.AstRefSymbol;
    3132import org.refal.plus.comp.ast.AstResultExp;
    3233import org.refal.plus.comp.ast.AstSentence;
     
    8081
    8182        public void visit(AstExp astExp) {
    82                 for( AstTerm astTerm : astExp.astTermList ) {
     83                for( AstTerm astTerm : astExp.termList ) {
    8384                        astTerm.accept(this);
    8485                }
     
    150151        }
    151152
     153        public void visit(AstRefSymbol astRefSymbol) {
     154        }
     155
    152156        public void visit(AstResultExp astResultExp) {
    153157                throw new UnsupportedOperationException();
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2262 r2264  
    2929import org.refal.plus.comp.ast.AstPatternAlt;
    3030import org.refal.plus.comp.ast.AstRef;
     31import org.refal.plus.comp.ast.AstRefSymbol;
    3132import org.refal.plus.comp.ast.AstResultExp;
    3233import org.refal.plus.comp.ast.AstSentence;
     
    193194
    194195        public void visit(AstRef astRef, LexicalEnvironment<VarType> e) {
     196                throw new UnsupportedOperationException();
     197        }
     198
     199        public void visit(AstRefSymbol astRefSymbol, LexicalEnvironment<VarType> e) {
    195200                throw new UnsupportedOperationException();
    196201        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstExp.java

    r2262 r2264  
    77
    88public final class AstExp extends AstNode {
    9         public final ArrayList<AstTerm> astTermList;
     9        public final ArrayList<AstTerm> termList;
    1010
    1111        public AstExp() {
     
    1414
    1515        public AstExp(ArrayList<AstTerm> astTermList) {
    16                 this.astTermList = astTermList;
     16                this.termList = astTermList;
    1717        }
    1818
     
    2020                ArrayList<AstTerm> termList = new ArrayList<AstTerm>(1);
    2121                termList.add(astTerm);
    22                 this.astTermList = termList;
     22                this.termList = termList;
    2323        }
    2424
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstFuncDef.java

    r2262 r2264  
    88
    99        public final AstPatternAlt body;
     10       
     11        public AstFuncDecl funcDecl = null;
    1012
    1113        public AstFuncDef(AstName name, AstPatternAlt body) {
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/ImageBuilder.java

    r2250 r2264  
    9191        public void visit(AstExp astExp) {
    9292                boolean first = true;
    93                 for (AstTerm astTerm : astExp.astTermList) {
     93                for (AstTerm astTerm : astExp.termList) {
    9494                        if( !first)
    9595                                append(" ");
     
    221221        }
    222222
     223        public void visit(AstRefSymbol astRefSymbol) {
     224                append("&");
     225                astRefSymbol.name.accept(this);
     226        }
     227
    223228        public void visit(AstResultExp astResultExp) {
    224229                astResultExp.exp.accept(this);
     
    234239                append("$traceall");
    235240        }
    236 
     241       
    237242        public void visit(AstTrap astTrap) {
    238243                append("$trap ");
     
    241246                astTrap.patternAlt.accept(this);
    242247        }
    243        
     248
    244249        public void visit(AstVar astVar) {
    245250                append(astVar.getTypeAsString());
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/NodeVisitor.java

    r2250 r2264  
    2828        void visit(AstPatternAlt astPatternAlt);
    2929        void visit(AstRef astRef);
     30        void visit(AstRefSymbol astRefSymbol);
    3031        void visit(AstResultExp astResultExp);
    3132        void visit(AstSentence astSentence);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/VisitorWithEnv.java

    r2262 r2264  
    2828        void visit(AstPatternAlt astPatternAlt, E e);
    2929        void visit(AstRef astRef, E e);
     30        void visit(AstRefSymbol astRefSymbol, E e);
    3031        void visit(AstResultExp astResultExp, E e);
    3132        void visit(AstSentence astSentence, E e);
Note: See TracChangeset for help on using the changeset viewer.