Crash if v. n with v undefined; pass WILLOPEN through u&n n&v hook; unfinished business

Author: HenryHRich

jsrc/am.c

@@ -616,7 +616,7 @@ onecellframe:;   // come here when we detect single cell, possibly of higher ran
     if(JT(jt,deprecct)!=0)RZ(jtdeprecmsg(jt,1,"(001) (x (<\"0 array)} y): consider using (<<array)}\n"));
     goto doubleboxednumeric;  // the boxes were created with <"0 array.  That is the same as <<array now
    }else if(AR(ind0)==indr+1){
-    if(JT(jt,deprecct)!=0)RZ(jtdeprecmsg(jt,2,"(002) (x (<\"1 array)} y): consider using <array} or array}\n"));
+    if(JT(jt,deprecct)!=0)RZ(jtdeprecmsg(jt,2,"(002) (x (<\"1 array)} y): consider using (<array)} or array}\n"));
     goto boxednumeric;  // the boxes were created with  <"1 array, which is like <array now
    }else ASSERT(0,EVRANK)  // error if not <"0 or <"1
   }else{

jsrc/ca.c

@@ -482,6 +482,7 @@ F2(jtamp){F2PREFIP;A h=0;AF f1,f2;B b;C c;I flag,flag2=0,linktype=0,mode=-1,p,r;
   if(likely(f2==on2)){flag2|=VF2RANKATOP2; f2=r==RMAX?on2cell:f2; f2=r==0?on20:f2;}
   fdeffillall(z,flag2,CAMP,VERB, f1,f2, a,w,0L, flag, r,r,r,fffv->localuse.lu0.cachedloc=0,FAV(z)->localuse.lu1.linkvb=linktype);
   R z;
+
  }else ASSERT((AT(a)|AT(w))&VERB,EVDOMAIN)  // m&n not allowed
   // continuing must be m&v or u&n
   A va=AT(a)&VERB?a:w, na=AT(a)&VERB?w:a;
@@ -490,6 +491,9 @@ F2(jtamp){F2PREFIP;A h=0;AF f1,f2;B b;C c;I flag,flag2=0,linktype=0,mode=-1,p,r;
   p=FAV(va)->flag; flag=((p&(VJTFLGOK2|VIRS2))>>1)+(FAV(va)->flag&VASGSAFE);
   // the noun will be INCORPed by fdef
 
+  // take WILLOPEN/COUNT for the monad from the appropriate side of the dyadic verb.
+  flag2=((FAV(va)->flag2)>>(AT(a)&VERB?VF2WILLOPEN2AX-VF2WILLOPEN1X:VF2WILLOPEN2WX-VF2WILLOPEN1X))&(VF2WILLOPEN1|VF2USESITEMCOUNT1);
+
   // look for supported forms: comparison, i.-family, 128!:3.  But not if the arg is atomic or empty - no value in that
   if((-AN(na)&-AR(na))<0){  // noun is not atomic and not empty
    if(unlikely(b=c==CFIT)){c=FAV(FAV(va)->fgh[0])->id; p=FAV(FAV(va)->fgh[0])->flag;}  // if verb is u1!.n1, replace the id and flag with that of u1, and remember cct from n1
@@ -504,6 +508,7 @@ F2(jtamp){F2PREFIP;A h=0;AF f1,f2;B b;C c;I flag,flag2=0,linktype=0,mode=-1,p,r;
    }else if(unlikely(FAV(w)->valencefns[0]==jtcrc1)){RZ(h=crccompile(a)); f1=jtcrcfixedleft; flag&=~VJTFLGOK1; // m&128!:3
    }
   }
-  fdeffillall(z,0,CAMP,VERB, f1,with2, a,w,h, flag, RMAX,RMAX,RMAX,fffv->localuse.lu0.cachedloc=0,FAV(z)->localuse.lu1.cct=cct);
+
+  fdeffillall(z,flag2,CAMP,VERB, f1,with2, a,w,h, flag, RMAX,RMAX,RMAX,fffv->localuse.lu0.cachedloc=0,FAV(z)->localuse.lu1.cct=cct);
   R z;
 }

jsrc/cf.c

@@ -323,9 +323,15 @@ A jthook(J jt,A a,A w,A h){AF f1=0,f2=0;C c,d,e,id;I flag=VFLAGNONE,linktype=0;V
     case CFROM:   if(d==CGRADE){f2=jtordstati; flag &=~VJTFLGOK2;} else if(d==CTILDE&&e==CGRADE){f2=jtordstat; flag &=~VJTFLGOK2;}
     }
    }
