LCOV - code coverage report
Current view: top level - include/flatcc/reflection - flatbuffers_common_reader.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 9 9 100.0 %
Date: 2016-11-30 13:12:14 Functions: 2 2 100.0 %
Branches: 10 16 62.5 %

           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 */

Generated by: LCOV version 1.12