### Bug Summary

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