-// scaf should inherit WILLOPEN/PROP from u and v
+
+   // Copy the open/raze status from u (for a) and v (for w) or both (for monad).  PROP is not needed, since (u ][) is silly.
+   // Since this status is a characteristic of the combined verb specs, it does not depend on the selection of f[12]
+   I flag2=((v->flag2&(VF2WILLOPEN1|VF2USESITEMCOUNT1))<<(VF2WILLOPEN2WX-VF2WILLOPEN1X)) |  // dyad w from v monad w
+             (u->flag2&(VF2WILLOPEN2A|VF2USESITEMCOUNT2A)) |    // dyad a from u dyad a
+             (v->flag2&(VF2WILLOPEN1|VF2USESITEMCOUNT1) & ((u->flag2&(VF2WILLOPEN2A|VF2USESITEMCOUNT2A))>>(VF2WILLOPEN2AX-VF2WILLOPEN1X))); // monad only if monad w AND dyad a
+
    // Return the derived verb
-   fdeffillall(z,0,CHOOK, VERB, f1,f2, a,w,0L, flag, RMAX,RMAX,RMAX,fffv->localuse.lu0.cachedloc=0,FAV(z)->localuse.lu1.linkvb=linktype)
+   fdeffillall(z,flag2,CHOOK, VERB, f1,f2, a,w,0L, flag, RMAX,RMAX,RMAX,fffv->localuse.lu0.cachedloc=0,FAV(z)->localuse.lu1.linkvb=linktype)
    R z;
   // All other cases produce a modifier unless they are immediately executable (V N or N/V A)
   }else{

jsrc/cip.c

@@ -227,8 +227,6 @@ typedef struct {
  I flgs;   // complex, triangular processing flags
  I nbigtasks[2];  // number of tasks using taskm[0]; number of tasks that are not in the shortened tail
  I4 taskm[2];  // number of rows in leading tasks, unshortened trailing tasks
-// obsolete  I nanerr; // nonzero whenever a nan was encountered; could indicate we should throw an error (_+__) or a case where we disagree with ieee (_*0)
-// scaf should deal with this case better; for the former case, should abort immediately (ideally siglonjmp or so but...); for the latter case, don't fall back to +/@(*"1 _), but rather recalculate the block with extra checks, maybe tell other threads about row/col containing inf/0
 } CACHEMMSTATE;
 #define OPHEIGHTX 2
 #define OPHEIGHT ((I)1<<OPHEIGHTX)  // height of outer-product block
@@ -260,10 +258,7 @@ static NOINLINE C cachedmmultx(J jt,void *ctx,UI4 ti){ CACHEMMSTATE *pd=ctx;
  // Small problems should use a multiplier that does not use full cacheblock.  For jobs, we make the decision for each task
  if(((((50-m)&(50-n)&(16-pstored)&((DCACHED_THRES-1)-m*n*pnom))|SGNIF(flgs,FLGCMPX))&SGNIFNOT(flgs,FLGWMINUSZX))>=0){  // blocked for small arrays in either dimension (after threading); not if CMP; force if WMINUSZ (can't be both)
   // blocked algorithm.  there is no size limit on the blocks
-// obsolete   I ok=blockedmmult(jt,av,wv,zv,m,n,pnom,pstored,flgs);  // blockedmult uses normal JE return of 0=error
   R blockedmmult(jt,av,wv,zv,m,n,pnom,pstored,flgs)?0:EVNAN;  // blockedmmult uses normal JE return of 0=error; we return job semantics, 0=OK
-// obsolete   if(unlikely(!ok))__atomic_fetch_add(&pd->nanerr,1,__ATOMIC_RELAXED);  //could be _fetch_or, but x86 has lock xadd
-// obsolete   R 0;  // scaf should return nonzero to abort if error
  }
 
  D c[(CACHEHEIGHT+1)*CACHEWIDTH + (CACHEHEIGHT+1)*OPHEIGHT*OPWIDTH*2 + 2*CACHELINESIZE/sizeof(D)];  // 2 in case complex
@@ -522,9 +517,7 @@ static NOINLINE C cachedmmultx(J jt,void *ctx,UI4 ti){ CACHEMMSTATE *pd=ctx;
    flgs&=~(FLGZFIRST|FLGZLAST);  // we have finished a 16x64 cache section.  That touched all the columns of z.  For the remaining sections we must accumulate into the z values.  If this was the last pass, clear that flag too, since we're finished
   }  // end of loop for each 16x64 section of w
  }  // end of loop for each 64-col slice of w
-// obsolete  if(unlikely(NANTEST))__atomic_fetch_add(&pd->nanerr,1,__ATOMIC_RELAXED);//could be _fetch_or, but x86 has lock xadd
  R unlikely(NANTEST)?EVNAN:0;  // return job semantics, 0=OK
-// obsolete  R 0;  // scaf should return nonzero to abort if error
 }
 // looping entry point for cached mmul
 // We split the input into products where the left arg has at most MAXAROWS rows.  This is to avoid overrunning L2 cache
