[COMMITTED] libpoke: add new call pk_val_kind and introduce PK_VAL_*

[Jose E. Marchesi]

This patch also renames the PK_* values for type codes to PK_TYPE_*.

2022-01-13  Jose E. Marchesi  <jemarch@gnu.org>

        * libpoke/libpoke.h (PK_TYPE_UNKNOWN): Rename from PK_UNKNOWN.
        (PK_TYPE_INT): Likewise.
        (PK_TYPE_UINT): Likewise.
        (PK_TYPE_STRING): Likewise.
        (PK_TYPE_OFFSET): Likewise.
        (PK_TYPE_ARRAY): Likewise.
        (PK_TYPE_STRUCT): Likewise.
        (PK_TYPE_CLOSURE): Likewise.
        (PK_TYPE_ANY): Likewise.
        (PK_VAL_INT): Define.
        (PK_VAL_UINT): Likewise.
        (PK_VAL_STRING): Likewise.
        (PK_VAL_OFFSET): Likewise.
        (PK_VAL_ARRAY): Likewise.
        (PK_VAL_STRUCT): Likewise.
        (PK_VAL_CLOSURE): Likewise.
        Prototype for pk_val_kind.
        * libpoke/pk-val.c (pk_val_kind): New function.
        (pk_type_code): Adapt to use PK_TYPE_* values.
        * poke/pk-ios.c (pk_open_file): Adapt accordingly.
        * poke/pk-map.c (pk_map_load_parsed_map): Likewise.
        (pk_map_resolve_map): Likewise.
        * poke/pk-mi-msg.c: Likewise.
        * poke/pk-mi-msg.def: Likewise.
        * poke/pk-mi-json.c: Likewise.
---
 ChangeLog          | 28 ++++++++++++++++++++++
 libpoke/libpoke.h  | 31 +++++++++++++++++-------
 libpoke/pk-val.c   | 41 +++++++++++++++++++++++++-------
 poke/pk-ios.c      |  6 ++---
 poke/pk-map.c      |  8 +++----
 poke/pk-mi-json.c  | 70 +++++++++++++++++++++++++++---------------------------
 poke/pk-mi-msg.c   |  8 +++----
 poke/pk-mi-msg.def | 12 +++++-----
 8 files changed, 134 insertions(+), 70 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index 4417a0bb..e4453fa1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,33 @@
 2022-01-13  Jose E. Marchesi  <jemarch@gnu.org>
 
+       * libpoke/libpoke.h (PK_TYPE_UNKNOWN): Rename from PK_UNKNOWN.
+       (PK_TYPE_INT): Likewise.
+       (PK_TYPE_UINT): Likewise.
+       (PK_TYPE_STRING): Likewise.
+       (PK_TYPE_OFFSET): Likewise.
+       (PK_TYPE_ARRAY): Likewise.
+       (PK_TYPE_STRUCT): Likewise.
+       (PK_TYPE_CLOSURE): Likewise.
+       (PK_TYPE_ANY): Likewise.
+       (PK_VAL_INT): Define.
+       (PK_VAL_UINT): Likewise.
+       (PK_VAL_STRING): Likewise.
+       (PK_VAL_OFFSET): Likewise.
+       (PK_VAL_ARRAY): Likewise.
+       (PK_VAL_STRUCT): Likewise.
+       (PK_VAL_CLOSURE): Likewise.
+       Prototype for pk_val_kind.
+       * libpoke/pk-val.c (pk_val_kind): New function.
+       (pk_type_code): Adapt to use PK_TYPE_* values.
+       * poke/pk-ios.c (pk_open_file): Adapt accordingly.
+       * poke/pk-map.c (pk_map_load_parsed_map): Likewise.
+       (pk_map_resolve_map): Likewise.
+       * poke/pk-mi-msg.c: Likewise.
+       * poke/pk-mi-msg.def: Likewise.
+       * poke/pk-mi-json.c: Likewise.
+
+2022-01-13  Jose E. Marchesi  <jemarch@gnu.org>
+
        * doc/poke.texi (Field Labels): Update section taking into account
        integral structs.
 
diff --git a/libpoke/libpoke.h b/libpoke/libpoke.h
index 0c36e6e5..e0b7aa86 100644
--- a/libpoke/libpoke.h
+++ b/libpoke/libpoke.h
@@ -1067,18 +1067,31 @@ pk_val pk_typeof (pk_val val) LIBPOKE_API;
 
 /* Given a type value, return its code.  */
 
