Continue converting calls & removing macros

Author: juntuu

jsrc/adverbs/a.c

@@ -40,7 +40,7 @@ jtswap(J jt, A w) {
         I flag = FAV(w)->flag & (VIRS2 | VJTFLGOK2);
         flag   = (FAV(w)->flag & VASGSAFE) + flag +
                (flag >> 1);  // set ASGSAFE, both inplace/irs bits from dyad; ISATOMIC immaterial, since always dyad
-        return fdef(0, CTILDE, VERB, (AF)(swap1), (AF)(swap2), w, 0L, 0L, flag, (I)(RMAX), (I)(rr(w)), (I)(lr(w)));
+        return jtfdef(jt, 0, CTILDE, VERB, (AF)(swap1), (AF)(swap2), w, 0L, 0L, flag, (I)(RMAX), (I)(rr(w)), (I)(lr(w)));
     } else {
         // evoke.  Ii must be LIT and convertible to ASCII.
         if ((C2T + C4T) & AT(w)) RZ(w = jtcvt(jt, LIT, w)) else ASSERT(LIT & AT(w), EVDOMAIN);
@@ -116,15 +116,15 @@ jtbdot(J jt, A w) {
         memcpy(AV(b), booltab, 64L);
         RZ(h = jtrifvs(jt, jtcant2(jt, IX(AR(w)), jtfrom(jt, w, b))));  // h is an array representing b.  One cell for
                                                                         // each atom of b; cell is 4 values
-        return fdef(0, CBDOT, VERB, jtbdot1, jtbdot2, 0L, w, h, VFLAGNONE, RMAX, 0L, 0L);
+        return jtfdef(jt, 0, CBDOT, VERB, jtbdot1, jtbdot2, 0L, w, h, VFLAGNONE, RMAX, 0L, 0L);
     } else
         switch (j) {
             case 32:
-                return fdef(0, CBDOT, VERB, jtbitwise1, jtbitwiserotate, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
+                return jtfdef(jt, 0, CBDOT, VERB, jtbitwise1, jtbitwiserotate, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
             case 33:
-                return fdef(0, CBDOT, VERB, jtbitwise1, jtbitwiseshift, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
+                return jtfdef(jt, 0, CBDOT, VERB, jtbitwise1, jtbitwiseshift, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
             case 34:
-                return fdef(0, CBDOT, VERB, jtbitwise1, jtbitwiseshifta, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
+                return jtfdef(jt, 0, CBDOT, VERB, jtbitwise1, jtbitwiseshifta, 0L, w, 0L, VASGSAFE | VJTFLGOK2, 0L, 0L, 0L);
             // The code uses a VERB with id CBDOT to stand for the derived verb of m b. .  This is used for spellout and
             // for inverses, so we retain it. We copy the other information from the verb that executes the function.
             // This contains pointers to the routines, and to the function table
@@ -300,7 +300,7 @@ jtmemo(J jt, A w) {
     RZ(hv[1] = jtmkwris(jt, q));
     GATV0(q, BOX, m, 1);
     hv[2] = q;
-    EPILOG(fdef(0, CMCAP, VERB, jtmemo1, jtmemo2, w, 0L, h, 0L, v->mr, lrv(v), rrv(v)));
+    EPILOG(jtfdef(jt, 0, CMCAP, VERB, jtmemo1, jtmemo2, w, 0L, h, 0L, v->mr, lrv(v), rrv(v)));
     // Now we have converted the verb result to recursive usecount, and gotten rid of the pending tpops for the
     // components of h
 }

jsrc/adverbs/a.h

@@ -98,9 +98,9 @@
     }
 
 #define ADERIV(id, f1, f2, flag, m, l, r) \
-    fdef(0, id, VERB, (AF)(f1), (AF)(f2), w, 0L, 0L, (flag), (I)(m), (I)(l), (I)(r))
+    jtfdef(jt, 0, id, VERB, (AF)(f1), (AF)(f2), w, 0L, 0L, (flag), (I)(m), (I)(l), (I)(r))
 #define CDERIV(id, f1, f2, flag, m, l, r) \
-    fdef(0, id, VERB, (AF)(f1), (AF)(f2), a, w, 0L, (flag), (I)(m), (I)(l), (I)(r))
+    jtfdef(jt, 0, id, VERB, (AF)(f1), (AF)(f2), a, w, 0L, (flag), (I)(m), (I)(l), (I)(r))
 
 #define ASSERTVV(a, w) ASSERT(VERB& AT(a) & AT(w), EVDOMAIN)
 #define ASSERTVVn(a, w) ASSERT(VERB& AT(a), EVDOMAIN)

jsrc/adverbs/ai.c

@@ -262,11 +262,11 @@ jtinvamp(J jt, A w) {
         case CFIT:
             ASSERT(nf && (CPOUND == ID(FAV(g)->fgh[0])), EVDOMAIN);
             ASSERT(1 == AR(x), EVRANK);
-            return fdef(0, CPOWOP, VERB, jtexpandg, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, 0L, 0L);
+            return jtfdef(jt, 0, CPOWOP, VERB, jtexpandg, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, 0L, 0L);
         case CPOUND:
             ASSERT(nf != 0, EVDOMAIN);
             ASSERT(1 == AR(x), EVRANK);
-            return fdef(0, CPOWOP, VERB, jtexpandf, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, 0L, 0L);
+            return jtfdef(jt, 0, CPOWOP, VERB, jtexpandf, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, 0L, 0L);
             break;
         case CPOWOP:
             if (VGERL & u->flag) {
@@ -409,8 +409,8 @@ jtinv(J jt, A w, I recur) {
         case CBANG:
             return jteval(jt, "3 : '(-(y -~ !)%0.001&* (0.001%~[:-/[:! 0.001 0 +/ ]) ])^:_<.&170^:(-:+)^.y' :. !");
         case CXCO: return jtamp(jt, num(-1), w);
-        case CSPARSE: return fdef(0, CPOWOP, VERB, jtdenseit, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, RMAX, RMAX);
-        case CPCO: return fdef(0, CPOWOP, VERB, jtplt, 0L, w, num(-1), 0L, 0L, 0L, 0L, 0L);
+        case CSPARSE: return jtfdef(jt, 0, CPOWOP, VERB, jtdenseit, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, RMAX, RMAX);
+        case CPCO: return jtfdef(jt, 0, CPOWOP, VERB, jtplt, 0L, w, num(-1), 0L, 0L, 0L, 0L, 0L);
         case CQCO: return jteval(jt, "*/");
         case CUCO: return jtamp(jt, num(3), w);
         case CUNDER: return jtunder(jt, invrecur(f), g);
@@ -472,7 +472,7 @@ jtinv(J jt, A w, I recur) {
             break;
         case CCUT:
             if (CBOX == ID(f) && ng && (p = jti0(jt, g), 1 == p || 2 == p))
-                return fdef(0, CPOWOP, VERB, jtbminv, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, RMAX, RMAX);
+                return jtfdef(jt, 0, CPOWOP, VERB, jtbminv, 0L, w, num(-1), 0L, VFLAGNONE, RMAX, RMAX, RMAX);
             break;
         case CIBEAM:
             p = jti0(jt, f);

jsrc/adverbs/ao.c

@@ -1452,5 +1452,5 @@ jtsldot(J jt, A w) {
             // otherwise (including keymean) fall through to...
         default: f2 = jtkey; flag |= (FAV(w)->flag & VASGSAFE);  // pass through ASGSAFE.
     }
-    return fdef(0, CSLDOT, VERB, f1, f2, w, 0L, h, flag, RMAX, RMAX, RMAX);
+    return jtfdef(jt, 0, CSLDOT, VERB, f1, f2, w, 0L, h, flag, RMAX, RMAX, RMAX);
 }

jsrc/adverbs/ap.c

@@ -1449,7 +1449,7 @@ jtbslash(J jt, A w) {
     ;
     if (!w) return 0;
     if (NOUN & AT(w))
-        return fdef(
+        return jtfdef(jt, 
           0, CBSLASH, VERB, jtinfixprefix1, jtinfixprefix2, w, 0L, jtfxeachv(jt, 1L, w), VGERL | flag, RMAX, 0L, RMAX);
     v = FAV(w);  // v is the u in u\ y
     switch (v->id) {

jsrc/adverbs/ar.c

@@ -1091,7 +1091,7 @@ jtslash(J jt, A w) {
             break;  // monad is inplaceable if the dyad for u is
     }
     RZ(h = jtqq(jt, w, jtv2(jt, lr(w), RMAX)));  // create the rank compound to use if dyad
-    RZ(h = fdef(0, CSLASH, VERB, f1, jtoprod, w, 0L, h, flag | FAV(ds(CSLASH))->flag, RMAX, RMAX, RMAX));
+    RZ(h = jtfdef(jt, 0, CSLASH, VERB, f1, jtoprod, w, 0L, h, flag | FAV(ds(CSLASH))->flag, RMAX, RMAX, RMAX));
     // set lvp[1] to point to the VARPSA block for w if w is atomic dyad; otherwise to the null VARPSA block
     FAV(h)->localuse.lvp[1] = v->flag & VISATOMIC2 ? ((VA*)v->localuse.lvp[0])->rps : &rpsnull;
     return h;

jsrc/adverbs/as.c

@@ -595,7 +595,7 @@ jtbsdot(J jt, A w) {
     C id;
     V* v;  // init flag is IRS1
     if (NOUN & AT(w))
-        return fdef(0,
+        return jtfdef(jt, 0,
                     CBSLASH,
                     VERB,
                     jtgsuffix,

jsrc/adverbs/au.c

@@ -47,7 +47,7 @@ jtself2(J jt, A a, A w) {
 
 A
 jtac2(J jt, AF f) {
-    return fdef(0, 0, VERB, 0L, f, 0L, 0L, 0L, VFLAGNONE, RMAX, RMAX, RMAX);
+    return jtfdef(jt, 0, 0, VERB, 0L, f, 0L, 0L, 0L, VFLAGNONE, RMAX, RMAX, RMAX);
 }
 
 A

jsrc/conjunctions/ca.c

@@ -271,14 +271,14 @@ jtatop(J jt, A a, A w) {
                 AT(w) |= LIT;
             }
         }
-        return fdef(0, CAT, VERB, onconst1, onconst2, a, w, h, VFLAGNONE, RMAX, RMAX, RMAX);
+        return jtfdef(jt, 0, CAT, VERB, onconst1, onconst2, a, w, h, VFLAGNONE, RMAX, RMAX, RMAX);
     }
     wv = FAV(w);
     d  = wv->id;
     if ((d & ~1) == CLEFT) {
         // the very common case u@] and u@[.  Take ASGSAFE and inplaceability from u.  No IRS.  Vector the monad
         // straight to u; vector the dyad to our routine that shuffles args and inplace bits
-        return fdef(0,
+        return jtfdef(jt, 0,
                     CAT,
                     VERB,
                     onright1,
@@ -471,7 +471,7 @@ jtatop(J jt, A a, A w) {
         }
     }
 
-    return fdef(flag2, CAT, VERB, f1, f2, a, w, h, flag, (I)wv->mr, (I)lrv(wv), rrv(wv));
+    return jtfdef(jt, flag2, CAT, VERB, f1, f2, a, w, h, flag, (I)wv->mr, (I)lrv(wv), rrv(wv));
 }
 
 // u@:v
@@ -493,7 +493,7 @@ jtatco(J jt, A a, A w) {
     if ((d & ~1) == CLEFT) {
         // the very common case u@:] and u@:[.  Take ASGSAFE and inplaceability from u.  No IRS.  Vector the monad
         // straight to u; vector the dyad to our routine that shuffles args and inplace bits
-        return fdef(0,
+        return jtfdef(jt, 0,
                     CATCO,
                     VERB,
                     onright1,
@@ -638,7 +638,7 @@ jtatco(J jt, A a, A w) {
     flag2 |= wv->flag2 & (VF2WILLOPEN1 | VF2WILLOPEN2W | VF2WILLOPEN2A | VF2USESITEMCOUNT1 | VF2USESITEMCOUNT2W |
                           VF2USESITEMCOUNT2A);
 
-    return fdef(flag2, CATCO, VERB, f1, f2, a, w, 0L, flag, RMAX, RMAX, RMAX);
+    return jtfdef(jt, flag2, CATCO, VERB, f1, f2, a, w, 0L, flag, RMAX, RMAX, RMAX);
 }
 
 // u&:v
@@ -693,7 +693,7 @@ jtampco(J jt, A a, A w) {
     flag2 |= (f1 == on1cell) << VF2RANKATOP1X;
     flag2 |= VF2RANKATOP2;
     A z;
-    RZ(z = fdef(flag2, CAMPCO, VERB, f1, f2, a, w, 0L, flag, RMAX, RMAX, RMAX));
+    RZ(z = jtfdef(jt, flag2, CAMPCO, VERB, f1, f2, a, w, 0L, flag, RMAX, RMAX, RMAX));
     FAV(z)->localuse.lclr[0] = linktype;
     return z;
 }
@@ -822,7 +822,7 @@ jtamp(J jt, A a, A w) {
                             flag &= ~VJTFLGOK1;
                         }
                 }
-            return fdef(0, CAMP, VERB, f1, with2, a, w, h, flag, RMAX, RMAX, RMAX);
+            return jtfdef(jt, 0, CAMP, VERB, f1, with2, a, w, h, flag, RMAX, RMAX, RMAX);
         case VN:
             f1 = withr;
             v  = FAV(a);
@@ -862,7 +862,7 @@ jtamp(J jt, A a, A w) {
                     flag &= ~VJTFLGOK1;
                 }
             }
-            return fdef(0, CAMP, VERB, f1, with2, a, w, h, flag, RMAX, RMAX, RMAX);
+            return jtfdef(jt, 0, CAMP, VERB, f1, with2, a, w, h, flag, RMAX, RMAX, RMAX);
         case VV:
             // u&v
             f1 = on1;
@@ -963,7 +963,7 @@ jtamp(J jt, A a, A w) {
                 }
             }
             A z;
-            RZ(z = fdef(flag2, CAMP, VERB, f1, f2, a, w, 0L, flag, r, r, r));
+            RZ(z = jtfdef(jt, flag2, CAMP, VERB, f1, f2, a, w, 0L, flag, r, r, r));
             FAV(z)->localuse.lclr[0] = linktype;
             return z;
     }

jsrc/conjunctions/cc.c

@@ -1951,24 +1951,24 @@ jtcut(J jt, A a, A w) {
     switch (k) {
         case 0:
             if (FAV(a)->id == CBOX) {  // <;.0
-                RZ(z = fdef(0, CCUT, VERB, jtcut01, jtboxcut0, a, w, h, flag | VJTFLGOK2, RMAX, 2L, RMAX));
+                RZ(z = jtfdef(jt, 0, CCUT, VERB, jtcut01, jtboxcut0, a, w, h, flag | VJTFLGOK2, RMAX, 2L, RMAX));
                 FAV(z)->localuse.lpf.parm = ~0;
                 FAV(z)->localuse.lpf.func = jtcut02;  // store parms to specify start/len format
                 return z;
             }
-            z = fdef(0, CCUT, VERB, jtcut01, jtcut02, a, w, h, flag | VJTFLGOK2, RMAX, 2L, RMAX);
+            z = jtfdef(jt, 0, CCUT, VERB, jtcut01, jtcut02, a, w, h, flag | VJTFLGOK2, RMAX, 2L, RMAX);
             break;
         case 1:
         case -1:
         case 2:
         case -2:
             if (!(NOUN & AT(a))) flag = VJTFLGOK2 + VJTFLGOK1;
-            z = fdef(0, CCUT, VERB, jtcut1, jtcut2, a, w, h, flag, RMAX, 1L, RMAX);
+            z = jtfdef(jt, 0, CCUT, VERB, jtcut1, jtcut2, a, w, h, flag, RMAX, 1L, RMAX);
             break;
         case 3:
         case -3:
         case 259:
-        case -259: z = fdef(0, CCUT, VERB, jttess1, jttess2, a, w, h, flag, RMAX, 2L, RMAX); break;
+        case -259: z = jtfdef(jt, 0, CCUT, VERB, jttess1, jttess2, a, w, h, flag, RMAX, 2L, RMAX); break;
         default: ASSERT(0, EVDOMAIN);
     }
     RZ(z);