import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
static Tree parseTree(CharSource input)
        throws IOException
{
    try (Reader reader = input.openStream()) {
        ThriftLexer lexer = new ThriftLexer(new ANTLRReaderStream(reader));
        ThriftParser parser = new ThriftParser(new CommonTokenStream(lexer));
        try {
            Tree tree = (Tree) parser.document().getTree();
            if (parser.getNumberOfSyntaxErrors() > 0) {
                throw new IllegalArgumentException("syntax error");
            }
            return tree;
        }
        catch (RecognitionException e) {
            throw new IllegalArgumentException(e);
        }
    }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
private static CommonTree getKoopaAST(String filename)
		throws FileNotFoundException, IOException, RecognitionException {
	System.out.println("Reading " + filename);
	Reader reader = new FileReader(filename);

	KGLexer lexer = new KGLexer(new ANTLRReaderStream(reader));

	CommonTokenStream tokens = new CommonTokenStream(lexer);

	KGParser parser = new KGParser(tokens);

	KGParser.koopa_return koopa = parser.koopa();

	CommonTree ast = (CommonTree) koopa.getTree();
	if (SHOW_AST) {
		new ASTFrame("KG", ast).setVisible(true);
	}
	return ast;
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public IParseResult doParse(Reader reader) {
	try {
		return parse(getDefaultRuleName(), new ANTLRReaderStream(reader));
	} catch (IOException e) {
		throw new WrappedException(e);
	}
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public IParseResult parse(ParserRule rule, Reader reader) {
	try {
		IParseResult parseResult = parse(rule.getName(), new ANTLRReaderStream(reader));
		return parseResult;
	} catch (IOException e) {
		throw new WrappedException(e);
	}
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
protected CharStream getCharStream(final Reader reader) {
  try {
    return new ANTLRReaderStream(reader);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
/**
 * The only method that should be called to initiate the process
 * @param is	The input stream from where to get the data
 * @param os 	The output stream to write the processed fragment/document to
 * @param htmlFilter	An interface called during the processing of the document. Can be used to modify elements
 * @param convertIntoValidXML	Converts the output into valid XML for XSL processing for example
 */
public static void process( Reader reader, Writer writer, IHTMLFilter htmlFilter, boolean convertIntoValidXML ) throws HandlingException {
	try {
		// Open a char stream input for the document
		ANTLRStringStream input = new ANTLRReaderStream( reader );
		
		// Start lexing the input
		htmlLexerLexer lex = new htmlLexerLexer(input);

		// Tokenstream for the parser.
		CommonTokenStream tokens = new CommonTokenStream(lex);
		htmlParserParser parser = new htmlParserParser(tokens);
		htmlParserParser.document_return root = parser.document();

		// Set up the tree parser
		CommonTreeNodeStream nodes = new CommonTreeNodeStream((Tree)root.getTree());
		htmlTreeParser walker = new htmlTreeParser(nodes);

		// Initialize data structures
		topNode = new ThreadLocal();
		currentNode = new ThreadLocal();
		attrNode = new ThreadLocal();

		// Walk in the entire document using the tree parser.
		walker.document();
		
		// Get the top node
		TagNode top = (TagNode)topNode.get();
		
		// Write the clean document out.
		top.writeAll( writer, htmlFilter, convertIntoValidXML, false );
	} catch ( IOException ioe ) {
		throw new HandlingException( "Could not parse document" );
	} catch ( RecognitionException re ) {
		throw new HandlingException( "Could not parse document" );
	}
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
private static ANTLRReaderStream getAntlrStream(String code) {
  try {
    return new ANTLRReaderStream(new StringReader(code));
  } catch (IOException e) {
    // Will never happen, since it's a StringReader...
    return null;
  }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
public static CSSInputStream stringStream(String source) throws IOException {
	CSSInputStream stream = new CSSInputStream();
	
	stream.rawData = source;
	stream.encoding = Charset.defaultCharset().name();
	
	BufferedReader br = new BufferedReader(
			new InputStreamReader(new ByteArrayInputStream(source.getBytes()), stream.encoding));
	stream.input = new ANTLRReaderStream(br);
	
	return stream;
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
private List<Integer> tokenStartPositions() throws IOException {
    List<Integer> res = new ArrayList<Integer>();
    ANTLRReaderStream input = new ANTLRInputStream(new FileInputStream(masterFile));
    v4Lexer lexer = new v4Lexer(input);
    Token t = lexer.nextToken();
    while (t.getType() != Token.EOF) {
        if (t.getChannel() != Token.HIDDEN_CHANNEL) {
            res.add(lexer.getCharIndex());
        }
        t = lexer.nextToken();
    }
    return res;
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
public static ObjCppParser newParser(String s) throws IOException {
    Result result = new Result(new JNAeratorConfig(), null, null);
    ObjCppParser parser = new ObjCppParser(new CommonTokenStream(new ObjCppLexer(
            new ANTLRReaderStream(new StringReader(s)))) // , new DummyDebugEventListener()
            );
    parser.objCParserHelper = result.typeConverter;
    return parser;
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
static ObjCDemanglingParser newObjCDemangler(String s, final boolean verbose) throws IOException {
        return new ObjCDemanglingParser(
                new CommonTokenStream(
                new ObjCDemanglingLexer(
                new ANTLRReaderStream(new StringReader(s)))) //				, new DummyDebugEventListener()
                ) {
            @Override
            public void reportError(RecognitionException arg0) {
                if (verbose) {
//					System.err.println(arg0 + " (next = '" + next() + "')");
                    super.reportError(arg0);
                }
            }
        };
    }
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
protected ObjCppParser newObjCppParser(TypeConversion typeConverter, String s, final boolean verbose, final PrintStream errorOut) throws IOException {
        ObjCppParser parser = new ObjCppParser(
                new CommonTokenStream(
                new ObjCppLexer(
                new ANTLRReaderStream(new StringReader(s)))) //		    , new DummyDebugEventListener()
                ) {
            @Override
            public void emitErrorMessage(String msg) {
                if (errorOut == null) {
//                    if (verbose)
//                        super.emitErrorMessage(msg);
                } else {
                    errorOut.println(msg);
                }
            }

            @Override
            public void reportError(RecognitionException arg0) {
                if (verbose) {
                    super.reportError(arg0);
                }
            }
        };
        parser.setupScopes();
        parser.objCParserHelper = typeConverter;

        return parser;
    }
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
public static ObjCppParser newParser(String s) throws IOException {
	Result result = new Result(new JNAeratorConfig(), null, null);
	ObjCppParser parser = new ObjCppParser(new CommonTokenStream(new ObjCppLexer(
			new ANTLRReaderStream(new StringReader(s))))
	// , new DummyDebugEventListener()
	);
	parser.objCParserHelper = result.typeConverter;
	return parser;
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
private List<String> extractTagsFromString(String in) throws IOException {
    try (Reader stringToInputStream = new StringReader(in)) {
        TagLexer tagsLexer = new TagLexer(new ANTLRReaderStream(stringToInputStream));
        CommonTokenStream tokens = new CommonTokenStream(tagsLexer);
        TagParser pa = new TagParser(tokens);
        return pa.getParsedTags();
    }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
public static CommonTokenStream getTokenStream(java.io.Reader reader)
	throws java.io.IOException
{
	SExpressionLexer lexer
		= new SExpressionLexer(new ANTLRReaderStream(reader));
	return new CommonTokenStream(lexer);
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
/**
 * Loads the proto from an {@link ANTLRReaderStream}.
 */
public static void loadFrom(ANTLRReaderStream input, Proto target) throws Exception
{
    // Create an ExprLexer that feeds from that stream
    ProtoLexer lexer = new ProtoLexer(input);
    // Create a stream of tokens fed by the lexer
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    // Create a parser that feeds off the token stream
    ProtoParser parser = new ProtoParser(tokens);
    // Begin parsing at rule parse
    parser.parse(target);
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public CLObject parse(Reader in) throws CLScriptException {

	try {
		return invokeParser(new ANTLRReaderStream(in));
	} catch (IOException ex) {
           throw new CLScriptException(ex);
       }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public CLCommand parse(Reader in) throws CLScriptException {

	try {
		return invokeParser(new ANTLRReaderStream(in));
	} catch (IOException ex) {
           throw new CLScriptException(ex);
       }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public CLParmAbstractComponent parse(Reader in) throws CLScriptException {

	try {
		return invokeParser(new ANTLRReaderStream(in));
	} catch (IOException ex) {
           throw new CLScriptException(ex);
       }
}
 

import org.antlr.runtime.ANTLRReaderStream; //导入依赖的package包/类
@Override
public QExpression parse(Reader in) throws CLScriptException {

	try {
		return invokeParser(new ANTLRReaderStream(in));
	} catch (IOException ex) {
           throw new CLScriptException(ex);
       }
}