diagnosticcodegenerator.java

来自「SRI international 发布的OAA框架软件」· Java 代码 · 共 892 行 · 第 1/2 页

package antlr_oaa;

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/RIGHTS.html
 *
 * $Id: DiagnosticCodeGenerator.java,v 1.1 2002/11/08 17:38:06 agno Exp $
 */

import java.util.Enumeration;
import antlr_oaa.collections.impl.BitSet;
import antlr_oaa.collections.impl.Vector;
import java.io.PrintWriter; //SAS: changed for proper text file io
import java.io.IOException;
import java.io.FileWriter;

/**Generate MyParser.txt, MyLexer.txt and MyParserTokenTypes.txt */
public class DiagnosticCodeGenerator extends CodeGenerator {
	/** non-zero if inside syntactic predicate generation */
	protected int syntacticPredLevel = 0;

	/** true during lexer generation, false during parser generation */
	protected boolean doingLexRules = false;


	/** Create a Diagnostic code-generator using the given Grammar
	 * The caller must still call setTool, setBehavior, and setAnalyzer
	 * before generating code.
	 */
	public DiagnosticCodeGenerator() {
		super();
		charFormatter = new JavaCharFormatter();
	}
	/**Generate the parser, lexer, and token types documentation */
	public void gen() {

		// Do the code generation
		try {
			// Loop over all grammars
			Enumeration grammarIter = behavior.grammars.elements();
			while (grammarIter.hasMoreElements()) {
				Grammar g = (Grammar)grammarIter.nextElement();

				// Connect all the components to each other
				g.setGrammarAnalyzer(analyzer);
				g.setCodeGenerator(this);
				analyzer.setGrammar(g);

				// To get right overloading behavior across hetrogeneous grammars
				g.generate();
	
				if (tool.hasError) {
					System.out.println("Exiting due to errors.");
					System.exit(1);
				}

			}

			// Loop over all token managers (some of which are lexers)
			Enumeration tmIter = behavior.tokenManagers.elements();
			while (tmIter.hasMoreElements()) {
				TokenManager tm = (TokenManager)tmIter.nextElement();
				if (!tm.isReadOnly()) {
					// Write the token manager tokens as Java
					genTokenTypes(tm);
				}
			}
		}
		catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}
	/** Generate code for the given grammar element.
	 * @param blk The {...} action to generate
	 */
	public void gen(ActionElement action) {
		if (action.isSemPred) {
			// handled elsewhere
		}
		else {
			print("ACTION: ");
			_printAction(action.actionText);
		}
	}
	/** Generate code for the given grammar element.
	 * @param blk The "x|y|z|..." block to generate
	 */
	public void gen(AlternativeBlock blk) {
		println("Start of alternative block.");
		tabs++;
		genBlockPreamble(blk);

		boolean ok = grammar.theLLkAnalyzer.deterministic(blk);
		if (!ok) {
			println("Warning: This alternative block is non-deterministic");
		}
		genCommonBlock(blk);
		tabs--;
	}
	/** Generate code for the given grammar element.
	 * @param blk The block-end element to generate.  Block-end
	 * elements are synthesized by the grammar parser to represent
	 * the end of a block.
	 */
	public void gen(BlockEndElement end) {
		// no-op
	}
	/** Generate code for the given grammar element.
	 * @param blk The character literal reference to generate
	 */
	public void gen(CharLiteralElement atom) {
		print("Match character ");
		if (atom.not) {
			_print("NOT ");
		}
		_print(atom.atomText);
		if (atom.label != null) {
			_print(", label=" + atom.label);
		}
		_println("");
	}
	/** Generate code for the given grammar element.
	 * @param blk The character-range reference to generate
	 */
	public void gen(CharRangeElement r) {
		print("Match character range: " + r.beginText + ".." + r.endText);
		if ( r.label!=null ) {
			_print(", label = " + r.label);
		}
		_println("");
	}
	/** Generate the lexer TXT file */
	public void gen(LexerGrammar g) throws IOException {
		setGrammar(g);
		System.out.println("Generating " + grammar.getClassName() + TokenTypesFileExt);
		currentOutput = antlr_oaa.Tool.openOutputFile(grammar.getClassName() + TokenTypesFileExt);
		//SAS: changed for proper text file io
		
		tabs=0;
		doingLexRules = true;

		// Generate header common to all TXT output files
		genHeader();

		// Output the user-defined lexer premamble
		println("");
		println("*** Lexer Preamble Action.");
		println("This action will appear before the declaration of your lexer class:");
		tabs++;
		println(grammar.preambleAction.getText());
		tabs--;
		println("*** End of Lexer Preamble Action");

		// Generate lexer class definition
		println("");
		println("*** Your lexer class is called '" + grammar.getClassName() + "' and is a subclass of '" + grammar.getSuperClass() + "'.");

		// Generate user-defined parser class members
		println("");
		println("*** User-defined lexer  class members:");
		println("These are the member declarations that you defined for your class:");
		tabs++;
		printAction(grammar.classMemberAction.getText());
		tabs--;
		println("*** End of user-defined lexer class members");

		// Generate string literals
		println("");
		println("*** String literals used in the parser");
		println("The following string literals were used in the parser.");
		println("An actual code generator would arrange to place these literals");
		println("into a table in the generated lexer, so that actions in the");
		println("generated lexer could match token text against the literals.");
		println("String literals used in the lexer are not listed here, as they");
		println("are incorporated into the mainstream lexer processing.");
		tabs++;
		// Enumerate all of the symbols and look for string literal symbols
		Enumeration ids = grammar.getSymbols();
		while ( ids.hasMoreElements() ) {
			GrammarSymbol sym = (GrammarSymbol)ids.nextElement();
			// Only processing string literals -- reject other symbol entries
			if ( sym instanceof StringLiteralSymbol ) {
				StringLiteralSymbol s = (StringLiteralSymbol)sym;
				println(s.getId() + " = " + s.getTokenType());
			}
		}
		tabs--;
		println("*** End of string literals used by the parser");

		// Generate nextToken() rule.
		// nextToken() is a synthetic lexer rule that is the implicit OR of all
		// user-defined lexer rules.
		genNextToken();

		// Generate code for each rule in the lexer
		println("");
		println("*** User-defined Lexer rules:");
		tabs++;
		
		ids = grammar.rules.elements();
		while ( ids.hasMoreElements() ) {
			RuleSymbol rs = (RuleSymbol)ids.nextElement();
			if (!rs.id.equals("mnextToken")) {
				genRule(rs);
			}
		}

		tabs--;
		println("");
		println("*** End User-defined Lexer rules:");

		// Close the lexer output file
		currentOutput.close();
		currentOutput = null;
		doingLexRules = false;
	}
	/** Generate code for the given grammar element.
	 * @param blk The (...)+ block to generate
	 */
	public void gen(OneOrMoreBlock blk) {
		println("Start ONE-OR-MORE (...)+ block:");
		tabs++;
		genBlockPreamble(blk);
		boolean ok = grammar.theLLkAnalyzer.deterministic(blk);
		if (!ok) {
			println("Warning: This one-or-more block is non-deterministic");
		}
		genCommonBlock(blk);
		tabs--;
		println("End ONE-OR-MORE block.");
	}
	/** Generate the parser TXT file */
	public void gen(ParserGrammar g) throws IOException {
		setGrammar(g);
		// Open the output stream for the parser and set the currentOutput
		System.out.println("Generating " + grammar.getClassName() + TokenTypesFileExt);
		currentOutput = antlr_oaa.Tool.openOutputFile(grammar.getClassName()+TokenTypesFileExt);
		//SAS: changed for proper text file io
		
		tabs = 0;

		// Generate the header common to all output files.
		genHeader();
		
		// Output the user-defined parser premamble
		println("");
		println("*** Parser Preamble Action.");
		println("This action will appear before the declaration of your parser class:");
		tabs++;
		println(grammar.preambleAction.getText());
		tabs--;
		println("*** End of Parser Preamble Action");

		// Generate parser class definition
		println("");
		println("*** Your parser class is called '" + grammar.getClassName() + "' and is a subclass of '" + grammar.getSuperClass() + "'.");

		// Generate user-defined parser class members
		println("");
		println("*** User-defined parser class members:");
		println("These are the member declarations that you defined for your class:");
		tabs++;
		printAction(grammar.classMemberAction.getText());
		tabs--;
		println("*** End of user-defined parser class members");

		// Generate code for each rule in the grammar
		println("");
		println("*** Parser rules:");
		tabs++;

		// Enumerate the parser rules
		Enumeration rules = grammar.rules.elements();
		while ( rules.hasMoreElements() ) {
			println("");
			// Get the rules from the list and downcast it to proper type
			GrammarSymbol sym = (GrammarSymbol) rules.nextElement();
			// Only process parser rules
			if ( sym instanceof RuleSymbol) {
				genRule((RuleSymbol)sym);
			}
		}
		tabs--;
		println("");
		println("*** End of parser rules");

		println("");
		println("*** End of parser");

		// Close the parser output stream
		currentOutput.close();
		currentOutput = null;
	}
	/** Generate code for the given grammar element.
	 * @param blk The rule-reference to generate
	 */
	public void gen(RuleRefElement rr) {
		RuleSymbol rs = (RuleSymbol)grammar.getSymbol(rr.targetRule);

		// Generate the actual rule description
		print("Rule Reference: " + rr.targetRule);
		if (rr.idAssign != null) {
			_print(", assigned to '" + rr.idAssign + "'");
		}
		if (rr.args != null) {
			_print(", arguments = " + rr.args);
		}
		_println("");

		// Perform diagnostics
		if (rs == null || !rs.isDefined())
		{
			println("Rule '" + rr.targetRule + "' is referenced, but that rule is not defined.");
			println("\tPerhaps the rule is misspelled, or you forgot to define it.");
			return;
		}
		if (!(rs instanceof RuleSymbol))
		{
			// Should this ever happen??
			println("Rule '" + rr.targetRule + "' is referenced, but that is not a grammar rule.");
			return;
		}
		if (rr.idAssign != null)
		{
			// Warn if the rule has no return type
			if (rs.block.returnAction == null)
			{
				println("Error: You assigned from Rule '" + rr.targetRule + "', but that rule has no return type.");
			}
		} else {
			// Warn about return value if any, but not inside syntactic predicate
			if (!(grammar instanceof LexerGrammar) && syntacticPredLevel == 0 && rs.block.returnAction != null)
			{
				println("Warning: Rule '" + rr.targetRule + "' returns a value");
			}
		}
		if (rr.args != null && rs.block.argAction == null) {
			println("Error: Rule '" + rr.targetRule + "' accepts no arguments.");
		}
	}
	/** Generate code for the given grammar element.
	 * @param blk The string-literal reference to generate
	 */
	public void gen(StringLiteralElement atom) {
		print("Match string literal ");
		_print(atom.atomText);
		if (atom.label != null) {
			_print(", label=" + atom.label);
		}
		_println("");
	}
	/** Generate code for the given grammar element.
	 * @param blk The token-range reference to generate
	 */
	public void gen(TokenRangeElement r) {
		print("Match token range: " + r.beginText + ".." + r.endText);
		if ( r.label!=null ) {
			_print(", label = " + r.label);
		}
		_println("");
	}
	/** Generate code for the given grammar element.
	 * @param blk The token-reference to generate
	 */
	public void gen(TokenRefElement atom) {
		print("Match token ");
		if (atom.not) {
			_print("NOT ");
		}
		_print(atom.atomText);
		if (atom.label != null) {
			_print(", label=" + atom.label);
		}
		_println("");
	}
	public void gen(TreeElement t) {
		print("Tree reference: "+t);
	}
	/** Generate the tree-walker TXT file */
	public  void gen(TreeWalkerGrammar g) throws IOException {
		setGrammar(g);
		// Open the output stream for the parser and set the currentOutput
		System.out.println("Generating " + grammar.getClassName() + TokenTypesFileExt);
		currentOutput = antlr_oaa.Tool.openOutputFile(grammar.getClassName()+TokenTypesFileExt);
		//SAS: changed for proper text file io
		
		tabs = 0;

		// Generate the header common to all output files.
		genHeader();
		
		// Output the user-defined parser premamble
		println("");
		println("*** Tree-walker Preamble Action.");
		println("This action will appear before the declaration of your tree-walker class:");
		tabs++;
		println(grammar.preambleAction.getText());
		tabs--;
		println("*** End of tree-walker Preamble Action");

		// Generate tree-walker class definition
		println("");
		println("*** Your tree-walker class is called '" + grammar.getClassName() + "' and is a subclass of '" + grammar.getSuperClass() + "'.");

		// Generate user-defined tree-walker class members
		println("");
		println("*** User-defined tree-walker class members:");
		println("These are the member declarations that you defined for your class:");
		tabs++;
		printAction(grammar.classMemberAction.getText());
		tabs--;
		println("*** End of user-defined tree-walker class members");

		// Generate code for each rule in the grammar
		println("");
		println("*** tree-walker rules:");
		tabs++;

		// Enumerate the tree-walker rules
		Enumeration rules = grammar.rules.elements();
		while ( rules.hasMoreElements() ) {
			println("");
			// Get the rules from the list and downcast it to proper type
			GrammarSymbol sym = (GrammarSymbol) rules.nextElement();
			// Only process tree-walker rules
			if ( sym instanceof RuleSymbol) {
				genRule((RuleSymbol)sym);
			}
		}
		tabs--;
		println("");
		println("*** End of tree-walker rules");

		println("");
		println("*** End of tree-walker");

		// Close the tree-walker output stream
		currentOutput.close();
		currentOutput = null;
	}
	/** Generate a wildcard element */
	public void gen(WildcardElement wc) {
		print("Match wildcard");
		if ( wc.getLabel()!=null ) {
			_print(", label = " + wc.getLabel());
		}