KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > fri > patterns > interpreter > parsergenerator > builder > SerializedParser


1 package fri.patterns.interpreter.parsergenerator.builder;
2
3 import java.io.File JavaDoc;
4 import fri.patterns.interpreter.parsergenerator.*;
5 import fri.patterns.interpreter.parsergenerator.syntax.Syntax;
6
7 /**
8     This class is definitely the shortest way to construct a Parser (with Lexer) for a Syntax.
9     It uses all serialization utils in this package to quickly build a parsing environment.
10     This factory accepts a syntax where parser and lexer rules were mixed.
11     <p>
12     Example (syntax input from a file):
13     <pre>
14     File ebnfFile = new File("MySyntax.syntax");
15     Parser parser = new SerializedParser().get(ebnfFile);
16     </pre>
17     or (syntax input from a Reader, must pass a filename):
18     <pre>
19     Reader ebnfReader = new InputStreamReader(MySyntaxSemantic.class.getResourceAsStream("MySyntax.syntax"));
20     Parser parser = new SerializedParser().get(ebnfReader, "MySyntax");
21     </pre>
22     
23     @author (c) 2002, Fritz Ritzberger
24 */
25
26 public class SerializedParser extends SerializedObject
27 {
28     /** The suffix for serialized Parser files. */
29     public static final String JavaDoc PARSERFILE_SUFFIX = "Parser.ser";
30     protected boolean PRODUCTION; // setting this to false in constructor will prevent the parsing environment from being serialized
31
32     /** Create a Parser factory that caches built Lexers. */
33     public SerializedParser() {
34         this(true);
35     }
36     
37     /** Create a Parser factory that caches built Lexers. @param production when false the Parser will not be serialized. */
38     public SerializedParser(boolean production) {
39         this.PRODUCTION = production;
40     }
41
42     /**
43         Builds the Parser from scratch if not found its parts in filesystem, else loads all serialized parts.
44         @param syntaxInput the mixed lexer/parser syntax as File, InputStream, List of Lists, String [][] or Syntax.
45         @return Parser, built from scratch or loaded from filesystem.
46     */
47     public Parser get(Object JavaDoc syntaxInput)
48         throws Exception JavaDoc
49     {
50         return get(null, syntaxInput);
51     }
52
53     /**
54         Builds the Parser from scratch if not found its parts in filesystem, else loads all serialized parts.
55         @param syntaxInput the mixed lexer/parser syntax as File, InputStream, List of Lists, String [][] or Syntax.
56         @param baseName basename for serialization, can be null
57         @return Parser, built from scratch or loaded from filesystem.
58     */
59     public Parser get(Object JavaDoc syntaxInput, String JavaDoc baseName)
60         throws Exception JavaDoc
61     {
62         return get(null, syntaxInput, baseName);
63     }
64
65     /**
66         Builds the Parser from scratch if not found its parts in filesystem, else loads all serialized parts.
67         @param parserType the class of ParserTables to create for the syntax (LALRParserTables.class is default).
68         @param syntaxInput the mixed lexer/parser syntax as File, InputStream, List of Lists, String [][] or Syntax.
69         @return Parser, built from scratch or loaded from filesystem.
70     */
71     public Parser get(Class JavaDoc parserType, Object JavaDoc syntaxInput)
72         throws Exception JavaDoc
73     {
74         return get(parserType, syntaxInput, null);
75     }
76
77     /**
78         Builds the parsing environment from scratch if not found its parts in filesystem, else loads all serialized parts.
79         @param parserType the class of ParserTables to create for the syntax (LALRParserTables.class is default).
80         @param syntaxInput the mixed lexer/parser syntax as File, InputStream, List of Lists, String [][] or Syntax.
81         @param baseName basename for serialization, can be null
82         @return Parser, built from scratch or loaded from filesystem.
83     */
84     public Parser get(Class JavaDoc parserType, Object JavaDoc syntaxInput, String JavaDoc baseName)
85         throws Exception JavaDoc
86     {
87         fri.util.TimeStopper ts = new fri.util.TimeStopper();
88         
89         Parser parser = PRODUCTION ? (Parser) read(ensureFileName(syntaxInput, baseName)) : null;
90         if (parser == null) {
91             SerializedLexer lexerFactory = newSerializedLexer();
92             lexerFactory.PRODUCTION = false; // do not store this lexer, it will be stored with parser
93 Lexer lexer = lexerFactory.buildAndStoreLexer(syntaxInput, baseName, null, null); // null: forces syntax separation
94 Syntax parserSyntax = lexerFactory.getSyntaxSeparation().getParserSyntax();
95             SerializedTables tablesFactory = new SerializedTables(false); // do not store this tables, it will be stored with parser
96 ParserTables tables = tablesFactory.buildAndStoreParserTables(parserType, parserSyntax, syntaxInput, baseName);
97             parser = new Parser(tables);
98             parser.setLexer(lexer);
99             
100             if (PRODUCTION)
101                 write(ensureFileName(syntaxInput, baseName), parser);
102         }
103
104         System.err.println("Parser construction took "+ts.getTimeMillis()+" millis");
105         return parser;
106     }
107
108     /** To be overridden when a modified SerializedLexer is needed. */
109     protected SerializedLexer newSerializedLexer()
110         throws Exception JavaDoc
111     {
112         return new SerializedLexer(false);
113     }
114     
115     private String JavaDoc ensureFileName(Object JavaDoc syntaxInput, String JavaDoc baseName) {
116         if (baseName == null)
117             baseName = baseNameFromSyntax(syntaxInput);
118         return baseName+PARSERFILE_SUFFIX;
119     }
120
121
122
123     /** Test main. Building serialized Java Parser takes 740, building from scratch takes 4000 millis. */
124     public static void main(String JavaDoc [] args) {
125         try {
126             File JavaDoc ebnfFile = new File JavaDoc("fri/patterns/interpreter/parsergenerator/syntax/builder/examples/SyntaxBuilder.syntax");
127             File JavaDoc fileToParse = new File JavaDoc("fri/patterns/interpreter/parsergenerator/syntax/builder/examples/SimpleSyntax.syntax");
128
129             fri.util.TimeStopper ts = new fri.util.TimeStopper();
130             SerializedParser parserBuilder = new SerializedParser();
131             Parser parser = parserBuilder.get(null, ebnfFile, "SyntaxBuilder");
132             Lexer lexer = parser.getLexer();
133             System.err.println("Parser was built in "+ts.getTimeMillis()+" millis");
134             lexer.setDebug(true);
135
136             lexer.setInput(fileToParse);
137             boolean ok = parser.parse(lexer);
138             System.err.println("Parsing result is "+ok);
139         }
140         catch (Exception JavaDoc e) {
141             e.printStackTrace();
142         }
143     }
144
145 }
146
Popular Tags