C# Parser.Init方法代码示例

        private static SymbolTable LoadCopies(AbstractErrorWriter writer, List<string> paths, DocumentFormat copyDocumentFormat)
        {
            var parser = new Parser();
            var table = new SymbolTable(null, SymbolTable.Scope.Intrinsic);

            var copies = new List<string>();
            foreach(string path in paths) copies.AddRange(Tools.FileSystem.GetFiles(path, parser.Extensions, false));

            foreach(string path in copies) {
                try {
                    parser.Init(path, copyDocumentFormat);
                    parser.Parse(path);

                    foreach (var diagnostic in parser.Results.CodeElementsDocumentSnapshot.ParserDiagnostics) {
                        AddError(writer, "Syntax error during parsing of " + path + ": " + diagnostic, path, "intrinsicLoading");
                    }

                    if (parser.Results.ProgramClassDocumentSnapshot == null) continue;
                    foreach (var diagnostic in parser.Results.ProgramClassDocumentSnapshot.Diagnostics) {
                        AddError(writer, "Semantic error during parsing of " + path + ": " + diagnostic, path, "intrinsicLoading");
                    }

                    if (parser.Results.ProgramClassDocumentSnapshot.Program == null) {
                        AddError(writer, "Error: Your Intrisic types/functions are not included into a program.", path,
                            "intrinsicLoading");
                        continue;
                    }
                    var symbols = parser.Results.ProgramClassDocumentSnapshot.Program.SymbolTable;
                    foreach (var types in symbols.Types)
                        foreach (var type in types.Value)
                            table.AddType((Compiler.Nodes.TypeDefinition) type);
                    foreach (var functions in symbols.Functions)
                        foreach (var function in functions.Value)
                            table.AddFunction((Compiler.Nodes.FunctionDeclaration) function);
                    //TODO check if types or functions are already there
                } catch (Exception e) {
                    AddError(writer, e.Message, path, "intrinsicLoading");
                }
            }
            return table;
        }

        private static Compiler.CodeModel.SymbolTable loadCopies(List<string> copies)
        {
            var parser = new Parser();
            var table = new SymbolTable(null, SymbolTable.Scope.Intrinsic);
            foreach(string path in copies) {
                parser.Init(path);
                parser.Parse(path);

                if (parser.Results.ProgramClassDocumentSnapshot == null) continue;
                if (parser.Results.ProgramClassDocumentSnapshot.Program == null)
                {
                    Console.WriteLine("Error: Your Intrisic types are not included into a program.");
                    continue;
                }

                foreach (var types in parser.Results.ProgramClassDocumentSnapshot.Program.SymbolTable.Types)
                    foreach(var type in types.Value)
                        table.AddType((TypeCobol.Compiler.Nodes.TypeDefinition)type);//TODO check if already there
            }
            return table;
        }

        private static void runOnce(Config config)
        {
            TextWriter w;
            if (config.ErrorFile == null) w = System.Console.Error;
            else w = File.CreateText(config.ErrorFile);
            AbstractErrorWriter writer;
            if (config.IsErrorXML) writer = new XMLWriter(w);
            else writer = new ConsoleWriter(w);
            writer.Outputs = config.OutputFiles;

            var parser = new Parser();
            parser.CustomSymbols = loadCopies(config.Copies);

            for(int c=0; c<config.InputFiles.Count; c++) {
                string path = config.InputFiles[c];
                try { parser.Init(path, config.Format); }
                catch(System.IO.IOException ex) {
                    AddError(writer, ex.Message, path);
                    continue;
                }
                parser.Parse(path);
                if (parser.Results.CodeElementsDocumentSnapshot == null) {
                    AddError(writer, "File \""+path+"\" has syntactic error(s) preventing codegen (CodeElements).", path);
                    continue;
                }

                writer.AddErrors(path, parser.Converter.AsDiagnostics(parser.Results.CodeElementsDocumentSnapshot.ParserDiagnostics));
                // no need to add errors from parser.CodeElementsSnapshot.CodeElements
                // as they are on parser.CodeElementsSnapshot.CodeElements which are added below

                if (parser.Results.ProgramClassDocumentSnapshot == null) {
                    AddError(writer, "File \""+path+"\" has semantic error(s) preventing codegen (ProgramClass).", path);
                    continue;
                }
                int errors = 0;
                errors += new List<Compiler.Diagnostics.Diagnostic>(parser.Results.CodeElementsDocumentSnapshot.ParserDiagnostics).Count;
                errors += parser.Results.ProgramClassDocumentSnapshot.Diagnostics.Count;
                writer.AddErrors(path, parser.Converter.AsDiagnostics(parser.Results.ProgramClassDocumentSnapshot.Diagnostics));
                foreach(var e in parser.Results.CodeElementsDocumentSnapshot.CodeElements) {
                    if (e.Diagnostics.Count < 1) continue;
                    errors += e.Diagnostics.Count;
                    writer.AddErrors(path, parser.Converter.GetDiagnostics(e));
                }

                if (config.Codegen && (errors == 0 || !config.Safe)) {
                    var skeletons = TypeCobol.Codegen.Config.Config.Parse(config.skeletonPath);
                    var codegen = new TypeCobol.Codegen.Generator(new StreamWriter(config.OutputFiles[c]), parser.Results.TokensLines, skeletons);
                    var program = parser.Results.ProgramClassDocumentSnapshot.Program;
                    codegen.Generate(program.SyntaxTree.Root, program.SymbolTable, ColumnsLayout.CobolReferenceFormat);
                }
            }
            writer.Write();
            writer.Flush();
        }