static struct buffer parse_string(struct buffer buff,
struct rmsgpack_dom_value *value, const char **error)
{
const char * str_start;
char terminator = '\0';
char c = '\0';
(void)c;
buff = get_char(buff, &terminator, error);
if (*error)
return buff;
if (terminator != '"' && terminator != '\'')
{
buff.offset--;
raise_expected_string(buff.offset, error);
}
str_start = buff.data + buff.offset;
buff = get_char(buff, &c, error);
while (!*error)
{
if (c == terminator)
break;
buff = get_char(buff, &c, error);
}
if (!*error)
{
value->type = RDT_STRING;
value->string.len = (buff.data + buff.offset) - str_start - 1;
value->string.buff = (char*)calloc(value->string.len + 1, sizeof(char));
if (!value->string.buff)
raise_enomem(error);
else
memcpy(
value->string.buff,
str_start,
value->string.len
);
}
return buff;
}
static struct buffer parse_table(struct buffer buff,
struct invocation *invocation, const char **error)
{
unsigned i;
size_t ident_len;
struct argument args[QUERY_MAX_ARGS];
const char *ident_name = NULL;
unsigned argi = 0;
buff = chomp(buff);
buff = expect_char(buff, '{', error);
if (*error)
goto clean;
buff = chomp(buff);
while (!peek(buff, "}"))
{
if (argi >= QUERY_MAX_ARGS)
{
raise_too_many_arguments(error);
goto clean;
}
if (isalpha((int)buff.data[buff.offset]))
{
buff = get_ident(buff, &ident_name, &ident_len, error);
if (!*error)
{
args[argi].a.value.type = RDT_STRING;
args[argi].a.value.val.string.len = ident_len;
args[argi].a.value.val.string.buff = (char*)calloc(
ident_len + 1,
sizeof(char)
);
if (!args[argi].a.value.val.string.buff)
goto clean;
strncpy(
args[argi].a.value.val.string.buff,
ident_name,
ident_len
);
}
}
else
buff = parse_string(buff, &args[argi].a.value, error);
if (*error)
goto clean;
args[argi].type = AT_VALUE;
buff = chomp(buff);
argi++;
buff = expect_char(buff, ':', error);
if (*error)
goto clean;
buff = chomp(buff);
if (argi >= QUERY_MAX_ARGS)
{
raise_too_many_arguments(error);
goto clean;
}
buff = parse_argument(buff, &args[argi], error);
if (*error)
goto clean;
argi++;
buff = chomp(buff);
buff = expect_char(buff, ',', error);
if (*error)
{
*error = NULL;
break;
}
buff = chomp(buff);
}
buff = expect_char(buff, '}', error);
if (*error)
goto clean;
invocation->func = all_map;
invocation->argc = argi;
invocation->argv = (struct argument*)
malloc(sizeof(struct argument) * argi);
if (!invocation->argv)
{
raise_enomem(error);
goto clean;
}
memcpy(invocation->argv, args,
sizeof(struct argument) * argi);
goto success;
clean:
for (i = 0; i < argi; i++)
argument_free(&args[i]);
success:
return buff;
}
static struct buffer parse_method_call(struct buffer buff,
struct invocation *invocation, const char **error)
{
size_t func_name_len;
unsigned i;
struct argument args[QUERY_MAX_ARGS];
unsigned argi = 0;
const char *func_name = NULL;
struct registered_func *rf = registered_functions;
invocation->func = NULL;
buff = get_ident(buff, &func_name, &func_name_len, error);
if (*error)
goto clean;
buff = chomp(buff);
buff = expect_char(buff, '(', error);
if (*error)
goto clean;
while (rf->name)
{
if (strncmp(rf->name, func_name, func_name_len) == 0)
{
invocation->func = rf->func;
break;
}
rf++;
}
if (!invocation->func)
{
raise_unknown_function(buff.offset, func_name,
func_name_len, error);
goto clean;
}
buff = chomp(buff);
while (!peek(buff, ")"))
{
if (argi >= QUERY_MAX_ARGS)
{
raise_too_many_arguments(error);
goto clean;
}
buff = parse_argument(buff, &args[argi], error);
if (*error)
goto clean;
argi++;
buff = chomp(buff);
buff = expect_char(buff, ',', error);
if (*error)
{
*error = NULL;
break;
}
buff = chomp(buff);
}
buff = expect_char(buff, ')', error);
if (*error)
goto clean;
invocation->argc = argi;
invocation->argv = (struct argument*)
malloc(sizeof(struct argument) * argi);
if (!invocation->argv)
{
raise_enomem(error);
goto clean;
}
memcpy(invocation->argv, args,
sizeof(struct argument) * argi);
goto success;
clean:
for (i = 0; i < argi; i++)
argument_free(&args[i]);
success:
return buff;
}
static struct buffer parse_string(struct buffer buff,
struct rmsgpack_dom_value *value, const char **error)
{
const char * str_start = NULL;
char terminator = '\0';
char c = '\0';
int is_binstr = 0;
(void)c;
buff = get_char(buff, &terminator, error);
if (*error)
return buff;
if (terminator == 'b')
{
is_binstr = 1;
buff = get_char(buff, &terminator, error);
}
if (terminator != '"' && terminator != '\'')
{
buff.offset--;
raise_expected_string(buff.offset, error);
}
str_start = buff.data + buff.offset;
buff = get_char(buff, &c, error);
while (!*error)
{
if (c == terminator)
break;
buff = get_char(buff, &c, error);
}
if (!*error)
{
size_t count;
value->type = is_binstr ? RDT_BINARY : RDT_STRING;
value->val.string.len = (buff.data + buff.offset) - str_start - 1;
count = is_binstr ? (value->val.string.len + 1) / 2 : (value->val.string.len + 1);
value->val.string.buff = (char*)calloc(count, sizeof(char));
if (!value->val.string.buff)
raise_enomem(error);
else if (is_binstr)
{
unsigned i;
const char *tok = str_start;
unsigned j = 0;
for (i = 0; i < value->val.string.len; i += 2)
{
uint8_t hi, lo;
char hic = tok[i];
char loc = tok[i + 1];
if (hic <= '9')
hi = hic - '0';
else
hi = (hic - 'A') + 10;
if (loc <= '9')
lo = loc - '0';
else
lo = (loc - 'A') + 10;
value->val.string.buff[j++] = hi * 16 + lo;
}
value->val.string.len = j;
}
else
memcpy(value->val.string.buff, str_start, value->val.string.len);
}
return buff;
}
