Changeset 2681


Ignore:
Timestamp:
Apr 13, 2007, 3:08:23 AM (14 years ago)
Author:
orlov
Message:
  • Sentence can begin with PatternAlt?.
  • In that case pattern in sentence is null and patternAlt is a part of the rest path

(now PatternAlt? extends Path).

Location:
devel-tools/trunk/eclipse
Files:
11 edited
1 copied

Legend:

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

    r2628 r2681  
    7171
    7272                expectMessage("$func F t = s;F tX = tX;", MsgCode.FormatMismatch);
    73                 expectMessage("$func F s = t;F tX = tX;", MsgCode.FormatMismatch);
     73                expectMessage("$func F s = t;F tX = tX;", MsgCode.WrongFormatOfPatternExpression);
    7474
    7575                expectOK("$func F s = t t; F sX = sX sX;");
     76               
     77                expectOK("$func F A = B; F { { { A; }; A; } = B; };");
     78                expectMessage("$func F A = B; F { { { B; }; A; } = B; };", MsgCode.WrongFormatOfPatternExpression);
     79                expectMessage("$func F A = B; F { { { A = A; }; A = B; }; };", MsgCode.FormatMismatch);
    7680        }
    7781
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp.test/src/org/refal/plus/rfpdt/comp/test/ParserTest.java

    r2665 r2681  
    125125                implem("$traceall;", "$traceall");
    126126
    127                 implem("\"F\" {};", "F{};");
     127                implem("\"F\" {};", "F {};");
    128128
    129                 implem("$use A B C; F {};", "$use A B C;F{};");
     129                implem("$use A B C; F {};", "$use A B C;F {};");
    130130
    131                 implem("F sX;", "F\\{sX,;};");
     131                implem("F;", "F ,;");
     132                implem("F sX;", "F sX,;");
    132133                implem("F s t e v sX1_ t2X_ eX3_ v_X4 s.X1_ t.2X_ e.X3_ v._X4;",
    133                                 "F\\{s t e v sX1_ t2X_ eX3_ v_X4 sX1_ t2X_ eX3_ v_X4,;};");
    134                 implem("F $l s;", "F\\{s,;};");
    135                 implem("F $r s;", "F\\{$r s,;};");
     134                                "F s t e v sX1_ t2X_ eX3_ v_X4 sX1_ t2X_ eX3_ v_X4,;");
     135                implem("F $l s;", "F s,;");
     136                implem("F $r s;", "F $r s,;");
    136137
    137                 implem("F {A; B;};", "F{A,;B,;};");
    138                 implem("F {};", "F{};");
    139                 implem("F {A;};", "F{A,;};");
    140                 implem("F \\{A; B;};", "F\\{A,;B,;};");
     138                implem("F {A; B;};", "F {A,;B,;};");
     139                implem("F {};", "F {};");
     140                implem("F {A;};", "F {A,;};");
     141                implem("F \\{A; B;};", "F \\{A,;B,;};");
    141142
    142143                implem("F = sX1_ t2X_ eX3_ v_X4 s.X1_ t.2X_ e.X3_ v._X4;",
    143                                 "F\\{, = sX1_ t2X_ eX3_ v_X4 sX1_ t2X_ eX3_ v_X4;};");
    144                 implem("F = sX <F (e2) A>;", "F\\{, = sX <F (e2) A>;};");
     144                                "F , = sX1_ t2X_ eX3_ v_X4 sX1_ t2X_ eX3_ v_X4;");
     145                implem("F = sX <F (e2) A>;", "F , = sX <F (e2) A>;");
    145146
    146                 implem("F , eX;", "F\\{,eX;};");
    147                 implem("F , A:: ;", "F\\{,A::,;};");
    148                 implem("F , A::s, B;", "F\\{,A::s,B;};");
    149                 implem("F , A $iter B;", "F\\{,A $iter B::,;};");
    150                 implem("F , A $iter B,;", "F\\{,A $iter B::,;};");
    151                 implem("F , A $iter B :: s;", "F\\{,A $iter B::s,;};");
    152                 implem("F , A $iter B :: s,;", "F\\{,A $iter B::s,;};");
    153                 implem("F , A : sX;", "F\\{,A:sX,;};");
    154                 implem("F , A : sX,;", "F\\{,A:sX,;};");
     147                implem("F , eX;", "F ,eX;");
     148                implem("F , A:: ;", "F ,A::,;");
     149                implem("F , A::s, B;", "F ,A::s,B;");
     150                implem("F , A $iter B;", "F ,A $iter B::,;");
     151                implem("F , A $iter B,;", "F ,A $iter B::,;");
     152                implem("F , A $iter B :: s;", "F ,A $iter B::s,;");
     153                implem("F , A $iter B :: s,;", "F ,A $iter B::s,;");
     154                implem("F , A : sX;", "F ,A:sX,;");
     155                implem("F , A : sX,;", "F ,A:sX,;");
    155156
    156                 implem("F , , A;", "F\\{,A;};");
    157                 implem("F , #{;};", "F\\{,#{;},;};");
    158                 implem("F , #{;},A;", "F\\{,#{;},A;};");
    159                 implem("F , \\? A;", "F\\{,\\?A;};");
    160                 implem("F , \\! A;", "F\\{,\\!A;};");
    161                 implem("F , $fail;", "F\\{,$fail;};");
    162                 implem("F , = A;", "F\\{, = A;};");
    163                 implem("F , $error A;", "F\\{,$error A;};");
     157                implem("F , , A;", "F ,A;");
     158                implem("F , #{;};", "F ,#{;},;");
     159                implem("F , #{;},A;", "F ,#{;},A;");
     160                implem("F , \\? A;", "F ,\\?A;");
     161                implem("F , \\! A;", "F ,\\!A;");
     162                implem("F , $fail;", "F ,$fail;");
     163                implem("F , = A;", "F , = A;");
     164                implem("F , $error A;", "F ,$error A;");
    164165                implem("F , $trap A $with { A,; B,; };",
    165                                 "F\\{,$trap A $with {A,;B,;};};");
     166                                "F ,$trap A $with {A,;B,;};");
    166167                implem("F , $trap A $with \\{ A,; B,; };",
    167                                 "F\\{,$trap A $with \\{A,;B,;};};");
     168                                "F ,$trap A $with \\{A,;B,;};");
    168169
    169                 implem("F , #A;", "F\\{,#A,;};");
    170                 implem("F , #;", "F\\{,#,;};");
    171                 implem("F , #{A; B;};", "F\\{,#{A;B;},;};");
    172                 implem("F , #\\{A; B;};", "F\\{,#\\{A;B;},;};");
    173                 implem("F , #A : {A,1;B,2;};", "F\\{,#A:{A,1;B,2;},;};");
    174                 implem("F , #A : \\{A,1;B,2;};", "F\\{,#A:\\{A,1;B,2;},;};");
     170                implem("F , #A;", "F ,#A,;");
     171                implem("F , #;", "F ,#,;");
     172                implem("F , #{A; B;};", "F ,#{A;B;},;");
     173                implem("F , #\\{A; B;};", "F ,#\\{A;B;},;");
     174                implem("F , #A : {A,1;B,2;};", "F ,#A:{A,1;B,2;},;");
     175                implem("F , #A : \\{A,1;B,2;};", "F ,#A:\\{A,1;B,2;},;");
    175176                implem("F , #A : {A,1;B,2;} : {A,1;B,2;};",
    176                                 "F\\{,#A:{A,1;B,2;}:{A,1;B,2;},;};");
     177                                "F ,#A:{A,1;B,2;}:{A,1;B,2;},;");
    177178                implem("F , A : {A,1;B,2;} : {A,1;B,2;} :: sX, sX;",
    178                                 "F\\{,A:{A,1;B,2;}:{A,1;B,2;}::sX,sX;};");
     179                                "F ,A:{A,1;B,2;}:{A,1;B,2;}::sX,sX;");
    179180                implem("F , A : {$fail;A;} : {A,1;B,2;} :: sX, sX;",
    180                                 "F\\{,A:{,$fail;A,;}:{A,1;B,2;}::sX,sX;};");
     181                                "F ,A:{,$fail;A,;}:{A,1;B,2;}::sX,sX;");
     182               
     183                implem("F { {}; };", "F {{};};");
     184                implem("F { { A = B; } :: sX; };", "F {{A, = B;}::sX,;};");
    181185        }
    182186       
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/FenceAndCutChecker.java

    r2677 r2681  
    163163        public void visit(AstPatternAlt astPatternAlt, Integer e) {
    164164                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    165                         astSentence.rest.accept(this, e);
     165                        astSentence.accept(this, e);
    166166                }
    167167        }
     
    180180
    181181        public void visit(AstSentence astSentence, Integer e) {
    182                 throw new UnsupportedOperationException();
     182                astSentence.rest.accept(this, e);
    183183        }
    184184
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/FormatChecker.java

    r2483 r2681  
    115115                if (decl == null)
    116116                        return;
    117                 for (AstSentence astSentence : astFuncDef.body.sentenceList) {
    118                         checkFormat(decl.inFormat, astSentence.pattern.exp);
    119                 }
     117                PatternFormatChecker.check(astFuncDef.body, decl.inFormat, msgHandler);
    120118                astFuncDef.body.accept(this, decl.outFormat);
    121119        }
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/MsgCode.java

    r2672 r2681  
    4949        Variable_X_IsNotDefined(Severity.Error, "Variable %s is not defined"), //
    5050        WrongSyntax(Severity.Error, "Wrong syntax"), //
     51        WrongFormatOfPatternExpression(Severity.Error, "Wrong format of pattern expression"), //
    5152        X_IsNotAFunction(Severity.Error, "%s is not a function"), //
    5253        ;
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/NameChecker.java

    r2677 r2681  
    299299        public void visit(AstPatternAlt astPatternAlt) {
    300300                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    301                         astSentence.pattern.accept(this);
    302                         astSentence.rest.accept(this);
     301                        astSentence.accept(this);
    303302                }
    304303        }
     
    317316
    318317        public void visit(AstSentence astSentence) {
    319                 astSentence.pattern.accept(this);
     318                if (astSentence.pattern != null)
     319                        astSentence.pattern.accept(this);
    320320                astSentence.rest.accept(this);
    321321        }
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/PatternFormatChecker.java

    r2680 r2681  
    2424import org.refal.plus.rfpdt.comp.ast.AstObjDecl;
    2525import org.refal.plus.rfpdt.comp.ast.AstParen;
    26 import org.refal.plus.rfpdt.comp.ast.AstPath;
    2726import org.refal.plus.rfpdt.comp.ast.AstPattern;
    2827import org.refal.plus.rfpdt.comp.ast.AstPatternAlt;
     
    3130import org.refal.plus.rfpdt.comp.ast.AstResultExp;
    3231import org.refal.plus.rfpdt.comp.ast.AstSentence;
    33 import org.refal.plus.rfpdt.comp.ast.AstTerm;
    34 import org.refal.plus.rfpdt.comp.ast.AstTopNode;
    3532import org.refal.plus.rfpdt.comp.ast.AstTraceAll;
    3633import org.refal.plus.rfpdt.comp.ast.AstTrap;
     
    3835import org.refal.plus.rfpdt.comp.ast.AstVar;
    3936import org.refal.plus.rfpdt.comp.ast.AstWordSymbol;
    40 import org.refal.plus.rfpdt.comp.ast.VisitorWithEnv;
    41 
    42 public class FormatChecker implements VisitorWithEnv<AstExp> {
    43 
    44         public static void check(AstImplem astImplem, MsgHandler msgHandler) {
    45                 FormatChecker v = new FormatChecker(msgHandler);
    46                 v.visit(astImplem, null);
     37import org.refal.plus.rfpdt.comp.ast.NodeVisitor;
     38
     39public class PatternFormatChecker implements NodeVisitor {
     40
     41        public static void check(AstSentence astSentence, AstExp format, MsgHandler msgHandler) {
     42                PatternFormatChecker v = new PatternFormatChecker(format, msgHandler);
     43                v.visit(astSentence);
    4744        }
    4845
    4946        private final MsgHandler msgHandler;
    50 
    51         private FormatChecker(final MsgHandler msgHandler) {
     47       
     48        private final AstExp inFormat;
     49
     50        private PatternFormatChecker(AstExp format, final MsgHandler msgHandler) {
     51                this.inFormat = format;
    5252                this.msgHandler = msgHandler;
    5353        }
    5454
    55         private void checkFormat(AstExp format, AstExp exp) {
    56                 if (!FormatMatcher.covers(format, exp)) {
    57                         msgHandler.send(exp.pos, MsgCode.FormatMismatch);
     55        public void visit(AstAlt astAlt) {
     56                throw new UnsupportedOperationException();
     57        }
     58
     59        public void visit(AstAltMatch astAltMatch) {
     60                astAltMatch.source.accept(this);
     61        }
     62
     63        public void visit(AstCall astCall) {
     64                throw new UnsupportedOperationException();
     65        }
     66
     67        public void visit(AstCharSymbol astCharSymbol) {
     68                throw new UnsupportedOperationException();
     69        }
     70
     71        public void visit(AstConstBinding astConstBinding) {
     72                throw new UnsupportedOperationException();
     73        }
     74
     75        public void visit(AstCut astCut) {
     76                throw new UnsupportedOperationException();
     77        }
     78
     79        public void visit(AstCutAll astCutAll) {
     80                throw new UnsupportedOperationException();
     81        }
     82
     83        public void visit(AstError astError) {
     84                throw new UnsupportedOperationException();
     85        }
     86
     87        public void visit(AstExp astExp) {
     88                throw new UnsupportedOperationException();
     89        }
     90
     91        public void visit(AstFail astFail) {
     92                throw new UnsupportedOperationException();
     93        }
     94
     95        public void visit(AstFence astFence) {
     96                throw new UnsupportedOperationException();
     97        }
     98
     99        public void visit(AstFuncDecl astFuncDecl) {
     100                throw new UnsupportedOperationException();
     101        }
     102
     103        public void visit(AstFuncDef astFuncDef) {
     104                throw new UnsupportedOperationException();
     105        }
     106
     107        public void visit(AstImplem astImplem) {
     108                throw new UnsupportedOperationException();
     109        }
     110
     111        public void visit(AstInterf astInterf) {
     112                throw new UnsupportedOperationException();
     113        }
     114
     115        public void visit(AstIter astIter) {
     116                astIter.source1.accept(this);
     117        }
     118
     119        public void visit(AstLet astLet) {
     120                astLet.source.accept(this);
     121        }
     122
     123        public void visit(AstMatch astMatch) {
     124                astMatch.source.accept(this);
     125        }
     126
     127        public void visit(AstName astName) {
     128                throw new UnsupportedOperationException();
     129        }
     130
     131        public void visit(AstNot astNot) {
     132                throw new UnsupportedOperationException();
     133        }
     134
     135        public void visit(AstNumberSymbol astNumberSymbol) {
     136                throw new UnsupportedOperationException();
     137        }
     138
     139        public void visit(AstObjDecl astObjDecl) {
     140                throw new UnsupportedOperationException();
     141        }
     142
     143        public void visit(AstParen astParen) {
     144                throw new UnsupportedOperationException();
     145        }
     146
     147        public void visit(AstPattern astPattern) {
     148                throw new UnsupportedOperationException();
     149        }
     150
     151        public void visit(AstPatternAlt astPatternAlt) {
     152                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     153                        astSentence.accept(this);
    58154                }
    59155        }
    60156
    61         public void visit(AstAlt astAlt, AstExp e) {
    62                 for (AstPath astPath : astAlt.pathList) {
    63                         astPath.accept(this, e);
     157        public void visit(AstRef astRef) {
     158                throw new UnsupportedOperationException();
     159        }
     160
     161        public void visit(AstRefSymbol astRefSymbol) {
     162                throw new UnsupportedOperationException();
     163        }
     164
     165        public void visit(AstResultExp astResultExp) {
     166                throw new UnsupportedOperationException();
     167        }
     168
     169        public void visit(AstSentence astSentence) {
     170                if (astSentence.pattern != null) {
     171                        if (!FormatMatcher.covers(inFormat, astSentence.pattern.exp)) {
     172                                msgHandler.send(astSentence.pattern.exp.pos,
     173                                                MsgCode.WrongFormatOfPatternExpression);
     174                        }
    64175                }
    65         }
    66 
    67         public void visit(AstAltMatch astAltMatch, AstExp e) {
    68                 astAltMatch.patternAlt.accept(this, e);
    69         }
    70 
    71         public void visit(AstCall astCall, AstExp e) {
    72                 astCall.arg.accept(this, null);
    73                 if (astCall.funcDecl != null)
    74                         checkFormat(astCall.funcDecl.inFormat, astCall.arg);
    75         }
    76 
    77         public void visit(AstCharSymbol astCharSymbol, AstExp e) {
    78         }
    79 
    80         public void visit(AstConstBinding astConstBinding, AstExp e) {
    81         }
    82 
    83         public void visit(AstCut astCut, AstExp e) {
    84                 astCut.path.accept(this, e);
    85         }
    86 
    87         public void visit(AstCutAll astCutAll, AstExp e) {
    88                 astCutAll.path.accept(this, e);
    89         }
    90 
    91         public void visit(AstError astError, AstExp e) {
    92                 return;
    93         }
    94 
    95         public void visit(AstExp astExp, AstExp e) {
    96                 for (AstTerm astTerm : astExp.termList) {
    97                         astTerm.accept(this, null);
     176                else {
     177                        astSentence.rest.accept(this);
    98178                }
    99 
    100         }
    101 
    102         public void visit(AstFail astFail, AstExp e) {
    103                 return;
    104         }
    105 
    106         public void visit(AstFence astFence, AstExp e) {
    107                 astFence.path.accept(this, e);
    108         }
    109 
    110         public void visit(AstFuncDecl astFuncDecl, AstExp e) {
    111         }
    112 
    113         public void visit(AstFuncDef astFuncDef, AstExp e) {
    114                 AstFuncDecl decl = astFuncDef.funcDecl;
    115                 if (decl == null)
    116                         return;
    117                 for (AstSentence astSentence : astFuncDef.body.sentenceList) {
    118                         checkFormat(decl.inFormat, astSentence.pattern.exp);
    119                 }
    120                 astFuncDef.body.accept(this, decl.outFormat);
    121         }
    122 
    123         public void visit(AstImplem astImplem, AstExp e) {
    124                 for (AstTopNode astTopNode : astImplem.topNodes)
    125                         astTopNode.accept(this, null);
    126         }
    127 
    128         public void visit(AstInterf astInterf, AstExp e) {
     179        }
     180
     181        public void visit(AstTraceAll astTraceAll) {
     182                throw new UnsupportedOperationException();
     183        }
     184
     185        public void visit(AstTrap astTrap) {
     186                throw new UnsupportedOperationException();
     187        }
     188
     189        public void visit(AstUse astUse) {
    129190                throw new UnsupportedOperationException();
    130191        }
    131192
    132         public void visit(AstIter astIter, AstExp e) {
    133                 astIter.source1.accept(this, astIter.target);
    134                 astIter.source2.accept(this, astIter.target);
    135                 astIter.rest.accept(this, e);
    136         }
    137 
    138         public void visit(AstLet astLet, AstExp e) {
    139                 astLet.source.accept(this, astLet.target);
    140                 astLet.rest.accept(this, e);
    141         }
    142 
    143         public void visit(AstMatch astMatch, AstExp e) {
    144                 astMatch.sentence.accept(this, e);
    145         }
    146 
    147         public void visit(AstName astName, AstExp e) {
    148         }
    149 
    150         public void visit(AstNot astNot, AstExp e) {
    151                 astNot.source.accept(this, new AstExp(astNot.source.pos));
    152                 astNot.rest.accept(this, e);
    153         }
    154 
    155         public void visit(AstNumberSymbol astNumberSymbol, AstExp e) {
    156         }
    157 
    158         public void visit(AstObjDecl astObjDecl, AstExp e) {
    159         }
    160 
    161         public void visit(AstParen astParen, AstExp e) {
    162                 astParen.exp.accept(this, null);
    163         }
    164 
    165         public void visit(AstPattern astPattern, AstExp e) {
    166                 throw new UnsupportedOperationException();
    167         }
    168 
    169         public void visit(AstPatternAlt astPatternAlt, AstExp e) {
    170                 for (AstSentence astSentence : astPatternAlt.sentenceList) {
    171                         astSentence.accept(this, e);
    172                 }
    173         }
    174 
    175         public void visit(AstRef astRef, AstExp e) {
    176         }
    177 
    178         public void visit(AstRefSymbol astRefSymbol, AstExp e) {
    179         }
    180 
    181         public void visit(AstResultExp astResultExp, AstExp e) {
    182                 checkFormat(e, astResultExp.exp);
    183         }
    184 
    185         public void visit(AstSentence astSentence, AstExp e) {
    186                 astSentence.rest.accept(this, e);
    187         }
    188 
    189         public void visit(AstTraceAll astTraceAll, AstExp e) {
    190         }
    191 
    192         public void visit(AstTrap astTrap, AstExp e) {
    193                 astTrap.path.accept(this, e);
    194                 astTrap.patternAlt.accept(this, e);
    195         }
    196 
    197         public void visit(AstUse astUse, AstExp e) {
    198                 throw new UnsupportedOperationException();
    199         }
    200 
    201         public void visit(AstVar astVar, AstExp e) {
    202         }
    203 
    204         public void visit(AstWordSymbol astWordSymbol, AstExp e) {
     193        public void visit(AstVar astVar) {
     194                throw new UnsupportedOperationException();
     195        }
     196
     197        public void visit(AstWordSymbol astWordSymbol) {
     198                throw new UnsupportedOperationException();
    205199        }
    206200
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/RfpParser.java

    r2677 r2681  
    22
    33import static org.refal.plus.rfpdt.comp.TkFollowers.f_const_bindings;
    4 import static org.refal.plus.rfpdt.comp.TkFollowers.f_func_body;
    54import static org.refal.plus.rfpdt.comp.TkFollowers.f_implem;
    65import static org.refal.plus.rfpdt.comp.TkFollowers.f_interf;
     
    3433import static org.refal.plus.rfpdt.comp.TkStarters.s_result_exp_head;
    3534import static org.refal.plus.rfpdt.comp.TkStarters.s_sentence;
     35import static org.refal.plus.rfpdt.comp.TkStarters.s_sentence_tail;
    3636import static org.refal.plus.rfpdt.comp.TkStarters.s_sentences;
    3737import static org.refal.plus.rfpdt.comp.TkStarters.s_source;
     
    569569                assert tkIs(WORD);
    570570                AstName astName = name(s_func_body | ftk, stk);
    571                 AstPatternAlt astBody = func_body(ftk, stk);
    572                 return new AstFuncDef(astName, astBody);
     571                AstSentence body = sentence(ftk, stk);
     572                return new AstFuncDef(astName, body);
    573573        }
    574574
    575575        // #func_body
    576         // : (LCURL) pattern_alt
    577         // | (s_func_body | f_func_body) #sentence ;
    578 
    579         private AstPatternAlt func_body(long ftk, long stk) {
    580                 AstPatternAlt astPatternAlt;
    581 
    582                 sync(s_func_body | ftk, stk);
    583                 if (tkIs(LCURL)) {
    584                         astPatternAlt = pattern_alt(ftk, stk);
    585                 } else if (tkIn(s_sentence | f_func_body)) {
    586                         AstSentence astSentence = sentence(ftk, stk);
    587                         astPatternAlt = new AstPatternAlt(true,
    588                                         new AstSentence[] { astSentence });
     576        // : (s_func_body | f_func_body) #sentence ;
     577
     578        // #sentence
     579        // : (s_pattern | s_o_rest | f_sentence) #pattern #o_rest
     580        // | (LCURL) pattern_alt #source_tail #sentence_tail
     581
     582        private AstSentence sentence(long ftk, long stk) {
     583                sync(s_sentence | ftk, stk);
     584                AstPattern astPattern = null;
     585                AstPath astRest;
     586                if (tkIn(s_pattern | s_o_rest | ftk)) {
     587                        astPattern = pattern(s_o_rest | ftk, stk);
     588                        astRest = path(ftk, stk);
    589589                } else {
    590                         astPatternAlt = new AstPatternAlt(true, new AstSentence[] {});
    591                 }
    592                 return astPatternAlt;
     590                        assert (tkIs(LCURL));
     591                        AstPatternAlt astPatternAlt = pattern_alt(s_source_tail | s_sentence_tail | ftk, stk);
     592                        AstPath astSource = source_tail(s_path_tail | ftk, stk, astPatternAlt);
     593                        astRest = path_tail(ftk, stk, astSource);
     594                }
     595                return new AstSentence(astPattern, astRest);
    593596        }
    594597
     
    625628                }
    626629                return list.toArray(new AstSentence[list.size()]);
    627         }
    628 
    629         // #sentence
    630         // : (s_sentence | f_sentence) #pattern #o_rest ;
    631 
    632         private AstSentence sentence(long ftk, long stk) {
    633                 sync(s_sentence | ftk, stk);
    634                 AstPattern astPattern = pattern(s_o_rest | ftk, stk);
    635                 AstPath astRest = o_rest(ftk, stk);
    636                 return new AstSentence(astPattern, astRest);
    637630        }
    638631
     
    807800        private AstPath source(long ftk, long stk) {
    808801                AstPath astSource;
    809 
    810802                sync(s_source | ftk, stk);
    811803                if (tkIs(LCURL)) {
     
    814806                        AstExp astExp = result_exp(s_source_tail | ftk, stk);
    815807                        astSource = new AstResultExp(astExp);
    816                 } else {
     808                } else
    817809                        astSource = dummyPath();
    818                 }
     810                return source_tail(ftk, stk, astSource);
     811        }
     812       
     813        private AstPath source_tail(long ftk, long stk, AstPath source_head) {
     814                AstPath astSource = source_head;
    819815                while (tkIs(COL_CURL)) {
    820816                        nextTk();
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/VariableScopeChecker.java

    r2483 r2681  
    161161        public void visit(AstMatch astMatch, LexicalEnvironment<VarType> e) {
    162162                astMatch.source.accept(this, e);
    163                 AstSentence astSentence = astMatch.sentence;
    164                 LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    165                 addVariablesFrom(t1, astSentence.pattern.exp);
    166                 astSentence.rest.accept(this, t1);
     163                astMatch.sentence.accept(this, e);
    167164        }
    168165
     
    193190        public void visit(AstPatternAlt astPatternAlt, LexicalEnvironment<VarType> e) {
    194191                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    195                         LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    196                         addVariablesFrom(t1, astSentence.pattern.exp);
    197                         astSentence.rest.accept(this, t1);
     192                        astSentence.accept(this, e);
    198193                }
    199194        }
     
    228223
    229224        public void visit(AstSentence astSentence, LexicalEnvironment<VarType> e) {
    230                 throw new UnsupportedOperationException();
     225                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
     226                if (astSentence.pattern != null)
     227                        addVariablesFrom(t1, astSentence.pattern.exp);
     228                astSentence.rest.accept(this, t1);
    231229        }
    232230
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/ast/AstFuncDef.java

    r2483 r2681  
    77        public final AstName name;
    88
    9         public final AstPatternAlt body;
     9        public final AstSentence body;
    1010       
    1111        public AstFuncDecl funcDecl = null;
    1212
    13         public AstFuncDef(AstName name, AstPatternAlt body) {
     13        public AstFuncDef(AstName name, AstSentence body) {
    1414                this.name = name;
    1515                this.body = body;
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/ast/AstPatternAlt.java

    r2483 r2681  
    44package org.refal.plus.rfpdt.comp.ast;
    55
    6 public final class AstPatternAlt extends AstNode {
     6public final class AstPatternAlt extends AstPath {
    77        boolean failing;
    88
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.comp/src/org/refal/plus/rfpdt/comp/ast/ImageBuilder.java

    r2483 r2681  
    123123        public void visit(AstFuncDef astFuncDef) {
    124124                astFuncDef.name.accept(this);
     125                append(" ");
    125126                astFuncDef.body.accept(this);
    126127                append(";");
     
    232233
    233234        public void visit(AstSentence astSentence) {
    234                 astSentence.pattern.accept(this);
    235                 append(",");
     235                if (astSentence.pattern != null) {
     236                        astSentence.pattern.accept(this);
     237                        append(",");
     238                }
    236239                astSentence.rest.accept(this);
    237240        }
Note: See TracChangeset for help on using the changeset viewer.