[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 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);
}
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);
}
