v5.2.4

- fix source locations for copied lambdas
- amend projection boxes a bare primitive verb
- indexed monadic compound assignment a[i]+:
- parse errors for malformed assignment

Author: cmh25

README.md

@@ -37,7 +37,7 @@ make test
 
 ```
 $ ./gk
-gk-v5.2.3 Copyright (c) 2023-2026 Charles Hall
+gk-v5.2.4 Copyright (c) 2023-2026 Charles Hall
 
   1+2
 3

src/fn.c

@@ -11,6 +11,26 @@ K fnestack[EVALDEPTH];   /* per-lambda-call stack; depth-indexed, must match A0/
 int fnestacki=-1;
 static char* spf;
 
+/* A deserialized lambda has definition text but no parse result.  Until its
+   first fnd(), slot 1 carries this private (file;line) marker: the db call is
+   its local provenance anchor, while line offsets reconstructed from the text
+   remain virtual.  It is never serialized (bd already writes slot 1 as null)
+   and fnd() consumes it before installing the real parse result. */
+static int fnanchor(K x, char **file, int *line) {
+  if(!x || s(x) || T(x)!=0 || n(x)!=2) return 0;
+  K *p=px(x);
+  if(s(p[0]) || T(p[0])!=-3 || s(p[1]) || T(p[1])!=1) return 0;
+  *file=px(p[0]); *line=ik(p[1]);
+  return 1;
+}
+
+static K fnanchor_new(void) {
+  K r=tn(0,2),*p=px(r);
+  p[0]=tnv(3,strlen(pfile),xmemdup(pfile,1+strlen(pfile)));
+  p[1]=t(1,(u32)fileline);
+  return r;
+}
+
 void fninit(void) {
   K f;
   f=fnnew("{x dvl,y}"); dset(C,sp("dv"),f); fnfree(f);
@@ -71,15 +91,48 @@ static K fncp_(K x) {
   pf[1]=null;       /* parse result */
   pf[2]=null;       /* scope */
   pf[3]=FN_VF(0,0); /* valence + force-monad FM[] index */
-  if((p=fnd(f))) { fnfree(f); return p; }
+
+  /* fnd() reparses the definition, and pgparse() stamps that fresh parse with
+     the current pfile/fileline globals.  A copy may be made long after and in
+     a different file from the definition (a lambda projection does exactly
+     that), so using the current globals moves error locations to the copy
+     site.  Recover the definition location from the source parse before the
+     reparse; lex() will add the proper relative offsets for nested lambdas. */
+  char *pfile0=pfile;
+  int fileline0=fileline;
+  int filevirtual0=filevirtual;
+  char *anchorfile;
+  int anchorline;
+  if(fnanchor(px[1],&anchorfile,&anchorline)) {
+    pfile=anchorfile;
+    fileline=anchorline;
+    filevirtual=1;
+  }
+  else if(px[1] && px[1]!=null && !T(px[1]) && n(px[1])) {
+    K loc=((K*)px(px[1]))[0];
+    if(loc && !T(loc) && n(loc)>=7) {
+      K *ploc=px(loc);
+      if(-3==T(ploc[4]) && 1==T(ploc[6])) {
+        pfile=px(ploc[4]);
+        i32 base=ik(ploc[6]);
+        filevirtual=base<0;
+        fileline=filevirtual?~base:base;
+      }
+    }
+  }
+  p=fnd(f);
+  pfile=pfile0;
+  fileline=fileline0;
+  filevirtual=filevirtual0;
+  if(p) { fnfree(f); return p; }
   /* A lambda scope's slot[0] (parent) is the environment its FREE variables
      resolve against.  fnd just bound the fresh copy's parent to the ambient
      cs -- but a COPY of a lambda must keep the SOURCE's captured environment,
      otherwise free variables rebind to whatever scope did the copy (dynamic
      scope; lost closures -- e.g. a local-capturing lambda passed to another
      function).  The source parent is correct whether it is a live lexical
      enclosing scope or a frozen closure snapshot (slot[3]==1). */
-  if(px[2]!=null && pf[2]!=null) {
+  if(px[2] && px[2]!=null && pf[2] && pf[2]!=null) {
     K *sps=px(px[2]); K *nps=px(pf[2]);
     _k(nps[0]); nps[0]=k_(sps[0]);
     ((K*)px(nps[0]))[4]=t(1,1);  /* the copy parents there too (scope.c slot 4) */
@@ -497,6 +550,7 @@ K fnrestore(K f) {
   K *pf, cap, sc, *psc, *ps, p;
   if(0xc3!=s(f)) return f;
   pf=px(f);
+  if(pf[1]==null) pf[1]=fnanchor_new();
   if(0x80!=s(pf[2])) return f;   /* not a closure blob */
   cap=pf[2];
   pf[2]=null;                    /* let fnd() build the real scope */
@@ -532,7 +586,7 @@ K fnrestore(K f) {
   (b)[(l)]=(c); \
 } while (0)
 
-K fnd(K f) {
+static K fnd_(K f) {
   K p,r=0,*pf;
   char *ff=0,*ff0=0,*b,**v,*g,*h;
   int j,s,n,q,vx,vy,vz,ffq=0,first=1,params=1;
@@ -760,6 +814,24 @@ K fnd(K f) {
   return r;
 }
 
+K fnd(K f) {
+  K *pf=px(f),anchor=pf[1],r;
+  char *anchorfile,*pfile0;
+  int anchorline,fileline0,filevirtual0;
+  if(!fnanchor(anchor,&anchorfile,&anchorline)) return fnd_(f);
+
+  /* The marker owns anchorfile, so keep anchor alive until fnd_ has copied the
+     filename into every parse frame.  Detach it first: fnd_ replaces slot 1
+     with the actual parse result. */
+  pf[1]=null;
+  pfile0=pfile; fileline0=fileline; filevirtual0=filevirtual;
+  pfile=anchorfile; fileline=anchorline; filevirtual=1;
+  r=fnd_(f);
+  pfile=pfile0; fileline=fileline0; filevirtual=filevirtual0;
+  _k(anchor);
+  return r;
+}
+
 // make a copy of r and parent scope
 // closure only if parent scope == s0
 // can't create a closure like this:

src/k.c

@@ -1012,7 +1012,7 @@ K kamendi3(K d, K i, K f) {
     K args=tn(0,3); K *pa=px(args);
     pa[0]=kcp(d); if(E(pa[0])) { e=pa[0]; _k(args); goto cleanup; }
     pa[1]=kcp(i); if(E(pa[1])) { e=pa[1]; _k(args); goto cleanup; }
-    pa[2]=f?kcp(f):inull; if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
+    pa[2]=!f?inull:f<256?t(1,st(0xc0,f+32)):kcp(f); if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
     args=st(0x81,args);
     K g=t(1,st(0xc0,45)); /* @ */
     _k(d); _k(i); _k(f);
@@ -1784,7 +1784,7 @@ K kamendi4(K d, K i, K f, K y) {
     K args=tn(0,4); K *pa=px(args);
     pa[0]=kcp(d); if(E(pa[0])) { e=pa[0]; _k(args); goto cleanup; }
     pa[1]=kcp(i); if(E(pa[1])) { e=pa[1]; _k(args); goto cleanup; }
-    pa[2]=f?kcp(f):inull; if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
+    pa[2]=!f?inull:f<256?t(1,st(0xc0,f+32)):kcp(f); if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
     pa[3]=kcp(y); if(E(pa[3])) { e=pa[3]; _k(args); goto cleanup; }
     args=st(0x81,args);
     K g=t(1,st(0xc0,45)); /* @ */
@@ -2401,7 +2401,7 @@ K kamend3(K d, K i, K f) {
     K args=tn(0,3); K *pa=px(args);
     pa[0]=kcp(d); if(E(pa[0])) { e=pa[0]; _k(args); goto cleanup; }
     pa[1]=kcp(i); if(E(pa[1])) { e=pa[1]; _k(args); goto cleanup; }
-    pa[2]=f?kcp(f):inull; if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
+    pa[2]=!f?inull:f<256?t(1,st(0xc0,f+32)):kcp(f); if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
     args=st(0x81,args);
     K g=t(1,st(0xc0,43)); /* . */
     _k(d); _k(i); _k(f);
@@ -3043,7 +3043,7 @@ K kamend4(K d, K i, K f, K y) {
     K args=tn(0,4); K *pa=px(args);
     pa[0]=kcp(d); if(E(pa[0])) { e=pa[0]; _k(args); goto cleanup; }
     pa[1]=kcp(i); if(E(pa[1])) { e=pa[1]; _k(args); goto cleanup; }
-    pa[2]=f?kcp(f):inull; if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
+    pa[2]=!f?inull:f<256?t(1,st(0xc0,f+32)):kcp(f); if(E(pa[2])) { e=pa[2]; _k(args); goto cleanup; }
     pa[3]=kcp(y); if(E(pa[3])) { e=pa[3]; _k(args); goto cleanup; }
     args=st(0x81,args);
     K g=t(1,st(0xc0,43)); /* . */

src/lex.c

@@ -590,7 +590,7 @@ static int gf(pgs *pgs) {
       char *p1_=p1;
       int line_=line;
       int fileline0=fileline;
-      fileline+=startline;
+      if(!filevirtual) fileline+=startline;
       f=fnnew(q);
       p=p_; p0=p0_; p1=p1_; line=line_;
       fileline=fileline0;

src/main.c

@@ -82,7 +82,7 @@ int main(int argc, char **argv) {
   setvbuf(stderr, NULL, _IONBF, 0);  /* glibc has this by default; Windows pipes
     don't -- without it, buffered stderr (prompts/errors) races the unbuffered
     stdout (results) and the merged transcript reorders intermittently */
-  if(!quiet) fprintf(stderr, "gk-v5.2.3 Copyright (c) 2023-2026 Charles Hall\n\n");
+  if(!quiet) fprintf(stderr, "gk-v5.2.4 Copyright (c) 2023-2026 Charles Hall\n\n");
 #ifdef _WIN32
   SetConsoleCtrlHandler(ctlc,TRUE);
 #else

src/p.c

@@ -50,7 +50,7 @@ long gk_alloc_budget=GK_ALLOC_BUDGET;
 #endif
 int opencode=1;
 char *pfile="";
-int gline,glinei,gline0,gline0i,fileline;
+int gline,glinei,gline0,gline0i,fileline,filevirtual;
 
 /* A projection of a LAMBDA is a noun, exactly like the lambda itself: a verb
    juxtaposed on its left applies (`,{x+y}[1]` enlists, as `,{x+y}` does), it
@@ -264,8 +264,15 @@ static void printerror(K v, K x0, int i) {
     char *ff0=px(f0);
     if(pline[i]) { /* multiline lambda */
       if(strlen(pfile)) {
-        fprintf(stderr,"%s ... + %d in %s:%d\n",ff0,pline[i],pfile,1+pline[i]+ik(px0[6]));
-        LOADLINE=1+pline[i]+ik(px0[6]);
+        i32 base=ik(px0[6]);
+        if(base<0) {
+          fprintf(stderr,"%s ... + %d from %s:%d\n",ff0,pline[i],pfile,-base);
+          LOADLINE=-base;
+        }
+        else {
+          fprintf(stderr,"%s ... + %d in %s:%d\n",ff0,pline[i],pfile,1+pline[i]+base);
+          LOADLINE=1+pline[i]+base;
+        }
       }
       else fprintf(stderr,"%s ... + %d\n",ff0,pline[i]);
       kprint(v,"","\n","");
@@ -278,8 +285,9 @@ static void printerror(K v, K x0, int i) {
     }
     else { /* single line lambda */
       if(strlen(pfile)) {
-        fprintf(stderr,"in %s:%d\n",pfile,1+ik(px0[6]));
-        LOADLINE=1+ik(px0[6]);
+        i32 base=ik(px0[6]);
+        if(base<0) { fprintf(stderr,"from %s:%d\n",pfile,-base); LOADLINE=-base; }
+        else { fprintf(stderr,"in %s:%d\n",pfile,1+base); LOADLINE=1+base; }
       }
       kprint(v,"","\n","");
       fprintf(stderr,"%s\n",ff0);
@@ -555,6 +563,9 @@ static K r44(K x) {
     return r;
   }
 
+  /* The assign verbs ':' and '::' never take a bracket RHS */
+  if(':'==f0 || 0x82==s(f0)) { _k(x); return KERR_PARSE; }
+
   /* fast path: f[a;b;...] where f is a simple variable resolving to a
      0xc3 lambda, 0xd9 projection, or 0xda wrapper, and the param list
      is 0x41 or 0x81.  Bypasses avb/strlen/strchr/snprintf and the
@@ -1277,7 +1288,9 @@ K pgreduce_(K x0, int *quiet) {
         --pA;
         b=*--pA;
         a=*--pA;
-        if(!a||!b) { _k(a); _k(b); *pA++=KERR_TYPE; break; } /* backstop: never store/amend a NULL operand (mirrors the 0x81 guard above). Known producers are fixed at the push site, but the operand-stack-never-NULL invariant has several entry points. */
+        if(!a||!b) { _k(a); _k(b); *pA++=KERR_TYPE; break; } /* backstop: never store/amend a NULL operand */
+        /* a bare bracket group is not a value */
+        if(0x41==s(b)) { _k(a); _k(b); *pA++=KERR_PARSE; break; }
         if(s(b)) { b=reduce(b); if(E(b)||EXIT) { _k(a); *pA++=b; break; } }
         if(0x40==s(a)) { /* a::1 */
           if(!VST(b)) { _k(b); *pA++=KERR_PARSE; break; }
@@ -1345,14 +1358,60 @@ K pgreduce_(K x0, int *quiet) {
         if(pA<=A+1) { k_(v); break; }
         --pA;
         a=*--pA;
-        if(0x40!=s(a)) { _k(a); *pA++=KERR_VALUE; break; }
-        if(KERR_VALUE==(a_=vlookup(a))) a_=null;
-        if(E(a_)) { *pA++=a_; break; }
-        t=k(strchr(P,ik(v))-P,0,a_);
-        if(E(t)) { *pA++=t; break; };
-        p=scope_set(cs,a,t);
-        if(E(p)) { *pA++=p; }  /* t already freed by scope_set */
-        else { *pA++=p; *quiet=1; }
+        if(0x40==s(a)) {
+          K rs; if(KERR_VALUE==(a_=vlookuprs(a,&rs))) { a_=null; rs=scope_home(); }
+          if(E(a_)) { *pA++=a_; break; }
+          rs=asnrs(rs);
+          t=k(strchr(P,ik(v))-P,0,a_);
+          if(E(t)||EXIT) { *pA++=t; break; };
+          p=scope_set(rs,a,t);
+          if(E(p)) { *pA++=p; }  /* t already freed by scope_set */
+          else { *pA++=p; *quiet=1; }
+        }
+        else if(0x44==s(a)) { /* a[0]-: - amend with the monad */
+          pa=px(a);
+          K target=pa[0]; K a_=k_(target); K i_=k_(pa[1]); _k(a);
+          if(0x41==s(i_)) {
+            if(n(i_)) {
+              i_=r41(i_); if(E(i_)||EXIT) { _k(a_); *pA++=i_; break; }
+              if(0x81==s(i_)) i_=b(48)&i_;
+            }
+            else { _k(i_); i_=null; }
+          }
+          else if(0x81==s(i_)) {
+            if(n(i_)) i_=b(48)&i_;
+            else { _k(i_); i_=null; }
+          }
+          else { _k(a_); _k(i_); *pA++=KERR_TYPE; break; }
+          if(0x40!=s(a_)) { _k(a_); _k(i_); *pA++=KERR_TYPE; break; }
+          // resolve, then apply closure check
+          K rs; if(KERR_VALUE==(a_=vlookuprs(a_,&rs))) { a_=null; rs=scope_home(); }
+          if(E(a_)) { _k(i_); *pA++=a_; break; }
+          { K rsf=rs; rs=asnrs(rsf);
+            /* redirected write (non-closure parent / namespace): the found
+               binding survives, so kamend3 must not amend it in place */
+            if(rs!=rsf && a_!=null && (T(a_)<=0||T(a_)==2) && ((ko*)(b(48)&a_))->r) {
+              K a2=kcp(a_); _k(a_); a_=a2;
+              if(E(a_)) { _k(i_); *pA++=a_; break; }
+            } }
+          K r=kamend3(a_,k_(i_),strchr(P,ik(v))-P);
+          if(E(r)) { _k(i_); *pA++=r; }
+          else {
+            u64 zi=i+1; while(zi<nx && 0x83==s(px[zi])) ++zi;
+            if(disc&&zi>=nx) { _k(i_); t=null; }  /* statement position: value freed unread */
+            else {
+              /* Compound assignment returns the selected values after the
+                 complete amend (not the whole amended container). */
+              t=k(11,k_(r),i_);
+              /* selection failure must not discard the completed write */
+              if(E(t)||EXIT) { if(t>=256) _k(t); t=null; }
+            }
+            p=scope_set(rs,target,r);
+            if(E(p)) { _k(t); *pA++=p; }  /* r already freed by scope_set */
+            else { _k(p); *pA++=t; *quiet=1; }
+          }
+        }
+        else { _k(a); *pA++=KERR_VALUE; break; }
         break;
       case 0xce: /* a+:1 */
         if(pA<=A+2) {
@@ -1932,7 +1991,8 @@ apply_n_fallback: {
       }
       break;
     case 2: /* 64 64 66 ... */
-      if(pA<=A+1) { *pA++=KERR_VALENCE; break; }
+      /* an assign token with no target/value to consume is a malformed statement */
+      if(pA<=A+1) { *pA++=KERR_PARSE; break; }
       b=*--pA;
       a=*--pA;
 
@@ -3710,7 +3770,7 @@ static K listbc(pgs *s, pn *a, int t) {
     ((K*)px(pz[k]))[3]=line;
     ((K*)px(pz[k]))[4]=tnv(3,strlen(s->file),xmemdup(s->file,1+strlen(s->file)));
     ((K*)px(pz[k]))[5]=t(1,(u32)a->line); // gline
-    ((K*)px(pz[k]))[6]=t(1,(u32)fileline); // ggline
+    ((K*)px(pz[k]))[6]=t(1,(u32)s->fileline); // ggline
     bc(s,a->a[i],values,index,line,&vm);
     if(n(values)==1) {
       pv=px(values);
@@ -4819,6 +4879,12 @@ K pgparse(char *q, int load, K locals) {
   pz=px(z);
   s->p=q;
   s->file=pfile;
+  /* A negative frame base marks source reconstructed from a serialized
+     definition.  Its relative lambda lines are real, but its file location is
+     only an anchor, so printerror prints "+N from FILE:LINE" without adding N
+     to the physical line.  Keep the process-global fileline itself ordinary:
+     the lexer performs arithmetic on it while finding nested lambdas. */
+  s->fileline=filevirtual?~fileline:fileline;
   s->valuesmax=256;
   s->ti=0;s->tc=0;s->si=-1;s->ri=-1;s->vi=-1;
   if(opencode) stmt=ksplit(q,"\r\n");
@@ -4842,9 +4908,9 @@ K pgparse(char *q, int load, K locals) {
     ((K*)px(pz[zn]))[1]=index;
     ((K*)px(pz[zn]))[2]=k_(stmt);
     ((K*)px(pz[zn]))[3]=line;
-    ((K*)px(pz[zn]))[4]=tnv(3,strlen(pfile),xmemdup(pfile,1+strlen(pfile)));
+    ((K*)px(pz[zn]))[4]=tnv(3,strlen(s->file),xmemdup(s->file,1+strlen(s->file)));
     ((K*)px(pz[zn]))[5]=t(1,(u32)gline);
-    ((K*)px(pz[zn]))[6]=t(1,(u32)fileline);
+    ((K*)px(pz[zn]))[6]=t(1,(u32)s->fileline);
     n(z)++;
     s->values=values;
     s->index=index;

src/p.h

@@ -67,6 +67,7 @@ typedef struct {
   K locals;
   int overflow;    /* set by mark_lvalues when a statement's parse tree exceeds
                       maxr depth; pgparse turns it into a "stack" error */
+  int fileline;    /* file base line captured with file at pgparse entry */
 } pgs;
 
 extern int quiet,RETURN;
@@ -96,7 +97,7 @@ extern long gk_budget;
 extern long gk_alloc_budget;
 #define GK_ALLOC_BUDGET (64L*1024*1024)
 #endif
-extern int gline,glinei,gline0,gline0i,fileline;
+extern int gline,glinei,gline0,gline0i,fileline,filevirtual;
 extern char *glinep,*gline0p;
 extern K params[];
 extern int paramsi;

src/wasm.c

@@ -34,7 +34,7 @@ EMSCRIPTEN_KEEPALIVE void gk_init(void) {
   ipc_init_ns();
   wasm = 1;   /* no interactive error subconsole in a browser tab (no stdin) */
   /* The startup banner (same as main.c). To stdout so it shows in the REPL output. */
-  printf("gk-v5.2.3 Copyright (c) 2023-2026 Charles Hall\n\n");
+  printf("gk-v5.2.4 Copyright (c) 2023-2026 Charles Hall\n\n");
 }
 
 /* An eval error opens gk's interactive `>` debug subconsole IN PLACE (p.c:312-317:

t/r805

@@ -0,0 +1,11 @@
+-1 2 3
+(1 -2
+ 3 4)
+-1 2 3
+-3
+-1 -2 -3
+-1 -2 -3
+-1 -2 -3
+9
+6 2 3
+-1 -2 -3