static tsf_bool_t write_mainpass()

in benchmarks/JetStream2/wasm/TSF/tsf_reflect.c [492:654]

• 161 lines of code
• 44 McCabe index (conditional complexity)

static tsf_bool_t write_mainpass(tsf_reflect_t *data,
                                 tsf_type_out_map_t *type_map,
                                 uint8_t **buf) {
    switch (data->type->kind_code) {
    case TSF_TK_INT8:
    case TSF_TK_UINT8:
    case TSF_TK_BIT:
        copy_htonc_incdst(*buf, &data->u.p_uint8_t);
        break;
    case TSF_TK_INT16:
    case TSF_TK_UINT16:
        copy_htons_incdst(*buf, (uint8_t*)&data->u.p_uint16_t);
        break;
    case TSF_TK_INT32:
    case TSF_TK_UINT32:
        copy_htonl_incdst(*buf, (uint8_t*)&data->u.p_uint32_t);
        break;
    case TSF_TK_INT64:
    case TSF_TK_UINT64:
        copy_htonll_incdst(*buf, (uint8_t*)&data->u.p_uint64_t);
        break;
    case TSF_TK_INTEGER:
        *buf += write_tsf_integer(*buf, data->u.p_integer);
        break;
    case TSF_TK_LONG:
        *buf += write_tsf_long(*buf, data->u.p_long);
        break;
    case TSF_TK_FLOAT:
        copy_htonf_incdst(*buf, (uint8_t*)&data->u.p_float);
        break;
    case TSF_TK_DOUBLE:
        copy_htond_incdst(*buf, (uint8_t*)&data->u.p_double);
        break;
    case TSF_TK_ARRAY: {
        uint8_t tmp;
        if (data->u.c.size >= 255) {
            tmp = (uint8_t)255;
            copy_htonc_incdst(*buf, &tmp);
            copy_htonl_incdst(*buf, (uint8_t*)&data->u.c.size);
        } else {
            tmp = (uint8_t)data->u.c.size;
            copy_htonc_incdst(*buf, &tmp);
        }
        if (tsf_type_get_kind_code(
                tsf_array_type_get_element_type(data->type))
            == TSF_TK_BIT) {
            uint32_t i, j;
            uint8_t value;
            
            for (i = 0; i + 7 < data->u.c.size; i += 8) {
                value = 0;
                for (j = 0; j < 8; ++j) {
                    if (data->u.c.array[i + j]->u.bit) {
                        value |= (1 << j);
                    }
                }
                copy_htonc_incdst(*buf, &value);
            }
            if (data->u.c.size > i) {
                value = 0;
                for (j = 0; j < data->u.c.size - i; ++j) {
                    if (data->u.c.array[i + j]->u.bit) {
                        value |= (1 << j);
                    }
                }
                copy_htonc_incdst(*buf, &value);
            }
        } else {
            uint32_t i;
            for (i = 0; i < data->u.c.size; ++i) {
                if (!write_mainpass(data->u.c.array[i],
                                    type_map,
                                    buf)) {
                    return tsf_false;
                }
            }
        }
        break;
    }
    case TSF_TK_STRUCT: {
        uint32_t i;
        uint8_t value, bit;
        for (i = 0; i < data->u.c.size; ++i) {
            if (data->u.c.array[i]->type->kind_code == TSF_TK_BIT) {
                continue;
            }
            if (!write_mainpass(data->u.c.array[i],
                                type_map,
                                buf)) {
                return tsf_false;
            }
        }
        value = 0;
        bit = 0;
        for (i = 0; i < data->u.c.size; ++i) {
            if (data->u.c.array[i]->type->kind_code != TSF_TK_BIT) {
                continue;
            }
            if (data->u.c.array[i]->u.bit) {
                value |= (1 << bit);
            }
            ++bit;
            if (bit == 8) {
                copy_htonc_incdst(*buf, &value);
                value = 0;
                bit = 0;
            }
        }
        if (bit) {
            copy_htonc_incdst(*buf, &value);
        }
        break;
    }
    case TSF_TK_CHOICE:
        if (tsf_choice_type_get_num_elements(data->type) >= 256) {
            if (data->type->u.h.choice_as_full_word) {
                copy_htonl_incdst(*buf, (uint8_t*)&data->u.h.choice);
            } else {
                *buf += write_tsf_unsigned(*buf, data->u.h.choice + 1);
            }
        } else {
            uint8_t choice_8bit;
            if (data->u.h.choice == UINT32_MAX) {
                choice_8bit = 255;
            } else {
                choice_8bit = data->u.h.choice;
            }
            copy_htonc_incdst(*buf, &choice_8bit);
        }
        if (data->u.h.data != NULL) {
            if (!write_mainpass(data->u.h.data,
                                type_map,
                                buf)) {
                return tsf_false;
            }
        }
        break;
    case TSF_TK_VOID:
        break;
    case TSF_TK_STRING:
#ifdef HAVE_STPCPY
        *buf = (uint8_t*)stpcpy((char*)*buf, data->u.str) + 1;
#else
        strcpy((char*)*buf, data->u.str);
        *buf += strlen(data->u.str) + 1;
#endif
        break;
    case TSF_TK_ANY:
        if (!tsf_buffer_write_to_buf(data->u.any,
                                     type_map,
                                     buf)) {
            return tsf_false;
        }
        break;
    default:
        tsf_set_error(TSF_E_BAD_TYPE_KIND,
                      fui8 " is not a recognized kind code.",
                      data->type->kind_code);
        return tsf_false;
    }
    
    return tsf_true;
}