/////////////////////////////////////////////////////////////////////// public static bool WriteText( IInteractiveHost interactiveHost ) { return((interactiveHost != null) ? interactiveHost.WriteLine(Text) : false); }
/////////////////////////////////////////////////////////////////////// #region Public Methods #if EAGLE public static bool WriteSummary( IInteractiveHost interactiveHost ) { return((interactiveHost != null) ? interactiveHost.WriteLine(Summary) : false); }
/////////////////////////////////////////////////////////////////////// #region Public Methods public ReturnCode ArgumentCallback( Interpreter interpreter, IInteractiveHost interactiveHost, IClientData clientData, int count, string arg, ref IList <string> argv, ref Result result ) { if (callback == null) { result = "invalid shell callback"; return(ReturnCode.Error); } return(callback.ProcessArgument( interpreter, interactiveHost, clientData, count, arg, ref argv, ref result)); }
/////////////////////////////////////////////////////////////////////// #region Application Entry Point /// <summary> /// This is the main entry point for this assembly. /// </summary> /// <param name="args"> /// The command line arguments received from the calling assembly. /// </param> /// <returns> /// Zero for success, non-zero on error. /// </returns> private static int Main( string[] args /* in */ ) { // // NOTE: The integer exit code to return to the caller (parent // process, etc). // ExitCode exitCode = Utility.SuccessExitCode(); // // NOTE: Save the command line arguments for use by the // interpreter via the linked variable (optional). // mainArgs = args; // // NOTE: The "interpreter result" that is passed to various // methods. // Result result = null; // // NOTE: First, we create a new interpreter (with the default // options). // using (Interpreter interpreter = Interpreter.Create( args, ref result)) { if (interpreter != null) { ReturnCode code = interpreter.SetVariableLink( VariableFlags.None, fieldName, typeof(Program). GetField(fieldName), null, ref result); if (code != ReturnCode.Ok) { // // NOTE: Handle variable linking error. // exitCode = Utility.ReturnCodeToExitCode(code); } // // NOTE: Create an instance of the example custom command. // Class0 class0 = new Class0(new CommandData("class0", null, null, ClientData.Empty, typeof(Class0).FullName, CommandFlags.None, null, 0)); // // NOTE: The token that will represent the custom command // we add. // long commandToken = 0; // // NOTE: Next, we can optionally add one or more custom // commands. // if (code == ReturnCode.Ok) { code = interpreter.AddCommand( class0, null, ref commandToken, ref result); } // // NOTE: The token that will represent the custom command // policy we add. // long policyToken = 0; // // NOTE: Next, add our custom command execution policy (for // use in "safe" mode). // if (code == ReturnCode.Ok) { code = interpreter.AddPolicy( Class0PolicyCallback, null, null, ref policyToken, ref result); } // // NOTE: The error line number that is passed to various // script evaluation methods. // int errorLine = 0; // // NOTE: Check for a successful return code. // if (code == ReturnCode.Ok) // OR: Utility.IsSuccess(code, true) { #if SHELL result = null; code = Interpreter.InteractiveLoop( interpreter, args, ref result); #else // // NOTE: Next, evaluate one or more scripts of your // choosing (which may or may not reference any // custom commands you may have added in the // previous step). // code = Engine.EvaluateScript( interpreter, "class0 test; # <-- script text", ref result, ref errorLine); #endif // // NOTE: Check for an unsuccessful return code. // if (code != ReturnCode.Ok) // OR: !Utility.IsSuccess(code, true) { // // NOTE: Handle script error. // exitCode = Utility.ReturnCodeToExitCode(code); } // // NOTE: Next, we can optionally remove one or more of // the custom command policies we added earlier. // code = interpreter.RemovePolicy(policyToken, null, ref result); // // NOTE: Check for an unsuccessful return code. // if (code != ReturnCode.Ok) { // // NOTE: Handle policy removal error. // exitCode = Utility.ReturnCodeToExitCode(code); } // // NOTE: Next, we can optionally remove one or more of // the custom commands we added earlier. // code = interpreter.RemoveCommand(commandToken, null, ref result); // // NOTE: Check for an unsuccessful return code. // if (code != ReturnCode.Ok) { // // NOTE: Handle command removal error. // exitCode = Utility.ReturnCodeToExitCode(code); } code = interpreter.UnsetVariable(VariableFlags.None, fieldName, ref result); if (code != ReturnCode.Ok) { // // NOTE: Handle variable unlinking error. // exitCode = Utility.ReturnCodeToExitCode(code); } } else { // // NOTE: Handle failure to add the custom command // or policy. // exitCode = Utility.ReturnCodeToExitCode(code); } // // NOTE: Always check for a valid interpreter hosting // environment before using it as it is not // guaranteed to always be available. // IInteractiveHost interactiveHost = interpreter.Host; if (interactiveHost != null) { interactiveHost.WriteResultLine( code, result, errorLine); } else { Console.WriteLine(Utility.FormatResult( code, result, errorLine)); } } else { // // NOTE: Creation of the interpreter failed. // Console.WriteLine(Utility.FormatResult( ReturnCode.Error, result)); exitCode = Utility.FailureExitCode(); } } return((int)exitCode); }
[STAThread()] /* WinForms */ private static int Main(string[] args) { ReturnCode code; Result result = null; using (interpreter = Interpreter.Create( args, CreateFlags.ShellUse, ref result)) { if (interpreter != null) { code = interpreter.Initialize(false, ref result); if (code == ReturnCode.Ok) { Assembly assembly = Assembly.GetExecutingAssembly(); AssemblyName assemblyName = assembly.GetName(); string fileName = assembly.Location; string typeName = typeof(_Plugins.Toolkit).FullName; Uri uri = Utility.GetAssemblyUri(assembly); IPlugin plugin = new _Plugins.Toolkit(new PluginData( Utility.FormatPluginName(assemblyName.FullName, typeName), null, null, ClientData.Empty, PluginFlags.None, assemblyName.Version, uri, interpreter.GetAppDomain(), assembly, assemblyName, fileName, typeName, null, null, null, null, null, null, null, null, 0)); code = Utility.PrepareStaticPlugin(plugin, ref result); if (code == ReturnCode.Ok) { code = interpreter.AddPlugin(plugin, null, ref toolkitPluginToken, ref result); } } if (code == ReturnCode.Ok) { Thread thread = Engine.CreateThread( interpreter, InteractiveLoopThreadStart, 0, true, false); if (thread != null) { thread.Name = String.Format( "interactiveLoopThread: {0}", interpreter); thread.Start(args); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Toplevel toplevel = new Toplevel(interpreter, "."); Application.Run(toplevel); if (thread != null) { thread.Join(); } exitCode = interpreter.ExitCode; } else { result = "could not create interactive loop thread"; code = ReturnCode.Error; } } if (code != ReturnCode.Ok) { IInteractiveHost interactiveHost = interpreter.Host; if (interactiveHost != null) { interactiveHost.WriteResultLine( code, result, interpreter.ErrorLine); } exitCode = Utility.ReturnCodeToExitCode(code, true); } } else { #if CONSOLE // // NOTE: Creation of the interpreter failed. // Console.WriteLine(Utility.FormatResult( ReturnCode.Error, result)); #endif exitCode = Utility.FailureExitCode(); } } return((int)exitCode); }
/////////////////////////////////////////////////////////////////////// #region INotify Members (Required) /// <summary> /// Receives notifications when an event occurs that the plugin has /// declared it wants to be notified about. /// </summary> /// <param name="interpreter"> /// The interpreter context we are executing in. /// </param> /// <param name="eventArgs"> /// Contains data related to the event. The exact data depends on the /// type of event being processed. /// </param> /// <param name="clientData"> /// The extra data supplied for this event, if any. /// </param> /// <param name="result"> /// Upon success, this may contain an informational message. /// Upon failure, this must contain an appropriate error message. /// </param> /// <returns> /// ReturnCode.Ok on success, ReturnCode.Error on failure. /// </returns> public override ReturnCode Notify( Interpreter interpreter, /* in */ IScriptEventArgs eventArgs, /* in */ IClientData clientData, /* in */ ArgumentList arguments, /* in */ ref Result result /* out */ ) { ReturnCode code = ReturnCode.Ok; // // NOTE: If there is no data associated with this event, just // return. We do not know how to handle these types of // events and nothing else should be done. The best advice // when implementing this interface is "when in doubt, just // do nothing". // if (eventArgs == null) { return(code); } // // NOTE: Make sure that notification matches the types and flags // that we care about. In theory, this should be handled // by the core library before we get called; however, it // cannot really hurt to double check. // if (!Utility.HasFlags( eventArgs.NotifyTypes, NotifyType.Script, true) || !Utility.HasFlags( eventArgs.NotifyFlags, NotifyFlags.Completed, true)) { return(code); } #if false // // NOTE: This is the interpreter involved in the event, which may // be different from the interpreter context we are executing // in. This example does not make use of this interpreter; // therefore, this code block is commented out. // /* NOT USED */ Interpreter eventInterpreter = eventArgs.Interpreter; if (eventInterpreter == null) { return(code); } #endif // // NOTE: Grab the extra data associated with this "event" now. The // exact contents will vary depending on the event type being // serviced. The source code associated with the event type // in question should be consulted to determine the necessary // type conversion(s). // IClientData eventClientData = eventArgs.ClientData; if (eventClientData == null) { return(code); } // // NOTE: In this case, the data associated with the event is an // "object list". If the data does not conform to that type, // bail out now. // IList <object> list = eventClientData.Data as IList <object>; if (list == null) { return(code); } // // NOTE: Attempt to fetch the text of the script that was just // completed. // string text; try { // // NOTE: The third element should contain the full text of the // completed script. // text = list[2] as string; if (text != null) { // // NOTE: The third and fourth elements should contain the // offset and number of characters for the completed // script, respectively. // text = text.Substring((int)list[3], (int)list[4]); } } catch { // // NOTE: Somehow, the data does not conform to expectations for // this event type. Gracefully ignore it. // text = null; } // // NOTE: To display the text of the completed script, both the // interpreter and the text itself is required. // if ((interpreter != null) && (text != null)) { // // NOTE: Grab the host from the interpreter context we are // executing in. // IInteractiveHost interactiveHost = interpreter.Host; if (interactiveHost != null) { // // NOTE: Emit a message to the interpreter host that // includes the full text of the completed script. // interactiveHost.WriteLine(String.Format( "{0}: script completed{1}{2}", GetType().FullName, Environment.NewLine, text)); } } return(code); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count == 2) { if (!interpreter.HasNoBackgroundError()) { IInteractiveHost interactiveHost = interpreter.Host; if (interactiveHost != null) { string message = arguments[1]; message = !String.IsNullOrEmpty(message) ? String.Format("{0}: {1}", this.Name, message) : this.Name; interactiveHost.WriteResultLine(ReturnCode.Error, message, Interpreter.GetErrorLine(interpreter)); result = String.Empty; } else { result = "interpreter host not available"; code = ReturnCode.Error; } } else { result = "background error handling disabled"; code = ReturnCode.Error; } } else { result = "wrong # args: should be \"bgerror message\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
public static ReturnCode PolicyCallback( /* POLICY */ Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { IPolicyContext policyContext = null; bool match = false; if (Utility.ExtractPolicyContextAndCommand( interpreter, clientData, null, 0, ref policyContext, ref match, ref result) == ReturnCode.Ok) { if (match) { // // NOTE: Fetch the reference to the Cmdlet itself that we // smuggled in via the named opaque object handle // that was prearranged with the base cmdlet itself. // _Cmdlets.Script script = null; if (GetCmdlet(interpreter, ref script, ref result) == ReturnCode.Ok) { // // NOTE: Grab the interpreter host, if any. // IInteractiveHost interactiveHost = interpreter.Host; // // NOTE: If the interpreter host is available, use the // title as the caption; otherwise, we will use // the hard-coded default. // string processCaption = (interactiveHost != null) ? interactiveHost.Title : null; // // NOTE: If the caption is null or empty, use the // hard-coded default. // if (String.IsNullOrEmpty(processCaption)) { processCaption = _Constants.Policy.ProcessCaption; } // // NOTE: Build the description of the operation for // "What-If" and "Verbose" modes. // string verboseDescription = String.Format( _Constants.Policy.VerboseDescription, arguments); // // NOTE: Grab the command name from the argument list // because we need to present it to the user in // the confirmation query. // string commandName = (arguments.Count > 0) ? arguments[0] : null; // // NOTE: Build the confirmation query to present to // the user. // string verboseWarning = String.Format( _Constants.Policy.VerboseWarning, commandName, arguments); // // TODO: *TEST* Verify that this works correctly and // has the expected semantics. // if (ShouldProcess(script, verboseDescription, verboseWarning, processCaption)) { // // NOTE: If the interpreter host is available, use // the title as the caption; otherwise, we // will use the hard-coded default. // string continueCaption = (interactiveHost != null) ? interactiveHost.Title : null; // // NOTE: If the caption is null or empty, use the // hard-coded default. // if (String.IsNullOrEmpty(continueCaption)) { continueCaption = _Constants.Policy.ContinueCaption; } // // NOTE: Build the re-confirmation query to present // to the user. // string query = String.Format( _Constants.Policy.Query, verboseWarning); // // NOTE: If we are in "force" mode or the user // allows us to continue then do so; // otherwise, do nothing and the command will // be allowed/denied based on the other // policies, if any. In the event that there // are no other policies present, the command // will not be allowed to execute. // // BUGFIX: Cannot ask user when not interactive. // if (script.Force || ShouldContinue(script, query, continueCaption, ref yesToAll, ref noToAll)) { // // NOTE: The user has explicitly approved the // command execution. // policyContext.Approved(); } else if (script.Deny) { // // BUGFIX: Must explicitly deny to override the // built-in policies (e.g. for [info], // [object], etc). // policyContext.Denied(); } } else if (script.Deny) { // // BUGFIX: Must explicitly deny to override the // built-in policies (e.g. for [info], // [object], etc). // policyContext.Denied(); } // // NOTE: The policy checking has been successful; // however, this does not necessarily mean // that we allow the command to be executed. // return(ReturnCode.Ok); } } else { result = "policyContext does not contain a command object"; } } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// public static HeaderFlags GetHeaderFlags( IInteractiveHost interactiveHost, HeaderFlags headerFlags, bool debug, bool show, bool empty, bool @default ) { // // NOTE: If we are in debug mode and no header display flags have // been explicitly set for the interpreter, initialize them // to the default value. // if (@default && FlagOps.HasFlags( headerFlags, HeaderFlags.Invalid, true)) { // // NOTE: Remove the "these flags have not been setup before" // indicator flag. // headerFlags &= ~HeaderFlags.Invalid; // // NOTE: Add the default header flags for the interactive // host. If the interactive host is not available, // fallback on the system default header flags. // HeaderFlags defaultHeaderFlags = HeaderFlags.Default; if (interactiveHost != null) { headerFlags |= HostOps.GetHeaderFlags( interactiveHost, defaultHeaderFlags); } else { headerFlags |= defaultHeaderFlags; } } // // NOTE: Only modify (set or unset) the active debugger flag if we // have been told to do so; otherwise, the active debugger // flag may have been manually changed and should be left // alone. // if (show) { // // NOTE: Is there an active debugger? // if (debug) { // // NOTE: Set the active debugger flag. // headerFlags |= HeaderFlags.Debug; } else { // // NOTE: Unset the active debugger flag. // headerFlags &= ~HeaderFlags.Debug; } } // // NOTE: Show empty content? // if (empty) { headerFlags |= HeaderFlags.EmptyContent; } return(headerFlags); }