ffi: rename functions in the carray-num group.

* ffi.c (carray_unum, carray_num, unum_carray, num_carray):
Functions renamed to carray_uint, carray_int, uint_carray,
int_carray.
(ffi_init): Functions registered under new names:
carray-uint, carray-int, uint-carray, int-carray. Compat
values of 227 or less provide the old old names.

* ffi.h (carray_unum, carray_num, unum_carray, num_carray):
Declarations renamed.

* txr.1: Updated to new names; compat note added.

3 files changed, 61 insertions, 30 deletions

diff --git a/ffi.c b/ffi.c
index dbaa1ce5..fe7cf5d6 100644
--- a/ffi.c
+++ b/ffi.c
@@ -59,6 +59,7 @@
 #include "utf8.h"
 #include "hash.h"
 #include "ffi.h"
+#include "txr.h"
 
 #define zalloca(size) memset(alloca(size), 0, size)
 
@@ -5355,9 +5356,9 @@ val carray_pun(val carray, val type)
   return make_carray(type, scry->data, size / tft->size, carray, 0);
 }
 
-val carray_unum(val num, val eltype_in)
+val carray_uint(val num, val eltype_in)
 {
-  val self = lit("carray-unum");
+  val self = lit("carray-uint");
   val eltype = default_arg(eltype_in, ffi_type_compile(uchar_s));
   struct txr_ffi_type *tft = ffi_type_struct(eltype);
 
@@ -5390,9 +5391,9 @@ val carray_unum(val num, val eltype_in)
   }
 }
 
-val carray_num(val num, val eltype_in)
+val carray_int(val num, val eltype_in)
 {
-  val self = lit("carray-num");
+  val self = lit("carray-int");
   val eltype = default_arg(eltype_in, ffi_type_compile(uchar_s));
   struct txr_ffi_type *tft = ffi_type_struct(eltype);
 
@@ -5428,9 +5429,9 @@ val carray_num(val num, val eltype_in)
   }
 }
 
-val unum_carray(val carray)
+val uint_carray(val carray)
 {
-  val self = lit("unum-carray");
+  val self = lit("uint-carray");
   struct carray *scry = carray_struct_checked(self, carray);
   struct txr_ffi_type *etft = scry->eltft;
   ucnum size = (ucnum) etft->size * (ucnum) scry->nelem;
@@ -5441,9 +5442,9 @@ val unum_carray(val carray)
   return normalize(ubn);
 }
 
