definegrammarsymbols.java

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

			return;
		}
	}
	public void endRule(String r)
	{
	}
	public void endSubRule()
	{
	}
	public void endTree()
	{
	}
	public void hasError()
	{
	}
	public void noASTSubRule()
	{
	}
	public void oneOrMoreSubRule()
	{
	}
	public void optionalSubRule()
	{
	}
    public void setUserExceptions(String thr) {}
	public void refAction(Token action)
	{
	}
	public void refArgAction(Token action)
	{
	}
	public void refCharLiteral(Token lit, Token label, boolean inverted, int autoGenType, boolean lastInRule)
	{
	}
	public void refCharRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule)
	{
	}

	public void refElementOption(Token option, Token value) {
	}

	public void refTokensSpecElementOption(Token tok, Token option, Token value) {
	}

	public void refExceptionHandler(Token exTypeAndName, Token action) {
	}

	// Header action applies to all parsers and lexers.
	public void refHeaderAction(Token name,Token act)
	{
		headerActions.put((name==null) ? "" : Tool.stripFrontBack(name.getText(),"\"","\""),
								act);
		//		headerAction = act.getText();
	}

	public String getHeaderAction(String name)
	{
		Token t = (Token)headerActions.get(name);
		if ( t==null )
		{
			return "";
		}
		return t.getText();
	}

	public void refInitAction(Token action)
	{
	}
	public void refMemberAction(Token act)
	{
	}
	public void refPreambleAction(Token act)
	{
		thePreambleAction = act;
	}
	public void refReturnAction(Token returnAction)
	{
	}

	public void refRule(Token idAssign,
							  Token r,
							  Token label,
							  Token args,
							  int autoGenType)
	{
		String id = r.getText();
		//		if ( Character.isUpperCase(id.charAt(0)) ) { // lexer rule?
																			  if ( r.type == ANTLRTokenTypes.TOKEN_REF )
																			  {
																				  // lexer rule?
																				  id = CodeGenerator.lexerRuleName(id);
																			  }
		if ( !grammar.isDefined(id) )
		{
			grammar.define(new RuleSymbol(id));
		}
	}

	public void refSemPred(Token pred)
	{
	}

	public void refStringLiteral(Token lit,
										  Token label,
										  int autoGenType,
										  boolean lastInRule)
	{
		_refStringLiteral(lit, label, autoGenType, lastInRule);
	}

    /** Reference a token */
	public void refToken(Token assignId, Token t, Token label, Token args,
								boolean inverted, int autoGenType, boolean lastInRule)
	{
		_refToken(assignId, t, label, args, inverted, autoGenType, lastInRule);
	}

	public void refTokenRange(Token t1, Token t2, Token label, int autoGenType, boolean lastInRule)
	{
		// ensure that the DefineGrammarSymbols methods are called; otherwise a range addes more
		// token refs to the alternative by calling MakeGrammar.refToken etc...
		if ( t1.getText().charAt(0) == '"' )
		{
			refStringLiteral(t1, null, GrammarElement.AUTO_GEN_NONE, lastInRule);
		}
		else
		{
			_refToken(null, t1, null, null, false, GrammarElement.AUTO_GEN_NONE, lastInRule);
		}
		if ( t2.getText().charAt(0) == '"' )
		{
			_refStringLiteral(t2, null, GrammarElement.AUTO_GEN_NONE, lastInRule);
		}
		else
		{
			_refToken(null, t2, null, null, false, GrammarElement.AUTO_GEN_NONE, lastInRule);
		}
	}

	public void refTreeSpecifier(Token treeSpec) {
	}

	public void refWildcard(Token t, Token label, int autoGenType)
	{
	}

    /** Get ready to process a new grammar */
	public void reset()
	{
		grammar = null;
	}

	public void setArgOfRuleRef(Token argaction)
	{
	}

    /** Set the character vocabulary for a lexer */
	public void setCharVocabulary(BitSet b)
	{
		// grammar should enforce that this is only called for lexer
		((LexerGrammar)grammar).setCharVocabulary(b);
	}

    /** setFileOption: Associate an option value with a key.
	 * This applies to options for an entire grammar file.
	 * @param key The token containing the option name
	 * @param value The token containing the option value.
	 */
	public void setFileOption(Token key, Token value, String filename)
	{
		if (key.getText().equals("language"))
		{
			if (value.getType() == ANTLRParser.STRING_LITERAL)
			{
				language = Tool.stripBack(Tool.stripFront(value.getText(), '"'), '"');
			}
			else if (value.getType() == ANTLRParser.TOKEN_REF || value.getType() == ANTLRParser.RULE_REF)
			{
				language = value.getText();
			}
			else
			{
				tool.error("language option must be string or identifier", filename, value.getLine());
			}
		}
		else if (key.getText().equals("mangleLiteralPrefix"))
		{
			if (value.getType() == ANTLRParser.STRING_LITERAL)
			{
				tool.literalsPrefix = tool.stripFrontBack(value.getText(), "\"","\"");
			}
			else
			{
				tool.error("mangleLiteralPrefix option must be string", filename, value.getLine());
			}
		}
		else if (key.getText().equals("upperCaseMangledLiterals"))
		{
			if (value.getText().equals("true"))
			{
				tool.upperCaseMangledLiterals = true;
			}
			else if (value.getText().equals("false"))
			{
				tool.upperCaseMangledLiterals = false;
			}
			else
			{
				grammar.tool.error("Value for upperCaseMangledLiterals must be true or false", filename, key.getLine());
			}
		}
		else if (key.getText().equals("namespace") ||
					key.getText().equals("namespaceStd") ||
					key.getText().equals("namespaceAntlr") ||
					key.getText().equals("genHashLines") )
		{
			if (!language.equals("Cpp"))
			{
				tool.error(key.getText() + " option only valid for C++", filename, key.getLine());
			}
			else
			{
				if( key.getText().equals("genHashLines") )
				{
					if(!( value.getText().equals("true") || value.getText().equals("false") ))
						tool.error("genHashLines option must be true or false", filename, value.getLine());
					tool.genHashLines = value.getText().equals("true");
				}
				else
				{
					if ( value.getType() != ANTLRParser.STRING_LITERAL )
					{
						tool.error(key.getText()+" option must be a string", filename, value.getLine());
					}
					else
					{
						if ( key.getText().equals("namespace") )
							tool.setNameSpace(value.getText());
						else if( key.getText().equals("namespaceStd") )
							tool.namespaceStd = value.getText();
						else if( key.getText().equals("namespaceAntlr") )
							tool.namespaceAntlr = value.getText();
					}
				}
			}
		}
		else
		{
			tool.error("Invalid file-level option: " + key.getText(), filename, key.getLine());
		}
	}
    /** setGrammarOption: Associate an option value with a key.
	 * This function forwards to Grammar.setOption for some options.
	 * @param key The token containing the option name
	 * @param value The token containing the option value.
	 */
	public void setGrammarOption(Token key, Token value)
	{
		if (key.getText().equals("tokdef")||key.getText().equals("tokenVocabulary"))
		{
			tool.error("tokdef/tokenVocabulary options are invalid >= ANTLR 2.6.0.\n"+
						  "  Use importVocab/exportVocab instead.  Please see the documentation.\n"+
						  "  The previous options were so heinous that Terence changed the whole\n"+
						  "  vocabulary mechanism; it was better to change the names rather than\n"+
						  "  subtly change the functionality of the known options.  Sorry!", grammar.getFilename(), value.getLine());
		}
		else if (key.getText().equals("literal") &&
					grammar instanceof LexerGrammar )
		{
			tool.error("the literal option is invalid >= ANTLR 2.6.0.\n"+
						  "  Use the \"tokens {...}\" mechanism instead.",
						  grammar.getFilename(), value.getLine());
		}
		else if (key.getText().equals("exportVocab"))
		{
			// Set the token manager associated with the parser
			if (value.getType() == ANTLRParser.RULE_REF || value.getType() == ANTLRParser.TOKEN_REF)
			{
				grammar.exportVocab = value.getText();
			}
			else
			{
				tool.error("exportVocab must be an identifier", grammar.getFilename(), value.getLine());
			}
		}
		else if (key.getText().equals("importVocab"))
		{
			if (value.getType() == ANTLRParser.RULE_REF || value.getType() == ANTLRParser.TOKEN_REF)
			{
				grammar.importVocab = value.getText();
			}
			else
			{
				tool.error("importVocab must be an identifier", grammar.getFilename(), value.getLine());
			}
		}

		else
		{
			// Forward all unrecognized options to the grammar
			grammar.setOption(key.getText(), value);
		}
	}
	public void setRuleOption(Token key, Token value)
	{
	}
	public void setSubruleOption(Token key, Token value)
	{
	}
    /** Start a new lexer */
	public void startLexer(String file, Token name, String superClass, String doc)
	{
		if ( numLexers>0 )
		{
			tool.panic("You may only have one lexer per grammar file: class "+ name.getText());
		}
		numLexers++;
		reset();
		//System.out.println("Processing lexer '" + name.getText() + "'");
		// Does the lexer already exist?
		Grammar g = (Grammar)grammars.get(name);
		if (g != null)
		{
			if (!(g instanceof LexerGrammar))
			{
				tool.panic("'" + name.getText() + "' is already defined as a non-lexer");
			}
			else
			{
				tool.panic("Lexer '" + name.getText() + "' is already defined");
			}
		}
		else
		{
			// Create a new lexer grammar
			LexerGrammar lg = new LexerGrammar(name.getText(), tool, superClass);
			lg.comment = doc;
			lg.processArguments(args);
			lg.setFilename(file);
			grammars.put(lg.getClassName(), lg);
			// Use any preamble action
			lg.preambleAction = thePreambleAction;
			thePreambleAction = new CommonToken(Token.INVALID_TYPE, "");
			// This is now the current grammar
			grammar = lg;
		}
	}
    /** Start a new parser */
	public void startParser(String file, Token name, String superClass, String doc)
	{
		if ( numParsers>0 )
		{
			tool.panic("You may only have one parser per grammar file: class "+ name.getText());
		}
		numParsers++;
		reset();
		//System.out.println("Processing parser '" + name.getText() + "'");
		// Is this grammar already defined?
		Grammar g = (Grammar)grammars.get(name);
		if (g != null)
		{
			if (!(g instanceof ParserGrammar))
			{
				tool.panic("'" + name.getText() + "' is already defined as a non-parser");
			}
			else
			{
				tool.panic("Parser '" + name.getText() + "' is already defined");
			}
		}
		else
		{
			// Create a new grammar
			grammar = new ParserGrammar(name.getText(), tool, superClass);
			grammar.comment = doc;
			grammar.processArguments(args);
			grammar.setFilename(file);
			grammars.put(grammar.getClassName(), grammar);
			// Use any preamble action
			grammar.preambleAction = thePreambleAction;
			thePreambleAction = new CommonToken(Token.INVALID_TYPE, "");
		}
	}
    /** Start a new tree-walker */
	public void startTreeWalker(String file, Token name, String superClass, String doc)
	{
		if ( numTreeParsers>0 )
		{
			tool.panic("You may only have one tree parser per grammar file: class "+ name.getText());
		}
		numTreeParsers++;
		reset();
		//System.out.println("Processing tree-walker '" + name.getText() + "'");
		// Is this grammar already defined?
		Grammar g = (Grammar)grammars.get(name);
		if (g != null)
		{
			if (!(g instanceof TreeWalkerGrammar))
			{
				tool.panic("'" + name.getText() + "' is already defined as a non-tree-walker");
			}
			else
			{
				tool.panic("Tree-walker '" + name.getText() + "' is already defined");
			}
		}
		else
		{
			// Create a new grammar
			grammar = new TreeWalkerGrammar(name.getText(), tool, superClass);
			grammar.comment = doc;
			grammar.processArguments(args);
			grammar.setFilename(file);
			grammars.put(grammar.getClassName(), grammar);
			// Use any preamble action
			grammar.preambleAction = thePreambleAction;
			thePreambleAction = new CommonToken(Token.INVALID_TYPE, "");
		}
	}
	public void synPred()
	{
	}
	public void zeroOrMoreSubRule()
	{
	}
}