public void Initialize(StepDirection direction = StepDirection.Clockwise, StepMode stepMode = StepMode.Full, bool isEnabled = true)
{
Direction = direction;
IsEnabled = isEnabled;
Mode = stepMode;
//StepperMotor = stepperMotor;
}
public StepMode SetMode(StepMode stepMode)
{
var old = _stepMode;
_stepMode = stepMode;
return(old);
}
/// <summary>
/// Creates a new instance of <see cref="IntegerStepsAttribute"/>
/// </summary>
public IntegerStepsAttribute(int min, int max, int step, StepMode mode)
{
_min = min;
_max = max;
_step = step;
_mode = mode;
}
public void Import(string codename)
{
var sitedb = this.RenderContext.WebSite.SiteDb();
var code = sitedb.Code.Get(codename);
if (code != null)
{
Guid? currentCodeId = null;
StepMode currentStepMode = StepMode.None;
var debugsession = Kooboo.Sites.ScriptDebugger.SessionManager.GetSession(RenderContext, DebugSession.GetWay.CurrentContext);
var debugMode = debugsession != null;
if (debugMode)
{
currentCodeId = debugsession.CurrentCodeId;
var step = debugsession.StepMode == StepMode.Into ? StepMode.Into : StepMode.None;
currentStepMode = debugsession.JsEngine.SetDebugHandlerMode(step);
}
var result = Manager.ExecuteCode(this.RenderContext, code.Body, code.Id);
if (result != null)
{
Response.write(result);
}
if (debugMode)
{
debugsession.JsEngine.SetDebugHandlerMode(currentStepMode);
Manager.ExchangeDebugInfo(currentCodeId.GetValueOrDefault(), debugsession, debugsession.JsEngine);
}
}
}
public DebugHandler(Engine engine)
{
_engine = engine;
_debugCallStack = new Stack <string>();
// _stepMode = StepMode.Into;
// edit Guoqi
_stepMode = StepMode.None;
}
private StepMode Interpreter_Step(object sender, DebugInformation e)
{
// Check if on GL Thread - we don't want to block it.
if (GLThread.IsGLThread())
{
_currentScriptExec = "Found script, but it was on the GL Thread where it can't be debugged.";
return(StepMode.None);
}
// If this errors it will break the script, that's why it should be in a try-catch.
try
{
// Get the source and write it down.
string sourceFull = e.CurrentStatement.Location.Source;
if (string.IsNullOrEmpty(sourceFull))
{
_currentScriptExec = "Unknown Script Source";
}
else
{
_currentScriptExec = sourceFull;
_currentStatement = sourceFull.Substring(e.CurrentStatement.Range[0], e.CurrentStatement.Range[1] - e.CurrentStatement.Range[0]);
}
_canStepInto = true;
if (e.CallStack.Count > 0)
{
_canStepOut = true;
}
bool wait = true;
StepMode exit = StepMode.None;
_stepFunction = mode =>
{
exit = mode;
wait = false;
};
while (wait)
{
if (!Open)
{
return(StepMode.Into);
}
Engine.ScriptingEngine.Interpreter.ResetTimeoutTicks();
}
_canStepInto = false;
_canStepOut = false;
return(exit);
}
catch (Exception ex)
{
Engine.Log.Warning($"Rationale script debugger encountered an error: {ex}", MessageSource.Other);
return(StepMode.Into);
}
}
public StepFrame(Language language, StepMode mode, StackFrame stack,
TargetAddress start, TargetAddress end)
{
this.start = start;
this.end = end;
this.stack = stack;
this.language = language;
this.mode = mode;
}
public StepFrame(Language language, StepMode mode, StackFrame stack,
TargetAddress start, TargetAddress end)
{
this.start = start;
this.end = end;
this.stack = stack;
this.language = language;
this.mode = mode;
}
private bool Continue(string args)
{
// Note that in some cases (and maybe eventually in this case), we may want to set StepMode.Into here, and
// keep track of "running" vs "stepping" ourselves. This in order to be called regularly, and give the user
// a chance to interactively pause the script when it's running.
// For now, however, we stick with StepMode.None.
stepMode = StepMode.None;
return(true);
}
/// <summary>
/// Runs the script without stepping.
/// </summary>
public void Run()
{
// We can't use StepMode.None here. We want to be able to pause again manually (see Stop), but
// StepMode.None will stop the engine sending Step events at all, meaning we also can't
// change the StepMode later (except if we hit a Break event).
// So, instead we simply set a flag and check it in the Step event
noStepping = true;
nextStep = StepMode.Into;
waitForInterface.Set();
}
public void StepOut()
{
if (IsRunning == true)
{
_stepMode = StepMode.Out;
_breakType = BreakType.Break;
BreakOnNextStatement = false;
_event.Set();
}
}
private void Continue(StepMode stepMode)
{
DebugInformation = null;
IsRunning = true;
var continuation = _continuation;
_continuation = null;
continuation.Signal(stepMode);
}
public void StepOver()
{
if (IsRunning == true)
{
_stepMode = StepMode.Over;
_breakType = BreakType.Step;
BreakOnNextStatement = true;
_event.Set();
}
}
/*******************************************************************************************/
/*******************************************************************************************/
public void CreateTreeInStepMode(List <int> keysToBuld, List <int> keysToCheck, TreeType treeType)
{
Tree tree = GetTree(treeType);
StepMode stepMode = StepMode.GetInstance();
stepMode.PrepareStepsForAddNodes(tree, keysToBuld);
TriggerStepModeActions(stepMode.StepForward, tree, stepMode.Steps.Count + 10);
CheckNode(tree.Root, keysToCheck);
}
public static ClusterConfig GetCompatibility(StepMode stepMode, int delayTime, bool useBrake)
{
if (delayTime < 200 || delayTime > 10000)
throw new ArgumentOutOfRangeException("delayTime");
ClusterConfig config = GetDefault();
config.StepMode = stepMode;
config.TickTime = (uint)delayTime;
config.BrakeMode = useBrake ? BrakeMode.Always : BrakeMode.None;
return config;
}
/*******************************************************************************************/
/*******************************************************************************************/
public void CreateTreeInStepModeBackAndPartial(List <int> keysToBuld, List <int> keysToCheck, int finalStep,
TreeType treeType, int firstIter = 10, int secondIter = 20)
{
Tree tree = GetTree(treeType);
StepMode stepMode = StepMode.GetInstance();
stepMode.PrepareStepsForAddNodes(tree, keysToBuld);
TriggerStepModeActions(stepMode.StepForward, tree, stepMode.Steps.Count + firstIter);
TriggerStepModeActions(stepMode.StepBackward, tree, stepMode.Steps.Count + secondIter);
TriggerStepModeActions(stepMode.StepForward, tree, finalStep);
CheckNode(tree.Root, keysToCheck);
}
internal void OnStep(Statement statement)
{
var old = _stepMode;
if (statement == null)
{
return;
}
BreakPoint breakpoint = _engine.BreakPoints.FirstOrDefault(breakPoint => BpTest(statement, breakPoint));
bool breakpointFound = false;
if (breakpoint != null)
{
DebugInformation info = CreateDebugInformation(statement);
var result = _engine.InvokeBreakEvent(info);
if (result.HasValue)
{
_stepMode = result.Value;
breakpointFound = true;
}
}
if (breakpointFound == false && _stepMode == StepMode.Into)
{
DebugInformation info = CreateDebugInformation(statement);
var result = _engine.InvokeStepEvent(info);
if (result.HasValue)
{
_stepMode = result.Value;
}
}
//add StepMode.None to fix line 22 changed on this document
if ((old == StepMode.Into || old == StepMode.None) && _stepMode == StepMode.Out)
{
_callBackStepOverDepth = _debugCallStack.Count;
}
else if ((old == StepMode.Into || old == StepMode.None) && _stepMode == StepMode.Over)
{
var expressionStatement = statement as ExpressionStatement;
if (expressionStatement != null && expressionStatement.Expression is CallExpression)
{
_callBackStepOverDepth = _debugCallStack.Count;
}
else
{
_stepMode = StepMode.Into;
}
}
}
/*******************************************************************************************/
/*******************************************************************************************/
public void AddNodesInStepModeAndBack(List <int> keysToBuld, List <int> keysToAdd, List <int> keysToCheck,
int finalStep, TreeType treeType)
{
Tree tree = GetTree(treeType);
tree.CreateNodes(keysToBuld);
StepMode stepMode = StepMode.GetInstance();
stepMode.PrepareStepsForAddNodes(tree, keysToAdd);
TriggerStepModeActions(stepMode.StepForward, tree, stepMode.Steps.Count + 100);
TriggerStepModeActions(stepMode.StepBackward, tree, stepMode.Steps.Count + 200);
TriggerStepModeActions(stepMode.StepForward, tree, finalStep);
CheckNode(tree.Root, keysToCheck);
}
/// <inheritdoc />
public bool Equals([AllowNull] Button other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Visible == other.Visible ||
Visible != null &&
Visible.Equals(other.Visible)
) &&
(
Step == other.Step ||
Step != null &&
Step.Equals(other.Step)
) &&
(
StepMode == other.StepMode ||
StepMode != null &&
StepMode.Equals(other.StepMode)
) &&
(
Count == other.Count ||
Count != null &&
Count.Equals(other.Count)
) &&
(
Label == other.Label ||
Label != null &&
Label.Equals(other.Label)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
TemplateItemName == other.TemplateItemName ||
TemplateItemName != null &&
TemplateItemName.Equals(other.TemplateItemName)
));
}
public void ShouldExecuteStepByStep()
{
countBreak = 0;
stepMode = StepMode.Into;
var engine = new Engine(options => options.DebugMode());
engine.Step += EngineStep;
engine.Execute(@"var local = true;
var creatingSomeOtherLine = 0;
var lastOneIPromise = true");
engine.Step -= EngineStep;
Assert.Equal(3, countBreak);
}
internal void PopDebugCallStack()
{
if (_debugCallStack.Count > 0)
{
_debugCallStack.Pop();
}
if (_stepMode == StepMode.Out && _debugCallStack.Count < _callBackStepOverDepth)
{
_callBackStepOverDepth = _debugCallStack.Count;
_stepMode = StepMode.Into;
}
else if (_stepMode == StepMode.Over && _debugCallStack.Count == _callBackStepOverDepth)
{
_callBackStepOverDepth = _debugCallStack.Count;
_stepMode = StepMode.Into;
}
}
public void ShouldNotBreakTwiceIfSteppingOverBreakpoint()
{
countBreak = 0;
stepMode = StepMode.Into;
var engine = new Engine(options => options.DebugMode());
engine.BreakPoints.Add(new BreakPoint(1, 1));
engine.Step += EngineStep;
engine.Break += EngineStep;
engine.Execute(@"var local = true;");
engine.Step -= EngineStep;
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
if (Visible != null)
{
hashCode = hashCode * 59 + Visible.GetHashCode();
}
if (Step != null)
{
hashCode = hashCode * 59 + Step.GetHashCode();
}
if (StepMode != null)
{
hashCode = hashCode * 59 + StepMode.GetHashCode();
}
if (Count != null)
{
hashCode = hashCode * 59 + Count.GetHashCode();
}
if (Label != null)
{
hashCode = hashCode * 59 + Label.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (TemplateItemName != null)
{
hashCode = hashCode * 59 + TemplateItemName.GetHashCode();
}
return(hashCode);
}
}
public void ShouldBreakWhenBreakpointIsReached()
{
countBreak = 0;
stepMode = StepMode.None;
var engine = new Engine(options => options.DebugMode());
engine.Break += EngineStep;
engine.BreakPoints.Add(new BreakPoint(1, 1));
engine.Execute(@"var local = true;
if (local === true)
{}");
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
public void ShouldStepAllStatementsWithoutInvocationsIfStepOver()
{
countBreak = 0;
var engine = new Engine(options => options.DebugMode());
stepMode = StepMode.Over;
engine.Step += EngineStep;
engine.Execute(@"var step1 = 1; // first step
var step2 = 2; // second step
if (step1 !== step2) // third step
{ // fourth step
; // fifth step
}");
engine.Step -= EngineStep;
Assert.Equal(5, countBreak);
}
public void ShouldNotStepInsideIfRequiredToStepOver()
{
countBreak = 0;
var engine = new Engine(options => options.DebugMode());
stepMode = StepMode.Over;
engine.Step += EngineStep;
engine.Execute(@"function func() // first step
{
; // third step - it shall not step here
; // it shall not step here
}
func(); // second step
; // third step ");
engine.Step -= EngineStep;
Assert.Equal(3, countBreak);
}
public void ShouldNotStepInSameLevelStatementsWhenStepOut()
{
countBreak = 0;
stepMode = StepMode.Out;
var engine = new Engine(options => options.DebugMode());
engine.Step += EngineStep;
engine.Execute(@"function func() // first step - then stepping out
{
; // shall not step
; // not even here
}
func(); // shall not step
; // shall not step ");
engine.Step -= EngineStep;
Assert.Equal(1, countBreak);
}
static async void ProcessInput()
{
await Task.Run(() => {
while (true)
{
ConsoleKeyInfo keyPressed = Console.ReadKey(false);
if (keyPressed.KeyChar == 's' && stepMode == StepMode.STEP)
{
doStep = true;
}
if (keyPressed.KeyChar == 'p')
{
stepMode = StepMode.STEP;
}
if (keyPressed.KeyChar == 'r')
{
stepMode = StepMode.RUN;
}
}
});
}
private void tsoNormalMode_Click(object sender, EventArgs e)
{
_stepmode = StepMode.Normal;
setSMode();
setNormalButton();
}
internal void OnStep(Statement statement)
{
var old = _stepMode;
if (statement == null)
{
return;
}
BreakPoint breakpoint = _engine.BreakPoints.FirstOrDefault(breakPoint => BpTest(statement, breakPoint));
bool breakpointFound = false;
if (breakpoint != null)
{
DebugInformation info = CreateDebugInformation(statement);
var result = _engine.InvokeBreakEvent(info);
if (result.HasValue)
{
_stepMode = result.Value;
breakpointFound = true;
}
}
if (breakpointFound == false && _stepMode == StepMode.Into)
{
DebugInformation info = CreateDebugInformation(statement);
var result = _engine.InvokeStepEvent(info);
if (result.HasValue)
{
_stepMode = result.Value;
}
}
if (old == StepMode.Into && _stepMode == StepMode.Out)
{
_callBackStepOverDepth = _debugCallStack.Count;
}
else if (old == StepMode.Into && _stepMode == StepMode.Over)
{
var expressionStatement = statement as ExpressionStatement;
if (expressionStatement != null && expressionStatement.Expression is CallExpression)
{
_callBackStepOverDepth = _debugCallStack.Count;
}
else
{
_stepMode = StepMode.Into;
}
}
}
public OperationStep(SingleSteppingEngine sse, StepMode mode, StepFrame frame, CommandResult result)
: base(sse, result)
{
this.StepFrame = frame;
this.StepMode = mode;
}
public void ShouldNotStepInSameLevelStatementsWhenStepOut()
{
countBreak = 0;
stepMode = StepMode.Out;
var engine = new Engine(options => options.DebugMode());
engine.Step += EngineStep;
engine.Execute(@"function func() // first step - then stepping out
{
; // shall not step
; // not even here
}
func(); // shall not step
; // shall not step ");
engine.Step -= EngineStep;
Assert.Equal(1, countBreak);
}
public void ShouldShowProperDebugInformation()
{
countBreak = 0;
stepMode = StepMode.None;
var engine = new Engine(options => options.DebugMode());
engine.BreakPoints.Add(new BreakPoint(5, 0));
engine.Break += EngineStepVerifyDebugInfo;
engine.Execute(@"var global = true;
function func1()
{
var local = false;
;
}
func1();");
engine.Break -= EngineStepVerifyDebugInfo;
Assert.Equal(1, countBreak);
}
internal override ThreadCommandResult Old_Step(StepMode mode, StepFrame frame)
{
ThreadCommandResult result = new ThreadCommandResult (thread);
StartOperation (new OperationStep (this, mode, frame, result));
return result;
}
public StepRequest(DalvikThread thread, Jdwp.StepDepth stepDepth, StepMode stepMode = StepMode.Line)
{
Thread = thread;
StepDepth = stepDepth;
StepMode = stepMode;
}
private void ClearWorkSpace()
{
_counter = 0;
_hcounter = -1;
_sequence = 1;
_prev = new Paragraph();
_main = new Paragraph();
_next = new Paragraph();
_stepmode = (StepMode)Properties.Settings.Default.smode;
_forward = null;
switch (_stepmode)
{
case StepMode.Danger:
setDangerButton();
break;
case StepMode.Incomplete:
setIncompleteButton();
break;
case StepMode.Normal:
default:
setNormalButton();
break;
}
}
public DebugHandler(Engine engine)
{
_engine = engine;
_debugCallStack = new Stack<string>();
_stepMode = StepMode.Into;
}
public void ShouldBreakWhenBreakpointIsReached()
{
countBreak = 0;
stepMode = StepMode.None;
var engine = new Engine(options => options.DebugMode());
engine.Break += EngineStep;
engine.BreakPoints.Add(new BreakPoint(1, 1));
engine.Execute(@"var local = true;
if (local === true)
{}");
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
public void ShouldExecuteStepByStep()
{
countBreak = 0;
stepMode = StepMode.Into;
var engine = new Engine(options => options.DebugMode());
engine.Step += EngineStep;
engine.Execute(@"var local = true;
var creatingSomeOtherLine = 0;
var lastOneIPromise = true");
engine.Step -= EngineStep;
Assert.Equal(3, countBreak);
}
// <summary>
// Create a step frame for a native stepping operation.
// </summary>
StepFrame CreateStepFrame(StepMode mode)
{
check_inferior ();
Language language = (current_method != null) ?
current_method.Module.Language : null;
return new StepFrame (language, mode);
}
public void ShouldBreakWhenStatementIsMultiLine()
{
countBreak = 0;
stepMode = StepMode.None;
var engine = new Engine(options => options.DebugMode());
engine.BreakPoints.Add(new BreakPoint(4, 33));
engine.Break += EngineStep;
engine.Execute(@"var global = true;
function func1()
{
var local =
false;
}
func1();");
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
public StepFrame(Language language, StepMode mode, TargetAddress until)
: this(language, mode, null, TargetAddress.Null, until)
{
}
public override CommandResult Step(ThreadingModel model, StepMode mode, StepFrame frame)
{
StartOperation ();
return (CommandResult) SendCommand (delegate {
Report.Debug (DebugFlags.SSE, "{0} step: {1} {2} {3}", this, model, mode, frame);
CommandResult result = process.Debugger.StartOperation (model, this);
return ProcessOperation (new OperationStep (this, mode, frame, result));
});
}
private void tsoIncompleteMode_Click(object sender, EventArgs e)
{
_stepmode = StepMode.Incomplete;
setSMode();
setIncompleteButton();
}
private void tsoDangerMode_Click(object sender, EventArgs e)
{
_stepmode = StepMode.Danger;
setSMode();
setDangerButton();
}
public void ShouldNotBreakTwiceIfSteppingOverBreakpoint()
{
countBreak = 0;
stepMode = StepMode.Into;
var engine = new Engine(options => options.DebugMode());
engine.BreakPoints.Add(new BreakPoint(1, 1));
engine.Step += EngineStep;
engine.Break += EngineStep;
engine.Execute(@"var local = true;");
engine.Step -= EngineStep;
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
private void tsoShuffle_Click(object sender, EventArgs e)
{
_stepmode = StepMode.Shuffle;
setSMode();
setShuffleButton();
}
public void ShouldNotStepInsideIfRequiredToStepOver()
{
countBreak = 0;
var engine = new Engine(options => options.DebugMode());
stepMode = StepMode.Over;
engine.Step += EngineStep;
engine.Execute(@"function func() // first step
{
; // third step - it shall not step here
; // it shall not step here
}
func(); // second step
; // third step ");
engine.Step -= EngineStep;
Assert.Equal(3, countBreak);
}
public CommandResult Step(ThreadingModel model, StepMode mode, StepFrame frame)
{
lock (this) {
check_alive ();
return servant.Step (model, mode, frame);
}
}
public void ShouldStepAllStatementsWithoutInvocationsIfStepOver()
{
countBreak = 0;
var engine = new Engine(options => options.DebugMode());
stepMode = StepMode.Over;
engine.Step += EngineStep;
engine.Execute(@"var step1 = 1; // first step
var step2 = 2; // second step
if (step1 !== step2) // third step
{ // fourth step
; // fifth step
}");
engine.Step -= EngineStep;
Assert.Equal(5, countBreak);
}
ThreadCommandResult Old_Step(StepMode mode)
{
return Old_Step (mode, null);
}
public void ShouldBreakWhenConditionIsMatched()
{
countBreak = 0;
stepMode = StepMode.None;
var engine = new Engine(options => options.DebugMode());
engine.Break += EngineStep;
engine.BreakPoints.Add(new BreakPoint(5, 16, "condition === true"));
engine.BreakPoints.Add(new BreakPoint(6, 16, "condition === false"));
engine.Execute(@"var local = true;
var condition = true;
if (local === true)
{
;
;
}");
engine.Break -= EngineStep;
Assert.Equal(1, countBreak);
}
ThreadCommandResult Old_Step(StepMode mode, StepFrame frame)
{
lock (this) {
check_alive ();
return servant.Old_Step (mode, frame);
}
}
// Simple function to set the current DLA cluster growth method
public void SetMode(StepMode set_mode)
{
step_method = set_mode;
}
internal override ThreadCommandResult Old_Step(StepMode mode, StepFrame frame)
{
throw new InvalidOperationException ();
}
