public static string CurrentWorkingDirectoryOrDefault(IProgramContext context, string defaultDirectory = "C:\\Windows\\System32")
{
if (context.CurrentProcess.ProcessName != "explorer")
{
return(defaultDirectory);
}
SHDocVw.ShellWindows shellWindows = new SHDocVw.ShellWindows();
int handle = context.WindowHandle.ToInt32();
string path = null;
foreach (SHDocVw.InternetExplorer exp in shellWindows)
{
if (handle == exp.HWND)
{
path = System.Web.HttpUtility.UrlDecode(exp.LocationURL);
if (path.StartsWith("file:///") == true)
{
path = path.Substring(8);
}
if (path.Length > 0)
{
return(path);
}
else
{
return(defaultDirectory);
}
}
}
path = Path.Combine(Environment.GetEnvironmentVariable("HOMEDRIVE") + "\\", Environment.GetEnvironmentVariable("HOMEPATH").Substring(1), "desktop");
return(path);
}
public void ShowWindow(IProgramContext context)
{
if (IsVisible == true)
{
return;
}
RECT position = context.WindowPosition;
double ttop = position.Top + 50;
double halfwidthdiff = ((position.Right - position.Left) - Width) / 2;
double tleft = position.Left + halfwidthdiff;
if (tleft < 0 && tleft + Width > 0)
{
tleft = -(Width + 50);
}
if (ttop < 50)
{
ttop = 50;
}
Left = tleft;
Top = ttop;
Show();
Activate();
textbox_input.Focus();
SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, 3);
}
public override void ThreadInitialize(SafeSharedObjects shared)
{
if (compileMode != CompileMode.FILE)
{
programContext = shared.Cpu.SwitchToProgramContext(); // only switch the context if executing
}
codeParts = new List <CodePart>();
}
public bool IsWaitingForCommand()
{
IProgramContext context = ((CPU)Shared.Cpu).GetInterpreterContext();
// If running from a boot script, there will be no interpreter instructions,
// only a single OpcodeEOF. So we check to see if the interpreter is locked,
// which is a sign that a sub-program is running.
return(!locked && context.Program[context.InstructionPointer] is OpcodeEOF);
}
/// <summary>
/// Make a new trigger for insertion into the trigger list, which is a callback from C# code.
/// </summary>
/// <param name="context">The ProgramContext under which this Trigger is meant to run.</param>
/// <param name="entryPoint">Address within the program context where the routine starts that
/// needs to be called when the trigger needs to be invoked.</param>
/// <param name="closure">If not-null, this is the closure the trigger should be called with.
/// If null, the trigger will only reliably be able to see global variables.</param>
/// <param name="args">list of the arguments to pass in to the function. Note, the existence of
/// arguments mandates that this is a callback trigger.</param>
public TriggerInfo(IProgramContext context, int entryPoint, List <VariableScope> closure, List <Structure> args)
{
EntryPoint = entryPoint;
IsCSharpCallback = true;
ReturnValue = new ScalarIntValue(0);
CallbackFinished = false;
Args = args;
ContextId = context.ContextId;
Closure = closure;
}
/// <summary>
/// Make a new UserDelegate given the current state of the CPU and its stack, and
/// the entry point location of the function to call.
/// </summary>
/// <param name="cpu">the CPU on which this program is running.</param>
/// <param name="context">The IProgramContext in which the entryPoint is stored. Entry point 27 in the interpreter is not the same as entrypoint 27 in program context.</param>
/// <param name="entryPoint">instruction address where OpcodeCall should jump to to call the function.</param>
/// <param name="useClosure">If true, then a snapshot of the current scoping stack, and thus a persistent ref to its variables,
/// will be kept in the delegate so it can be called later as a callback with closure. Set to false if the
/// function is only getting called instantly using whatever the scope is at the time of the call.</param>
public UserDelegate(ICpu cpu, IProgramContext context, int entryPoint, bool useClosure)
{
this.cpu = cpu;
ProgContext = context;
EntryPoint = entryPoint;
if (useClosure)
CaptureClosure();
else
Closure = new List<VariableScope>(); // make sure it exists as an empty list so we don't have to have 'if null' checks everwywhere.
}
/// <summary>
/// Make a new trigger for insertion into the trigger list, which is a callback from C# code.
/// </summary>
/// <param name="context">The ProgramContext under which this Trigger is meant to run.</param>
/// <param name="entryPoint">Address within the program context where the routine starts that
/// needs to be called when the trigger needs to be invoked.</param>
/// <param name="instanceCount">If you want it to be allowed to make more than one instance of
/// a trigger at this EntryPoint, then pass in a call to TriggerInfo.NextInstance here, else
/// pass in zero to mean that multiple instances from the same entry point aren't allowed.</param>
/// <param name="closure">If not-null, this is the closure the trigger should be called with.
/// If null, the trigger will only reliably be able to see global variables.</param>
/// <param name="args">list of the arguments to pass in to the function. Note, the existence of
/// arguments mandates that this is a callback trigger.</param>
public TriggerInfo(IProgramContext context, int entryPoint, InterruptPriority priority, int instanceCount, List <VariableScope> closure, List <Structure> args)
{
EntryPoint = entryPoint;
Priority = priority;
InstanceCount = instanceCount;
IsCSharpCallback = true;
ReturnValue = new ScalarIntValue(0);
CallbackFinished = false;
Args = args ?? new List <Structure>();
ContextId = context.ContextId;
Closure = closure;
}
private void OnHotKeyPressed(IHotKey sender, int hotkeyid)
{
if (window.IsVisible)
{
window.HideWindow();
return;
}
pool.EnterScope();
IProgramContext context = services.GetService <IProgramContext>();
window.ClearInput();
window.ShowWindow(context);
}
/// <summary>
/// Make a new UserDelegate given the current state of the CPU and its stack, and
/// the entry point location of the function to call.
/// </summary>
/// <param name="cpu">the CPU on which this program is running.</param>
/// <param name="context">The IProgramContext in which the entryPoint is stored. Entry point 27 in the interpreter is not the same as entrypoint 27 in program context.</param>
/// <param name="entryPoint">instruction address where OpcodeCall should jump to to call the function.</param>
/// <param name="useClosure">If true, then a snapshot of the current scoping stack, and thus a persistent ref to its variables,
/// will be kept in the delegate so it can be called later as a callback with closure. Set to false if the
/// function is only getting called instantly using whatever the scope is at the time of the call.</param>
public UserDelegate(ICpu cpu, IProgramContext context, int entryPoint, bool useClosure) :
base(cpu)
{
ProgContext = context;
EntryPoint = entryPoint;
if (useClosure)
{
CaptureClosure();
}
if (Cpu != null)
{
Cpu.AddPopContextNotifyee(this);
}
}
/// <summary>
/// Make a new UserDelegate given the current state of the CPU and its stack, and
/// the entry point location of the function to call.
/// </summary>
/// <param name="cpu">the CPU on which this program is running.</param>
/// <param name="context">The IProgramContext in which the entryPoint is stored. Entry point 27 in the interpreter is not the same as entrypoint 27 in program context.</param>
/// <param name="entryPoint">instruction address where OpcodeCall should jump to to call the function.</param>
/// <param name="useClosure">If true, then a snapshot of the current scoping stack, and thus a persistent ref to its variables,
/// will be kept in the delegate so it can be called later as a callback with closure. Set to false if the
/// function is only getting called instantly using whatever the scope is at the time of the call.</param>
public UserDelegate(ICpu cpu, IProgramContext context, int entryPoint, bool useClosure)
{
this.cpu = cpu;
ProgContext = context;
EntryPoint = entryPoint;
if (useClosure)
{
CaptureClosure();
}
else
{
Closure = new List <VariableScope>(); // make sure it exists as an empty list so we don't have to have 'if null' checks everwywhere.
}
}
public void Invoke(IProgramContext progContext, ILogger runnerLogger, bool admin = false)
{
ProcessStartInfo psi = new ProcessStartInfo(exeCommand, exeArgs);
psi.WorkingDirectory = Helper.CurrentWorkingDirectoryOrDefault(progContext);
if (admin)
{
psi.Verb = "runas";
}
try
{
Process.Start(psi);
}
catch (Exception ex)
{
runnerLogger.LogExceptionAsync(ex);
}
}
/// <summary>
/// Cleans up the references I hold (to allow GC to happen on them) because I
/// know I can never be called again at this point.
/// (Note, this is called because of Cpu.AddPopContextNotifyee()).
/// </summary>
public bool OnPopContext(IProgramContext context)
{
// Just in case we ever add more contexts later than just interpreter
// and program, we want to be sure we don't invoke the cleanup code
// unless it's *our* program context (the one this UserDelegate is from)
// that's being removed. That's the reason for these checks here:
if (weakProgContext.IsAlive)
{
if (weakProgContext.Target == context)
{
DeadCleanup();
return(false);
}
return(true); // act like this never fired off. It's not for our program context.
}
// If we already orphaned our program context for some other reason (I don't
// know what that would be), then at least clean up what's still left:
DeadCleanup();
return(false);
}
public IProgramContext CreateProgramContext(ContextFeatures contextFeatures, IProgram program, IExecutor executor)
{
if (contextFeatures == null)
{
throw new ArgumentNullException("contextFeatures");
}
if (executor == null)
{
throw new ArgumentNullException("executor");
}
IProgramContext context = (IProgramContext)_CreateContext(ContextTargetType.Program, contextFeatures);
if (context != null)
{
context.Executor = executor;
context.Program = program;
_AddContext(context);
}
return(context);
}
public Task Invoke(IQuickContext context, IProgramContext program, Func <Task> next)
{
if (!Config.EnableSearch)
{
return(next());
}
bool isChrome = program.CurrentProcess.ProcessName == "chrome";
if (isChrome)
{
string search = context.Command.Raw.Trim().ToLower();
if (search.Length <= 0)
{
return(next());
}
Regex searchReg = null;
try
{
searchReg = new Regex(search);
}
catch
{
SearchPatternErrorAction.Update("搜索模式错误", search);
context.AddAction(SearchPatternErrorAction);
}
if (searchReg != null)
{
List <Bookmark> bookmarks = new List <Bookmark>();
SearchFolder(Bookmarks.BookmarkBar, searchReg, bookmarks);
SearchFolder(Bookmarks.Others, searchReg, bookmarks);
foreach (Bookmark bookmark in bookmarks)
{
context.AddAction(new BookmarkAction(bookmark.Name, bookmark.Url));
}
}
}
return(next());
}
public void ShowWindow(IProgramContext context)
{
if (IsVisible == true)
{
return;
}
System.Windows.Forms.Screen[] screens = System.Windows.Forms.Screen.AllScreens;
List <uint> dpis = ScreenHelpers.GetScreenDpis(screens);
RECT position = context.WindowPosition;
double ttop = position.Top + 50;
double windowWidth = ActualWidth;
if (windowWidth <= 0)
{
windowWidth = Width;
}
uint scale = dpis[0] / 96;
windowWidth *= scale;
double halfwidthdiff = ((position.Right - position.Left) - windowWidth) / 2;
double tleft = position.Left + halfwidthdiff;
if (tleft < 0 && tleft + windowWidth > 0)
{
tleft = -(windowWidth + 50);
}
if (ttop < 50)
{
ttop = 50;
}
Left = tleft / scale;
Top = ttop / scale;
Show();
Activate();
textbox_input.Focus();
SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, 3);
}
public void Invoke(IProgramContext progContext, ILogger runnerLogger, ICommand command, bool admin = false, bool a = false)
{
admin = admin || a || defaultAsAdmin;
string procname = RunCommand;
if (commandPath.Length > 0)
{
procname = commandPath;
}
ProcessStartInfo psi = new ProcessStartInfo(procname);
if (arguments != null)
{
psi.Arguments = arguments;
}
if (admin)
{
psi.Verb = "runas";
}
if (workingDirectory == null)
{
psi.WorkingDirectory = Helper.CurrentWorkingDirectoryOrDefault(progContext);
}
else
{
psi.WorkingDirectory = workingDirectory;
}
try
{
Process.Start(psi);
}
catch (Exception ex)
{
runnerLogger.LogExceptionAsync(ex);
}
}
public ProgramContextEventArgs(IProgramContext programContext)
{
ProgramContext = programContext;
}
public ProgramContextEventArgs(IProgramContext programContext)
{
ProgramContext = programContext;
}
private bool ExecuteInstruction(IProgramContext context)
{
const bool DEBUG_EACH_OPCODE = false;
Opcode opcode = context.Program[context.InstructionPointer];
if (DEBUG_EACH_OPCODE)
{
executeLog.Append(String.Format("Executing Opcode {0:0000}/{1:0000} {2} {3}\n",
context.InstructionPointer, context.Program.Count, opcode.Label, opcode.ToString()));
}
try
{
opcode.AbortContext = false;
opcode.AbortProgram = false;
opcode.Execute(this);
if (opcode.AbortProgram)
{
BreakExecution(false);
SafeHouse.Logger.Log("Execution Broken");
return false;
}
else if (opcode.AbortContext)
{
return false;
}
else
{
int prevPointer = context.InstructionPointer;
context.InstructionPointer += opcode.DeltaInstructionPointer;
if (context.InstructionPointer < 0 || context.InstructionPointer >= context.Program.Count())
{
throw new KOSBadJumpException(
context.InstructionPointer, String.Format("after executing {0:0000} {1} {2}", prevPointer, opcode.Label, opcode));
}
return true;
}
}
catch (Exception)
{
// exception will skip the normal printing of the log buffer,
// so print what we have so far before throwing up the exception:
if (executeLog.Length > 0)
SafeHouse.Logger.Log(executeLog.ToString());
throw;
}
}
private bool ExecuteInstruction(IProgramContext context, bool doProfiling)
{
Opcode opcode = context.Program[context.InstructionPointer];
if (SafeHouse.Config.DebugEachOpcode)
{
executeLog.Append(string.Format("Executing Opcode {0:0000}/{1:0000} {2} {3}\n", context.InstructionPointer, context.Program.Count, opcode.Label, opcode));
executeLog.Append(string.Format("Prior to exeucting, stack looks like this:\n{0}\n", DumpStack()));
}
try
{
opcode.AbortContext = false;
opcode.AbortProgram = false;
opcode.Execute(this);
if (doProfiling)
{
// This will count *all* the time between the end of the prev instruction and now:
instructionWatch.Stop();
opcode.ProfileTicksElapsed += instructionWatch.ElapsedTicks;
opcode.ProfileExecutionCount++;
// start the *next* instruction's timer right after this instruction ended
instructionWatch.Reset();
instructionWatch.Start();
}
if (opcode.AbortProgram)
{
BreakExecution(false);
SafeHouse.Logger.Log("Execution Broken");
return false;
}
if (opcode.AbortContext)
{
return false;
}
int prevPointer = context.InstructionPointer;
context.InstructionPointer += opcode.DeltaInstructionPointer;
if (context.InstructionPointer < 0 || context.InstructionPointer >= context.Program.Count)
{
throw new KOSBadJumpException(
context.InstructionPointer, string.Format("after executing {0:0000} {1} {2}", prevPointer, opcode.Label, opcode));
}
return true;
}
catch (Exception)
{
// exception will skip the normal printing of the log buffer,
// so print what we have so far before throwing up the exception:
if (executeLog.Length > 0)
SafeHouse.Logger.Log(executeLog.ToString());
throw;
}
}
public IProgramContext RebuildContext()
{
context = services.CreateInstance <ProgramContext>();
return(context);
}
