@naanlang/naan 1.5.0 → 1.7.0

package/frameworks/node/ws_client.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2023-2024 by Richard C. Zulch
+ * Copyright (c) 2023-2026 by Richard C. Zulch
  *
  */
 
@@ -13,7 +13,7 @@
 /*
  * WebSocket
  *
- * Create a WebSocket client connection object using the existing HTTPS connection.
+ * Create a WebSocket client connection object.
  *
  * Required:
  *      host:       <string>                    // host:port

package/frameworks/project/build.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2019-2024 by Richard C. Zulch
+ * Copyright (c) 2019-2026 by Richard C. Zulch
  *
  */
 
@@ -426,7 +426,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     // autoquoted to itself, a symbol. This can be used to detect build time vs. runtime.
     
     function parseAndPack1(text, fpath, options, operation,
-        local util, lib, penv, naansym, dlogsym, pmod, pcomp, output, textout, annerror, annotations, package)
+        local util, lib, penv, naansym, dlogsym, pmod, pcomp, ournn, output, textout, annerror, annotations, package)
     {
         //
         // textline
@@ -445,20 +445,39 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
         lib = Naan.module.modlist().Lib.exports
         if !util || !lib
             return (list("Build packager cannot access support functions"))
+        //
+        // The following crazy rigmarole is about customizing the ParsEnvironment so we can glean
+        // enough information to build a package without actually executing the code. To do this we
+        // replace the entire Naan.module collection of functions with just build, so the others do
+        // nothing. From that we collect the module and component names, plus the manifest. This 
+        // also sets up a benign "exports" dictionary so module build can "go through the mtions"
+        // without modification.
+        //
         penv = lib.ParsEnvironment(Dialect, "build-".concat(operation))
         penv.evalq(letlocal(App))                                           // make local copy of App
         penv.evalq(letlocal(js))                                            // make local copy of js
-        naansym = penv.evalq(letlocal(Naan).0)                              // make local copy of Naan
-        penv.evalq(assign(naansym,new(Naan)))                               // make it modifiable
+        ournn = new(Naan)                                                   // get modifiable Naan
         pmod = { }                                                          // our module object
         pcomp = { }                                                         // our component object
-        car(naansym).module = {
+        ournn.module = {
             build: function(modname, compname, proc) {
-                pmod.id = module
+                pmod.id = module.id
+                pmod.exports = { }
                 pcomp.name = compname
                 call(proc, pmod, pcomp)                                     // obtain manifest
             }
         }
+        naansym = penv.evalq(function(nn) {
+            assign(letlocal(Naan).0,nn)
+            `Naan
+        }(ournn))                                                           // make Naan modifiable
+        penv.evalq(assign(letlocal(module).0, {                             // make local copy of module
+            exports: { }
+        }))
+        //
+        // Here we make a custom debuglog function that identifies the text without color and will
+        // write the output to the build log.
+        //
         dlogsym = penv.evalq(letlocal(debuglog).0)                          // make local copy of debuglog
         penv.evalq(function \.debuglog args {                               // redefine debuglog for capture
             let (arg, spaced) {
@@ -471,8 +490,19 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
                 apply(textline, reverse(spaced))
             } () })
         penv.evalq(putproc(car(dlogsym), \.debuglog.proc))
+        //
+        // The NideBuild symbol is "debug" or "release", etc. or is simply autoquoted as the symbol
+        // itself when not building. This is used if the source needs different behavior at build
+        // time or run time.
+        //
         penv.eval(append(quote(assign(compress("NideBuild"))), operation))  // NideBuild symbol is operation name string
+        //
+        // This is the actual meat of the matter, the parsing of the program text.
+        //
         output = penv.parse(text)                                           // parse and evaluate
+        //
+        // Output processing and error logging
+        //
         textout = ""
         try {
             if !pcomp.name
@@ -507,20 +537,30 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
             }
             if output.errors.length > 0
                 return (list("errors in ".concat(fpath), false, annotations, textout))
+            //
+            // Build the package, if not just doing syntax checking
+            //
             if options.naanpack || options.jspack {                         // actually building a package?
                 if !pcomp.name {
-                    pcomp = penv.evalq(car(compress(NaanBuildComponent)))   // fallback for building Module.nlg itself
+                    //
+                    // Some components cannot use a build function because they are too early in the
+                    // boot process, but we still need a component. We look for NaanBuildComponent
+                    // to define a dictionary with filename, name and manifest fields. For example,
+                    // see Util:Module.nlg
+                    //
+                    pcomp = penv.evalq(car(compress(NaanBuildComponent)))
                     if !pcomp || !fpath.endsWith("/".concat(pcomp.filename))
                         return (list("Build cannot package without component in ".concat(fpath), false, annotations, textout))
                 }
-                package = penv.evalq(util.pkgSave(compress(pcomp.name), pcomp.manifest))
+                package = util.pkgSave(compress(pcomp.name), pcomp.manifest)
+                if string(package)
+                    return (list("Build cannot generate package for ".concat(fpath), false, annotations, textout))
             }
         } catch {
             if true
                 return (list("Packaging exception in ".concat(fpath, ": ", tostring(exception)), false, annotations, textout))
         } finally {
             penv.destroy()                                                  // remove the namespace
-            debuglog("parseAndPack1 done", fpath)
         }
         if options.naanpack
             package = (js.w||js.s||js.g).JSON.stringify(package)            // doesn't have frameworks/common available
@@ -546,7 +586,7 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
             build.parallel = ExecutorParallel(track, {                      // create worker pool
                 basename: "build"
                 initeval: `(false, (parseAndPack1))
-            }) 
+            })
         result = build.parallel.rpc(parseAndPack1, list(text, fpath, options, operation))
         if !result.0 {
             result = result.1                                               // unpeel RPC result
@@ -1211,17 +1251,19 @@ closure Builder(rules, operation, fs, srcpath, destpath, track, local build, gro
     //
     // Run the current build product by spawning a new worker.
     //
-    build.runSpawn = function runSpawn(local error, maintext, executor, vpath, site) {
+    build.runSpawn = function runSpawn(local error, maintext, executor, vpath, site, dirpath) {
         `(error, maintext) = fs.readFile(JSpath.join(build.destpath, build.runway.main))
         if error
             error = Error("Builder: cannot read main file", error)
         else {
+            dirpath = fs.path.resolve("/", fs.rootpath, build.destpath, build.runway.path || "")
             `(error, executor) = track.spawn(build.runway.spawn.0, "${rules.name} ${build.version}", {
-                workerID: "Run-${build.buildnum}"
+                workerID: "Run-${build.version}+${build.buildnum}"
                 startup: {
-                    initcmds: maintext
-                    dirpath: fs.path.resolve("/", fs.rootpath, build.destpath)
+                    maintext: maintext
+                    dirpath: dirpath
                 }
+                rootPath: dirpath
             })
             if error
                 error = Error("Builder: cannot spawn executor instance", error)

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.5.0+1 etc.
+ *      NaanIDE_version.txt             - [default] substitution file defining 1.7.0+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/debugcom.nlg

@@ -19,9 +19,6 @@
 
 closure DebugCommand(executor, notify, local decom, excon) {
     decom = new(object, this)
-    executor.DebugCmd({
-        op: "attach"
-    })
     decom.executor = executor
 
     // debugData
@@ -96,6 +93,24 @@ closure DebugCommand(executor, notify, local decom, excon) {
         status
     }
 
+    // query
+    // Send a status update back.
+    //
+    decom.query = function query() {
+        decom.executor.DebugCmd({
+            op: "query"
+        })
+    }
+    
+    // attach
+    // Attach our GUI to the low-level debugger
+    //
+    decom.attach = function attach() {
+        executor.DebugCmd({
+            op: "attach"
+        })
+    }
+
     //
     // Run control.
     //
@@ -138,6 +153,8 @@ closure DebugCommand(executor, notify, local decom, excon) {
         notify.runState(debugStatus())
     }
 
+    attach()
+
     // finis
     
     decom

package/frameworks/running/debugnub.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021-2024 by Richard C. Zulch
+ * Copyright (c) 2021-2026 by Richard C. Zulch
  *
  */
 
@@ -33,9 +33,9 @@ closure DebugNub(local nub, debug, paused) {
     nub.codemgr = CodeManager()
     nub.exenable = true
     nub.watches = []
-    nub.contIDs = new(weakmap)
     nub.stacks = { }
     nub.usage = { }
+    paused = { }
 
     // debugDepth
     // Return the recursive debugging depth as an integer.
@@ -46,6 +46,18 @@ closure DebugNub(local nub, debug, paused) {
             curdepth = 0
         curdepth
     }
+    
+    // sendStatus
+    // Send current status to the far end.
+    //
+    function sendStatus() {
+        js.t.ReplyDebugger({
+            op: "status"
+            depth: debugDepth()
+            bpenable: debug.bpenable
+            exenable: nub.exenable
+        })
+    }
 
     // onDebugger proc
     // Process an incoming debugger command.
@@ -53,17 +65,13 @@ closure DebugNub(local nub, debug, paused) {
     function onDebugger(msg) {
         if msg.op == "attach" {
             debug.setCommander(nub)
-            js.t.ReplyDebugger({
-                op: "status"
-                depth: debugDepth()
-                bpenable: debug.bpenable
-                exenable: nub.exenable
-            })
+            sendStatus()
         }
         else if msg.op == "detach" {
             debug.setCommander(false)
             paused.wait = false                                             // false: go back to ndb
-        }
+        } else if msg.op == "query"
+            sendStatus()
         else if msg.op == "pause"
             debugger()
         else if msg.op == "resume" || msg.op == "stop"
@@ -405,8 +413,17 @@ closure DebugNub(local nub, debug, paused) {
     // Get the location of a procdef.
     
     nub.procLoc = function procLoc(procdef, task, local comp, position) {
-        if !task
+        if !task {
+            if nub.procLocs[procdef]
+                return                                                      // use the cached value
             task = rrrest(procdef)
+            if task {
+                if !nub.procLocs
+                    nub.procLocs = new(weakmap)                             // make sure we have a weakmap
+                nub.procLocs[procdef] = procLoc(procdef, task)              // cache a new location
+                return
+            }
+        }
         comp = nub.codemgr.procComponent(procdef)
         position = comp.textpos(procdef, task)
         {
@@ -424,8 +441,11 @@ closure DebugNub(local nub, debug, paused) {
     
     nub.getContID = function getContID(cont, local contID, frames) {
         contID = nub.contIDs[cont]
-        if !contID
+        if !contID {
+            if !nub.contIDs
+                nub.contIDs = new(weakmap)                                  // make sure we have a weakmap
             nub.contIDs[cont] = contID = UUID()
+        }
         frames = cont.stacktrace().toarray
         if frames.slice(-1).0 == `interrupt
             frames.pop()
@@ -580,6 +600,8 @@ closure DebugNub(local nub, debug, paused) {
             frames = new(nub.stacks[contID])
         else
             frames = new(debug.frames)
+        if !array(frames)
+            return (false)                                                  // invalid frames array
         loop {
             if frames.length == 0
                 break