Remove unused argument from CPROD macro

Author: juntuu

jsrc/conjunctions/cr.c

@@ -16,7 +16,6 @@
 #define STATEANOTEMPTYX 17  // set if a arg has atoms
 #define STATEANOTEMPTY ((I)1 << STATEANOTEMPTYX)
 #define STATEAWNOTEMPTYX 18  // set if a and w args both have atoms
-#define STATEAWNOTEMPTY ((I)1 << STATEAWNOTEMPTYX)
 // These bits start where they do to avoid overlap with AFPRISTINE.  Also, they are above where rank significance is
 #define STATEOUTERREPEATAX 22
 #define STATEOUTERREPEATA (((I)1) << STATEOUTERREPEATAX)
@@ -64,7 +63,7 @@ jtrank1ex(J jt, AD *RESTRICT w, A fs, I rr, AF f1) {
     // multiple cells.  Loop through them.
     // Get size of each argument cell in atoms.  If this overflows, there must be a 0 in the frame, & we will have
     // gone through the fill path (& caught the overflow)
-    CPROD(AN(w), mn, wf, AS(w));
+    CPROD(mn, wf, AS(w));
     PROD(wcn, rr, AS(w) + wf);  // number of cells, number of atoms in a cell
     // ?cn=number of atoms in a cell, ?k=#bytes in a cell
     wk = wcn << bplg(AT(w));
@@ -389,9 +388,8 @@ jtrank2ex(J jt, AD *RESTRICT a, AD *RESTRICT w, A fs, UI lrrrlcrrcr, AF f2) {
         los = aof - wof < 0 ? AS(w) : los;
         state |= (aof - wof) & STATEOUTERREPEATA;
         ASSERTAGREE(AS(a), AS(w), sof)  // prefixes must agree
-        CPROD(state & STATEAWNOTEMPTY, outerframect, sof, los);
-        CPROD(
-          state & STATEAWNOTEMPTY, outerrptct, lof - sof, los + sof);  // get # cells in frame, and in unmatched frame
+        CPROD(outerframect, sof, los);
+        CPROD(outerrptct, lof - sof, los + sof);  // get # cells in frame, and in unmatched frame
     }
 
     // Now work on inner frames.  Compare frame lengths after discarding outer frames
@@ -410,8 +408,8 @@ jtrank2ex(J jt, AD *RESTRICT a, AD *RESTRICT w, A fs, UI lrrrlcrrcr, AF f2) {
         state |=
           (ew - ea) & STATEINNERREPEATW;  // make lis the shape pointer for longer; if a is longer, indicate repeating w
     }
-    CPROD(state & STATEAWNOTEMPTY, innerrptct, lif - sif, lis + sif);  // number of repetitions per matched-frame cell
-    CPROD(state & STATEAWNOTEMPTY, innerframect, sif, lis);            // number of cells in matched frame
+    CPROD(innerrptct, lif - sif, lis + sif);  // number of repetitions per matched-frame cell
+    CPROD(innerframect, sif, lis);            // number of cells in matched frame
 
     // Migrate loops with count=1 toward the inner to reduce overhead.  We choose not to promote the outer to the inner
     // if both innerframect & innerrptct are 1, on grounds of rarity

jsrc/j.h

@@ -877,7 +877,7 @@
     }
 // CPROD is to be used to create a test testing #atoms.  Because empty arrays can have cells that have too many atoms,
 // we can't use PROD if we don't know that the array isn't empty or will be checked later
-#define CPROD(t, z, x, a) PRODX(z, x, a, 1)
+#define CPROD(z, x, a) PRODX(z, x, a, 1)
 // PROLOG/EPILOG are the main means of memory allocation/free.  jt->tstack contains a pointer to every block that is
 // allocated by GATV(i. e. all blocks). GA causes a pointer to the block to be pushed onto tstack.  PROLOG saves a copy
 // of the stack pointer in _ttop, a local variable in its function.  Later, jttpop(jt,_ttop) can be executed to free

