wslua: Add support for base.RANGE_STRING handling.
authorRichard Sharpe <realrichardsharpe@gmail.com>
Sun, 14 Oct 2018 19:14:13 +0000 (12:14 -0700)
committerRichard Sharpe <realrichardsharpe@gmail.com>
Wed, 17 Oct 2018 20:08:57 +0000 (20:08 +0000)
A range string is passed as a table of tables, eg:

  range_string = {
     { 0, 24, "Some string for values 0 to 24" },
     { 25, 25, "The string for value 25" },
     { 26, 255, "The string for the remainder" }
  }

Included is a minimal Lua test for range strings and value strings
(which did not have one previously.) It will take more time than I
currently have to figure out how to do a more exhaustive test.

Also fixed some grammar issues in error messages along the way.

Change-Id: Ia9d1efc8adabb6528c4bdcf1624c9ede49e2fdc6
Reviewed-on: https://code.wireshark.org/review/30211
Reviewed-by: Peter Wu <peter@lekensteyn.nl>
Petri-Dish: Peter Wu <peter@lekensteyn.nl>
Reviewed-by: Richard Sharpe <realrichardsharpe@gmail.com>
epan/proto.c
epan/proto.h
epan/wslua/make-init-lua.pl
epan/wslua/wslua_proto_field.c
test/lua/tvb.lua

index 8f09e654bc2dde87197211cf5380b091f419753b..06769ab58f000e58522ca6cf8382de4e9888d015 100644 (file)
@@ -7429,6 +7429,12 @@ free_deregistered_field (gpointer data, gpointer user_data _U_)
                                        unit_name_string *unit = (unit_name_string*)hfi->strings;
                                        g_free ((gchar *)unit->singular);
                                        g_free ((gchar *)unit->plural);
