bool Streader_read_finite_rt(Streader* sr, Value* dest) { rassert(sr != NULL); if (Streader_is_error_set(sr)) return false; Streader_skip_whitespace(sr); const int64_t start_pos = sr->pos; Value* value = VALUE_AUTO; if (Streader_read_bool(sr, &value->value.bool_type)) value->type = VALUE_TYPE_BOOL; else if ((recover(sr, start_pos), Streader_read_int(sr, &value->value.int_type)) && (CUR_CH != '.') && (CUR_CH != 'e') && (CUR_CH != 'E')) value->type = VALUE_TYPE_INT; else if (recover(sr, start_pos), (Streader_read_float(sr, &value->value.float_type) && isfinite(value->value.float_type))) value->type = VALUE_TYPE_FLOAT; else if (recover(sr, start_pos), Streader_read_tstamp(sr, &value->value.Tstamp_type)) value->type = VALUE_TYPE_TSTAMP; if (value->type == VALUE_TYPE_NONE) return false; if (dest != NULL) Value_copy(dest, value); return true; }
END_TEST static bool check_adjusted_tstamp(Streader* sr, int32_t index, void* userdata) { fail_if(sr == NULL, "Callback did not get a Streader"); fail_if(Streader_is_error_set(sr), "Callback was called with Streader error set: %s", Streader_get_error_desc(sr)); fail_if(index < 0, "Callback got a negative item index (%" PRId32 ")", index); fail_if(index >= item_count, "Callback got too large an index (%" PRId32 ")", index); fail_if(userdata != NULL, "Callback got unexpected userdata"); Tstamp* ts = TSTAMP_AUTO; fail_if(!Streader_read_tstamp(sr, ts), "Could not read timestamp from list index %" PRId32 ": %s", index, Streader_get_error_desc(sr)); fail_if((Tstamp_get_beats(ts) != index + 10) || (Tstamp_get_rem(ts) != index + 100), "Unexpected list item " PRIts " (expected (%d, %d))", PRIVALts(*ts), (int)index + 10, (int)index + 100); return true; }
END_TEST START_TEST(Read_valid_tstamp) { static const struct { const char* data; const Tstamp expected; } tstamps[] = { { "[0, 0]", { 0, 0 } }, { "[2,5]", { 2, 5 } }, { " [2,5]", { 2, 5 } }, { "[ 2,5]", { 2, 5 } }, { "[2 ,5]", { 2, 5 } }, { "[2, 5]", { 2, 5 } }, { "[2,5 ]", { 2, 5 } }, { "[-1, 3]", { -1, 3 } }, { "[0, 882161279]", { 0, KQT_TSTAMP_BEAT - 1 } }, }; for (size_t i = 0; i < arr_size(tstamps); ++i) { char data[128] = ""; sprintf(data, "%s x", tstamps[i].data); Streader* sr = init_with_cstr(data); Tstamp* result = Tstamp_set(TSTAMP_AUTO, 99, 99); fail_if(!Streader_read_tstamp(sr, result), "Could not read timestamp " PRIts " from `%s`: %s", PRIVALts(tstamps[i].expected), data, Streader_get_error_desc(sr)); fail_if(Tstamp_cmp(result, &tstamps[i].expected) != 0, "Streader stored " PRIts " instead of " PRIts " when reading `%s`", PRIVALts(*result), PRIVALts(tstamps[i].expected), data); fail_if(!Streader_match_char(sr, 'x'), "Streader did not consume timestamp from `%s` correctly", data); } }
END_TEST START_TEST(Reading_invalid_tstamp_fails) { const char* data[] = { "0, 0]", "[0 0]", "[0, 0", "[0, -1]", "[0, 882161280]", }; for (size_t i = 0; i < arr_size(data); ++i) { Streader* sr = init_with_cstr(data[i]); Tstamp* result = TSTAMP_AUTO; fail_if(Streader_read_tstamp(sr, result), "Streader accepted `%s` as a valid timestamp", data[i]); } }
bool Streader_readf(Streader* sr, const char* format, ...) { rassert(sr != NULL); rassert(format != NULL); va_list args; va_start(args, format); while (!Streader_is_error_set(sr) && *format != '\0') { if (*format == '%') { // Conversion characters ++format; switch (*format) { case 'n': { Streader_read_null(sr); } break; case 'b': { bool* dest = va_arg(args, bool*); Streader_read_bool(sr, dest); } break; case 'i': { int64_t* dest = va_arg(args, int64_t*); Streader_read_int(sr, dest); } break; case 'f': { double* dest = va_arg(args, double*); Streader_read_float(sr, dest); } break; case 's': { Streader_readf_str_info info = va_arg(args, Streader_readf_str_info); rassert(info.guard == Streader_readf_str_guard); const int64_t max_bytes = info.max_bytes; char* dest = info.dest; Streader_read_string(sr, max_bytes, dest); } break; case 't': { Tstamp* dest = va_arg(args, Tstamp*); Streader_read_tstamp(sr, dest); } break; case 'p': { Pat_inst_ref* dest = va_arg(args, Pat_inst_ref*); Streader_read_piref(sr, dest); } break; case 'l': { List_item_reader* ir = va_arg(args, List_item_reader*); void* userdata = va_arg(args, void*); Streader_read_list(sr, ir, userdata); } break; case 'd': { Dict_item_reader* ir = va_arg(args, Dict_item_reader*); void* userdata = va_arg(args, void*); Streader_read_dict(sr, ir, userdata); } break; case '%': { Streader_match_char(sr, '%'); } break; default: rassert(false); } } else { // Characters to be matched if (!isspace(*format))
Env_var* new_Env_var_from_string(Streader* sr) { rassert(sr != NULL); if (Streader_is_error_set(sr)) return NULL; char type_name[16] = ""; char name[KQT_VAR_NAME_MAX] = ""; if (!Streader_readf( sr, "[%s,%s,", READF_STR(16, type_name), READF_STR(KQT_VAR_NAME_MAX, name))) return NULL; if (!is_valid_var_name(name)) { Streader_set_error( sr, "Illegal variable name %s" " (Variable names may only contain" " lower-case letters and underscores" " (and digits as other than first characters))", name); return NULL; } Value* value = VALUE_AUTO; if (string_eq(type_name, "bool")) { value->type = VALUE_TYPE_BOOL; Streader_read_bool(sr, &value->value.bool_type); } else if (string_eq(type_name, "int")) { value->type = VALUE_TYPE_INT; Streader_read_int(sr, &value->value.int_type); } else if (string_eq(type_name, "float")) { value->type = VALUE_TYPE_FLOAT; Streader_read_float(sr, &value->value.float_type); } else if (string_eq(type_name, "timestamp")) { value->type = VALUE_TYPE_TSTAMP; Streader_read_tstamp(sr, &value->value.Tstamp_type); } else { Streader_set_error( sr, "Invalid type of environment variable %s: %s", name, type_name); return NULL; } if (!Streader_match_char(sr, ']')) return NULL; Env_var* var = new_Env_var(value->type, name); if (var == NULL) { Streader_set_memory_error( sr, "Could not allocate memory for environment variable"); return NULL; } Env_var_set_value(var, value); return var; }