741 lines
14 KiB
C
741 lines
14 KiB
C
|
#include "snbt.h"
|
||
|
|
#include "../lib.h"
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
typedef enum {
|
||
|
|
TOK_RBRACE,
|
||
|
|
TOK_LBRACE,
|
||
|
|
TOK_RBRACK,
|
||
|
|
TOK_LBRACK,
|
||
|
|
TOK_COMMA,
|
||
|
|
TOK_COLON,
|
||
|
|
TOK_SEMI_COLON,
|
||
|
|
TOK_STRING,
|
||
|
|
TOK_IDENT,
|
||
|
|
} tokentype_t;
|
||
|
|
|
||
|
|
typedef union {
|
||
|
|
struct {
|
||
|
|
char *data;
|
||
|
|
uint16_t len;
|
||
|
|
} text;
|
||
|
|
double d;
|
||
|
|
int64_t l;
|
||
|
|
} tokendata_t;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
tokentype_t type;
|
||
|
|
tokendata_t data;
|
||
|
|
} token_t;
|
||
|
|
|
||
|
|
static char ret = '\0';
|
||
|
|
|
||
|
|
static void snbt_free_token(token_t *token) {
|
||
|
|
if (token->type == TOK_IDENT || token->type == TOK_STRING) {
|
||
|
|
free(token->data.text.data);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_parse_string(token_t *token, const stream_t *stream, char delimiter) {
|
||
|
|
int len = 0;
|
||
|
|
int capacity = 8;
|
||
|
|
char *buf = xalloc(capacity * sizeof(char));
|
||
|
|
|
||
|
|
while (1) {
|
||
|
|
char c;
|
||
|
|
if (stream_read(stream, &c, 1) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (c == delimiter)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if (c == '\\') {
|
||
|
|
if (stream_read(stream, &c, 1) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (c != '\\' && c != delimiter) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
buf = xrealloc(buf, capacity);
|
||
|
|
}
|
||
|
|
|
||
|
|
buf[len++] = c;
|
||
|
|
}
|
||
|
|
|
||
|
|
token->data.text.data = xalloc(len * sizeof(char));
|
||
|
|
token->data.text.len = len;
|
||
|
|
memcpy(token->data.text.data, buf, len * sizeof(char));
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool snbt_allowed_ident(char c) {
|
||
|
|
if (c >= '0' && c <= '9')
|
||
|
|
return true;
|
||
|
|
if (c >= 'a' && c <= 'z')
|
||
|
|
return true;
|
||
|
|
if (c >= 'A' && c <= 'Z')
|
||
|
|
return true;
|
||
|
|
if (c == '_' || c == '-' || c == '.' || c == '+')
|
||
|
|
return true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_parse_ident(token_t *token, const stream_t *stream, char first) {
|
||
|
|
int len = 0;
|
||
|
|
int capacity = 8;
|
||
|
|
char *buf = xalloc(capacity * sizeof(char));
|
||
|
|
|
||
|
|
buf[len++] = first;
|
||
|
|
|
||
|
|
while (1) {
|
||
|
|
char c;
|
||
|
|
if (stream_read(stream, &c, 1) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (snbt_allowed_ident(c) == false) {
|
||
|
|
if (len == 0) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
} else {
|
||
|
|
ret = c;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
buf = xrealloc(buf, capacity);
|
||
|
|
}
|
||
|
|
|
||
|
|
buf[len++] = c;
|
||
|
|
}
|
||
|
|
|
||
|
|
token->data.text.data = xalloc(len * sizeof(char));
|
||
|
|
token->data.text.len = len;
|
||
|
|
memcpy(token->data.text.data, buf, len * sizeof(char));
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_next_token(token_t *token, const stream_t *stream) {
|
||
|
|
|
||
|
|
memset(token, 0, sizeof(token_t));
|
||
|
|
|
||
|
|
char c;
|
||
|
|
bool ok = true;
|
||
|
|
|
||
|
|
retry:
|
||
|
|
|
||
|
|
c = ret;
|
||
|
|
ret = '\0';
|
||
|
|
|
||
|
|
if (c == '\0' && stream_read(stream, &c, 1) == false)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
switch (c) {
|
||
|
|
case ' ':
|
||
|
|
case '\t':
|
||
|
|
case '\n':
|
||
|
|
case '\r':
|
||
|
|
goto retry;
|
||
|
|
case '{':
|
||
|
|
token->type = TOK_LBRACE;
|
||
|
|
break;
|
||
|
|
case '}':
|
||
|
|
token->type = TOK_RBRACE;
|
||
|
|
break;
|
||
|
|
case '[':
|
||
|
|
token->type = TOK_LBRACK;
|
||
|
|
break;
|
||
|
|
case ']':
|
||
|
|
token->type = TOK_RBRACK;
|
||
|
|
break;
|
||
|
|
case ':':
|
||
|
|
token->type = TOK_COLON;
|
||
|
|
break;
|
||
|
|
case ';':
|
||
|
|
token->type = TOK_SEMI_COLON;
|
||
|
|
break;
|
||
|
|
case ',':
|
||
|
|
token->type = TOK_COMMA;
|
||
|
|
break;
|
||
|
|
case '"':
|
||
|
|
case '\'':
|
||
|
|
token->type = TOK_STRING;
|
||
|
|
ok = snbt_parse_string(token, stream, c);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
token->type = TOK_IDENT;
|
||
|
|
ok = snbt_parse_ident(token, stream, c);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ok;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_value(tag_t *tag, const stream_t *stream, token_t *first);
|
||
|
|
static bool snbt_convert_ident(tag_t *tag, token_t token);
|
||
|
|
|
||
|
|
static bool snbt_read_byte_array(tag_t *tag, const stream_t *stream) {
|
||
|
|
int capacity = 8;
|
||
|
|
int len = 0;
|
||
|
|
int8_t *buf = xalloc(capacity * sizeof(int8_t));
|
||
|
|
|
||
|
|
while(1) {
|
||
|
|
tag_t value;
|
||
|
|
if (snbt_read_value(&value, stream, NULL) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (value.type != TAG_BYTE) {
|
||
|
|
tag_free(&value);
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
buf = xrealloc(buf, capacity * sizeof(int8_t));
|
||
|
|
}
|
||
|
|
buf[len++] = value.data.b;
|
||
|
|
token_t token;
|
||
|
|
if (snbt_next_token(&token, stream) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (token.type == TOK_COMMA)
|
||
|
|
continue;
|
||
|
|
if (token.type == TOK_RBRACK)
|
||
|
|
break;
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
tag->type = TAG_BYTE_ARRAY;
|
||
|
|
tag->data.b_arr.data = xalloc(len * sizeof(int8_t));
|
||
|
|
tag->data.b_arr.size = len;
|
||
|
|
memcpy(tag->data.b_arr.data, buf, len * sizeof(int8_t));
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_int_array(tag_t *tag, const stream_t *stream) {
|
||
|
|
int capacity = 8;
|
||
|
|
int len = 0;
|
||
|
|
int32_t *buf = xalloc(capacity * sizeof(int32_t));
|
||
|
|
|
||
|
|
while(1) {
|
||
|
|
tag_t value;
|
||
|
|
if (snbt_read_value(&value, stream, NULL) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (value.type != TAG_INT) {
|
||
|
|
tag_free(&value);
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
buf = xrealloc(buf, capacity * sizeof(int32_t));
|
||
|
|
}
|
||
|
|
buf[len++] = value.data.i;
|
||
|
|
token_t token;
|
||
|
|
if (snbt_next_token(&token, stream) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (token.type == TOK_COMMA)
|
||
|
|
continue;
|
||
|
|
if (token.type == TOK_RBRACK)
|
||
|
|
break;
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
tag->type = TAG_INT_ARRAY;
|
||
|
|
tag->data.i_arr.data = xalloc(len * sizeof(int32_t));
|
||
|
|
tag->data.i_arr.size = len;
|
||
|
|
memcpy(tag->data.i_arr.data, buf, len * sizeof(int32_t));
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_long_array(tag_t *tag, const stream_t *stream) {
|
||
|
|
int capacity = 8;
|
||
|
|
int len = 0;
|
||
|
|
int64_t *buf = xalloc(capacity * sizeof(int64_t));
|
||
|
|
|
||
|
|
while(1) {
|
||
|
|
tag_t value;
|
||
|
|
if (snbt_read_value(&value, stream, NULL) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (value.type != TAG_LONG) {
|
||
|
|
tag_free(&value);
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
buf = xrealloc(buf, capacity * sizeof(int64_t));
|
||
|
|
}
|
||
|
|
buf[len++] = value.data.l;
|
||
|
|
token_t token;
|
||
|
|
if (snbt_next_token(&token, stream) == false) {
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (token.type == TOK_COMMA)
|
||
|
|
continue;
|
||
|
|
if (token.type == TOK_RBRACK)
|
||
|
|
break;
|
||
|
|
free(buf);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
tag->type = TAG_LONG_ARRAY;
|
||
|
|
tag->data.l_arr.data = xalloc(len * sizeof(int64_t));
|
||
|
|
tag->data.l_arr.size = len;
|
||
|
|
memcpy(tag->data.l_arr.data, buf, len * sizeof(int64_t));
|
||
|
|
free(buf);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_array(tag_t *tag, tagtype_t type, const stream_t *stream) {
|
||
|
|
switch(type) {
|
||
|
|
case TAG_BYTE:
|
||
|
|
return snbt_read_byte_array(tag, stream);
|
||
|
|
case TAG_INT:
|
||
|
|
return snbt_read_int_array(tag, stream);
|
||
|
|
case TAG_LONG:
|
||
|
|
return snbt_read_long_array(tag, stream);
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_list(tag_t *tag, tag_t *first, token_t *tok_sav, const stream_t *stream) {
|
||
|
|
int capacity = 8;
|
||
|
|
int len = 0;
|
||
|
|
tag_t *tags = xalloc(sizeof(tag_t) * capacity);
|
||
|
|
tagtype_t type = TAG_END;
|
||
|
|
|
||
|
|
if (first != NULL) {
|
||
|
|
first->name_len = 0;
|
||
|
|
first->name = "";
|
||
|
|
tags[len++] = *first;
|
||
|
|
type = first->type;
|
||
|
|
goto endcheck;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tok_sav == NULL) {
|
||
|
|
if (snbt_next_token(tok_sav, stream) == false) {
|
||
|
|
free(tags);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (tok_sav->type == TOK_RBRACK) {
|
||
|
|
goto end;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
while(1) {
|
||
|
|
|
||
|
|
tag_t value;
|
||
|
|
token_t check;
|
||
|
|
|
||
|
|
if (snbt_read_value(&value, stream, tok_sav) == false) {
|
||
|
|
snbt_free_token(tok_sav);
|
||
|
|
free(tags);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
tok_sav = NULL;
|
||
|
|
|
||
|
|
if (type != TAG_END && value.type != type) {
|
||
|
|
free(tags);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (len == capacity) {
|
||
|
|
capacity *= 2;
|
||
|
|
tags = xrealloc(tags, capacity * sizeof(tag_t));
|
||
|
|
}
|
||
|
|
|
||
|
|
tags[len++] = value;
|
||
|
|
|
||
|
|
endcheck:
|
||
|
|
|
||
|
|
if (snbt_next_token(&check, stream) == false) {
|
||
|
|
free(tags);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (check.type == TOK_COMMA)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (check.type == TOK_RBRACK)
|
||
|
|
break;
|
||
|
|
|
||
|
|
free(tags);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
end:
|
||
|
|
tag->type = TAG_LIST;
|
||
|
|
tag->data.list.type = type;
|
||
|
|
tag->data.list.size = len;
|
||
|
|
tag->data.list.tags = xalloc(len * sizeof(tag_t));
|
||
|
|
memcpy(tag->data.list.tags, tags, len *sizeof(tag_t));
|
||
|
|
free(tags);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_collection(tag_t *tag, const stream_t *stream) {
|
||
|
|
|
||
|
|
token_t first;
|
||
|
|
|
||
|
|
if (snbt_next_token(&first, stream) == false)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (first.type == TOK_RBRACK) {
|
||
|
|
tag->type = TAG_LIST;
|
||
|
|
tag->data.list.type = TAG_END;
|
||
|
|
tag->data.list.size = 0;
|
||
|
|
tag->data.list.tags = NULL;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (first.type == TOK_IDENT && first.data.text.len == 1) {
|
||
|
|
tagtype_t type;
|
||
|
|
char c = first.data.text.data[0];
|
||
|
|
switch (c) {
|
||
|
|
case 'B':
|
||
|
|
type = TAG_BYTE;
|
||
|
|
break;
|
||
|
|
case 'I':
|
||
|
|
type = TAG_INT;
|
||
|
|
break;
|
||
|
|
case 'L':
|
||
|
|
type = TAG_LONG;
|
||
|
|
break;
|
||
|
|
default: {
|
||
|
|
tag_t new;
|
||
|
|
if (snbt_convert_ident(&new, first) == false) {
|
||
|
|
snbt_free_token(&first);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return snbt_read_list(tag, &new, NULL, stream);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
token_t second;
|
||
|
|
if (snbt_next_token(&second, stream) == false) {
|
||
|
|
snbt_free_token(&first);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (second.type == TOK_COMMA) {
|
||
|
|
tag_t new;
|
||
|
|
new.type = TAG_STRING;
|
||
|
|
new.data.string.data = first.data.text.data;
|
||
|
|
new.data.string.size = first.data.text.len;
|
||
|
|
return snbt_read_list(tag, &new, NULL, stream);
|
||
|
|
}
|
||
|
|
|
||
|
|
snbt_free_token(&first);
|
||
|
|
|
||
|
|
if (second.type == TOK_SEMI_COLON) {
|
||
|
|
return snbt_read_array(tag, type, stream);
|
||
|
|
}
|
||
|
|
|
||
|
|
snbt_free_token(&second);
|
||
|
|
return false;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
return snbt_read_list(tag, NULL, &first, stream);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_compound(tagdata_t *data, const stream_t *stream) {
|
||
|
|
map_t map;
|
||
|
|
map_init(&map);
|
||
|
|
|
||
|
|
token_t next = {0};
|
||
|
|
if (snbt_next_token(&next, stream) == false) {
|
||
|
|
snbt_free_token(&next);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (next.type == TOK_RBRACE) {
|
||
|
|
data->compound = map;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (1) {
|
||
|
|
|
||
|
|
if (next.type != TOK_STRING && next.type != TOK_IDENT) {
|
||
|
|
map_free(&map);
|
||
|
|
snbt_free_token(&next);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
char *name = next.data.text.data;
|
||
|
|
int name_len = next.data.text.len;
|
||
|
|
|
||
|
|
if (name_len < 1) {
|
||
|
|
map_free(&map);
|
||
|
|
free(name);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (snbt_next_token(&next, stream) == false || next.type != TOK_COLON) {
|
||
|
|
map_free(&map);
|
||
|
|
free(name);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
tag_t value;
|
||
|
|
if (snbt_read_value(&value, stream, NULL) == false) {
|
||
|
|
map_free(&map);
|
||
|
|
free(name);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
value.name = name;
|
||
|
|
value.name_len = name_len;
|
||
|
|
|
||
|
|
map_put(&map, &value);
|
||
|
|
|
||
|
|
if (snbt_next_token(&next, stream) == false) {
|
||
|
|
map_free(&map);
|
||
|
|
snbt_free_token(&next);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (next.type == TOK_COMMA) {
|
||
|
|
if (snbt_next_token(&next, stream) == false) {
|
||
|
|
map_free(&map);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
} else if (next.type == TOK_RBRACE) {
|
||
|
|
break;
|
||
|
|
} else {
|
||
|
|
map_free(&map);
|
||
|
|
snbt_free_token(&next);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
data->compound = map;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_convert_decimal(tag_t *tag, char *text) {
|
||
|
|
uint16_t len = strlen(text);
|
||
|
|
|
||
|
|
char *end = NULL;
|
||
|
|
|
||
|
|
double d = strtod(text, &end);
|
||
|
|
|
||
|
|
char c = *end;
|
||
|
|
bool check1 = end == &text[len - 1] && (
|
||
|
|
c == 'f' ||
|
||
|
|
c == 'F' ||
|
||
|
|
c == 'd' ||
|
||
|
|
c == 'D'
|
||
|
|
);
|
||
|
|
bool check2 = end == &text[len] && c == '\0';
|
||
|
|
if (!check1 && !check2) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tag->type == TAG_FLOAT) {
|
||
|
|
tag->data.f = (float)d;
|
||
|
|
} else {
|
||
|
|
tag->data.d = d;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_convert_int(tag_t *tag, char *text) {
|
||
|
|
uint16_t len = strlen(text);
|
||
|
|
|
||
|
|
char *end = NULL;
|
||
|
|
|
||
|
|
uint64_t i = strtol(text, &end, 10);
|
||
|
|
|
||
|
|
char c = *end;
|
||
|
|
bool check1 = end == &text[len - 1] && (
|
||
|
|
c == 'b' ||
|
||
|
|
c == 'B' ||
|
||
|
|
c == 's' ||
|
||
|
|
c == 'S' ||
|
||
|
|
c == 'l' ||
|
||
|
|
c == 'L'
|
||
|
|
);
|
||
|
|
bool check2 = end == &text[len] && c == '\0';
|
||
|
|
if (!check1 && !check2) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tag->type == TAG_BYTE) {
|
||
|
|
tag->data.b = (uint8_t)i;
|
||
|
|
} else if (tag->type == TAG_SHORT) {
|
||
|
|
tag->data.s = (uint16_t)i;
|
||
|
|
} else if (tag->type == TAG_INT) {
|
||
|
|
tag->data.i = (uint32_t)i;
|
||
|
|
} else {
|
||
|
|
tag->data.l = i;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_convert_ident(tag_t *tag, token_t token) {
|
||
|
|
uint16_t len = token.data.text.len + 1;
|
||
|
|
char *text = xalloc(len * sizeof(char));
|
||
|
|
memcpy(text, token.data.text.data, len - 1);
|
||
|
|
text[len - 1] = '\0';
|
||
|
|
|
||
|
|
if (len == 4 && memcmp(text, "true", 4) == 0) {
|
||
|
|
tag->type = TAG_BYTE;
|
||
|
|
tag->data.b = 1;
|
||
|
|
} else if (len == 5 && memcmp(text, "false", 5) == 0) {
|
||
|
|
tag->type = TAG_BYTE;
|
||
|
|
tag->data.b = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// try to parse as a number lol he he ha ha
|
||
|
|
char end = text[len - 2];
|
||
|
|
|
||
|
|
bool ok = false;
|
||
|
|
|
||
|
|
switch (end) {
|
||
|
|
case 'f':
|
||
|
|
case 'F':
|
||
|
|
tag->type = TAG_FLOAT;
|
||
|
|
ok = snbt_convert_decimal(tag, text);
|
||
|
|
break;
|
||
|
|
case 'd':
|
||
|
|
case 'D':
|
||
|
|
tag->type = TAG_DOUBLE;
|
||
|
|
ok = snbt_convert_decimal(tag, text);
|
||
|
|
break;
|
||
|
|
case 'b':
|
||
|
|
case 'B':
|
||
|
|
tag->type = TAG_BYTE;
|
||
|
|
ok = snbt_convert_int(tag, text);
|
||
|
|
break;
|
||
|
|
case 's':
|
||
|
|
case 'S':
|
||
|
|
tag->type = TAG_SHORT;
|
||
|
|
ok = snbt_convert_int(tag, text);
|
||
|
|
break;
|
||
|
|
case 'l':
|
||
|
|
case 'L':
|
||
|
|
tag->type = TAG_LONG;
|
||
|
|
ok = snbt_convert_int(tag, text);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ok) {
|
||
|
|
free(text);
|
||
|
|
snbt_free_token(&token);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// unkown type try long >> double >> string (fallback)
|
||
|
|
|
||
|
|
tag->type = TAG_INT;
|
||
|
|
if (snbt_convert_int(tag, text) == true) {
|
||
|
|
free(text);
|
||
|
|
snbt_free_token(&token);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
tag->type = TAG_DOUBLE;
|
||
|
|
if (snbt_convert_decimal(tag, text) == true) {
|
||
|
|
free(text);
|
||
|
|
snbt_free_token(&token);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
tag->type = TAG_STRING;
|
||
|
|
tag->data.string.data = token.data.text.data;
|
||
|
|
tag->data.string.size = token.data.text.len;
|
||
|
|
free(text);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool snbt_read_value(tag_t *tag, const stream_t *stream, token_t *first) {
|
||
|
|
|
||
|
|
token_t token;
|
||
|
|
|
||
|
|
if (first != NULL)
|
||
|
|
token = *first;
|
||
|
|
else if (snbt_next_token(&token, stream) == false)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
tag->name = "";
|
||
|
|
tag->name_len = 0;
|
||
|
|
|
||
|
|
bool ok = true;
|
||
|
|
|
||
|
|
switch (token.type) {
|
||
|
|
case TOK_RBRACK:
|
||
|
|
case TOK_RBRACE:
|
||
|
|
case TOK_COLON:
|
||
|
|
case TOK_SEMI_COLON:
|
||
|
|
case TOK_COMMA:
|
||
|
|
ok = false;
|
||
|
|
break;
|
||
|
|
case TOK_LBRACK:
|
||
|
|
tag->type = TAG_LIST;
|
||
|
|
ok = snbt_read_collection(tag, stream);
|
||
|
|
break;
|
||
|
|
case TOK_LBRACE:
|
||
|
|
tag->type = TAG_COMPOUND;
|
||
|
|
ok = snbt_read_compound(&tag->data, stream);
|
||
|
|
break;
|
||
|
|
case TOK_STRING:
|
||
|
|
tag->type = TAG_STRING;
|
||
|
|
tag->data.string.data = token.data.text.data;
|
||
|
|
tag->data.string.size = token.data.text.len;
|
||
|
|
break;
|
||
|
|
case TOK_IDENT:
|
||
|
|
ok = snbt_convert_ident(tag, token);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ok;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool snbt_read(tag_t *tag, const stream_t *stream) {
|
||
|
|
return snbt_read_value(tag, stream, NULL);
|
||
|
|
}
|