Branch data Line data Source code
1 : : #ifndef FLATBUFFERS_COMMON_READER_H
2 : : #define FLATBUFFERS_COMMON_READER_H
3 : :
4 : : /* Generated by flatcc 0.4.0 FlatBuffers schema compiler for C by dvide.com */
5 : :
6 : : /* Common FlatBuffers read functionality for C. */
7 : :
8 : : #define PDIAGNOSTIC_IGNORE_UNUSED
9 : : #include "flatcc/portable/pdiagnostic_push.h"
10 : : #include "flatcc/flatcc_flatbuffers.h"
11 : :
12 : :
13 : : #define __flatbuffers_read_scalar_at_byteoffset(N, p, o) N ## _read_from_pe((uint8_t *)(p) + (o))
14 : : #define __flatbuffers_read_scalar(N, p) N ## _read_from_pe(p)
15 : : #define __flatbuffers_read_vt(ID, offset, t)\
16 : : flatbuffers_voffset_t offset = 0;\
17 : : { flatbuffers_voffset_t id, *vt;\
18 : : assert(t != 0 && "null pointer table access");\
19 : : id = ID;\
20 : : vt = (flatbuffers_voffset_t *)((uint8_t *)(t) -\
21 : : __flatbuffers_soffset_read_from_pe(t));\
22 : : if (__flatbuffers_voffset_read_from_pe(vt) >= sizeof(vt[0]) * (id + 3)) {\
23 : : offset = __flatbuffers_voffset_read_from_pe(vt + id + 2);\
24 : : }\
25 : : }
26 : : #define __flatbuffers_field_present(ID, t) { __flatbuffers_read_vt(ID, offset, t) return offset != 0; }
27 : : #define __flatbuffers_scalar_field(N, ID, V, t)\
28 : : {\
29 : : __flatbuffers_read_vt(ID, offset, t)\
30 : : return offset ? __flatbuffers_read_scalar_at_byteoffset(N, t, offset) : V;\
31 : : }
32 : : #define __flatbuffers_struct_field(T, ID, t, r)\
33 : : {\
34 : : __flatbuffers_read_vt(ID, offset, t)\
35 : : if (offset) {\
36 : : return (T)((uint8_t *)(t) + offset);\
37 : : }\
38 : : assert(!(r) && "required field missing");\
39 : : return 0;\
40 : : }
41 : : #define __flatbuffers_offset_field(T, ID, t, r, adjust)\
42 : : {\
43 : : flatbuffers_uoffset_t *elem;\
44 : : __flatbuffers_read_vt(ID, offset, t)\
45 : : if (offset) {\
46 : : elem = (flatbuffers_uoffset_t *)((uint8_t *)(t) + offset);\
47 : : /* Add sizeof so C api can have raw access past header field. */\
48 : : return (T)((uint8_t *)(elem) + adjust +\
49 : : __flatbuffers_uoffset_read_from_pe(elem));\
50 : : }\
51 : : assert(!(r) && "required field missing");\
52 : : return 0;\
53 : : }
54 : : #define __flatbuffers_vector_field(T, ID, t, r) __flatbuffers_offset_field(T, ID, t, r, sizeof(flatbuffers_uoffset_t))
55 : : #define __flatbuffers_table_field(T, ID, t, r) __flatbuffers_offset_field(T, ID, t, r, 0)
56 : : #define __flatbuffers_vec_len(vec)\
57 : : { return (vec) ? (size_t)__flatbuffers_uoffset_read_from_pe((flatbuffers_uoffset_t *)vec - 1) : 0; }
58 : : #define __flatbuffers_string_len(s) __flatbuffers_vec_len(s)
59 : : static inline size_t flatbuffers_vec_len(const void *vec)
60 : : __flatbuffers_vec_len(vec)
61 : : #define __flatbuffers_scalar_vec_at(N, vec, i)\
62 : : { assert(flatbuffers_vec_len(vec) > (i) && "index out of range");\
63 : : return __flatbuffers_read_scalar(N, &(vec)[i]); }
64 : : #define __flatbuffers_struct_vec_at(vec, i)\
65 : : { assert(flatbuffers_vec_len(vec) > (i) && "index out of range"); return (vec) + (i); }
66 : : /* `adjust` skips past the header for string vectors. */
67 : : #define __flatbuffers_offset_vec_at(T, vec, i, adjust)\
68 : : { const flatbuffers_uoffset_t *elem = (vec) + (i);\
69 : : assert(flatbuffers_vec_len(vec) > (i) && "index out of range");\
70 : : return (T)((uint8_t *)(elem) + (size_t)__flatbuffers_uoffset_read_from_pe(elem) + adjust); }
71 : : #define __flatbuffers_define_scalar_vec_len(N) \
72 : : static inline size_t N ## _vec_len(N ##_vec_t vec)\
73 : : { return flatbuffers_vec_len(vec); }
74 : : #define __flatbuffers_define_scalar_vec_at(N, T) \
75 : : static inline T N ## _vec_at(N ## _vec_t vec, size_t i)\
76 : : __flatbuffers_scalar_vec_at(N, vec, i)
77 : : typedef const char *flatbuffers_string_t;
78 : : static inline size_t flatbuffers_string_len(flatbuffers_string_t s)
79 [ + - ][ + - ]: 736 : __flatbuffers_string_len(s)
[ + - ]
80 : : typedef const flatbuffers_uoffset_t *flatbuffers_string_vec_t;
81 : : typedef flatbuffers_uoffset_t *flatbuffers_string_mutable_vec_t;
82 : : static inline size_t flatbuffers_string_vec_len(flatbuffers_string_vec_t vec)
83 : : __flatbuffers_vec_len(vec)
84 : : static inline flatbuffers_string_t flatbuffers_string_vec_at(flatbuffers_string_vec_t vec, size_t i)
85 : : __flatbuffers_offset_vec_at(flatbuffers_string_t, vec, i, sizeof(vec[0]))
86 : : typedef const void *flatbuffers_generic_table_t;
87 : : #include <string.h>
88 : : static size_t flatbuffers_not_found = (size_t)-1;
89 : : #define __flatbuffers_identity(n) (n)
90 : : /* Subtraction doesn't work for unsigned types. */
91 : : #define __flatbuffers_scalar_cmp(x, y, n) ((x) < (y) ? -1 : (x) > (y))
92 : 368 : static inline int __flatbuffers_string_n_cmp(flatbuffers_string_t v, const char *s, size_t n)
93 : 368 : { size_t nv = flatbuffers_string_len(v); int x = strncmp(v, s, nv < n ? nv : n);
94 [ + + ][ + + ]: 368 : return x != 0 ? x : nv < n ? -1 : nv > n; }
95 : : /* `n` arg unused, but needed by string find macro expansion. */
96 : : static inline int __flatbuffers_string_cmp(flatbuffers_string_t v, const char *s, size_t n) { (void)n; return strcmp(v, s); }
97 : : /* A = identity if searching scalar vectors rather than key fields. */
98 : : /* Returns lowest matching index not_found. */
99 : : #define __flatbuffers_find_by_field(A, V, E, L, K, Kn, T, D)\
100 : : { T v; size_t a = 0, b, m; if (!(b = L(V))) { return flatbuffers_not_found; }\
101 : : --b;\
102 : : while (a < b) {\
103 : : m = a + ((b - a) >> 1);\
104 : : v = A(E(V, m));\
105 : : if ((D(v, (K), (Kn))) < 0) {\
106 : : a = m + 1;\
107 : : } else {\
108 : : b = m;\
109 : : }\
110 : : }\
111 : : if (a == b) {\
112 : : v = A(E(V, a));\
113 : : if (D(v, (K), (Kn)) == 0) {\
114 : : return a;\
115 : : }\
116 : : }\
117 : : return flatbuffers_not_found;\
118 : : }
119 : : #define __flatbuffers_find_by_scalar_field(A, V, E, L, K, T)\
120 : : __flatbuffers_find_by_field(A, V, E, L, K, 0, T, __flatbuffers_scalar_cmp)
121 : : #define __flatbuffers_find_by_string_field(A, V, E, L, K)\
122 : : __flatbuffers_find_by_field(A, V, E, L, K, 0, flatbuffers_string_t, __flatbuffers_string_cmp)
123 : : #define __flatbuffers_find_by_string_n_field(A, V, E, L, K, Kn)\
124 : : __flatbuffers_find_by_field(A, V, E, L, K, Kn, flatbuffers_string_t, __flatbuffers_string_n_cmp)
125 : : #define __flatbuffers_define_find_by_scalar_field(N, NK, TK)\
126 : : static inline size_t N ## _vec_find_by_ ## NK(N ## _vec_t vec, TK key)\
127 : : __flatbuffers_find_by_scalar_field(N ## _ ## NK, vec, N ## _vec_at, N ## _vec_len, key, TK)
128 : : #define __flatbuffers_define_scalar_find(N, T)\
129 : : static inline size_t N ## _vec_find(N ## _vec_t vec, T key)\
130 : : __flatbuffers_find_by_scalar_field(__flatbuffers_identity, vec, N ## _vec_at, N ## _vec_len, key, T)
131 : : #define __flatbuffers_heap_sort(N, X, A, E, L, TK, TE, D, S)\
132 : : static inline void __ ## N ## X ## __heap_sift_down(\
133 : : N ## _mutable_vec_t vec, size_t start, size_t end)\
134 : : { size_t child, root; TK v1, v2, vroot;\
135 : : root = start;\
136 : : while ((root << 1) <= end) {\
137 : : child = root << 1;\
138 : : if (child < end) {\
139 : : v1 = A(E(vec, child));\
140 : : v2 = A(E(vec, child + 1));\
141 : : if (D(v1, v2) < 0) {\
142 : : child++;\
143 : : }\
144 : : }\
145 : : vroot = A(E(vec, root));\
146 : : v1 = A(E(vec, child));\
147 : : if (D(vroot, v1) < 0) {\
148 : : S(vec, root, child, TE);\
149 : : root = child;\
150 : : } else {\
151 : : return;\
152 : : }\
153 : : }\
154 : : }\
155 : : static inline void __ ## N ## X ## __heap_sort(N ## _mutable_vec_t vec)\
156 : : { size_t start, end, size;\
157 : : size = L(vec); if (size == 0) return; end = size - 1; start = size >> 1;\
158 : : do { __ ## N ## X ## __heap_sift_down(vec, start, end); } while (start--);\
159 : : while (end > 0) { \
160 : : S(vec, 0, end, TE);\
161 : : __ ## N ## X ## __heap_sift_down(vec, 0, --end); } }
162 : : #define __flatbuffers_define_sort_by_field(N, NK, TK, TE, D, S)\
163 : : __flatbuffers_heap_sort(N, _sort_by_ ## NK, N ## _ ## NK, N ## _vec_at, N ## _vec_len, TK, TE, D, S)\
164 : : static inline void N ## _vec_sort_by_ ## NK(N ## _mutable_vec_t vec)\
165 : : { __ ## N ## _sort_by_ ## NK ## __heap_sort(vec); }
166 : : #define __flatbuffers_define_sort(N, TK, TE, D, S)\
167 : : __flatbuffers_heap_sort(N, , __flatbuffers_identity, N ## _vec_at, N ## _vec_len, TK, TE, D, S)\
168 : : static inline void N ## _vec_sort(N ## _mutable_vec_t vec) { __ ## N ## __heap_sort(vec); }
169 : : #define __flatbuffers_scalar_diff(x, y) ((x) < (y) ? -1 : (x) > (y))
170 : : #define __flatbuffers_string_diff(x, y) __flatbuffers_string_n_cmp((x), (const char *)(y), flatbuffers_string_len(y))
171 : : #define __flatbuffers_scalar_swap(vec, a, b, TE) { TE tmp = vec[b]; vec[b] = vec[a]; vec[a] = tmp; }
172 : : #define __flatbuffers_string_swap(vec, a, b, TE)\
173 : : { TE ta, tb, d;\
174 : : d = (TE)((a - b) * sizeof(vec[0]));\
175 : : ta = __flatbuffers_uoffset_read_from_pe(vec + b) - d;\
176 : : tb = __flatbuffers_uoffset_read_from_pe(vec + a) + d;\
177 : : __flatbuffers_uoffset_write_to_pe(vec + a, ta);\
178 : : __flatbuffers_uoffset_write_to_pe(vec + b, tb); }
179 : : #define __flatbuffers_define_sort_by_scalar_field(N, NK, TK, TE)\
180 : : __flatbuffers_define_sort_by_field(N, NK, TK, TE, __flatbuffers_scalar_diff, __flatbuffers_scalar_swap)
181 : : #define __flatbuffers_define_sort_by_string_field(N, NK)\
182 : : __flatbuffers_define_sort_by_field(N, NK, flatbuffers_string_t, flatbuffers_uoffset_t, __flatbuffers_string_diff, __flatbuffers_string_swap)
183 : : #define __flatbuffers_define_scalar_sort(N, T) __flatbuffers_define_sort(N, T, T, __flatbuffers_scalar_diff, __flatbuffers_scalar_swap)
184 : : #define __flatbuffers_define_string_sort() __flatbuffers_define_sort(flatbuffers_string, flatbuffers_string_t, flatbuffers_uoffset_t, __flatbuffers_string_diff, __flatbuffers_string_swap)
185 : : #define __flatbuffers_define_scalar_vector(N, T)\
186 : : typedef const T *N ## _vec_t;\
187 : : typedef T *N ## _mutable_vec_t;\
188 : : __flatbuffers_define_scalar_vec_len(N)\
189 : : __flatbuffers_define_scalar_vec_at(N, T)\
190 : : __flatbuffers_define_scalar_find(N, T)\
191 : : \
192 : : __flatbuffers_define_scalar_sort(N, T)
193 : :
194 : : #define __flatbuffers_define_integer_type(N, T, W)\
195 : : __flatcc_define_integer_accessors(N, T, W, flatbuffers_endian)\
196 : : __flatbuffers_define_scalar_vector(N, T)
197 : : __flatbuffers_define_scalar_vector(flatbuffers_bool, flatbuffers_bool_t)
198 : : __flatbuffers_define_scalar_vector(flatbuffers_uint8, uint8_t)
199 : : __flatbuffers_define_scalar_vector(flatbuffers_int8, int8_t)
200 : : __flatbuffers_define_scalar_vector(flatbuffers_uint16, uint16_t)
201 : : __flatbuffers_define_scalar_vector(flatbuffers_int16, int16_t)
202 : : __flatbuffers_define_scalar_vector(flatbuffers_uint32, uint32_t)
203 : : __flatbuffers_define_scalar_vector(flatbuffers_int32, int32_t)
204 : : __flatbuffers_define_scalar_vector(flatbuffers_uint64, uint64_t)
205 : : __flatbuffers_define_scalar_vector(flatbuffers_int64, int64_t)
206 : : __flatbuffers_define_scalar_vector(flatbuffers_float, float)
207 : : __flatbuffers_define_scalar_vector(flatbuffers_double, double)
208 : : static inline size_t flatbuffers_string_vec_find(flatbuffers_string_vec_t vec, const char *s)
209 : : __flatbuffers_find_by_string_field(__flatbuffers_identity, vec, flatbuffers_string_vec_at, flatbuffers_string_vec_len, s)
210 : : static inline size_t flatbuffers_string_vec_find_n(flatbuffers_string_vec_t vec, const char *s, size_t n)
211 : : __flatbuffers_find_by_string_n_field(__flatbuffers_identity, vec, flatbuffers_string_vec_at, flatbuffers_string_vec_len, s, n)
212 : : __flatbuffers_define_string_sort()
213 : : #define __flatbuffers_struct_scalar_field(t, M, N)\
214 : : { return t ? __flatbuffers_read_scalar(N, &(t->M)) : 0; }
215 : : #define __flatbuffers_struct_struct_field(t, M) { return t ? &(t->M) : 0; }
216 : : /* If fid is null, the function returns true without testing as buffer is not expected to have any id. */
217 : 2 : static inline int flatbuffers_has_identifier(const void *buffer, const char *fid)
218 [ + - ]: 2 : { flatbuffers_thash_t id, id2 = 0; if (fid == 0) { return 1; };
219 : 2 : strncpy((char *)&id2, fid, sizeof(id2));
220 : : /* Identifier strings are always considered little endian. */
221 : 2 : id2 = __flatbuffers_thash_cast_from_le(id2);
222 : : id = __flatbuffers_thash_read_from_pe(((flatbuffers_uoffset_t *)buffer) + 1);
223 [ + - ][ - + ]: 2 : return id2 == 0 || id == id2; }
224 : : static inline int flatbuffers_has_type_hash(const void *buffer, flatbuffers_thash_t thash)
225 : : { return thash == 0 || (__flatbuffers_thash_read_from_pe((flatbuffers_uoffset_t *)buffer + 1) == thash); }
226 : :
227 : : static inline flatbuffers_thash_t flatbuffers_get_type_hash(const void *buffer)
228 : : { return __flatbuffers_thash_read_from_pe((flatbuffers_uoffset_t *)buffer + 1); }
229 : :
230 : : #define flatbuffers_verify_endian() flatbuffers_has_identifier("\x00\x00\x00\x00" "1234", "1234")
231 : : static inline void *flatbuffers_read_size_prefix(void *b, size_t *size_out)
232 : : { if (size_out) { *size_out = (size_t)__flatbuffers_uoffset_read_from_pe(b); }
233 : : return (uint8_t *)b + sizeof(flatbuffers_uoffset_t); }
234 : : /* Null file identifier accepts anything, otherwise fid should be 4 characters. */
235 : : #define __flatbuffers_read_root(T, K, buffer, fid)\
236 : : ((!buffer || !flatbuffers_has_identifier(buffer, fid)) ? 0 :\
237 : : ((T ## _ ## K ## t)(((uint8_t *)buffer) +\
238 : : __flatbuffers_uoffset_read_from_pe(buffer))))
239 : : #define __flatbuffers_read_typed_root(T, K, buffer, thash)\
240 : : ((!buffer || !flatbuffers_has_type_hash(buffer, thash)) ? 0 :\
241 : : ((T ## _ ## K ## t)(((uint8_t *)buffer) +\
242 : : __flatbuffers_uoffset_read_from_pe(buffer))))
243 : : #define __flatbuffers_nested_buffer_as_root(C, N, T, K)\
244 : : static inline T ## _ ## K ## t C ## _ ## N ## _as_root_with_identifier(C ## _ ## table_t t, const char *fid)\
245 : : { const uint8_t *buffer = C ## _ ## N(t); return __flatbuffers_read_root(T, K, buffer, fid); }\
246 : : static inline T ## _ ## K ## t C ## _ ## N ## _as_typed_root(C ## _ ## table_t t)\
247 : : { const uint8_t *buffer = C ## _ ## N(t); return __flatbuffers_read_root(T, K, buffer, C ## _ ## type_identifier); }\
248 : : static inline T ## _ ## K ## t C ## _ ## N ## _as_root(C ## _ ## table_t t)\
249 : : { const char *fid = T ## _identifier;\
250 : : const uint8_t *buffer = C ## _ ## N(t); return __flatbuffers_read_root(T, K, buffer, fid); }
251 : : #define __flatbuffers_buffer_as_root(N, K)\
252 : : static inline N ## _ ## K ## t N ## _as_root_with_identifier(const void *buffer, const char *fid)\
253 : : { return __flatbuffers_read_root(N, K, buffer, fid); }\
254 : : static inline N ## _ ## K ## t N ## _as_root_with_type_hash(const void *buffer, flatbuffers_thash_t thash)\
255 : : { return __flatbuffers_read_typed_root(N, K, buffer, thash); }\
256 : : static inline N ## _ ## K ## t N ## _as_root(const void *buffer)\
257 : : { const char *fid = N ## _identifier;\
258 : : return __flatbuffers_read_root(N, K, buffer, fid); }\
259 : : static inline N ## _ ## K ## t N ## _as_typed_root(const void *buffer)\
260 : : { return __flatbuffers_read_typed_root(N, K, buffer, N ## _type_hash); }
261 : : #define __flatbuffers_struct_as_root(N) __flatbuffers_buffer_as_root(N, struct_)
262 : : #define __flatbuffers_table_as_root(N) __flatbuffers_buffer_as_root(N, table_)
263 : :
264 : : #include "flatcc/portable/pdiagnostic_pop.h"
265 : : #endif /* FLATBUFFERS_COMMON_H */
|