osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

ftypes: Use an order function to compare ftypes 

All the order operators can be defined in terms of 'lt'
and 'eq' so use that to reduce the number of required
methods from 6 to 2.

Further reduce to one by combining those two into a single
function that has memcmp semantics: negative return is
"less than", positive is "greater than" and zero is equal.
This commit is contained in:
João Valverde 2021-10-10 16:00:51 +01:00 committed by Wireshark GitLab Utility
parent 6299a66a92
commit 13e9e7199c
13 changed files with 151 additions and 1389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
epan/ftypes/ftype-bytes.c
View File

@ -525,101 +525,16 @@ slice(fvalue_t *fv, GByteArray *bytes, guint offset, guint length)
g_byte_array_append(bytes, data, length);
}
static gboolean
cmp_eq(const fvalue_t *fv_a, const fvalue_t *fv_b)
static int
cmp_order(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len != b->len) {
return FALSE;
}
if (a->len != b->len)
return a->len < b->len ? -1 : 1;
return (memcmp(a->data, b->data, a->len) == 0);
}
static gboolean
cmp_ne(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len != b->len) {
return TRUE;
}
return (memcmp(a->data, b->data, a->len) != 0);
}
static gboolean
cmp_gt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len > b->len) {
return TRUE;
}
if (a->len < b->len) {
return FALSE;
}
return (memcmp(a->data, b->data, a->len) > 0);
}
static gboolean
cmp_ge(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len > b->len) {
return TRUE;
}
if (a->len < b->len) {
return FALSE;
}
return (memcmp(a->data, b->data, a->len) >= 0);
}
static gboolean
cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len < b->len) {
return TRUE;
}
if (a->len > b->len) {
return FALSE;
}
return (memcmp(a->data, b->data, a->len) < 0);
}
static gboolean
cmp_le(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
GByteArray *a = fv_a->value.bytes;
GByteArray *b = fv_b->value.bytes;
if (a->len < b->len) {
return TRUE;
}
if (a->len > b->len) {
return FALSE;
}
return (memcmp(a->data, b->data, a->len) <= 0);
return memcmp(a->data, b->data, a->len);
}
static gboolean
@ -694,12 +609,7 @@ ftype_register_bytes(void)
{ .set_value_byte_array = bytes_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
CMP_MATCHES,
@ -723,12 +633,7 @@ ftype_register_bytes(void)
{ .set_value_byte_array = bytes_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
NULL, /* cmp_matches */
@ -752,12 +657,7 @@ ftype_register_bytes(void)
{ .set_value_bytes = ax25_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
CMP_MATCHES,
@ -781,12 +681,7 @@ ftype_register_bytes(void)
{ .set_value_bytes = vines_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
CMP_MATCHES,
@ -810,12 +705,7 @@ ftype_register_bytes(void)
{ .set_value_bytes = ether_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
CMP_MATCHES,
@ -839,12 +729,7 @@ ftype_register_bytes(void)
{ .set_value_byte_array = oid_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
NULL, /* cmp_matches */
@ -868,12 +753,7 @@ ftype_register_bytes(void)
{ .set_value_byte_array = oid_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
NULL, /* cmp_matches */
@ -897,12 +777,7 @@ ftype_register_bytes(void)
{ .set_value_byte_array = system_id_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
NULL, /* cmp_matches */
@ -926,12 +801,7 @@ ftype_register_bytes(void)
{ .set_value_bytes = fcwwn_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
cmp_contains,
CMP_MATCHES,

54
epan/ftypes/ftype-double.c
View File

@ -91,40 +91,14 @@ double_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_, char
g_ascii_formatd(buf, size, "%." G_STRINGIFY(DBL_DIG) "g", fv->value.floating);
}
static gboolean
cmp_eq(const fvalue_t *a, const fvalue_t *b)
static int
cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating == b->value.floating;
}
static gboolean
cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating != b->value.floating;
}
static gboolean
cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating > b->value.floating;
}
static gboolean
cmp_ge(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating >= b->value.floating;
}
static gboolean
cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating < b->value.floating;
}
static gboolean
cmp_le(const fvalue_t *a, const fvalue_t *b)
{
return a->value.floating <= b->value.floating;
if (a->value.floating < b->value.floating)
return -1;
if (a->value.floating > b->value.floating)
return 1;
return 0;
}
void
@ -146,12 +120,7 @@ ftype_register_double(void)
{ .set_value_floating = double_fvalue_set_floating }, /* union set_value */
{ .get_value_floating = value_get_floating }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -175,12 +144,7 @@ ftype_register_double(void)
{ .set_value_floating = double_fvalue_set_floating }, /* union set_value */
{ .get_value_floating = value_get_floating }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */

19
epan/ftypes/ftype-guid.c
View File

@ -93,16 +93,10 @@ guid_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_, char *buf,
guid_to_str_buf(&fv->value.guid, buf, size);
}
static gboolean
cmp_eq(const fvalue_t *a, const fvalue_t *b)
static int
cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return memcmp(&a->value.guid, &b->value.guid, sizeof(e_guid_t)) == 0;
}
static gboolean
cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return memcmp(&a->value.guid, &b->value.guid, sizeof(e_guid_t)) != 0;
return memcmp(&a->value.guid, &b->value.guid, sizeof(e_guid_t));
}
void
@ -124,12 +118,7 @@ ftype_register_guid(void)
{ .set_value_guid = guid_fvalue_set_guid }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
NULL,
NULL,
NULL,
NULL,
cmp_order,
NULL,
NULL,
NULL, /* cmp_matches */

546
epan/ftypes/ftype-ieee-11073-float.c
View File

@ -357,192 +357,6 @@ sfloat_ieee_11073_cmp_eq(const fvalue_t *a, const fvalue_t *b)
return sfloat_to_normal_form(a->value.sfloat_ieee_11073) == sfloat_to_normal_form(b->value.sfloat_ieee_11073);
}
static gboolean
sfloat_ieee_11073_cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return sfloat_to_normal_form(a->value.sfloat_ieee_11073) != sfloat_to_normal_form(b->value.sfloat_ieee_11073);
}
static gboolean
sfloat_ieee_11073_cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
guint16 a_norm;
guint16 b_norm;
gint16 a_norm_mantissa;
gint16 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = sfloat_to_normal_form(a->value.sfloat_ieee_11073);
b_norm = sfloat_to_normal_form(b->value.sfloat_ieee_11073);
if (a_norm == b_norm)
return FALSE;
switch (a_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_MINUS:
return FALSE;
case SFLOAT_VALUE_INFINITY_PLUS:
switch (b_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_PLUS: /* Dead, informative case */
return FALSE;
case SFLOAT_VALUE_INFINITY_MINUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x0FFF;
b_norm_mantissa = b_norm & 0x0FFF;
if (a_norm & 0x0800)
a_norm_mantissa |= 0xF000;
if (b_norm & 0x0800)
b_norm_mantissa |= 0xF000;
a_norm_exponent = a_norm >> 12;
b_norm_exponent = b_norm >> 12;
if (a_norm_exponent & 0x08) {
a_norm_exponent |= 0xF0;
}
if (b_norm_exponent & 0x08) {
b_norm_exponent |= 0xF0;
}
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent > b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa > b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 4)
return FALSE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 4)
return TRUE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa > b_norm_mantissa)
return TRUE;
return FALSE;
}
static gboolean
sfloat_ieee_11073_cmp_ge(const fvalue_t *a, const fvalue_t *b)
{
guint16 a_norm;
guint16 b_norm;
gint16 a_norm_mantissa;
gint16 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = sfloat_to_normal_form(a->value.sfloat_ieee_11073);
b_norm = sfloat_to_normal_form(b->value.sfloat_ieee_11073);
if (a_norm == b_norm)
return TRUE;
switch (a_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_MINUS:
return FALSE;
case SFLOAT_VALUE_INFINITY_PLUS:
switch (b_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_PLUS: /* Dead, informative case */
return FALSE;
case SFLOAT_VALUE_INFINITY_MINUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x0FFF;
b_norm_mantissa = b_norm & 0x0FFF;
if (a_norm & 0x0800)
a_norm_mantissa |= 0xF000;
if (b_norm & 0x0800)
b_norm_mantissa |= 0xF000;
a_norm_exponent = a_norm >> 12;
b_norm_exponent = b_norm >> 12;
if (a_norm_exponent & 0x08) {
a_norm_exponent |= 0xF0;
}
if (b_norm_exponent & 0x08) {
b_norm_exponent |= 0xF0;
}
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent >= b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa >= b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 4)
return FALSE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 4)
return TRUE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa > b_norm_mantissa)
return TRUE;
return FALSE;
}
static gboolean
sfloat_ieee_11073_cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
@ -633,94 +447,12 @@ sfloat_ieee_11073_cmp_lt(const fvalue_t *a, const fvalue_t *b)
return FALSE;
}
static gboolean
sfloat_ieee_11073_cmp_le(const fvalue_t *a, const fvalue_t *b)
static int
sfloat_ieee_11073_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
guint16 a_norm;
guint16 b_norm;
gint16 a_norm_mantissa;
gint16 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = sfloat_to_normal_form(a->value.sfloat_ieee_11073);
b_norm = sfloat_to_normal_form(b->value.sfloat_ieee_11073);
if (a_norm == b_norm)
return TRUE;
switch (a_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_PLUS:
return FALSE;
case SFLOAT_VALUE_INFINITY_MINUS:
switch (b_norm) {
case SFLOAT_VALUE_NAN:
case SFLOAT_VALUE_NRES:
case SFLOAT_VALUE_RFU:
case SFLOAT_VALUE_INFINITY_MINUS: /* Dead, informative case */
return FALSE;
case SFLOAT_VALUE_INFINITY_PLUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x0FFF;
b_norm_mantissa = b_norm & 0x0FFF;
if (a_norm & 0x0800)
a_norm_mantissa |= 0xF000;
if (b_norm & 0x0800)
b_norm_mantissa |= 0xF000;
a_norm_exponent = a_norm >> 12;
b_norm_exponent = b_norm >> 12;
if (a_norm_exponent & 0x08) {
a_norm_exponent |= 0xF0;
}
if (b_norm_exponent & 0x08) {
b_norm_exponent |= 0xF0;
}
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent <= b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa <= b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 4)
return TRUE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 4)
return FALSE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa < b_norm_mantissa)
return TRUE;
return FALSE;
if (sfloat_ieee_11073_cmp_lt(a, b))
return -1;
return sfloat_ieee_11073_cmp_eq(a, b) ? 0 : 1;
}
static gboolean
@ -1045,176 +777,6 @@ float_ieee_11073_cmp_eq(const fvalue_t *a, const fvalue_t *b)
return float_to_normal_form(a->value.float_ieee_11073) == float_to_normal_form(b->value.float_ieee_11073);
}
static gboolean
float_ieee_11073_cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return float_to_normal_form(a->value.float_ieee_11073) != float_to_normal_form(b->value.float_ieee_11073);
}
static gboolean
float_ieee_11073_cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
guint32 a_norm;
guint32 b_norm;
gint32 a_norm_mantissa;
gint32 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = float_to_normal_form(a->value.float_ieee_11073);
b_norm = float_to_normal_form(b->value.float_ieee_11073);
if (a_norm == b_norm)
return FALSE;
switch (a_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_MINUS:
return FALSE;
case FLOAT_VALUE_INFINITY_PLUS:
switch (b_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_PLUS: /* Dead, informative case */
return FALSE;
case FLOAT_VALUE_INFINITY_MINUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x00FFFFFF;
b_norm_mantissa = b_norm & 0x00FFFFFF;
if (a_norm & 0x00800000)
a_norm_mantissa |= 0xFF000000;
if (b_norm & 0x00800000)
b_norm_mantissa |= 0xFF000000;
a_norm_exponent = a_norm >> 24;
b_norm_exponent = b_norm >> 24;
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent > b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa > b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 7)
return FALSE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 7)
return TRUE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa > b_norm_mantissa)
return TRUE;
return FALSE;
}
static gboolean
float_ieee_11073_cmp_ge(const fvalue_t *a, const fvalue_t *b)
{
guint32 a_norm;
guint32 b_norm;
gint32 a_norm_mantissa;
gint32 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = float_to_normal_form(a->value.float_ieee_11073);
b_norm = float_to_normal_form(b->value.float_ieee_11073);
if (a_norm == b_norm)
return TRUE;
switch (a_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_MINUS:
return FALSE;
case FLOAT_VALUE_INFINITY_PLUS:
switch (b_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_PLUS: /* Dead, informative case */
return FALSE;
case FLOAT_VALUE_INFINITY_MINUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x00FFFFFF;
b_norm_mantissa = b_norm & 0x00FFFFFF;
if (a_norm & 0x00800000)
a_norm_mantissa |= 0xFF000000;
if (b_norm & 0x00800000)
b_norm_mantissa |= 0xFF000000;
a_norm_exponent = a_norm >> 24;
b_norm_exponent = b_norm >> 24;
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent >= b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa >= b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 7)
return FALSE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 7)
return TRUE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa > b_norm_mantissa)
return TRUE;
return FALSE;
}
static gboolean
float_ieee_11073_cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
@ -1297,86 +859,12 @@ float_ieee_11073_cmp_lt(const fvalue_t *a, const fvalue_t *b)
return FALSE;
}
static gboolean
float_ieee_11073_cmp_le(const fvalue_t *a, const fvalue_t *b)
static int
float_ieee_11073_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
guint32 a_norm;
guint32 b_norm;
gint32 a_norm_mantissa;
gint32 b_norm_mantissa;
gint8 a_norm_exponent;
gint8 b_norm_exponent;
a_norm = float_to_normal_form(a->value.float_ieee_11073);
b_norm = float_to_normal_form(b->value.float_ieee_11073);
if (a_norm == b_norm)
return TRUE;
switch (a_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_PLUS:
return FALSE;
case FLOAT_VALUE_INFINITY_MINUS:
switch (b_norm) {
case FLOAT_VALUE_NAN:
case FLOAT_VALUE_NRES:
case FLOAT_VALUE_RFU:
case FLOAT_VALUE_INFINITY_MINUS: /* Dead, informative case */
return FALSE;
case FLOAT_VALUE_INFINITY_PLUS:
default:
return TRUE;
}
}
a_norm_mantissa = a_norm & 0x00FFFFFF;
b_norm_mantissa = b_norm & 0x00FFFFFF;
if (a_norm & 0x00800000)
a_norm_mantissa |= 0xFF000000;
if (b_norm & 0x00800000)
b_norm_mantissa |= 0xFF000000;
a_norm_exponent = a_norm >> 24;
b_norm_exponent = b_norm >> 24;
if (a_norm_mantissa == b_norm_mantissa && a_norm_exponent <= b_norm_exponent)
return TRUE;
if (a_norm_exponent == b_norm_exponent && a_norm_mantissa <= b_norm_mantissa)
return TRUE;
if (a_norm_exponent < b_norm_exponent) {
guint8 exponent_difference;
exponent_difference = b_norm_exponent - a_norm_exponent;
if (exponent_difference >= 7)
return TRUE;
while (exponent_difference--) {
b_norm_mantissa *= 10;
}
} else {
guint8 exponent_difference;
exponent_difference = a_norm_exponent - b_norm_exponent;
if (exponent_difference >= 7)
return FALSE;
while (exponent_difference--) {
a_norm_mantissa *= 10;
}
}
if (a_norm_mantissa < b_norm_mantissa)
return TRUE;
return FALSE;
if (float_ieee_11073_cmp_lt(a, b))
return -1;
return float_ieee_11073_cmp_eq(a, b) ? 0 : 1;
}
static gboolean
@ -1431,12 +919,7 @@ Example: 114 is 0x0072
{ .set_value_uinteger = sfloat_ieee_11073_value_set }, /* union set_value */
{ .get_value_uinteger = sfloat_ieee_11073_value_get }, /* union get_value */
sfloat_ieee_11073_cmp_eq,
sfloat_ieee_11073_cmp_ne,
sfloat_ieee_11073_cmp_gt,
sfloat_ieee_11073_cmp_ge,
sfloat_ieee_11073_cmp_lt,
sfloat_ieee_11073_cmp_le,
sfloat_ieee_11073_cmp_order,
sfloat_ieee_11073_cmp_bitwise_and, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1487,12 +970,7 @@ Example: 36.4 is 0xFF00016C
{ .set_value_uinteger = float_ieee_11073_value_set }, /* union set_value */
{ .get_value_uinteger = float_ieee_11073_value_get }, /* union get_value */
float_ieee_11073_cmp_eq,
float_ieee_11073_cmp_ne,
float_ieee_11073_cmp_gt,
float_ieee_11073_cmp_ge,
float_ieee_11073_cmp_lt,
float_ieee_11073_cmp_le,
float_ieee_11073_cmp_order,
float_ieee_11073_cmp_bitwise_and, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */

