epan/ftypes/ftype-double.c

   1 /*
   2  * Wireshark - Network traffic analyzer
   3  * By Gerald Combs <gerald@wireshark.org>
   4  * Copyright 2001 Gerald Combs
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-or-later
   7  */
   8
   9 #include "config.h"
  10
  11 #include <ftypes-int.h>
  12 #include <float.h>
  13 #include <wsutil/array.h>
  14
  15 static void
  16 double_fvalue_new(fvalue_t *fv)
  17 {
  18         fv->value.floating = 0.0;
  19 }
  20
  21 static void
  22 double_fvalue_set_floating(fvalue_t *fv, double value)
  23 {
  24         fv->value.floating = value;
  25 }
  26
  27 static double
  28 value_get_floating(fvalue_t *fv)
  29 {
  30         return fv->value.floating;
  31 }
  32
  33 static bool
  34 val_from_uinteger64(fvalue_t *fv, const char *s _U_, uint64_t value, char **err_msg _U_)
  35 {
  36         fv->value.floating = (double)value;
  37         return true;
  38 }
  39
  40 static bool
  41 val_from_sinteger64(fvalue_t *fv, const char *s _U_, int64_t value, char **err_msg _U_)
  42 {
  43         fv->value.floating = (double)value;
  44         return true;
  45 }
  46
  47 static bool
  48 val_from_double(fvalue_t *fv, const char *s _U_, double floating, char **err_msg _U_)
  49 {
  50         fv->value.floating = floating;
  51         return true;
  52 }
  53
  54 static char *
  55 float_val_to_repr(wmem_allocator_t *scope, const fvalue_t *fv, ftrepr_t rtype, int field_display _U_)
  56 {
  57         char *buf = wmem_alloc(scope, G_ASCII_DTOSTR_BUF_SIZE);
  58         if (rtype == FTREPR_DFILTER)
  59                 g_ascii_dtostr(buf, G_ASCII_DTOSTR_BUF_SIZE, fv->value.floating);
  60         else
  61                 g_ascii_formatd(buf, G_ASCII_DTOSTR_BUF_SIZE, "%." G_STRINGIFY(FLT_DIG) "g", fv->value.floating);
  62         return buf;
  63 }
  64
  65 static char *
  66 double_val_to_repr(wmem_allocator_t *scope, const fvalue_t *fv, ftrepr_t rtype, int field_display _U_)
  67 {
  68         char *buf = wmem_alloc(scope, G_ASCII_DTOSTR_BUF_SIZE);
  69         if (rtype == FTREPR_DFILTER)
  70                 g_ascii_dtostr(buf, G_ASCII_DTOSTR_BUF_SIZE, fv->value.floating);
  71         else
  72                 g_ascii_formatd(buf, G_ASCII_DTOSTR_BUF_SIZE, "%." G_STRINGIFY(DBL_DIG) "g", fv->value.floating);
  73         return buf;
  74 }
  75
  76 enum ft_result
  77 double_val_to_double(const fvalue_t *fv, double *repr)
  78 {
  79         *repr = fv->value.floating;
  80         return FT_OK;
  81 }
  82
  83 static enum ft_result
  84 val_unary_minus(fvalue_t * dst, const fvalue_t *src, char **err_ptr _U_)
  85 {
  86         dst->value.floating = -src->value.floating;
  87         return FT_OK;
  88 }
  89
  90 static enum ft_result
  91 val_add(fvalue_t * dst, const fvalue_t *a, const fvalue_t *b, char **err_ptr _U_)
  92 {
  93         dst->value.floating = a->value.floating + b->value.floating;
  94         return FT_OK;
  95 }
  96
  97 static enum ft_result
  98 val_subtract(fvalue_t * dst, const fvalue_t *a, const fvalue_t *b, char **err_ptr _U_)
  99 {
 100         dst->value.floating = a->value.floating - b->value.floating;
 101         return FT_OK;
 102 }
 103
 104 static enum ft_result
 105 val_multiply(fvalue_t * dst, const fvalue_t *a, const fvalue_t *b, char **err_ptr _U_)
 106 {
 107         dst->value.floating = a->value.floating * b->value.floating;
 108         return FT_OK;
 109 }
 110
 111 static enum ft_result
 112 val_divide(fvalue_t * dst, const fvalue_t *a, const fvalue_t *b, char **err_ptr _U_)
 113 {
 114         dst->value.floating = a->value.floating / b->value.floating;
 115         return FT_OK;
 116 }
 117
 118 static enum ft_result
 119 cmp_order(const fvalue_t *a, const fvalue_t *b, int *cmp)
 120 {
 121         if (a->value.floating < b->value.floating)
 122                 *cmp = -1;
 123         else if (a->value.floating > b->value.floating)
 124                 *cmp = 1;
 125         else
 126                 *cmp = 0;
 127         return FT_OK;
 128 }
 129
 130 static bool
 131 val_is_zero(const fvalue_t *fv_a)
 132 {
 133         return fv_a->value.floating == 0;
 134 }
 135
 136 static bool
 137 val_is_negative(const fvalue_t *fv_a)
 138 {
 139         return fv_a->value.floating < 0;
 140 }
 141
 142 static unsigned
 143 val_hash(const fvalue_t *fv)
 144 {
 145         return g_double_hash(&fv->value.floating);
 146 }
 147
 148 void
 149 ftype_register_double(void)
 150 {
 151
 152         static const ftype_t float_type = {
 153                 FT_FLOAT,                       /* ftype */
 154                 0,                              /* wire_size */
 155                 double_fvalue_new,              /* new_value */
 156                 NULL,                           /* copy_value */
 157                 NULL,                           /* free_value */
 158                 NULL,                           /* val_from_literal */
 159                 NULL,                           /* val_from_string */
 160                 NULL,                           /* val_from_charconst */
 161                 val_from_uinteger64,            /* val_from_uinteger64 */
 162                 val_from_sinteger64,            /* val_from_sinteger64 */
 163                 val_from_double,                /* val_from_double */
 164                 float_val_to_repr,              /* val_to_string_repr */
 165
 166                 NULL,                           /* val_to_uinteger64 */
 167                 NULL,                           /* val_to_sinteger64 */
 168                 double_val_to_double,           /* val_to_double */
 169
 170                 { .set_value_floating = double_fvalue_set_floating },           /* union set_value */
 171                 { .get_value_floating = value_get_floating },   /* union get_value */
 172
 173                 cmp_order,
 174                 NULL,                           /* cmp_contains */
 175                 NULL,                           /* cmp_matches */
 176
 177                 val_hash,                       /* hash */
 178                 val_is_zero,                    /* is_zero */
 179                 val_is_negative,                /* is_negative */
 180                 NULL,                           /* len */
 181                 NULL,                           /* slice */
 182                 NULL,                           /* bitwise_and */
 183                 val_unary_minus,                /* unary_minus */
 184                 val_add,                        /* add */
 185                 val_subtract,                   /* subtract */
 186                 val_multiply,                   /* multiply */
 187                 val_divide,                     /* divide */
 188                 NULL,                           /* modulo */
 189         };
 190
 191         static const ftype_t double_type = {
 192                 FT_DOUBLE,                      /* ftype */
 193                 0,                              /* wire_size */
 194                 double_fvalue_new,              /* new_value */
 195                 NULL,                           /* copy_value */
 196                 NULL,                           /* free_value */
 197                 NULL,                           /* val_from_literal */
 198                 NULL,                           /* val_from_string */
 199                 NULL,                           /* val_from_charconst */
 200                 val_from_uinteger64,            /* val_from_uinteger64 */
 201                 val_from_sinteger64,            /* val_from_sinteger64 */
 202                 val_from_double,                /* val_from_double */
 203                 double_val_to_repr,             /* val_to_string_repr */
 204
 205                 NULL,                           /* val_to_uinteger64 */
 206                 NULL,                           /* val_to_sinteger64 */
 207                 double_val_to_double,           /* val_to_double */
 208
 209                 { .set_value_floating = double_fvalue_set_floating },           /* union set_value */
 210                 { .get_value_floating = value_get_floating },   /* union get_value */
 211
 212                 cmp_order,
 213                 NULL,                           /* cmp_contains */
 214                 NULL,                           /* cmp_matches */
 215
 216                 val_hash,                       /* hash */
 217                 val_is_zero,                    /* is_zero */
 218                 val_is_negative,                /* is_negative */
 219                 NULL,                           /* len */
 220                 NULL,                           /* slice */
 221                 NULL,                           /* bitwise_and */
 222                 val_unary_minus,                /* unary_minus */
 223                 val_add,                        /* add */
 224                 val_subtract,                   /* subtract */
 225                 val_multiply,                   /* multiply */
 226                 val_divide,                     /* divide */
 227                 NULL,                           /* modulo */
 228         };
 229
 230         ftype_register(FT_FLOAT, &float_type);
 231         ftype_register(FT_DOUBLE, &double_type);
 232 }
 233
 234 void
 235 ftype_register_pseudofields_double(int proto)
 236 {
 237         static int hf_ft_float;
 238         static int hf_ft_double;
 239
 240         static hf_register_info hf_ftypes[] = {
 241                 { &hf_ft_float,
 242                     { "FT_FLOAT", "_ws.ftypes.float",
 243                         FT_FLOAT, BASE_NONE, NULL, 0x00,
 244                         NULL, HFILL }
 245                 },
 246                 { &hf_ft_double,
 247                     { "FT_DOUBLE", "_ws.ftypes.double",
 248                         FT_DOUBLE, BASE_NONE, NULL, 0x00,
 249                         NULL, HFILL }
 250                 },
 251         };
 252
 253         proto_register_field_array(proto, hf_ftypes, array_length(hf_ftypes));
 254 }
 255
 256 /*
 257  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 258  *
 259  * Local variables:
 260  * c-basic-offset: 8
 261  * tab-width: 8
 262  * indent-tabs-mode: t
 263  * End:
 264  *
 265  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 266  * :indentSize=8:tabSize=8:noTabs=false:
 267  */