CClash.Program.Main C# (CSharp) Method

        public static int Main(string[] args)
        {
            var start = DateTime.Now;

            var dbg = Environment.GetEnvironmentVariable("CCLASH_DEBUG");
            if (!string.IsNullOrEmpty(dbg))
            {
                Settings.DebugFile = dbg;
                Settings.DebugEnabled = true;
            }

            if (Settings.DebugEnabled)
            {
                Logging.Emit("command line args:");
                foreach (var a in args)
                {
                    Logging.Emit("arg: {0}", a);
                }
            }

            if (args.Contains("--cclash-server"))
            {
                
                if (args.Contains("--attempt-pdb"))
                {
                    Environment.SetEnvironmentVariable("CCLASH_ATTEMPT_PDB_CACHE", "yes");
                }
                if (args.Contains("--pdb-to-z7"))
                {
                    Environment.SetEnvironmentVariable("CCLASH_Z7_OBJ", "yes");
                }

                if (Settings.DebugEnabled)
                {
                    if (Settings.DebugFile != null)
                    {
                        Settings.DebugFile += ".serv";
                    }
                }

                if (args.Contains("--debug")) {
                    if (Settings.DebugFile == null) {
                        Settings.DebugFile = "Console";
                        Settings.DebugEnabled = true;
                    }
                }

                Logging.Emit("starting in server mode");

                if (Settings.DebugFile != "Console") {
                    Logging.Emit("closing server console");
                    Console.Out.Close();
                    Console.Error.Close();
                    Console.In.Close();
                }

                
                Server = new CClashServer();
                if (Server.Preflight(Settings.CacheDirectory))
                {
                    Logging.Emit("server created");
                    Server.Listen(Settings.CacheDirectory);
                    return 0;
                }
                else
                {
                    Logging.Emit("another server is running.. quitting");
                    return 1;
                }
            }

            if (args.Contains("--cclash"))
            {
                Logging.Emit("maint mode");
                Console.Error.WriteLine("cclash {0} (c) Ian Norton, April 2014",
                    typeof(Program).Assembly.GetName().Version.ToString());

                var compiler = Compiler.Find();
                if (Settings.ServiceMode)
                {
                    for (int i = 0; i < 3; i++)
                    {
                        try
                        {
                            var cc = new CClashServerClient(Settings.CacheDirectory);
                            if (args.Contains("--stop"))
                            {
                                cc.Transact(new CClashRequest() { cmd = Command.Quit });
                            }
                            else {
                                #region server commands
                                if (args.Contains("--clear")) {
                                    cc.Transact(new CClashRequest() { cmd = Command.ClearCache });
                                } else if ( args.Contains("--disable") ){
                                    cc.Transact(new CClashRequest() { cmd = Command.DisableCache });
                                } else if (args.Contains("--enable") ){
                                    cc.Transact(new CClashRequest() { cmd = Command.EnableCache });
                                } else if (args.Contains("--start")) {
                                    Console.Out.WriteLine("starting server");
                                    CClashServerClient.StartBackgroundServer();
                                } else {
                                    Console.Out.WriteLine(cc.GetStats(compiler));
                                }
                                return 0;

                                #endregion
                            }

                        }
                        catch (CClashErrorException ex)
                        {
                            Logging.Error(ex.Message);
                            return -1;
                        }
                        catch (CClashWarningException)
                        {
                            System.Threading.Thread.Sleep(2000);
                        }
                        catch (CClashServerNotReadyException)
                        {
                            Logging.Emit("server not ready, try again");
                            return -1;
                        }
                        catch (IOException ex)
                        {
                            Logging.Error(ex.ToString());
                            return -1;
                        }
                    }
                }
                else
                {
                    ICompiler comp;
                    using (ICompilerCache cc =
                        CompilerCacheFactory.Get(Settings.DirectMode, Settings.CacheDirectory, compiler, Environment.CurrentDirectory, Compiler.GetEnvironmentDictionary(), out comp))
                    {
                        Console.Out.WriteLine(StatOutputs.GetStatsString(compiler, cc));
                    }
                }
                return 0;
            }

            var rv = RunBuild(args, start, AppendStdout, AppendStderr);
            if (rv != 0)
            {
                if (!Settings.NoAutoRebuild)
                {
                    for (int i = 1; i < 4; i++)
                    {
                        MainStdErr.Clear();
                        MainStdOut.Clear();
                        rv = RunBuild(args, start, AppendStdout, AppendStderr);
                        if (rv == 0) break;
                        System.Threading.Thread.Sleep(100);
                    }
                }
            }
            Console.Error.Write(MainStdErr.ToString());
            Console.Out.Write(MainStdOut.ToString());

            if (spawnServer) {
                Logging.Emit("server needs to be started");
            }
            return rv;
        }