310
epan/ftypes/ftype-integer.c
View File

@ -557,64 +557,36 @@ ipxnet_to_repr(fvalue_t *fv, ftrepr_t rtype, int field_display _U_, char *buf, u
uinteger_to_repr(fv, rtype, BASE_HEX, buf, size);
}
static gboolean
cmp_eq(const fvalue_t *a, const fvalue_t *b)
static int
uinteger_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger == b->value.uinteger;
if (a->value.uinteger == b->value.uinteger)
return 0;
return a->value.uinteger < b->value.uinteger ? -1 : 1;
}
static gboolean
cmp_ne(const fvalue_t *a, const fvalue_t *b)
static int
sinteger_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger != b->value.uinteger;
if (a->value.sinteger == b->value.sinteger)
return 0;
return a->value.sinteger < b->value.sinteger ? -1 : 1;
}
static gboolean
u_cmp_gt(const fvalue_t *a, const fvalue_t *b)
static int
uinteger64_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger > b->value.uinteger;
if (a->value.uinteger64 == b->value.uinteger64)
return 0;
return a->value.uinteger64 < b->value.uinteger64 ? -1 : 1;
}
static gboolean
u_cmp_ge(const fvalue_t *a, const fvalue_t *b)
static int
sinteger64_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger >= b->value.uinteger;
}
static gboolean
u_cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger < b->value.uinteger;
}
static gboolean
u_cmp_le(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger <= b->value.uinteger;
}
static gboolean
s_cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
return a->value.sinteger > b->value.sinteger;
}
static gboolean
s_cmp_ge(const fvalue_t *a, const fvalue_t *b)
{
return a->value.sinteger >= b->value.sinteger;
}
static gboolean
s_cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
return a->value.sinteger < b->value.sinteger;
}
static gboolean
s_cmp_le(const fvalue_t *a, const fvalue_t *b)
{
return a->value.sinteger <= b->value.sinteger;
if (a->value.sinteger64 == b->value.sinteger64)
return 0;
return a->value.sinteger64 < b->value.sinteger64 ? -1 : 1;
}
static gboolean
@ -856,66 +828,6 @@ uinteger64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display, char *bu
}
}
static gboolean
cmp_eq64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 == b->value.uinteger64;
}
static gboolean
cmp_ne64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 != b->value.uinteger64;
}
static gboolean
u_cmp_gt64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 > b->value.uinteger64;
}
static gboolean
u_cmp_ge64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 >= b->value.uinteger64;
}
static gboolean
u_cmp_lt64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 < b->value.uinteger64;
}
static gboolean
u_cmp_le64(const fvalue_t *a, const fvalue_t *b)
{
return a->value.uinteger64 <= b->value.uinteger64;
}
static gboolean
s_cmp_gt64(const fvalue_t *a, const fvalue_t *b)
{
return (gint64)a->value.sinteger64 > (gint64)b->value.sinteger64;
}
static gboolean
s_cmp_ge64(const fvalue_t *a, const fvalue_t *b)
{
return (gint64)a->value.sinteger64 >= (gint64)b->value.sinteger64;
}
static gboolean
s_cmp_lt64(const fvalue_t *a, const fvalue_t *b)
{
return (gint64)a->value.sinteger64 < (gint64)b->value.sinteger64;
}
static gboolean
s_cmp_le64(const fvalue_t *a, const fvalue_t *b)
{
return (gint64)a->value.sinteger64 <= (gint64)b->value.sinteger64;
}
static gboolean
cmp_bitwise_and64(const fvalue_t *a, const fvalue_t *b)
{
@ -943,33 +855,26 @@ boolean_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_, char *b
*buf = '\0';
}
/* Checks for equality with zero or non-zero */
static gboolean
bool_eq(const fvalue_t *a, const fvalue_t *b)
/* False is less than True (arbitrary):
* A B cmp(A, B)
* T T 0
* F F 0
* F T -1
* T F 1
*/
static int
bool_cmp_order(const fvalue_t *a, const fvalue_t *b)
{
if (a->value.uinteger64) {
if (b->value.uinteger64) {
return TRUE;
}
else {
return FALSE;
return 0;
}
return 1;
}
else {
if (b->value.uinteger64) {
return FALSE;
}
else {
return TRUE;
}
if (b->value.uinteger64) {
return -1;
}
}
/* Checks for inequality with zero or non-zero */
static gboolean
bool_ne(const fvalue_t *a, const fvalue_t *b)
{
return (!bool_eq(a,b));
return 0;
}
/* EUI64-specific */
@ -1047,12 +952,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1075,12 +975,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1103,12 +998,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1131,12 +1021,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1159,12 +1044,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1187,12 +1067,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
u_cmp_gt64,
u_cmp_ge64,
u_cmp_lt64,
u_cmp_le64,
uinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1215,12 +1090,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
u_cmp_gt64,
u_cmp_ge64,
u_cmp_lt64,
u_cmp_le64,
uinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1243,12 +1113,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
u_cmp_gt64,
u_cmp_ge64,
u_cmp_lt64,
u_cmp_le64,
uinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1271,12 +1136,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
u_cmp_gt64,
u_cmp_ge64,
u_cmp_lt64,
u_cmp_le64,
uinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1299,12 +1159,7 @@ ftype_register_integers(void)
{ .set_value_sinteger = set_sinteger }, /* union set_value */
{ .get_value_sinteger = get_sinteger }, /* union get_value */
cmp_eq,
cmp_ne,
s_cmp_gt,
s_cmp_ge,
s_cmp_lt,
s_cmp_le,
sinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1327,12 +1182,7 @@ ftype_register_integers(void)
{ .set_value_sinteger = set_sinteger }, /* union set_value */
{ .get_value_sinteger = get_sinteger }, /* union get_value */
cmp_eq,
cmp_ne,
s_cmp_gt,
s_cmp_ge,
s_cmp_lt,
s_cmp_le,
sinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1355,12 +1205,7 @@ ftype_register_integers(void)
{ .set_value_sinteger = set_sinteger }, /* union set_value */
{ .get_value_sinteger = get_sinteger }, /* union get_value */
cmp_eq,
cmp_ne,
s_cmp_gt,
s_cmp_ge,
s_cmp_lt,
s_cmp_le,
sinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1383,12 +1228,7 @@ ftype_register_integers(void)
{ .set_value_sinteger = set_sinteger }, /* union set_value */
{ .get_value_sinteger = get_sinteger }, /* union get_value */
cmp_eq,
cmp_ne,
s_cmp_gt,
s_cmp_ge,
s_cmp_lt,
s_cmp_le,
sinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1411,12 +1251,7 @@ ftype_register_integers(void)
{ .set_value_sinteger64 = set_sinteger64 }, /* union set_value */
{ .get_value_sinteger64 = get_sinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
s_cmp_gt64,
s_cmp_ge64,
s_cmp_lt64,
s_cmp_le64,
sinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1439,12 +1274,7 @@ ftype_register_integers(void)
{ .set_value_sinteger64 = set_sinteger64 }, /* union set_value */
{ .get_value_sinteger64 = get_sinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
s_cmp_gt64,
s_cmp_ge64,
s_cmp_lt64,
s_cmp_le64,
sinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1467,12 +1297,7 @@ ftype_register_integers(void)
{ .set_value_sinteger64 = set_sinteger64 }, /* union set_value */
{ .get_value_sinteger64 = get_sinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
s_cmp_gt64,
s_cmp_ge64,
s_cmp_lt64,
s_cmp_le64,
sinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1495,12 +1320,7 @@ ftype_register_integers(void)
{ .set_value_sinteger64 = set_sinteger64 }, /* union set_value */
{ .get_value_sinteger64 = get_sinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
s_cmp_gt64,
s_cmp_ge64,
s_cmp_lt64,
s_cmp_le64,
sinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1523,12 +1343,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
bool_eq, /* cmp_eq */
bool_ne, /* cmp_ne */
NULL, /* cmp_gt */
NULL, /* cmp_ge */
NULL, /* cmp_lt */
NULL, /* cmp_le */
bool_cmp_order, /* cmp_eq */
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1552,12 +1367,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1581,12 +1391,7 @@ ftype_register_integers(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = get_uinteger }, /* union get_value */
cmp_eq,
cmp_ne,
u_cmp_gt,
u_cmp_ge,
u_cmp_lt,
u_cmp_le,
uinteger_cmp_order,
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -1610,12 +1415,7 @@ ftype_register_integers(void)
{ .set_value_uinteger64 = set_uinteger64 }, /* union set_value */
{ .get_value_uinteger64 = get_uinteger64 }, /* union get_value */
cmp_eq64,
cmp_ne64,
u_cmp_gt64,
u_cmp_ge64,
u_cmp_lt64,
u_cmp_le64,
uinteger64_cmp_order,
cmp_bitwise_and64,
NULL, /* cmp_contains */
NULL, /* cmp_matches */

70
epan/ftypes/ftype-ipv4.c
View File

@ -119,70 +119,17 @@ val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_, char *buf,
* So, for example, w.x.y.z/32 eq w.x.y.0/24 is TRUE.
*/
static gboolean
cmp_eq(const fvalue_t *fv_a, const fvalue_t *fv_b)
static int
cmp_order(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a == addr_b);
}
static gboolean
cmp_ne(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a != addr_b);
}
static gboolean
cmp_gt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a > addr_b);
}
static gboolean
cmp_ge(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a >= addr_b);
}
static gboolean
cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a < addr_b);
}
static gboolean
cmp_le(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
guint32 addr_a, addr_b, nmask;
nmask = MIN(fv_a->value.ipv4.nmask, fv_b->value.ipv4.nmask);
addr_a = fv_a->value.ipv4.addr & nmask;
addr_b = fv_b->value.ipv4.addr & nmask;
return (addr_a <= addr_b);
if (addr_a == addr_b)
return 0;
return addr_a < addr_b ? -1 : 1;
}
static gboolean
@ -224,12 +171,7 @@ ftype_register_ipv4(void)
{ .set_value_uinteger = set_uinteger }, /* union set_value */
{ .get_value_uinteger = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
NULL, /* cmp_contains */
NULL, /* cmp_matches */

47
epan/ftypes/ftype-ipv6.c
View File

@ -100,8 +100,8 @@ value_get(fvalue_t *fv)
static const guint8 bitmasks[9] =
{ 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
static gint
cmp_compare(const fvalue_t *fv_a, const fvalue_t *fv_b)
static int
cmp_order(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
const ipv6_addr_and_prefix *a = &(fv_a->value.ipv6);
const ipv6_addr_and_prefix *b = &(fv_b->value.ipv6);
@ -132,42 +132,6 @@ cmp_compare(const fvalue_t *fv_a, const fvalue_t *fv_b)
return 0;
}
static gboolean
cmp_eq(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) == 0);
}
static gboolean
cmp_ne(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) != 0);
}
static gboolean
cmp_gt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) > 0);
}
static gboolean
cmp_ge(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) >= 0);
}
static gboolean
cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) < 0);
}
static gboolean
cmp_le(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
return (cmp_compare(fv_a, fv_b) <= 0);
}
static gboolean
cmp_bitwise_and(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
@ -225,12 +189,7 @@ ftype_register_ipv6(void)
{ .set_value_bytes = ipv6_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
cmp_bitwise_and,
NULL, /* XXX, cmp_contains, needed? ipv4 doesn't support it */
NULL, /* cmp_matches */

7
epan/ftypes/ftype-none.c
View File

@ -30,12 +30,7 @@ ftype_register_none(void)
{ NULL }, /* union set_value */
{ NULL }, /* union get_value */
NULL, /* cmp_eq */
NULL, /* cmp_ne */
NULL, /* cmp_gt */
NULL, /* cmp_ge */
NULL, /* cmp_lt */
NULL, /* cmp_le */
NULL, /* cmp_order */
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */

123
epan/ftypes/ftype-protocol.c
View File

@ -223,89 +223,6 @@ cmp_eq(const fvalue_t *fv_a, const fvalue_t *fv_b)
return eq;
}
static gboolean
cmp_ne(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
const protocol_value_t *a = (const protocol_value_t *)&fv_a->value.protocol;
const protocol_value_t *b = (const protocol_value_t *)&fv_b->value.protocol;
volatile gboolean ne = TRUE;
TRY {
if ((a->tvb != NULL) && (b->tvb != NULL)) {
guint a_len = tvb_captured_length(a->tvb);
if (a_len == tvb_captured_length(b->tvb))
ne = (memcmp(tvb_get_ptr(a->tvb, 0, a_len), tvb_get_ptr(b->tvb, 0, a_len), a_len) != 0);
} else {
ne = (strcmp(a->proto_string, b->proto_string) != 0);
}
}
CATCH_ALL {
/* nothing */
}
ENDTRY;
return ne;
}
static gboolean
cmp_gt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
const protocol_value_t *a = (const protocol_value_t *)&fv_a->value.protocol;
const protocol_value_t *b = (const protocol_value_t *)&fv_b->value.protocol;
volatile gboolean gt = FALSE;
TRY {
if ((a->tvb != NULL) && (b->tvb != NULL)) {
guint a_len = tvb_captured_length(a->tvb);
guint b_len = tvb_captured_length(b->tvb);
if (a_len > b_len) {
gt = TRUE;
} else if (a_len == b_len) {
gt = (memcmp(tvb_get_ptr(a->tvb, 0, a_len), tvb_get_ptr(b->tvb, 0, a_len), a_len) > 0);
}
} else {
gt = (strcmp(a->proto_string, b->proto_string) > 0);
}
}
CATCH_ALL {
/* nothing */
}
ENDTRY;
return gt;
}
static gboolean
cmp_ge(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
const protocol_value_t *a = (const protocol_value_t *)&fv_a->value.protocol;
const protocol_value_t *b = (const protocol_value_t *)&fv_b->value.protocol;
volatile gboolean ge = FALSE;
TRY {
if ((a->tvb != NULL) && (b->tvb != NULL)) {
guint a_len = tvb_captured_length(a->tvb);
guint b_len = tvb_captured_length(b->tvb);
if (a_len > b_len) {
ge = TRUE;
} else if (a_len == b_len) {
ge = (memcmp(tvb_get_ptr(a->tvb, 0, a_len), tvb_get_ptr(b->tvb, 0, a_len), a_len) >= 0);
}
} else {
ge = (strcmp(a->proto_string, b->proto_string) >= 0);
}
}
CATCH_ALL {
/* nothing */
}
ENDTRY;
return ge;
}
static gboolean
cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
@ -335,33 +252,14 @@ cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
return lt;
}
static gboolean
cmp_le(const fvalue_t *fv_a, const fvalue_t *fv_b)
static int
cmp_order(const fvalue_t *fv_a, const fvalue_t *fv_b)
{
const protocol_value_t *a = (const protocol_value_t *)&fv_a->value.protocol;
const protocol_value_t *b = (const protocol_value_t *)&fv_b->value.protocol;
volatile gboolean le = FALSE;
TRY {
if ((a->tvb != NULL) && (b->tvb != NULL)) {
guint a_len = tvb_captured_length(a->tvb);
guint b_len = tvb_captured_length(b->tvb);
if (a_len < b_len) {
le = TRUE;
} else if (a_len == b_len) {
le = (memcmp(tvb_get_ptr(a->tvb, 0, a_len), tvb_get_ptr(b->tvb, 0, a_len), a_len) <= 0);
}
} else {
le = (strcmp(a->proto_string, b->proto_string) <= 0);
}
}
CATCH_ALL {
/* nothing */
}
ENDTRY;
return le;
if (cmp_lt(fv_a, fv_b))
return -1;
if (cmp_eq(fv_a, fv_b))
return 0;
return 1;
}
static gboolean
@ -454,12 +352,7 @@ ftype_register_tvbuff(void)
{ .set_value_protocol = value_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains,
CMP_MATCHES,

72
epan/ftypes/ftype-string.c
View File

@ -130,41 +130,10 @@ slice(fvalue_t *fv, GByteArray *bytes, guint offset, guint length)
g_byte_array_append(bytes, data, length);
}
static gboolean
cmp_eq(const fvalue_t *a, const fvalue_t *b)
static int
cmp_order(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) == 0);
}
static gboolean
cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) != 0);
}
static gboolean
cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) > 0);
}
static gboolean
cmp_ge(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) >= 0);
}
static gboolean
cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) < 0);
}
static gboolean
cmp_le(const fvalue_t *a, const fvalue_t *b)
{
return (strcmp(a->value.string, b->value.string) <= 0);
return strcmp(a->value.string, b->value.string);
}
static gboolean
@ -224,12 +193,7 @@ ftype_register_string(void)
{ .set_value_string = string_fvalue_set_string }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains,
CMP_MATCHES,
@ -252,12 +216,7 @@ ftype_register_string(void)
{ .set_value_string = string_fvalue_set_string }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains, /* cmp_contains */
CMP_MATCHES,
@ -280,12 +239,7 @@ ftype_register_string(void)
{ .set_value_string = string_fvalue_set_string }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains, /* cmp_contains */
CMP_MATCHES,
@ -308,12 +262,7 @@ ftype_register_string(void)
{ .set_value_string = string_fvalue_set_string }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains, /* cmp_contains */
CMP_MATCHES,
@ -336,12 +285,7 @@ ftype_register_string(void)
{ .set_value_string = string_fvalue_set_string }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
cmp_contains, /* cmp_contains */
CMP_MATCHES,

