Pause execution or sleep/wait

[juanpaexpedite]

I am new using Jint, so might be there is an standard way to do the following without having issues with the performance.

I am using the following in a UWP app.

To explain what I'm trying to achieve, I have made a test using LUA interpreter and the trick for LUA is calling a C# class to delay and stopping the 'coroutine', then after an await I call to resume and the script continues.

Basically the following:

  public async void Wait(int j)
    {
        await Task.Delay(500);
        coroutines[j].Coroutine.Resume();

    }

    private void MainPage_Loaded(object sender, RoutedEventArgs e)
    {
        ScriptBox.Text =

        @"
        return function(j)
        for i=10,20 do 
        paint(i*2) 
        wait(j);
        coroutine.yield()
        end
        end";
    }

Now I am trying to do the same with Jint, because I prefer all its functionality.

1.- Is there a way to pause the processing?
2.- Any async/await jint functionality?

The following is what I've tried:

 private void MainPage_Loaded(object sender, RoutedEventArgs e)
    {
        ScriptBox.Text = @"
        function hello() 
        { 
            for (i = 10; i < 20; i++) 
             {    paint(i*2);
                  wait();
              }
           }";
         }

    public bool Wait()
    {
        Task.Delay(500).Wait();
        return true;
    }
    int k = 0;
    private async void RunScript_Click(object sender, RoutedEventArgs e)
    {
        k++;
        ScriptsBlock.Text = $"Scripts {k}";
        var script = ScriptBox.Text;

        await Task.Run(() =>
        {
            var engine = new Engine(cfg => cfg.DebugMode(false));

            engine.SetValue("paint", new Action<double>(AddEllipse));
            engine.SetValue("wait", new Func<bool>(Wait));

            engine.Execute(script);
            engine.Invoke("hello");
        });

    }

But when I start about 7 scripts, the UI is responding but the scripts are in somehow halted and suddenly continue. Is there a better way to implement this?

[sebastienros]

I would suggest to enable debugging, and on a debugger step, check for a ManualResetEvent or TokenEventSource, which would then block when set from an external program. This event handler is call for every statement that is executed.

[juanpaexpedite]

Interesting approach. I have checked that and because I have to return a StepMode in the event I cannot make it await a delay. I've also tried to do with Break in the following way: (I've realize that debugger; does not fire the break)

 ScriptBox.Text = @"
        function hello() 
        { 
            for (i = 10; i < 20; i++) 
            {
                paint(i*2);
                wait();
            }
         }";

And then search for the wait statements:

   int k = 0;
    private async void RunScript_Click(object sender, RoutedEventArgs e)
    {
        k++;
        ScriptsBlock.Text = $"Scripts {k}";
        var script = ScriptBox.Text;
        var lines = script.Replace("\r\n", "\n").Split('\r');

        await Task.Run(() =>
        {
            var engine = new Engine(cfg => cfg.DebugMode(true));

            int iline = 0;
            foreach(var line in lines)
            {
                if(line.Contains("wait"))
                {
                    var pos = line.IndexOf('w');

                    engine.BreakPoints.Add(new BreakPoint(iline, pos));
                }
                iline++;
            }

            engine.Break += Engine_Break;
            engine.SetValue("paint", new Action<double>(AddEllipse));
            engine.SetValue("wait", new Func<bool>(Wait));

            engine.Execute(script);
            engine.Invoke("hello");
        });

    }

    public bool Wait()
    {
        return true;
    }

    private StepMode Engine_Break(object sender, DebugInformation e)
    {
        Task.Delay(500).Wait();

        return StepMode.None;
    }

So now the only option I have is adding another delegate with Task and recompile Jint with that in order to make it work.

[leeyh20]

@sebastienros Could you kindly elaborate on how to enable debugging for the latest version of Jint? Additionally, how do i check for ManualResetEvent or TokenEventSource? Thank you! This feature is very important to me as it will be very useful to run the Jint code statement by statement and also know which statement is running at each time! I could elaborate more about the project I am doing if required.

[sebastienros]

@leeyh20 This is how it works:
https://docs.microsoft.com/en-us/dotnet/api/system.threading.manualresetevent?view=netframework-4.7.2

You will need more than that. Might be easier for you to just do some logging on every step.

[RanjeetBShinde1]

Hi @Jither @sebastienros ,

Using Jint 3.1.0
In Script Debugger, I have the code below, but I am getting an error like "Engine Doesn't Content the Definition of DebugHandler." Am I missing some references? I have checked everything but am not getting a solution on this.

Also, I am getting the same issue in the statement "e.CurrentCallFrame.ScopeChain.Global.GetBindingValue("o")". like  DegugScopes doesn't contain a definition of global

here is the Code :

using System;
using System.Net;
using Jint;
using Jint.Runtime.Debugger;

namespace JintDebugTestByRanjeet
{
    class Program
    {
void Main()
{
var engine = new Engine(c =>
{
c.AllowClr(typeof(WebClient).Assembly);
c.DebugMode();
c.DebuggerStatementHandling(Jint.Runtime.Debugger.DebuggerStatementHandling.Script);
});

var handler = engine.DebugHandler;
handler.Break += Handler_Break;
handler.Step += Handler_Step;
handler.BreakPoints.Add(new Jint.Runtime.Debugger.BreakPoint(1, 0));
engine.Execute(@"var o = { 'Hallo': 'Welt', 'Test': 0};
o = { 'Hallo': 'Welt2', 'Test': 1};
o = { 'Hallo': 'Welt3', 'Test': 2};");
}

private static StepMode Handler_Step(object sender, DebugInformation e)
{
var f = e.CurrentCallFrame.ScopeChain.Global.GetBindingValue("o");
Console.WriteLine($"Step o: {f}");
var prop = f.Get("Hallo");
Console.WriteLine($"Step: {prop}");
return StepMode.Into;
}

private static StepMode Handler_Break(object sender, DebugInformation e)
{
var f = e.CurrentCallFrame.ScopeChain.Global.GetBindingValue("o");
Console.WriteLine($"Break o: {f}");
var prop = f.Get("Hallo");
Console.WriteLine($"Break: {prop}");
return StepMode.Into;
}
}
}

[Jither]

engine.DebugHandler was renamed engine.Debugger before the release of 3.0.
The original scope chain only included Global and Local, so properties made sense back then. But since then, it was changed to an actual, well, "chain" (an IReadOnlyList of scopes). Meaning in order to specifically get the global scope, you'd have to look through the list for a scope with ScopeType == DebugScopeType.Global. The scope types are listed (and documented) here:

https://github.com/sebastienros/jint/blob/main/Jint/Runtime/Debugger/DebugScopeType.cs

Other than Break and Step, note that there's an additional event now, Skip, although that's only relevant if you need to do something at execution points that aren't a breakpoint, and where you aren't stepping through the code.

Also, since the time of whatever documentation you have based this on, Breakpoint positions are now required to be exact line and column (this in order to support e.g. multiple breakpoints in a single line). 🙂

[Jither]

There's a test (hence current) which shows similar usage here:

https://github.com/sebastienros/jint/blob/main/Jint.Tests/Runtime/EngineTests.cs#L1556