-#define PK_UNKNOWN 0
-#define PK_INT     1
-#define PK_UINT    2
-#define PK_STRING  3
-#define PK_OFFSET  4
-#define PK_ARRAY   5
-#define PK_STRUCT  6
-#define PK_CLOSURE 7
-#define PK_ANY     8
+#define PK_TYPE_UNKNOWN 0
+#define PK_TYPE_INT     1
+#define PK_TYPE_UINT    2
+#define PK_TYPE_STRING  3
+#define PK_TYPE_OFFSET  4
+#define PK_TYPE_ARRAY   5
+#define PK_TYPE_STRUCT  6
+#define PK_TYPE_CLOSURE 7
+#define PK_TYPE_ANY     8
 
 int pk_type_code (pk_val val) LIBPOKE_API;
 
+/* Given a value, return its kind.  */
+
+#define PK_VAL_UNKNOWN 0
+#define PK_VAL_INT     1
+#define PK_VAL_UINT    2
+#define PK_VAL_STRING  3
+#define PK_VAL_OFFSET  4
+#define PK_VAL_ARRAY   5
+#define PK_VAL_STRUCT  6
+#define PK_VAL_CLOSURE 7
+
+int pk_val_kind (pk_val val) LIBPOKE_API;
+
 /* Compare two Poke values.
 
    Returns 1 if they match, 0 otherwise.  */
diff --git a/libpoke/pk-val.c b/libpoke/pk-val.c
index e7326f9b..5a19a48c 100644
--- a/libpoke/pk-val.c
+++ b/libpoke/pk-val.c
@@ -210,27 +210,50 @@ pk_type_code (pk_val val)
     {
     case PVM_TYPE_INTEGRAL:
       if ((pk_int_value (pk_integral_type_signed_p (val))))
-        return PK_INT;
+        return PK_TYPE_INT;
       else
-        return PK_UINT;
+        return PK_TYPE_UINT;
     case PVM_TYPE_STRING:
-      return PK_STRING;
+      return PK_TYPE_STRING;
     case PVM_TYPE_ARRAY:
-      return PK_ARRAY;
+      return PK_TYPE_ARRAY;
     case PVM_TYPE_STRUCT:
-      return PK_STRUCT;
+      return PK_TYPE_STRUCT;
     case PVM_TYPE_OFFSET:
-      return PK_OFFSET;
+      return PK_TYPE_OFFSET;
     case PVM_TYPE_CLOSURE:
-      return PK_CLOSURE;
+      return PK_TYPE_CLOSURE;
     case PVM_TYPE_ANY:
-      return PK_ANY;
+      return PK_TYPE_ANY;
     default:
-      return PK_UNKNOWN;
+      return PK_TYPE_UNKNOWN;
     }
 }
 
 int