75
epan/ftypes/ftype-time.c
View File

@ -30,67 +30,12 @@
#include "wsutil/strptime.h"
#endif
static gboolean
cmp_eq(const fvalue_t *a, const fvalue_t *b)
{
return ((a->value.time.secs) ==(b->value.time.secs))
&&((a->value.time.nsecs)==(b->value.time.nsecs));
}
static gboolean
cmp_ne(const fvalue_t *a, const fvalue_t *b)
{
return (a->value.time.secs !=b->value.time.secs)
||(a->value.time.nsecs!=b->value.time.nsecs);
}
static gboolean
cmp_gt(const fvalue_t *a, const fvalue_t *b)
{
if (a->value.time.secs > b->value.time.secs) {
return TRUE;
}
if (a->value.time.secs < b->value.time.secs) {
return FALSE;
}
return a->value.time.nsecs > b->value.time.nsecs;
}
static gboolean
cmp_ge(const fvalue_t *a, const fvalue_t *b)
static int
cmp_order(const fvalue_t *a, const fvalue_t *b)
{
if (a->value.time.secs > b->value.time.secs) {
return TRUE;
}
if (a->value.time.secs < b->value.time.secs) {
return FALSE;
}
return a->value.time.nsecs >= b->value.time.nsecs;
return nstime_cmp(&(a->value.time), &(b->value.time));
}
static gboolean
cmp_lt(const fvalue_t *a, const fvalue_t *b)
{
if (a->value.time.secs < b->value.time.secs) {
return TRUE;
}
if (a->value.time.secs > b->value.time.secs) {
return FALSE;
}
return a->value.time.nsecs < b->value.time.nsecs;
}
static gboolean
cmp_le(const fvalue_t *a, const fvalue_t *b)
{
if (a->value.time.secs < b->value.time.secs) {
return TRUE;
}
if (a->value.time.secs > b->value.time.secs) {
return FALSE;
}
return a->value.time.nsecs <= b->value.time.nsecs;
}
/*
* Get a nanoseconds value, starting at "p".
@ -451,12 +396,7 @@ ftype_register_time(void)
{ .set_value_time = time_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */
@ -479,12 +419,7 @@ ftype_register_time(void)
{ .set_value_time = time_fvalue_set }, /* union set_value */
{ .get_value_ptr = value_get }, /* union get_value */
cmp_eq,
cmp_ne,
cmp_gt,
cmp_ge,
cmp_lt,
cmp_le,
cmp_order,
NULL, /* cmp_bitwise_and */
NULL, /* cmp_contains */
NULL, /* cmp_matches */

