| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* GATE PROJECT LICENSE: | ||
| 2 | +----------------------------------------------------------------------------+ | ||
| 3 | | Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at> | | ||
| 4 | | All rights reserved. | | ||
| 5 | | | | ||
| 6 | | Redistribution and use in source and binary forms, with or without | | ||
| 7 | | modification, are permitted provided that the following conditions are met:| | ||
| 8 | | | | ||
| 9 | | 1. Redistributions of source code must retain the above copyright notice, | | ||
| 10 | | this list of conditions and the following disclaimer. | | ||
| 11 | | 2. Redistributions in binary form must reproduce the above copyright | | ||
| 12 | | notice, this list of conditions and the following disclaimer in the | | ||
| 13 | | documentation and/or other materials provided with the distribution. | | ||
| 14 | | | | ||
| 15 | | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"| | ||
| 16 | | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | | ||
| 17 | | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | | ||
| 18 | | ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | | ||
| 19 | | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | | ||
| 20 | | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | | ||
| 21 | | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | | ||
| 22 | | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | | ||
| 23 | | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | | ||
| 24 | | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | | ||
| 25 | | THE POSSIBILITY OF SUCH DAMAGE. | | ||
| 26 | +----------------------------------------------------------------------------+ | ||
| 27 | */ | ||
| 28 | #include "gate/typeids.h" | ||
| 29 | #include "gate/guids.h" | ||
| 30 | #include "gate/times.h" | ||
| 31 | #include "gate/strings.h" | ||
| 32 | #include "gate/objects.h" | ||
| 33 | #include "gate/structs.h" | ||
| 34 | #include "gate/arrays.h" | ||
| 35 | #include "gate/results.h" | ||
| 36 | #include "gate/properties.h" | ||
| 37 | #include "gate/blobs.h" | ||
| 38 | |||
| 39 | |||
| 40 | 2363 | gate_size_t gate_type_length(gate_type_id_t value_type) | |
| 41 | { | ||
| 42 |
25/29✓ Branch 0 taken 15 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 15 times.
✓ Branch 4 taken 15 times.
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 15 times.
✓ Branch 7 taken 11 times.
✓ Branch 8 taken 11 times.
✓ Branch 9 taken 24 times.
✓ Branch 10 taken 11 times.
✓ Branch 11 taken 4 times.
✓ Branch 12 taken 4 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 4 times.
✓ Branch 15 taken 4 times.
✓ Branch 16 taken 4 times.
✓ Branch 17 taken 4 times.
✓ Branch 18 taken 4 times.
✓ Branch 19 taken 4 times.
✓ Branch 20 taken 272 times.
✓ Branch 21 taken 1894 times.
✗ Branch 22 not taken.
✓ Branch 23 taken 4 times.
✓ Branch 24 taken 1 times.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✓ Branch 28 taken 11 times.
|
2363 | switch (value_type) |
| 43 | { | ||
| 44 | 15 | case GATE_TYPE_BOOL: return sizeof(gate_bool_t); | |
| 45 | 11 | case GATE_TYPE_I8: return sizeof(gate_int8_t); | |
| 46 | 6 | case GATE_TYPE_UI8: return sizeof(gate_uint8_t); | |
| 47 | 15 | case GATE_TYPE_I16: return sizeof(gate_int16_t); | |
| 48 | 15 | case GATE_TYPE_UI16: return sizeof(gate_uint16_t); | |
| 49 | 11 | case GATE_TYPE_I32: return sizeof(gate_int32_t); | |
| 50 | 15 | case GATE_TYPE_UI32: return sizeof(gate_uint32_t); | |
| 51 | 11 | case GATE_TYPE_I64: return sizeof(gate_int64_t); | |
| 52 | 11 | case GATE_TYPE_UI64: return sizeof(gate_uint64_t); | |
| 53 | 24 | case GATE_TYPE_R32: return sizeof(gate_real32_t); | |
| 54 | 11 | case GATE_TYPE_R64: return sizeof(gate_real64_t); | |
| 55 | 4 | case GATE_TYPE_ADDRESS: return sizeof(gate_uintptr_t); | |
| 56 | |||
| 57 | 4 | case GATE_TYPE_DATAPTR: return sizeof(gate_dataptr_t); | |
| 58 | 4 | case GATE_TYPE_FUNCPTR: return sizeof(gate_funcptr_t); | |
| 59 | 4 | case GATE_TYPE_CSTR: return sizeof(gate_cstr_t); | |
| 60 | 4 | case GATE_TYPE_WSTR: return sizeof(gate_wstr_t); | |
| 61 | 4 | case GATE_TYPE_GUID: return sizeof(gate_guid_t); | |
| 62 | 4 | case GATE_TYPE_DATE: return sizeof(gate_date_t); | |
| 63 | 4 | case GATE_TYPE_DAYTIME: return sizeof(gate_daytime_t); | |
| 64 | 4 | case GATE_TYPE_DATETIME: return sizeof(gate_datetime_t); | |
| 65 | 272 | case GATE_TYPE_TIME: return sizeof(gate_time_t); | |
| 66 | |||
| 67 | 1894 | case GATE_TYPE_STRING: return sizeof(gate_string_t); | |
| 68 | ✗ | case GATE_TYPE_ARRAY: return sizeof(gate_array_t); | |
| 69 | 4 | case GATE_TYPE_BLOB: return sizeof(gate_blob_t); | |
| 70 | 1 | case GATE_TYPE_ARRAYLIST: return sizeof(gate_arraylist_t); | |
| 71 | |||
| 72 | ✗ | case GATE_TYPE_STRUCT: return sizeof(gate_struct_ptr_t); | |
| 73 | ✗ | case GATE_TYPE_OBJECT: return sizeof(gate_object_ptr_t); | |
| 74 | ✗ | case GATE_TYPE_PROPERTY: return sizeof(gate_property_t); | |
| 75 | |||
| 76 | 11 | default: | |
| 77 | { | ||
| 78 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 10 times.
|
11 | if ((value_type & GATE_TYPE_ARRAYLIST) == GATE_TYPE_ARRAYLIST) |
| 79 | { | ||
| 80 | 1 | return sizeof(gate_arraylist_t); | |
| 81 | } | ||
| 82 | 10 | break; | |
| 83 | } | ||
| 84 | } | ||
| 85 | 10 | return 0; | |
| 86 | } | ||
| 87 | |||
| 88 | #define CREATE_ALIGNED_TYPE(type_name) struct alignment_helper_ ## type_name { char pad; type_name item; } | ||
| 89 | CREATE_ALIGNED_TYPE(gate_bool_t); | ||
| 90 | CREATE_ALIGNED_TYPE(gate_int8_t); | ||
| 91 | CREATE_ALIGNED_TYPE(gate_int16_t); | ||
| 92 | CREATE_ALIGNED_TYPE(gate_int32_t); | ||
| 93 | CREATE_ALIGNED_TYPE(gate_int64_t); | ||
| 94 | CREATE_ALIGNED_TYPE(gate_uint8_t); | ||
| 95 | CREATE_ALIGNED_TYPE(gate_uint16_t); | ||
| 96 | CREATE_ALIGNED_TYPE(gate_uint32_t); | ||
| 97 | CREATE_ALIGNED_TYPE(gate_uint64_t); | ||
| 98 | CREATE_ALIGNED_TYPE(gate_real32_t); | ||
| 99 | CREATE_ALIGNED_TYPE(gate_real64_t); | ||
| 100 | CREATE_ALIGNED_TYPE(gate_uintptr_t); | ||
| 101 | CREATE_ALIGNED_TYPE(gate_dataptr_t); | ||
| 102 | CREATE_ALIGNED_TYPE(gate_funcptr_t); | ||
| 103 | CREATE_ALIGNED_TYPE(gate_cstr_t); | ||
| 104 | CREATE_ALIGNED_TYPE(gate_wstr_t); | ||
| 105 | CREATE_ALIGNED_TYPE(gate_guid_t); | ||
| 106 | CREATE_ALIGNED_TYPE(gate_date_t); | ||
| 107 | CREATE_ALIGNED_TYPE(gate_daytime_t); | ||
| 108 | CREATE_ALIGNED_TYPE(gate_datetime_t); | ||
| 109 | CREATE_ALIGNED_TYPE(gate_time_t); | ||
| 110 | CREATE_ALIGNED_TYPE(gate_string_t); | ||
| 111 | CREATE_ALIGNED_TYPE(gate_array_t); | ||
| 112 | CREATE_ALIGNED_TYPE(gate_blob_t); | ||
| 113 | CREATE_ALIGNED_TYPE(gate_arraylist_t); | ||
| 114 | CREATE_ALIGNED_TYPE(gate_struct_ptr_t); | ||
| 115 | CREATE_ALIGNED_TYPE(gate_object_ptr_t); | ||
| 116 | CREATE_ALIGNED_TYPE(gate_property_t); | ||
| 117 | |||
| 118 | CREATE_ALIGNED_TYPE(gate_c_maxalign_t); | ||
| 119 | |||
| 120 | #define GET_ALIGNMENT_OF_TYPE(type_name) (sizeof(struct alignment_helper_ ## type_name) - sizeof(type_name)) | ||
| 121 | |||
| 122 | #define GET_MAX_OF(a, b) (((a) > (b)) ? (a) : (b)) | ||
| 123 | |||
| 124 | #define GET_ALIGNED_SIZE_OF_TYPE(type_name) GET_MAX_OF(sizeof(type_name), GET_ALIGNMENT_OF_TYPE(type_name)) | ||
| 125 | |||
| 126 | |||
| 127 | ✗ | gate_size_t gate_type_aligned_length(gate_type_id_t value_type) | |
| 128 | { | ||
| 129 | ✗ | switch (value_type) | |
| 130 | { | ||
| 131 | ✗ | case GATE_TYPE_BOOL: return GET_ALIGNED_SIZE_OF_TYPE(gate_bool_t); | |
| 132 | ✗ | case GATE_TYPE_I8: return GET_ALIGNED_SIZE_OF_TYPE(gate_int8_t); | |
| 133 | ✗ | case GATE_TYPE_UI8: return GET_ALIGNED_SIZE_OF_TYPE(gate_uint8_t); | |
| 134 | ✗ | case GATE_TYPE_I16: return GET_ALIGNED_SIZE_OF_TYPE(gate_int16_t); | |
| 135 | ✗ | case GATE_TYPE_UI16: return GET_ALIGNED_SIZE_OF_TYPE(gate_uint16_t); | |
| 136 | ✗ | case GATE_TYPE_I32: return GET_ALIGNED_SIZE_OF_TYPE(gate_int32_t); | |
| 137 | ✗ | case GATE_TYPE_UI32: return GET_ALIGNED_SIZE_OF_TYPE(gate_uint32_t); | |
| 138 | ✗ | case GATE_TYPE_I64: return GET_ALIGNED_SIZE_OF_TYPE(gate_int64_t); | |
| 139 | ✗ | case GATE_TYPE_UI64: return GET_ALIGNED_SIZE_OF_TYPE(gate_uint64_t); | |
| 140 | ✗ | case GATE_TYPE_R32: return GET_ALIGNED_SIZE_OF_TYPE(gate_real32_t); | |
| 141 | ✗ | case GATE_TYPE_R64: return GET_ALIGNED_SIZE_OF_TYPE(gate_real64_t); | |
| 142 | ✗ | case GATE_TYPE_ADDRESS: return GET_ALIGNED_SIZE_OF_TYPE(gate_uintptr_t); | |
| 143 | |||
| 144 | ✗ | case GATE_TYPE_DATAPTR: return GET_ALIGNED_SIZE_OF_TYPE(gate_dataptr_t); | |
| 145 | ✗ | case GATE_TYPE_FUNCPTR: return GET_ALIGNED_SIZE_OF_TYPE(gate_funcptr_t); | |
| 146 | ✗ | case GATE_TYPE_CSTR: return GET_ALIGNED_SIZE_OF_TYPE(gate_cstr_t); | |
| 147 | ✗ | case GATE_TYPE_WSTR: return GET_ALIGNED_SIZE_OF_TYPE(gate_wstr_t); | |
| 148 | ✗ | case GATE_TYPE_GUID: return GET_ALIGNED_SIZE_OF_TYPE(gate_guid_t); | |
| 149 | ✗ | case GATE_TYPE_DATE: return GET_ALIGNED_SIZE_OF_TYPE(gate_date_t); | |
| 150 | ✗ | case GATE_TYPE_DAYTIME: return GET_ALIGNED_SIZE_OF_TYPE(gate_daytime_t); | |
| 151 | ✗ | case GATE_TYPE_DATETIME: return GET_ALIGNED_SIZE_OF_TYPE(gate_datetime_t); | |
| 152 | ✗ | case GATE_TYPE_TIME: return GET_ALIGNED_SIZE_OF_TYPE(gate_time_t); | |
| 153 | |||
| 154 | ✗ | case GATE_TYPE_STRING: return GET_ALIGNED_SIZE_OF_TYPE(gate_string_t); | |
| 155 | ✗ | case GATE_TYPE_ARRAY: return GET_ALIGNED_SIZE_OF_TYPE(gate_array_t); | |
| 156 | ✗ | case GATE_TYPE_BLOB: return GET_ALIGNED_SIZE_OF_TYPE(gate_blob_t); | |
| 157 | ✗ | case GATE_TYPE_ARRAYLIST: return GET_ALIGNED_SIZE_OF_TYPE(gate_arraylist_t); | |
| 158 | |||
| 159 | ✗ | case GATE_TYPE_STRUCT: return GET_ALIGNED_SIZE_OF_TYPE(gate_struct_ptr_t); | |
| 160 | ✗ | case GATE_TYPE_OBJECT: return GET_ALIGNED_SIZE_OF_TYPE(gate_object_ptr_t); | |
| 161 | ✗ | case GATE_TYPE_PROPERTY: return GET_ALIGNED_SIZE_OF_TYPE(gate_property_t); | |
| 162 | |||
| 163 | ✗ | default: | |
| 164 | { | ||
| 165 | ✗ | if ((value_type & GATE_TYPE_ARRAYLIST) == GATE_TYPE_ARRAYLIST) | |
| 166 | { | ||
| 167 | ✗ | return GET_ALIGNED_SIZE_OF_TYPE(gate_arraylist_t); | |
| 168 | } | ||
| 169 | ✗ | break; | |
| 170 | } | ||
| 171 | |||
| 172 | } | ||
| 173 | ✗ | return GET_ALIGNMENT_OF_TYPE(gate_c_maxalign_t); | |
| 174 | } | ||
| 175 | |||
| 176 | |||
| 177 | ✗ | gate_result_t gate_type_init(gate_type_id_t value_type, void* ptr) | |
| 178 | { | ||
| 179 | ✗ | gate_size_t type_size = gate_type_length(value_type); | |
| 180 | ✗ | if (type_size == 0) | |
| 181 | { | ||
| 182 | ✗ | return GATE_RESULT_NOTSUPPORTED; | |
| 183 | } | ||
| 184 | else | ||
| 185 | { | ||
| 186 | ✗ | gate_mem_clear(ptr, type_size); | |
| 187 | ✗ | return GATE_RESULT_OK; | |
| 188 | } | ||
| 189 | } | ||
| 190 | |||
| 191 | 976 | gate_result_t gate_type_copy(gate_type_id_t value_type, void* dst, void const* src) | |
| 192 | { | ||
| 193 | 976 | gate_size_t type_size = gate_type_length(value_type); | |
| 194 | |||
| 195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 976 times.
|
976 | if (src == NULL) |
| 196 | { | ||
| 197 | ✗ | return gate_type_init(value_type, dst); | |
| 198 | } | ||
| 199 | else | ||
| 200 | { | ||
| 201 |
2/7✓ Branch 0 taken 854 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 122 times.
|
976 | switch (value_type) |
| 202 | { | ||
| 203 | 854 | case GATE_TYPE_STRING: | |
| 204 | { | ||
| 205 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 854 times.
|
854 | if (NULL == gate_string_clone((gate_string_t*)dst, (gate_string_t const*)src)) |
| 206 | { | ||
| 207 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 208 | } | ||
| 209 | else | ||
| 210 | { | ||
| 211 | 854 | return GATE_RESULT_OK; | |
| 212 | } | ||
| 213 | } | ||
| 214 | ✗ | case GATE_TYPE_ARRAY: | |
| 215 | { | ||
| 216 | ✗ | if (NULL == gate_array_duplicate((gate_array_t*)dst, (gate_array_t const*)src)) | |
| 217 | { | ||
| 218 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 219 | } | ||
| 220 | else | ||
| 221 | { | ||
| 222 | ✗ | return GATE_RESULT_OK; | |
| 223 | } | ||
| 224 | } | ||
| 225 | ✗ | case GATE_TYPE_BLOB: | |
| 226 | { | ||
| 227 | ✗ | if (NULL == gate_blob_create_duplicate((gate_blob_t*)dst, (gate_blob_t const*)src)) | |
| 228 | { | ||
| 229 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 230 | } | ||
| 231 | else | ||
| 232 | { | ||
| 233 | ✗ | return GATE_RESULT_OK; | |
| 234 | } | ||
| 235 | } | ||
| 236 | ✗ | case GATE_TYPE_STRUCT: | |
| 237 | { | ||
| 238 | ✗ | return gate_struct_copy((gate_struct_t*)dst, (gate_struct_t const*)src); | |
| 239 | } | ||
| 240 | ✗ | case GATE_TYPE_OBJECT: | |
| 241 | { | ||
| 242 | ✗ | *((gate_object_ptr_t*)dst) = *(gate_object_ptr_t const*)src; | |
| 243 | ✗ | if ((*((gate_object_ptr_t*)dst)) != NULL) | |
| 244 | { | ||
| 245 | ✗ | gate_object_retain(*((gate_object_ptr_t*)dst)); | |
| 246 | } | ||
| 247 | ✗ | return GATE_RESULT_OK; | |
| 248 | } | ||
| 249 | ✗ | case GATE_TYPE_PROPERTY: | |
| 250 | { | ||
| 251 | ✗ | if (NULL == gate_property_copy((gate_property_t*)dst, (gate_property_t const*)src)) | |
| 252 | { | ||
| 253 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 254 | } | ||
| 255 | else | ||
| 256 | { | ||
| 257 | ✗ | return GATE_RESULT_OK; | |
| 258 | } | ||
| 259 | } | ||
| 260 | 122 | default: | |
| 261 | { | ||
| 262 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 122 times.
|
122 | if (GATE_FLAG_ENABLED(value_type, GATE_TYPE_ARRAYLIST)) |
| 263 | { | ||
| 264 | ✗ | *((gate_arraylist_t*)dst) = gate_arraylist_copy(*(gate_arraylist_t const*)src); | |
| 265 | ✗ | if (*((gate_arraylist_t*)dst) == NULL) | |
| 266 | { | ||
| 267 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 268 | } | ||
| 269 | else | ||
| 270 | { | ||
| 271 | ✗ | return GATE_RESULT_OK; | |
| 272 | } | ||
| 273 | } | ||
| 274 | |||
| 275 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 122 times.
|
122 | if (NULL == gate_mem_copy(dst, src, type_size)) |
| 276 | { | ||
| 277 | ✗ | return GATE_RESULT_OUTOFMEMORY; | |
| 278 | } | ||
| 279 | else | ||
| 280 | { | ||
| 281 | 122 | return GATE_RESULT_OK; | |
| 282 | } | ||
| 283 | } | ||
| 284 | } | ||
| 285 | } | ||
| 286 | } | ||
| 287 | |||
| 288 | |||
| 289 | ✗ | gate_result_t gate_type_release(gate_type_id_t value_type, void* ptr) | |
| 290 | { | ||
| 291 | ✗ | switch (value_type) | |
| 292 | { | ||
| 293 | ✗ | case GATE_TYPE_STRING: | |
| 294 | { | ||
| 295 | ✗ | gate_string_release((gate_string_t*)ptr); | |
| 296 | ✗ | break; | |
| 297 | } | ||
| 298 | ✗ | case GATE_TYPE_ARRAY: | |
| 299 | { | ||
| 300 | ✗ | gate_array_release((gate_array_t*)ptr); | |
| 301 | ✗ | break; | |
| 302 | } | ||
| 303 | ✗ | case GATE_TYPE_BLOB: | |
| 304 | { | ||
| 305 | ✗ | gate_blob_release((gate_blob_t*)ptr); | |
| 306 | ✗ | break; | |
| 307 | } | ||
| 308 | ✗ | case GATE_TYPE_STRUCT: | |
| 309 | { | ||
| 310 | ✗ | gate_struct_release((gate_struct_ptr_t)ptr); | |
| 311 | ✗ | return GATE_RESULT_OK; | |
| 312 | } | ||
| 313 | ✗ | case GATE_TYPE_OBJECT: | |
| 314 | { | ||
| 315 | ✗ | gate_object_release(ptr); | |
| 316 | ✗ | break; | |
| 317 | } | ||
| 318 | } | ||
| 319 | ✗ | return gate_type_init(value_type, ptr); | |
| 320 | } | ||
| 321 | |||
| 322 | static gate_type_sig_t const gate_typesig_void = GATE_TYPESIG_VOID; | ||
| 323 | static gate_type_sig_t const gate_typesig_bool = GATE_TYPESIG_BOOL; | ||
| 324 | static gate_type_sig_t const gate_typesig_i8 = GATE_TYPESIG_I8; | ||
| 325 | static gate_type_sig_t const gate_typesig_ui8 = GATE_TYPESIG_UI8; | ||
| 326 | static gate_type_sig_t const gate_typesig_i16 = GATE_TYPESIG_I16; | ||
| 327 | static gate_type_sig_t const gate_typesig_ui16 = GATE_TYPESIG_UI16; | ||
| 328 | static gate_type_sig_t const gate_typesig_i32 = GATE_TYPESIG_I32; | ||
| 329 | static gate_type_sig_t const gate_typesig_ui32 = GATE_TYPESIG_UI32; | ||
| 330 | static gate_type_sig_t const gate_typesig_i64 = GATE_TYPESIG_I64; | ||
| 331 | static gate_type_sig_t const gate_typesig_ui64 = GATE_TYPESIG_UI64; | ||
| 332 | static gate_type_sig_t const gate_typesig_r32 = GATE_TYPESIG_R32; | ||
| 333 | static gate_type_sig_t const gate_typesig_r64 = GATE_TYPESIG_R64; | ||
| 334 | static gate_type_sig_t const gate_typesig_addr = GATE_TYPESIG_ADDR; | ||
| 335 | |||
| 336 | static gate_type_sig_t const gate_typesig_dataptr = GATE_TYPESIG_DATAPTR; | ||
| 337 | static gate_type_sig_t const gate_typesig_funcptr = GATE_TYPESIG_FUNCPTR; | ||
| 338 | static gate_type_sig_t const gate_typesig_cstring = GATE_TYPESIG_CSTR; | ||
| 339 | static gate_type_sig_t const gate_typesig_wstring = GATE_TYPESIG_WSTR; | ||
| 340 | static gate_type_sig_t const gate_typesig_guid = GATE_TYPESIG_GUID; | ||
| 341 | static gate_type_sig_t const gate_typesig_date = GATE_TYPESIG_DATE; | ||
| 342 | static gate_type_sig_t const gate_typesig_daytime = GATE_TYPESIG_DAYTIME; | ||
| 343 | static gate_type_sig_t const gate_typesig_datetime = GATE_TYPESIG_DATETIME; | ||
| 344 | static gate_type_sig_t const gate_typesig_time = GATE_TYPESIG_TIME; | ||
| 345 | |||
| 346 | static gate_type_sig_t const gate_typesig_string = GATE_TYPESIG_STRING; | ||
| 347 | static gate_type_sig_t const gate_typesig_array = GATE_TYPESIG_ARRAY; | ||
| 348 | static gate_type_sig_t const gate_typesig_blob = GATE_TYPESIG_BLOB; | ||
| 349 | |||
| 350 | static gate_type_sig_t const gate_typesig_struct = GATE_TYPESIG_STRUCT; | ||
| 351 | static gate_type_sig_t const gate_typesig_object = GATE_TYPESIG_OBJECT; | ||
| 352 | static gate_type_sig_t const gate_typesig_property = GATE_TYPESIG_PROPERTY; | ||
| 353 | |||
| 354 | static gate_type_sig_t const gate_typesig_arraylist = GATE_TYPESIG_ARRAYLIST; | ||
| 355 | static gate_type_sig_t const gate_typesig_arraylist_bool = GATE_TYPESIG_ARRAYLIST_BOOL; | ||
| 356 | static gate_type_sig_t const gate_typesig_arraylist_i8 = GATE_TYPESIG_ARRAYLIST_I8; | ||
| 357 | static gate_type_sig_t const gate_typesig_arraylist_ui8 = GATE_TYPESIG_ARRAYLIST_UI8; | ||
| 358 | static gate_type_sig_t const gate_typesig_arraylist_i16 = GATE_TYPESIG_ARRAYLIST_I16; | ||
| 359 | static gate_type_sig_t const gate_typesig_arraylist_ui16 = GATE_TYPESIG_ARRAYLIST_UI16; | ||
| 360 | static gate_type_sig_t const gate_typesig_arraylist_i32 = GATE_TYPESIG_ARRAYLIST_I32; | ||
| 361 | static gate_type_sig_t const gate_typesig_arraylist_ui32 = GATE_TYPESIG_ARRAYLIST_UI32; | ||
| 362 | static gate_type_sig_t const gate_typesig_arraylist_i64 = GATE_TYPESIG_ARRAYLIST_I64; | ||
| 363 | static gate_type_sig_t const gate_typesig_arraylist_ui64 = GATE_TYPESIG_ARRAYLIST_UI64; | ||
| 364 | static gate_type_sig_t const gate_typesig_arraylist_r32 = GATE_TYPESIG_ARRAYLIST_R32; | ||
| 365 | static gate_type_sig_t const gate_typesig_arraylist_r64 = GATE_TYPESIG_ARRAYLIST_R64; | ||
| 366 | static gate_type_sig_t const gate_typesig_arraylist_address = GATE_TYPESIG_ARRAYLIST_ADDR; | ||
| 367 | |||
| 368 | static gate_type_sig_t const gate_typesig_arraylist_dataptr = GATE_TYPESIG_ARRAYLIST_DATAPTR; | ||
| 369 | static gate_type_sig_t const gate_typesig_arraylist_funcptr = GATE_TYPESIG_ARRAYLIST_FUNCTIONPTR; | ||
| 370 | static gate_type_sig_t const gate_typesig_arraylist_cstring = GATE_TYPESIG_ARRAYLIST_CSTR; | ||
| 371 | static gate_type_sig_t const gate_typesig_arraylist_wstring = GATE_TYPESIG_ARRAYLIST_WSTR; | ||
| 372 | static gate_type_sig_t const gate_typesig_arraylist_guid = GATE_TYPESIG_ARRAYLIST_GUID; | ||
| 373 | static gate_type_sig_t const gate_typesig_arraylist_date = GATE_TYPESIG_ARRAYLIST_DATE; | ||
| 374 | static gate_type_sig_t const gate_typesig_arraylist_daytime = GATE_TYPESIG_ARRAYLIST_DAYTIME; | ||
| 375 | static gate_type_sig_t const gate_typesig_arraylist_datetime = GATE_TYPESIG_ARRAYLIST_DATETIME; | ||
| 376 | static gate_type_sig_t const gate_typesig_arraylist_time = GATE_TYPESIG_ARRAYLIST_TIME; | ||
| 377 | |||
| 378 | static gate_type_sig_t const gate_typesig_arraylist_string = GATE_TYPESIG_ARRAYLIST_STRING; | ||
| 379 | static gate_type_sig_t const gate_typesig_arraylist_array = GATE_TYPESIG_ARRAYLIST_ARRAY; | ||
| 380 | static gate_type_sig_t const gate_typesig_arraylist_blob = GATE_TYPESIG_ARRAYLIST_BLOB; | ||
| 381 | |||
| 382 | static gate_type_sig_t const gate_typesig_arraylist_struct = GATE_TYPESIG_ARRAYLIST_STRUCT; | ||
| 383 | static gate_type_sig_t const gate_typesig_arraylist_object = GATE_TYPESIG_ARRAYLIST_OBJECT; | ||
| 384 | static gate_type_sig_t const gate_typesig_arraylist_property = GATE_TYPESIG_ARRAYLIST_PROPERTY; | ||
| 385 | |||
| 386 | 47 | gate_type_sig_t gate_type_signature(gate_type_id_t value_type_id) | |
| 387 | { | ||
| 388 |
23/57✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 3 times.
✓ Branch 6 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 8 taken 3 times.
✓ Branch 9 taken 3 times.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 3 times.
✓ Branch 12 taken 1 times.
✓ Branch 13 taken 1 times.
✓ Branch 14 taken 1 times.
✓ Branch 15 taken 1 times.
✓ Branch 16 taken 1 times.
✓ Branch 17 taken 1 times.
✓ Branch 18 taken 1 times.
✓ Branch 19 taken 1 times.
✓ Branch 20 taken 1 times.
✓ Branch 21 taken 1 times.
✓ Branch 22 taken 3 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 1 times.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✗ Branch 39 not taken.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✗ Branch 47 not taken.
✗ Branch 48 not taken.
✗ Branch 49 not taken.
✗ Branch 50 not taken.
✗ Branch 51 not taken.
✗ Branch 52 not taken.
✗ Branch 53 not taken.
✗ Branch 54 not taken.
✗ Branch 55 not taken.
✗ Branch 56 not taken.
|
47 | switch (value_type_id) |
| 389 | { | ||
| 390 | ✗ | case GATE_TYPE_VOID: return gate_typesig_void; | |
| 391 | 3 | case GATE_TYPE_BOOL: return gate_typesig_bool; | |
| 392 | 3 | case GATE_TYPE_I8: return gate_typesig_i8; | |
| 393 | 3 | case GATE_TYPE_UI8: return gate_typesig_ui8; | |
| 394 | 3 | case GATE_TYPE_I16: return gate_typesig_i16; | |
| 395 | 3 | case GATE_TYPE_UI16: return gate_typesig_ui16; | |
| 396 | 3 | case GATE_TYPE_I32: return gate_typesig_i32; | |
| 397 | 3 | case GATE_TYPE_UI32: return gate_typesig_ui32; | |
| 398 | 3 | case GATE_TYPE_I64: return gate_typesig_i64; | |
| 399 | 3 | case GATE_TYPE_UI64: return gate_typesig_ui64; | |
| 400 | 3 | case GATE_TYPE_R32: return gate_typesig_r32; | |
| 401 | 3 | case GATE_TYPE_R64: return gate_typesig_r64; | |
| 402 | 1 | case GATE_TYPE_ADDRESS: return gate_typesig_addr; | |
| 403 | |||
| 404 | 1 | case GATE_TYPE_DATAPTR: return gate_typesig_dataptr; | |
| 405 | 1 | case GATE_TYPE_FUNCPTR: return gate_typesig_funcptr; | |
| 406 | 1 | case GATE_TYPE_CSTR: return gate_typesig_cstring; | |
| 407 | 1 | case GATE_TYPE_WSTR: return gate_typesig_wstring; | |
| 408 | 1 | case GATE_TYPE_GUID: return gate_typesig_guid; | |
| 409 | 1 | case GATE_TYPE_DATE: return gate_typesig_date; | |
| 410 | 1 | case GATE_TYPE_DAYTIME: return gate_typesig_daytime; | |
| 411 | 1 | case GATE_TYPE_DATETIME: return gate_typesig_datetime; | |
| 412 | 1 | case GATE_TYPE_TIME: return gate_typesig_time; | |
| 413 | |||
| 414 | 3 | case GATE_TYPE_STRING: return gate_typesig_string; | |
| 415 | ✗ | case GATE_TYPE_ARRAY: return gate_typesig_array; | |
| 416 | 1 | case GATE_TYPE_BLOB: return gate_typesig_blob; | |
| 417 | |||
| 418 | ✗ | case GATE_TYPE_STRUCT: return gate_typesig_struct; | |
| 419 | ✗ | case GATE_TYPE_OBJECT: return gate_typesig_object; | |
| 420 | ✗ | case GATE_TYPE_PROPERTY: return gate_typesig_property; | |
| 421 | |||
| 422 | ✗ | case GATE_TYPE_ARRAYLIST: return gate_typesig_arraylist; | |
| 423 | ✗ | case GATE_TYPE_ARRAYLIST_BOOL: return gate_typesig_arraylist_bool; | |
| 424 | ✗ | case GATE_TYPE_ARRAYLIST_I8: return gate_typesig_arraylist_i8; | |
| 425 | ✗ | case GATE_TYPE_ARRAYLIST_UI8: return gate_typesig_arraylist_ui8; | |
| 426 | ✗ | case GATE_TYPE_ARRAYLIST_I16: return gate_typesig_arraylist_i16; | |
| 427 | ✗ | case GATE_TYPE_ARRAYLIST_UI16: return gate_typesig_arraylist_ui16; | |
| 428 | ✗ | case GATE_TYPE_ARRAYLIST_I32: return gate_typesig_arraylist_i32; | |
| 429 | ✗ | case GATE_TYPE_ARRAYLIST_UI32: return gate_typesig_arraylist_ui32; | |
| 430 | ✗ | case GATE_TYPE_ARRAYLIST_I64: return gate_typesig_arraylist_i64; | |
| 431 | ✗ | case GATE_TYPE_ARRAYLIST_UI64: return gate_typesig_arraylist_ui64; | |
| 432 | ✗ | case GATE_TYPE_ARRAYLIST_R32: return gate_typesig_arraylist_r32; | |
| 433 | ✗ | case GATE_TYPE_ARRAYLIST_R64: return gate_typesig_arraylist_r64; | |
| 434 | ✗ | case GATE_TYPE_ARRAYLIST_ADDRESS: return gate_typesig_arraylist_address; | |
| 435 | |||
| 436 | ✗ | case GATE_TYPE_ARRAYLIST_DATAPTR: return gate_typesig_arraylist_dataptr; | |
| 437 | ✗ | case GATE_TYPE_ARRAYLIST_FUNCPTR: return gate_typesig_arraylist_funcptr; | |
| 438 | ✗ | case GATE_TYPE_ARRAYLIST_CSTR: return gate_typesig_arraylist_cstring; | |
| 439 | ✗ | case GATE_TYPE_ARRAYLIST_WSTR: return gate_typesig_arraylist_wstring; | |
| 440 | ✗ | case GATE_TYPE_ARRAYLIST_GUID: return gate_typesig_arraylist_guid; | |
| 441 | ✗ | case GATE_TYPE_ARRAYLIST_DATE: return gate_typesig_arraylist_date; | |
| 442 | ✗ | case GATE_TYPE_ARRAYLIST_DAYTIME: return gate_typesig_arraylist_daytime; | |
| 443 | ✗ | case GATE_TYPE_ARRAYLIST_DATETIME: return gate_typesig_arraylist_datetime; | |
| 444 | ✗ | case GATE_TYPE_ARRAYLIST_TIME: return gate_typesig_arraylist_time; | |
| 445 | |||
| 446 | ✗ | case GATE_TYPE_ARRAYLIST_STRING: return gate_typesig_arraylist_string; | |
| 447 | ✗ | case GATE_TYPE_ARRAYLIST_ARRAY: return gate_typesig_arraylist_array; | |
| 448 | ✗ | case GATE_TYPE_ARRAYLIST_BLOB: return gate_typesig_arraylist_blob; | |
| 449 | |||
| 450 | ✗ | case GATE_TYPE_ARRAYLIST_STRUCT: return gate_typesig_arraylist_struct; | |
| 451 | ✗ | case GATE_TYPE_ARRAYLIST_OBJECT: return gate_typesig_arraylist_object; | |
| 452 | ✗ | case GATE_TYPE_ARRAYLIST_PROPERTY: return gate_typesig_arraylist_property; | |
| 453 | ✗ | default: break; | |
| 454 | } | ||
| 455 | ✗ | return GATE_TYPE_EMPTY; | |
| 456 | } | ||
| 457 | |||
| 458 | ✗ | gate_bool_t gate_type_signature_equals(gate_type_sig_t sig1, gate_type_sig_t sig2) | |
| 459 | { | ||
| 460 | ✗ | if (sig1 == sig2) | |
| 461 | { | ||
| 462 | ✗ | return true; | |
| 463 | } | ||
| 464 | ✗ | if ((sig1 == NULL) || (sig2 == NULL)) | |
| 465 | { | ||
| 466 | ✗ | return false; | |
| 467 | } | ||
| 468 | ✗ | return gate_str_comp(sig1, sig2) == 0; | |
| 469 | } | ||
| 470 |