Write error messages to stderr, renamed messages to errorMessages

Brahim Hadriche · tritao · commit d5a1210aa48c · 2018-04-10T15:56:49.000+01:00
diff --git a/src/CLI/CLI.cs b/src/CLI/CLI.cs
@@ -10,25 +10,25 @@ class CLI
         private static OptionSet optionSet = new OptionSet();
         private static Options options = new Options();
         
-        static bool ParseCommandLineArgs(string[] args, List<string> messages, ref bool helpShown)
+        static bool ParseCommandLineArgs(string[] args, List<string> errorMessages, ref bool helpShown)
         {
             var showHelp = false;
 
-            optionSet.Add("I=", "the {PATH} of a folder to search for include files", (i) => { AddIncludeDirs(i, messages); });
+            optionSet.Add("I=", "the {PATH} of a folder to search for include files", (i) => { AddIncludeDirs(i, errorMessages); });
             optionSet.Add("l=", "{LIBRARY} that that contains the symbols of the generated code", l => options.Libraries.Add(l) );
             optionSet.Add("L=", "the {PATH} of a folder to search for additional libraries", l => options.LibraryDirs.Add(l) );
-            optionSet.Add("D:", "additional define with (optional) value to add to be used while parsing the given header files", (n, v) => AddDefine(n, v, messages) );
-            optionSet.Add("A=", "additional Clang arguments to pass to the compiler while parsing the given header files", (v) => AddArgument(v, messages) );
+            optionSet.Add("D:", "additional define with (optional) value to add to be used while parsing the given header files", (n, v) => AddDefine(n, v, errorMessages) );
+            optionSet.Add("A=", "additional Clang arguments to pass to the compiler while parsing the given header files", (v) => AddArgument(v, errorMessages) );
 
-            optionSet.Add("o=|output=", "the {PATH} for the generated bindings file (doesn't need the extension since it will depend on the generator)", v => HandleOutputArg(v, messages) );
+            optionSet.Add("o=|output=", "the {PATH} for the generated bindings file (doesn't need the extension since it will depend on the generator)", v => HandleOutputArg(v, errorMessages) );
             optionSet.Add("on=|outputnamespace=", "the {NAMESPACE} that will be used for the generated code", on => options.OutputNamespace = on );
 
             optionSet.Add("iln=|inputlibraryname=|inputlib=", "the {NAME} of the shared library that contains the symbols of the generated code", iln => options.InputLibraryName = iln );
             optionSet.Add("d|debug", "enables debug mode which generates more verbose code to aid debugging", v => options.Debug = true);
             optionSet.Add("c|compile", "enables automatic compilation of the generated code", v => options.Compile = true);
-            optionSet.Add("g=|gen=|generator=", "the {TYPE} of generated code: 'chsarp' or 'cli' ('cli' supported only for Windows)", g => { GetGeneratorKind(g, messages); } );
-            optionSet.Add("p=|platform=", "the {PLATFORM} that the generated code will target: 'win', 'osx' or 'linux'", p => { GetDestinationPlatform(p, messages); } );
-            optionSet.Add("a=|arch=", "the {ARCHITECTURE} that the generated code will target: 'x86' or 'x64'", a => { GetDestinationArchitecture(a, messages); } );
+            optionSet.Add("g=|gen=|generator=", "the {TYPE} of generated code: 'chsarp' or 'cli' ('cli' supported only for Windows)", g => { GetGeneratorKind(g, errorMessages); } );
+            optionSet.Add("p=|platform=", "the {PLATFORM} that the generated code will target: 'win', 'osx' or 'linux'", p => { GetDestinationPlatform(p, errorMessages); } );
+            optionSet.Add("a=|arch=", "the {ARCHITECTURE} that the generated code will target: 'x86' or 'x64'", a => { GetDestinationArchitecture(a, errorMessages); } );
 
             optionSet.Add("exceptions", "enables support for C++ exceptions in the parser", v => { options.Arguments.Add("-fcxx-exceptions"); });
 
@@ -59,7 +59,7 @@ static bool ParseCommandLineArgs(string[] args, List<string> messages, ref bool
             }
 
             foreach(string s in additionalArguments)
-                HandleAdditionalArgument(s, messages);
+                HandleAdditionalArgument(s, errorMessages);
 
             return true;
         }