15
epan/ftypes/ftypes-int.h
View File

@ -61,7 +61,9 @@ typedef guint64 (*FvalueGetUnsignedInteger64Func)(fvalue_t*);
typedef gint64 (*FvalueGetSignedInteger64Func)(fvalue_t*);
typedef double (*FvalueGetFloatingFunc)(fvalue_t*);
typedef gboolean (*FvalueCmp)(const fvalue_t*, const fvalue_t*);
typedef int (*FvalueCmp)(const fvalue_t*, const fvalue_t*);
typedef gboolean (*FvalueBitwiseAnd)(const fvalue_t*, const fvalue_t*);
typedef gboolean (*FvalueContains)(const fvalue_t*, const fvalue_t*);
typedef gboolean (*FvalueMatches)(const fvalue_t*, const GRegex*);
typedef guint (*FvalueLen)(fvalue_t*);
@ -102,14 +104,9 @@ struct _ftype_t {
FvalueGetFloatingFunc get_value_floating;
} get_value;
FvalueCmp cmp_eq;
FvalueCmp cmp_ne;
FvalueCmp cmp_gt;
FvalueCmp cmp_ge;
FvalueCmp cmp_lt;
FvalueCmp cmp_le;
FvalueCmp cmp_bitwise_and;
FvalueCmp cmp_contains;
FvalueCmp cmp_order;
FvalueBitwiseAnd cmp_bitwise_and;
FvalueContains cmp_contains;
FvalueMatches cmp_matches;
FvalueLen len;

