KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > groovy > antlr > Main


1 package org.codehaus.groovy.antlr;
2
3 import java.awt.event.WindowAdapter JavaDoc;
4 import java.awt.event.WindowEvent JavaDoc;
5 import java.io.File JavaDoc;
6 import java.io.FileReader JavaDoc;
7
8 import org.codehaus.groovy.antlr.parser.GroovyLexer;
9 import org.codehaus.groovy.antlr.parser.GroovyRecognizer;
10
11 import antlr.ASTFactory;
12 import antlr.CommonAST;
13 import antlr.Token;
14 import antlr.collections.AST;
15 import antlr.debug.misc.ASTFrame;
16
17 class Main {
18
19     static boolean whitespaceIncluded = false;
20
21     static boolean showTree = false;
22     //static boolean xml = false;
23 static boolean verbose = false;
24     public static void main(String JavaDoc[] args) {
25         // Use a try/catch block for parser exceptions
26 try {
27             // if we have at least one command-line argument
28 if (args.length > 0 ) {
29                 System.err.println("Parsing...");
30
31                 // for each directory/file specified on the command line
32 for(int i=0; i< args.length;i++) {
33                     if ( args[i].equals("-showtree") ) {
34                         showTree = true;
35                     }
36                     //else if ( args[i].equals("-xml") ) {
37 // xml = true;
38 //}
39 else if ( args[i].equals("-verbose") ) {
40                         verbose = true;
41                     }
42                     else if ( args[i].equals("-trace") ) {
43                         GroovyRecognizer.tracing = true;
44                         GroovyLexer.tracing = true;
45                     }
46                     else if ( args[i].equals("-traceParser") ) {
47                         GroovyRecognizer.tracing = true;
48                     }
49                     else if ( args[i].equals("-traceLexer") ) {
50                         GroovyLexer.tracing = true;
51                     }
52                                         else if ( args[i].equals("-whitespaceIncluded") ) {
53                                             whitespaceIncluded = true;
54                                         }
55                                         else {
56                         doFile(new File JavaDoc(args[i])); // parse it
57 }
58                 } }
59             else
60                 System.err.println("Usage: java -jar groovyc.jar [-showtree] [-verbose] [-trace{,Lexer,Parser}]"+
61                                    "<directory or file name>");
62         }
63         catch(Exception JavaDoc e) {
64             System.err.println("exception: "+e);
65             e.printStackTrace(System.err); // so we can get stack trace
66 }
67     }
68
69
70     // This method decides what action to take based on the type of
71 // file we are looking at
72 public static void doFile(File JavaDoc f)
73                               throws Exception JavaDoc {
74         // If this is a directory, walk each file/dir in that directory
75 if (f.isDirectory()) {
76             String JavaDoc files[] = f.list();
77             for(int i=0; i < files.length; i++)
78                 doFile(new File JavaDoc(f, files[i]));
79         }
80
81         // otherwise, if this is a groovy file, parse it!
82 else if (f.getName().endsWith(".groovy")) {
83             System.err.println(" --- "+f.getAbsolutePath());
84             // parseFile(f.getName(), new FileInputStream(f));
85 SourceBuffer sourceBuffer = new SourceBuffer();
86             UnicodeEscapingReader unicodeReader = new UnicodeEscapingReader(new FileReader JavaDoc(f),sourceBuffer);
87             GroovyLexer lexer = new GroovyLexer(unicodeReader);
88             unicodeReader.setLexer(lexer);
89             parseFile(f.getName(),lexer,sourceBuffer);
90         }
91     }
92
93     // Here's where we do the real work...
94 public static void parseFile(String JavaDoc f, GroovyLexer l, SourceBuffer sourceBuffer)
95                                  throws Exception JavaDoc {
96         try {
97             // Create a parser that reads from the scanner
98 GroovyRecognizer parser = GroovyRecognizer.make(l);
99             parser.setSourceBuffer(sourceBuffer);
100             parser.setFilename(f);
101                         
102                         if (whitespaceIncluded) {
103                             GroovyLexer lexer = parser.getLexer();
104                             lexer.setWhitespaceIncluded(true);
105                             while (true) {
106                                 Token t = lexer.nextToken();
107                                 System.out.println(t);
108                                 if (t == null || t.getType() == Token.EOF_TYPE) break;
109                             }
110                             return;
111                         }
112
113             // start parsing at the compilationUnit rule
114 parser.compilationUnit();
115             
116             System.out.println("parseFile "+f+" => "+parser.getAST());
117
118             // do something with the tree
119 doTreeAction(f, parser.getAST(), parser.getTokenNames());
120         }
121         catch (Exception JavaDoc e) {
122             System.err.println("parser exception: "+e);
123             e.printStackTrace(); // so we can get stack trace
124 }
125     }
126     
127     public static void doTreeAction(String JavaDoc f, AST t, String JavaDoc[] tokenNames) {
128         if ( t==null ) return;
129         if ( showTree ) {
130             CommonAST.setVerboseStringConversion(true, tokenNames);
131             ASTFactory factory = new ASTFactory();
132             AST r = factory.create(0,"AST ROOT");
133             r.setFirstChild(t);
134             final ASTFrame frame = new ASTFrame("Groovy AST", r);
135             frame.setVisible(true);
136             frame.addWindowListener(
137                 new WindowAdapter JavaDoc() {
138                    public void windowClosing (WindowEvent JavaDoc e) {
139                        frame.setVisible(false); // hide the Frame
140 frame.dispose();
141                        System.exit(0);
142                    }
143                 }
144             );
145             if (verbose) System.out.println(t.toStringList());
146         }
147         /*if ( xml ) {
148             ((CommonAST)t).setVerboseStringConversion(true, tokenNames);
149             ASTFactory factory = new ASTFactory();
150             AST r = factory.create(0,"AST ROOT");
151             r.setFirstChild(t);
152             XStream xstream = new XStream();
153             xstream.alias("ast", CommonAST.class);
154             try {
155                 xstream.toXML(r,new FileWriter(f + ".xml"));
156                 System.out.println("Written AST to " + f + ".xml");
157             } catch (Exception e) {
158                 System.out.println("couldn't write to " + f + ".xml");
159                 e.printStackTrace();
160             }
161             //if (verbose) System.out.println(t.toStringList());
162         }*/
163     /*@todo
164         GroovyTreeParser tparse = new GroovyTreeParser();
165         try {
166             tparse.compilationUnit(t);
167             if (verbose) System.out.println("successful walk of result AST for "+f);
168         }
169         catch (RecognitionException e) {
170             System.err.println(e.getMessage());
171             e.printStackTrace();
172         }
173     @todo*/
174
175     }
176 }
177
178
Popular Tags