Beispiel #1
0
        static int Main(string[] args)
        {
            ScriptContext context = new ScriptContext();
            using (ConsoleWithColors cout = new ConsoleWithColors(Environment.GetEnvironmentVariable("XSH_COLORS")))
            using (ConsoleRedirector redir = new ConsoleRedirector(context))
            using (CtrlCInterceptor ctrl = new CtrlCInterceptor())
            {
                context.Output += cout.OnOutput;
                ctrl.Output = context.Error;
                ctrl.Abort += delegate { context.Abort(); };
                cout.DebugMode = true;

                // context.Progress=console.OnOutputProgress;
                int exitCode = 0;
                try
                {
                    var script = new Generated.$safeprojectname$().Script;
                    ctrl.IgnoreCtrlC = script.IgnoreCtrlC;
                    ctrl.AbortDelay = Utils.ToTimeSpan(script.AbortDelay) ?? ctrl.AbortDelay;
                    ctrl.ExitDelay = Utils.ToTimeSpan(script.ExitDelay) ?? ctrl.ExitDelay;

                    object o = context.ExecuteScript(script, args);
                    if (o != null)
                        exitCode = Utils.To<int>(o);
                }
                catch (ScriptTerminateException te)
                {
                    exitCode = te.ExitCode;
                    if (te.InnerException != null)
                        context.WriteException(te.InnerException);
                }
                catch (Exception e)
                {
                    context.WriteException(e);
                    exitCode = -1;
                }
                return exitCode;
            }
        }