@@ -562,7 +555,6 @@ I cachedmmult(J jt,D* av,D* wv,D* zv,I m,I n,I p,I flgs){
  CACHEMMSTATE ctx={.av=av,.wv=wv,.zv=zv,.m=m,.n=n,.p=p,.flgs=flgs,.nbigtasks={nfulltasks,nfulltasks+nremnant},.taskm={fulltasksize,endtasksize}};
    // number of full tasks, followed by number that have size 'endtasksize'.  Later tasks have size endtasksize-CACHEHEIGHT
  R !jtjobrun(jt,cachedmmultx,&ctx,nfulltasks+tailtasks,0);  // go run the tasks - default to threadpool 0.  Switch return from job semantice to JE error samantics - 0 if error, 1 if OK
-// obsolete  R !ctx.nanerr;
 }
 
 #else

jsrc/cx.c

@@ -155,10 +155,9 @@ static B jtforinit(J jt,CDATA*cv,A t){A x;C*s,*v;I k;
 // result is address of cv after stack popped
 static CDATA* jtunstackcv(J jt,CDATA*cv,I assignvirt){
  if(cv->w==CFOR){
-  if(cv->t){A svb;  // if for_xyz. that has processed forinit ...
+  if(cv->t){A svb;  // if for_xyz. that has processed forinit ...  svb=the virtual block for the item
    SYMORIGIN[cv->indexsym].flag&=~LREADONLY;  // set xyz_index is no longer readonly.  It is still available for inspection
    // If xyz still points to the virtual block, we must be exiting the loop early: the value must remain, so realize it
-   ;  // the virtual block for the item
    if(likely((svb=cv->item)!=0)){   // if the svb was allocated...
     if(unlikely(SYMORIGIN[cv->itemsym].val==svb)){A newb;   // svb was allocated, loop did not complete, and xyz has not been reassigned
      fa(svb);   // remove svb from itemsym.val.  Safe, because it can't be the last free
@@ -526,7 +525,7 @@ nextlinetcesx:;   // here when we have the next tcesx already loaded, possibly w
     tdv->trap=PUSHTRYSTK;
     // turn off debugging UNLESS there is a catchd; then keep on only if user set debug mode
     // if debugging is already off, it stays off
-    if(unlikely(jt->uflags.trace&TRACEDB)){jt->uflags.trace&=~TRACEDB; if((NPGpysfmtdl&16)&&isd)jt->uflags.trace|=TRACEDB1&(JT(jt,dbuser));}  // scaf avoid branches
+    if(unlikely(jt->uflags.trace&TRACEDB)){jt->uflags.trace&=~TRACEDB; if(unlikely(NPGpysfmtdl&(isd<<4)))jt->uflags.trace|=TRACEDB1&(JT(jt,dbuser));}  // isd&&(flag&16)
     // debugging is now off if we are trapping.  In that case, indicate that we are trapping errors, to prevent holding them for debug
     jt->emsgstate|=(~jt->uflags.trace&TRACEDB1)<<EMSGSTATETRAPPINGX;  // turn on trapping if not now debug
     // We allow verbose messages in case the catch. wants to display them.  This is different from u :: v
@@ -594,9 +593,10 @@ nextlinetcesx:;   // here when we have the next tcesx already loaded, possibly w
    tcesx&=~(32<<TCESXTYPEX);  // the flag for DOF is for the loop, but we are exiting, so turn off the flag
   case CENDSEL:
    // end. for select., and do. for for. after the last iteration, must pop the stack - just once
-   // Must rat() if the current result might be final result, in case it includes the variables we will delete in unstack
-   // (scaf this is no longer needed since names are not deleted but the result case is rare)
-   if(unlikely(!(tcesx&TCESXCECANT)))BZ(z=rat(z)); cv=unstackcv(cv,1);
+// obsolete    // Must rat() if the current result might be final result, in case it includes the variables we will delete in unstack
+// obsolete    // (this is no longer needed since names are not deleted but the result case is rare)
+// obsolete    if(unlikely(!(tcesx&TCESXCECANT)))BZ(z=rat(z)); 
+   cv=unstackcv(cv,1);  // This leaves xyz[_index] defined, so there is no need to rat() z
    if(FLAGGEDNOTRACE(tcesx)){--ic; goto dobblock;}  // if flagged (must be ENDSEL), NSI is bblock, go do it without reading
    ic=CWGO(cwsent,CNSTOREDCW,ic);    // continue at new location
    goto nextline;

jsrc/jt.h

@@ -404,15 +404,16 @@ typedef struct JSTstruct {
 // Cacheline 7: startup (scripts and deprecmsgs), essentially read-only
  C _cl7[0];
  A slist;            // boxed list of filenames used in right arg to 0!:, the entries made in sn field of L blocks are indexes into this.  AM has # valid entries
- A deprecex;  // list of INTs of messages not to display  // scaf could be a short mask
  I4 deprecct;  // number of deprecation  errors to display, -1 to emsg
  S startlock;        // lock for slist
+ US deprecex;  // bitmask of messages not to display
  // rest of cacheline used only in exceptional paths
+ US cachesizes[3];  // [0]: size of fastest cache  [1]: size of largest cache private to each core  [2]: size of largest cache shared by all cores, in multiples of 4KB
  C bx[11];               /* box drawing characters                          */
  UC disp[7];          // # different verb displays, followed by list thereof in order of display  could be 15 bits
- US cachesizes[3];  // [0]: size of fastest cache  [1]: size of largest cache private to each core  [2]: size of largest cache shared by all cores, in multiples of 4KB
  C oleop;            /* com flag to capture output                    */
  UC cstacktype;  /* cstackmin set during 0: jt init  1: passed in JSM  2: set in JDo  */
+// 6 bytes free
 #if PYXES || 1
  JOBQ (*jobqueue)[MAXTHREADPOOLS];     // one JOBQ block for each threadpool
  I filler7[1];

jsrc/jtype.h

@@ -531,7 +531,7 @@ typedef I SI;
 #define TRAVERSIBLE     (BOX|VERB|ADV|CONJ|RAT|XNUM|NAME|SYMB|SPARSE)
 // Allow recursive usecount in one of these types
 // A recursive block is flagged by having the recursible type bit copied into the AFLAG.  But note: the block is not recursible unless the same bit is set in both
-// the type and the flag, where something like (0$a:) + 0$0 might reuse an argument block and leave the flags showing boxed when the type is B01.  scaf should fix this?
+// the type and the flag, where something like (0$a:) + 0$0 might reuse an argument block and leave the flags showing boxed when the type is B01.
 // We know that any block that has been ra()d is recursive, and therefore that fa() can assume recursibility for any recursible type
 #define RECURSIBLE      (BOX|VERB|ADV|CONJ|RAT|XNUM|NAME|SYMB)  // sparse box not allowed
 // SYMB is TRAVERSIBLE so that fa() will call to free the symbols, and RECURSIBLE so that fanapop will pass the type-flag.  To ensure that a SYMB is always freed when
@@ -1219,7 +1219,7 @@ typedef struct {
 #define VF2WILLOPEN1X      4   // This verb will open y as its first act, or will discard y.  No boxed contents in y can appear in the result (they may be virtual).  Monad case only.  This becomes the WILLBEOPENED flag in jt
 #define VF2WILLOPEN1       ((I)(((I)1)<<VF2WILLOPEN1X))
 // must leave a gap for WILLBEOPENED in result.h
-// 6 free
+// 5-6 free
 // next flag must be same as JTCOUNTITEMS
 #define VF2USESITEMCOUNT1X 7   // This verb can make use of an item count stored in m.  Monad case only
 #define VF2USESITEMCOUNT1  ((I)(((I)1)<<VF2USESITEMCOUNT1X))
@@ -1251,10 +1251,10 @@ typedef struct {
 #define VF2WILLOPEN2A       ((I)(((I)1)<<VF2WILLOPEN2AX))
 #define VF2USESITEMCOUNT2WX 19   // This verb can make use of an item count stored in m.  This becomes the COUNTITEMS flag in jt
 #define VF2USESITEMCOUNT2W  ((I)(((I)1)<<VF2USESITEMCOUNT2WX))
-#define VF2USESITEMCOUNT2AX 21   // This verb can make use of an item count stored in m.  This becomes the COUNTITEMS flag in jt
-#define VF2USESITEMCOUNT2A  ((I)(((I)1)<<VF2USESITEMCOUNT2AX))
 #define VF2IMPLOCX 20   // This verb is one of u. v.
 #define VF2IMPLOC  ((I)(((I)1)<<VF2IMPLOCX))
+#define VF2USESITEMCOUNT2AX 21   // This verb can make use of an item count stored in m.  This becomes the COUNTITEMS flag in jt
+#define VF2USESITEMCOUNT2A  ((I)(((I)1)<<VF2USESITEMCOUNT2AX))
 #define VF2CACHEABLEX 21   // In a nameref, indicates the nameref is cacheable
 #define VF2CACHEABLE  ((I)(((I)1)<<VF2CACHEABLEX))
 #define VF2PRIMX 22   // Set in primitive ACV

jsrc/sc.c

@@ -83,11 +83,11 @@ DF2(jtunquote){A z;
      }
      fs=jtsyrd1((J)((I)jt+NAV(thisname)->m),NAV(thisname)->s,NAV(thisname)->hash,explocale);  // Look up the name starting in the locale of the locative
     }else{  // u./v.  We have to look at the assigned name/value to know whether this is an implied locative (it usually is)
-     if(fs=jtprobe((J)((I)jt+NAV(thisname)->m),NAV(thisname)->s,NAV(thisname)->hash,jt->locsyms)){  // look only in local symbols
+     if(likely((fs=jtprobe((J)((I)jt+NAV(thisname)->m),NAV(thisname)->s,NAV(thisname)->hash,jt->locsyms))!=0)){  // look only in local symbols
       // u/v, assigned by xdefn.  Implied locative.  Switch locals and globals to caller's environment
       jt->locsyms=(A)AM(jt->locsyms); explocale=AKGST(jt->locsyms);  // move to new locals and their globals (up the local-sym chain)
       raposlocal(QCWORD(fs),fs);   // incr usecount to match what syrd1 does
-     }
+     }else explocale=jt->global;  // explocale must be defined for flgd0cpC
     }
     flgd0cpC|=((explocale!=jt->global)&~(LXAV0(explocale)[SYMLEXECCT]>>EXECCTPERMX))<<FLGLOCINCRDECRX;  // remember that there is a change of locale to non-PERMANENT
     SYMSETGLOBAL(explocale);   // switch to the (possibly new) locale.  We DO NOT change AKGST because if we are calling a non-operator modifier we need the old locale if the modifier calls u./v. .
@@ -101,7 +101,6 @@ DF2(jtunquote){A z;
    // ** as of here we know there is a value for the name, and it has been ra()d.  We must not take an error exit without fa
    ASSERTSUFF(PARTOFSPEECHEQACV(AT(self),AT(fs)),EVDOMAIN,z=0; fa(fs); goto exitname;);   // make sure its part of speech has not changed since the name was parsed; if error must use general fa
    // if this reference allows caching (lI4[0]<0), save the value if it comes from a cachable source, and attach the primitive block to the name
-   // we have to wait till here to 
    if(unlikely((FAV(self)->flag2>>(VF2CACHEABLEX-QCNAMEDX))&namedloc)){   // cacheable nameref, and value found in a named locale
     thisname=jt->curname;  // refresh thisname
     // the nameref is cachable.  Fill it in.  Happens the first time a cachable reference is encountered.

jsrc/vo.c

@@ -684,7 +684,8 @@ F1(jtraze){A*v,y,z;C* RESTRICT zu;I *wws,d,i,klg,m=0,n,r=1,t=0,te=0;
   GA(z,t,m*nitems,r,wws); AS(z)[0]=nitems; // allocate the result area; finish shape
   zu=CAV(z); klg=bplg(t); // input pointers, depending on type; length of an item
   // loop through the boxes copying the data into sequential output positions.  pyx impossible
-  DO(n, y=v[i]; d=AN(y)<<klg; MC(zu,AV(y),d); zu+=d;)   // scaf use JMC
+// obsolete   DO(n, y=v[i]; d=AN(y)<<klg; MC(zu,AV(y),d); zu+=d;)
+  DO(n, y=v[i]; d=AN(y)<<klg; JMC(zu,AV(y),d,0); zu+=d;)   // copy the items
  }
 
  RETF(z);

jsrc/x.c

@@ -286,9 +286,6 @@ void jtforeigninit(J jt){UI i;
  MN(9,57)  XPRIM(VERB, jtaudittdisab, 0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(9,58)  XPRIM(VERB, jtgemmtune, jtgemmtune2,    VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(9,59)  XPRIM(VERB, jtemsglevel, 0,    VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
- MN(9,60)  XPRIM(VERB, jtleakblockread, 0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
- MN(9,61)  XPRIM(VERB, jtleakblockreset, 0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
- MN(9,63)  XPRIM(VERB, jtshowinplacing1, jtshowinplacing2,  VASGSAFE|VJTFLGOK1|VJTFLGOK2,VF2NONE,RMAX,RMAX,RMAX);
  MN(9,66)  XPRIM(VERB, jtcheckcompfeatures, 0,  VASGSAFE,VF2NONE,RMAX,RMAX,RMAX);
  MN(13,0)  XPRIM(VERB, jtdbc,        0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(13,1)  XPRIM(VERB, jtdbstack,    0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
@@ -346,12 +343,15 @@ void jtforeigninit(J jt){UI i;
  MN(128,8) XPRIM(VERB, jtqhash12,    jtqhash12,    VASGSAFE|VJTFLGOK1|VJTFLGOK2,VF2NONE,RMAX,RMAX,RMAX);  
  MN(128,10) XPRIM(VERB, jtludecomp,   jtludecomp,     VASGSAFE,VF2NONE,RMAX,   RMAX,RMAX);
  MN(18,6)  XPRIM(VERB, jtresetbloom,    0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
-#if 0  // withdrawn
+#if 0  // obsolete 
  MN(18,7)  XPRIM(VERB, jtsetpermanent,    0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
 #endif
 
  MN(0,-1) XPRIM(VERB, jtskipinscript,            0, VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(5,-1)  XPRIM(VERB, 0,            jtoutstr,     VASGSAFE,VF2NONE,RMAX,RMAX,RMAX);
+ MN(9,-1)  XPRIM(VERB, jtleakblockread, 0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
+ MN(9,-2)  XPRIM(VERB, jtleakblockreset, 0,            VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
+ MN(9,-3)  XPRIM(VERB, jtshowinplacing1, jtshowinplacing2,  VASGSAFE|VJTFLGOK1|VJTFLGOK2,VF2NONE,RMAX,RMAX,RMAX);
  MN(13,-1) XPRIM(VERB, 0,            jtfindrange,  VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(13,-2) XPRIM(VERB, 0,            jtfindrange4, VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);
  MN(13,-3) XPRIM(VERB, 0,            jtfindrange2, VFLAGNONE,VF2NONE,RMAX,RMAX,RMAX);