C# Runtime.CommonTokenStream类代码示例

        public void Execute()
        {
            string input = 
            @"
                Sart(0,0)
                End(12,15)
            ";
            ANTLRStringStream inStream = new ANTLRStringStream(input);
            ConfLexer lexer = new ConfLexer(inStream);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            ConfParser parser = new ConfParser(tokens);
            ConfParser.prog_return returnParser = parser.prog();

            var tree = returnParser.Tree as CommonTree;

            foreach (CommonTree item in tree.Children)
            {
                if (item.Type == ConfLexer.ID)
                    Console.WriteLine("function=" + item.Text);
                else if(item.Type == ConfLexer.INT)
                    Console.WriteLine("params:" + item.Text);
            }


            Console.ReadKey();
        }

        public static List<Error> Translate(Source source)
        {
            var err = new List<Error>();
            var prg = new Program();
            try
            {
                var input = new ANTLRStringStream(source.GetSourceData());
                var lexer = new PascalLexer(input);
                var tokens = new CommonTokenStream(lexer);
                var parser = new PascalParser(tokens);
                prg = parser.program();
                prg.SetSourceIdentifier(source.GetSourceIdentifier());
            }
            catch (RecognitionException e)
            {
                err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier())));
            }
            if (err.Count != 0)
                return err;

            var val = new Validator();
            err = val.Validate(prg);
            Root = prg;
            return err;
        }

        public Context From(string source)
        {
            var stream = new ANTLRStringStream(source);
            var lexer = new MessageContractsLexer(stream);

            var tokens = new CommonTokenStream(lexer);

            var parser = new MessageContractsParser(tokens)
            {
                TreeAdaptor = new CommonTreeAdaptor()
            };

            var program = parser.GetProgram();

            var commonTree = (CommonTree)program.Tree;

            var node = commonTree as CommonErrorNode;

            if (node != null)
            {
                throw new InvalidOperationException(node.ToString());
            }

            var ctx = new Context();
            foreach (var child in commonTree.Children)
            {
                WalkDeclarations(child, ctx);
            }
            return ctx;
        }

        public BlaiseInstrumentTreeWalker(CommonTree tree, CommonTokenStream tokens, BlaiseImportOptions options, string agencyId, string mainLanguage)
        {
            this.tree = tree;
            this.tokens = tokens;
            this.options = options;
            this.MainLanguage = mainLanguage;
            this.AgencyId = agencyId;

            Result = new XDocument();

            DdiInstance = Ddi.Element(Ddi.DdiInstance);
            Ddi.AddNamespaces(DdiInstance);

            ResourcePackage = Ddi.Element(Ddi.ResourcePackage);

            // Required in DDI 3.1
            var purpose = Ddi.Element(Ddi.Purpose);
            purpose.Add(Ddi.XmlLang(MainLanguage));
            purpose.Add(new XElement(Ddi.Content, "Not Specified"));
            ResourcePackage.Add(purpose);

            Instrument = Ddi.Element(Ddi.Instrument);
            ControlConstructScheme = Ddi.Element(Ddi.ControlConstructScheme);

            XElement groupDataCollection = Ddi.Element(Ddi.GroupDataCollection, false);
            XElement dataCollection = Ddi.Element(Ddi.DataCollection);
            groupDataCollection.Add(dataCollection);
            dataCollection.Add(Instrument);
            ResourcePackage.Add(groupDataCollection);
            ResourcePackage.Add(ControlConstructScheme);
            DdiInstance.Add(ResourcePackage);
        }

        public static InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>> Parse()
        {
            return new InOutStep<EvilLexer, Tuple<CommonTokenStream, CommonTree>>((lexer) =>
            {
                CommonTokenStream tokens = new CommonTokenStream(lexer);
                EvilParser parser = new EvilParser(tokens);
                EvilParser.program_return ret = null;
                parser.TraceDestination = Console.Out;

                try
                {
                    ret = parser.Program();
                }
                catch (RecognitionException e)
                {
                    throw new EvilException(EvilSystem.Parsing, "Error parsing.", e);
                }

                if (parser.NumberOfSyntaxErrors != 0)
                    throw new EvilException(EvilSystem.Parsing,  "Syntax errors.");

                CommonTree t = (CommonTree)ret.Tree;

                return new Tuple<CommonTokenStream, CommonTree>(tokens, t);
            });
        }

        public Expression Compile(String relinqScript)
        {
            var input = new ANTLRStringStream(relinqScript);
            var lex = new EcmaScriptV3Lexer(input);
            var tokens = new CommonTokenStream(lex);
            var parser = new EcmaScriptV3Parser(tokens);

            var es3Ast = parser.expression();
            var rsAst = new RelinqScriptParser().Visit((CommonTree)es3Ast.Tree);

            var compilerAst = new TypeInferenceAstBuilder().Visit(rsAst);
            using (var engine = new TypeInferenceEngine(compilerAst))
            {
#if DEBUG
                try
                {
                    var wtf = 0;
                    while(!engine.Run()) if (wtf++ == 10) break;
                    return new StronglyTypedAstBuilder().Visit(compilerAst);
                }
                catch (Exception)
                {
                    engine.Dump();
                    throw;
                }
#else
                engine.Run();
                return new StronglyTypedAstBuilder().Visit(tiAst);
#endif
            }
        }

        public static string Compile(string input)
        {
            input = input.Replace("\r", "");
            ANTLRStringStream Input = new ANTLRStringStream(input);
            SugarCppLexer lexer = new SugarCppLexer(Input);
            CommonTokenStream tokens = new CommonTokenStream(lexer);

            SugarCppParser parser = new SugarCppParser(tokens);

            AstParserRuleReturnScope<CommonTree, IToken> t = parser.root();
            CommonTree ct = (CommonTree)t.Tree;

            if (parser.errors.Count() > 0)
            {
                StringBuilder sb = new StringBuilder();
                foreach (var error in parser.errors)
                {
                    sb.Append(error);
                    sb.Append("\n");
                }
                throw new Exception(sb.ToString());
            }

            CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct);
            SugarWalker walker = new SugarWalker(nodes);

            Root ast = walker.root();

            TargetCpp target_cpp = new TargetCpp();

            return ast.Accept(target_cpp).Render();
        }

        /// <summary>
        /// Parses an expression in text form for later evaluation.
        /// </summary>
        /// <param name="pszCode">The expression to be parsed.</param>
        /// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param>
        /// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param>
        /// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param>
        /// <param name="pbstrError">Returns the error message if the expression contains an error.</param>
        /// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param>
        /// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
        /// <remarks>
        /// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness.
        /// The pbstrError and pichError parameters may be filled in if the expression is invalid.
        /// 
        /// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync
        /// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression.
        /// </remarks>
        public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
        {
            if (pszCode == null)
                throw new ArgumentNullException("pszCode");
            if (pszCode.Length == 0)
                throw new ArgumentException();
            // dwFlags=0 in the Immediate window
            if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0)
                throw new NotImplementedException();

            try
            {
                var expressionInput = new ANTLRStringStream(pszCode);
                var expressionUnicodeInput = new JavaUnicodeStream(expressionInput);
                var expressionLexer = new Java2Lexer(expressionUnicodeInput);
                var expressionTokens = new CommonTokenStream(expressionLexer);
                var expressionParser = new Java2Parser(expressionTokens);
                IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression();

                ppExpr = new JavaDebugExpression(this, result.Tree, pszCode);
                pbstrError = null;
                pichError = 0;
                return VSConstants.S_OK;
            }
            catch (RecognitionException e)
            {
                ppExpr = null;
                pbstrError = e.Message;
                pichError = (uint)Math.Max(0, e.Index);
                return VSConstants.E_FAIL;
            }
        }

        public Feature Parse(TextReader featureFileReader)
        {
            var fileContent = featureFileReader.ReadToEnd() + Environment.NewLine;

            CultureInfo language = GetLanguage(fileContent);

            var inputStream = new ANTLRReaderStream(new StringReader(fileContent));
            var lexer = GetLexter(language, inputStream);
            var tokenStream = new CommonTokenStream(lexer);
            var parser = new Grammar.SpecFlowLangParser(tokenStream);

            var featureTree = parser.feature().Tree as CommonTree;

            if (featureTree == null || parser.ParserErrors.Count > 0 || lexer.LexerErrors.Count > 0)
            {
                throw new SpecFlowParserException("Invalid Gherkin file!", lexer.LexerErrors.Concat(parser.ParserErrors).ToArray());
            }

            var walker = new SpecFlowLangWalker(new CommonTreeNodeStream(featureTree));

            Feature feature = walker.feature();

            if (feature == null)
                throw new SpecFlowParserException("Invalid Gherkin file!");

            feature.Language = language.Name;

            return feature;
        }

        public static void Main(string[] args)
        {
            if (args.Length == 1)
            {
                string fullpath;
                if ( Path.IsPathRooted(args[0]) )
                    fullpath = args[0];
                else
                    fullpath = Path.Combine(Environment.CurrentDirectory, args[0]);

                Console.Out.WriteLine("Processing file: {0}", fullpath);
                ICharStream input = new ANTLRFileStream(fullpath);
                SimpleCLexer lex = new SimpleCLexer(input);
                CommonTokenStream tokens = new CommonTokenStream(lex);
                SimpleCParser parser = new SimpleCParser(tokens);
                SimpleCParser.program_return r = parser.program();
                Console.Out.WriteLine("tree="+((ITree)r.Tree).ToStringTree());

                if ( parser.NumberOfSyntaxErrors > 0 ) {
                    // don't tree parse if has errors
                    return;
                }

                CommonTreeNodeStream nodes = new CommonTreeNodeStream((ITree)r.Tree);
                nodes.TokenStream = tokens;
                SimpleCWalker walker = new SimpleCWalker(nodes);

                walker.program();
            }
            else
                Console.Error.WriteLine("Usage: SimpleC <input-file>");
        }

 public ASMParser GetParser(string script)
 {
     var input = new ANTLRStringStream(script);
     var lexer = new ASMLexer(input);
     var tokens = new CommonTokenStream(lexer);
     return new ASMParser(tokens);
 }

        public void Compile(ICharStream input)
        {
            try
            {
                AssemblerLexer lex = new AssemblerLexer(input);
                CommonTokenStream tokens = new CommonTokenStream(lex);
                AssemblerParser p = new AssemblerParser(tokens);
                BytecodeGenerator gen = new BytecodeGenerator(Defaults.SystemMethods.Values);
                
                p.SetGenerator(gen);
                p.TraceDestination = _traceDestination;
                p.program();

                if (p.NumberOfSyntaxErrors > 0 && _listener != null)
                {
                    _listener.Error(Convert.ToString(p.NumberOfSyntaxErrors) + " syntax error(s)");
                    return;
                }

                _result = gen.Result;
            }
            catch (GenerationException ex)
            {
                _listener.Error(ex.Message);
            }
        }

        public static MAst Compile(AstHelper runtime, ICharStream stream)
        {
            var lexer = new TigerLexer(stream);
            var tokens = new CommonTokenStream(lexer);
            var parser = new TigerParser(tokens);
            ProgramExpression programExpression = parser.parse();

            if (parser.NumberOfSyntaxErrors > 0)
            {
                IEnumerable<string> errors = from e in parser.Errors
                                             select e.ToString();

                throw new SyntaxException(errors);
            }

            AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true);
            programExpression.CheckSemantics(helper);

            if (helper.Errors.HasErrors)
            {
                throw new SemanticException(helper.Errors);
            }

            return programExpression.Transform();
        }

        public void VisitLine(String line)
        {
            Core interp_visitor = new Core();
            PrintVisitor print_visitor = new PrintVisitor(interp_visitor);
            ANTLRStringStream string_stream = new ANTLRStringStream(line);
            spinachLexer lexer = new spinachLexer(string_stream);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            spinachParser parser = new Test_Core(tokens, "");
            try
            {
                spinachParser.program_return program = parser.program(); //h= (l+j)*h*l+l-h;
                if (strBuilder.ToString() == "")
                {
                    List<Element> elements = program.ret;

                    ///-- call core function. to pass list of element.

                    for (int i = 0; i < elements.Count; i++)
                    {
                        Element curr = elements[i];
                        curr.Accept(print_visitor);
                        curr.Accept(interp_visitor);//PlotReceiver
                    }
                }
                else
                {
                    Onerror(101, strBuilder.ToString());
                }
            }
            catch (RecognitionException e)
            {
                Onerror(102, e.Message);
            }
        }

        public Boolean RunTest()
        {
            try
            {
                GlobalMemory.Clear();

                var sStream = new ANTLRStringStream(input);
                var lexer = new SGLLexer(sStream);

                var tStream = new CommonTokenStream(lexer);

                // Parsing
                var parser = new SGLParser(tStream);
                var t = (CommonTree) parser.main().Tree;

                // Printing tree
                Console.WriteLine("; " + t.ToStringTree());

                // TreeWalking
                var treeStream = new CommonTreeNodeStream(t);

                var tw = new SGLTreeWalker(treeStream, true);
                AbstractNode returned = tw.main();
                returned.Evaluate();

                if (debug)
                {
                    realOutput = GlobalMemory.Instance.DebugString;
                }
                else
                {
                    realOutput = GlobalMemory.Instance.StoryboardCode.ToString();
                }

                // comparison
                realOutput = realOutput.Trim();
                output.Trim();

                if (output.Equals(realOutput))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (CompilerException ce)
            {
                Console.WriteLine(ce.GetExceptionAsString());
                return false;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Es ist ein Fehler aufgetreten.");
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
                return false;
            }
        }