@@ -94,15 +94,15 @@ static void ShowHelp()
             Console.WriteLine("   contain only the bindings for that header file.");
         }
 
-        static void AddIncludeDirs(string dir, List<string> messages)
+        static void AddIncludeDirs(string dir, List<string> errorMessages)
         {
             if (Directory.Exists(dir))
                 options.IncludeDirs.Add(dir);
             else
-                messages.Add(string.Format("Directory '{0}' doesn't exist. Ignoring as include directory.", dir));
+                errorMessages.Add(string.Format("Directory '{0}' doesn't exist. Ignoring as include directory.", dir));
         }
 
-        static void HandleOutputArg(string arg, List<string> messages)
+        static void HandleOutputArg(string arg, List<string> errorMessages)
         {
             try
             {
@@ -114,30 +114,30 @@ static void HandleOutputArg(string arg, List<string> messages)
             }
             catch(Exception e)
             {
-                messages.Add(e.Message);
+                errorMessages.Add(e.Message);
 
                 options.OutputDir = "";
                 options.OutputFileName = "";
             }
         }
 
-        static void AddArgument(string value, List<string> messages)
+        static void AddArgument(string value, List<string> errorMessages)
         {
             if (value == null)
-                messages.Add("Invalid compiler argument name for option -A.");
+                errorMessages.Add("Invalid compiler argument name for option -A.");
             else
                 options.Arguments.Add(value);
         }
 
-        static void AddDefine(string name, string value, List<string> messages)
+        static void AddDefine(string name, string value, List<string> errorMessages)
         {
             if (name == null)
-                messages.Add("Invalid definition name for option -D.");
+                errorMessages.Add("Invalid definition name for option -D.");
             else
                 options.Defines.Add(name, value);
         }
 
-        static void HandleAdditionalArgument(string args, List<string> messages)
+        static void HandleAdditionalArgument(string args, List<string> errorMessages)
         {
             if (!Path.IsPathRooted(args))
                 args = Path.Combine(Directory.GetCurrentDirectory(), args);
@@ -146,21 +146,21 @@ static void HandleAdditionalArgument(string args, List<string> messages)
             {
                 bool searchQuery = args.IndexOf('*') >= 0 || args.IndexOf('?') >= 0;
                 if (searchQuery || Directory.Exists(args))
-                    GetFilesFromPath(args, messages);
+                    GetFilesFromPath(args, errorMessages);
                 else if (File.Exists(args))
                     options.HeaderFiles.Add(args);
                 else
                 {
-                    messages.Add(string.Format("File '{0}' could not be found.", args));
+                    errorMessages.Add(string.Format("File '{0}' could not be found.", args));
                 }
             }
             catch(Exception)
             {
-                messages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", args));
+                errorMessages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", args));
             }
         }
 
-        static void GetFilesFromPath(string path, List<string> messages)
+        static void GetFilesFromPath(string path, List<string> errorMessages)
         {
             path = path.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 
@@ -195,11 +195,11 @@ static void GetFilesFromPath(string path, List<string> messages)
             }
             catch (Exception)
             {
-                messages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", path));
+                errorMessages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", path));
             }
         }
 
-        static void GetGeneratorKind(string generator, List<string> messages)
+        static void GetGeneratorKind(string generator, List<string> errorMessages)
         {
             switch (generator.ToLower())
             {
@@ -211,10 +211,10 @@ static void GetGeneratorKind(string generator, List<string> messages)
                     return;
             }
 
-            messages.Add(string.Format("Unknown generator kind: {0}. Defaulting to {1}", generator, options.Kind.ToString()));
+            errorMessages.Add(string.Format("Unknown generator kind: {0}. Defaulting to {1}", generator, options.Kind.ToString()));
         }
 
-        static void GetDestinationPlatform(string platform, List<string> messages)
+        static void GetDestinationPlatform(string platform, List<string> errorMessages)
         {
             switch (platform.ToLower())
             {
@@ -229,10 +229,10 @@ static void GetDestinationPlatform(string platform, List<string> messages)
                     return;
             }
 
-            messages.Add(string.Format("Unknown target platform: {0}. Defaulting to {1}", platform, options.Platform.ToString()));
+            errorMessages.Add(string.Format("Unknown target platform: {0}. Defaulting to {1}", platform, options.Platform.ToString()));
         }
 