44
epan/ftypes/ftypes.c
View File

@ -173,7 +173,7 @@ ftype_can_eq(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_eq ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -182,7 +182,7 @@ ftype_can_ne(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_ne ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -191,7 +191,7 @@ ftype_can_gt(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_gt ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -200,7 +200,7 @@ ftype_can_ge(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_ge ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -209,7 +209,7 @@ ftype_can_lt(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_lt ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -218,7 +218,7 @@ ftype_can_le(enum ftenum ftype)
ftype_t *ft;
FTYPE_LOOKUP(ftype, ft);
return ft->cmp_le ? TRUE : FALSE;
return ft->cmp_order != NULL;
}
gboolean
@ -686,52 +686,48 @@ fvalue_get_floating(fvalue_t *fv)
return fv->ftype->get_value.get_value_floating(fv);
}
static inline int
_fvalue_cmp(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_order);
return a->ftype->cmp_order(a, b);
}
gboolean
fvalue_eq(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_eq);
return a->ftype->cmp_eq(a, b);
return _fvalue_cmp(a, b) == 0;
}
gboolean
fvalue_ne(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_ne);
return a->ftype->cmp_ne(a, b);
return _fvalue_cmp(a, b) != 0;
}
gboolean
fvalue_gt(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_gt);
return a->ftype->cmp_gt(a, b);
return _fvalue_cmp(a, b) > 0;
}
gboolean
fvalue_ge(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_ge);
return a->ftype->cmp_ge(a, b);
return _fvalue_cmp(a, b) >= 0;
}
gboolean
fvalue_lt(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_lt);
return a->ftype->cmp_lt(a, b);
return _fvalue_cmp(a, b) < 0;
}
gboolean
fvalue_le(const fvalue_t *a, const fvalue_t *b)
{
/* XXX - check compatibility of a and b */
ws_assert(a->ftype->cmp_le);
return a->ftype->cmp_le(a, b);
return _fvalue_cmp(a, b) <= 0;
}
gboolean