symm/blkc.h: Define a new `BLKC_ADD' macro.

[catacomb] / symm / blkc.h

diff --git a/symm/blkc.h b/symm/blkc.h
index e083752..5e996e8 100644 (file)
--- a/symm/blkc.h
+++ b/symm/blkc.h
@@ -95,9 +95,11 @@
   BLKC_GLUE(BLKC_XMOVE_, BLKC_TYPE(PRE))                               \
     (PRE, w, wx, BLKC_BITS(PRE))
 
-#define BLKC_STEP(PRE, w)                                              \
-  BLKC_GLUE(BLKC_STEP_X_, BLKC_ENDIAN(PRE))                            \
-    (PRE, w)
+#define BLKC_STEP(PRE, w) BLKC_ADD(PRE, w, 1)
+
+#define BLKC_ADD(PRE, w, n)                                            \
+  BLKC_GLUE(BLKC_ADD_X_, BLKC_ENDIAN(PRE))                             \
+    (PRE, w, n)
 
 #define BLKC_ZERO(PRE, w)                                              \
   BLKC_GLUE(BLKC_ZERO_, BLKC_TYPE(PRE))                                        \
@@ -113,6 +115,24 @@
   fputc('\n', stdout);                                                 \
 } while (0)
 
+/* --- Utilities --- *
+ *
+ * These seem too hard to properly generalize, or I'd have put them in
+ * <mLib/bits.h>.
+ */
+
+#ifdef HAVE_UINT64
+#  define BLKC_ADDC32(z_out, c_out, x, y) do {                         \
+     uint64 _t = (uint64)(x) + (y);                                    \
+     (z_out) = U32(_t); (c_out) = _t >> 32;                            \
+   } while (0)
+#else
+#  define BLKC_ADDC32(z_out, c_out, x, y) do {                         \
+     uint32 _x = (x), _c = 0, _t;                                      \
+     _t = U32(_x + (y)); (z_out) = _t; (c_out) = (_t < _x);            \
+   } while (0)
+#endif
+
 /* --- General implementation skeleton --- */
 
 #define BLKC_SKEL(PRE, decl, guts) do {                                        \
@@ -120,15 +140,15 @@
   guts                                                                 \
 } while (0)
 
-#define BLKC_P(p) register octet *_p = (octet *)(p)
-#define BLKC_W(w) register uint32 *_w = (w)
-#define BLKC_WX(wx) register uint32 *_wx = (wx)
+#define BLKC_P(p) octet *_p = (octet *)(p)
+#define BLKC_W(w) uint32 *_w = (w)
+#define BLKC_WX(wx) uint32 *_wx = (wx)
 
 /* --- Implementation for unusual block sizes --- */
 
 #define BLKC_SKEL_X(PRE, decl, guts)                                   \
   BLKC_SKEL(PRE, unsigned _i; decl,                                    \
-           for (_i = 0; _i < PRE##_BLKSZ / 4; _i++) {                  \
+           for (_i = 0; _i < PRE##_BLKSZ/4; _i++) {                    \
              guts                                                      \
            })
 
@@ -159,28 +179,28 @@
 #define BLKC_ZERO_X(PRE, w, n)                                         \
   BLKC_SKEL_X(PRE, BLKC_W(w);, *_w++ = 0;)
 
-#define BLKC_STEP_X_B(PRE, w) do {                                     \
-  unsigned _i = PRE##_BLKSZ / 4; BLKC_W(w); uint32 _x = 0;             \
-  while (_i && !_x) { _i--; _w[_i] = _x = U32(_w[_i] + 1); }           \
+#define BLKC_ADD_X_B(PRE, w, n) do {                                   \
+  unsigned _i = PRE##_BLKSZ/4; BLKC_W(w); uint32 _n = (n);             \
+  while (_i-- && _n) BLKC_ADDC32(_w[_i], _n, _w[_i], _n);              \
 } while (0)
 
-#define BLKC_STEP_X_L(PRE, w) do {                                     \
-  unsigned _i = 0; BLKC_W(w); uint32 _x = 0;                           \
-  while (_i < PRE##_BLKSZ / 4 && !_x)                                  \
-    { _w[_i] = _x = U32(_w[_i] + 1); _i++; }                           \
+#define BLKC_ADD_X_L(PRE, w, n) do {                                   \
+  unsigned _i = 0; BLKC_W(w); uint32 _n = (n);                         \
+  while (_i < PRE##_BLKSZ/4 && _n)                                     \
+    { BLKC_ADDC32(_w[_i], _n, _w[_i], _n); _i++; }                     \
 } while (0)
 
 #define BLKC_SET_X_B(PRE, w, x) do {                                   \
   unsigned _i; BLKC_W(w); unsigned long _x = x;                                \
-  for (_i = 0; _i < PRE##_BLKSZ / 4; _i++) {                           \
+  for (_i = 0; _i < PRE##_BLKSZ/4; _i++) {                             \
     *_w++ = U32(_x);                                                   \
     _x = ((_x & ~(unsigned long)MASK32) >> 16) >> 16;                  \
   }                                                                    \
 } while (0)
 
 #define BLKC_SET_X_L(PRE, w, x) do {                                   \
-  unsigned _i; BLKC_W(w); unsigned long _x = x;        _w += PRE##_BLKSZ / 4;  \
-  for (_i = 0; _i < PRE##_BLKSZ / 4; _i++) {                           \
+  unsigned _i; BLKC_W(w); unsigned long _x = x; _w += PRE##_BLKSZ/4;   \
+  for (_i = 0; _i < PRE##_BLKSZ/4; _i++) {                             \
     *--_w = U32(_x);                                                   \
     _x = ((_x & ~(unsigned long)MASK32) >> 16) >> 16;                  \
   }                                                                    \
@@ -267,9 +287,9 @@
 static int pre##_verify(dstr *v)                                       \
 {                                                                      \
   pre##_ctx k;                                                         \
-  uint32 p[PRE##_BLKSZ / 4];                                           \
-  uint32 c[PRE##_BLKSZ / 4];                                           \
-  uint32 d[PRE##_BLKSZ / 4];                                           \
+  uint32 p[PRE##_BLKSZ/4];                                             \
+  uint32 c[PRE##_BLKSZ/4];                                             \
+  uint32 d[PRE##_BLKSZ/4];                                             \
   dstr b = DSTR_INIT;                                                  \
   int ok = 1;                                                          \
                                                                        \