-        static void GetDestinationArchitecture(string architecture, List<string> messages)
+        static void GetDestinationArchitecture(string architecture, List<string> errorMessages)
         {
             switch (architecture.ToLower())
             {
@@ -244,43 +244,43 @@ static void GetDestinationArchitecture(string architecture, List<string> message
                     return;
             }
 
-            messages.Add(string.Format("Unknown target architecture: {0}. Defaulting to {1}", architecture, options.Architecture.ToString()));
+            errorMessages.Add(string.Format("Unknown target architecture: {0}. Defaulting to {1}", architecture, options.Architecture.ToString()));
         }
 
-        static void PrintMessages(List<string> messages)
+        static void PrintErrorMessages(List<string> errorMessages)
         {
-            foreach (string m in messages)
-                Console.WriteLine(m);
+            foreach (string m in errorMessages)
+                Console.Error.WriteLine(m);
         }
 
         static void Main(string[] args)
         {
-            List<string> messages = new List<string>();
+            List<string> errorMessages = new List<string>();
             bool helpShown = false;
 
             try
             {
-                if (!ParseCommandLineArgs(args, messages, ref helpShown))
+                if (!ParseCommandLineArgs(args, errorMessages, ref helpShown))
                 {
-                    PrintMessages(messages);
+                    PrintErrorMessages(errorMessages);
 
                     // Don't need to show the help since if ParseCommandLineArgs returns false the help has already been shown
                     return;
                 }
 
                 Generator gen = new Generator(options);
 
-                bool validOptions = gen.ValidateOptions(messages);
+                bool validOptions = gen.ValidateOptions(errorMessages);
 
-                PrintMessages(messages);
+                PrintErrorMessages(errorMessages);
 
                 if (validOptions)
                     gen.Run();
             }
             catch (Exception ex)
             {
-                PrintMessages(messages);
-                Console.WriteLine(ex.Message);
+                PrintErrorMessages(errorMessages);
+                Console.Error.WriteLine(ex.Message);
             }
         }
     }
diff --git a/src/Core/Diagnostics.cs b/src/Core/Diagnostics.cs
@@ -120,7 +120,14 @@ public void Emit(DiagnosticInfo info)
             var currentIndent = Indents.Sum();
             var message = new string(' ', currentIndent) + info.Message;
 
