/// <summary> /// LoadCopies method. /// </summary> /// <param name="writer">AbstractErrorWriter</param> /// <param name="paths">List<string></param> /// <param name="copyDocumentFormat">DocumentFormat</param> /// <returns>SymbolTable</returns> 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, new TypeCobolOptions { ExecToStep = ExecutionStep.SemanticCheck }, copyDocumentFormat); parser.Parse(path); foreach (var diagnostic in parser.Results.AllDiagnostics()) { Server.AddError(writer, MessageCode.IntrinsicLoading, diagnostic.ColumnStart, diagnostic.ColumnEnd, diagnostic.Line, "Error during parsing of " + path + ": " + diagnostic, path); } if (parser.Results.ProgramClassDocumentSnapshot.Program == null) { Server.AddError(writer, MessageCode.IntrinsicLoading, "Error: Your Intrisic types/functions are not included into a program.", path); continue; } var symbols = parser.Results.ProgramClassDocumentSnapshot.Program.SymbolTable; foreach (var types in symbols.Types) { foreach (var type in types.Value) { table.AddType(type); } } foreach (var functions in symbols.Functions) { foreach (var function in functions.Value) { table.AddFunction(function); } } //TODO check if types or functions are already there } catch (Exception e) { Server.AddError(writer, MessageCode.IntrinsicLoading, e.Message + "\n" + e.StackTrace, path); } } return(table); }
private static void AddError(AbstractErrorWriter writer, string message, string path) { var error = new TypeCobol.Tools.Diagnostic(); error.Message = message; error.Code = "codegen"; try { error.Source = writer.Inputs[path]; } catch(KeyNotFoundException) { error.Source = writer.Count.ToString(); } var list = new List<TypeCobol.Tools.Diagnostic>(); list.Add(error); writer.AddErrors(path, list); System.Console.WriteLine(error.Message); }
/// <summary> /// Add an error message /// </summary> /// <param name="writer">Error Writer</param> /// <param name="messageCode">Message's code</param> /// <param name="columnStart">Start column in the source file</param> /// <param name="columnEnd">End column in the source file</param> /// <param name="lineNumber">Lien number in the source file</param> /// <param name="message">The text message</param> /// <param name="path">The source file path</param> internal static void AddError(AbstractErrorWriter writer, MessageCode messageCode, int columnStart, int columnEnd, int lineNumber, string message, string path) { Diagnostic diag = new Diagnostic(messageCode, columnStart, columnEnd, lineNumber, message != null ? (path != null ? new object[2] { message, path } : new object[1] { message }) : (path != null ? new object[1] { path } : new object[0])); diag.Message = message; AddError(writer, path, diag); }
/// <summary> /// Add an error message /// </summary> /// <param name="writer">Error Writer</param> /// <param name="messageCode">Message's code</param> /// <param name="columnStart">Start column in the source file</param> /// <param name="columnEnd">End column in the source file</param> /// <param name="lineNumber">Lien number in the source file</param> /// <param name="message">The text message</param> /// <param name="path">The source file path</param> internal static void AddError(AbstractErrorWriter writer, MessageCode messageCode, int columnStart, int columnEnd, int lineNumber, string message, string path) { Diagnostic diag = new Diagnostic(messageCode, columnStart, columnEnd, lineNumber, message != null ? (path != null ? new object[2] { message, path } : new object[1] { message }) : (path != null ? new object[1] { path } : new object[0])); diag.Message = message; writer.AddErrors(path, diag); Console.WriteLine(string.Format("Code : {0} - Message : {1}", messageCode, message)); }
/// <summary> /// LoadCopies method. /// </summary> /// <param name="writer">AbstractErrorWriter</param> /// <param name="paths">List<string></param> /// <param name="copyDocumentFormat">DocumentFormat</param> /// <returns>SymbolTable</returns> private static SymbolTable LoadDependencies(AbstractErrorWriter writer, List <string> paths, DocumentFormat format, SymbolTable intrinsicTable) { var parser = new Parser(intrinsicTable); var table = new SymbolTable(intrinsicTable, SymbolTable.Scope.Namespace); //Generate a table of NameSPace containing the dependencies programs based on the previously created intrinsic table. var dependencies = new List <string>(); foreach (var path in paths) { dependencies.AddRange(Tools.FileSystem.GetFiles(path, parser.Extensions, true)); //Get File by name or search the directory for all files } foreach (string path in dependencies) { try { parser.Init(path, new TypeCobolOptions { ExecToStep = ExecutionStep.SemanticCheck }, format); parser.Parse(path); //Parse the dependencie file foreach (var diagnostic in parser.Results.AllDiagnostics()) { Server.AddError(writer, MessageCode.DependenciesLoading, diagnostic.ColumnStart, diagnostic.ColumnEnd, diagnostic.Line, "Error during parsing of " + path + ": " + diagnostic, path); } if (parser.Results.ProgramClassDocumentSnapshot.Program == null) { Server.AddError(writer, MessageCode.DependenciesLoading, "Error: Your dependency file is not included into a program.", path); continue; } table.AddProgram(parser.Results.ProgramClassDocumentSnapshot.Program); //Add program to Namespace symbol table } catch (Exception e) { Server.AddError(writer, MessageCode.DependenciesLoading, e.Message + "\n" + e.StackTrace, path); } } return(table); }
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; }
/// <summary> /// Add an error message /// </summary> /// <param name="writer">Error Writer</param> /// <param name="messageCode">Message's code</param> /// <param name="message">The text message</param> /// <param name="path">The source file path</param> internal static void AddError(AbstractErrorWriter writer, MessageCode messageCode, string message, string path) { AddError(writer, messageCode, 0, 0, 1, message, path); }
internal static void AddError(AbstractErrorWriter writer, string path, Diagnostic diagnostic) { writer.AddErrors(path, diagnostic); Console.WriteLine(diagnostic); }
private static ReturnCode runOnce2(TypeCobolConfiguration config, AbstractErrorWriter errorWriter) { var parser = new Parser(); bool diagDetected = false; if (config.ExecToStep > ExecutionStep.Preprocessor) { #region Event Diags Handler EventHandler <Tools.APIHelpers.DiagnosticsErrorEvent> DiagnosticsErrorEvent = delegate(object sender, Tools.APIHelpers.DiagnosticsErrorEvent diagEvent) { //Delegate Event to handle diagnostics generated while loading dependencies/intrinsics diagDetected = true; var diagnostic = diagEvent.Diagnostic; Server.AddError(errorWriter, MessageCode.IntrinsicLoading, diagnostic.ColumnStart, diagnostic.ColumnEnd, diagnostic.Line, "Error while parsing " + diagEvent.Path + ": " + diagnostic, diagEvent.Path); }; EventHandler <Tools.APIHelpers.DiagnosticsErrorEvent> DependencyErrorEvent = delegate(object sender, Tools.APIHelpers.DiagnosticsErrorEvent diagEvent) { //Delegate Event to handle diagnostics generated while loading dependencies/intrinsics Server.AddError(errorWriter, diagEvent.Path, diagEvent.Diagnostic); }; #endregion parser.CustomSymbols = Tools.APIHelpers.Helpers.LoadIntrinsic(config.Copies, config.Format, DiagnosticsErrorEvent); //Load intrinsic parser.CustomSymbols = Tools.APIHelpers.Helpers.LoadDependencies(config.Dependencies, config.Format, parser.CustomSymbols, config.InputFiles, DependencyErrorEvent); //Load dependencies if (diagDetected) { throw new CopyLoadingException("Diagnostics detected while parsing Intrinsic file", null, null, logged: false, needMail: false); } } ReturnCode returnCode = ReturnCode.Success; for (int c = 0; c < config.InputFiles.Count; c++) { string path = config.InputFiles[c]; try { var typeCobolOptions = new TypeCobolOptions { HaltOnMissingCopy = config.HaltOnMissingCopyFilePath != null, ExecToStep = config.ExecToStep, }; #if EUROINFO_RULES typeCobolOptions.AutoRemarksEnable = config.AutoRemarks; #endif parser.Init(path, typeCobolOptions, config.Format, config.CopyFolders); //Init parser create CompilationProject & Compiler before parsing the given file } catch (Exception ex) { throw new ParsingException(MessageCode.ParserInit, ex.Message, path, ex); //Make ParsingException trace back to RunOnce() } parser.Parse(path); bool copyAreMissing = false; if (!string.IsNullOrEmpty(config.HaltOnMissingCopyFilePath)) { if (parser.MissingCopys.Count > 0) { //Write in the specified file all the absent copys detected File.WriteAllLines(config.HaltOnMissingCopyFilePath, parser.MissingCopys); copyAreMissing = true; } else { //Delete the file File.Delete(config.HaltOnMissingCopyFilePath); } } if (config.ExecToStep >= ExecutionStep.Preprocessor && !string.IsNullOrEmpty(config.ExtractedCopiesFilePath)) { if (parser.Results.CopyTextNamesVariations.Count > 0) { #if EUROINFO_RULES var copiesName = parser.Results.CopyTextNamesVariations.Select(cp => cp.TextName).Distinct(); //Get copies without suffix #else var copiesName = parser.Results.CopyTextNamesVariations.Select(cp => cp.TextNameWithSuffix).Distinct(); //Get copies with suffix #endif //Create an output document of all the copy encountered by the parser File.WriteAllLines(config.ExtractedCopiesFilePath, copiesName); } else { File.Delete(config.ExtractedCopiesFilePath); } } var allDiags = parser.Results.AllDiagnostics(); errorWriter.AddErrors(path, allDiags.Take(config.MaximumDiagnostics == 0 ? allDiags.Count : config.MaximumDiagnostics)); //Write diags into error file if (allDiags.Count > 0) { foreach (var diag in allDiags) { if (diag.CatchedException != null) { AnalyticsWrapper.Telemetry.TrackException(diag.CatchedException); AnalyticsWrapper.Telemetry.SendMail(diag.CatchedException, config.InputFiles, config.CopyFolders, config.CommandLine); } } AnalyticsWrapper.Telemetry.TrackEvent("[Diagnostics] Detected", EventType.Diagnostics); //Exception is thrown just below } //Copy missing is more important than diagnostics if (copyAreMissing) { throw new MissingCopyException("Some copy are missing", path, null, logged: false, needMail: false); } else if (parser.Results.AllDiagnostics().Any(d => d.Info.Severity == Compiler.Diagnostics.Severity.Error)) { throw new PresenceOfDiagnostics("Diagnostics Detected"); //Make ParsingException trace back to RunOnce() } if (parser.Results.CodeElementsDocumentSnapshot == null && config.ExecToStep > ExecutionStep.Preprocessor) { throw new ParsingException(MessageCode.SyntaxErrorInParser, "File \"" + path + "\" has syntactic error(s) preventing codegen (CodeElements).", path); //Make ParsingException trace back to RunOnce() } else if (parser.Results.ProgramClassDocumentSnapshot == null && config.ExecToStep > ExecutionStep.SyntaxCheck) { throw new ParsingException(MessageCode.SyntaxErrorInParser, "File \"" + path + "\" has semantic error(s) preventing codegen (ProgramClass).", path); //Make ParsingException trace back to RunOnce() } if (config.ExecToStep >= ExecutionStep.Preprocessor && !string.IsNullOrEmpty(config.ExpandingCopyFilePath)) { try { var generator = GeneratorFactoryManager.Instance.Create(TypeCobol.Tools.Options_Config.OutputFormat.ExpandingCopy.ToString(), parser.Results, new StreamWriter(config.ExpandingCopyFilePath), null, null); generator.Generate(parser.Results, ColumnsLayout.CobolReferenceFormat); } catch (Exception e) { throw new GenerationException(e.Message, path, e); } } if (config.ExecToStep >= ExecutionStep.Generate) { try { //Load skeletons if necessary List <Skeleton> skeletons = null; if (!(string.IsNullOrEmpty(config.skeletonPath))) { skeletons = TypeCobol.Codegen.Config.Config.Parse(config.skeletonPath); } //Get Generator from specified config.OutputFormat var generator = GeneratorFactoryManager.Instance.Create(config.OutputFormat.ToString(), parser.Results, new StreamWriter(config.OutputFiles[c]), skeletons, AnalyticsWrapper.Telemetry.TypeCobolVersion); if (generator == null) { throw new GenerationException("Unknown OutputFormat=" + config.OutputFormat + "_", path); } //Generate and check diagnostics generator.Generate(parser.Results, ColumnsLayout.CobolReferenceFormat); if (generator.Diagnostics != null) { errorWriter.AddErrors(path, generator.Diagnostics); //Write diags into error file throw new PresenceOfDiagnostics("Diagnostics Detected"); //Make ParsingException trace back to RunOnce() } } catch (PresenceOfDiagnostics) { throw; //Throw the same exception to let runOnce() knows there is a problem } catch (GenerationException) { throw; //Throw the same exception to let runOnce() knows there is a problem } catch (Exception e) { //Otherwise create a new GenerationException throw new GenerationException(e.Message, path, e); } } if (parser.Results.AllDiagnostics().Any(d => d.Info.Severity == Compiler.Diagnostics.Severity.Warning)) { returnCode = ReturnCode.Warning; } } return(returnCode); }
private static ReturnCode runOnce2(TypeCobolConfiguration config, AbstractErrorWriter errorWriter) { SymbolTable baseTable = null; #region Dependencies parsing var depParser = new Parser(); bool diagDetected = false; if (config.ExecToStep > ExecutionStep.Preprocessor) { #region Event Diags Handler EventHandler <Tools.APIHelpers.DiagnosticsErrorEvent> DiagnosticsErrorEvent = delegate(object sender, Tools.APIHelpers.DiagnosticsErrorEvent diagEvent) { //Delegate Event to handle diagnostics generated while loading dependencies/intrinsics diagDetected = true; var diagnostic = diagEvent.Diagnostic; Server.AddError(errorWriter, MessageCode.IntrinsicLoading, diagnostic.ColumnStart, diagnostic.ColumnEnd, diagnostic.Line, "Error while parsing " + diagEvent.Path + ": " + diagnostic, diagEvent.Path); }; EventHandler <Tools.APIHelpers.DiagnosticsErrorEvent> DependencyErrorEvent = delegate(object sender, Tools.APIHelpers.DiagnosticsErrorEvent diagEvent) { //Delegate Event to handle diagnostics generated while loading dependencies/intrinsics Server.AddError(errorWriter, diagEvent.Path, diagEvent.Diagnostic); }; #endregion depParser.CustomSymbols = Tools.APIHelpers.Helpers.LoadIntrinsic(config.Copies, config.Format, DiagnosticsErrorEvent); //Load intrinsic depParser.CustomSymbols = Tools.APIHelpers.Helpers.LoadDependencies(config.Dependencies, config.Format, depParser.CustomSymbols, config.InputFiles, config.CopyFolders, DependencyErrorEvent); //Load dependencies if (diagDetected) { throw new CopyLoadingException("Diagnostics detected while parsing Intrinsic file", null, null, logged: false, needMail: false); } } baseTable = depParser.CustomSymbols; #endregion var typeCobolOptions = new TypeCobolOptions(config); #if EUROINFO_RULES typeCobolOptions.AutoRemarksEnable = config.AutoRemarks; #endif ReturnCode returnCode = ReturnCode.Success; List <Parser> parsers = new List <Parser>(); List <Compiler.Report.AbstractReport> reports = new List <AbstractReport>(); bool copyAreMissing = false; List <Diagnostic> diagnostics = new List <Diagnostic>(); foreach (var inputFilePath in config.InputFiles) { var parser = new Parser(); parser.CustomSymbols = baseTable; parsers.Add(parser); if (config.ExecToStep > ExecutionStep.SemanticCheck) //If inferior to semantic, use the execstep given by the user. { typeCobolOptions.ExecToStep = ExecutionStep.SemanticCheck; } try { parser.Init(inputFilePath, typeCobolOptions, config.Format, config.CopyFolders); //Init parser create CompilationProject & Compiler before parsing the given file } catch (Exception ex) { throw new ParsingException(MessageCode.ParserInit, ex.Message, inputFilePath, ex); //Make ParsingException trace back to RunOnce() } #region Copy Report Init if (config.ExecToStep >= ExecutionStep.CrossCheck) { if (!string.IsNullOrEmpty(config.ReportCopyMoveInitializeFilePath)) { if (config.UseAntlrProgramParsing) { Compiler.Parser.NodeDispatcher <Antlr4.Runtime.ParserRuleContext> .RegisterStaticNodeListenerFactory( () => { var report = new Compiler.Report.CopyMoveInitializeReport <Antlr4.Runtime.ParserRuleContext>(config.ReportCopyMoveInitializeFilePath); reports.Add(report); return(report); }); } else { Compiler.Parser.NodeDispatcher <Compiler.CodeElements.CodeElement> .RegisterStaticNodeListenerFactory( () => { var report = new Compiler.Report.CopyMoveInitializeReport <Compiler.CodeElements.CodeElement>(config.ReportCopyMoveInitializeFilePath); reports.Add(report); return(report); }); } } if (!string.IsNullOrEmpty(config.ReportZCallFilePath)) { if (config.UseAntlrProgramParsing) { Compiler.Parser.NodeDispatcher <Antlr4.Runtime.ParserRuleContext> .RegisterStaticNodeListenerFactory( () => { var report = new Compiler.Report.ZCallPgmReport <Antlr4.Runtime.ParserRuleContext>(config.ReportZCallFilePath); reports.Add(report); return(report); }); } else { Compiler.Parser.NodeDispatcher <Compiler.CodeElements.CodeElement> .RegisterStaticNodeListenerFactory( () => { var report = new Compiler.Report.ZCallPgmReport <Compiler.CodeElements.CodeElement>(config.ReportZCallFilePath); reports.Add(report); return(report); }); } } } #endregion //Parse input file parser.Parse(inputFilePath); diagnostics.AddRange(parser.Results.AllDiagnostics()); //Get all diags errorWriter.AddErrors(inputFilePath, diagnostics.Take(config.MaximumDiagnostics == 0 ? diagnostics.Count : config.MaximumDiagnostics)); //Write diags into error file if (!string.IsNullOrEmpty(config.HaltOnMissingCopyFilePath)) { if (parser.MissingCopys.Count > 0) { //Collect the missing copies copyAreMissing = true; File.WriteAllLines(config.HaltOnMissingCopyFilePath, parser.MissingCopys); } else { //Delete the file File.Delete(config.HaltOnMissingCopyFilePath); } } if (config.ExecToStep >= ExecutionStep.Preprocessor && !string.IsNullOrEmpty(config.ExtractedCopiesFilePath)) { if (parser.Results.CopyTextNamesVariations.Count > 0) { #if EUROINFO_RULES IEnumerable <string> copiesName; if (config.UseEuroInformationLegacyReplacingSyntax) { copiesName = parser.Results.CopyTextNamesVariations.Select(cp => cp.TextName).Distinct(); //Get copies without suffix } else { copiesName = parser.Results.CopyTextNamesVariations.Select(cp => cp.TextNameWithSuffix).Distinct(); //Get copies with suffix } #else var copiesName = parser.Results.CopyTextNamesVariations.Select(cp => cp.TextNameWithSuffix).Distinct(); //Get copies with suffix #endif //Create an output document of all the copy encountered by the parser File.WriteAllLines(config.ExtractedCopiesFilePath, copiesName); } else { File.Delete(config.ExtractedCopiesFilePath); } } if (copyAreMissing) { throw new MissingCopyException("Some copy are missing", inputFilePath, null, logged: false, needMail: false); } if (parser.Results.CodeElementsDocumentSnapshot == null && config.ExecToStep > ExecutionStep.Preprocessor) { throw new ParsingException(MessageCode.SyntaxErrorInParser, "File \"" + inputFilePath + "\" has syntactic error(s) preventing codegen (CodeElements).", inputFilePath); //Make ParsingException trace back to RunOnce() } else if (parser.Results.TemporaryProgramClassDocumentSnapshot == null && config.ExecToStep > ExecutionStep.SyntaxCheck) { throw new ParsingException(MessageCode.SyntaxErrorInParser, "File \"" + inputFilePath + "\" has semantic error(s) preventing codegen (ProgramClass).", inputFilePath); //Make ParsingException trace back to RunOnce() } if (config.ExecToStep >= ExecutionStep.SemanticCheck) { foreach (var program in parser.Results.TemporaryProgramClassDocumentSnapshot.Root.Programs) { var previousPrograms = baseTable.GetPrograms(); foreach (var previousProgram in previousPrograms) { previousProgram.SymbolTable.GetTableFromScope(SymbolTable.Scope.Namespace).AddProgram(program); } baseTable.AddProgram(program); //Add program to Namespace symbol table } } if (config.ExecToStep >= ExecutionStep.Preprocessor && !string.IsNullOrEmpty(config.ExpandingCopyFilePath)) { try { StringBuilder generatedCobolStringBuilder = new StringBuilder(); var generator = GeneratorFactoryManager.Instance.Create(TypeCobol.Tools.Options_Config.OutputFormat.ExpandingCopy.ToString(), parser.Results, generatedCobolStringBuilder, null, null); var streamWriter = new StreamWriter(config.ExpandingCopyFilePath); generator.Generate(parser.Results, ColumnsLayout.CobolReferenceFormat); streamWriter.Write(generatedCobolStringBuilder); streamWriter.Flush(); streamWriter.Close(); } catch (Exception e) { throw new GenerationException(e.Message, inputFilePath, e); } } } //Then do the CrossCheck when all the programs are loaded in SymbolTable if (config.ExecToStep > ExecutionStep.SemanticCheck) { int fileIndex = 0; foreach (var parser in parsers) { parser.Results.RefreshProgramClassDocumentSnapshot(); //Do Cross Check phase for each file diagnostics.Clear(); diagnostics.AddRange(parser.Results.AllDiagnostics()); //Get all diags errorWriter.Errors.Clear(); //Clear errorWriter because of the potential previous diags errorWriter.AddErrors(config.InputFiles[fileIndex], diagnostics.Take(config.MaximumDiagnostics == 0 ? diagnostics.Count : config.MaximumDiagnostics)); //Write diags into error file if (diagnostics.Count > 0) { foreach (var diag in diagnostics) { if (diag.CatchedException != null) { AnalyticsWrapper.Telemetry.TrackException(diag.CatchedException, config.InputFiles[fileIndex]); AnalyticsWrapper.Telemetry.SendMail(diag.CatchedException, config.InputFiles, config.CopyFolders, config.CommandLine); } } } if (diagnostics.Count == 0) { if (config.ExecToStep >= ExecutionStep.CrossCheck && reports != null && reports.Count > 0) { foreach (var report in reports) { try { report.Report(); string msg = string.Format( "Succeed to emit report '{0}'", report.Filepath); Console.WriteLine(msg); } catch (Exception e) { Console.Error.WriteLine(e.Message); throw new GenerationException(e.Message, report.Filepath, e); } } } } if (diagnostics.Any(d => d.Info.Severity == Compiler.Diagnostics.Severity.Error)) { throw new PresenceOfDiagnostics("Diagnostics Detected", config.InputFiles[fileIndex]); //Make ParsingException trace back to RunOnce() } if (diagnostics.Any(d => d.Info.Severity == Compiler.Diagnostics.Severity.Warning)) { returnCode = ReturnCode.Warning; } if (config.ExecToStep >= ExecutionStep.Generate) { try { //Load skeletons if necessary List <Skeleton> skeletons = null; if (!(string.IsNullOrEmpty(config.skeletonPath))) { skeletons = TypeCobol.Codegen.Config.Config.Parse(config.skeletonPath); } var sb = new StringBuilder(); //Get Generator from specified config.OutputFormat var generator = GeneratorFactoryManager.Instance.Create(config.OutputFormat.ToString(), parser.Results, sb, skeletons, AnalyticsWrapper.Telemetry.TypeCobolVersion); if (generator == null) { throw new GenerationException("Unknown OutputFormat=" + config.OutputFormat + "_", config.InputFiles[fileIndex]); } //Generate and check diagnostics generator.Generate(parser.Results, ColumnsLayout.CobolReferenceFormat); if (generator.Diagnostics != null) { errorWriter.AddErrors(config.InputFiles[fileIndex], generator.Diagnostics); //Write diags into error file throw new PresenceOfDiagnostics("Diagnostics Detected", config.InputFiles[fileIndex]); //Make ParsingException trace back to RunOnce() } var outputDirectory = new FileInfo(config.OutputFiles[fileIndex]).Directory; var lockFilePath = outputDirectory.FullName + Path.DirectorySeparatorChar + "~.lock"; if (File.Exists(lockFilePath)) { errorWriter.AddErrors(config.InputFiles[fileIndex], new Diagnostic(MessageCode.GenerationFailled, 0, 0, 0)); } else { var lockWriter = new StreamWriter(lockFilePath); lockWriter.Flush(); lockWriter.Close(); using (var streamWriter = new StreamWriter(config.OutputFiles[fileIndex])) { try { streamWriter.Write(sb); //Write generated Cobol inside file streamWriter.Flush(); } catch (Exception) { throw; } finally { File.Delete(lockFilePath); //Remove lock to allow watchers to read the file streamWriter.Close(); } } } } catch (PresenceOfDiagnostics) { throw; //Throw the same exception to let runOnce() knows there is a problem } catch (GenerationException) { throw; //Throw the same exception to let runOnce() knows there is a problem } catch (Exception e) { //Otherwise create a new GenerationException throw new GenerationException(e.Message, config.InputFiles[fileIndex], e); } fileIndex++; } } } return(returnCode); }