+                                } else  if (hfi->display & BASE_RANGE_STRING) {
+                                       range_string *rs = (range_string *)hfi->strings;
+                                       while (rs->strptr) {
+                                               g_free((gchar *)rs->strptr);
+                                               rs++;
+                                       }
                                } else {
                                        value_string *vs = (value_string *)hfi->strings;
                                        while (vs->strptr) {
index c6bec70941ad8177339e8a8248ff2fa46bb65eda..d9721893937de6a8450b8ab46f531d607bc23ebb 100644 (file)
@@ -602,7 +602,7 @@ typedef enum {
 
 /* Following constants have to be ORed with a field_display_e when dissector
  * want to use specials value-string MACROs for a header_field_info */
-#define BASE_RANGE_STRING       0x0100
+#define BASE_RANGE_STRING       0x0100  /**< Use the supplied range string to convert the field to text */
 #define BASE_EXT_STRING         0x0200
 #define BASE_VAL64_STRING       0x0400
 #define BASE_ALLOW_ZERO         0x0800  /**< Display <none> instead of <MISSING> for zero sized byte array */
index 2d863429ee3b319dd409d167d00c5b943caa9e34..068a1b5b969af59f23dac011a1b93429094310ac 100755 (executable)
@@ -172,6 +172,12 @@ while(<PROTO_H>) {
         $bases_table .= "\t[\"$1\"] = $2,  -- $3\n";
     }
 
+    if (/^#define\s+BASE_(RANGE_STRING)[ ]*((?:0x)?[0-9]+)[ ]+(?:\/\*\*< (.*?) \*\/)?/) {
+        # Handle BASE_RANGE_STRING
+        my $num = hex($2);
+        $bases_table .= "\t[\"$1\"] = $num,  -- $3\n";
+    }
+
     if (/^#define\s+BASE_(UNIT_STRING)[ ]*((?:0x)?[0-9]+)[ ]+(?:\/\*\*< (.*?) \*\/)?/) {
         # Handle BASE_UNIT_STRING as a valid base value in Lua
         my $num = hex($2);
index 7af9b513a3ba2c11ad7e99f9acf1e3ecb8a08a7f..b660b66d665db4ae80f6b2733bcf827695949468 100644 (file)
@@ -19,7 +19,6 @@
 
 #include "wslua.h"
 
-
 /* WSLUA_CONTINUE_MODULE Proto */
 
 
@@ -140,6 +139,110 @@ static unsigned string_to_base(const gchar* str) {
     return BASE_NONE;
 }
 
+static void cleanup_range_string(GArray *rs) {
+    range_string *rs32 = (range_string *)(void *)(rs->data);
+
+    while (rs32->strptr) {
+        g_free((gchar *)rs32->strptr);
+        rs32++;
+    }
+    g_array_free(rs, TRUE);
+}
+
+static range_string * range_string_from_table(lua_State* L, int idx) {
+    GArray* rs;
+    range_string* rs32;
+
+    if (lua_isnil(L,idx)) {
+        return NULL;
+    } else if (!lua_istable(L,idx)) {
+        luaL_argerror(L,idx,"must be a table");
+        return NULL;
+    }
+
+    /*
+     * The first parameter set to TRUE means give us a zero-filled
+     * terminal entry.
+     */
+    rs = g_array_new(TRUE,TRUE,sizeof(range_string));
+
+    lua_pushnil(L);
+
+    while (lua_next(L, idx) != 0) {
+        int inner_idx;
+        int key_count = 0;
+        range_string r = {0,0,NULL};
+
+        if (!lua_istable(L, -1)) {
+            cleanup_range_string(rs);
+            luaL_argerror(L, idx, "All values of a table used as a range_string must be tables");
+            return NULL;
+        }
+
+        /*
+         * Now process the table ... it must have three elements,
+         * the min value, the max, both integers and a string.
+         *
+         * However, they are each separate items in the table and we
+         * ignore their keys.
+         */
+        inner_idx = lua_gettop(L);
+        lua_pushnil(L);
+
+        /*
+         * First two elements must be numbers, third is a string
+         */
+        while (lua_next(L, inner_idx) != 0) {
+            if (++key_count > 3) {
+                break;
+            }
+
+            switch (key_count) {
+            case 1:
+            case 2:
+                if (!lua_isnumber(L, -1)) {
+                    cleanup_range_string(rs);
+                    luaL_argerror(L, idx, "First two elements of a range string value must be integers");
+                    return NULL;
+                }
+                if (key_count == 1) /* We incremented it above */
+                    r.value_min = wslua_toguint32(L, -1);
+                else
+                    r.value_max = wslua_toguint32(L, -1);
+                break;
+
+            case 3:
+                if (lua_type(L, -1) != LUA_TSTRING) {
+                    cleanup_range_string(rs);
+                    luaL_argerror(L, idx, "Third element of a range string value must be a string");
+                    return NULL;
+                }
+                r.strptr = g_strdup(lua_tostring(L,-1));
+                /*
+                 * We append the value here to avoid a mem leak if there
+                 * are more than three entries in the table.
+                 */
+                g_array_append_val(rs,r);
+                break;
+            }
+
+            lua_pop(L, 1);
+        }
+
+        if (key_count != 3) {
+            cleanup_range_string(rs);
+            luaL_argerror(L, idx, "Values of a range string must be tables with exactly three elements");
+            return NULL;
+        }
+
+        lua_pop(L, 1);
+    }
+
+    rs32 = (range_string*)(void*)g_array_free(rs, FALSE);
+
+    return rs32;
+}
+
 static value_string* value_string_from_table(lua_State* L, int idx) {
     GArray* vs;
     value_string* vs32;
@@ -151,6 +254,10 @@ static value_string* value_string_from_table(lua_State* L, int idx) {
         return NULL;
     }
 
+    /*
+     * The first parameter set to TRUE means give us a zero-filled
+     * terminal entry.
+     */
     vs = g_array_new(TRUE,TRUE,sizeof(value_string));
 
     lua_pushnil(L);
@@ -204,6 +311,10 @@ static val64_string* val64_string_from_table(lua_State* L, int idx) {
         return NULL;
     }
 
+    /*
+     * The first parameter set to TRUE means give us a zero-filled
+     * terminal entry.
+     */
     vs = g_array_new(TRUE,TRUE,sizeof(val64_string));
 
     lua_pushnil(L);
@@ -409,12 +520,14 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
         `ftypes.SYSTEM_ID`, `ftypes.EUI64` or `ftypes.NONE`.
     */
 #define WSLUA_OPTARG_ProtoField_new_VALUESTRING 4 /* A table containing the text that
-        corresponds to the values, or a table containing unit name for the values if base is
-        `base.UNIT_STRING`, or one of `frametype.NONE`, `frametype.REQUEST`, `frametype.RESPONSE`,
-        `frametype.ACK` or `frametype.DUP_ACK` if field type is ftypes.FRAMENUM. */
+        corresponds to the values, or a table containing tables of range string values that
+        corresponds to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name
+        for the values if base is `base.UNIT_STRING`, or one of `frametype.NONE`, `frametype.REQUEST`,
+        `frametype.RESPONSE`, `frametype.ACK` or `frametype.DUP_ACK` if field type is ftypes.FRAMENUM. */
 #define WSLUA_OPTARG_ProtoField_new_BASE 5 /* The representation, one of: `base.NONE`, `base.DEC`,
                                               `base.HEX`, `base.OCT`, `base.DEC_HEX`,
-                                              `base.HEX_DEC` or `base.UNIT_STRING`. */
+                                              `base.HEX_DEC`, `base.UNIT_STRING` or
+                                              `base.RANGE_STRING`. */
 #define WSLUA_OPTARG_ProtoField_new_MASK 6 /* The bitmask to be used. */
 #define WSLUA_OPTARG_ProtoField_new_DESCR 7 /* The description of the field. */
 
@@ -424,6 +537,7 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
     const gchar* abbr = NULL;
     enum ftenum type;
     enum ft_framenum_type framenum_type = FT_FRAMENUM_NONE;
+    range_string *rs32 = NULL;
     value_string *vs32 = NULL;
     val64_string *vs64 = NULL;
     true_false_string *tfs = NULL;
@@ -431,7 +545,8 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
     unsigned base;
     guint32 mask = wslua_optguint32(L, WSLUA_OPTARG_ProtoField_new_MASK, 0x0);
     const gchar *blob = luaL_optstring(L,WSLUA_OPTARG_ProtoField_new_DESCR,NULL);
-    gboolean unit_string = FALSE;
+    gboolean base_unit_string = FALSE;
+    gboolean base_range_string = FALSE;
 
     if (!name[0]) {
         WSLUA_ARG_ERROR(ProtoField_new,NAME,"cannot be an empty string");
@@ -482,9 +597,18 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
     case FT_INT32:
     case FT_INT64:
         if (type != FT_CHAR && base & BASE_UNIT_STRING) {
-            unit_string = TRUE;
+            base_unit_string = TRUE;
             base &= ~BASE_UNIT_STRING;
         }
+        if (type != FT_CHAR && base & BASE_RANGE_STRING) {
+            base_range_string = TRUE;
+            base &= ~BASE_RANGE_STRING;
+        }
+        if (base_unit_string && base_range_string) {
+                WSLUA_OPTARG_ERROR(ProtoField_new, BASE, "Only one of base.UNIT_STRING and base.RANGE_STRING can be specified");
+                return 0;
+        }
+
         if (base == BASE_NONE) {
             if (type == FT_CHAR)
                 base = BASE_OCT; /* default base for characters (BASE_HEX instead?) */
@@ -502,8 +626,10 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
             return 0;
         }
         if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING) {
-            if (unit_string) {
+            if (base_unit_string) {
                 uns = unit_name_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING);
+            } else if (base_range_string) {
+                rs32 = range_string_from_table(L, WSLUA_OPTARG_ProtoField_new_VALUESTRING);
             } else if (type == FT_UINT64 || type == FT_INT64) {
                 vs64 = val64_string_from_table(L,WSLUA_OPTARG_ProtoField_new_VALUESTRING);
             } else {
@@ -561,7 +687,7 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
     case FT_FLOAT:
     case FT_DOUBLE:
         if (base & BASE_UNIT_STRING) {
-            unit_string = TRUE;
+            base_unit_string = TRUE;
             base &= ~BASE_UNIT_STRING;
         }
         if (nargs >= WSLUA_OPTARG_ProtoField_new_VALUESTRING) {
@@ -612,8 +738,13 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
         break;
     }
 
-    if (unit_string && !uns) {
-        WSLUA_OPTARG_ERROR(ProtoField_new,VALUESTRING, "Base is base.UNIT_STRING but no table is given");
+    if (base_unit_string && !uns) {
+        WSLUA_OPTARG_ERROR(ProtoField_new,VALUESTRING, "Base contains base.UNIT_STRING but no table was provided");
+        return 0;
+    }
+
+    if (base_range_string && !rs32) {
+        WSLUA_OPTARG_ERROR(ProtoField_new, VALUESTRING, "Base contains bas.RANGE_STRING but no table was provided")
         return 0;
     }
 
@@ -629,6 +760,9 @@ WSLUA_CONSTRUCTOR ProtoField_new(lua_State* L) {
         f->vs = TFS(tfs);
     } else if (vs32) {
         f->vs = VALS(vs32);
+    } else if (rs32) {
+        f->base |= BASE_RANGE_STRING;
+        f->vs = RVALS(rs32);
     } else if (vs64) {
         /* Indicate that we are using val64_string */
         f->base |= BASE_VAL64_STRING;
@@ -661,11 +795,13 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
     unsigned base = (unsigned)luaL_optinteger(L, 3, default_base);
     enum ft_framenum_type framenum_type = FT_FRAMENUM_NONE;
     value_string* vs32 = NULL;
+    range_string* rs32 = NULL;
     val64_string* vs64 = NULL;
     unit_name_string* uns = NULL;
     guint32 mask = wslua_optguint32(L,5,0);
     const gchar* blob = luaL_optstring(L,6,NULL);
-    gboolean unit_string = FALSE;
+    gboolean base_unit_string = FALSE;
+    gboolean base_range_string = FALSE;
 
     if (!name[0]) {
         luaL_argerror(L, 2, "cannot be an empty string");
@@ -673,13 +809,26 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
     }
 
     if (base & BASE_UNIT_STRING) {
-        unit_string = TRUE;
+        base_unit_string = TRUE;
         base &= ~BASE_UNIT_STRING;
         if (base == BASE_NONE) {
             base = BASE_DEC;
         }
     }
 
+    if (base & BASE_RANGE_STRING) {
+        base_range_string = TRUE;
+        base &= ~BASE_RANGE_STRING;
+        if (base == BASE_NONE) {
+            base = BASE_DEC;
+        }
+    }
+
+    if (base_unit_string && base_range_string) {
+        luaL_argerror(L, 4, "Only one of base.RANGE_STRING and base.UNIT_STRING can be specified");
+        return 0;
+    }
+
     if (lua_gettop(L) > 3 && !lua_isnil(L, 4)) {
         if (type == FT_FRAMENUM) {
             framenum_type = (enum ft_framenum_type) luaL_checkinteger(L, 4);
@@ -687,8 +836,10 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
                 luaL_argerror(L, 4, "Invalid frametype");
                 return 0;
             }
-        } else if (unit_string) {
+        } else if (base_unit_string) {
             uns = unit_name_string_from_table(L,4);
+        } else if (base_range_string) {
+            rs32 = range_string_from_table(L, 4);
         } else if (type == FT_UINT64 || type == FT_INT64) {
             vs64 = val64_string_from_table(L,4);
         } else {
@@ -711,8 +862,13 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
         return 0;
     }
 
-    if (unit_string && !uns) {
-        luaL_argerror(L, 4, "Base is base.UNIT_STRING but no table is given");
+    if (base_unit_string && !uns) {
+        luaL_argerror(L, 4, "Base contains base.UNIT_STRING but no table was given");
+        return 0;
+    }
+
+    if (base_range_string && !rs32) {
+        luaL_argerror(L, 4, "Base contains base.RANGE_STRING but no table was given");
         return 0;
     }
 
@@ -728,6 +884,9 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
         /* Indicate that we are using val64_string */
         f->base |= BASE_VAL64_STRING;
         f->vs = VALS64(vs64);
+    } else if (rs32) {
+        f->base |= BASE_RANGE_STRING;
+        f->vs = rs32;
     } else if (vs32) {
         f->vs = VALS(vs32);
     } else if (uns) {
@@ -755,7 +914,7 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* WSLUA_ARG_Protofield_uint8_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_uint8_NAME Actual name of the field (the string that appears in the tree). */
 /* WSLUA_OPTARG_Protofield_uint8_BASE One of `base.DEC`, `base.HEX` or `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_uint8_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint8_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing the unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_uint8_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_uint8_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -763,8 +922,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_uint16 Creates a `ProtoField` of an unsigned 16-bit integer. */
 /* WSLUA_ARG_Protofield_uint16_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_uint16_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_uint16_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_uint16_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint16_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC`, `base.UNIT_STRING` or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint16_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_uint16_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_uint16_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -772,8 +931,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_uint24 Creates a `ProtoField` of an unsigned 24-bit integer. */
 /* WSLUA_ARG_Protofield_uint24_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_uint24_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_uint24_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_uint24_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint24_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint24_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing the unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_uint24_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_uint24_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -781,8 +940,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_uint32 Creates a `ProtoField` of an unsigned 32-bit integer. */
 /* WSLUA_ARG_Protofield_uint32_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_uint32_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_uint32_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_uint32_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint32_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint32_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing the unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_uint32_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_uint32_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -790,8 +949,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_uint64 Creates a `ProtoField` of an unsigned 64-bit integer. */
 /* WSLUA_ARG_Protofield_uint64_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_uint64_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_uint64_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_uint64_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint64_BASE One of `base.DEC`, `base.HEX`, `base.OCT`, `base.DEC_HEX`, `base.HEX_DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_uint64_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing the unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_uint64_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_uint64_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -799,8 +958,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_int8 Creates a `ProtoField` of a signed 8-bit integer (i.e., a byte). */
 /* WSLUA_ARG_Protofield_int8_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_int8_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_int8_BASE One of `base.DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_int8_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_int8_BASE One of `base.DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_int8_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_int8_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_int8_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -808,8 +967,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_int16 Creates a `ProtoField` of a signed 16-bit integer. */
 /* WSLUA_ARG_Protofield_int16_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_int16_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_int16_BASE One of `base.DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_int16_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_int16_BASE One of `base.DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_int16_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_int16_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_int16_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -817,8 +976,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_int24 Creates a `ProtoField` of a signed 24-bit integer. */
 /* WSLUA_ARG_Protofield_int24_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_int24_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_int24_BASE One of `base.DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_int24_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_int24_BASE One of `base.DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_int24_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_int24_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_int24_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -826,8 +985,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_int32 Creates a `ProtoField` of a signed 32-bit integer. */
 /* WSLUA_ARG_Protofield_int32_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_int32_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_int32_BASE One of `base.DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_int32_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_int32_BASE One of `base.DEC`, `base.UNIT_STRING`, or `base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_int32_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_int32_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_int32_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
@@ -835,8 +994,8 @@ static int ProtoField_integer(lua_State* L, enum ftenum type) {
 /* _WSLUA_CONSTRUCTOR_ ProtoField_int64 Creates a `ProtoField` of a signed 64-bit integer. */
 /* WSLUA_ARG_Protofield_int64_ABBR Abbreviated name of the field (the string used in filters). */
 /* WSLUA_OPTARG_Protofield_int64_NAME Actual name of the field (the string that appears in the tree). */
-/* WSLUA_OPTARG_Protofield_int64_BASE One of `base.DEC` or `base.UNIT_STRING`. */
-/* WSLUA_OPTARG_Protofield_int64_VALUESTRING A table containing the text that corresponds to the values, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
+/* WSLUA_OPTARG_Protofield_int64_BASE One of `base.DEC`, `base.UNIT_STRING`, or`base.RANGE_STRING`. */
+/* WSLUA_OPTARG_Protofield_int64_VALUESTRING A table containing the text that corresponds to the values, or a table containing tables of range string values that correspond to the values ({min, max, "string"}) if the base is `base.RANGE_STRING`, or a table containing unit name for the values if base is `base.UNIT_STRING`. */
 /* WSLUA_OPTARG_Protofield_int64_MASK Integer mask of this field. */
 /* WSLUA_OPTARG_Protofield_int64_DESC Description of the field. */
 /* _WSLUA_RETURNS_ A `ProtoField` object to be added to a table set to the `Proto.fields` attribute. */
index e03a7b61b4499b25a3aadebe4a8bd47891219354..43a042ee852b6b90eb1b2779f0ce1582522a9d81 100644 (file)
@@ -142,13 +142,21 @@ end
 
 ----------------------------------------
 -- a table of all of our Protocol's fields
+range_string = {
+  { 0, 200, "The first part" },
+  { 201, 233, "The second part" },
+  { 234, 255, "The last part" },
+}
+
 local testfield =
 {
     basic =
     {
         STRING         = ProtoField.string ("test.basic.string",  "Basic string"),
         BOOLEAN        = ProtoField.bool   ("test.basic.boolean", "Basic boolean", 16, {"yes","no"}, 0x0001),
+        UINT8          = ProtoField.uint8  ("test.basic.uint8",   "Basic uint8 with range string", base.RANGE_STRING, range_string ),
         UINT16         = ProtoField.uint16 ("test.basic.uint16",  "Basic uint16"),
+        UINT32         = ProtoField.uint32 ("test.basic.uint32",  "Basic uint32 test with a unit string", base.UINT_STRING, { "femtoFarads" }),
         INT24          = ProtoField.int24  ("test.basic.uint24",  "Basic uint24"),
         BYTES          = ProtoField.bytes  ("test.basic.bytes",   "Basic Bytes"),
         UINT_BYTES     = ProtoField.ubytes ("test.basic.ubytes",  "Basic Uint Bytes"),
@@ -197,6 +205,7 @@ local getfield =
     {
         STRING         = Field.new ("test.basic.string"),
         BOOLEAN        = Field.new ("test.basic.boolean"),
+       UINT8          = Field.new ("test.basic.uint8"),
         UINT16         = Field.new ("test.basic.uint16"),
         INT24          = Field.new ("test.basic.uint24"),
         BYTES          = Field.new ("test.basic.bytes"),