jsrc/verbs/v.c

@@ -43,7 +43,7 @@ jtravel(J jt, A w) {
         if (r == 1)
             return w;  // if we are enfiling 1-cells, there's nothing to do, return the input (note: AN of sparse array
                        // is always 1)
-        CPROD(AN(w), m, r, f + AS(w));  // m=#atoms in cell
+        CPROD(m, r, f + AS(w));  // m=#atoms in cell
         if (ASGNINPLACESGN(SGNIF((I)jtinplace, JTINPLACEWX) & (-r), w) &&
             !(AFLAG(w) & AFUNINCORPABLE)) {  // inplace allowed, rank not 0 (so shape will fit), usecount is right
             // operation is loosely inplaceable.  Just shorten the shape to frame,(#atoms in cell).  We do this here

jsrc/verbs/ve.c

@@ -587,7 +587,7 @@ jtbase1(J jt, A w) {
     ASSERT(t & DENSE, EVNONCE);
     if (((c - BW) & SGNIF(t, B01X)) >= 0)
         return jtpdt(jt, w, jtweight(jt, jtsc(jt, c), t & RAT + XNUM ? jtcvt(jt, XNUM, num(2)) : num(2)));  //
-    CPROD(n, m, r - 1, s);
+    CPROD(m, r - 1, s);
     GATV(z, INT, m, r ? r - 1 : 0, s);
     x = AV(z);
     v = BAV(w);

jsrc/verbs/vf.c

@@ -533,8 +533,9 @@ jtreshape(J jt, A a, A w) {
     u = AV(a);  // r=length of a   u->values of a
     if ((SPARSE & AT(w)) != 0) { return reshapesp(a, w, wf, wcr); }
     wn = AN(w);
-    PRODX(m, r, u, 1) CPROD(wn, c, wf, ws);
-    CPROD(wn, n, wcr, wf + ws);             // m=*/a (#atoms in result)  c=#cells of w  n=#atoms/cell of w
+    PRODX(m, r, u, 1)
+    CPROD(c, wf, ws);
+    CPROD(n, wcr, wf + ws);                 // m=*/a (#atoms in result)  c=#cells of w  n=#atoms/cell of w
     ASSERT(n || !m || jt->fill, EVLENGTH);  // error if attempt to extend array of no items to some items without fill
     t       = AT(w);
     filling = 0;

jsrc/verbs/viix.c

@@ -230,8 +230,8 @@ jticap2(J jt, A a, A w) {
     ASSERTAGREE(as + ar - r, ws + wr - r, r)
     ASSERT((POSIFHOMO(at, wt) & -AN(a) & -AN(w)) >= 0, EVDOMAIN);
     ASSERT(!((at | wt) & SPARSE), EVNONCE);  // if no empties, verify agreement & non-sparse
-    CPROD(AN(w), m, wr - r, ws);
-    CPROD(AN(w), c, r, ws + wr - r);  // m=#atoms in result   c=# atoms in a cell of w
+    CPROD(m, wr - r, ws);
+    CPROD(c, r, ws + wr - r);  // m=#atoms in result   c=# atoms in a cell of w
     GATV(z, INT, m, wr - r, ws);
     zv = AV(z);
     if (((m - 1) | (n - 1) | (c - 1)) < 0) {

jsrc/verbs/vo.c

@@ -66,8 +66,8 @@ jtbox(J jt, A w) {
     } else {
         // <"r
         ws = AS(w);
-        CPROD(AN(w), n, f, ws);
-        CPROD(AN(w), m, r, f + ws);
+        CPROD(n, f, ws);
+        CPROD(m, r, f + ws);
         k  = m << bplg(wt);
         wv = CAV(w);
         // Since we are allocating the new boxes, the result will ipso facto be PRIVATE, as long as w is DIRECT.  If w