-val num_carray(val carray)
+val int_carray(val carray)
 {
-  val self = lit("num-carray");
+  val self = lit("int-carray");
   struct carray *scry = carray_struct_checked(self, carray);
   struct txr_ffi_type *etft = scry->eltft;
   ucnum size = (ucnum) etft->size * (ucnum) scry->nelem;
@@ -5858,10 +5859,24 @@ void ffi_init(void)
   reg_fun(intern(lit("carray-put"), user_package), func_n2(carray_put));
   reg_fun(intern(lit("carray-putz"), user_package), func_n2(carray_putz));
   reg_fun(intern(lit("carray-pun"), user_package), func_n2(carray_pun));
-  reg_fun(intern(lit("carray-unum"), user_package), func_n2o(carray_unum, 1));
-  reg_fun(intern(lit("carray-num"), user_package), func_n2o(carray_num, 1));
-  reg_fun(intern(lit("unum-carray"), user_package), func_n1(unum_carray));
-  reg_fun(intern(lit("num-carray"), user_package), func_n1(num_carray));
+  {
+    val ca_uint = func_n2o(carray_uint, 1);
+    val ca_int = func_n2o(carray_int, 1);
+    val uint_ca = func_n1(uint_carray);
+    val int_ca = func_n1(int_carray);
+
+    reg_fun(intern(lit("carray-uint"), user_package), ca_uint);
+    reg_fun(intern(lit("carray-int"), user_package), ca_int);
+    reg_fun(intern(lit("uint-carray"), user_package), uint_ca);
+    reg_fun(intern(lit("int-carray"), user_package), int_ca);
+
+    if (opt_compat && opt_compat <= 227) {
+      reg_fun(intern(lit("carray-unum"), user_package), ca_uint);
+      reg_fun(intern(lit("carray-num"), user_package), ca_int);
+      reg_fun(intern(lit("unum-carray"), user_package), uint_ca);
+      reg_fun(intern(lit("num-carray"), user_package), int_ca);
+    }
+  }
   reg_fun(intern(lit("put-carray"), user_package), func_n3o(put_carray, 1));
   reg_fun(intern(lit("fill-carray"), user_package), func_n3o(fill_carray, 1));
   reg_fun(intern(lit("make-union"), user_package), func_n3o(make_union, 1));
diff --git a/ffi.h b/ffi.h
index 77ab966b..673ba911 100644
--- a/ffi.h
+++ b/ffi.h
@@ -119,10 +119,10 @@ val carray_getz(val carray);
 val carray_put(val array, val seq);
 val carray_putz(val array, val seq);
 val carray_pun(val carray, val type);
-val carray_unum(val num, val type);
-val carray_num(val num, val type);
-val unum_carray(val carray);
-val num_carray(val carray);
+val carray_uint(val num, val type);
+val carray_int(val num, val type);
+val uint_carray(val carray);
+val int_carray(val carray);
 val put_carray(val carray, val offs, val stream);
 val fill_carray(val carray, val offs, val stream);
 mem_t *union_get_ptr(val self, val uni);
diff --git a/txr.1 b/txr.1
index ea82953f..297759d9 100644
--- a/txr.1
+++ b/txr.1
@@ -68185,16 +68185,16 @@ is invoked on the aliasing array.
 The meaning of the aliasing depends entirely on the bitwise representations of
 the types involved.
 
-.coNP Functions @ carray-unum and @ carray-num
+.coNP Functions @ carray-uint and @ carray-int
 .synb
-.mets (carray-unum < number <> [ type ])
-.mets (carray-num < number <> [ type ])
+.mets (carray-uint < number <> [ type ])
+.mets (carray-int < number <> [ type ])
 .syne
 .desc
 The
-.code carray-unum
+.code carray-uint
 and
-.code carray-num
+.code carray-int
 functions convert
 .metn number ,
 an integer, to a binary image, which is then used as
@@ -68223,7 +68223,7 @@ than the storage provided by the array, it extended with padding bytes on the
 left, near the beginning of the array.
 
 In the case of
-.codn carray-unum ,
+.codn carray-uint ,
 .meta number
 must be a non-negative integer. An unsigned representation is produced
 which carries no sign bit. The representation is as many bytes wide as
@@ -68232,7 +68232,7 @@ value is 1. If any padding bytes are required due to the array being larger,
 they are always zero.
 
 The
-.code carray-num
+.code carray-int
 function encodes negative integers also, using a variable-length two's
 complement representation. The number of bits required to hold the number
 is calculated as the smallest width which can represent the value in two's
@@ -68245,28 +68245,28 @@ the padding bytes are filled with the value
 .code #b11111111
 (255) if the number is negative, or else 0 if it is non-negative.
 
-.coNP Functions @ unum-carray and @ num-carray
+.coNP Functions @ uint-carray and @ int-carray
 .synb
-.mets (unum-carray << carray )
-.mets (num-carray < number <> [ type ])
+.mets (uint-carray << carray )
+.mets (int-carray < number <> [ type ])
 .syne
 .desc
 The
-.code unum-carray
+.code uint-carray
 and
-.code num-carray
+.code int-carray
 functions treat the storage bytes
 .meta carray
 object as the representation of an integer.
 
 The
-.code unum-carray
+.code uint-carray
 function simply treats all of the bytes as a big-endian unsigned integer in
 a pure binary representation, and returns that integer, which is necessarily
 always non-negative.
 
 The
-.code num-carray
+.code int-carray
 function treats the bytes as a two's complement representation. The returned
 number is negative if the first storage byte of
 .meta carray
@@ -71134,6 +71134,22 @@ of these version values, the described behaviors are provided if
 is given an argument which is equal or lower. For instance
 .code "-C 103"
 selects the behaviors described below for version 105, but not those for 102.
+.IP 227
+In \*(TX 227 and older versions, the functions
+.codn carray-uint ,
+.codn carray-int ,
+.code uint-carray
+and
+.code int-carray
+had different names, namely
+.codn carray-unum ,
+.codn carray-num ,
+.code unum-carray
+and
+.codn num-carray ,
+respectively.
+If 227 or lower compatibility is selected, these functions become
+available under their old names in addition to their new names.
 .IP 225
 After \*(TX 225, the behavior of the
 .code do