+pk_val_kind (pk_val val)
+{
+  if (PVM_IS_INT (val) || PVM_IS_LONG (val))
+    return PK_VAL_INT;
+  else if (PVM_IS_UINT (val) || PVM_IS_ULONG (val))
+    return PK_VAL_UINT;
+  else if (PVM_IS_OFF (val))
+    return PK_VAL_OFFSET;
+  else if (PVM_IS_STR (val))
+    return PK_VAL_STRING;
+  else if (PVM_IS_ARR (val))
+    return PK_VAL_ARRAY;
+  else if (PVM_IS_SCT (val))
+    return PK_VAL_STRUCT;
+  else if (PVM_IS_CLS (val))
+    return PK_VAL_CLOSURE;
+  else if (PVM_IS_TYP (val))
+    return PK_VAL_UNKNOWN;
+  else
+    return PK_VAL_UNKNOWN;
+}
+
+int
 pk_val_equal_p (pk_val val1, pk_val val2)
 {
   return pvm_val_equal_p (val1, val2);
diff --git a/poke/pk-ios.c b/poke/pk-ios.c
index 376de528..7f65d55b 100644
--- a/poke/pk-ios.c
+++ b/poke/pk-ios.c
@@ -63,16 +63,16 @@ pk_open_file (const char *handler, int set_cur_p, int 
create_p)
         regmatch_t matches;
 
         auto_map_entry = pk_array_elem_val (auto_map, i);
-        if (pk_type_code (pk_typeof (auto_map_entry)) != PK_ARRAY
+        if (pk_val_kind (auto_map_entry) != PK_VAL_ARRAY
             || pk_uint_value (pk_array_nelem (auto_map_entry)) != 2)
           pk_fatal ("invalid entry in auto_val");
 
         regex = pk_array_elem_val (auto_map_entry, 0);
-        if (pk_type_code (pk_typeof (regex)) != PK_STRING)
+        if (pk_val_kind (regex) != PK_VAL_STRING)
           pk_fatal ("regexp should be a string in an auto_val entry");
 
         mapname = pk_array_elem_val (auto_map_entry, 1);
-        if (pk_type_code (pk_typeof (mapname)) != PK_STRING)
+        if (pk_val_kind (mapname) != PK_VAL_STRING)
           pk_fatal ("mapname should be a string in an auto_val entry");
 
         if (regcomp (&regexp, pk_string_str (regex),
diff --git a/poke/pk-map.c b/poke/pk-map.c
index d4b61c81..10b0bed9 100644
--- a/poke/pk-map.c
+++ b/poke/pk-map.c
@@ -505,15 +505,15 @@ pk_map_load_parsed_map (int ios_id, const char *mapname,
                                      NULL /* exception */) != PK_OK)
             goto error;
 
-          if (pk_type_code (pk_typeof (val)) != PK_INT
-              && pk_type_code (pk_typeof (val)) != PK_UINT)
+          if (pk_val_kind (val) != PK_VAL_INT
+              && pk_val_kind (val) != PK_VAL_UINT)
             {
               /* XXX error location.  */
               pk_printf ("error: invalid condition expression\n");
               goto error;
             }
 
-          if (!(pk_type_code (pk_typeof (val)) == PK_INT
+          if (!(pk_val_kind (val) == PK_VAL_INT
                 ? pk_int_value (val) : pk_uint_value (val)))
             process_p = 0;
         }
@@ -676,7 +676,7 @@ pk_map_resolve_map (const char *mapname, int filename_p)
   if (val == PK_NULL)
     pk_fatal ("couldn't get `map_load_path'");
 
-  if (pk_type_code (pk_typeof (val)) != PK_STRING)
+  if (pk_val_kind (val) != PK_VAL_STRING)
     pk_fatal ("map_load_path should be a string");
 
   map_load_path = pk_string_str (val);
diff --git a/poke/pk-mi-json.c b/poke/pk-mi-json.c
index 1f95e35d..b2faaa89 100644
--- a/poke/pk-mi-json.c
+++ b/poke/pk-mi-json.c
@@ -263,15 +263,15 @@ static int
 pk_type_to_json (pk_val ptype, json_object **j_type, char **errmsg)
 {
   static const pk_type_to_json_func pk_type_to_json_functions[] = {
-    [PK_UNKNOWN] = NULL,
-    [PK_INT] = pk_type_to_json_integral,
-    [PK_UINT] = pk_type_to_json_integral,
-    [PK_STRING] = pk_type_to_json_string,
-    [PK_OFFSET] = pk_type_to_json_offset,
-    [PK_ARRAY] = pk_type_to_json_array,
-    [PK_STRUCT] = pk_type_to_json_struct,
-    [PK_CLOSURE] = NULL,
-    [PK_ANY] = pk_type_to_json_any,
+    [PK_TYPE_UNKNOWN] = NULL,
+    [PK_TYPE_INT] = pk_type_to_json_integral,
+    [PK_TYPE_UINT] = pk_type_to_json_integral,
+    [PK_TYPE_STRING] = pk_type_to_json_string,
+    [PK_TYPE_OFFSET] = pk_type_to_json_offset,
+    [PK_TYPE_ARRAY] = pk_type_to_json_array,
+    [PK_TYPE_STRUCT] = pk_type_to_json_struct,
+    [PK_TYPE_CLOSURE] = NULL,
+    [PK_TYPE_ANY] = pk_type_to_json_any,
   };
   const size_t len = sizeof (pk_type_to_json_functions) /
                      sizeof (pk_type_to_json_functions[0]);
@@ -562,21 +562,21 @@ pk_type_to_json_array (pk_val p_type_arr, json_object 
**j_type_arr,
 
       switch (pk_type_code (bound_type))
         {
-          case PK_UINT:
+          case PK_TYPE_UINT:
             bound_value = pk_uint_value (p_bound);
             bound_size_p = 0;
             break;
-          case PK_OFFSET:
+          case PK_TYPE_OFFSET:
             {
               pk_val b_off_mag = pk_offset_magnitude (p_bound);
 
               switch (pk_type_code (pk_typeof (b_off_mag)))
                 {
-                  case PK_INT:
+                  case PK_TYPE_INT:
                     bound_value = pk_int_value (b_off_mag);
                     assert (bound_value > 0);
                     break;
-                  case PK_UINT:
+                  case PK_TYPE_UINT:
                     bound_value = pk_uint_value (b_off_mag);
                     break;
                   default:
@@ -714,15 +714,15 @@ static int
 pk_val_to_json (pk_val pval, json_object **obj, char **errmsg)
 {
   static const pk_val_to_json_func pk_val_to_json_functions[] = {
-    [PK_UNKNOWN] = NULL,
-    [PK_INT] = pk_val_to_json_int,
-    [PK_UINT] = pk_val_to_json_uint,
-    [PK_STRING] = pk_val_to_json_string,
-    [PK_OFFSET] = pk_val_to_json_offset,
-    [PK_ARRAY] = pk_val_to_json_array,
-    [PK_STRUCT] = pk_val_to_json_struct,
-    [PK_CLOSURE] = NULL,
-    [PK_ANY] = pk_val_to_json_any,
+    [PK_TYPE_UNKNOWN] = NULL,
+    [PK_TYPE_INT] = pk_val_to_json_int,
+    [PK_TYPE_UINT] = pk_val_to_json_uint,
+    [PK_TYPE_STRING] = pk_val_to_json_string,
+    [PK_TYPE_OFFSET] = pk_val_to_json_offset,
+    [PK_TYPE_ARRAY] = pk_val_to_json_array,
+    [PK_TYPE_STRUCT] = pk_val_to_json_struct,
+    [PK_TYPE_CLOSURE] = NULL,
+    [PK_TYPE_ANY] = pk_val_to_json_any,
   };
   const size_t len = sizeof (pk_val_to_json_functions) /
                      sizeof (pk_val_to_json_functions[0]);
@@ -778,10 +778,10 @@ pk_val_to_json_offset (pk_val pk_off, json_object 
**j_off, char **errmsg)
 
   switch (pk_type_code (pk_typeof (p_mag)))
     {
-      case PK_INT:
+      case PK_TYPE_INT:
         val = pk_int_value (p_mag);
         break;
-      case PK_UINT:
+      case PK_TYPE_UINT:
         val = (int64_t) pk_uint_value (p_mag);
         break;
       default:
@@ -1436,15 +1436,15 @@ json_to_pk_val (json_object *obj, pk_val p_type, pk_val 
*p_value,
                 char **errmsg)
 {
   static const json_to_pk_val_func json_to_pk_val_functions[] = {
-    [PK_UNKNOWN] = NULL,
-    [PK_INT] = json_to_pk_val_int,
-    [PK_UINT] = json_to_pk_val_uint,
-    [PK_STRING] = json_to_pk_val_string,
-    [PK_OFFSET] = json_to_pk_val_offset,
-    [PK_ARRAY] = json_to_pk_val_array,
-    [PK_STRUCT] = json_to_pk_val_struct,
-    [PK_CLOSURE] = NULL,
-    [PK_ANY] = json_to_pk_val_any,
+    [PK_TYPE_UNKNOWN] = NULL,
+    [PK_TYPE_INT] = json_to_pk_val_int,
+    [PK_TYPE_UINT] = json_to_pk_val_uint,
+    [PK_TYPE_STRING] = json_to_pk_val_string,
+    [PK_TYPE_OFFSET] = json_to_pk_val_offset,
+    [PK_TYPE_ARRAY] = json_to_pk_val_array,
+    [PK_TYPE_STRUCT] = json_to_pk_val_struct,
+    [PK_TYPE_CLOSURE] = NULL,
+    [PK_TYPE_ANY] = json_to_pk_val_any,
   };
   const size_t len = sizeof (json_to_pk_val_functions) /
                      sizeof (json_to_pk_val_functions[0]);
@@ -1561,10 +1561,10 @@ json_to_pk_val_offset (json_object *j_off, pk_val 
pk_off_type, pk_val *pk_off,
   size = pk_uint_value (pk_integral_type_size (base_type));
   switch (pk_type_code (base_type))
     {
-      case PK_INT:
+      case PK_TYPE_INT:
         magnitude = pk_make_int (json_object_get_int64 (j_off), size);
         break;
-      case PK_UINT:
+      case PK_TYPE_UINT:
         magnitude = pk_make_uint (json_object_get_int64 (j_off), size);
         break;
       default:
diff --git a/poke/pk-mi-msg.c b/poke/pk-mi-msg.c
index 7c8b9dbd..29233202 100644
--- a/poke/pk-mi-msg.c
+++ b/poke/pk-mi-msg.c
@@ -41,7 +41,7 @@ struct pk_mi_msg_arginfo
 static struct pk_mi_msg_arginfo req_arginfo[][PK_MI_MAX_ARGS] =
 {
 #define PK_DEF_ARG(N,T) { #N, T }
-#define PK_DEF_NOARG { NULL, PK_UNKNOWN }
+#define PK_DEF_NOARG { NULL, PK_TYPE_UNKNOWN }
 #define PK_DEF_REQ(ID,ARGS) { ARGS, PK_DEF_NOARG },
 #include "pk-mi-msg.def"
 };
@@ -49,7 +49,7 @@ static struct pk_mi_msg_arginfo req_arginfo[][PK_MI_MAX_ARGS] 
=
 static struct pk_mi_msg_arginfo resp_arginfo[][PK_MI_MAX_ARGS] =
 {
 #define PK_DEF_ARG(N,T) { #N, T }
-#define PK_DEF_NOARG { NULL, PK_UNKNOWN }
+#define PK_DEF_NOARG { NULL, PK_TYPE_UNKNOWN }
 #define PK_DEF_RESP(ID,ARGS) { ARGS, PK_DEF_NOARG },
 #include "pk-mi-msg.def"
 };
@@ -57,7 +57,7 @@ static struct pk_mi_msg_arginfo 
resp_arginfo[][PK_MI_MAX_ARGS] =
 static struct pk_mi_msg_arginfo event_arginfo[][PK_MI_MAX_ARGS] =
 {
 #define PK_DEF_ARG(N,T) { #N, T }
-#define PK_DEF_NOARG { NULL, PK_UNKNOWN }
+#define PK_DEF_NOARG { NULL, PK_TYPE_UNKNOWN }
 #define PK_DEF_EVENT(ID,ARGS) { ARGS, PK_DEF_NOARG },
 #include "pk-mi-msg.def"
 };
@@ -312,7 +312,7 @@ pk_mi_set_arg (pk_mi_msg msg, const char *argname, pk_val 
value)
     assert (0);
 
   /* Check that VALUE is of the right kind for this argument.  */
-  assert (kind == PK_ANY || pk_type_code (type) == kind);
+  assert (kind == PK_TYPE_ANY || pk_type_code (type) == kind);
 
   /* Ok, set the value for this argument.  */
   PK_MI_MSG_ARGS (msg)[argindex] = value;
diff --git a/poke/pk-mi-msg.def b/poke/pk-mi-msg.def
index 8712813c..c32e7f25 100644
--- a/poke/pk-mi-msg.def
+++ b/poke/pk-mi-msg.def
@@ -78,8 +78,8 @@
 */
 
 PK_DEF_EVENT (INITIALIZED,
-              PK_DEF_ARGS (PK_DEF_ARG (mi_version, PK_INT),
-                           PK_DEF_ARG (version, PK_STRING)))
+              PK_DEF_ARGS (PK_DEF_ARG (mi_version, PK_TYPE_INT),
+                           PK_DEF_ARG (version, PK_TYPE_STRING)))
 
 /* Request/Response: EXIT
 
@@ -95,8 +95,8 @@ PK_DEF_RESP (EXIT, PK_DEF_NOARG)
    is expected with a string contatining the printed representation of
    the given value, if the request was processed successfully.  */
 
-PK_DEF_REQ (PRINTV, PK_DEF_ARGS (PK_DEF_ARG (value, PK_ANY)))
-PK_DEF_RESP (PRINTV, PK_DEF_ARGS (PK_DEF_ARG (string, PK_STRING)))
+PK_DEF_REQ (PRINTV, PK_DEF_ARGS (PK_DEF_ARG (value, PK_TYPE_ANY)))
+PK_DEF_RESP (PRINTV, PK_DEF_ARGS (PK_DEF_ARG (string, PK_TYPE_STRING)))
 
 /* Event: INVREQ
 
@@ -113,8 +113,8 @@ PK_DEF_RESP (PRINTV, PK_DEF_ARGS (PK_DEF_ARG (string, 
PK_STRING)))
 */
 
 PK_DEF_EVENT (INVREQ,
-              PK_DEF_ARGS (PK_DEF_ARG (reqnum, PK_UINT),
-                           PK_DEF_ARG (errmsg, PK_STRING)))
+              PK_DEF_ARGS (PK_DEF_ARG (reqnum, PK_TYPE_UINT),
+                           PK_DEF_ARG (errmsg, PK_TYPE_STRING)))
 
 /* Cleanup.  */
 
-- 
2.11.0