Changeset 2717


Ignore:
Timestamp:
Apr 19, 2007, 3:18:13 AM (14 years ago)
Author:
orlov
Message:
  • Refal Abstract Syntax generator is finished.
Location:
devel-tools/trunk/eclipse
Files:
4 edited

Legend:

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

    r2681 r2717  
    55
    66public final class AstPatternAlt extends AstPath {
    7         boolean failing;
     7        public boolean failing;
    88
    99        public AstSentence[] sentenceList;
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt.extcomp/META-INF/MANIFEST.MF

    r2672 r2717  
    1212 org.refal.plus.wrappers.org.objectweb.asm,
    1313 org.refal.plus.wrappers.org.refal.plus.comp,
    14  org.refal.plus.wrappers.org.refal.plus.library,
    1514 refal.plus
    1615Bundle-RequiredExecutionEnvironment: J2SE-1.5
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt/src/org/refal/plus/rfpdt/core/builder/RefalASGenerator.java

    r2698 r2717  
    22
    33import java.util.LinkedList;
     4import java.util.List;
    45
    56import org.refal.plus.Expr;
     
    2829import org.refal.plus.rfpdt.comp.ast.AstObjDecl;
    2930import org.refal.plus.rfpdt.comp.ast.AstParen;
     31import org.refal.plus.rfpdt.comp.ast.AstPath;
    3032import org.refal.plus.rfpdt.comp.ast.AstPattern;
    3133import org.refal.plus.rfpdt.comp.ast.AstPatternAlt;
     
    4143import org.refal.plus.rfpdt.comp.ast.AstVar;
    4244import org.refal.plus.rfpdt.comp.ast.AstWordSymbol;
    43 import org.refal.plus.rfpdt.comp.ast.NodeVisitor;
    44 
    45 public class RefalASGenerator implements NodeVisitor {
     45import org.refal.plus.rfpdt.comp.ast.VisitorWithEnv;
     46
     47public class RefalASGenerator implements VisitorWithEnv<List<Object>> {
    4648
    4749        public static Expr generateAS(AstImplem astImplem) {
    4850                RefalASGenerator generator = new RefalASGenerator();
    49                 generator.visit(astImplem);
    50                 return (Expr) generator.buf;
     51                LinkedList<Object> buf = new LinkedList<Object>();
     52                generator.visit(astImplem, buf);
     53                return new Expr(Expr.fromArrayUnsafe(buf.toArray()));
    5154        }
    5255
    5356        private String moduleName;
    54 
    55         private Object buf;
    5657
    5758        private static final Word MODULE  = new Word("MODULE");
     
    6162        private static final Word FUNC    = new Word("FUNC");
    6263        private static final Word FUNC_Q  = new Word("FUNC?");
     64        private static final Word CONST   = new Word("CONST");
    6365        private static final Word BRANCH  = new Word("BRANCH");
     66        private static final Word ALT     = new Word("ALT");
     67        private static final Word ALT_Q   = new Word("ALT?");
     68        private static final Word NOT     = new Word("NOT");
     69        private static final Word ITER    = new Word("ITER");
     70        private static final Word TRY     = new Word("TRY");
    6471        private static final Word FORMAT  = new Word("FORMAT");
    6572        private static final Word LEFT    = new Word("LEFT");
    6673        private static final Word RIGHT   = new Word("RIGHT");
    6774        private static final Word RESULT  = new Word("RESULT");
     75        private static final Word CALL    = new Word("CALL");
     76        private static final Word REF     = new Word("REF");
     77        private static final Word CUT     = new Word("CUT");
     78        private static final Word STAKE   = new Word("STAKE");
     79        private static final Word CUTALL  = new Word("CUTALL");
     80        private static final Word FAIL    = new Word("FAIL");
     81        private static final Word ERROR   = new Word("ERROR");
    6882
    6983        private static Expr makeName(String name) {
     
    7589        }
    7690
    77         public void visit(AstAlt astAlt) {
    78                 // TODO Auto-generated method stub
    79                
    80         }
    81 
    82         public void visit(AstAltMatch astAltMatch) {
    83                 // TODO Auto-generated method stub
    84                
    85         }
    86 
    87         public void visit(AstCall astCall) {
    88                 // TODO Auto-generated method stub
    89                
    90         }
    91 
    92         public void visit(AstCharSymbol astCharSymbol) {
    93                 // TODO Auto-generated method stub
    94                
    95         }
    96 
    97         public void visit(AstConstBinding astConstBinding) {
    98                 // TODO Auto-generated method stub
    99                
    100         }
    101 
    102         public void visit(AstCut astCut) {
    103                 // TODO Auto-generated method stub
    104                
    105         }
    106 
    107         public void visit(AstCutAll astCutAll) {
    108                 // TODO Auto-generated method stub
    109                
    110         }
    111 
    112         public void visit(AstError astError) {
    113                 // TODO Auto-generated method stub
    114                
    115         }
    116 
    117         public void visit(AstExp astExp) {
    118                 Object[] items = new Object[astExp.termList.size()];
    119                 int i = 0;
     91        public void visit(AstAlt astAlt, List<Object> e) {
     92                LinkedList<Object> items = new LinkedList<Object>();
     93                items.add(astAlt.failing ? ALT_Q : ALT);
     94                for (AstPath astPath : astAlt.pathList) {
     95                        LinkedList<Object> buf = new LinkedList<Object>();
     96                        buf.add(BRANCH);
     97                        astPath.accept(this, buf);
     98                        items.add(Expr.fromArrayUnsafe(buf.toArray()));
     99                }
     100                e.add(Expr.fromArrayUnsafe(items.toArray()));
     101        }
     102
     103        public void visit(AstAltMatch astAltMatch, List<Object> e) {
     104                astAltMatch.source.accept(this, e);
     105                astAltMatch.patternAlt.accept(this, e);
     106        }
     107
     108        public void visit(AstCall astCall, List<Object> e) {
     109                LinkedList<Object> items = new LinkedList<Object>();
     110                items.add(CALL);
     111                String modName = astCall.funcDecl.module;
     112                if (modName == null)
     113                        modName = moduleName;
     114                items.add(makeName(modName + "." + astCall.name.identifier));
     115                astCall.arg.accept(this, items);
     116                e.add(Expr.fromArrayUnsafe(items.toArray()));
     117        }
     118
     119        public void visit(AstCharSymbol astCharSymbol, List<Object> e) {
     120                e.add(astCharSymbol.character);
     121        }
     122
     123        public void visit(AstConstBinding astConstBinding, List<Object> e) {
     124                LinkedList<Object> items = new LinkedList<Object>();
     125                if (astConstBinding.module == null)
     126                        items.add(LOCAL);
     127                else if (astConstBinding.module.equals(moduleName))
     128                        items.add(EXPORT);
     129                else
     130                        items.add(IMPORT);
     131                items.add(CONST);
     132                String modName = astConstBinding.module != null ? astConstBinding.module : moduleName;
     133                items.add(makeName(modName + "." + astConstBinding.name.identifier));
     134                astConstBinding.exp.accept(this, items);
     135                e.add(Expr.fromArrayUnsafe(items.toArray()));
     136        }
     137
     138        public void visit(AstCut astCut, List<Object> e) {
     139                e.add(new Expr(CUT));
     140                astCut.path.accept(this, e);
     141        }
     142
     143        public void visit(AstCutAll astCutAll, List<Object> e) {
     144                e.add(new Expr(CUTALL));
     145                astCutAll.path.accept(this, e);
     146        }
     147
     148        public void visit(AstError astError, List<Object> e) {
     149                e.add(new Expr(ERROR));
     150                astError.path.accept(this, e);
     151        }
     152
     153        public void visit(AstExp astExp, List<Object> e) {
    120154                for (AstTerm astTerm : astExp.termList) {
    121                         astTerm.accept(this);
    122                         items[i++] = buf;
    123                 }
    124                 buf = Expr.fromArrayUnsafe(items);
    125         }
    126 
    127         public void visit(AstFail astFail) {
    128                 // TODO Auto-generated method stub
    129                
    130         }
    131 
    132         public void visit(AstFence astFence) {
    133                 // TODO Auto-generated method stub
    134                
    135         }
    136 
    137         public void visit(AstFuncDecl astFuncDecl) {
     155                        astTerm.accept(this, e);
     156                }
     157        }
     158
     159        public void visit(AstFail astFail, List<Object> e) {
     160                e.add(new Expr(FAIL));
     161        }
     162
     163        public void visit(AstFence astFence, List<Object> e) {
     164                e.add(new Expr(STAKE));
     165                astFence.path.accept(this, e);
     166        }
     167
     168        public void visit(AstFuncDecl astFuncDecl, List<Object> e) {
    138169                LinkedList<Object> items = new LinkedList<Object>();
    139170                if (astFuncDecl.funcDef == null)
     
    146177                String modName = astFuncDecl.module != null ? astFuncDecl.module : moduleName;
    147178                items.add(makeName(modName + "." + astFuncDecl.name.identifier));
    148                 astFuncDecl.inFormat.accept(this);
    149                 items.add(buf);
    150                 astFuncDecl.outFormat.accept(this);
    151                 items.add(buf);
     179                LinkedList<Object> inFormat = new LinkedList<Object>();
     180                astFuncDecl.inFormat.accept(this, inFormat);
     181                items.add(Expr.fromArrayUnsafe(inFormat.toArray()));
     182                LinkedList<Object> outFormat = new LinkedList<Object>();
     183                astFuncDecl.outFormat.accept(this, outFormat);
     184                items.add(Expr.fromArrayUnsafe(outFormat.toArray()));
    152185                if (astFuncDecl.funcDef != null) {
    153                         astFuncDecl.funcDef.body.accept(this);
    154                         items.add(Expr.concat(new Expr(BRANCH), new Expr(buf)));
    155                 }
    156                 buf = Expr.fromArrayUnsafe(items.toArray());
    157         }
    158 
    159         public void visit(AstFuncDef astFuncDef) {
    160         }
    161 
    162         public void visit(AstImplem astImplem) {
     186                        LinkedList<Object> body = new LinkedList<Object>();
     187                        body.add(BRANCH);
     188                        astFuncDecl.funcDef.body.accept(this, body);
     189                        items.add(Expr.fromArrayUnsafe(body.toArray()));
     190                }
     191                e.add(Expr.fromArrayUnsafe(items.toArray()));
     192        }
     193
     194        public void visit(AstFuncDef astFuncDef, List<Object> e) {
     195        }
     196
     197        public void visit(AstImplem astImplem, List<Object> e) {
    163198                this.moduleName = astImplem.moduleName;
    164                 LinkedList<Object> items = new LinkedList<Object>();
    165                 items.add(MODULE);
    166                 items.add(makeName(astImplem.moduleName));
     199                e.add(MODULE);
     200                e.add(makeName(astImplem.moduleName));
    167201                for (AstUse astUse : astImplem.useList) {
    168202                        for (AstTopNode astTopNode : astUse.interf.topNodes) {
    169                                 astTopNode.accept(this);
    170                                 items.add(buf);
     203                                astTopNode.accept(this, e);
    171204                        }
    172205                }
    173206                for (AstTopNode astTopNode : astImplem.topNodes) {
    174                         astTopNode.accept(this);
    175                         items.add(buf);
    176                 }
    177                 buf = new Expr(Expr.fromArrayUnsafe(items.toArray()));
    178         }
    179 
    180         public void visit(AstInterf astInterf) {
     207                        astTopNode.accept(this, e);
     208                }
     209        }
     210
     211        public void visit(AstInterf astInterf, List<Object> e) {
    181212                throw new UnsupportedOperationException();
    182213        }
    183214
    184         public void visit(AstIter astIter) {
    185                 // TODO Auto-generated method stub
    186                
    187         }
    188 
    189         public void visit(AstLet astLet) {
    190                 astLet.target.accept(this);
    191                 Expr format = Expr.concat(new Expr(FORMAT), (Expr) buf);
    192                 astLet.source.accept(this);
    193                 buf = Expr.fromArrayUnsafe(new Object[] { buf, format });
    194         }
    195 
    196         public void visit(AstMatch astMatch) {
    197                 // TODO Auto-generated method stub
    198                
    199         }
    200 
    201         public void visit(AstName astName) {
    202                 // TODO Auto-generated method stub
    203                
    204         }
    205 
    206         public void visit(AstNot astNot) {
    207                 // TODO Auto-generated method stub
    208                
    209         }
    210 
    211         public void visit(AstNumberSymbol astNumberSymbol) {
    212                 // TODO Auto-generated method stub
    213                
    214         }
    215 
    216         public void visit(AstObjDecl astObjDecl) {
    217                 // TODO Auto-generated method stub
    218                
    219         }
    220 
    221         public void visit(AstParen astParen) {
    222                 // TODO Auto-generated method stub
    223                
    224         }
    225 
    226         public void visit(AstPattern astPattern) {
    227                 Expr tag = new Expr(astPattern.r ? RIGHT : LEFT);
    228                 astPattern.exp.accept(this);
    229                 buf = Expr.concat(tag, (Expr) buf);
    230         }
    231 
    232         public void visit(AstPatternAlt astPatternAlt) {
    233                 // TODO Auto-generated method stub
    234                
    235         }
    236 
    237         public void visit(AstRef astRef) {
    238                 // TODO Auto-generated method stub
    239                
    240         }
    241 
    242         public void visit(AstRefSymbol astRefSymbol) {
    243                 // TODO Auto-generated method stub
    244                
    245         }
    246 
    247         public void visit(AstResultExp astResultExp) {
    248                 astResultExp.exp.accept(this);
    249                 buf = Expr.concat(new Expr(RESULT), (Expr) buf);
    250         }
    251 
    252         public void visit(AstSentence astSentence) {
    253                 LinkedList<Object> items = new LinkedList<Object>();
     215        public void visit(AstIter astIter, List<Object> e) {
     216                astIter.source1.accept(this, e);
     217                LinkedList<Object> iter = new LinkedList<Object>();
     218                iter.add(ITER);
     219                LinkedList<Object> source = new LinkedList<Object>();
     220                source.add(BRANCH);
     221                astIter.source2.accept(this, source);
     222                iter.add(Expr.fromArrayUnsafe(source.toArray()));
     223                LinkedList<Object> format = new LinkedList<Object>();
     224                format.add(FORMAT);
     225                astIter.target.accept(this, format);
     226                iter.add(Expr.fromArrayUnsafe(format.toArray()));
     227                LinkedList<Object> rest = new LinkedList<Object>();
     228                rest.add(BRANCH);
     229                astIter.rest.accept(this, rest);
     230                iter.add(Expr.fromArrayUnsafe(rest.toArray()));
     231                e.add(Expr.fromArrayUnsafe(iter.toArray()));
     232        }
     233
     234        public void visit(AstLet astLet, List<Object> e) {
     235                astLet.source.accept(this, e);
     236                LinkedList<Object> format = new LinkedList<Object>();
     237                format.add(FORMAT);
     238                astLet.target.accept(this, format);
     239                e.add(Expr.fromArrayUnsafe(format.toArray()));
     240                astLet.rest.accept(this, e);
     241        }
     242
     243        public void visit(AstMatch astMatch, List<Object> e) {
     244                astMatch.source.accept(this, e);
     245                astMatch.sentence.accept(this, e);
     246        }
     247
     248        public void visit(AstName astName, List<Object> e) {
     249                throw new UnsupportedOperationException();
     250        }
     251
     252        public void visit(AstNot astNot, List<Object> e) {
     253                Object[] items = new Object[2];
     254                items[0] = NOT;
     255                LinkedList<Object> source = new LinkedList<Object>();
     256                source.add(BRANCH);
     257                astNot.source.accept(this, source);
     258                items[1] = Expr.fromArrayUnsafe(source.toArray());
     259                e.add(Expr.fromArrayUnsafe(items));
     260                astNot.rest.accept(this, e);
     261        }
     262
     263        public void visit(AstNumberSymbol astNumberSymbol, List<Object> e) {
     264                e.add(astNumberSymbol.bigInteger);
     265        }
     266
     267        public void visit(AstObjDecl astObjDecl, List<Object> e) {
     268                LinkedList<Object> items = new LinkedList<Object>();
     269                if (astObjDecl.module == null)
     270                        items.add(LOCAL);
     271                else if (astObjDecl.module.equals(moduleName))
     272                        items.add(EXPORT);
     273                else
     274                        items.add(IMPORT);
     275                items.add(new Word(astObjDecl.kind.toString().toUpperCase()));
     276                String modName = astObjDecl.module != null ? astObjDecl.module : moduleName;
     277                items.add(makeName(modName + "." + astObjDecl.name.identifier));
     278                e.add(Expr.fromArrayUnsafe(items.toArray()));
     279        }
     280
     281        public void visit(AstParen astParen, List<Object> e) {
     282                LinkedList<Object> items = new LinkedList<Object>();
     283                astParen.exp.accept(this, items);
     284                e.add(new Expr(Expr.fromArrayUnsafe(items.toArray())));
     285        }
     286
     287        public void visit(AstPattern astPattern, List<Object> e) {
     288                LinkedList<Object> items = new LinkedList<Object>();
     289                items.add(astPattern.r ? RIGHT : LEFT);
     290                astPattern.exp.accept(this, items);
     291                e.add(Expr.fromArrayUnsafe(items.toArray()));
     292        }
     293
     294        public void visit(AstPatternAlt astPatternAlt, List<Object> e) {
     295                LinkedList<Object> items = new LinkedList<Object>();
     296                items.add(astPatternAlt.failing ? ALT_Q : ALT);
     297                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     298                        LinkedList<Object> sentence = new LinkedList<Object>();
     299                        sentence.add(BRANCH);
     300                        astSentence.accept(this, sentence);
     301                        items.add(Expr.fromArrayUnsafe(sentence.toArray()));
     302                }
     303                e.add(Expr.fromArrayUnsafe(items.toArray()));
     304        }
     305
     306        public void visit(AstRef astRef, List<Object> e) {
     307                LinkedList<Object> items = new LinkedList<Object>();
     308                items.add(REF);
     309                String modName = astRef.decl.module;
     310                if (modName == null)
     311                        modName = moduleName;
     312                items.add(makeName(modName + "." + astRef.name.identifier));
     313                e.add(Expr.fromArrayUnsafe(items.toArray()));
     314        }
     315
     316        public void visit(AstRefSymbol astRefSymbol, List<Object> e) {
     317                LinkedList<Object> items = new LinkedList<Object>();
     318                items.add(REF);
     319                String modName = astRefSymbol.decl.module;
     320                if (modName == null)
     321                        modName = moduleName;
     322                items.add(makeName(modName + "." + astRefSymbol.name.identifier));
     323                e.add(Expr.fromArrayUnsafe(items.toArray()));
     324        }
     325
     326        public void visit(AstResultExp astResultExp, List<Object> e) {
     327                LinkedList<Object> items = new LinkedList<Object>();
     328                items.add(RESULT);
     329                astResultExp.exp.accept(this, items);
     330                e.add(Expr.fromArrayUnsafe(items.toArray()));
     331        }
     332
     333        public void visit(AstSentence astSentence, List<Object> e) {
    254334                if (astSentence.pattern != null) {
    255                         astSentence.pattern.accept(this);
    256                         items.add(buf);
    257                 }
    258                 astSentence.rest.accept(this);
    259                 items.add(buf);
    260                 buf = Expr.fromArrayUnsafe(items.toArray());
    261         }
    262 
    263         public void visit(AstTraceAll astTraceAll) {
    264                 // TODO Auto-generated method stub
    265                
    266         }
    267 
    268         public void visit(AstTrap astTrap) {
    269                 // TODO Auto-generated method stub
    270                
    271         }
    272 
    273         public void visit(AstUse astUse) {
    274                 // TODO Auto-generated method stub
    275                
    276         }
    277 
    278         public void visit(AstVar astVar) {
    279                 Object[] items = {
    280                                 new Word(astVar.type.name() + "VAR"),
    281                                 new Expr(new Word(astVar.index)),
    282                 };
    283                 buf = Expr.fromArrayUnsafe(items);
    284         }
    285 
    286         public void visit(AstWordSymbol astWordSymbol) {
    287                 // TODO Auto-generated method stub
    288                
     335                        astSentence.pattern.accept(this, e);
     336                }
     337                astSentence.rest.accept(this, e);
     338        }
     339
     340        public void visit(AstTraceAll astTraceAll, List<Object> e) {
     341        }
     342
     343        public void visit(AstTrap astTrap, List<Object> e) {
     344                LinkedList<Object> items = new LinkedList<Object>();
     345                items.add(TRY);
     346                LinkedList<Object> trap = new LinkedList<Object>();
     347                trap.add(BRANCH);
     348                astTrap.path.accept(this, trap);
     349                items.add(Expr.fromArrayUnsafe(trap.toArray()));
     350                astTrap.patternAlt.accept(this, items);
     351                e.add(Expr.fromArrayUnsafe(items.toArray()));
     352        }
     353
     354        public void visit(AstUse astUse, List<Object> e) {
     355        }
     356
     357        public void visit(AstVar astVar, List<Object> e) {
     358                Object[] items = new Object[2];
     359                items[0] = new Word(astVar.type.name() + "VAR");
     360                if (astVar.index.length() > 0)
     361                        items[1] = new Expr(new Word(astVar.index));
     362                else
     363                        items[1] = new Expr(new Word("$tmp-" + astVar.pos.charStart));
     364                e.add(Expr.fromArrayUnsafe(items));
     365        }
     366
     367        public void visit(AstWordSymbol astWordSymbol, List<Object> e) {
     368                e.add(new Word(astWordSymbol.word));
    289369        }
    290370
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt/src/org/refal/plus/rfpdt/core/builder/RfpBuilder.java

    r2713 r2717  
    285285                CompilerEnvironment environment = new IdeCompilerEnvironment(file);
    286286                final MsgHandler msgHandler = environment.getMsgHandler();
    287                 @SuppressWarnings("unused")
    288287                AstImplem astImplem = Checker.getModuleImplementation(environment);
    289288                if (msgHandler.getErrorCount() > 0)
    290289                        return;
    291                 //System.out.println(RefalASGenerator.generateAS(astImplem).formattedRepresentation());
     290                IPath filePath = file.getProjectRelativePath().removeFileExtension();
     291                IFile asrFile = getProject().getFile(filePath.addFileExtension("asr"));
     292                String asr = RefalASGenerator.generateAS(astImplem).formattedRepresentation();
     293                try {
     294                        if (asrFile.exists())
     295                                asrFile.delete(false, null);
     296                        asrFile.create(new ByteArrayInputStream(asr.getBytes()), false, null);
     297                } catch (CoreException e) {
     298                        System.err.println(e);
     299                }
    292300                ExternalCompilerEnvironment externalCompilerEnvironment = new ExternalCompilerEnvironment(
    293301                                file);
     
    296304                                        .CompileModule(externalCompilerEnvironment);
    297305                } catch (org.refal.plus.RefalException e) {
    298                         System.out.println(e);
     306                        System.err.println(e);
    299307                }
    300308        }
Note: See TracChangeset for help on using the changeset viewer.