@naanlang/naan 1.3.2 → 1.4.1

package/frameworks/node/worker.nlg

@@ -10,6 +10,13 @@
  *
  */
 
+/*
+ * globals
+ *
+ */
+
+gWorkers;
+
 
 /*
  * workCurrent
@@ -19,8 +26,8 @@
  */
 
 closure workCurrent(workco, workerID, startup, local current) {
-    global()
-    current = new(object, this)
+    global(js)
+    current = require("../running/executors.nlg").ExecutorBase(workco, workerID, startup.name)
     current.workerID = workerID
     current.name = startup.name
     current.links = []
@@ -94,6 +101,7 @@ closure workCurrent(workco, workerID, startup, local current) {
     function ONmessageOut(data) {
         if data._guid
             return                                                          // already replied
+        current.execReceived(data)
         sendAll({
             id: "targetout",
             data: data
@@ -153,7 +161,17 @@ closure workCurrent(workco, workerID, startup, local current) {
         if current.links.length == 0
             current.host.Detach(current.termif)                             // attached while one link is active
     }
-    
+
+    //
+    // target.PostMessage
+    //
+    //     Post a message to the main thread.
+    //
+    current.PostMessage = function PostMessage(data) {
+        js.t.DispatchMessage(data)
+        list(false, { posted: true })
+    }
+
     //
     // msgin
     //
@@ -188,6 +206,18 @@ closure workCurrent(workco, workerID, startup, local current) {
 };
 
 
+/*
+ * WorkerConnect
+ *
+ *     Return the existing web worker for a workerGUID, or false if it does not exist.
+ *
+ */
+
+function WorkerConnect(workerGUID) {
+    gWorkers[workerGUID]
+}
+
+
 /*
  * workMainProxy
  *
@@ -270,18 +300,19 @@ closure WorkerToMain(local nideRunning, track) {
  *
  */
 
-closure workThread(workco, workerID, startup, local worker, options, subChannel, deathWatcher) {
-    global(threads, JSpath)
-    worker = new(object, this)
+closure workThread(workco, workerID, startup, guid
+    local worker, options, subChannel, deathWatcher) {
+    global(js, threads, JSpath)
+    worker = require("../running/executors.nlg").ExecutorBase(workco, workerID, startup.name)
     worker.name = startup.name
     worker.workerID = workerID
     worker.links = []
-    worker.guid = UUID()
+    worker.guid = guid || UUID()
 
     // create our worker thread
 
     // options = { execArgv: ["--inspect-brk"] }                            // uncomment for NodeJS debugging
-    worker.thread = xnew(threads.Worker, JSpath.resolve(js.d, "node_worker.js"), options)
+    worker.thread = xnew(threads.Worker, JSpath.resolve(js.d, "lib/node_worker.js"), options)
     subChannel = xnew(threads.MessageChannel)
     worker.thread.postMessage({ hereIsYourPort: subChannel.port1 }, [subChannel.port1])
     worker.msgport = subChannel.port2
@@ -346,6 +377,8 @@ closure workThread(workco, workerID, startup, local worker, options, subChannel,
                 state: false                                                // resume state, if we have any
                 altcmd: false
                 dirpath: js.d
+                workerID: workerID
+                workerGUID: worker.guid
             }
             if startup.initcmds
                 startmsg.altcmd = startup.initcmds.concat("\n")
@@ -364,6 +397,8 @@ closure workThread(workco, workerID, startup, local worker, options, subChannel,
         else {
             if msg.id == "status"
                 worker.lastStatus = milliseconds()
+            else if msg.id == "targetout"
+                worker.execReceived(msg.data)
             sendAll(msg) }                                                  // default is just return message to the client
     })
     
@@ -401,6 +436,19 @@ closure workThread(workco, workerID, startup, local worker, options, subChannel,
         removeLink(link)
     }
 
+    //
+    // PostMessage
+    //
+    //     Post a message to the main thread.
+    //
+    worker.PostMessage = function PostMessage(data) {
+        worker.msgport.postMessage({                                        // send data to worker
+            id: "targetin",
+            data: data
+        })
+        list(false, { posted: true })
+    }
+
     //
     // msgin
     //
@@ -498,7 +546,7 @@ closure workLink(workco, conn, worker, sender, local link) {
  */
 
 closure workController(api, local workco) {
-    global()
+    global(gWorkers)
     workco = new(object, this)
     workco.serverID = "Workers"                                             // our serverID, used for communications
     workco.workers = { }                                                    // dictionary of workers by workerID
@@ -559,12 +607,47 @@ closure workController(api, local workco) {
         workco.workers[workerID] = undefined                                // it's like this worker has never been
     }
 
-    //
+    // spawn
+    //
+    //     Spawn a new worker with the specified configuration dictionary and optional GUID.
+    //
+    workco.spawn = closure spawn(workerID, config, guid, local worker) {
+        if !dictionary(gWorkers)
+            gWorkers = {}
+        worker = workco.workers[workerID]
+        if !worker {                                                        // create worker if needed
+            if workerID == "NideServer"
+                worker = workco.current = workCurrent(workco, workerID, config)
+            else
+                worker = workThread(workco, workerID, config, guid)
+            workco.uworkers[worker.guid] = worker
+            workco.workers[workerID] = worker
+            gWorkers[worker.guid] = worker }
+        if workerID == "NideServer"
+            workco.current.vitalUpdate({
+                id: "workerlist",                                           // send the initial list of workers
+                workers: let(workers, workerID, worker) {
+                    workers = { }
+                    for `(workerID, worker) in workco.workers
+                        workers[workerID] = {
+                            name: worker.name
+                        }
+                    workers
+                }()
+            })
+        else {
+            worker.vitalWatch(termination)
+            workco.current.vitalUpdate({
+                id: "spawned",                                              // note a new worker thread
+                name: config.name
+                workerID: workerID
+            }) }
+    }
+
     // wsReceive
     //
     //     Process a message from the websocket API.
     //
-
     workco.wsReceive = function wsReceive(message, conn, local worker, link, error) {
         if !message.workerID
             error = Error("workerID required", message.workerOp)
@@ -576,50 +659,25 @@ closure workController(api, local workco) {
                 if worker && message.payload {
                     if !link
                         makeLink(message, conn)                             // make sure we have a link for responses
-                    worker.msgin(message.payload)                           // send message to worker
-                    return } }
+                    worker.msgin(message.payload) }                         // send message to worker
+                return }
             else if message.workerOp == "echo" {
                 if worker && message.payload {
                     if !link
                         makeLink(message, conn)                             // make sure we have a link for responses
-                    worker.echo(message.payload, link)                      // echo message to other links
-                    return } }
+                    worker.echo(message.payload, link) }                    // echo message to other links
+                return }
             else if message.workerOp == "spawn" {
-                if !worker {                                                // create worker if needed
-                    if message.workerID == "NideServer"
-                        worker = workco.current = workCurrent(workco, message.workerID, message.payload)
-                    else
-                        worker = workThread(workco, message.workerID, message.payload)
-                    workco.uworkers[worker.guid] = worker
-                    workco.workers[message.workerID] = worker }
+                spawn(message.workerID, message.payload, message.workerGUID)
                 if !link
                     makeLink(message, conn)                                 // make sure we have a link for responses
-                if message.workerID == "NideServer"
-                    workco.current.vitalUpdate({
-                        id: "workerlist",                                   // send the initial list of workers
-                        workers: let(workers, workerID, worker) {
-                            workers = { }
-                            for `(workerID, worker) in workco.workers
-                                workers[workerID] = {
-                                    name: worker.name
-                                }
-                            workers
-                        }()
-                    })
-                else {
-                    worker.vitalWatch(termination)
-                    workco.current.vitalUpdate({
-                        id: "spawned",                                      // note a new worker thread
-                        name: message.payload.name
-                        workerID: message.workerID
-                    }) }
                 return }
             else if message.workerOp == "terminate" {
                 if worker {
                     if !link
                         makeLink(message, conn)                             // make sure we have a link for responses
-                    worker.terminate()                                      // echo message to other links
-                    return } }
+                    worker.terminate() }                                    // echo message to other links
+                return }
             error = Error("invalid parameters", message.workerOp, message.workerID)
         }
         ErrorDebuglog("workController.wsReceive error:", error)
@@ -663,13 +721,13 @@ closure workController(api, local workco) {
  */
 
 function workInit(local manifest) {
-    manifest = `(workCurrent, workMainProxy, WorkerToMain, workThread, workLink, workController,
-        workInit)
-
+    manifest = `(workCurrent, WorkerConnect, workMainProxy, WorkerToMain, workThread, workLink,
+        workController, workInit)
     Naan.module.build(module.id, "worker", function(modobj, compobj) {
         require("./node.nlg")
         compobj.manifest = manifest
         modobj.exports.WorkerController = workController
+        modobj.exports.WorkerConnect = WorkerConnect
         modobj.exports.WorkerToMain = WorkerToMain
     })
 }();

package/frameworks/project/build.nlg

@@ -368,7 +368,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     // for each file. The result is a standard (error, data) tuple.
     
     function zip1(files, options, local libzip, ziparc, file, result) {
-        libzip = require("frameworks/project/jszip.nlg").JSZip()
+        libzip = require("naanlib:frameworks/project/jszip.nlg").JSZip()
         if !libzip
             return (list(Error("Build requires zip but it's not available")))
         ziparc = libzip.create()
@@ -1067,7 +1067,6 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         //
         function writeCatenate(writepath,
             local template, entry, content, catsub, dozip, docat, fsoptions, zipmap, error, result) {
-            debuglog("writeCatenate", writepath)
             template = build.templates[writepath]                       // optional in some cases ### should warn in others
             catsub = { }
             for entry in catenates[writepath] {                         // error check and substitution build

package/frameworks/project/projects.nlg

@@ -296,7 +296,7 @@ closure projConnector(projman, projtype, local connector, watch) {
  *
  * Nide.proj/
  *      nide_cliser.cfg                 - JSON definition of the project (see below)
- *      NaanIDE_version.txt             - [default] substitution file defining 1.3.2+1 etc.
+ *      NaanIDE_version.txt             - [default] substitution file defining 1.4.1+1 etc.
  *      NaanIDE_version_builds.txt      - [default] contains current build number as decimal string
  *      build/                          - [optional] default build output location
  *      NaanIDE.lic                     - [optional] defines Zulch Laboratories, Inc. and other license info

package/frameworks/running/debugnub.nlg

@@ -33,6 +33,9 @@ closure DebugNub(local nub, debug, paused) {
     nub.codemgr = CodeManager()
     nub.exenable = true
     nub.watches = []
+    nub.contIDs = new(weakmap)
+    nub.stacks = { }
+    nub.usage = { }
 
     // debugDepth
     // Return the recursive debugging depth as an integer.
@@ -80,7 +83,7 @@ closure DebugNub(local nub, debug, paused) {
             for frame in nub.frames
                 if procedure(frame)
                     break
-            `(procdef, task) = nub.procTask(frame)
+            `(procdef, task) = debug.frameProcTask(frame)
         }
         if !procdef
             return (false)
@@ -396,14 +399,75 @@ closure DebugNub(local nub, debug, paused) {
             output.push(breakInfo(bpid))
         output
     }
+    
+    // procLoc
+    //
+    // Get the location of a procdef.
+    
+    nub.procLoc = function procLoc(procdef, task, local comp, position) {
+        if !task
+            task = rrrest(procdef)
+        comp = nub.codemgr.procComponent(procdef)
+        position = comp.textpos(procdef, task)
+        {
+            modname:    comp.modname
+            compname:   comp.compname
+            first:      position.first
+            last:       position.last
+            line:       position.line
+        }
+    }
+
+    // getContID
+    //
+    // Get the contID for a continuation.
+    
+    nub.getContID = function getContID(cont, local contID, frames) {
+        contID = nub.contIDs[cont]
+        if !contID
+            nub.contIDs[cont] = contID = UUID()
+        frames = cont.stacktrace().toarray
+        if frames.slice(-1).0 == `interrupt
+            frames.pop()
+        nub.stacks[contID] = frames
+        contID
+    }
+
+    // contGC
+    //
+    // Remove any continuations that are not in the specified array.
+    
+    nub.contGC = function contGC(contIDs, local contID) {
+        contIDs = contIDs.concat(nub.usage.*.toarray)                       // keep preserved ids
+        for contID in nub.stacks
+            if contIDs.indexOf(contID) < 0
+                nub.stacks[contID] = undefined
+    }
+    
+    // usingContID
+    //
+    // Mark that the contID is being used.
+    //
+    nub.usingContID = function usingContID(contID, usage) {
+        if nub.usage[contID]
+            nub.usage[contID] += usage
+        else if usage > 0
+            nub.usage[contID] = usage
+        if nub.usage[contID] == 0
+            nub.usage[contID] = undefined
+    }
 
     // callStack
     //
-    // List our callers as of the last entry.
+    // List our callers as of the last entry in the optional frames or current debugger stack.
     
-    nub.callStack = function callStack(local output, frame, type, record) {
+    nub.callStack = function callStack(contID, local frames, output, frame, type, record) {
         output = []
-        for frame in nub.frames {
+        if contID
+            frames = nub.stacks[contID]
+        else
+            frames = nub.frames
+        for frame in frames {
             record = {
                 type:       frame.0.tostring                                // e.g. "function"
             }
@@ -425,8 +489,12 @@ closure DebugNub(local nub, debug, paused) {
     //
     // Return the nth stack frame in the list returned by callStack above.
     
-    nub.nthFrame = function nthFrame(nth, local frame) {
-        for frame in nub.frames
+    nub.nthFrame = function nthFrame(nth, contID, local frames, frame) {
+        if contID
+            frames = nub.stacks[contID]
+        else
+            frames = nub.frames
+        for frame in frames
             if procedure(frame) || frame.0.tostring == "interrupt" {
                 if nth-- == 0
                     return (frame)
@@ -469,14 +537,15 @@ closure DebugNub(local nub, debug, paused) {
 
     // evalWatchesInFrame
     //
-    //     Parse and evaluate our watchpoints, optionally in the context of the nth frame. Each entry
-    // in the returned array is for a watchpoint, comprising a tuple: `(error, expression, evaluated)
+    //     Parse and evaluate our watchpoints, optionally in the context of the nth frame of the
+    // specified continuation or the current debugger stack. Each entry in the returned array is for
+    // a watchpoint, comprising a tuple: `(error, expression, evaluated).
     
-    nub.evalWatchesInFrame = function evalWatchesInFrame(nth,
+    nub.evalWatchesInFrame = function evalWatchesInFrame(nth, contID,
         local frame, locals, ns, mod, gohome, texts, watch, exprs, error, expr)
     {
         if integer(nth) {
-            frame = nthFrame(nth)
+            frame = nthFrame(nth, contID)
             locals = localist(frame)
             ns = frame.3.1.namespace
             if ns !== nsactive().0 {
@@ -506,8 +575,29 @@ closure DebugNub(local nub, debug, paused) {
     //
     // Return procedure and task from a frame, as a `(procdef, task) tuple.
     
-    nub.procTask = function procTask(frame) {
-        debug.frameProcTask(frame)
+    nub.procTask = function procTask(frame, contID, local frames, ftrav, procdef, bodydef) {
+        if contID
+            frames = new(nub.stacks[contID])
+        else
+            frames = new(debug.frames)
+        loop {
+            if frames.length == 0
+                break
+            ftrav = frames.shift()
+            if ftrav eq frame
+                frame = false                                               // can now stop on our desired procedure
+            if procedure(ftrav) {
+                if !frame {
+                    procdef = ftrav.3                                       // first procedure definition starting with desired frame
+                    if !bodydef
+                        bodydef = procdef                                   // use procdef as body if no body frame found
+                    break }
+                bodydef = false }                                           // any previously-found body applies to wrong procedure
+            else if ftrav.0 == `body || ftrav.0 == `loop {
+                if !bodydef
+                    bodydef = ftrav.2 } }                                   // use first body found before desired procedure
+        if procdef
+            list(procdef, bodydef)                                          // found valid location
     }
     
     // lastStepValue

package/frameworks/running/debugutil.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021 by Richard C. Zulch
+ * Copyright (c) 2021-2024 by Richard C. Zulch
  *
  */
 
@@ -260,24 +260,33 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     here.breakInfo = function breakInfo(bpid) {
         libBreakInfo(bpid)
     }
+    
+    // usingContID
+    //
+    // Mark that the contID is being used.
+    //
+    here.usingContID = function usingContID(contID, usage) {
+        debugNub = car(compress("debugNub"))
+        debugNub.usingContID(contID, usage)
+    }
 
     // callstack
     //
-    // Report current callstack.
+    // Report the specified fiber callstack or current debugger stack.
     //
-    here.callStack = function callStack(local debugNub) {
+    here.callStack = function callStack(contID, local debugNub) {
         debugNub = car(compress("debugNub"))
-        debugNub.callStack()
+        debugNub.callStack(contID)
     }
     
     // frameinfo
     //
-    // Report information about the nth frame in the callStack.
+    // Report information about the nth frame in a fiber callstack or the current debugger stack.
     //
-    here.frameinfo = function frameinfo(nth, local debugNub, frame, proctask, comp, position) {
+    here.frameinfo = function frameinfo(nth, contID, local debugNub, frame, proctask, comp, position) {
         debugNub = car(compress("debugNub"))
-        frame = debugNub.nthFrame(nth)
-        proctask = debugNub.procTask(frame)
+        frame = debugNub.nthFrame(nth, contID)
+        proctask = debugNub.procTask(frame, contID)
         comp = debugNub.codemgr.procComponent(proctask.0)
         position = comp.textpos(proctask.0, proctask.1)
         {
@@ -302,11 +311,11 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     //     The optional visible array is a preceding result of this function, where "visible=true"
     // can be applied to nested values to add recursive depth.
     //
-    here.scopeinfo = function scopeinfo(nth, visible,
+    here.scopeinfo = function scopeinfo(nth, visible, contID
         local debugNub, frame, procsym, parent, proc, lex1, ex1, params, content, scope, level, level1)
     {
         debugNub = car(compress("debugNub"))
-        frame = debugNub.nthFrame(nth)
+        frame = debugNub.nthFrame(nth, contID)
         procsym = frame.3.1
         parent = procsym@\.parent
         while parent {
@@ -370,11 +379,11 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     // can be applied to nested values to add recursive depth. A stack frame index can be specified
     // to evaluate an expression in that context.
 
-    here.watchInfo = function watchInfo(visible, nth,
+    here.watchInfo = function watchInfo(visible, nth, contID,
         local debugNub, values, content, watch, child1, error, value, level, expr)
     {
         debugNub = car(compress("debugNub"))
-        values = debugNub.evalWatchesInFrame(nth)
+        values = debugNub.evalWatchesInFrame(nth, contID)
         visible = new(visible)                                              // don't modify original
         content = []
         for watch in debugNub.watches {
@@ -417,8 +426,9 @@ closure DebugRemote(commander, local remoter, here, there, library) {
     //
     // List the current futures.
     
-    here.futureslist = function futureslist(local debugNub, output, future, record, procsym) {
+    here.futureslist = closure futureslist(local debugNub, contIDs, output, future, record, procsym) {
         debugNub = car(compress("debugNub"))
+        contIDs = []
         output = []
         for future in futures() {
             if member(debugNub.pauser, future.waiting)
@@ -431,6 +441,7 @@ closure DebugRemote(commander, local remoter, here, there, library) {
             if procedure(future.execute) {
                 procsym = future.execute.1
                 record.execute = strcat(future.execute.0, space, procsym.namespace.tostring, "::", debugNub.procname(procsym))
+                record.execloc = debugNub.procLoc(future.execute)
             }
             else if future.execute
                 record.execute = tostring(future.execute)
@@ -439,9 +450,15 @@ closure DebugRemote(commander, local remoter, here, there, library) {
                     procsym = item.1
                     strcat(item.0, space, procsym.namespace.tostring, "::", debugNub.procname(procsym))
                 })
+                record.continuations = future.continuations.toarray.map(function(cont, local contID) {
+                    contID = debugNub.getContID(cont)
+                    contIDs.push(contID)
+                    contID
+                })
             }
             output.push(record)
         }
+        debugNub.contGC(contIDs)
         output
     }