Beispiel #2
0
        // Real main
        static int MainWithContext(XS.ScriptContext context, string[] args)
        {
            AppDomainLoader.progress("MainWithContext: Entering --------------------");
            XS.CommandLineParameter[] param = new XS.CommandLineParameter[] {
                new XS.CommandLineParameter(xs.quiet,        XS.CommandLineValueCount.None, null,"true" ),
                new XS.CommandLineParameter(xs.debug,        XS.CommandLineValueCount.None, "false", "true" ) ,
                new XS.CommandLineParameter(xs.debugc,       XS.CommandLineValueCount.None, "false", "true" ) ,
                new XS.CommandLineParameter(xs.verbose,      XS.CommandLineValueCount.None, "false", "true" ) ,
                new XS.CommandLineParameter(xs.nocolors,     XS.CommandLineValueCount.None, "false", "true" ) ,
                new XS.CommandLineParameter(xs.wait,         XS.CommandLineValueCount.None, null,"true" ) ,
                new XS.CommandLineParameter(xs.save,         XS.CommandLineValueCount.Single, null,"xsharper_save.xsh" ) ,
                new XS.CommandLineParameter(xs.log,          XS.CommandLineValueCount.Single, null,"xsharper.log" ) ,
                new XS.CommandLineParameter(xs.requireAdmin, XS.CommandLineValueCount.None, null,"true" ) ,
                new XS.CommandLineParameter(xs.last,         XS.CommandLineValueCount.None, null,"true") ,
                new XS.CommandLineParameter(xs.utf8,         XS.CommandLineValueCount.None, "false", "true"),
                new XS.CommandLineParameter(xs.scriptargs,   null, XS.CommandLineValueCount.Multiple, null,null) 
             };
            param[param.Length - 1].Last = true;
            param[param.Length - 2].Last = true;

            XS.CommandLineParameters xsParams = new XS.CommandLineParameters(param,"//",false);
            foreach (XS.CommandLineParameter a in xsParams)
                if (!string.IsNullOrEmpty(a.Name) && a.Name!=xs.scriptargs)
                    a.Switch = a.Name.Replace("xs.", "");
            
            
            int exitCode = 0;

            bool utf8 = false;
            foreach (string arg in args)
                if (arg.Equals(xs.utf8.Replace("xs.", "//"), StringComparison.OrdinalIgnoreCase))
                    utf8 = true;
            using (XS.ConsoleWithColors cout = new XS.ConsoleWithColors(Environment.GetEnvironmentVariable("XSH_COLORS"),utf8))
            using (XS.CtrlCInterceptor ctrl = new XS.CtrlCInterceptor())
            {
                context.Output += cout.OnOutput;
                ctrl.Output = context.Error;
                ctrl.Abort += delegate { context.Abort(); };

                AppDomainLoader.progress("MainWithContext: Console ready --------------------"); 
                System.Diagnostics.Stopwatch w = System.Diagnostics.Stopwatch.StartNew();

                try
                {
                    AppDomainLoader.progress("MainWithContext: Before parse--------------------"); 
                    xsParams.Parse(context, args, false);
                    AppDomainLoader.progress("MainWithContext: Before set options--------------------"); 
                    setOutputOptions(context, cout);

                    AppDomainLoader.progress("MainWithContext: Before load--------------------"); 
                    ${GENERATED_CLASS} cl = new ${GENERATED_CLASS}();
                    XS.Script s = cl.Script;
                    ctrl.IgnoreCtrlC = s.IgnoreCtrlC;
                    ctrl.AbortDelay = XS.Utils.ToTimeSpan(s.AbortDelay) ?? ctrl.AbortDelay;
                    ctrl.ExitDelay = XS.Utils.ToTimeSpan(s.ExitDelay) ?? ctrl.ExitDelay;
                        
                     
                    AppDomainLoader.progress("MainWithContext: After load--------------------"); 
                    if (context.IsSet(xs.save))
                    {
                        using (XS.ScriptContextScope r=new XS.ScriptContextScope(context))
                            s.Save(context.GetString(xs.save));
                    }
                    else
                    {
                        context.Compiler.AddRequireAdmin(XS.Utils.To<XS.RequireAdminMode>(context.GetStr(xs.requireAdmin, XS.RequireAdminMode.User.ToString())));
                        context.Compiler.AddRequireAdmin(s.RequireAdmin);
                        if (context.Compiler.RequireAdmin!=XS.RequireAdminMode.User && !context.IsAdministrator)
                            return restartAsAdmin(context, args, context.Compiler.RequireAdmin==XS.RequireAdminMode.Hidden);

                        AppDomainLoader.progress("MainWithContext: Before initialization --------------------"); 
                        context.Initialize(s);
                        AppDomainLoader.progress("MainWithContext: After initialization --------------------"); 
                        string[] parms = null;
                        if (context.IsSet(xs.scriptargs))
                            parms = context.GetStringArray(xs.scriptargs);

                        XS.ConsoleRedirector redir = new XS.ConsoleRedirector(context);
                        try
                        {
                            AppDomainLoader.progress("MainWithContext: Before executing --------------------"); 
                            object r = context.ExecuteScript(s, parms, XS.CallIsolation.High);
                            ctrl.KillAbortTimer();
                            AppDomainLoader.progress("MainWithContext: After executing --------------------"); 
                            if (r != null)
                                int.TryParse(r.ToString(), out exitCode);
                        }
                        finally 
                        {
                            ctrl.KillAbortTimer();
                            redir.Dispose();
                        }
                    }
                }
Beispiel #3
0
        static int MainWithContext(ScriptContext context, string[] args)
        {
            CommandLineParameters xsParams = getXsParams();
            int exitCode = 0;

            ConsoleRedirector redir = null;
            AppDomainLoader.progress("MainWithContext: Entering --------------------");
            bool utf8 = false;
            foreach (string arg in args)
                if (arg.Equals(xs.utf8.Replace("xs.", "//"), StringComparison.OrdinalIgnoreCase))
                    utf8 = true;
            using (ConsoleWithColors cout = new ConsoleWithColors(Environment.GetEnvironmentVariable("XSH_COLORS"),utf8))
            using (CtrlCInterceptor ctrl = new CtrlCInterceptor())
            {
                context.Output += cout.OnOutput;
                ctrl.Output = context.Error;
                ctrl.Abort += delegate { context.Abort(); };

                Stopwatch w = Stopwatch.StartNew();
                try
                {
                    // Parse arguments
                    var usage = new UsageGenerator() { Options = UsageOptions.None };
                    xsParams.Parse(context, args, false);
                    setOutputOptions(context, cout);

                    if (context.IsSet(xs.path))
                        context.ScriptPath = context.GetString(xs.path);

                    // Load references
                    List<IScriptAction> preScript = getCommandlineReferences(context);

                    // Print help
                    if (args.Length == 0 || context.IsSet(xs.help))
                    {
                        loadReferences(context,preScript);
                        exitCode = HelpHelper.Help(context, usage , xsParams);
                        goto end;
                    }

                    // Handle upgrade
                    if (context.GetBool(xs.upgrade, false))    { return upgrade(context);}
                    if (context.IsSet(xs.updateStage))              { return updateStage(context, context.GetStringArray(xs.updateStage));}

                    AppDomainLoader.progress("MainWithContext: Processing options");
                    // Process the remaining options
                    context.Compiler.AddRequireAdmin(Utils.To<RequireAdminMode>(context.GetStr(xs.requireAdmin, RequireAdminMode.User.ToString())));

                    if (context.IsSet(xs.codeout))
                        context.CodeOutputDirectory = Path.GetFullPath(context.GetString(xs.codeout));
                    if (context.IsSet(xs.genconfig) || context.IsSet(xs.gensample))
                        genDemoConfig(cout, context);
                    if (context.IsSet(xs.forcenet20))
                        context.Compiler.DefaultNETVersion = new Version(2,0);

                     AppDomainLoader.progress("MainWithContext: Processing options, continuing");

                    List<string> filteredArgs = new List<string>();
                    if (context.IsSet(xs.scriptargs))
                        filteredArgs.AddRange(context.GetStringArray(xs.scriptargs));

                    // Run utilities, like //download etc
                    Script script= getInlineScript(context, filteredArgs);
                    string scriptName = context.GetString(xs.script, null);
                    if (script == null)
                    {
                        // Load the script
                        if (scriptName == "/?" || scriptName == "-?")
                        {
                            for (int i = 0; i < args.Length;++i )
                                if (args[i] == "/?" || args[i]=="-?")
                                {
                                    if (i != args.Length - 1)
                                        context[xs.help] = args[i + 1];
                                    break;
                                }
                            loadReferences(context, preScript);
                            return HelpHelper.Help(context, usage, xsParams);
                        }
                        if (scriptName != null)
                        {
                            AppDomainLoader.progress("MainWithContext: Loading script " + scriptName);
                            script = loadScript(scriptName, context);
                            AppDomainLoader.progress("MainWithContext: Loading completed");
                        }
                    }

                    AppDomainLoader.progress("MainWithContext: About to initialize");
                    // Attach script
                    if (script != null)
                    {
                        // Insert pre-script before the script body
                        int n = 0;
                        foreach (var list in preScript)
                            script.Items.Insert(n++, list);

                        AppDomainLoader.BaseDirectory = script.DirectoryName;

                        RequireAdminMode mode = context.Compiler.RequireAdmin;
                        if ((!context.IsAdministrator || context.GetBool(xs.testElevation, false)) && !isCodeGeneration(context) && mode!=RequireAdminMode.User)
                        {
                            return restartAsAdmin(context, args, mode==RequireAdminMode.Hidden && !(context.GetBool(xs.testElevation, false)));
                        }

                        AppDomainLoader.progress("MainWithContext: Before script initialization");
                        if (isCodeGeneration(context))
                        {
                            if (!context.EnableCodePrecompilation && (context.IsSet(xs.genexe) ||
                                                                      context.IsSet(xs.genwinexe) ||
                                                                      context.IsSet(xs.genlibrary) ||
                                                                      context.IsSet(xs.gencs)))
                                throw new ParsingException("One of the loaded scripts has precompilation disabled. Executable cannot be generated from this script.");
                            context.EnableCodePrecompilation = false;
                        }
                        ctrl.IgnoreCtrlC = script.IgnoreCtrlC;
                        ctrl.AbortDelay = Utils.ToTimeSpan(script.AbortDelay) ?? ctrl.AbortDelay;
                        ctrl.ExitDelay = Utils.ToTimeSpan(script.ExitDelay) ?? ctrl.ExitDelay;
                        context.Initialize(script);

                        AppDomainLoader.progress("MainWithContext: Script initialization completed");
                    }

                    // After precompilation we're ready to write .exe, if requested
                    if (isCodeGeneration(context))
                    {
                        doCodeGeneration(context, script);
                    }
                    else if (script != null)
                    {
                        // Run the script
                        AppDomainLoader.progress("MainWithContext: Before script execution");
                        redir = new ConsoleRedirector(context);
                        try
                        {
                            object r = context.ExecuteScript(script, filteredArgs.ToArray(), CallIsolation.High);
                            if (r != null)
                                int.TryParse(r.ToString(), out exitCode);
                        }
                        finally
                        {
                            ctrl.KillAbortTimer();
                            redir.Dispose();
                            redir = null;
                        }

                        AppDomainLoader.progress("MainWithContext: Script execution completed");
                    }
                }
                catch (ThreadAbortException ae)
                {
                    AppDomainLoader.progress("MainWithContext: ThreadAbortException is being aborted");
                    resetAbort(context);
                    context.WriteException(ae);
                    exitCode = -1;
                }
                catch(ScriptTerminateException te)
                {
                    exitCode = te.ExitCode;
                    resetAbort(context);
                    if (te.InnerException != null)
                    {
                        context.WriteException(te.InnerException);
                        AppDomainLoader.progress("MainWithContext: " + te.InnerException);
                    }
                    AppDomainLoader.progress("MainWithContext: Terminating with exit code " + exitCode);
                }
                catch (Exception e)
                {
                    exitCode = -1;
                    resetAbort(context);
                    context.WriteException(e);
                    AppDomainLoader.progress("MainWithContext: " + e);
                }
                finally
                {
                    resetAbort(context);
                    AppDomainLoader.BaseDirectory = null;
                }
            end:
                // Display how long did it take
                w.Stop();
                if (context.GetBool(xs.wait,false))
                {
                    cout.WriteLine(OutputType.Info,string.Format("Completed in {0} with exit code={1}. Press Enter to close...", w.Elapsed, exitCode));
                    Console.ReadLine();

                }
            }
            AppDomainLoader.progress("MainWithContext: Exiting with code "+exitCode);
            return exitCode;
        }