Changeset 2262


Ignore:
Timestamp:
Jan 21, 2007, 2:03:25 PM (14 years ago)
Author:
roman
Message:

T t --> E e in VisitorWithEnv?

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

Legend:

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

    r2259 r2262  
    3030import org.refal.plus.comp.ast.AstResultExp;
    3131import org.refal.plus.comp.ast.AstSentence;
     32import org.refal.plus.comp.ast.AstTopNode;
    3233import org.refal.plus.comp.ast.AstTraceAll;
    3334import org.refal.plus.comp.ast.AstTrap;
     
    4445        }
    4546
    46         public void visit(AstAlt astAlt, Integer t) {
     47        public void visit(AstAlt astAlt, Integer e) {
    4748                for (AstPath astPath : astAlt.pathList) {
    48                         astPath.accept(this, t);
     49                        astPath.accept(this, e);
    4950                }
    5051        }
    5152
    52         public void visit(AstAltMatch astAltMatch, Integer t) {
     53        public void visit(AstAltMatch astAltMatch, Integer e) {
    5354                astAltMatch.source.accept(this, 0);
    54                 visit(astAltMatch.patternAlt, t);
     55                visit(astAltMatch.patternAlt, e);
    5556        }
    5657
    57         public void visit(AstCut astCut, Integer t) {
    58                 int k = t;
     58        public void visit(AstCut astCut, Integer e) {
     59                int k = e;
    5960
    6061                if (k > 0)
     
    6667        }
    6768
    68         public void visit(AstCutAll astCutAll, Integer t) {
     69        public void visit(AstCutAll astCutAll, Integer e) {
    6970                astCutAll.path.accept(this, 0);
    7071        }
    7172
    72         public void visit(AstError astError, Integer t) {
     73        public void visit(AstError astError, Integer e) {
    7374                astError.path.accept(this, 0);
    7475        }
    7576
    76         public void visit(AstFail astFail, Integer t) {
     77        public void visit(AstFail astFail, Integer e) {
    7778                return;
    7879        }
    7980
    80         public void visit(AstFence astFence, Integer t) {
    81                 astFence.path.accept(this, t + 1);
     81        public void visit(AstFence astFence, Integer e) {
     82                astFence.path.accept(this, e + 1);
    8283        }
    8384
    84         public void visit(AstIter astIter, Integer t) {
     85        public void visit(AstIter astIter, Integer e) {
    8586                astIter.source1.accept(this, 0);
    8687                astIter.source2.accept(this, 0);
    87                 astIter.rest.accept(this, t);
     88                astIter.rest.accept(this, e);
    8889        }
    8990
    90         public void visit(AstLet astLet, Integer t) {
     91        public void visit(AstLet astLet, Integer e) {
    9192                astLet.source.accept(this, 0);
    92                 astLet.rest.accept(this, t);
     93                astLet.rest.accept(this, e);
    9394        }
    9495
    95         public void visit(AstMatch astMatch, Integer t) {
     96        public void visit(AstMatch astMatch, Integer e) {
    9697                astMatch.source.accept(this, 0);
    97                 astMatch.sentence.rest.accept(this, t);
     98                astMatch.sentence.rest.accept(this, e);
    9899        }
    99100
    100         public void visit(AstNot astNot, Integer t) {
     101        public void visit(AstNot astNot, Integer e) {
    101102                astNot.source.accept(this, 0);
    102                 astNot.rest.accept(this, t);
     103                astNot.rest.accept(this, e);
    103104        }
    104105
    105         public void visit(AstPatternAlt astPatternAlt, Integer t) {
     106        public void visit(AstPatternAlt astPatternAlt, Integer e) {
    106107                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    107                         astSentence.rest.accept(this, t);
     108                        astSentence.rest.accept(this, e);
    108109                }
    109110        }
    110111
    111         public void visit(AstResultExp astResultExp, Integer t) {
     112        public void visit(AstResultExp astResultExp, Integer e) {
    112113                return;
    113114        }
    114115
    115         public void visit(AstTrap astTrap, Integer t) {
     116        public void visit(AstTrap astTrap, Integer e) {
    116117                astTrap.path.accept(this, 0);
    117                 visit( astTrap.patternAlt, t);
     118                visit( astTrap.patternAlt, e);
    118119        }
    119120
    120         public void visit(AstCall astCall, Integer t) {
     121        public void visit(AstCall astCall, Integer e) {
    121122                throw new UnsupportedOperationException();
    122123        }
    123124
    124         public void visit(AstCharSymbol astCharSymbol, Integer t) {
     125        public void visit(AstCharSymbol astCharSymbol, Integer e) {
    125126                throw new UnsupportedOperationException();
    126127        }
    127128
    128         public void visit(AstConstBinding astConstBinding, Integer t) {
     129        public void visit(AstConstBinding astConstBinding, Integer e) {
     130        }
     131
     132        public void visit(AstExp astExp, Integer e) {
    129133                throw new UnsupportedOperationException();
    130134        }
    131135
    132         public void visit(AstExp astExp, Integer t) {
     136        public void visit(AstFuncDecl astFuncDecl, Integer e) {
     137        }
     138
     139        public void visit(AstFuncDef astFuncDef, Integer e) {
     140                astFuncDef.body.accept(this, 0);
     141        }
     142
     143        public void visit(AstImplem astImplem, Integer e) {
     144                for(AstTopNode astTopNode : astImplem.topNodes)
     145                        astTopNode.accept(this, 0);
     146        }
     147
     148        public void visit(AstInterf astInterf, Integer e) {
    133149                throw new UnsupportedOperationException();
    134150        }
    135151
    136         public void visit(AstFuncDecl astFuncDecl, Integer t) {
     152        public void visit(AstName astName, Integer e) {
    137153                throw new UnsupportedOperationException();
    138154        }
    139155
    140         public void visit(AstFuncDef astFuncDef, Integer t) {
     156        public void visit(AstNumberSymbol astNumberSymbol, Integer e) {
    141157                throw new UnsupportedOperationException();
    142158        }
    143159
    144         public void visit(AstImplem astImplem, Integer t) {
     160        public void visit(AstObjDecl astObjDecl, Integer e) {
     161        }
     162
     163        public void visit(AstParen astParen, Integer e) {
    145164                throw new UnsupportedOperationException();
    146165        }
    147166
    148         public void visit(AstInterf astInterf, Integer t) {
     167        public void visit(AstPattern astPattern, Integer e) {
    149168                throw new UnsupportedOperationException();
    150169        }
    151170
    152         public void visit(AstName astName, Integer t) {
     171        public void visit(AstRef astRef, Integer e) {
    153172                throw new UnsupportedOperationException();
    154173        }
    155174
    156         public void visit(AstNumberSymbol astNumberSymbol, Integer t) {
     175        public void visit(AstSentence astSentence, Integer e) {
    157176                throw new UnsupportedOperationException();
    158177        }
    159178
    160         public void visit(AstObjDecl astObjDecl, Integer t) {
     179        public void visit(AstTraceAll astTraceAll, Integer e) {
     180        }
     181
     182        public void visit(AstVar astVar, Integer e) {
    161183                throw new UnsupportedOperationException();
    162184        }
    163185
    164         public void visit(AstParen astParen, Integer t) {
     186        public void visit(AstWordSymbol astWordSymbol, Integer e) {
    165187                throw new UnsupportedOperationException();
    166188        }
    167 
    168         public void visit(AstPattern astPattern, Integer t) {
    169                 throw new UnsupportedOperationException();
    170         }
    171 
    172         public void visit(AstRef astRef, Integer t) {
    173                 throw new UnsupportedOperationException();
    174         }
    175 
    176         public void visit(AstSentence astSentence, Integer t) {
    177                 throw new UnsupportedOperationException();
    178         }
    179 
    180         public void visit(AstTraceAll astTraceAll, Integer t) {
    181                 throw new UnsupportedOperationException();
    182         }
    183 
    184         public void visit(AstVar astVar, Integer t) {
    185                 throw new UnsupportedOperationException();
    186         }
    187 
    188         public void visit(AstWordSymbol astWordSymbol, Integer t) {
    189                 throw new UnsupportedOperationException();
    190         }
    191 
    192189}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2259 r2262  
    3131import org.refal.plus.comp.ast.AstResultExp;
    3232import org.refal.plus.comp.ast.AstSentence;
     33import org.refal.plus.comp.ast.AstTopNode;
    3334import org.refal.plus.comp.ast.AstTraceAll;
    3435import org.refal.plus.comp.ast.AstTrap;
     
    7475        }
    7576
    76         public void visit(AstAlt astAlt, LexicalEnvironment<VarType> t) {
     77        public void visit(AstAlt astAlt, LexicalEnvironment<VarType> e) {
    7778                for (AstPath astPath : astAlt.pathList) {
    78                         astPath.accept(this, t);
    79                 }
    80         }
    81 
    82         public void visit(AstAltMatch astAltMatch, LexicalEnvironment<VarType> t) {
    83                 astAltMatch.source.accept(this, t);
    84                 visit(astAltMatch.patternAlt, t);
    85         }
    86 
    87         public void visit(AstCall astCall, LexicalEnvironment<VarType> t) {
    88                 throw new UnsupportedOperationException();
    89         }
    90 
    91         public void visit(AstCharSymbol astCharSymbol, LexicalEnvironment<VarType> t) {
    92                 throw new UnsupportedOperationException();
    93         }
    94 
    95         public void visit(AstConstBinding astConstBinding, LexicalEnvironment<VarType> t) {
    96                 throw new UnsupportedOperationException();
    97         }
    98 
    99         public void visit(AstCut astCut, LexicalEnvironment<VarType> t) {
    100                 astCut.path.accept(this, t);
    101         }
    102 
    103         public void visit(AstCutAll astCutAll, LexicalEnvironment<VarType> t) {
    104                 astCutAll.path.accept(this, t);
    105         }
    106 
    107         public void visit(AstError astError, LexicalEnvironment<VarType> t) {
    108                 astError.path.accept(this, t);
    109         }
    110 
    111         public void visit(AstExp astExp, LexicalEnvironment<VarType> t) {
    112                 throw new UnsupportedOperationException();
    113         }
    114 
    115         public void visit(AstFail astFail, LexicalEnvironment<VarType> t) {
     79                        astPath.accept(this, e);
     80                }
     81        }
     82
     83        public void visit(AstAltMatch astAltMatch, LexicalEnvironment<VarType> e) {
     84                astAltMatch.source.accept(this, e);
     85                visit(astAltMatch.patternAlt, e);
     86        }
     87
     88        public void visit(AstCall astCall, LexicalEnvironment<VarType> e) {
     89                throw new UnsupportedOperationException();
     90        }
     91
     92        public void visit(AstCharSymbol astCharSymbol, LexicalEnvironment<VarType> e) {
     93                throw new UnsupportedOperationException();
     94        }
     95
     96        public void visit(AstConstBinding astConstBinding, LexicalEnvironment<VarType> e) {
     97        }
     98
     99        public void visit(AstCut astCut, LexicalEnvironment<VarType> e) {
     100                astCut.path.accept(this, e);
     101        }
     102
     103        public void visit(AstCutAll astCutAll, LexicalEnvironment<VarType> e) {
     104                astCutAll.path.accept(this, e);
     105        }
     106
     107        public void visit(AstError astError, LexicalEnvironment<VarType> e) {
     108                astError.path.accept(this, e);
     109        }
     110
     111        public void visit(AstExp astExp, LexicalEnvironment<VarType> e) {
     112                throw new UnsupportedOperationException();
     113        }
     114
     115        public void visit(AstFail astFail, LexicalEnvironment<VarType> e) {
    116116                return;
    117117        }
    118118
    119         public void visit(AstFence astFence, LexicalEnvironment<VarType> t) {
    120                 astFence.path.accept(this, t);
    121         }
    122 
    123         public void visit(AstFuncDecl astFuncDecl, LexicalEnvironment<VarType> t) {
    124                 throw new UnsupportedOperationException();
    125         }
    126 
    127         public void visit(AstFuncDef astFuncDef, LexicalEnvironment<VarType> t) {
    128                 throw new UnsupportedOperationException();
    129         }
    130 
    131         public void visit(AstImplem astImplem, LexicalEnvironment<VarType> t) {
    132                 throw new UnsupportedOperationException();
    133         }
    134 
    135         public void visit(AstInterf astInterf, LexicalEnvironment<VarType> t) {
    136                 throw new UnsupportedOperationException();
    137         }
    138 
    139         public void visit(AstIter astIter, LexicalEnvironment<VarType> t) {
    140                 astIter.source1.accept(this, t);
    141                 LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     119        public void visit(AstFence astFence, LexicalEnvironment<VarType> e) {
     120                astFence.path.accept(this, e);
     121        }
     122
     123        public void visit(AstFuncDecl astFuncDecl, LexicalEnvironment<VarType> e) {
     124        }
     125
     126        public void visit(AstFuncDef astFuncDef, LexicalEnvironment<VarType> e) {
     127                astFuncDef.body.accept(this, null);
     128        }
     129
     130        public void visit(AstImplem astImplem, LexicalEnvironment<VarType> e) {
     131                for( AstTopNode astTopNode : astImplem.topNodes )
     132                        astTopNode.accept(this, e);
     133        }
     134
     135        public void visit(AstInterf astInterf, LexicalEnvironment<VarType> e) {
     136                throw new UnsupportedOperationException();
     137        }
     138
     139        public void visit(AstIter astIter, LexicalEnvironment<VarType> e) {
     140                astIter.source1.accept(this, e);
     141                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    142142                defineVariablesFrom(t1, astIter.target);
    143143                astIter.source2.accept(this, t1);
     
    145145        }
    146146
    147         public void visit(AstLet astLet, LexicalEnvironment<VarType> t) {
    148                 astLet.source.accept(this, t);
    149                 LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     147        public void visit(AstLet astLet, LexicalEnvironment<VarType> e) {
     148                astLet.source.accept(this, e);
     149                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    150150                defineVariablesFrom(t1, astLet.target);
    151151                astLet.rest.accept(this, t1);
    152152        }
    153153
    154         public void visit(AstMatch astMatch, LexicalEnvironment<VarType> t) {
    155                 astMatch.source.accept(this, t);
     154        public void visit(AstMatch astMatch, LexicalEnvironment<VarType> e) {
     155                astMatch.source.accept(this, e);
    156156                AstSentence astSentence = astMatch.sentence;
    157                 LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     157                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    158158                addVariablesFrom(t1, astSentence.pattern.exp);
    159159                astSentence.rest.accept(this, t1);
    160160        }
    161161
    162         public void visit(AstName astName, LexicalEnvironment<VarType> t) {
    163                 throw new UnsupportedOperationException();
    164         }
    165 
    166         public void visit(AstNot astNot, LexicalEnvironment<VarType> t) {
    167                 astNot.source.accept(this, t);
    168                 astNot.rest.accept(this, t);
    169         }
    170 
    171         public void visit(AstNumberSymbol astNumberSymbol, LexicalEnvironment<VarType> t) {
    172                 throw new UnsupportedOperationException();
    173         }
    174 
    175         public void visit(AstObjDecl astObjDecl, LexicalEnvironment<VarType> t) {
    176                 throw new UnsupportedOperationException();
    177         }
    178 
    179         public void visit(AstParen astParen, LexicalEnvironment<VarType> t) {
    180                 throw new UnsupportedOperationException();
    181         }
    182 
    183         public void visit(AstPattern astPattern, LexicalEnvironment<VarType> t) {
    184                 throw new UnsupportedOperationException();
    185         }
    186 
    187         public void visit(AstPatternAlt astPatternAlt, LexicalEnvironment<VarType> t) {
     162        public void visit(AstName astName, LexicalEnvironment<VarType> e) {
     163                throw new UnsupportedOperationException();
     164        }
     165
     166        public void visit(AstNot astNot, LexicalEnvironment<VarType> e) {
     167                astNot.source.accept(this, e);
     168                astNot.rest.accept(this, e);
     169        }
     170
     171        public void visit(AstNumberSymbol astNumberSymbol, LexicalEnvironment<VarType> e) {
     172                throw new UnsupportedOperationException();
     173        }
     174
     175        public void visit(AstObjDecl astObjDecl, LexicalEnvironment<VarType> e) {
     176        }
     177
     178        public void visit(AstParen astParen, LexicalEnvironment<VarType> e) {
     179                throw new UnsupportedOperationException();
     180        }
     181
     182        public void visit(AstPattern astPattern, LexicalEnvironment<VarType> e) {
     183                throw new UnsupportedOperationException();
     184        }
     185
     186        public void visit(AstPatternAlt astPatternAlt, LexicalEnvironment<VarType> e) {
    188187                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    189                         LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     188                        LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(e);
    190189                        addVariablesFrom(t1, astSentence.pattern.exp);
    191190                        astSentence.rest.accept(this, t1);
     
    193192        }
    194193
    195         public void visit(AstRef astRef, LexicalEnvironment<VarType> t) {
    196                 throw new UnsupportedOperationException();
    197         }
    198 
    199         public void visit(AstResultExp astResultExp, LexicalEnvironment<VarType> t) {
     194        public void visit(AstRef astRef, LexicalEnvironment<VarType> e) {
     195                throw new UnsupportedOperationException();
     196        }
     197
     198        public void visit(AstResultExp astResultExp, LexicalEnvironment<VarType> e) {
    200199                AstExp astExp = astResultExp.exp;
    201200                VariableCollector vc = new VariableCollector();
     
    205204                                msgHandler.send(astVar.pos,
    206205                                                MsgCode.AVariableWithoutIndexInResultExpression);
    207                         else if (!t.contains(astVar.index))
     206                        else if (!e.contains(astVar.index))
    208207                                msgHandler.send(astVar.pos, MsgCode.Variable_X_IsNotDefined,
    209208                                                astVar.index);
    210                         else if (!t.isCompatibleWith(astVar.index, astVar.type))
     209                        else if (!e.isCompatibleWith(astVar.index, astVar.type))
    211210                                msgHandler
    212211                                                .send(
     
    217216        }
    218217
    219         public void visit(AstSentence astSentence, LexicalEnvironment<VarType> t) {
    220                 throw new UnsupportedOperationException();
    221         }
    222 
    223         public void visit(AstTraceAll astTraceAll, LexicalEnvironment<VarType> t) {
    224                 throw new UnsupportedOperationException();
    225         }
    226 
    227         public void visit(AstTrap astTrap, LexicalEnvironment<VarType> t) {
    228                 astTrap.path.accept(this, t);
    229                 visit(astTrap.patternAlt, t);
    230         }
    231 
    232         public void visit(AstVar astVar, LexicalEnvironment<VarType> t) {
    233                 throw new UnsupportedOperationException();
    234         }
    235 
    236         public void visit(AstWordSymbol astWordSymbol, LexicalEnvironment<VarType> t) {
     218        public void visit(AstSentence astSentence, LexicalEnvironment<VarType> e) {
     219                throw new UnsupportedOperationException();
     220        }
     221
     222        public void visit(AstTraceAll astTraceAll, LexicalEnvironment<VarType> e) {
     223        }
     224
     225        public void visit(AstTrap astTrap, LexicalEnvironment<VarType> e) {
     226                astTrap.path.accept(this, e);
     227                visit(astTrap.patternAlt, e);
     228        }
     229
     230        public void visit(AstVar astVar, LexicalEnvironment<VarType> e) {
     231                throw new UnsupportedOperationException();
     232        }
     233
     234        public void visit(AstWordSymbol astWordSymbol, LexicalEnvironment<VarType> e) {
    237235                throw new UnsupportedOperationException();
    238236        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstAlt.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstAltMatch.java

    r2259 r2262  
    2121
    2222        @Override
    23         public <T> void accept(VisitorWithEnv<T> v, T t) {
    24                 v.visit(this, t);
     23        public <E> void accept(VisitorWithEnv<E> v, E e) {
     24                v.visit(this, e);
    2525        }
    2626}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCall.java

    r2259 r2262  
    2323
    2424        @Override
    25         public <T> void accept(VisitorWithEnv<T> v, T t) {
    26                 v.visit(this, t);
     25        public <E> void accept(VisitorWithEnv<E> v, E e) {
     26                v.visit(this, e);
    2727        }
    2828}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCharSymbol.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstConstBinding.java

    r2259 r2262  
    1818
    1919        @Override
    20         public <T> void accept(VisitorWithEnv<T> v, T t) {
    21                 v.visit(this, t);
     20        public <E> void accept(VisitorWithEnv<E> v, E e) {
     21                v.visit(this, e);
    2222        }
    2323}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCut.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCutAll.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);               
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);               
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstError.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstExp.java

    r2259 r2262  
    2929
    3030        @Override
    31         public <T> void accept(VisitorWithEnv<T> v, T t) {
    32                 v.visit(this, t);
     31        public <E> void accept(VisitorWithEnv<E> v, E e) {
     32                v.visit(this, e);
    3333        }
    3434}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstFail.java

    r2259 r2262  
    1414
    1515        @Override
    16         public <T> void accept(VisitorWithEnv<T> v, T t) {
    17                 v.visit(this, t);
     16        public <E> void accept(VisitorWithEnv<E> v, E e) {
     17                v.visit(this, e);
    1818        }
    1919}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstFence.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstFuncDecl.java

    r2259 r2262  
    2727
    2828        @Override
    29         public <T> void accept(VisitorWithEnv<T> v, T t) {
    30                 v.visit(this, t);
     29        public <E> void accept(VisitorWithEnv<E> v, E e) {
     30                v.visit(this, e);
    3131        }
    3232}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstFuncDef.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstImplem.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstInterf.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstIter.java

    r2259 r2262  
    2626
    2727        @Override
    28         public <T> void accept(VisitorWithEnv<T> v, T t) {
    29                 v.visit(this, t);
     28        public <E> void accept(VisitorWithEnv<E> v, E e) {
     29                v.visit(this, e);
    3030        }
    3131}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstLet.java

    r2259 r2262  
    2323
    2424        @Override
    25         public <T> void accept(VisitorWithEnv<T> v, T t) {
    26                 v.visit(this, t);
     25        public <E> void accept(VisitorWithEnv<E> v, E e) {
     26                v.visit(this, e);
    2727        }
    2828}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstMatch.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstName.java

    r2259 r2262  
    2121
    2222        @Override
    23         public <T> void accept(VisitorWithEnv<T> v, T t) {
    24                 v.visit(this, t);
     23        public <E> void accept(VisitorWithEnv<E> v, E e) {
     24                v.visit(this, e);
    2525        }
    2626}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstNode.java

    r2259 r2262  
    1111        public abstract void accept(NodeVisitor v);
    1212       
    13         public abstract <T> void accept(VisitorWithEnv<T> v, T t);
     13        public abstract <E> void accept(VisitorWithEnv<E> v, E e);
    1414}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstNot.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstNumberSymbol.java

    r2259 r2262  
    2222
    2323        @Override
    24         public <T> void accept(VisitorWithEnv<T> v, T t) {
    25                 v.visit(this, t);
     24        public <E> void accept(VisitorWithEnv<E> v, E e) {
     25                v.visit(this, e);
    2626        }
    2727}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstObjDecl.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstParen.java

    r2259 r2262  
    2222
    2323        @Override
    24         public <T> void accept(VisitorWithEnv<T> v, T t) {
    25                 v.visit(this, t);
     24        public <E> void accept(VisitorWithEnv<E> v, E e) {
     25                v.visit(this, e);
    2626        }
    2727}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstPattern.java

    r2259 r2262  
    2121
    2222        @Override
    23         public <T> void accept(VisitorWithEnv<T> v, T t) {
    24                 v.visit(this, t);
     23        public <E> void accept(VisitorWithEnv<E> v, E e) {
     24                v.visit(this, e);
    2525        }
    2626}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstPatternAlt.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstRef.java

    r2259 r2262  
    1919
    2020        @Override
    21         public <T> void accept(VisitorWithEnv<T> v, T t) {
    22                 v.visit(this, t);
     21        public <E> void accept(VisitorWithEnv<E> v, E e) {
     22                v.visit(this, e);
    2323        }
    2424}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstResultExp.java

    r2259 r2262  
    1717
    1818        @Override
    19         public <T> void accept(VisitorWithEnv<T> v, T t) {
    20                 v.visit(this, t);
     19        public <E> void accept(VisitorWithEnv<E> v, E e) {
     20                v.visit(this, e);
    2121        }
    2222}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstSentence.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstTraceAll.java

    r2259 r2262  
    1212
    1313        @Override
    14         public <T> void accept(VisitorWithEnv<T> v, T t) {
    15                 v.visit(this, t);
     14        public <E> void accept(VisitorWithEnv<E> v, E e) {
     15                v.visit(this, e);
    1616        }
    1717}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstTrap.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstVar.java

    r2259 r2262  
    4545
    4646        @Override
    47         public <T> void accept(VisitorWithEnv<T> v, T t) {
    48                 v.visit(this, t);
     47        public <E> void accept(VisitorWithEnv<E> v, E e) {
     48                v.visit(this, e);
    4949        }
    5050}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstWordSymbol.java

    r2259 r2262  
    2020
    2121        @Override
    22         public <T> void accept(VisitorWithEnv<T> v, T t) {
    23                 v.visit(this, t);
     22        public <E> void accept(VisitorWithEnv<E> v, E e) {
     23                v.visit(this, e);
    2424        }
    2525}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/VisitorWithEnv.java

    r2259 r2262  
    11package org.refal.plus.comp.ast;
    22
    3 public interface VisitorWithEnv<T> {
    4         void visit(AstAlt astAlt, T t);
    5         void visit(AstAltMatch astAltMatch, T t);
    6         void visit(AstCall astCall, T t);
    7         void visit(AstCharSymbol astCharSymbol, T t);
    8         void visit(AstConstBinding astConstBinding, T t);
    9         void visit(AstCut astCut, T t);
    10         void visit(AstCutAll astCutAll, T t);
    11         void visit(AstError astError, T t);
    12         void visit(AstExp astExp, T t);
    13         void visit(AstFail astFail, T t);
    14         void visit(AstFence astFence, T t);
    15         void visit(AstFuncDecl astFuncDecl, T t);
    16         void visit(AstFuncDef astFuncDef, T t);
    17         void visit(AstImplem astImplem, T t);
    18         void visit(AstInterf astInterf, T t);
    19         void visit(AstIter astIter, T t);
    20         void visit(AstLet astLet, T t);
    21         void visit(AstMatch astMatch, T t);
    22         void visit(AstName astName, T t);
    23         void visit(AstNot astNot, T t);
    24         void visit(AstNumberSymbol astNumberSymbol, T t);
    25         void visit(AstObjDecl astObjDecl, T t);
    26         void visit(AstParen astParen, T t);
    27         void visit(AstPattern astPattern, T t);
    28         void visit(AstPatternAlt astPatternAlt, T t);
    29         void visit(AstRef astRef, T t);
    30         void visit(AstResultExp astResultExp, T t);
    31         void visit(AstSentence astSentence, T t);
    32         void visit(AstTraceAll astTraceAll, T t);
    33         void visit(AstTrap astTrap, T t);
    34         void visit(AstVar astVar, T t);
    35         void visit(AstWordSymbol astWordSymbol, T t);
     3public interface VisitorWithEnv<E> {
     4        void visit(AstAlt astAlt, E e);
     5        void visit(AstAltMatch astAltMatch, E e);
     6        void visit(AstCall astCall, E e);
     7        void visit(AstCharSymbol astCharSymbol, E e);
     8        void visit(AstConstBinding astConstBinding, E e);
     9        void visit(AstCut astCut, E e);
     10        void visit(AstCutAll astCutAll, E e);
     11        void visit(AstError astError, E e);
     12        void visit(AstExp astExp, E e);
     13        void visit(AstFail astFail, E e);
     14        void visit(AstFence astFence, E e);
     15        void visit(AstFuncDecl astFuncDecl, E e);
     16        void visit(AstFuncDef astFuncDef, E e);
     17        void visit(AstImplem astImplem, E e);
     18        void visit(AstInterf astInterf, E e);
     19        void visit(AstIter astIter, E e);
     20        void visit(AstLet astLet, E e);
     21        void visit(AstMatch astMatch, E e);
     22        void visit(AstName astName, E e);
     23        void visit(AstNot astNot, E e);
     24        void visit(AstNumberSymbol astNumberSymbol, E e);
     25        void visit(AstObjDecl astObjDecl, E e);
     26        void visit(AstParen astParen, E e);
     27        void visit(AstPattern astPattern, E e);
     28        void visit(AstPatternAlt astPatternAlt, E e);
     29        void visit(AstRef astRef, E e);
     30        void visit(AstResultExp astResultExp, E e);
     31        void visit(AstSentence astSentence, E e);
     32        void visit(AstTraceAll astTraceAll, E e);
     33        void visit(AstTrap astTrap, E e);
     34        void visit(AstVar astVar, E e);
     35        void visit(AstWordSymbol astWordSymbol, E e);
    3636}
Note: See TracChangeset for help on using the changeset viewer.