Merge pull request #178 from herwinw/extract_bool

Refactor Bnum lookups

Author: codereport

jsrc/adverbs/a.c

@@ -65,7 +65,7 @@ jtbdot2(J jt, A a, A w, A self) {
 
 static A
 jtbdot1(J jt, A w, A self) {
-    return jtbdot2(jt, num(0), w, self);
+    return jtbdot2(jt, jfalse, w, self);
 }
 
 static A

jsrc/adverbs/ab.c

@@ -162,7 +162,7 @@ BITWISE(jtbitwiseshifta, I, BWSHIFTA)
 
 A
 jtbitwise1(J jt, A w, A self) {
-    return CALL2(FAV(self)->valencefns[1], zeroionei(0), w, self);
+    return CALL2(FAV(self)->valencefns[1], num(0), w, self);
 }  // inplaceable - don't touch jt
 
 static AHDR2FN* bwC[16] = {(AHDR2FN*)bw0000CC,

jsrc/adverbs/af.c

@@ -248,7 +248,7 @@ jtfixa(J jt, A a, A w) {
     }
 } /* 0=a if fix names; 1=a if fix names only if does not contain $: */
 
-// On internal calls, self is an integer whose value contains flags.  Otherwise zeroionei is used
+// On internal calls, self is an integer whose value contains flags.  Otherwise num is used
 A
 jtfix(J jt, A w, A self) {
     PROLOG(0005);
@@ -259,7 +259,7 @@ jtfix(J jt, A w, A self) {
     }
     // only verbs/noun can get in through the parser, but internally we also vet adv/conj
     ASSERT(AT(w) & NAME + VERB + ADV + CONJ, EVDOMAIN);
-    self = AT(self) & NOUN ? self : zeroionei(0);  // default to 0 if noun not given
+    self = AT(self) & NOUN ? self : num(0);  // default to 0 if noun not given
     // To avoid infinite recursion we keep an array of names that we have looked up.  We create that array here,
     // initialized to empty.  To pass it into fixa, we create a faux INT block to hold the value, and use AM in that
     // block to point to the list of names

jsrc/adverbs/ai.c

@@ -52,7 +52,7 @@ jtinvfork(J jt, A w) {
     c = 1 && NOUN & AT(f);
     b = c || consf(f);
     ASSERT(b != consf(h), EVDOMAIN);
-    RZ(k = c ? f : df1(gi, num(0), b ? f : h));
+    RZ(k = c ? f : df1(gi, jfalse, b ? f : h));
     RZ(gi = invrecur(b ? jtamp(jt, k, g) : jtamp(jt, g, k)));
     RZ(fi = invrecur(b ? h : f));
     if (CAMP == ID(gi)) {
@@ -117,7 +117,7 @@ jtbminv(J jt, A w) {
     ws = AS(w);
     wv = AAV(w);
     if (1 >= wr) return jtraze(jt, w);
-    if (!wn) return jtiota(jt, jtreshape(jt, jtsc(jt, wr), num(0)));
+    if (!wn) return jtiota(jt, jtreshape(jt, jtsc(jt, wr), jfalse));
     GATV0(x, INT, wr, 1);
     u = AV(x);
     memset(u, C0, wr * SZI);
@@ -256,7 +256,7 @@ jtinvamp(J jt, A w) {
         case CQCO:
             if (nf) {
                 ASSERT(!AR(x), EVRANK);
-                return jtobverse(jt, jteval(jt, all1(lt(x, zeroionei(0))) ? "*/@(^/)\"2" : "(p:@i.@# */ .^ ])\"1"), w);
+                return jtobverse(jt, jteval(jt, all1(lt(x, num(0))) ? "*/@(^/)\"2" : "(p:@i.@# */ .^ ])\"1"), w);
             }
             break;
         case CFIT:
@@ -310,7 +310,7 @@ jtinvamp(J jt, A w) {
             }
             break;
         case CQQ:
-            if (ng && jtequ(jt, x, num(1)) && jtequ(jt, f, jteval(jt, "i.\"1"))) return jthook(jt, ds(CFROM), ds(CEQ));
+            if (ng && jtequ(jt, x, jtrue) && jtequ(jt, f, jteval(jt, "i.\"1"))) return jthook(jt, ds(CFROM), ds(CEQ));
             break;
         case CBSLASH:
             if (nf && (n = jti0(jt, x), 0 > n) && (d = ID(u->fgh[0]), (d & -2) == CLEFT))
@@ -351,7 +351,7 @@ jtinvamp(J jt, A w) {
             break;
         case CPOLY:
             if (nf && 1 == AR(x) && 2 == AN(x) && NUMERIC & AT(x) &&
-                !jtequ(jt, zeroionei(0), jttail(jt, x))) {  // linear polynomial only
+                !jtequ(jt, num(0), jttail(jt, x))) {  // linear polynomial only
                 RZ(y = jtrecip(jt, jttail(jt, x)));
                 return jtamp(jt, apip(tymes(y, jtnegate(jt, jthead(jt, x))), y), h);
             }
@@ -478,7 +478,7 @@ jtinv(J jt, A w, I recur) {
             p = jti0(jt, f);
             q = jti0(jt, g);
             if (3 == p && 1 == q) return jtforeign(jt, f, num(2));
-            if (3 == p && 2 == q) return jtforeign(jt, f, num(1));
+            if (3 == p && 2 == q) return jtforeign(jt, f, jtrue);
             if (3 == p && 3 == q) return jtforeign(jt, f, num(2));
             break;
         case CHOOK:
@@ -489,7 +489,7 @@ jtinv(J jt, A w, I recur) {
     // But only fix once, at the top recursion level, (1) to avoid an infinite loop if
     // there is a circular reference that leaves names in the fixed form of w; (2) to avoid
     // repeated fixing of lower branches, which will only be tried again when higher levels are fixed
-    if (!recur && !nameless(w)) return invrecur(jtfix(jt, w, zeroionei(0)));
+    if (!recur && !nameless(w)) return invrecur(jtfix(jt, w, num(0)));
     ASSERT(0, EVDOMAIN);
 }
 
@@ -509,14 +509,14 @@ jtneutral(J jt, A w) {
     b = jtequ(jt, y, CALL2(v->valencefns[1], x, y, w));
     RESETERR;
     if (b) return x;
-    x = zeroionei(0);
+    x = num(0);
     b = jtequ(jt, y, CALL2(v->valencefns[1], x, y, w));
     RESETERR;
-    if (b) return num(0);
-    x = zeroionei(1);
+    if (b) return jfalse;
+    x = num(1);
     b = jtequ(jt, y, CALL2(v->valencefns[1], x, y, w));
     RESETERR;
-    if (b) return num(1);
+    if (b) return jtrue;
     RZ(x = jtscf(jt, infm));
     b = jtequ(jt, y, CALL2(v->valencefns[1], y, x, w));
     RESETERR;
@@ -525,22 +525,22 @@ jtneutral(J jt, A w) {
     b = jtequ(jt, y, CALL2(v->valencefns[1], y, x, w));
     RESETERR;
     if (b) return x;
-    x = zeroionei(0);
+    x = num(0);
     b = jtequ(jt, y, CALL2(v->valencefns[1], y, x, w));
     RESETERR;
-    if (b) return num(0);
-    x = zeroionei(1);
+    if (b) return jfalse;
+    x = num(1);
     b = jtequ(jt, y, CALL2(v->valencefns[1], y, x, w));
     RESETERR;
-    if (b) return num(1);
+    if (b) return jtrue;
     ASSERT(0, EVDOMAIN);
 } /* neutral of arbitrary rank-0 function */
 
 A
 jtiden(J jt, A w) {
     A f, g, x = 0;
     V *u, *v;
-    RZ(w = jtfix(jt, w, zeroionei(0)));
+    RZ(w = jtfix(jt, w, num(0)));
     ASSERT(VERB & AT(w), EVDOMAIN);
     v = FAV(w);
     f = v->fgh[0];
@@ -565,7 +565,7 @@ jtiden(J jt, A w) {
         case CLT:
         case CPLUSDOT:
         case CJDOT:
-        case CRDOT: x = num(0); break;
+        case CRDOT: x = jfalse; break;
         case CSTAR:
         case CDIV:
         case CEXP:
@@ -574,7 +574,7 @@ jtiden(J jt, A w) {
         case CEQ:
         case CGE:
         case CLE:
-        case CSTARDOT: x = num(1); break;
+        case CSTARDOT: x = jtrue; break;
         case CMAX: x = jtscf(jt, infm); break;
         case CMIN: x = ainf; break;
         case CUNDER:;
@@ -585,8 +585,8 @@ jtiden(J jt, A w) {
             if (CAMP == ID(f) && (u = FAV(f), NOUN & AT(u->fgh[0]) && !AR(u->fgh[0]) && CSTILE == ID(u->fgh[1])))
                 switch (ID(g)) {
                     case CSTAR:
-                    case CEXP: x = num(1); break;
-                    case CPLUS: x = num(0);
+                    case CEXP: x = jtrue; break;
+                    case CPLUS: x = jfalse;
                 }
             break;
         case CBDOT:;  // canned inverses for (bt b.)
@@ -599,7 +599,7 @@ jtiden(J jt, A w) {
                 bi = -1;
                 bi = INV0 & (1LL << bt) ? 0 : bi;
                 bi = INV1 & (1LL << bt) ? 1 : bi;
-                x  = num(bi);
+                x  = numbool(bi);
             }
             break;
     }
@@ -611,7 +611,7 @@ A
 jtidensb(J jt, A w) {
     A f, g, x = 0, w0 = w;
     V* v;
-    RZ(w = jtfix(jt, w, zeroionei(0)));
+    RZ(w = jtfix(jt, w, num(0)));
     ASSERT(VERB & AT(w), EVDOMAIN);
     v = FAV(w);
     f = v->fgh[0];

jsrc/adverbs/am.c

@@ -431,7 +431,7 @@ jtjstd(J jt, A w, A ind, I *cellframelen) {
     ws = AS(w);
     b  = -AN(ind) & SGNIF(AT(ind), BOXX);  // b<0 = indexes are boxed and nonempty
     if (!wr) {
-        x             = jtfrom(jt, ind, zeroionei(0));
+        x             = jtfrom(jt, ind, num(0));
         *cellframelen = 0;
         return x;
     }                                // if w is an atom, the best you can get is indexes of 0.  No axes are used
@@ -466,7 +466,7 @@ jtjstd(J jt, A w, A ind, I *cellframelen) {
         ASSERT(1 >= r, EVINDEX);                             // not a table
         ASSERT(n <= wr, EVINDEX);                            // not too many axes
         DQ(n, if (!jtequ(jt, ds(CACE), v[i])) break; --n;);  // discard trailing (boxed) empty axes
-        j = zeroionei(0);                                    // init list to a single 0 offset
+        j = num(0);                                          // init list to a single 0 offset
         for (i = 0; i < n; ++i) {  // for each axis, grow the cartesian product of the specified offsets
             x = v[i];
             d = ws[i];

jsrc/adverbs/am1.c

@@ -257,7 +257,7 @@ jtscube(J jt, A z, A i1, A p) {
     zp = PAV(z);
     a  = SPA(zp, a);
     y  = SPA(zp, i);
-    return !AN(a) && !*AS(y) ? jttake(jt, num(1), mtm) : jtover(jt, jtscubb(jt, z, i1), jtscubc(jt, z, i1, p));
+    return !AN(a) && !*AS(y) ? jttake(jt, jtrue, mtm) : jtover(jt, jtscubb(jt, z, i1), jtscubc(jt, z, i1, p));
 } /* new rows for the index matrix of z */
 
 static A

jsrc/adverbs/ao.c

@@ -277,9 +277,9 @@ jtkeysp(J jt, A a, A w, A self) {
     *AS(q) = n; /* q=: 0 by}1$.n;0;1 */
     p      = PAV(q);
     SPB(p, a, iv0);
-    SPB(p, e, num(1));
+    SPB(p, e, jtrue);
     SPB(p, i, by);
-    SPB(p, x, jtreshape(jt, tally(jt, by), num(0)));
+    SPB(p, x, jtreshape(jt, tally(jt, by), jfalse));
     RZ(z = jtover(jt, df1(b, jtrepeat(jt, q, w), VAV(self)->fgh[0]), x));
     z = j ? jtcdot2(jt, jtbox(jt, IX(1 + j)), z) : z;
     EPILOG(z);

jsrc/adverbs/ap.c

@@ -622,7 +622,7 @@ jtinfix(J jt, A a, A w, A self) {
         // Create fill-cell of shape s; apply u to it
         RZ(df1(x, jtreshape(jt, s, jtfiller(jt, w)), fs));
         // Prepend leading axis of 0 to the result
-        z = jtreshape(jt, jtover(jt, zeroionei(0), shape(jt, x)), x);
+        z = jtreshape(jt, jtover(jt, num(0), shape(jt, x)), x);
     }
     EPILOG(z);
 }
@@ -657,7 +657,7 @@ jtginfix(J jt, A a, A w, A self) {
         RZ(s = AR(w) ? shape(jt, w) : jtca(jt, iv0));
         AV(s)[0] = ABS(m);
         RZ(df1(x, jtreshape(jt, s, jtfiller(jt, w)), *hv));
-        return jtreshape(jt, jtover(jt, zeroionei(0), shape(jt, x)), x);
+        return jtreshape(jt, jtover(jt, num(0), shape(jt, x)), x);
     }
 }
 
@@ -864,14 +864,14 @@ jtinfixprefix2(J jt, A a, A w, A self) {
         // for prefix, 0 items of fill
         // for infix +, invabs items of fill
         // for infix -, 0 items of fill
-        RZ(z = jtreitem(jt, zeroionei(0), w));  // create 0 items of the type of w
+        RZ(z = jtreitem(jt, num(0), w));  // create 0 items of the type of w
         if (ilnval >= 0) {
             ilnval = (ilnval == IMAX) ? (wi + 1) : ilnval;
             RZ(z = jttake(jt, jtsc(jt, ilnval), z));
         }  // if items needed, create them.  For compatibility, treat _ as 1 more than #items in w
         WITHDEBUGOFF(zz = CALL1(f1, z, fs);) if (EMSK(jt->jerr) & EXIGENTERROR) RZ(zz);
         RESETERR;
-        RZ(zz = jtreshape(jt, jtover(jt, zeroionei(0), shape(jt, zz ? zz : mtv)), zz ? zz : zeroionei(0)));
+        RZ(zz = jtreshape(jt, jtover(jt, num(0), shape(jt, zz ? zz : mtv)), zz ? zz : num(0)));
     }
 
     // result is now in zz
@@ -909,7 +909,7 @@ jtpscan(J jt, A w, A self) {
     SETICFR(w, f, r, n);  // wn=0 doesn't matter
     // If there are 0 or 1 items, or w is empty, return the input unchanged, except: if rank 0, return (($w),1)($,)w -
     // if atomic op, do it right here, otherwise call the routine to get the shape of result cell
-    if (((1 - n) & -wn) >= 0) { return r ? w : jtreshape(jt, apip(shape(jt, w), zeroionei(1)), w); }  // n<2 or wn=0
+    if (((1 - n) & -wn) >= 0) { return r ? w : jtreshape(jt, apip(shape(jt, w), num(1)), w); }  // n<2 or wn=0
     VARPS adocv;
     varps(adocv, self, wt, 1);  // fetch info for f/\ and this type of arg
     if (!adocv.f)