Remove unnecessary macros

Author: juntuu

jsrc/j.h

@@ -629,19 +629,19 @@
 // Install new value z into xv[k], where xv is AAV(x).  If x has recursive usecount, we must increment the usecount of
 // z. This also guarantees that z has recursive usecount whenever x does, and that z is realized
 #define INSTALLBOX(x, xv, k, z) \
-    rifv(z);                    \
+    realizeifvirtual(z);        \
     if ((UCISRECUR(x)) != 0) {  \
         A zzZ = xv[k];          \
         ra(z);                  \
         fa(zzZ);                \
     }                           \
     xv[k] = z
 #define INSTALLBOXNF(x, xv, k, z)       \
-    rifv(z);                            \
+    realizeifvirtual(z);                \
     if ((UCISRECUR(x)) != 0) { ra(z); } \
     xv[k] = z  // Don't do the free - if we are installing into known 0 or known nonrecursive
 #define INSTALLBOXRECUR(xv, k, z) \
-    rifv(z);                      \
+    realizeifvirtual(z);          \
     {                             \
         I zzK = (k);              \
         {                         \

jsrc/ja.h

@@ -433,7 +433,6 @@
     {                                                                \
         if ((AFLAG(x) & AFVIRTUAL) != 0) RZ((x) = jtrealize(jt, x)); \
     }
-#define rifv(x) realizeifvirtual(x)
 // We have used rifvs liberally through the code to guarantee that all functions can deal with virtual blocks returned.
 // In some cases, the call is to an internal routine that we know will not return a virtual block normally, and is in an
 // important performance path.  We use rifvsdebug for these places.  rifvs is called only during debugging.  Review them
@@ -519,7 +518,7 @@
 // usecount We can have an inplaceable but recursible block, if it was gc'd.  We never push a PERMANENT block, so that
 // we won't try to free it NOTE that PERMANENT blocks are always marked traversible if they are of traversible type, so
 // we will not recur on them internally
-#define tpushcommon(x, suffix)                                                                 \
+#define tpush(x)                                                                               \
     {                                                                                          \
         if (!ACISPERM(AC(x))) {                                                                \
             I tt     = AT(x);                                                                  \
@@ -528,10 +527,8 @@
             if (!((I)pushp & (NTSTACKBLOCK - 1))) { RZ(pushp = jttg(jt, pushp)); }             \
             if (((tt ^ AFLAG(x)) & TRAVERSIBLE) != 0) RZ(pushp = jttpush(jt, (x), tt, pushp)); \
             jt->tnextpushp = pushp;                                                            \
-            suffix                                                                             \
         }                                                                                      \
     }
-#define tpush(x) tpushcommon(x, )
 // Internal version, used when the local name pushp is known to hold jt->tnextpushp
 #define tpushi(x)                                                                              \
     {                                                                                          \

jsrc/words/w.c

@@ -449,7 +449,7 @@ jtenqueue(J jt, A a, A w, I env) {
             }  // bad first character or inflection
         }
         // Since the word is being incorporated into a list, we must realize it
-        rifv(*x);
+        realizeifvirtual(*x);
         // Mark the word as not-inplaceable.  Since all allocations start life marked in-placeable, we get into trouble
         // if words in a explicit definition are left that way, because the sentences may get reexecuted and any
         // constant marked inplaceable could be modified by each use.  The trouble happens only if the definition is not