### Bug Summary

File: | epan/ftypes/ftypes.c
Warning: | line 234, column 14 Value stored to 's' during its initialization is never read

### Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ftypes.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/build/epan/ftypes -I /builds/wireshark/wireshark/epan/ftypes -I /builds/wireshark/wireshark/epan -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2026-01-10-100353-3604-1 -x c /builds/wireshark/wireshark/epan/ftypes/ftypes.c

Keyboard shortcuts:

- Use 'j/k' keys for keyboard navigation
- Use 'Shift+S' to show/hide relevant lines
- Use '?' to toggle this window

Close
Show only relevant lines Show control flow arrows

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 |
13 | #include <wsutil/ws_assert.h>
14 |
15 | /* Keep track of ftype_t's via their ftenum number */
16 | const ftype_t* type_list[FT_ENUM_SIZE + 1];
17 |
18 | /* Initialize the ftype module. */
19 | void
20 | ftypes_initialize(void)
21 | {
22 | ftype_register_bytes();
23 | ftype_register_double();
24 | ftype_register_ieee_11073_float();
25 | ftype_register_integers();
26 | ftype_register_ipv4();
27 | ftype_register_ipv6();
28 | ftype_register_guid();
29 | ftype_register_none();
30 | ftype_register_string();
31 | ftype_register_time();
32 | ftype_register_tvbuff();
33 | }
34 |
35 | void
36 | ftypes_register_pseudofields(void)
37 | {
38 | static int proto_ftypes;
39 |
40 | proto_ftypes = proto_register_protocol(
41 | "Wireshark Field/Fundamental Types",
42 | "Wireshark FTypes",
43 | "_ws.ftypes");
44 |
45 | ftype_register_pseudofields_bytes(proto_ftypes);
46 | ftype_register_pseudofields_double(proto_ftypes);
47 | ftype_register_pseudofields_ieee_11073_float(proto_ftypes);
48 | ftype_register_pseudofields_integer(proto_ftypes);
49 | ftype_register_pseudofields_ipv4(proto_ftypes);
50 | ftype_register_pseudofields_ipv6(proto_ftypes);
51 | ftype_register_pseudofields_guid(proto_ftypes);
52 | ftype_register_pseudofields_none(proto_ftypes);
53 | ftype_register_pseudofields_string(proto_ftypes);
54 | ftype_register_pseudofields_time(proto_ftypes);
55 | ftype_register_pseudofields_tvbuff(proto_ftypes);
56 |
57 | proto_set_cant_toggle(proto_ftypes);
58 | }
59 |
60 | /* Each ftype_t is registered via this function */
61 | void
62 | ftype_register(enum ftenum ftype, const ftype_t *ft)
63 | {
64 | /* Check input */
65 | ws_assert(ftype < FT_NUM_TYPES)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 65, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0);
66 | ws_assert(ftype == ft->ftype)do { if ((1) && !(ftype == ft->ftype)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 66, __func__, "assertion failed: %s" , "ftype == ft->ftype"); } while (0);
67 |
68 | /* Don't re-register. */
69 | ws_assert(type_list[ftype] == NULL)do { if ((1) && !(type_list[ftype] == ((void*)0))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 69, __func__, "assertion failed: %s" , "type_list[ftype] == ((void*)0)"); } while (0);
70 |
71 | type_list[ftype] = ft;
72 | }
73 |
74 |
75 | /* from README.dissector:
76 | Note that the formats used must all belong to the same list as defined below:
77 | - FT_INT8, FT_INT16, FT_INT24 and FT_INT32, FT_CHAR, FT_UINT8, FT_UINT16,
78 | FT_UINT24, FT_UINT32, FT_IPXNET, FT_FRAMENUM, FT_INT40, FT_INT48, FT_INT56
79 | FT_INT64, FT_UINT40, FT_UINT48, FT_UINT56 and FT_UINT64
80 | - FT_ABSOLUTE_TIME and FT_RELATIVE_TIME
81 | - FT_STRING, FT_STRINGZ, FT_UINT_STRING, FT_STRINGZPAD, FT_STRINGZTRUNC and FT_AX25
82 | - FT_FLOAT, FT_DOUBLE, FT_IEEE_11073_SFLOAT and FT_IEEE_11073_FLOAT
83 | - FT_BYTES, FT_UINT_BYTES, FT_ETHER, FT_VINES, FT_FCWWN and FT_EUI64
84 | - FT_OID, FT_REL_OID and FT_SYSTEM_ID
85 |
86 | We thus divide the types into equivalence classes of compatible types.
87 | The same field abbreviation can be used by more than one field, even of
88 | different types, so long as the types are compatible.
89 |
90 | This function returns the canonical representative of a type. It can
91 | be used to check if two fields are compatible.
92 |
93 | XXX - Currently epan/dfilter/semcheck.c has its own implementation of
94 | compatible types.
95 | */
96 | static enum ftenum
97 | same_ftype(const enum ftenum ftype)
98 | {
99 | switch (ftype) {
100 | case FT_INT8:
101 | case FT_INT16:
102 | case FT_INT24:
103 | case FT_INT32:
104 | case FT_CHAR:
105 | case FT_UINT8:
106 | case FT_UINT16:
107 | case FT_UINT24:
108 | case FT_UINT32:
109 | case FT_IPXNET:
110 | case FT_FRAMENUM:
111 | case FT_INT40:
112 | case FT_INT48:
113 | case FT_INT56:
114 | case FT_INT64:
115 | case FT_UINT40:
116 | case FT_UINT48:
117 | case FT_UINT56:
118 | case FT_UINT64:
119 | return FT_UINT64;
120 |
121 | case FT_STRING:
122 | case FT_STRINGZ:
123 | case FT_UINT_STRING:
124 | case FT_STRINGZPAD:
125 | case FT_STRINGZTRUNC:
126 | case FT_AX25:
127 | return FT_STRING;
128 |
129 | case FT_FLOAT:
130 | case FT_DOUBLE:
131 | return FT_DOUBLE;
132 |
133 | case FT_BYTES:
134 | case FT_UINT_BYTES:
135 | case FT_ETHER:
136 | case FT_VINES:
137 | case FT_FCWWN:
138 | case FT_EUI64:
139 | return FT_BYTES;
140 |
141 | case FT_OID:
142 | case FT_REL_OID:
143 | case FT_SYSTEM_ID:
144 | /* XXX - dfilter/semcheck.c treats this group as compatible with BYTES */
145 | return FT_OID;
146 |
147 | /* XXX: the following are unique for now */
148 | case FT_IPv4:
149 | case FT_IPv6:
150 | case FT_IEEE_11073_SFLOAT: /* XXX - should be able to compare with DOUBLE (#19011) */
151 | case FT_IEEE_11073_FLOAT: /* XXX - should be able to compare with DOUBLE */
152 |
153 | /* everything else is unique */
154 | /* XXX - README.dissector claims the time types are compatible. */
155 | default:
156 | return ftype;
157 | }
158 | }
159 |
160 | /* given two types, are they similar - for example can two
161 | * duplicate fields be registered of these two types. */
162 | bool_Bool
163 | ftype_similar_types(const enum ftenum ftype_a, const enum ftenum ftype_b)
164 | {
165 | return (same_ftype(ftype_a) == same_ftype(ftype_b));
166 | }
167 |
168 | /* Returns a string representing the name of the type. Useful
169 | * for glossary production. */
170 | const char*
171 | ftype_name(enum ftenum ftype)
172 | {
173 | const ftype_t *ft;
174 | const char *s = "(null)";
175 |
176 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 176, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
177 | switch (ft->ftype) {
178 | case FT_NONE: s = "FT_NONE"; break;
179 | case FT_PROTOCOL: s = "FT_PROTOCOL"; break;
180 | case FT_BOOLEAN: s = "FT_BOOLEAN"; break;
181 | case FT_CHAR: s = "FT_CHAR"; break;
182 | case FT_UINT8: s = "FT_UINT8"; break;
183 | case FT_UINT16: s = "FT_UINT16"; break;
184 | case FT_UINT24: s = "FT_UINT24"; break;
185 | case FT_UINT32: s = "FT_UINT32"; break;
186 | case FT_UINT40: s = "FT_UINT40"; break;
187 | case FT_UINT48: s = "FT_UINT48"; break;
188 | case FT_UINT56: s = "FT_UINT56"; break;
189 | case FT_UINT64: s = "FT_UINT64"; break;
190 | case FT_INT8: s = "FT_INT8"; break;
191 | case FT_INT16: s = "FT_INT16"; break;
192 | case FT_INT24: s = "FT_INT24"; break;
193 | case FT_INT32: s = "FT_INT32"; break;
194 | case FT_INT40: s = "FT_INT40"; break;
195 | case FT_INT48: s = "FT_INT48"; break;
196 | case FT_INT56: s = "FT_INT56"; break;
197 | case FT_INT64: s = "FT_INT64"; break;
198 | case FT_IEEE_11073_SFLOAT: s = "FT_IEEE_11073_SFLOAT"; break;
199 | case FT_IEEE_11073_FLOAT: s = "FT_IEEE_11073_FLOAT"; break;
200 | case FT_FLOAT: s = "FT_FLOAT"; break;
201 | case FT_DOUBLE: s = "FT_DOUBLE"; break;
202 | case FT_ABSOLUTE_TIME: s = "FT_ABSOLUTE_TIME"; break;
203 | case FT_RELATIVE_TIME: s = "FT_RELATIVE_TIME"; break;
204 | case FT_STRING: s = "FT_STRING"; break;
205 | case FT_STRINGZ: s = "FT_STRINGZ"; break;
206 | case FT_UINT_STRING: s = "FT_UINT_STRING"; break;
207 | case FT_ETHER: s = "FT_ETHER"; break;
208 | case FT_BYTES: s = "FT_BYTES"; break;
209 | case FT_UINT_BYTES: s = "FT_UINT_BYTES"; break;
210 | case FT_IPv4: s = "FT_IPv4"; break;
211 | case FT_IPv6: s = "FT_IPv6"; break;
212 | case FT_IPXNET: s = "FT_IPXNET"; break;
213 | case FT_FRAMENUM: s = "FT_FRAMENUM"; break;
214 | case FT_GUID: s = "FT_GUID"; break;
215 | case FT_OID: s = "FT_OID"; break;
216 | case FT_EUI64: s = "FT_EUI64"; break;
217 | case FT_AX25: s = "FT_AX25"; break;
218 | case FT_VINES: s = "FT_VINES"; break;
219 | case FT_REL_OID: s = "FT_REL_OID"; break;
220 | case FT_SYSTEM_ID: s = "FT_SYSTEM_ID"; break;
221 | case FT_STRINGZPAD: s = "FT_STRINGZPAD"; break;
222 | case FT_FCWWN: s = "FT_FCWWN"; break;
223 | case FT_STRINGZTRUNC: s = "FT_STRINGZTRUNC"; break;
224 | case FT_NUM_TYPES: s = "FT_NUM_TYPES"; break;
225 | case FT_SCALAR: s = "FT_SCALAR"; break;
226 | }
227 | return s;
228 | }
229 |
230 | const char*
231 | ftype_pretty_name(enum ftenum ftype)
232 | {
233 | const ftype_t *ft;
234 | const char *s = "(null)";
| Value stored to 's' during its initialization is never read
235 |
236 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 236, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
237 | switch (ft->ftype) {
238 | case FT_NONE: s = "Label"; break;
239 | case FT_PROTOCOL: s = "Protocol"; break;
240 | case FT_BOOLEAN: s = "Boolean"; break;
241 | case FT_CHAR: s = "Character (8 bits)"; break;
242 | case FT_UINT8: s = "Unsigned integer (8 bits)"; break;
243 | case FT_UINT16: s = "Unsigned integer (16 bits)"; break;
244 | case FT_UINT24: s = "Unsigned integer (24 bits)"; break;
245 | case FT_UINT32: s = "Unsigned integer (32 bits)"; break;
246 | case FT_UINT40: s = "Unsigned integer (40 bits)"; break;
247 | case FT_UINT48: s = "Unsigned integer (48 bits)"; break;
248 | case FT_UINT56: s = "Unsigned integer (56 bits)"; break;
249 | case FT_UINT64: s = "Unsigned integer (64 bits)"; break;
250 | case FT_INT8: s = "Signed integer (8 bits)"; break;
251 | case FT_INT16: s = "Signed integer (16 bits)"; break;
252 | case FT_INT24: s = "Signed integer (24 bits)"; break;
253 | case FT_INT32: s = "Signed integer (32 bits)"; break;
254 | case FT_INT40: s = "Signed integer (40 bits)"; break;
255 | case FT_INT48: s = "Signed integer (48 bits)"; break;
256 | case FT_INT56: s = "Signed integer (56 bits)"; break;
257 | case FT_INT64: s = "Signed integer (64 bits)"; break;
258 | case FT_IEEE_11073_SFLOAT: s = "IEEE-11073 floating point (16-bit)"; break;
259 | case FT_IEEE_11073_FLOAT: s = "IEEE-11073 Floating point (32-bit)"; break;
260 | case FT_FLOAT: s = "Floating point (single-precision)"; break;
261 | case FT_DOUBLE: s = "Floating point (double-precision)"; break;
262 | case FT_ABSOLUTE_TIME: s = "Date and time"; break;
263 | case FT_RELATIVE_TIME: s = "Time offset"; break;
264 | case FT_STRING: s = "Character string"; break;
265 | case FT_STRINGZ: s = "Character string"; break;
266 | case FT_UINT_STRING: s = "Character string"; break;
267 | case FT_ETHER: s = "Ethernet or other MAC address"; break;
268 | case FT_BYTES: s = "Byte sequence"; break;
269 | case FT_UINT_BYTES: s = "Byte sequence"; break;
270 | case FT_IPv4: s = "IPv4 address"; break;
271 | case FT_IPv6: s = "IPv6 address"; break;
272 | case FT_IPXNET: s = "IPX network number"; break;
273 | case FT_FRAMENUM: s = "Frame number"; break;
274 | case FT_GUID: s = "Globally Unique Identifier"; break;
275 | case FT_OID: s = "ASN.1 object identifier"; break;
276 | case FT_EUI64: s = "EUI64 address"; break;
277 | case FT_AX25: s = "AX.25 address"; break;
278 | case FT_VINES: s = "VINES address"; break;
279 | case FT_REL_OID: s = "ASN.1 relative object identifier"; break;
280 | case FT_SYSTEM_ID: s = "OSI System-ID"; break;
281 | case FT_STRINGZPAD: s = "Character string"; break;
282 | case FT_FCWWN: s = "Fibre Channel WWN"; break;
283 | case FT_STRINGZTRUNC: s = "Character string"; break;
284 | case FT_NUM_TYPES: s = "(num types)"; break;
285 | case FT_SCALAR: s = "Scalar"; break;
286 | }
287 | return s;
288 | }
289 |
290 | int
291 | ftype_wire_size(enum ftenum ftype)
292 | {
293 | const ftype_t *ft;
294 |
295 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 295, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
296 | return ft->wire_size;
297 | }
298 |
299 | bool_Bool
300 | ftype_can_length(enum ftenum ftype)
301 | {
302 | const ftype_t *ft;
303 |
304 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 304, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
305 | return ft->len ? true1 : false0;
306 | }
307 |
308 | bool_Bool
309 | ftype_can_slice(enum ftenum ftype)
310 | {
311 | const ftype_t *ft;
312 |
313 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 313, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
314 | return ft->slice ? true1 : false0;
315 | }
316 |
317 | bool_Bool
318 | ftype_can_eq(enum ftenum ftype)
319 | {
320 | const ftype_t *ft;
321 |
322 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 322, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
323 | return ft->compare != NULL((void*)0);
324 | }
325 |
326 | bool_Bool
327 | ftype_can_cmp(enum ftenum ftype)
328 | {
329 | const ftype_t *ft;
330 |
331 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 331, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
332 | return ft->compare != NULL((void*)0);
333 | }
334 |
335 | bool_Bool
336 | ftype_can_bitwise_and(enum ftenum ftype)
337 | {
338 | const ftype_t *ft;
339 |
340 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 340, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
341 | return ft->bitwise_and ? true1 : false0;
342 | }
343 |
344 | bool_Bool
345 | ftype_can_unary_minus(enum ftenum ftype)
346 | {
347 | const ftype_t *ft;
348 |
349 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 349, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
350 | return ft->unary_minus != NULL((void*)0);
351 | }
352 |
353 | bool_Bool
354 | ftype_can_add(enum ftenum ftype)
355 | {
356 | const ftype_t *ft;
357 |
358 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 358, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
359 | return ft->add != NULL((void*)0);
360 | }
361 |
362 | bool_Bool
363 | ftype_can_subtract(enum ftenum ftype)
364 | {
365 | const ftype_t *ft;
366 |
367 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 367, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
368 | return ft->subtract != NULL((void*)0);
369 | }
370 |
371 | bool_Bool
372 | ftype_can_multiply(enum ftenum ftype)
373 | {
374 | const ftype_t *ft;
375 |
376 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 376, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
377 | return ft->multiply != NULL((void*)0);
378 | }
379 |
380 | bool_Bool
381 | ftype_can_divide(enum ftenum ftype)
382 | {
383 | const ftype_t *ft;
384 |
385 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 385, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
386 | return ft->divide != NULL((void*)0);
387 | }
388 |
389 | bool_Bool
390 | ftype_can_modulo(enum ftenum ftype)
391 | {
392 | const ftype_t *ft;
393 |
394 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 394, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
395 | return ft->modulo != NULL((void*)0);
396 | }
397 |
398 | bool_Bool
399 | ftype_can_contains(enum ftenum ftype)
400 | {
401 | const ftype_t *ft;
402 |
403 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 403, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
404 | return ft->contains ? true1 : false0;
405 | }
406 |
407 | bool_Bool
408 | ftype_can_matches(enum ftenum ftype)
409 | {
410 | const ftype_t *ft;
411 |
412 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 412, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
413 | return ft->matches ? true1 : false0;
414 | }
415 |
416 | bool_Bool
417 | ftype_can_is_zero(enum ftenum ftype)
418 | {
419 | const ftype_t *ft;
420 |
421 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 421, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
422 | return ft->is_zero ? true1 : false0;
423 | }
424 |
425 | bool_Bool
426 | ftype_can_is_negative(enum ftenum ftype)
427 | {
428 | const ftype_t *ft;
429 |
430 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 430, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
431 | return ft->is_negative ? true1 : false0;
432 | }
433 |
434 | bool_Bool
435 | ftype_can_is_nan(enum ftenum ftype)
436 | {
437 | const ftype_t *ft;
438 |
439 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 439, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
440 | return ft->is_nan ? true1 : false0;
441 | }
442 |
443 | bool_Bool
444 | ftype_can_val_to_sinteger(enum ftenum ftype)
445 | {
446 | const ftype_t *ft;
447 |
448 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 448, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
449 | /* We first convert to 64 bit and then check for overflow. */
450 | return ft->val_to_sinteger64 ? true1 : false0;
451 | }
452 |
453 | bool_Bool
454 | ftype_can_val_to_uinteger(enum ftenum ftype)
455 | {
456 | const ftype_t *ft;
457 |
458 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 458, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
459 | /* We first convert to 64 bit and then check for overflow. */
460 | return ft->val_to_uinteger64 ? true1 : false0;
461 | }
462 |
463 | bool_Bool
464 | ftype_can_val_to_sinteger64(enum ftenum ftype)
465 | {
466 | const ftype_t *ft;
467 |
468 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 468, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
469 | return ft->val_to_sinteger64 ? true1 : false0;
470 | }
471 |
472 | bool_Bool
473 | ftype_can_val_to_uinteger64(enum ftenum ftype)
474 | {
475 | const ftype_t *ft;
476 |
477 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 477, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
478 | return ft->val_to_uinteger64 ? true1 : false0;
479 | }
480 |
481 | bool_Bool
482 | ftype_can_val_to_double(enum ftenum ftype)
483 | {
484 | const ftype_t *ft;
485 |
486 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 486, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
487 | /* We first convert to 64 bit and then check for overflow. */
488 | return ft->val_to_double ? true1 : false0;
489 | }
490 |
491 | /* ---------------------------------------------------------- */
492 |
493 | /* Allocate and initialize an fvalue_t, given an ftype */
494 | fvalue_t*
495 | fvalue_new(ftenum_t ftype)
496 | {
497 | fvalue_t *fv;
498 | const ftype_t *ft;
499 | FvalueNewFunc new_value;
500 |
501 | fv = g_slice_new(fvalue_t)((fvalue_t*) g_slice_alloc (sizeof (fvalue_t)));
502 |
503 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 503, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
504 | fv->ftype = ft;
505 |
506 | new_value = ft->new_value;
507 | if (new_value) {
508 | new_value(fv);
509 | }
510 |
511 | return fv;
512 | }
513 |
514 | fvalue_t*
515 | fvalue_dup(const fvalue_t *fv_orig)
516 | {
517 | fvalue_t *fv_new;
518 | FvalueCopyFunc copy_value;
519 |
520 | fv_new = g_slice_new(fvalue_t)((fvalue_t*) g_slice_alloc (sizeof (fvalue_t)));
521 | fv_new->ftype = fv_orig->ftype;
522 | copy_value = fv_new->ftype->copy_value;
523 | if (copy_value != NULL((void*)0)) {
524 | /* deep copy */
525 | copy_value(fv_new, fv_orig);
526 | }
527 | else {
528 | /* shallow copy */
529 | memcpy(&fv_new->value, &fv_orig->value, sizeof(fv_orig->value));
530 | }
531 |
532 | return fv_new;
533 | }
534 |
535 | void
536 | fvalue_init(fvalue_t *fv, ftenum_t ftype)
537 | {
538 | const ftype_t *ft;
539 | FvalueNewFunc new_value;
540 |
541 | FTYPE_LOOKUP(ftype, ft)do { if ((1) && !(ftype < FT_NUM_TYPES)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 541, __func__, "assertion failed: %s" , "ftype < FT_NUM_TYPES"); } while (0); ft = type_list[ftype ];;
542 | fv->ftype = ft;
543 |
544 | new_value = ft->new_value;
545 | if (new_value) {
546 | new_value(fv);
547 | }
548 | }
549 |
550 | void
551 | fvalue_cleanup(fvalue_t *fv)
552 | {
553 | if (!fv->ftype->free_value)
554 | return;
555 | fv->ftype->free_value(fv);
556 | }
557 |
558 | void
559 | fvalue_free(fvalue_t *fv)
560 | {
561 | fvalue_cleanup(fv);
562 | g_slice_free(fvalue_t, fv)do { if (1) g_slice_free1 (sizeof (fvalue_t), (fv)); else (void ) ((fvalue_t*) 0 == (fv)); } while (0);
563 | }
564 |
565 | fvalue_t*
566 | fvalue_from_literal(ftenum_t ftype, const char *s, bool_Bool allow_partial_value, char **err_msg)
567 | {
568 | fvalue_t *fv;
569 | bool_Bool ok = false0;
570 |
571 | fv = fvalue_new(ftype);
572 | if (fv->ftype->val_from_literal) {
573 | ok = fv->ftype->val_from_literal(fv, s, allow_partial_value, err_msg);
574 | }
575 | if (ok) {
576 | /* Success */
577 | if (err_msg != NULL((void*)0))
578 | *err_msg = NULL((void*)0);
579 | return fv;
580 | }
581 | else {
582 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
583 | *err_msg = ws_strdup_printf("\"%s\" cannot be converted to %s.",wmem_strdup_printf(((void*)0), "\"%s\" cannot be converted to %s." , s, ftype_pretty_name(ftype))
584 | s, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "\"%s\" cannot be converted to %s." , s, ftype_pretty_name(ftype));
585 | }
586 | }
587 | fvalue_free(fv);
588 | return NULL((void*)0);
589 | }
590 |
591 | fvalue_t*
592 | fvalue_from_string(ftenum_t ftype, const char *str, size_t len, char **err_msg)
593 | {
594 | fvalue_t *fv;
595 |
596 | fv = fvalue_new(ftype);
597 | if (fv->ftype->val_from_string && fv->ftype->val_from_string(fv, str, len, err_msg)) {
598 | /* Success */
599 | if (err_msg != NULL((void*)0))
600 | *err_msg = NULL((void*)0);
601 | return fv;
602 | }
603 | else {
604 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
605 | *err_msg = ws_strdup_printf("%s cannot be converted from a string (\"%s\").",wmem_strdup_printf(((void*)0), "%s cannot be converted from a string (\"%s\")." , ftype_pretty_name(ftype), str)
606 | ftype_pretty_name(ftype), str)wmem_strdup_printf(((void*)0), "%s cannot be converted from a string (\"%s\")." , ftype_pretty_name(ftype), str);
607 | }
608 | }
609 | fvalue_free(fv);
610 | return NULL((void*)0);
611 | }
612 |
613 | fvalue_t*
614 | fvalue_from_charconst(ftenum_t ftype, unsigned long num, char **err_msg)
615 | {
616 | fvalue_t *fv;
617 |
618 | fv = fvalue_new(ftype);
619 | if (fv->ftype->val_from_charconst && fv->ftype->val_from_charconst(fv, num, err_msg)) {
620 | /* Success */
621 | if (err_msg != NULL((void*)0))
622 | *err_msg = NULL((void*)0);
623 | return fv;
624 | }
625 | else {
626 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
627 | if (num <= 0x7f && g_ascii_isprint(num)((g_ascii_table[(guchar) (num)] & G_ASCII_PRINT) != 0)) {
628 | *err_msg = ws_strdup_printf("Character constant '%c' (0x%lx) cannot be converted to %s.",wmem_strdup_printf(((void*)0), "Character constant '%c' (0x%lx) cannot be converted to %s." , (int)num, num, ftype_pretty_name(ftype))
629 | (int)num, num, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "Character constant '%c' (0x%lx) cannot be converted to %s." , (int)num, num, ftype_pretty_name(ftype));
630 | }
631 | else {
632 | *err_msg = ws_strdup_printf("Character constant 0x%lx cannot be converted to %s.",wmem_strdup_printf(((void*)0), "Character constant 0x%lx cannot be converted to %s." , num, ftype_pretty_name(ftype))
633 | num, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "Character constant 0x%lx cannot be converted to %s." , num, ftype_pretty_name(ftype));
634 | }
635 | }
636 | }
637 | fvalue_free(fv);
638 | return NULL((void*)0);
639 | }
640 |
641 | fvalue_t*
642 | fvalue_from_sinteger64(ftenum_t ftype, const char *s, int64_t num, char **err_msg)
643 | {
644 | fvalue_t *fv;
645 |
646 | fv = fvalue_new(ftype);
647 | if (fv->ftype->val_from_sinteger64 && fv->ftype->val_from_sinteger64(fv, s, num, err_msg)) {
648 | /* Success */
649 | if (err_msg != NULL((void*)0))
650 | *err_msg = NULL((void*)0);
651 | return fv;
652 | }
653 | else {
654 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
655 | *err_msg = ws_strdup_printf("Integer %"PRId64" cannot be converted to %s.",wmem_strdup_printf(((void*)0), "Integer %""l" "d"" cannot be converted to %s." , num, ftype_pretty_name(ftype))
656 | num, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "Integer %""l" "d"" cannot be converted to %s." , num, ftype_pretty_name(ftype));
657 | }
658 | }
659 | fvalue_free(fv);
660 | return NULL((void*)0);
661 | }
662 |
663 | fvalue_t*
664 | fvalue_from_uinteger64(ftenum_t ftype, const char *s, uint64_t num, char **err_msg)
665 | {
666 | fvalue_t *fv;
667 |
668 | fv = fvalue_new(ftype);
669 | if (fv->ftype->val_from_uinteger64 && fv->ftype->val_from_uinteger64(fv, s, num, err_msg)) {
670 | /* Success */
671 | if (err_msg != NULL((void*)0))
672 | *err_msg = NULL((void*)0);
673 | return fv;
674 | }
675 | else {
676 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
677 | *err_msg = ws_strdup_printf("Unsigned integer %"PRIu64" cannot be converted to %s.",wmem_strdup_printf(((void*)0), "Unsigned integer %""l" "u"" cannot be converted to %s." , num, ftype_pretty_name(ftype))
678 | num, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "Unsigned integer %""l" "u"" cannot be converted to %s." , num, ftype_pretty_name(ftype));
679 | }
680 | }
681 | fvalue_free(fv);
682 | return NULL((void*)0);
683 | }
684 |
685 | fvalue_t*
686 | fvalue_from_floating(ftenum_t ftype, const char *s, double num, char **err_msg)
687 | {
688 | fvalue_t *fv;
689 |
690 | fv = fvalue_new(ftype);
691 | if (fv->ftype->val_from_double && fv->ftype->val_from_double(fv, s, num, err_msg)) {
692 | /* Success */
693 | if (err_msg != NULL((void*)0))
694 | *err_msg = NULL((void*)0);
695 | return fv;
696 | }
697 | else {
698 | if (err_msg != NULL((void*)0) && *err_msg == NULL((void*)0)) {
699 | *err_msg = ws_strdup_printf("Double %g cannot be converted to %s.",wmem_strdup_printf(((void*)0), "Double %g cannot be converted to %s." , num, ftype_pretty_name(ftype))
700 | num, ftype_pretty_name(ftype))wmem_strdup_printf(((void*)0), "Double %g cannot be converted to %s." , num, ftype_pretty_name(ftype));
701 | }
702 | }
703 | fvalue_free(fv);
704 | return NULL((void*)0);
705 | }
706 |
707 | ftenum_t
708 | fvalue_type_ftenum(const fvalue_t *fv)
709 | {
710 | return fv->ftype->ftype;
711 | }
712 |
713 | const char*
714 | fvalue_type_name(const fvalue_t *fv)
715 | {
716 | return ftype_name(fv->ftype->ftype);
717 | }
718 |
719 |
720 | size_t
721 | fvalue_length2(fvalue_t *fv)
722 | {
723 | if (!fv->ftype->len) {
724 | ws_critical("fv->ftype->len is NULL")do { if (1) { ws_log_full("", LOG_LEVEL_CRITICAL, "epan/ftypes/ftypes.c" , 724, __func__, "fv->ftype->len is NULL"); } } while ( 0);
725 | return 0;
726 | }
727 | return fv->ftype->len(fv);
728 | }
729 |
730 | char *
731 | fvalue_to_string_repr(wmem_allocator_t *scope, const fvalue_t *fv, ftrepr_t rtype, int field_display)
732 | {
733 | if (fv->ftype->val_to_string_repr == NULL((void*)0)) {
734 | /* no value-to-string-representation function, so the value cannot be represented */
735 | return NULL((void*)0);
736 | }
737 |
738 | return fv->ftype->val_to_string_repr(scope, fv, rtype, field_display);
739 | }
740 |
741 | enum ft_result
742 | fvalue_to_uinteger(const fvalue_t *fv, uint32_t *repr)
743 | {
744 | uint64_t val;
745 | enum ft_result res = fv->ftype->val_to_uinteger64(fv, &val);
746 | if (res != FT_OK)
747 | return res;
748 | if (val > UINT32_MAX(4294967295U))
749 | return FT_OVERFLOW;
750 |
751 | *repr = (uint32_t)val;
752 | return FT_OK;
753 | }
754 |
755 | enum ft_result
756 | fvalue_to_sinteger(const fvalue_t *fv, int32_t *repr)
757 | {
758 | int64_t val;
759 | enum ft_result res = fv->ftype->val_to_sinteger64(fv, &val);
760 | if (res != FT_OK)
761 | return res;
762 | if (val > INT32_MAX(2147483647))
763 | return FT_OVERFLOW;
764 | if (val < INT32_MIN(-2147483647-1))
765 | return FT_UNDERFLOW;
766 |
767 | *repr = (int32_t)val;
768 | return FT_OK;
769 | }
770 |
771 | enum ft_result
772 | fvalue_to_uinteger64(const fvalue_t *fv, uint64_t *repr)
773 | {
774 | if (!fv->ftype->val_to_uinteger64) {
775 | return FT_BADARG;
776 | }
777 | return fv->ftype->val_to_uinteger64(fv, repr);
778 | }
779 |
780 | enum ft_result
781 | fvalue_to_sinteger64(const fvalue_t *fv, int64_t *repr)
782 | {
783 | if (!fv->ftype->val_to_sinteger64) {
784 | return FT_BADARG;
785 | }
786 | return fv->ftype->val_to_sinteger64(fv, repr);
787 | }
788 |
789 | enum ft_result
790 | fvalue_to_double(const fvalue_t *fv, double *repr)
791 | {
792 | /* We should be able to test this earlier (e.g., in semantic check)
793 | * but there are non-compatible fields that share the same abbrev
794 | * so we have to check it on each fvalue.
795 | */
796 | if (!fv->ftype->val_to_double) {
797 | return FT_BADARG;
798 | }
799 | return fv->ftype->val_to_double(fv, repr);
800 | }
801 |
802 | typedef struct {
803 | fvalue_t *fv;
804 | void *ptr;
805 | bool_Bool slice_failure;
806 | } slice_data_t;
807 |
808 | static bool_Bool
809 | compute_drnode(size_t field_length, drange_node *drnode, size_t *offset_ptr, size_t *length_ptr)
810 | {
811 | ssize_t start_offset;
812 | ssize_t length = 0;
813 | ssize_t end_offset = 0;
814 | drange_node_end_t ending;
815 |
816 | start_offset = drange_node_get_start_offset(drnode);
817 | ending = drange_node_get_ending(drnode);
818 |
819 | /* Check for negative start */
820 | if (start_offset < 0) {
821 | start_offset = field_length + start_offset;
822 | if (start_offset < 0) {
823 | return false0;
824 | }
825 | }
826 |
827 | /* Check the end type and set the length */
828 |
829 | if (ending == DRANGE_NODE_END_T_TO_THE_END) {
830 | length = field_length - start_offset;
831 | if (length <= 0) {
832 | return false0;
833 | }
834 | }
835 | else if (ending == DRANGE_NODE_END_T_LENGTH) {
836 | length = drange_node_get_length(drnode);
837 | if (start_offset + length > (int) field_length) {
838 | return false0;
839 | }
840 | }
841 | else if (ending == DRANGE_NODE_END_T_OFFSET) {
842 | end_offset = drange_node_get_end_offset(drnode);
843 | if (end_offset < 0) {
844 | end_offset = field_length + end_offset;
845 | if (end_offset < start_offset) {
846 | return false0;
847 | }
848 | } else if (end_offset >= (int) field_length) {
849 | return false0;
850 | }
851 | length = end_offset - start_offset + 1;
852 | }
853 | else {
854 | ws_assert_not_reached()ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 854, __func__, "assertion \"not reached\" failed");
855 | }
856 |
857 | *offset_ptr = start_offset;
858 | *length_ptr = length;
859 | return true1;
860 | }
861 |
862 | static void
863 | slice_func(void * data, void * user_data)
864 | {
865 | drange_node *drnode = (drange_node *)data;
866 | slice_data_t *slice_data = (slice_data_t *)user_data;
867 | size_t start_offset;
868 | size_t length = 0;
869 | fvalue_t *fv;
870 |
871 | if (slice_data->slice_failure) {
872 | return;
873 | }
874 |
875 | fv = slice_data->fv;
876 | if (!compute_drnode((unsigned)fvalue_length2(fv), drnode, &start_offset, &length)) {
877 | slice_data->slice_failure = true1;
878 | return;
879 | }
880 |
881 | ws_assert(length > 0)do { if ((1) && !(length > 0)) ws_log_fatal_full("" , LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 881, __func__, "assertion failed: %s" , "length > 0"); } while (0);
882 | fv->ftype->slice(fv, slice_data->ptr, (unsigned)start_offset, (unsigned)length);
883 | }
884 |
885 | static fvalue_t *
886 | slice_string(fvalue_t *fv, drange_t *d_range)
887 | {
888 | slice_data_t slice_data;
889 | fvalue_t *new_fv;
890 |
891 | slice_data.fv = fv;
892 | slice_data.ptr = wmem_strbuf_create(NULL)wmem_strbuf_new(((void*)0), "");
893 | slice_data.slice_failure = false0;
894 |
895 | /* XXX - We could make some optimizations here based on
896 | * drange_has_total_length() and
897 | * drange_get_max_offset().
898 | */
899 |
900 | drange_foreach_drange_node(d_range, slice_func, &slice_data);
901 |
902 | new_fv = fvalue_new(FT_STRING);
903 | fvalue_set_strbuf(new_fv, slice_data.ptr);
904 | return new_fv;
905 | }
906 |
907 | static fvalue_t *
908 | slice_bytes(fvalue_t *fv, drange_t *d_range)
909 | {
910 | slice_data_t slice_data;
911 | fvalue_t *new_fv;
912 |
913 | slice_data.fv = fv;
914 | slice_data.ptr = g_byte_array_new();
915 | slice_data.slice_failure = false0;
916 |
917 | /* XXX - We could make some optimizations here based on
918 | * drange_has_total_length() and
919 | * drange_get_max_offset().
920 | */
921 |
922 | drange_foreach_drange_node(d_range, slice_func, &slice_data);
923 |
924 | new_fv = fvalue_new(FT_BYTES);
925 | fvalue_set_byte_array(new_fv, slice_data.ptr);
926 | return new_fv;
927 | }
928 |
929 | /* Returns a new slice fvalue_t* if possible, otherwise NULL */
930 | fvalue_t*
931 | fvalue_slice(fvalue_t *fv, drange_t *d_range)
932 | {
933 | if (FT_IS_STRING(fvalue_type_ftenum(fv))((fvalue_type_ftenum(fv)) == FT_STRING || (fvalue_type_ftenum (fv)) == FT_STRINGZ || (fvalue_type_ftenum(fv)) == FT_STRINGZPAD || (fvalue_type_ftenum(fv)) == FT_STRINGZTRUNC || (fvalue_type_ftenum (fv)) == FT_UINT_STRING || (fvalue_type_ftenum(fv)) == FT_AX25 )) {
934 | return slice_string(fv, d_range);
935 | }
936 | return slice_bytes(fv, d_range);
937 | }
938 |
939 | void
940 | fvalue_set_bytes(fvalue_t *fv, GBytes *value)
941 | {
942 | ws_assert(fv->ftype->ftype == FT_BYTES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
943 | fv->ftype->ftype == FT_UINT_BYTES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
944 | fv->ftype->ftype == FT_OID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
945 | fv->ftype->ftype == FT_REL_OID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
946 | fv->ftype->ftype == FT_SYSTEM_ID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
947 | fv->ftype->ftype == FT_VINES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
948 | fv->ftype->ftype == FT_ETHER ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
949 | fv->ftype->ftype == FT_EUI64 ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0)
950 | fv->ftype->ftype == FT_FCWWN)do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv ->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv-> ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 950, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_FCWWN" ); } while (0);
951 | ws_assert(fv->ftype->set_value.set_value_bytes)do { if ((1) && !(fv->ftype->set_value.set_value_bytes )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 951, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_bytes" ); } while (0);
952 | fv->ftype->set_value.set_value_bytes(fv, value);
953 | }
954 |
955 | void
956 | fvalue_set_byte_array(fvalue_t *fv, GByteArray *value)
957 | {
958 | GBytes *bytes = g_byte_array_free_to_bytes(value);
959 | fvalue_set_bytes(fv, bytes);
960 | g_bytes_unref(bytes);
961 | }
962 |
963 | void
964 | fvalue_set_bytes_data(fvalue_t *fv, const void *data, size_t size)
965 | {
966 | GBytes *bytes = g_bytes_new(data, size);
967 | fvalue_set_bytes(fv, bytes);
968 | g_bytes_unref(bytes);
969 | }
970 |
971 | void
972 | fvalue_set_fcwwn(fvalue_t *fv, const uint8_t *value)
973 | {
974 | GBytes *bytes = g_bytes_new(value, FT_FCWWN_LEN8);
975 | fvalue_set_bytes(fv, bytes);
976 | g_bytes_unref(bytes);
977 | }
978 |
979 | void
980 | fvalue_set_ax25(fvalue_t *fv, const uint8_t *value)
981 | {
982 | wmem_strbuf_t *buf = wmem_strbuf_new(NULL((void*)0), NULL((void*)0));
983 | for (size_t i = 0; i < FT_AX25_ADDR_LEN7 - 1; i++) {
984 | if (value[i] != 0x40) {
985 | /* ignore space-padding */
986 | wmem_strbuf_append_c(buf, value[i] >> 1);
987 | }
988 | }
989 | /* Ignore C-bit and reserved bits, and end of address bits. */
990 | uint8_t ssid = (value[FT_AX25_ADDR_LEN7 - 1] >> 1) & 0x0f;
991 | if (ssid != 0) {
992 | wmem_strbuf_append_printf(buf, "-%u", ssid);
993 | }
994 | fvalue_set_strbuf(fv, buf);
995 | }
996 |
997 | void
998 | fvalue_set_vines(fvalue_t *fv, const uint8_t *value)
999 | {
1000 | GBytes *bytes = g_bytes_new(value, FT_VINES_ADDR_LEN6);
1001 | fvalue_set_bytes(fv, bytes);
1002 | g_bytes_unref(bytes);
1003 | }
1004 |
1005 | void
1006 | fvalue_set_ether(fvalue_t *fv, const uint8_t *value)
1007 | {
1008 | GBytes *bytes = g_bytes_new(value, FT_ETHER_LEN6);
1009 | fvalue_set_bytes(fv, bytes);
1010 | g_bytes_unref(bytes);
1011 | }
1012 |
1013 | void
1014 | fvalue_set_guid(fvalue_t *fv, const e_guid_t *value)
1015 | {
1016 | ws_assert(fv->ftype->ftype == FT_GUID)do { if ((1) && !(fv->ftype->ftype == FT_GUID)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1016, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_GUID" ); } while (0);
1017 | ws_assert(fv->ftype->set_value.set_value_guid)do { if ((1) && !(fv->ftype->set_value.set_value_guid )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1017, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_guid" ); } while (0);
1018 | fv->ftype->set_value.set_value_guid(fv, value);
1019 | }
1020 |
1021 | void
1022 | fvalue_set_time(fvalue_t *fv, const nstime_t *value)
1023 | {
1024 | ws_assert(FT_IS_TIME(fv->ftype->ftype))do { if ((1) && !(((fv->ftype->ftype) == FT_ABSOLUTE_TIME || (fv->ftype->ftype) == FT_RELATIVE_TIME))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1024, __func__, "assertion failed: %s", "((fv->ftype->ftype) == FT_ABSOLUTE_TIME || (fv->ftype->ftype) == FT_RELATIVE_TIME)" ); } while (0);
1025 | ws_assert(fv->ftype->set_value.set_value_time)do { if ((1) && !(fv->ftype->set_value.set_value_time )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1025, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_time" ); } while (0);
1026 | fv->ftype->set_value.set_value_time(fv, value);
1027 | }
1028 |
1029 | void
1030 | fvalue_set_string(fvalue_t *fv, const char *value)
1031 | {
1032 | wmem_strbuf_t *buf = wmem_strbuf_new(NULL((void*)0), value);
1033 | fvalue_set_strbuf(fv, buf);
1034 | }
1035 |
1036 | void
1037 | fvalue_set_strbuf(fvalue_t *fv, wmem_strbuf_t *value)
1038 | {
1039 | if (value->allocator != NULL((void*)0)) {
1040 | /* XXX Can this condition be relaxed? */
1041 | ws_critical("Fvalue strbuf allocator must be NULL")do { if (1) { ws_log_full("", LOG_LEVEL_CRITICAL, "epan/ftypes/ftypes.c" , 1041, __func__, "Fvalue strbuf allocator must be NULL"); } } while (0);
1042 | }
1043 | ws_assert(FT_IS_STRING(fv->ftype->ftype))do { if ((1) && !(((fv->ftype->ftype) == FT_STRING || (fv->ftype->ftype) == FT_STRINGZ || (fv->ftype-> ftype) == FT_STRINGZPAD || (fv->ftype->ftype) == FT_STRINGZTRUNC || (fv->ftype->ftype) == FT_UINT_STRING || (fv->ftype ->ftype) == FT_AX25))) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1043, __func__, "assertion failed: %s" , "((fv->ftype->ftype) == FT_STRING || (fv->ftype->ftype) == FT_STRINGZ || (fv->ftype->ftype) == FT_STRINGZPAD || (fv->ftype->ftype) == FT_STRINGZTRUNC || (fv->ftype->ftype) == FT_UINT_STRING || (fv->ftype->ftype) == FT_AX25)" ); } while (0);
1044 | ws_assert(fv->ftype->set_value.set_value_strbuf)do { if ((1) && !(fv->ftype->set_value.set_value_strbuf )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1044, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_strbuf" ); } while (0);
1045 | fv->ftype->set_value.set_value_strbuf(fv, value);
1046 | }
1047 |
1048 | void
1049 | fvalue_set_protocol(fvalue_t *fv, tvbuff_t *value, const char *name, int length)
1050 | {
1051 | ws_assert(fv->ftype->ftype == FT_PROTOCOL)do { if ((1) && !(fv->ftype->ftype == FT_PROTOCOL )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1051, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_PROTOCOL" ); } while (0);
1052 | ws_assert(fv->ftype->set_value.set_value_protocol)do { if ((1) && !(fv->ftype->set_value.set_value_protocol )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1052, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_protocol" ); } while (0);
1053 | fv->ftype->set_value.set_value_protocol(fv, value, name, length);
1054 | }
1055 |
1056 | void
1057 | fvalue_set_protocol_length(fvalue_t *fv, int length)
1058 | {
1059 | ws_assert(fv->ftype->ftype == FT_PROTOCOL)do { if ((1) && !(fv->ftype->ftype == FT_PROTOCOL )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1059, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_PROTOCOL" ); } while (0);
1060 | protocol_value_t *proto = &fv->value.protocol;
1061 | proto->length = length;
1062 | }
1063 |
1064 | void
1065 | fvalue_set_uinteger(fvalue_t *fv, uint32_t value)
1066 | {
1067 | ws_assert(fv->ftype->ftype == FT_IEEE_11073_SFLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1068 | fv->ftype->ftype == FT_IEEE_11073_FLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1069 | fv->ftype->ftype == FT_CHAR ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1070 | fv->ftype->ftype == FT_UINT8 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1071 | fv->ftype->ftype == FT_UINT16 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1072 | fv->ftype->ftype == FT_UINT24 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1073 | fv->ftype->ftype == FT_UINT32 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1074 | fv->ftype->ftype == FT_IPXNET ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1075 | fv->ftype->ftype == FT_FRAMENUM)do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1075, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0);
1076 | ws_assert(fv->ftype->set_value.set_value_uinteger)do { if ((1) && !(fv->ftype->set_value.set_value_uinteger )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1076, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_uinteger" ); } while (0);
1077 | fv->ftype->set_value.set_value_uinteger(fv, value);
1078 | }
1079 |
1080 | void
1081 | fvalue_set_sinteger(fvalue_t *fv, int32_t value)
1082 | {
1083 | ws_assert(fv->ftype->ftype == FT_INT8 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1086, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1084 | fv->ftype->ftype == FT_INT16 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1086, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1085 | fv->ftype->ftype == FT_INT24 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1086, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1086 | fv->ftype->ftype == FT_INT32)do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1086, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0);
1087 | ws_assert(fv->ftype->set_value.set_value_sinteger)do { if ((1) && !(fv->ftype->set_value.set_value_sinteger )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1087, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_sinteger" ); } while (0);
1088 | fv->ftype->set_value.set_value_sinteger(fv, value);
1089 | }
1090 |
1091 | void
1092 | fvalue_set_uinteger64(fvalue_t *fv, uint64_t value)
1093 | {
1094 | ws_assert(fv->ftype->ftype == FT_UINT40 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1098, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1095 | fv->ftype->ftype == FT_UINT48 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1098, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1096 | fv->ftype->ftype == FT_UINT56 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1098, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1097 | fv->ftype->ftype == FT_UINT64 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1098, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1098 | fv->ftype->ftype == FT_BOOLEAN)do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1098, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0);
1099 | ws_assert(fv->ftype->set_value.set_value_uinteger64)do { if ((1) && !(fv->ftype->set_value.set_value_uinteger64 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1099, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_uinteger64" ); } while (0);
1100 | fv->ftype->set_value.set_value_uinteger64(fv, value);
1101 | }
1102 |
1103 | void
1104 | fvalue_set_sinteger64(fvalue_t *fv, int64_t value)
1105 | {
1106 | ws_assert(fv->ftype->ftype == FT_INT40 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1109, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1107 | fv->ftype->ftype == FT_INT48 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1109, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1108 | fv->ftype->ftype == FT_INT56 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1109, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1109 | fv->ftype->ftype == FT_INT64)do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1109, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0);
1110 | ws_assert(fv->ftype->set_value.set_value_sinteger64)do { if ((1) && !(fv->ftype->set_value.set_value_sinteger64 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1110, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_sinteger64" ); } while (0);
1111 | fv->ftype->set_value.set_value_sinteger64(fv, value);
1112 | }
1113 |
1114 | void
1115 | fvalue_set_floating(fvalue_t *fv, double value)
1116 | {
1117 | ws_assert(fv->ftype->ftype == FT_FLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1118, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE" ); } while (0)
1118 | fv->ftype->ftype == FT_DOUBLE)do { if ((1) && !(fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1118, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE" ); } while (0);
1119 | ws_assert(fv->ftype->set_value.set_value_floating)do { if ((1) && !(fv->ftype->set_value.set_value_floating )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1119, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_floating" ); } while (0);
1120 | fv->ftype->set_value.set_value_floating(fv, value);
1121 | }
1122 |
1123 | void
1124 | fvalue_set_ipv4(fvalue_t *fv, const ipv4_addr_and_mask *value)
1125 | {
1126 | ws_assert(fv->ftype->ftype == FT_IPv4)do { if ((1) && !(fv->ftype->ftype == FT_IPv4)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1126, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IPv4" ); } while (0);
1127 | ws_assert(fv->ftype->set_value.set_value_ipv4)do { if ((1) && !(fv->ftype->set_value.set_value_ipv4 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1127, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_ipv4" ); } while (0);
1128 | fv->ftype->set_value.set_value_ipv4(fv, value);
1129 | }
1130 |
1131 | void
1132 | fvalue_set_ipv6(fvalue_t *fv, const ipv6_addr_and_prefix *value)
1133 | {
1134 | ws_assert(fv->ftype->ftype == FT_IPv6)do { if ((1) && !(fv->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1134, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IPv6" ); } while (0);
1135 | ws_assert(fv->ftype->set_value.set_value_ipv6)do { if ((1) && !(fv->ftype->set_value.set_value_ipv6 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1135, __func__, "assertion failed: %s", "fv->ftype->set_value.set_value_ipv6" ); } while (0);
1136 | fv->ftype->set_value.set_value_ipv6(fv, value);
1137 | }
1138 |
1139 | GBytes *
1140 | fvalue_get_bytes(fvalue_t *fv)
1141 | {
1142 | ws_assert(fv->ftype->ftype == FT_BYTES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1143 | fv->ftype->ftype == FT_UINT_BYTES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1144 | fv->ftype->ftype == FT_VINES ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1145 | fv->ftype->ftype == FT_ETHER ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1146 | fv->ftype->ftype == FT_OID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1147 | fv->ftype->ftype == FT_REL_OID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1148 | fv->ftype->ftype == FT_SYSTEM_ID ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1149 | fv->ftype->ftype == FT_FCWWN ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1150 | fv->ftype->ftype == FT_EUI64 ||do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0)
1151 | fv->ftype->ftype == FT_IPv6)do { if ((1) && !(fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype-> ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv ->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype-> ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv ->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1151, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_BYTES || fv->ftype->ftype == FT_UINT_BYTES || fv->ftype->ftype == FT_VINES || fv->ftype->ftype == FT_ETHER || fv->ftype->ftype == FT_OID || fv->ftype->ftype == FT_REL_OID || fv->ftype->ftype == FT_SYSTEM_ID || fv->ftype->ftype == FT_FCWWN || fv->ftype->ftype == FT_EUI64 || fv->ftype->ftype == FT_IPv6" ); } while (0);
1152 | ws_assert(fv->ftype->get_value.get_value_bytes)do { if ((1) && !(fv->ftype->get_value.get_value_bytes )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1152, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_bytes" ); } while (0);
1153 | return fv->ftype->get_value.get_value_bytes(fv);
1154 | }
1155 |
1156 | size_t
1157 | fvalue_get_bytes_size(fvalue_t *fv)
1158 | {
1159 | GBytes *bytes = fvalue_get_bytes(fv);
1160 | size_t size = g_bytes_get_size(bytes);
1161 | g_bytes_unref(bytes);
1162 | return size;
1163 | }
1164 |
1165 | const void *
1166 | fvalue_get_bytes_data(fvalue_t *fv)
1167 | {
1168 | GBytes *bytes = fvalue_get_bytes(fv);
1169 | const void *data = g_bytes_get_data(bytes, NULL((void*)0));
1170 | g_bytes_unref(bytes);
1171 | return data;
1172 | }
1173 |
1174 | const e_guid_t *
1175 | fvalue_get_guid(fvalue_t *fv)
1176 | {
1177 | ws_assert(fv->ftype->ftype == FT_GUID)do { if ((1) && !(fv->ftype->ftype == FT_GUID)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1177, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_GUID" ); } while (0);
1178 | ws_assert(fv->ftype->get_value.get_value_guid)do { if ((1) && !(fv->ftype->get_value.get_value_guid )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1178, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_guid" ); } while (0);
1179 | return fv->ftype->get_value.get_value_guid(fv);
1180 | }
1181 |
1182 | const nstime_t *
1183 | fvalue_get_time(fvalue_t *fv)
1184 | {
1185 | ws_assert(FT_IS_TIME(fv->ftype->ftype))do { if ((1) && !(((fv->ftype->ftype) == FT_ABSOLUTE_TIME || (fv->ftype->ftype) == FT_RELATIVE_TIME))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1185, __func__, "assertion failed: %s", "((fv->ftype->ftype) == FT_ABSOLUTE_TIME || (fv->ftype->ftype) == FT_RELATIVE_TIME)" ); } while (0);
1186 | ws_assert(fv->ftype->get_value.get_value_time)do { if ((1) && !(fv->ftype->get_value.get_value_time )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1186, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_time" ); } while (0);
1187 | return fv->ftype->get_value.get_value_time(fv);
1188 | }
1189 |
1190 | const char *
1191 | fvalue_get_string(fvalue_t *fv)
1192 | {
1193 | return wmem_strbuf_get_str(fvalue_get_strbuf(fv));
1194 | }
1195 |
1196 | const wmem_strbuf_t *
1197 | fvalue_get_strbuf(fvalue_t *fv)
1198 | {
1199 | ws_assert(FT_IS_STRING(fv->ftype->ftype))do { if ((1) && !(((fv->ftype->ftype) == FT_STRING || (fv->ftype->ftype) == FT_STRINGZ || (fv->ftype-> ftype) == FT_STRINGZPAD || (fv->ftype->ftype) == FT_STRINGZTRUNC || (fv->ftype->ftype) == FT_UINT_STRING || (fv->ftype ->ftype) == FT_AX25))) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1199, __func__, "assertion failed: %s" , "((fv->ftype->ftype) == FT_STRING || (fv->ftype->ftype) == FT_STRINGZ || (fv->ftype->ftype) == FT_STRINGZPAD || (fv->ftype->ftype) == FT_STRINGZTRUNC || (fv->ftype->ftype) == FT_UINT_STRING || (fv->ftype->ftype) == FT_AX25)" ); } while (0);
1200 | ws_assert(fv->ftype->get_value.get_value_strbuf)do { if ((1) && !(fv->ftype->get_value.get_value_strbuf )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1200, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_strbuf" ); } while (0);
1201 | return fv->ftype->get_value.get_value_strbuf(fv);
1202 | }
1203 |
1204 | tvbuff_t *
1205 | fvalue_get_protocol(fvalue_t *fv)
1206 | {
1207 | ws_assert(fv->ftype->ftype == FT_PROTOCOL)do { if ((1) && !(fv->ftype->ftype == FT_PROTOCOL )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1207, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_PROTOCOL" ); } while (0);
1208 | ws_assert(fv->ftype->get_value.get_value_protocol)do { if ((1) && !(fv->ftype->get_value.get_value_protocol )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1208, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_protocol" ); } while (0);
1209 | return fv->ftype->get_value.get_value_protocol(fv);
1210 | }
1211 |
1212 | uint32_t
1213 | fvalue_get_uinteger(fvalue_t *fv)
1214 | {
1215 | ws_assert(fv->ftype->ftype == FT_IEEE_11073_SFLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1216 | fv->ftype->ftype == FT_IEEE_11073_FLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1217 | fv->ftype->ftype == FT_CHAR ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1218 | fv->ftype->ftype == FT_UINT8 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1219 | fv->ftype->ftype == FT_UINT16 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1220 | fv->ftype->ftype == FT_UINT24 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1221 | fv->ftype->ftype == FT_UINT32 ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1222 | fv->ftype->ftype == FT_IPXNET ||do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0)
1223 | fv->ftype->ftype == FT_FRAMENUM)do { if ((1) && !(fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype ->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv-> ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1223, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IEEE_11073_SFLOAT || fv->ftype->ftype == FT_IEEE_11073_FLOAT || fv->ftype->ftype == FT_CHAR || fv->ftype->ftype == FT_UINT8 || fv->ftype->ftype == FT_UINT16 || fv->ftype->ftype == FT_UINT24 || fv->ftype->ftype == FT_UINT32 || fv->ftype->ftype == FT_IPXNET || fv->ftype->ftype == FT_FRAMENUM" ); } while (0);
1224 | ws_assert(fv->ftype->get_value.get_value_uinteger)do { if ((1) && !(fv->ftype->get_value.get_value_uinteger )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1224, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_uinteger" ); } while (0);
1225 | return fv->ftype->get_value.get_value_uinteger(fv);
1226 | }
1227 |
1228 | int32_t
1229 | fvalue_get_sinteger(fvalue_t *fv)
1230 | {
1231 | ws_assert(fv->ftype->ftype == FT_INT8 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1234, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1232 | fv->ftype->ftype == FT_INT16 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1234, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1233 | fv->ftype->ftype == FT_INT24 ||do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1234, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0)
1234 | fv->ftype->ftype == FT_INT32)do { if ((1) && !(fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1234, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT8 || fv->ftype->ftype == FT_INT16 || fv->ftype->ftype == FT_INT24 || fv->ftype->ftype == FT_INT32" ); } while (0);
1235 | ws_assert(fv->ftype->get_value.get_value_sinteger)do { if ((1) && !(fv->ftype->get_value.get_value_sinteger )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1235, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_sinteger" ); } while (0);
1236 | return fv->ftype->get_value.get_value_sinteger(fv);
1237 | }
1238 |
1239 | uint64_t
1240 | fvalue_get_uinteger64(fvalue_t *fv)
1241 | {
1242 | ws_assert(fv->ftype->ftype == FT_UINT40 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1246, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1243 | fv->ftype->ftype == FT_UINT48 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1246, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1244 | fv->ftype->ftype == FT_UINT56 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1246, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1245 | fv->ftype->ftype == FT_UINT64 ||do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1246, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0)
1246 | fv->ftype->ftype == FT_BOOLEAN)do { if ((1) && !(fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv-> ftype->ftype == FT_BOOLEAN)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1246, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_UINT40 || fv->ftype->ftype == FT_UINT48 || fv->ftype->ftype == FT_UINT56 || fv->ftype->ftype == FT_UINT64 || fv->ftype->ftype == FT_BOOLEAN" ); } while (0);
1247 | ws_assert(fv->ftype->get_value.get_value_uinteger64)do { if ((1) && !(fv->ftype->get_value.get_value_uinteger64 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1247, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_uinteger64" ); } while (0);
1248 | return fv->ftype->get_value.get_value_uinteger64(fv);
1249 | }
1250 |
1251 | int64_t
1252 | fvalue_get_sinteger64(fvalue_t *fv)
1253 | {
1254 | ws_assert(fv->ftype->ftype == FT_INT40 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1257, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1255 | fv->ftype->ftype == FT_INT48 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1257, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1256 | fv->ftype->ftype == FT_INT56 ||do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1257, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0)
1257 | fv->ftype->ftype == FT_INT64)do { if ((1) && !(fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1257, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_INT40 || fv->ftype->ftype == FT_INT48 || fv->ftype->ftype == FT_INT56 || fv->ftype->ftype == FT_INT64" ); } while (0);
1258 | ws_assert(fv->ftype->get_value.get_value_sinteger64)do { if ((1) && !(fv->ftype->get_value.get_value_sinteger64 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1258, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_sinteger64" ); } while (0);
1259 | return fv->ftype->get_value.get_value_sinteger64(fv);
1260 | }
1261 |
1262 | double
1263 | fvalue_get_floating(fvalue_t *fv)
1264 | {
1265 | ws_assert(fv->ftype->ftype == FT_FLOAT ||do { if ((1) && !(fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1266, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE" ); } while (0)
1266 | fv->ftype->ftype == FT_DOUBLE)do { if ((1) && !(fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/ftypes/ftypes.c", 1266, __func__, "assertion failed: %s" , "fv->ftype->ftype == FT_FLOAT || fv->ftype->ftype == FT_DOUBLE" ); } while (0);
1267 | ws_assert(fv->ftype->get_value.get_value_floating)do { if ((1) && !(fv->ftype->get_value.get_value_floating )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1267, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_floating" ); } while (0);
1268 | return fv->ftype->get_value.get_value_floating(fv);
1269 | }
1270 |
1271 | const ipv4_addr_and_mask *
1272 | fvalue_get_ipv4(fvalue_t *fv)
1273 | {
1274 | ws_assert(fv->ftype->ftype == FT_IPv4)do { if ((1) && !(fv->ftype->ftype == FT_IPv4)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1274, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IPv4" ); } while (0);
1275 | ws_assert(fv->ftype->get_value.get_value_ipv4)do { if ((1) && !(fv->ftype->get_value.get_value_ipv4 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1275, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_ipv4" ); } while (0);
1276 | return fv->ftype->get_value.get_value_ipv4(fv);
1277 | }
1278 |
1279 | const ipv6_addr_and_prefix *
1280 | fvalue_get_ipv6(fvalue_t *fv)
1281 | {
1282 | ws_assert(fv->ftype->ftype == FT_IPv6)do { if ((1) && !(fv->ftype->ftype == FT_IPv6)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1282, __func__, "assertion failed: %s", "fv->ftype->ftype == FT_IPv6" ); } while (0);
1283 | ws_assert(fv->ftype->get_value.get_value_ipv6)do { if ((1) && !(fv->ftype->get_value.get_value_ipv6 )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c" , 1283, __func__, "assertion failed: %s", "fv->ftype->get_value.get_value_ipv6" ); } while (0);
1284 | return fv->ftype->get_value.get_value_ipv6(fv);
1285 | }
1286 |
1287 | ft_bool_t
1288 | fvalue_eq(const fvalue_t *a, const fvalue_t *b)
1289 | {
1290 | int cmp;
1291 | enum ft_result res;
1292 |
1293 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1293, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1294 | res = a->ftype->compare(a, b, &cmp);
1295 | if (res != FT_OK)
1296 | return -res;
1297 | return cmp == 0 ? FT_TRUE1 : FT_FALSE0;
1298 | }
1299 |
1300 | ft_bool_t
1301 | fvalue_ne(const fvalue_t *a, const fvalue_t *b)
1302 | {
1303 | int cmp;
1304 | enum ft_result res;
1305 |
1306 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1306, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1307 | res = a->ftype->compare(a, b, &cmp);
1308 | if (res != FT_OK)
1309 | return -res;
1310 | return cmp != 0 ? FT_TRUE1 : FT_FALSE0;
1311 | }
1312 |
1313 | ft_bool_t
1314 | fvalue_gt(const fvalue_t *a, const fvalue_t *b)
1315 | {
1316 | int cmp;
1317 | enum ft_result res;
1318 |
1319 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1319, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1320 | res = a->ftype->compare(a, b, &cmp);
1321 | if (res != FT_OK)
1322 | return -res;
1323 | return cmp > 0 ? FT_TRUE1 : FT_FALSE0;
1324 | }
1325 |
1326 | ft_bool_t
1327 | fvalue_ge(const fvalue_t *a, const fvalue_t *b)
1328 | {
1329 | int cmp;
1330 | enum ft_result res;
1331 |
1332 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1332, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1333 | res = a->ftype->compare(a, b, &cmp);
1334 | if (res != FT_OK)
1335 | return -res;
1336 | return cmp >= 0 ? FT_TRUE1 : FT_FALSE0;
1337 | }
1338 |
1339 | ft_bool_t
1340 | fvalue_lt(const fvalue_t *a, const fvalue_t *b)
1341 | {
1342 | int cmp;
1343 | enum ft_result res;
1344 |
1345 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1345, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1346 | res = a->ftype->compare(a, b, &cmp);
1347 | if (res != FT_OK)
1348 | return -res;
1349 | return cmp < 0 ? FT_TRUE1 : FT_FALSE0;
1350 | }
1351 |
1352 | ft_bool_t
1353 | fvalue_le(const fvalue_t *a, const fvalue_t *b)
1354 | {
1355 | int cmp;
1356 | enum ft_result res;
1357 |
1358 | ws_assert(a->ftype->compare)do { if ((1) && !(a->ftype->compare)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1358, __func__, "assertion failed: %s", "a->ftype->compare"); } while ( 0);
1359 | res = a->ftype->compare(a, b, &cmp);
1360 | if (res != FT_OK)
1361 | return -res;
1362 | return cmp <= 0 ? FT_TRUE1 : FT_FALSE0;
1363 | }
1364 |
1365 | ft_bool_t
1366 | fvalue_contains(const fvalue_t *a, const fvalue_t *b)
1367 | {
1368 | bool_Bool yes;
1369 | enum ft_result res;
1370 |
1371 | ws_assert(a->ftype->contains)do { if ((1) && !(a->ftype->contains)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1371, __func__, "assertion failed: %s", "a->ftype->contains"); } while (0);
1372 | res = a->ftype->contains(a, b, &yes);
1373 | if (res != FT_OK)
1374 | return -res;
1375 | return yes ? FT_TRUE1 : FT_FALSE0;
1376 | }
1377 |
1378 | ft_bool_t
1379 | fvalue_matches(const fvalue_t *a, const ws_regex_t *re)
1380 | {
1381 | bool_Bool yes;
1382 | enum ft_result res;
1383 |
1384 | ws_assert(a->ftype->matches)do { if ((1) && !(a->ftype->matches)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1384, __func__, "assertion failed: %s", "a->ftype->matches"); } while ( 0);
1385 | res = a->ftype->matches(a, re, &yes);
1386 | if (res != FT_OK)
1387 | return -res;
1388 | return yes ? FT_TRUE1 : FT_FALSE0;
1389 | }
1390 |
1391 | bool_Bool
1392 | fvalue_is_zero(const fvalue_t *a)
1393 | {
1394 | return a->ftype->is_zero(a);
1395 | }
1396 |
1397 | bool_Bool
1398 | fvalue_is_negative(const fvalue_t *a)
1399 | {
1400 | return a->ftype->is_negative(a);
1401 | }
1402 |
1403 | bool_Bool
1404 | fvalue_is_nan(const fvalue_t *a)
1405 | {
1406 | return a->ftype->is_nan(a);
1407 | }
1408 |
1409 | static fvalue_t *
1410 | _fvalue_binop(FvalueBinaryOp op, const fvalue_t *a, const fvalue_t *b, char **err_msg)
1411 | {
1412 | fvalue_t *result;
1413 |
1414 | result = fvalue_new(a->ftype->ftype);
1415 | if (op(result, a, b, err_msg) != FT_OK) {
1416 | fvalue_free(result);
1417 | return NULL((void*)0);
1418 | }
1419 | return result;
1420 | }
1421 |
1422 | fvalue_t *
1423 | fvalue_bitwise_and(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1424 | {
1425 | /* XXX - check compatibility of a and b */
1426 | ws_assert(a->ftype->bitwise_and)do { if ((1) && !(a->ftype->bitwise_and)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1426, __func__, "assertion failed: %s", "a->ftype->bitwise_and"); } while (0);
1427 | return _fvalue_binop(a->ftype->bitwise_and, a, b, err_msg);
1428 | }
1429 |
1430 | fvalue_t *
1431 | fvalue_add(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1432 | {
1433 | /* XXX - check compatibility of a and b */
1434 | ws_assert(a->ftype->add)do { if ((1) && !(a->ftype->add)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1434, __func__, "assertion failed: %s", "a->ftype->add"); } while (0);
1435 | return _fvalue_binop(a->ftype->add, a, b, err_msg);
1436 | }
1437 |
1438 | fvalue_t *
1439 | fvalue_subtract(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1440 | {
1441 | /* XXX - check compatibility of a and b */
1442 | ws_assert(a->ftype->subtract)do { if ((1) && !(a->ftype->subtract)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1442, __func__, "assertion failed: %s", "a->ftype->subtract"); } while (0);
1443 | return _fvalue_binop(a->ftype->subtract, a, b, err_msg);
1444 | }
1445 |
1446 | fvalue_t *
1447 | fvalue_multiply(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1448 | {
1449 | /* XXX - check compatibility of a and b */
1450 | ws_assert(a->ftype->multiply)do { if ((1) && !(a->ftype->multiply)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1450, __func__, "assertion failed: %s", "a->ftype->multiply"); } while (0);
1451 | return _fvalue_binop(a->ftype->multiply, a, b, err_msg);
1452 | }
1453 |
1454 | fvalue_t *
1455 | fvalue_divide(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1456 | {
1457 | /* XXX - check compatibility of a and b */
1458 | ws_assert(a->ftype->divide)do { if ((1) && !(a->ftype->divide)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1458, __func__, "assertion failed: %s", "a->ftype->divide"); } while ( 0);
1459 | return _fvalue_binop(a->ftype->divide, a, b, err_msg);
1460 | }
1461 |
1462 | fvalue_t *
1463 | fvalue_modulo(const fvalue_t *a, const fvalue_t *b, char **err_msg)
1464 | {
1465 | /* XXX - check compatibility of a and b */
1466 | ws_assert(a->ftype->modulo)do { if ((1) && !(a->ftype->modulo)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1466, __func__, "assertion failed: %s", "a->ftype->modulo"); } while ( 0);
1467 | return _fvalue_binop(a->ftype->modulo, a, b, err_msg);
1468 | }
1469 |
1470 | fvalue_t*
1471 | fvalue_unary_minus(const fvalue_t *fv, char **err_msg)
1472 | {
1473 | fvalue_t *result;
1474 |
1475 | ws_assert(fv->ftype->unary_minus)do { if ((1) && !(fv->ftype->unary_minus)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1475, __func__, "assertion failed: %s", "fv->ftype->unary_minus"); } while (0);
1476 |
1477 | result = fvalue_new(fv->ftype->ftype);
1478 | if (fv->ftype->unary_minus(result, fv, err_msg) != FT_OK) {
1479 | fvalue_free(result);
1480 | return NULL((void*)0);
1481 | }
1482 | return result;
1483 | }
1484 |
1485 | unsigned
1486 | fvalue_hash(const fvalue_t *fv)
1487 | {
1488 | ws_assert(fv->ftype->hash)do { if ((1) && !(fv->ftype->hash)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/ftypes/ftypes.c", 1488, __func__, "assertion failed: %s", "fv->ftype->hash"); } while (0 );
1489 | return fv->ftype->hash(fv);
1490 | }
1491 |
1492 | bool_Bool
1493 | fvalue_equal(const fvalue_t *a, const fvalue_t *b)
1494 | {
1495 | return fvalue_eq(a, b) == FT_TRUE1;
1496 | }
1497 |
1498 | /*
1499 | * Editor modelines - https://www.wireshark.org/tools/modelines.html
1500 | *
1501 | * Local variables:
1502 | * c-basic-offset: 8
1503 | * tab-width: 8
1504 | * indent-tabs-mode: t
1505 | * End:
1506 | *
1507 | * vi: set shiftwidth=8 tabstop=8 noexpandtab:
1508 | * :indentSize=8:tabSize=8:noTabs=false:
1509 | */