END_TEST
START_TEST(Bool_with_trailing_garbage_is_rejected)
{
Streader* sr = init_with_cstr("falsez");
bool result = false;
fail_if(Streader_read_bool(sr, &result),
"Streader accepted falsez as a Boolean false value");
sr = init_with_cstr("truez");
fail_if(Streader_read_bool(sr, &result),
"Streader accepted truez as a Boolean true value");
}
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
START_TEST(Reading_bool_stores_correct_value)
{
Streader* sr = init_with_cstr("false x");
bool result = true;
fail_if(!Streader_read_bool(sr, &result), "Could not read a false value");
fail_if(result != false,
"Reading false stored %d", (int)result);
fail_if(!Streader_match_char(sr, 'x'),
"Streader did not consume the false value");
sr = init_with_cstr("true x");
result = false;
fail_if(!Streader_read_bool(sr, &result), "Could not read a true value");
fail_if(result != true,
"Reading true stored %d", (int)result);
fail_if(!Streader_match_char(sr, 'x'),
"Streader did not consume the true value");
}
bool Module_read_dc_blocker_enabled(Module* module, Streader* sr)
{
rassert(module != NULL);
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return false;
bool enabled = true;
if (Streader_has_data(sr))
{
if (!Streader_read_bool(sr, &enabled))
return false;
}
module->is_dc_blocker_enabled = enabled;
return true;
}
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;
}