-            Console.WriteLine(message);
+            if(info.Kind == DiagnosticKind.Error)
+            {
+                Console.Error.WriteLine(message);
+            }
+            else 
+            {
+                Console.WriteLine(message);
+            }
             Debug.WriteLine(message);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -10,25 +10,25 @@ class CLI`
`10`	`10`	`private static OptionSet optionSet = new OptionSet();`
`11`	`11`	`private static Options options = new Options();`
`12`	`12`
`13`		`- static bool ParseCommandLineArgs(string[] args, List<string> messages, ref bool helpShown)`
	`13`	`+ static bool ParseCommandLineArgs(string[] args, List<string> errorMessages, ref bool helpShown)`
`14`	`14`	`{`
`15`	`15`	`var showHelp = false;`
`16`	`16`
`17`		`- optionSet.Add("I=", "the {PATH} of a folder to search for include files", (i) => { AddIncludeDirs(i, messages); });`
	`17`	`+ optionSet.Add("I=", "the {PATH} of a folder to search for include files", (i) => { AddIncludeDirs(i, errorMessages); });`
`18`	`18`	`optionSet.Add("l=", "{LIBRARY} that that contains the symbols of the generated code", l => options.Libraries.Add(l) );`
`19`	`19`	`optionSet.Add("L=", "the {PATH} of a folder to search for additional libraries", l => options.LibraryDirs.Add(l) );`
`20`		`- optionSet.Add("D:", "additional define with (optional) value to add to be used while parsing the given header files", (n, v) => AddDefine(n, v, messages) );`
`21`		`- optionSet.Add("A=", "additional Clang arguments to pass to the compiler while parsing the given header files", (v) => AddArgument(v, messages) );`
	`20`	`+ optionSet.Add("D:", "additional define with (optional) value to add to be used while parsing the given header files", (n, v) => AddDefine(n, v, errorMessages) );`
	`21`	`+ optionSet.Add("A=", "additional Clang arguments to pass to the compiler while parsing the given header files", (v) => AddArgument(v, errorMessages) );`
`22`	`22`
`23`		`- optionSet.Add("o=\|output=", "the {PATH} for the generated bindings file (doesn't need the extension since it will depend on the generator)", v => HandleOutputArg(v, messages) );`
	`23`	`+ optionSet.Add("o=\|output=", "the {PATH} for the generated bindings file (doesn't need the extension since it will depend on the generator)", v => HandleOutputArg(v, errorMessages) );`
`24`	`24`	`optionSet.Add("on=\|outputnamespace=", "the {NAMESPACE} that will be used for the generated code", on => options.OutputNamespace = on );`
`25`	`25`
`26`	`26`	`optionSet.Add("iln=\|inputlibraryname=\|inputlib=", "the {NAME} of the shared library that contains the symbols of the generated code", iln => options.InputLibraryName = iln );`
`27`	`27`	`optionSet.Add("d\|debug", "enables debug mode which generates more verbose code to aid debugging", v => options.Debug = true);`
`28`	`28`	`optionSet.Add("c\|compile", "enables automatic compilation of the generated code", v => options.Compile = true);`
`29`		`- optionSet.Add("g=\|gen=\|generator=", "the {TYPE} of generated code: 'chsarp' or 'cli' ('cli' supported only for Windows)", g => { GetGeneratorKind(g, messages); } );`
`30`		`- optionSet.Add("p=\|platform=", "the {PLATFORM} that the generated code will target: 'win', 'osx' or 'linux'", p => { GetDestinationPlatform(p, messages); } );`
`31`		`- optionSet.Add("a=\|arch=", "the {ARCHITECTURE} that the generated code will target: 'x86' or 'x64'", a => { GetDestinationArchitecture(a, messages); } );`
	`29`	`+ optionSet.Add("g=\|gen=\|generator=", "the {TYPE} of generated code: 'chsarp' or 'cli' ('cli' supported only for Windows)", g => { GetGeneratorKind(g, errorMessages); } );`
	`30`	`+ optionSet.Add("p=\|platform=", "the {PLATFORM} that the generated code will target: 'win', 'osx' or 'linux'", p => { GetDestinationPlatform(p, errorMessages); } );`
	`31`	`+ optionSet.Add("a=\|arch=", "the {ARCHITECTURE} that the generated code will target: 'x86' or 'x64'", a => { GetDestinationArchitecture(a, errorMessages); } );`
`32`	`32`
`33`	`33`	`optionSet.Add("exceptions", "enables support for C++ exceptions in the parser", v => { options.Arguments.Add("-fcxx-exceptions"); });`
`34`	`34`
`@@ -59,7 +59,7 @@ static bool ParseCommandLineArgs(string[] args, List<string> messages, ref bool`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`foreach(string s in additionalArguments)`
`62`		`- HandleAdditionalArgument(s, messages);`
	`62`	`+ HandleAdditionalArgument(s, errorMessages);`
`63`	`63`
`64`	`64`	`return true;`
`65`	`65`	`}`
`@@ -94,15 +94,15 @@ static void ShowHelp()`
`94`	`94`	`Console.WriteLine(" contain only the bindings for that header file.");`
`95`	`95`	`}`
`96`	`96`
`97`		`- static void AddIncludeDirs(string dir, List<string> messages)`
	`97`	`+ static void AddIncludeDirs(string dir, List<string> errorMessages)`
`98`	`98`	`{`
`99`	`99`	`if (Directory.Exists(dir))`
`100`	`100`	`options.IncludeDirs.Add(dir);`
`101`	`101`	`else`
`102`		`- messages.Add(string.Format("Directory '{0}' doesn't exist. Ignoring as include directory.", dir));`
	`102`	`+ errorMessages.Add(string.Format("Directory '{0}' doesn't exist. Ignoring as include directory.", dir));`
`103`	`103`	`}`
`104`	`104`
`105`		`- static void HandleOutputArg(string arg, List<string> messages)`
	`105`	`+ static void HandleOutputArg(string arg, List<string> errorMessages)`
`106`	`106`	`{`
`107`	`107`	`try`
`108`	`108`	`{`
`@@ -114,30 +114,30 @@ static void HandleOutputArg(string arg, List<string> messages)`
`114`	`114`	`}`
`115`	`115`	`catch(Exception e)`
`116`	`116`	`{`
`117`		`- messages.Add(e.Message);`
	`117`	`+ errorMessages.Add(e.Message);`
`118`	`118`
`119`	`119`	`options.OutputDir = "";`
`120`	`120`	`options.OutputFileName = "";`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`- static void AddArgument(string value, List<string> messages)`
	`124`	`+ static void AddArgument(string value, List<string> errorMessages)`
`125`	`125`	`{`
`126`	`126`	`if (value == null)`
`127`		`- messages.Add("Invalid compiler argument name for option -A.");`
	`127`	`+ errorMessages.Add("Invalid compiler argument name for option -A.");`
`128`	`128`	`else`
`129`	`129`	`options.Arguments.Add(value);`
`130`	`130`	`}`
`131`	`131`
`132`		`- static void AddDefine(string name, string value, List<string> messages)`
	`132`	`+ static void AddDefine(string name, string value, List<string> errorMessages)`
`133`	`133`	`{`
`134`	`134`	`if (name == null)`
`135`		`- messages.Add("Invalid definition name for option -D.");`
	`135`	`+ errorMessages.Add("Invalid definition name for option -D.");`
`136`	`136`	`else`
`137`	`137`	`options.Defines.Add(name, value);`
`138`	`138`	`}`
`139`	`139`
`140`		`- static void HandleAdditionalArgument(string args, List<string> messages)`
	`140`	`+ static void HandleAdditionalArgument(string args, List<string> errorMessages)`
`141`	`141`	`{`
`142`	`142`	`if (!Path.IsPathRooted(args))`
`143`	`143`	`args = Path.Combine(Directory.GetCurrentDirectory(), args);`
`@@ -146,21 +146,21 @@ static void HandleAdditionalArgument(string args, List<string> messages)`
`146`	`146`	`{`
`147`	`147`	`bool searchQuery = args.IndexOf('*') >= 0 \|\| args.IndexOf('?') >= 0;`
`148`	`148`	`if (searchQuery \|\| Directory.Exists(args))`
`149`		`- GetFilesFromPath(args, messages);`
	`149`	`+ GetFilesFromPath(args, errorMessages);`
`150`	`150`	`else if (File.Exists(args))`
`151`	`151`	`options.HeaderFiles.Add(args);`
`152`	`152`	`else`
`153`	`153`	`{`
`154`		`- messages.Add(string.Format("File '{0}' could not be found.", args));`
	`154`	`+ errorMessages.Add(string.Format("File '{0}' could not be found.", args));`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`	`catch(Exception)`
`158`	`158`	`{`
`159`		`- messages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", args));`
	`159`	`+ errorMessages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", args));`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`		`- static void GetFilesFromPath(string path, List<string> messages)`
	`163`	`+ static void GetFilesFromPath(string path, List<string> errorMessages)`
`164`	`164`	`{`
`165`	`165`	`path = path.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);`
`166`	`166`
`@@ -195,11 +195,11 @@ static void GetFilesFromPath(string path, List<string> messages)`
`195`	`195`	`}`
`196`	`196`	`catch (Exception)`
`197`	`197`	`{`
`198`		`- messages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", path));`
	`198`	`+ errorMessages.Add(string.Format("Error while looking for files inside path '{0}'. Ignoring.", path));`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`202`		`- static void GetGeneratorKind(string generator, List<string> messages)`
	`202`	`+ static void GetGeneratorKind(string generator, List<string> errorMessages)`
`203`	`203`	`{`
`204`	`204`	`switch (generator.ToLower())`
`205`	`205`	`{`
`@@ -211,10 +211,10 @@ static void GetGeneratorKind(string generator, List<string> messages)`
`211`	`211`	`return;`
`212`	`212`	`}`
`213`	`213`
`214`		`- messages.Add(string.Format("Unknown generator kind: {0}. Defaulting to {1}", generator, options.Kind.ToString()));`
	`214`	`+ errorMessages.Add(string.Format("Unknown generator kind: {0}. Defaulting to {1}", generator, options.Kind.ToString()));`
`215`	`215`	`}`
`216`	`216`
`217`		`- static void GetDestinationPlatform(string platform, List<string> messages)`
	`217`	`+ static void GetDestinationPlatform(string platform, List<string> errorMessages)`
`218`	`218`	`{`
`219`	`219`	`switch (platform.ToLower())`
`220`	`220`	`{`
`@@ -229,10 +229,10 @@ static void GetDestinationPlatform(string platform, List<string> messages)`
`229`	`229`	`return;`
`230`	`230`	`}`
`231`	`231`
`232`		`- messages.Add(string.Format("Unknown target platform: {0}. Defaulting to {1}", platform, options.Platform.ToString()));`
	`232`	`+ errorMessages.Add(string.Format("Unknown target platform: {0}. Defaulting to {1}", platform, options.Platform.ToString()));`
`233`	`233`	`}`
`234`	`234`
`235`		`- static void GetDestinationArchitecture(string architecture, List<string> messages)`
	`235`	`+ static void GetDestinationArchitecture(string architecture, List<string> errorMessages)`
`236`	`236`	`{`
`237`	`237`	`switch (architecture.ToLower())`
`238`	`238`	`{`
`@@ -244,43 +244,43 @@ static void GetDestinationArchitecture(string architecture, List<string> message`
`244`	`244`	`return;`
`245`	`245`	`}`
`246`	`246`
`247`		`- messages.Add(string.Format("Unknown target architecture: {0}. Defaulting to {1}", architecture, options.Architecture.ToString()));`
	`247`	`+ errorMessages.Add(string.Format("Unknown target architecture: {0}. Defaulting to {1}", architecture, options.Architecture.ToString()));`
`248`	`248`	`}`
`249`	`249`
`250`		`- static void PrintMessages(List<string> messages)`
	`250`	`+ static void PrintErrorMessages(List<string> errorMessages)`
`251`	`251`	`{`
`252`		`- foreach (string m in messages)`
`253`		`- Console.WriteLine(m);`
	`252`	`+ foreach (string m in errorMessages)`
	`253`	`+ Console.Error.WriteLine(m);`
`254`	`254`	`}`
`255`	`255`
`256`	`256`	`static void Main(string[] args)`
`257`	`257`	`{`
`258`		`- List<string> messages = new List<string>();`
	`258`	`+ List<string> errorMessages = new List<string>();`
`259`	`259`	`bool helpShown = false;`
`260`	`260`
`261`	`261`	`try`
`262`	`262`	`{`
`263`		`- if (!ParseCommandLineArgs(args, messages, ref helpShown))`
	`263`	`+ if (!ParseCommandLineArgs(args, errorMessages, ref helpShown))`
`264`	`264`	`{`
`265`		`- PrintMessages(messages);`
	`265`	`+ PrintErrorMessages(errorMessages);`
`266`	`266`
`267`	`267`	`// Don't need to show the help since if ParseCommandLineArgs returns false the help has already been shown`
`268`	`268`	`return;`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`Generator gen = new Generator(options);`
`272`	`272`
`273`		`- bool validOptions = gen.ValidateOptions(messages);`
	`273`	`+ bool validOptions = gen.ValidateOptions(errorMessages);`
`274`	`274`
`275`		`- PrintMessages(messages);`
	`275`	`+ PrintErrorMessages(errorMessages);`
`276`	`276`
`277`	`277`	`if (validOptions)`
`278`	`278`	`gen.Run();`
`279`	`279`	`}`
`280`	`280`	`catch (Exception ex)`
`281`	`281`	`{`
`282`		`- PrintMessages(messages);`
`283`		`- Console.WriteLine(ex.Message);`
	`282`	`+ PrintErrorMessages(errorMessages);`
	`283`	`+ Console.Error.WriteLine(ex.Message);`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`	`}`