mirror of
https://github.com/Ed94/Odin.git
synced 2026-07-28 18:30:06 +00:00
Remove unneeded semicolons from the core library
This commit is contained in:
gingerBill
@@ -12,9 +12,9 @@ ENC_TABLE := [32]byte {
|
||||
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
|
||||
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
|
||||
'Y', 'Z', '2', '3', '4', '5', '6', '7',
|
||||
};
|
||||
}
|
||||
|
||||
PADDING :: '=';
|
||||
PADDING :: '='
|
||||
|
||||
DEC_TABLE := [?]u8 {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
@@ -31,118 +31,118 @@ DEC_TABLE := [?]u8 {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
}
|
||||
|
||||
encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) -> string {
|
||||
out_length := (len(data) + 4) / 5 * 8;
|
||||
out := make([]byte, out_length);
|
||||
_encode(out, data);
|
||||
return string(out);
|
||||
out_length := (len(data) + 4) / 5 * 8
|
||||
out := make([]byte, out_length)
|
||||
_encode(out, data)
|
||||
return string(out)
|
||||
}
|
||||
|
||||
@private
|
||||
_encode :: proc(out, data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) {
|
||||
out := out;
|
||||
data := data;
|
||||
out := out
|
||||
data := data
|
||||
|
||||
for len(data) > 0 {
|
||||
carry: byte;
|
||||
carry: byte
|
||||
switch len(data) {
|
||||
case:
|
||||
out[7] = ENC_TABLE[data[4] & 0x1f];
|
||||
carry = data[4] >> 5;
|
||||
fallthrough;
|
||||
out[7] = ENC_TABLE[data[4] & 0x1f]
|
||||
carry = data[4] >> 5
|
||||
fallthrough
|
||||
case 4:
|
||||
out[6] = ENC_TABLE[carry | (data[3] << 3) & 0x1f];
|
||||
out[5] = ENC_TABLE[(data[3] >> 2) & 0x1f];
|
||||
carry = data[3] >> 7;
|
||||
fallthrough;
|
||||
out[6] = ENC_TABLE[carry | (data[3] << 3) & 0x1f]
|
||||
out[5] = ENC_TABLE[(data[3] >> 2) & 0x1f]
|
||||
carry = data[3] >> 7
|
||||
fallthrough
|
||||
case 3:
|
||||
out[4] = ENC_TABLE[carry | (data[2] << 1) & 0x1f];
|
||||
carry = (data[2] >> 4) & 0x1f;
|
||||
fallthrough;
|
||||
out[4] = ENC_TABLE[carry | (data[2] << 1) & 0x1f]
|
||||
carry = (data[2] >> 4) & 0x1f
|
||||
fallthrough
|
||||
case 2:
|
||||
out[3] = ENC_TABLE[carry | (data[1] << 4) & 0x1f];
|
||||
out[2] = ENC_TABLE[(data[1] >> 1) & 0x1f];
|
||||
carry = (data[1] >> 6) & 0x1f;
|
||||
fallthrough;
|
||||
out[3] = ENC_TABLE[carry | (data[1] << 4) & 0x1f]
|
||||
out[2] = ENC_TABLE[(data[1] >> 1) & 0x1f]
|
||||
carry = (data[1] >> 6) & 0x1f
|
||||
fallthrough
|
||||
case 1:
|
||||
out[1] = ENC_TABLE[carry | (data[0] << 2) & 0x1f];
|
||||
out[0] = ENC_TABLE[data[0] >> 3];
|
||||
out[1] = ENC_TABLE[carry | (data[0] << 2) & 0x1f]
|
||||
out[0] = ENC_TABLE[data[0] >> 3]
|
||||
}
|
||||
|
||||
if len(data) < 5 {
|
||||
out[7] = byte(PADDING);
|
||||
out[7] = byte(PADDING)
|
||||
if len(data) < 4 {
|
||||
out[6] = byte(PADDING);
|
||||
out[5] = byte(PADDING);
|
||||
out[6] = byte(PADDING)
|
||||
out[5] = byte(PADDING)
|
||||
if len(data) < 3 {
|
||||
out[4] = byte(PADDING);
|
||||
out[4] = byte(PADDING)
|
||||
if len(data) < 2 {
|
||||
out[3] = byte(PADDING);
|
||||
out[2] = byte(PADDING);
|
||||
out[3] = byte(PADDING)
|
||||
out[2] = byte(PADDING)
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break
|
||||
}
|
||||
data = data[5:];
|
||||
out = out[8:];
|
||||
data = data[5:]
|
||||
out = out[8:]
|
||||
}
|
||||
}
|
||||
|
||||
decode :: proc(data: string, DEC_TBL := DEC_TABLE, allocator := context.allocator) -> []byte #no_bounds_check{
|
||||
if len(data) == 0 {
|
||||
return nil;
|
||||
return nil
|
||||
}
|
||||
|
||||
outi := 0;
|
||||
data := data;
|
||||
outi := 0
|
||||
data := data
|
||||
|
||||
out := make([]byte, len(data) / 8 * 5, allocator);
|
||||
end := false;
|
||||
out := make([]byte, len(data) / 8 * 5, allocator)
|
||||
end := false
|
||||
for len(data) > 0 && !end {
|
||||
dbuf : [8]byte;
|
||||
dlen := 8;
|
||||
dbuf : [8]byte
|
||||
dlen := 8
|
||||
|
||||
for j := 0; j < 8; {
|
||||
if len(data) == 0 {
|
||||
dlen, end = j, true;
|
||||
break;
|
||||
dlen, end = j, true
|
||||
break
|
||||
}
|
||||
input := data[0];
|
||||
data = data[1:];
|
||||
input := data[0]
|
||||
data = data[1:]
|
||||
if input == byte(PADDING) && j >= 2 && len(data) < 8 {
|
||||
assert(!(len(data) + j < 8 - 1), "Corrupted input");
|
||||
assert(!(len(data) + j < 8 - 1), "Corrupted input")
|
||||
for k := 0; k < 8-1-j; k +=1 {
|
||||
assert(len(data) < k || data[k] == byte(PADDING), "Corrupted input");
|
||||
assert(len(data) < k || data[k] == byte(PADDING), "Corrupted input")
|
||||
}
|
||||
dlen, end = j, true;
|
||||
assert(dlen != 1 && dlen != 3 && dlen != 6, "Corrupted input");
|
||||
break;
|
||||
dlen, end = j, true
|
||||
assert(dlen != 1 && dlen != 3 && dlen != 6, "Corrupted input")
|
||||
break
|
||||
}
|
||||
dbuf[j] = DEC_TABLE[input];
|
||||
assert(dbuf[j] != 0xff, "Corrupted input");
|
||||
j += 1;
|
||||
dbuf[j] = DEC_TABLE[input]
|
||||
assert(dbuf[j] != 0xff, "Corrupted input")
|
||||
j += 1
|
||||
}
|
||||
|
||||
switch dlen {
|
||||
case 8:
|
||||
out[outi + 4] = dbuf[6] << 5 | dbuf[7];
|
||||
fallthrough;
|
||||
out[outi + 4] = dbuf[6] << 5 | dbuf[7]
|
||||
fallthrough
|
||||
case 7:
|
||||
out[outi + 3] = dbuf[4] << 7 | dbuf[5] << 2 | dbuf[6] >> 3;
|
||||
fallthrough;
|
||||
out[outi + 3] = dbuf[4] << 7 | dbuf[5] << 2 | dbuf[6] >> 3
|
||||
fallthrough
|
||||
case 5:
|
||||
out[outi + 2] = dbuf[3] << 4 | dbuf[4] >> 1;
|
||||
fallthrough;
|
||||
out[outi + 2] = dbuf[3] << 4 | dbuf[4] >> 1
|
||||
fallthrough
|
||||
case 4:
|
||||
out[outi + 1] = dbuf[1] << 6 | dbuf[2] << 1 | dbuf[3] >> 4;
|
||||
fallthrough;
|
||||
out[outi + 1] = dbuf[1] << 6 | dbuf[2] << 1 | dbuf[3] >> 4
|
||||
fallthrough
|
||||
case 2:
|
||||
out[outi + 0] = dbuf[0] << 3 | dbuf[1] >> 2;
|
||||
out[outi + 0] = dbuf[0] << 3 | dbuf[1] >> 2
|
||||
}
|
||||
outi += 5;
|
||||
outi += 5
|
||||
}
|
||||
return out;
|
||||
return out
|
||||
}
|
||||
|
||||
@@ -16,9 +16,9 @@ ENC_TABLE := [64]byte {
|
||||
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
|
||||
'w', 'x', 'y', 'z', '0', '1', '2', '3',
|
||||
'4', '5', '6', '7', '8', '9', '+', '/',
|
||||
};
|
||||
}
|
||||
|
||||
PADDING :: '=';
|
||||
PADDING :: '='
|
||||
|
||||
DEC_TABLE := [128]int {
|
||||
-1, -1, -1, -1, -1, -1, -1, -1,
|
||||
@@ -37,61 +37,61 @@ DEC_TABLE := [128]int {
|
||||
33, 34, 35, 36, 37, 38, 39, 40,
|
||||
41, 42, 43, 44, 45, 46, 47, 48,
|
||||
49, 50, 51, -1, -1, -1, -1, -1,
|
||||
};
|
||||
}
|
||||
|
||||
encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) -> string #no_bounds_check {
|
||||
length := len(data);
|
||||
length := len(data)
|
||||
if length == 0 {
|
||||
return "";
|
||||
return ""
|
||||
}
|
||||
|
||||
out_length := ((4 * length / 3) + 3) &~ 3;
|
||||
out := make([]byte, out_length, allocator);
|
||||
out_length := ((4 * length / 3) + 3) &~ 3
|
||||
out := make([]byte, out_length, allocator)
|
||||
|
||||
c0, c1, c2, block: int;
|
||||
c0, c1, c2, block: int
|
||||
|
||||
for i, d := 0, 0; i < length; i, d = i + 3, d + 4 {
|
||||
c0, c1, c2 = int(data[i]), -1, -1;
|
||||
c0, c1, c2 = int(data[i]), -1, -1
|
||||
|
||||
if i + 1 < length { c1 = int(data[i + 1]); }
|
||||
if i + 2 < length { c2 = int(data[i + 2]); }
|
||||
|
||||
block = (c0 << 16) | (max(c1, 0) << 8) | max(c2, 0);
|
||||
block = (c0 << 16) | (max(c1, 0) << 8) | max(c2, 0)
|
||||
|
||||
out[d] = ENC_TBL[block >> 18 & 63];
|
||||
out[d + 1] = ENC_TBL[block >> 12 & 63];
|
||||
out[d + 2] = c1 == -1 ? PADDING : ENC_TBL[block >> 6 & 63];
|
||||
out[d + 3] = c2 == -1 ? PADDING : ENC_TBL[block & 63];
|
||||
out[d] = ENC_TBL[block >> 18 & 63]
|
||||
out[d + 1] = ENC_TBL[block >> 12 & 63]
|
||||
out[d + 2] = c1 == -1 ? PADDING : ENC_TBL[block >> 6 & 63]
|
||||
out[d + 3] = c2 == -1 ? PADDING : ENC_TBL[block & 63]
|
||||
}
|
||||
return string(out);
|
||||
return string(out)
|
||||
}
|
||||
|
||||
decode :: proc(data: string, DEC_TBL := DEC_TABLE, allocator := context.allocator) -> []byte #no_bounds_check {
|
||||
length := len(data);
|
||||
length := len(data)
|
||||
if length == 0 {
|
||||
return nil;
|
||||
return nil
|
||||
}
|
||||
|
||||
pad_count := data[length - 1] == PADDING ? (data[length - 2] == PADDING ? 2 : 1) : 0;
|
||||
out_length := ((length * 6) >> 3) - pad_count;
|
||||
out := make([]byte, out_length, allocator);
|
||||
pad_count := data[length - 1] == PADDING ? (data[length - 2] == PADDING ? 2 : 1) : 0
|
||||
out_length := ((length * 6) >> 3) - pad_count
|
||||
out := make([]byte, out_length, allocator)
|
||||
|
||||
c0, c1, c2, c3: int;
|
||||
b0, b1, b2: int;
|
||||
c0, c1, c2, c3: int
|
||||
b0, b1, b2: int
|
||||
|
||||
for i, j := 0, 0; i < length; i, j = i + 4, j + 3 {
|
||||
c0 = DEC_TBL[data[i]];
|
||||
c1 = DEC_TBL[data[i + 1]];
|
||||
c2 = DEC_TBL[data[i + 2]];
|
||||
c3 = DEC_TBL[data[i + 3]];
|
||||
c0 = DEC_TBL[data[i]]
|
||||
c1 = DEC_TBL[data[i + 1]]
|
||||
c2 = DEC_TBL[data[i + 2]]
|
||||
c3 = DEC_TBL[data[i + 3]]
|
||||
|
||||
b0 = (c0 << 2) | (c1 >> 4);
|
||||
b1 = (c1 << 4) | (c2 >> 2);
|
||||
b2 = (c2 << 6) | c3;
|
||||
b0 = (c0 << 2) | (c1 >> 4)
|
||||
b1 = (c1 << 4) | (c2 >> 2)
|
||||
b2 = (c2 << 6) | c3
|
||||
|
||||
out[j] = byte(b0);
|
||||
out[j + 1] = byte(b1);
|
||||
out[j + 2] = byte(b2);
|
||||
out[j] = byte(b0)
|
||||
out[j + 1] = byte(b1)
|
||||
out[j + 2] = byte(b2)
|
||||
}
|
||||
return out;
|
||||
return out
|
||||
}
|
||||
|
||||
+136
-136
@@ -68,7 +68,7 @@ reader_error_kind_string := [Reader_Error_Kind]string{
|
||||
.Quote = "extra or missing \" in quoted field",
|
||||
.Field_Count = "wrong field count",
|
||||
.Invalid_Delim = "invalid delimiter",
|
||||
};
|
||||
}
|
||||
|
||||
Reader_Error :: struct {
|
||||
kind: Reader_Error_Kind,
|
||||
@@ -83,35 +83,35 @@ Error :: union {
|
||||
io.Error,
|
||||
}
|
||||
|
||||
DEFAULT_RECORD_BUFFER_CAPACITY :: 256;
|
||||
DEFAULT_RECORD_BUFFER_CAPACITY :: 256
|
||||
|
||||
// reader_init initializes a new Reader from r
|
||||
reader_init :: proc(reader: ^Reader, r: io.Reader, buffer_allocator := context.allocator) {
|
||||
reader.comma = ',';
|
||||
reader.comma = ','
|
||||
|
||||
context.allocator = buffer_allocator;
|
||||
reserve(&reader.record_buffer, DEFAULT_RECORD_BUFFER_CAPACITY);
|
||||
reserve(&reader.raw_buffer, 0);
|
||||
reserve(&reader.field_indices, 0);
|
||||
reserve(&reader.last_record, 0);
|
||||
bufio.reader_init(&reader.r, r);
|
||||
context.allocator = buffer_allocator
|
||||
reserve(&reader.record_buffer, DEFAULT_RECORD_BUFFER_CAPACITY)
|
||||
reserve(&reader.raw_buffer, 0)
|
||||
reserve(&reader.field_indices, 0)
|
||||
reserve(&reader.last_record, 0)
|
||||
bufio.reader_init(&reader.r, r)
|
||||
}
|
||||
|
||||
|
||||
// reader_init_with_string initializes a new Reader from s
|
||||
reader_init_with_string :: proc(reader: ^Reader, s: string, buffer_allocator := context.allocator) {
|
||||
strings.reader_init(&reader.sr, s);
|
||||
r, _ := io.to_reader(strings.reader_to_stream(&reader.sr));
|
||||
reader_init(reader, r, buffer_allocator);
|
||||
strings.reader_init(&reader.sr, s)
|
||||
r, _ := io.to_reader(strings.reader_to_stream(&reader.sr))
|
||||
reader_init(reader, r, buffer_allocator)
|
||||
}
|
||||
|
||||
// reader_destroy destroys a Reader
|
||||
reader_destroy :: proc(r: ^Reader) {
|
||||
delete(r.raw_buffer);
|
||||
delete(r.record_buffer);
|
||||
delete(r.field_indices);
|
||||
delete(r.last_record);
|
||||
bufio.reader_destroy(&r.r);
|
||||
delete(r.raw_buffer)
|
||||
delete(r.record_buffer)
|
||||
delete(r.field_indices)
|
||||
delete(r.last_record)
|
||||
bufio.reader_destroy(&r.r)
|
||||
}
|
||||
|
||||
// read reads a single record (a slice of fields) from r
|
||||
@@ -119,21 +119,21 @@ reader_destroy :: proc(r: ^Reader) {
|
||||
// All \r\n sequences are normalized to \n, including multi-line field
|
||||
read :: proc(r: ^Reader, allocator := context.allocator) -> (record: []string, err: Error) {
|
||||
if r.reuse_record {
|
||||
record, err = _read_record(r, &r.last_record, allocator);
|
||||
resize(&r.last_record, len(record));
|
||||
copy(r.last_record[:], record);
|
||||
record, err = _read_record(r, &r.last_record, allocator)
|
||||
resize(&r.last_record, len(record))
|
||||
copy(r.last_record[:], record)
|
||||
} else {
|
||||
record, err = _read_record(r, nil, allocator);
|
||||
record, err = _read_record(r, nil, allocator)
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
// is_io_error checks where an Error is a specific io.Error kind
|
||||
is_io_error :: proc(err: Error, io_err: io.Error) -> bool {
|
||||
if v, ok := err.(io.Error); ok {
|
||||
return v == io_err;
|
||||
return v == io_err
|
||||
}
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
|
||||
@@ -141,97 +141,97 @@ is_io_error :: proc(err: Error, io_err: io.Error) -> bool {
|
||||
// Each record is a slice of fields.
|
||||
// read_all is defined to read until an EOF, and does not treat, and does not treat EOF as an error
|
||||
read_all :: proc(r: ^Reader, allocator := context.allocator) -> ([][]string, Error) {
|
||||
context.allocator = allocator;
|
||||
records: [dynamic][]string;
|
||||
context.allocator = allocator
|
||||
records: [dynamic][]string
|
||||
for {
|
||||
record, rerr := _read_record(r, nil, allocator);
|
||||
record, rerr := _read_record(r, nil, allocator)
|
||||
if is_io_error(rerr, .EOF) {
|
||||
return records[:], nil;
|
||||
return records[:], nil
|
||||
}
|
||||
if rerr != nil {
|
||||
return nil, rerr;
|
||||
return nil, rerr
|
||||
}
|
||||
append(&records, record);
|
||||
append(&records, record)
|
||||
}
|
||||
}
|
||||
|
||||
// read reads a single record (a slice of fields) from the provided input.
|
||||
read_from_string :: proc(input: string, record_allocator := context.allocator, buffer_allocator := context.allocator) -> (record: []string, n: int, err: Error) {
|
||||
ir: strings.Reader;
|
||||
strings.reader_init(&ir, input);
|
||||
input_reader, _ := io.to_reader(strings.reader_to_stream(&ir));
|
||||
ir: strings.Reader
|
||||
strings.reader_init(&ir, input)
|
||||
input_reader, _ := io.to_reader(strings.reader_to_stream(&ir))
|
||||
|
||||
r: Reader;
|
||||
reader_init(&r, input_reader, buffer_allocator);
|
||||
defer reader_destroy(&r);
|
||||
record, err = read(&r, record_allocator);
|
||||
n = int(r.r.r);
|
||||
return;
|
||||
r: Reader
|
||||
reader_init(&r, input_reader, buffer_allocator)
|
||||
defer reader_destroy(&r)
|
||||
record, err = read(&r, record_allocator)
|
||||
n = int(r.r.r)
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
// read_all reads all the remaining records from the provided input.
|
||||
read_all_from_string :: proc(input: string, records_allocator := context.allocator, buffer_allocator := context.allocator) -> ([][]string, Error) {
|
||||
ir: strings.Reader;
|
||||
strings.reader_init(&ir, input);
|
||||
input_reader, _ := io.to_reader(strings.reader_to_stream(&ir));
|
||||
ir: strings.Reader
|
||||
strings.reader_init(&ir, input)
|
||||
input_reader, _ := io.to_reader(strings.reader_to_stream(&ir))
|
||||
|
||||
r: Reader;
|
||||
reader_init(&r, input_reader, buffer_allocator);
|
||||
defer reader_destroy(&r);
|
||||
return read_all(&r, records_allocator);
|
||||
r: Reader
|
||||
reader_init(&r, input_reader, buffer_allocator)
|
||||
defer reader_destroy(&r)
|
||||
return read_all(&r, records_allocator)
|
||||
}
|
||||
|
||||
@private
|
||||
is_valid_delim :: proc(r: rune) -> bool {
|
||||
switch r {
|
||||
case 0, '"', '\r', '\n', utf8.RUNE_ERROR:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return utf8.valid_rune(r);
|
||||
return utf8.valid_rune(r)
|
||||
}
|
||||
|
||||
@private
|
||||
_read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.allocator) -> ([]string, Error) {
|
||||
read_line :: proc(r: ^Reader) -> ([]byte, io.Error) {
|
||||
line, err := bufio.reader_read_slice(&r.r, '\n');
|
||||
line, err := bufio.reader_read_slice(&r.r, '\n')
|
||||
if err == .Buffer_Full {
|
||||
clear(&r.raw_buffer);
|
||||
append(&r.raw_buffer, ..line);
|
||||
clear(&r.raw_buffer)
|
||||
append(&r.raw_buffer, ..line)
|
||||
for err == .Buffer_Full {
|
||||
line, err = bufio.reader_read_slice(&r.r, '\n');
|
||||
append(&r.raw_buffer, ..line);
|
||||
line, err = bufio.reader_read_slice(&r.r, '\n')
|
||||
append(&r.raw_buffer, ..line)
|
||||
}
|
||||
line = r.raw_buffer[:];
|
||||
line = r.raw_buffer[:]
|
||||
}
|
||||
if len(line) > 0 && err == .EOF {
|
||||
err = nil;
|
||||
err = nil
|
||||
if line[len(line)-1] == '\r' {
|
||||
line = line[:len(line)-1];
|
||||
line = line[:len(line)-1]
|
||||
}
|
||||
}
|
||||
r.line_count += 1;
|
||||
r.line_count += 1
|
||||
|
||||
// normalize \r\n to \n
|
||||
n := len(line);
|
||||
n := len(line)
|
||||
for n >= 2 && string(line[n-2:]) == "\r\n" {
|
||||
line[n-2] = '\n';
|
||||
line = line[:n-1];
|
||||
line[n-2] = '\n'
|
||||
line = line[:n-1]
|
||||
}
|
||||
|
||||
return line, err;
|
||||
return line, err
|
||||
}
|
||||
|
||||
length_newline :: proc(b: []byte) -> int {
|
||||
if len(b) > 0 && b[len(b)-1] == '\n' {
|
||||
return 1;
|
||||
return 1
|
||||
}
|
||||
return 0;
|
||||
return 0
|
||||
}
|
||||
|
||||
next_rune :: proc(b: []byte) -> rune {
|
||||
r, _ := utf8.decode_rune(b);
|
||||
return r;
|
||||
r, _ := utf8.decode_rune(b)
|
||||
return r
|
||||
}
|
||||
|
||||
if r.comma == r.comment ||
|
||||
@@ -240,152 +240,152 @@ _read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.all
|
||||
err := Reader_Error{
|
||||
kind = .Invalid_Delim,
|
||||
line = r.line_count,
|
||||
};
|
||||
return nil, err;
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
|
||||
line, full_line: []byte;
|
||||
err_read: io.Error;
|
||||
line, full_line: []byte
|
||||
err_read: io.Error
|
||||
for err_read == nil {
|
||||
line, err_read = read_line(r);
|
||||
line, err_read = read_line(r)
|
||||
if r.comment != 0 && next_rune(line) == r.comment {
|
||||
line = nil;
|
||||
continue;
|
||||
line = nil
|
||||
continue
|
||||
}
|
||||
if err_read == nil && len(line) == length_newline(line) {
|
||||
line = nil;
|
||||
continue;
|
||||
line = nil
|
||||
continue
|
||||
}
|
||||
full_line = line;
|
||||
break;
|
||||
full_line = line
|
||||
break
|
||||
}
|
||||
|
||||
if is_io_error(err_read, .EOF) {
|
||||
return nil, err_read;
|
||||
return nil, err_read
|
||||
}
|
||||
|
||||
err: Error;
|
||||
quote_len :: len(`"`);
|
||||
comma_len := utf8.rune_size(r.comma);
|
||||
record_line := r.line_count;
|
||||
clear(&r.record_buffer);
|
||||
clear(&r.field_indices);
|
||||
err: Error
|
||||
quote_len :: len(`"`)
|
||||
comma_len := utf8.rune_size(r.comma)
|
||||
record_line := r.line_count
|
||||
clear(&r.record_buffer)
|
||||
clear(&r.field_indices)
|
||||
|
||||
parse_field: for {
|
||||
if r.trim_leading_space {
|
||||
line = bytes.trim_left_space(line);
|
||||
line = bytes.trim_left_space(line)
|
||||
}
|
||||
if len(line) == 0 || line[0] != '"' {
|
||||
i := bytes.index_rune(line, r.comma);
|
||||
field := line;
|
||||
i := bytes.index_rune(line, r.comma)
|
||||
field := line
|
||||
if i >= 0 {
|
||||
field = field[:i];
|
||||
field = field[:i]
|
||||
} else {
|
||||
field = field[:len(field) - length_newline(field)];
|
||||
field = field[:len(field) - length_newline(field)]
|
||||
}
|
||||
|
||||
if !r.lazy_quotes {
|
||||
if j := bytes.index_byte(field, '"'); j >= 0 {
|
||||
column := utf8.rune_count(full_line[:len(full_line) - len(line[j:])]);
|
||||
column := utf8.rune_count(full_line[:len(full_line) - len(line[j:])])
|
||||
err = Reader_Error{
|
||||
kind = .Bare_Quote,
|
||||
start_line = record_line,
|
||||
line = r.line_count,
|
||||
column = column,
|
||||
};
|
||||
break parse_field;
|
||||
}
|
||||
break parse_field
|
||||
}
|
||||
}
|
||||
append(&r.record_buffer, ..field);
|
||||
append(&r.field_indices, len(r.record_buffer));
|
||||
append(&r.record_buffer, ..field)
|
||||
append(&r.field_indices, len(r.record_buffer))
|
||||
if i >= 0 {
|
||||
line = line[i+comma_len:];
|
||||
continue parse_field;
|
||||
line = line[i+comma_len:]
|
||||
continue parse_field
|
||||
}
|
||||
break parse_field;
|
||||
break parse_field
|
||||
|
||||
} else {
|
||||
line = line[quote_len:];
|
||||
line = line[quote_len:]
|
||||
for {
|
||||
i := bytes.index_byte(line, '"');
|
||||
i := bytes.index_byte(line, '"')
|
||||
switch {
|
||||
case i >= 0:
|
||||
append(&r.record_buffer, ..line[:i]);
|
||||
line = line[i+quote_len:];
|
||||
append(&r.record_buffer, ..line[:i])
|
||||
line = line[i+quote_len:]
|
||||
switch ch := next_rune(line); {
|
||||
case ch == '"': // append quote
|
||||
append(&r.record_buffer, '"');
|
||||
line = line[quote_len:];
|
||||
append(&r.record_buffer, '"')
|
||||
line = line[quote_len:]
|
||||
case ch == r.comma: // end of field
|
||||
line = line[comma_len:];
|
||||
append(&r.field_indices, len(r.record_buffer));
|
||||
continue parse_field;
|
||||
line = line[comma_len:]
|
||||
append(&r.field_indices, len(r.record_buffer))
|
||||
continue parse_field
|
||||
case length_newline(line) == len(line): // end of line
|
||||
append(&r.field_indices, len(r.record_buffer));
|
||||
break parse_field;
|
||||
append(&r.field_indices, len(r.record_buffer))
|
||||
break parse_field
|
||||
case r.lazy_quotes: // bare quote
|
||||
append(&r.record_buffer, '"');
|
||||
append(&r.record_buffer, '"')
|
||||
case: // invalid non-escaped quote
|
||||
column := utf8.rune_count(full_line[:len(full_line) - len(line) - quote_len]);
|
||||
column := utf8.rune_count(full_line[:len(full_line) - len(line) - quote_len])
|
||||
err = Reader_Error{
|
||||
kind = .Quote,
|
||||
start_line = record_line,
|
||||
line = r.line_count,
|
||||
column = column,
|
||||
};
|
||||
break parse_field;
|
||||
}
|
||||
break parse_field
|
||||
}
|
||||
|
||||
case len(line) > 0:
|
||||
append(&r.record_buffer, ..line);
|
||||
append(&r.record_buffer, ..line)
|
||||
if err_read != nil {
|
||||
break parse_field;
|
||||
break parse_field
|
||||
}
|
||||
line, err_read = read_line(r);
|
||||
line, err_read = read_line(r)
|
||||
if is_io_error(err_read, .EOF) {
|
||||
err_read = nil;
|
||||
err_read = nil
|
||||
}
|
||||
full_line = line;
|
||||
full_line = line
|
||||
|
||||
case:
|
||||
if !r.lazy_quotes && err_read == nil {
|
||||
column := utf8.rune_count(full_line);
|
||||
column := utf8.rune_count(full_line)
|
||||
err = Reader_Error{
|
||||
kind = .Quote,
|
||||
start_line = record_line,
|
||||
line = r.line_count,
|
||||
column = column,
|
||||
};
|
||||
break parse_field;
|
||||
}
|
||||
break parse_field
|
||||
}
|
||||
append(&r.field_indices, len(r.record_buffer));
|
||||
break parse_field;
|
||||
append(&r.field_indices, len(r.record_buffer))
|
||||
break parse_field
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if err == nil && err_read != nil {
|
||||
err = err_read;
|
||||
err = err_read
|
||||
}
|
||||
|
||||
context.allocator = allocator;
|
||||
dst := dst;
|
||||
str := string(r.record_buffer[:]);
|
||||
context.allocator = allocator
|
||||
dst := dst
|
||||
str := string(r.record_buffer[:])
|
||||
if dst == nil {
|
||||
// use local variable
|
||||
dst = &([dynamic]string){};
|
||||
dst = &([dynamic]string){}
|
||||
}
|
||||
clear(dst);
|
||||
resize(dst, len(r.field_indices));
|
||||
pre_idx: int;
|
||||
clear(dst)
|
||||
resize(dst, len(r.field_indices))
|
||||
pre_idx: int
|
||||
for idx, i in r.field_indices {
|
||||
field := str[pre_idx:idx];
|
||||
field := str[pre_idx:idx]
|
||||
if !r.reuse_record_buffer {
|
||||
field = strings.clone(field);
|
||||
field = strings.clone(field)
|
||||
}
|
||||
dst[i] = field;
|
||||
pre_idx = idx;
|
||||
dst[i] = field
|
||||
pre_idx = idx
|
||||
}
|
||||
|
||||
if r.fields_per_record > 0 {
|
||||
@@ -396,11 +396,11 @@ _read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.all
|
||||
line = r.line_count,
|
||||
expected = r.fields_per_record,
|
||||
got = len(dst),
|
||||
};
|
||||
}
|
||||
}
|
||||
} else if r.fields_per_record == 0 {
|
||||
r.fields_per_record = len(dst);
|
||||
r.fields_per_record = len(dst)
|
||||
}
|
||||
return dst[:], err;
|
||||
return dst[:], err
|
||||
|
||||
}
|
||||
|
||||
@@ -17,8 +17,8 @@ Writer :: struct {
|
||||
|
||||
// writer_init initializes a Writer that writes to w
|
||||
writer_init :: proc(writer: ^Writer, w: io.Writer) {
|
||||
writer.comma = ',';
|
||||
writer.w = w;
|
||||
writer.comma = ','
|
||||
writer.w = w
|
||||
}
|
||||
|
||||
// write writes a single CSV records to w with any of the necessarily quoting.
|
||||
@@ -26,101 +26,101 @@ writer_init :: proc(writer: ^Writer, w: io.Writer) {
|
||||
//
|
||||
// If the underlying io.Writer requires flushing, make sure to call io.flush
|
||||
write :: proc(w: ^Writer, record: []string) -> io.Error {
|
||||
CHAR_SET :: "\n\r\"";
|
||||
CHAR_SET :: "\n\r\""
|
||||
|
||||
field_needs_quoting :: proc(w: ^Writer, field: string) -> bool {
|
||||
switch {
|
||||
case field == "": // No need to quote empty strings
|
||||
return false;
|
||||
return false
|
||||
case field == `\.`: // Postgres is weird
|
||||
return true;
|
||||
return true
|
||||
case w.comma < utf8.RUNE_SELF: // ASCII optimization
|
||||
for i in 0..<len(field) {
|
||||
switch field[i] {
|
||||
case '\n', '\r', '"', byte(w.comma):
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
}
|
||||
case:
|
||||
if strings.contains_rune(field, w.comma) >= 0 {
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
if strings.contains_any(field, CHAR_SET) {
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// Leading spaces need quoting
|
||||
r, _ := utf8.decode_rune_in_string(field);
|
||||
return strings.is_space(r);
|
||||
r, _ := utf8.decode_rune_in_string(field)
|
||||
return strings.is_space(r)
|
||||
}
|
||||
|
||||
if !is_valid_delim(w.comma) {
|
||||
return .No_Progress; // TODO(bill): Is this a good error?
|
||||
return .No_Progress // TODO(bill): Is this a good error?
|
||||
}
|
||||
|
||||
for _, field_idx in record {
|
||||
// NOTE(bill): declared like this so that the field can be modified later if necessary
|
||||
field := record[field_idx];
|
||||
field := record[field_idx]
|
||||
|
||||
if field_idx > 0 {
|
||||
io.write_rune(w.w, w.comma) or_return;
|
||||
io.write_rune(w.w, w.comma) or_return
|
||||
}
|
||||
|
||||
if !field_needs_quoting(w, field) {
|
||||
io.write_string(w.w, field) or_return;
|
||||
continue;
|
||||
io.write_string(w.w, field) or_return
|
||||
continue
|
||||
}
|
||||
|
||||
io.write_byte(w.w, '"') or_return;
|
||||
io.write_byte(w.w, '"') or_return
|
||||
|
||||
for len(field) > 0 {
|
||||
i := strings.index_any(field, CHAR_SET);
|
||||
i := strings.index_any(field, CHAR_SET)
|
||||
if i < 0 {
|
||||
i = len(field);
|
||||
i = len(field)
|
||||
}
|
||||
|
||||
io.write_string(w.w, field[:i]) or_return;
|
||||
field = field[i:];
|
||||
io.write_string(w.w, field[:i]) or_return
|
||||
field = field[i:]
|
||||
|
||||
if len(field) > 0 {
|
||||
switch field[0] {
|
||||
case '\r':
|
||||
if !w.use_crlf {
|
||||
io.write_byte(w.w, '\r') or_return;
|
||||
io.write_byte(w.w, '\r') or_return
|
||||
}
|
||||
case '\n':
|
||||
if w.use_crlf {
|
||||
io.write_string(w.w, "\r\n") or_return;
|
||||
io.write_string(w.w, "\r\n") or_return
|
||||
} else {
|
||||
io.write_byte(w.w, '\n') or_return;
|
||||
io.write_byte(w.w, '\n') or_return
|
||||
}
|
||||
case '"':
|
||||
io.write_string(w.w, `""`) or_return;
|
||||
io.write_string(w.w, `""`) or_return
|
||||
}
|
||||
field = field[1:];
|
||||
field = field[1:]
|
||||
}
|
||||
}
|
||||
io.write_byte(w.w, '"') or_return;
|
||||
io.write_byte(w.w, '"') or_return
|
||||
}
|
||||
|
||||
if w.use_crlf {
|
||||
_, err := io.write_string(w.w, "\r\n");
|
||||
return err;
|
||||
_, err := io.write_string(w.w, "\r\n")
|
||||
return err
|
||||
}
|
||||
return io.write_byte(w.w, '\n');
|
||||
return io.write_byte(w.w, '\n')
|
||||
}
|
||||
|
||||
// write_all writes multiple CSV records to w using write, and then flushes (if necessary).
|
||||
write_all :: proc(w: ^Writer, records: [][]string) -> io.Error {
|
||||
for record in records {
|
||||
write(w, record) or_return;
|
||||
write(w, record) or_return
|
||||
}
|
||||
return writer_flush(w);
|
||||
return writer_flush(w)
|
||||
}
|
||||
|
||||
// writer_flush flushes the underlying io.Writer.
|
||||
// If the underlying io.Writer does not support flush, nil is returned.
|
||||
writer_flush :: proc(w: ^Writer) -> io.Error {
|
||||
return io.flush(auto_cast w.w);
|
||||
return io.flush(auto_cast w.w)
|
||||
}
|
||||
|
||||
+46
-46
@@ -2,10 +2,10 @@ package encoding_hxa
|
||||
|
||||
import "core:mem"
|
||||
|
||||
LATEST_VERSION :: 3;
|
||||
VERSION_API :: "0.3";
|
||||
LATEST_VERSION :: 3
|
||||
VERSION_API :: "0.3"
|
||||
|
||||
MAGIC_NUMBER :: 'H'<<0 | 'x'<<8 | 'A'<<16 | '\x00'<<24;
|
||||
MAGIC_NUMBER :: 'H'<<0 | 'x'<<8 | 'A'<<16 | '\x00'<<24
|
||||
|
||||
Header :: struct #packed {
|
||||
magic_number: u32le,
|
||||
@@ -48,7 +48,7 @@ Meta_Value_Type :: enum u8 {
|
||||
Text = 3,
|
||||
Binary = 4,
|
||||
Meta = 5,
|
||||
};
|
||||
}
|
||||
|
||||
Meta :: struct {
|
||||
name: string, // name of the meta data value (maximum length is 255)
|
||||
@@ -74,7 +74,7 @@ Layer :: struct {
|
||||
}
|
||||
|
||||
// Layers stacks are arrays of layers where all the layers have the same number of entries (polygons, edges, vertices or pixels)
|
||||
Layer_Stack :: distinct []Layer;
|
||||
Layer_Stack :: distinct []Layer
|
||||
|
||||
Node_Geometry :: struct {
|
||||
vertex_count: u32le, // number of vertices
|
||||
@@ -92,7 +92,7 @@ Node_Image :: struct {
|
||||
image_stack: Layer_Stack,
|
||||
}
|
||||
|
||||
Node_Index :: distinct u32le;
|
||||
Node_Index :: distinct u32le
|
||||
|
||||
// A file consists of an array of nodes, All nodes have meta data. Geometry nodes have geometry, image nodes have pixels
|
||||
Node :: struct {
|
||||
@@ -114,15 +114,15 @@ If you use HxA for something not covered by the conventions but need a conventio
|
||||
/* Hard conventions */
|
||||
/* ---------------- */
|
||||
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_NAME :: "vertex";
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_ID :: 0;
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_COMPONENTS :: 3;
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_NAME :: "reference";
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_ID :: 0;
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_COMPONENTS :: 1;
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_TYPE :: Layer_Data_Type.Int32;
|
||||
CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_NAME :: "neighbour";
|
||||
CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE :: Layer_Data_Type.Int32;
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_NAME :: "vertex"
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_ID :: 0
|
||||
CONVENTION_HARD_BASE_VERTEX_LAYER_COMPONENTS :: 3
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_NAME :: "reference"
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_ID :: 0
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_COMPONENTS :: 1
|
||||
CONVENTION_HARD_BASE_CORNER_LAYER_TYPE :: Layer_Data_Type.Int32
|
||||
CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_NAME :: "neighbour"
|
||||
CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE :: Layer_Data_Type.Int32
|
||||
|
||||
|
||||
|
||||
@@ -131,63 +131,63 @@ CONVENTION_HARD_EDGE_NEIGHBOUR_LAYER_TYPE :: Layer_Data_Type.Int32;
|
||||
|
||||
/* geometry layers */
|
||||
|
||||
CONVENTION_SOFT_LAYER_SEQUENCE0 :: "sequence";
|
||||
CONVENTION_SOFT_LAYER_NAME_UV0 :: "uv";
|
||||
CONVENTION_SOFT_LAYER_NORMALS :: "normal";
|
||||
CONVENTION_SOFT_LAYER_BINORMAL :: "binormal";
|
||||
CONVENTION_SOFT_LAYER_TANGENT :: "tangent";
|
||||
CONVENTION_SOFT_LAYER_COLOR :: "color";
|
||||
CONVENTION_SOFT_LAYER_CREASES :: "creases";
|
||||
CONVENTION_SOFT_LAYER_SELECTION :: "select";
|
||||
CONVENTION_SOFT_LAYER_SKIN_WEIGHT :: "skining_weight";
|
||||
CONVENTION_SOFT_LAYER_SKIN_REFERENCE :: "skining_reference";
|
||||
CONVENTION_SOFT_LAYER_BLENDSHAPE :: "blendshape";
|
||||
CONVENTION_SOFT_LAYER_ADD_BLENDSHAPE :: "addblendshape";
|
||||
CONVENTION_SOFT_LAYER_MATERIAL_ID :: "material";
|
||||
CONVENTION_SOFT_LAYER_SEQUENCE0 :: "sequence"
|
||||
CONVENTION_SOFT_LAYER_NAME_UV0 :: "uv"
|
||||
CONVENTION_SOFT_LAYER_NORMALS :: "normal"
|
||||
CONVENTION_SOFT_LAYER_BINORMAL :: "binormal"
|
||||
CONVENTION_SOFT_LAYER_TANGENT :: "tangent"
|
||||
CONVENTION_SOFT_LAYER_COLOR :: "color"
|
||||
CONVENTION_SOFT_LAYER_CREASES :: "creases"
|
||||
CONVENTION_SOFT_LAYER_SELECTION :: "select"
|
||||
CONVENTION_SOFT_LAYER_SKIN_WEIGHT :: "skining_weight"
|
||||
CONVENTION_SOFT_LAYER_SKIN_REFERENCE :: "skining_reference"
|
||||
CONVENTION_SOFT_LAYER_BLENDSHAPE :: "blendshape"
|
||||
CONVENTION_SOFT_LAYER_ADD_BLENDSHAPE :: "addblendshape"
|
||||
CONVENTION_SOFT_LAYER_MATERIAL_ID :: "material"
|
||||
|
||||
/* Image layers */
|
||||
|
||||
CONVENTION_SOFT_ALBEDO :: "albedo";
|
||||
CONVENTION_SOFT_LIGHT :: "light";
|
||||
CONVENTION_SOFT_DISPLACEMENT :: "displacement";
|
||||
CONVENTION_SOFT_DISTORTION :: "distortion";
|
||||
CONVENTION_SOFT_AMBIENT_OCCLUSION :: "ambient_occlusion";
|
||||
CONVENTION_SOFT_ALBEDO :: "albedo"
|
||||
CONVENTION_SOFT_LIGHT :: "light"
|
||||
CONVENTION_SOFT_DISPLACEMENT :: "displacement"
|
||||
CONVENTION_SOFT_DISTORTION :: "distortion"
|
||||
CONVENTION_SOFT_AMBIENT_OCCLUSION :: "ambient_occlusion"
|
||||
|
||||
/* tags layers */
|
||||
|
||||
CONVENTION_SOFT_NAME :: "name";
|
||||
CONVENTION_SOFT_TRANSFORM :: "transform";
|
||||
CONVENTION_SOFT_NAME :: "name"
|
||||
CONVENTION_SOFT_TRANSFORM :: "transform"
|
||||
|
||||
/* destroy procedures */
|
||||
|
||||
meta_destroy :: proc(meta: Meta, allocator := context.allocator) {
|
||||
if nested, ok := meta.value.([]Meta); ok {
|
||||
for m in nested {
|
||||
meta_destroy(m);
|
||||
meta_destroy(m)
|
||||
}
|
||||
delete(nested, allocator);
|
||||
delete(nested, allocator)
|
||||
}
|
||||
}
|
||||
nodes_destroy :: proc(nodes: []Node, allocator := context.allocator) {
|
||||
for node in nodes {
|
||||
for meta in node.meta_data {
|
||||
meta_destroy(meta);
|
||||
meta_destroy(meta)
|
||||
}
|
||||
delete(node.meta_data, allocator);
|
||||
delete(node.meta_data, allocator)
|
||||
|
||||
switch n in node.content {
|
||||
case Node_Geometry:
|
||||
delete(n.corner_stack, allocator);
|
||||
delete(n.edge_stack, allocator);
|
||||
delete(n.face_stack, allocator);
|
||||
delete(n.corner_stack, allocator)
|
||||
delete(n.edge_stack, allocator)
|
||||
delete(n.face_stack, allocator)
|
||||
case Node_Image:
|
||||
delete(n.image_stack, allocator);
|
||||
delete(n.image_stack, allocator)
|
||||
}
|
||||
}
|
||||
delete(nodes, allocator);
|
||||
delete(nodes, allocator)
|
||||
}
|
||||
|
||||
file_destroy :: proc(file: File) {
|
||||
nodes_destroy(file.nodes, file.allocator);
|
||||
delete(file.backing, file.allocator);
|
||||
nodes_destroy(file.nodes, file.allocator)
|
||||
delete(file.backing, file.allocator)
|
||||
}
|
||||
|
||||
+101
-101
@@ -12,20 +12,20 @@ Read_Error :: enum {
|
||||
}
|
||||
|
||||
read_from_file :: proc(filename: string, print_error := false, allocator := context.allocator) -> (file: File, err: Read_Error) {
|
||||
context.allocator = allocator;
|
||||
context.allocator = allocator
|
||||
|
||||
data, ok := os.read_entire_file(filename);
|
||||
data, ok := os.read_entire_file(filename)
|
||||
if !ok {
|
||||
err = .Unable_To_Read_File;
|
||||
return;
|
||||
err = .Unable_To_Read_File
|
||||
return
|
||||
}
|
||||
defer if !ok {
|
||||
delete(data);
|
||||
delete(data)
|
||||
} else {
|
||||
file.backing = data;
|
||||
file.backing = data
|
||||
}
|
||||
file, err = read(data, filename, print_error, allocator);
|
||||
return;
|
||||
file, err = read(data, filename, print_error, allocator)
|
||||
return
|
||||
}
|
||||
|
||||
read :: proc(data: []byte, filename := "<input>", print_error := false, allocator := context.allocator) -> (file: File, err: Read_Error) {
|
||||
@@ -34,182 +34,182 @@ read :: proc(data: []byte, filename := "<input>", print_error := false, allocato
|
||||
data: []byte,
|
||||
offset: int,
|
||||
print_error: bool,
|
||||
};
|
||||
}
|
||||
|
||||
read_value :: proc(r: ^Reader, $T: typeid) -> (value: T, err: Read_Error) {
|
||||
remaining := len(r.data) - r.offset;
|
||||
remaining := len(r.data) - r.offset
|
||||
if remaining < size_of(T) {
|
||||
err = .Short_Read;
|
||||
return;
|
||||
err = .Short_Read
|
||||
return
|
||||
}
|
||||
ptr := raw_data(r.data[r.offset:]);
|
||||
value = (^T)(ptr)^;
|
||||
r.offset += size_of(T);
|
||||
return;
|
||||
ptr := raw_data(r.data[r.offset:])
|
||||
value = (^T)(ptr)^
|
||||
r.offset += size_of(T)
|
||||
return
|
||||
}
|
||||
|
||||
read_array :: proc(r: ^Reader, $T: typeid, count: int) -> (value: []T, err: Read_Error) {
|
||||
remaining := len(r.data) - r.offset;
|
||||
remaining := len(r.data) - r.offset
|
||||
if remaining < size_of(T)*count {
|
||||
err = .Short_Read;
|
||||
return;
|
||||
err = .Short_Read
|
||||
return
|
||||
}
|
||||
ptr := raw_data(r.data[r.offset:]);
|
||||
ptr := raw_data(r.data[r.offset:])
|
||||
|
||||
value = mem.slice_ptr((^T)(ptr), count);
|
||||
r.offset += size_of(T)*count;
|
||||
return;
|
||||
value = mem.slice_ptr((^T)(ptr), count)
|
||||
r.offset += size_of(T)*count
|
||||
return
|
||||
}
|
||||
|
||||
read_string :: proc(r: ^Reader, count: int) -> (string, Read_Error) {
|
||||
buf, err := read_array(r, byte, count);
|
||||
return string(buf), err;
|
||||
buf, err := read_array(r, byte, count)
|
||||
return string(buf), err
|
||||
}
|
||||
|
||||
read_name :: proc(r: ^Reader) -> (value: string, err: Read_Error) {
|
||||
len := read_value(r, u8) or_return;
|
||||
data := read_array(r, byte, int(len)) or_return;
|
||||
return string(data[:len]), nil;
|
||||
len := read_value(r, u8) or_return
|
||||
data := read_array(r, byte, int(len)) or_return
|
||||
return string(data[:len]), nil
|
||||
}
|
||||
|
||||
read_meta :: proc(r: ^Reader, capacity: u32le) -> (meta_data: []Meta, err: Read_Error) {
|
||||
meta_data = make([]Meta, int(capacity));
|
||||
count := 0;
|
||||
defer meta_data = meta_data[:count];
|
||||
meta_data = make([]Meta, int(capacity))
|
||||
count := 0
|
||||
defer meta_data = meta_data[:count]
|
||||
for m in &meta_data {
|
||||
m.name = read_name(r) or_return;
|
||||
m.name = read_name(r) or_return
|
||||
|
||||
type := read_value(r, Meta_Value_Type) or_return;
|
||||
type := read_value(r, Meta_Value_Type) or_return
|
||||
if type > max(Meta_Value_Type) {
|
||||
if r.print_error {
|
||||
fmt.eprintf("HxA Error: file '%s' has meta value type %d. Maximum value is ", r.filename, u8(type), u8(max(Meta_Value_Type)));
|
||||
fmt.eprintf("HxA Error: file '%s' has meta value type %d. Maximum value is ", r.filename, u8(type), u8(max(Meta_Value_Type)))
|
||||
}
|
||||
err = .Invalid_Data;
|
||||
return;
|
||||
err = .Invalid_Data
|
||||
return
|
||||
}
|
||||
array_length := read_value(r, u32le) or_return;
|
||||
array_length := read_value(r, u32le) or_return
|
||||
|
||||
switch type {
|
||||
case .Int64: m.value = read_array(r, i64le, int(array_length)) or_return;
|
||||
case .Double: m.value = read_array(r, f64le, int(array_length)) or_return;
|
||||
case .Node: m.value = read_array(r, Node_Index, int(array_length)) or_return;
|
||||
case .Text: m.value = read_string(r, int(array_length)) or_return;
|
||||
case .Binary: m.value = read_array(r, byte, int(array_length)) or_return;
|
||||
case .Meta: m.value = read_meta(r, array_length) or_return;
|
||||
case .Int64: m.value = read_array(r, i64le, int(array_length)) or_return
|
||||
case .Double: m.value = read_array(r, f64le, int(array_length)) or_return
|
||||
case .Node: m.value = read_array(r, Node_Index, int(array_length)) or_return
|
||||
case .Text: m.value = read_string(r, int(array_length)) or_return
|
||||
case .Binary: m.value = read_array(r, byte, int(array_length)) or_return
|
||||
case .Meta: m.value = read_meta(r, array_length) or_return
|
||||
}
|
||||
|
||||
count += 1;
|
||||
count += 1
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
read_layer_stack :: proc(r: ^Reader, capacity: u32le) -> (layers: Layer_Stack, err: Read_Error) {
|
||||
stack_count := read_value(r, u32le) or_return;
|
||||
layer_count := 0;
|
||||
layers = make(Layer_Stack, stack_count);
|
||||
defer layers = layers[:layer_count];
|
||||
stack_count := read_value(r, u32le) or_return
|
||||
layer_count := 0
|
||||
layers = make(Layer_Stack, stack_count)
|
||||
defer layers = layers[:layer_count]
|
||||
for layer in &layers {
|
||||
layer.name = read_name(r) or_return;
|
||||
layer.components = read_value(r, u8) or_return;
|
||||
type := read_value(r, Layer_Data_Type) or_return;
|
||||
layer.name = read_name(r) or_return
|
||||
layer.components = read_value(r, u8) or_return
|
||||
type := read_value(r, Layer_Data_Type) or_return
|
||||
if type > max(type) {
|
||||
if r.print_error {
|
||||
fmt.eprintf("HxA Error: file '%s' has layer data type %d. Maximum value is ", r.filename, u8(type), u8(max(Layer_Data_Type)));
|
||||
fmt.eprintf("HxA Error: file '%s' has layer data type %d. Maximum value is ", r.filename, u8(type), u8(max(Layer_Data_Type)))
|
||||
}
|
||||
err = .Invalid_Data;
|
||||
return;
|
||||
err = .Invalid_Data
|
||||
return
|
||||
}
|
||||
data_len := int(layer.components) * int(capacity);
|
||||
data_len := int(layer.components) * int(capacity)
|
||||
|
||||
switch type {
|
||||
case .Uint8: layer.data = read_array(r, u8, data_len) or_return;
|
||||
case .Int32: layer.data = read_array(r, i32le, data_len) or_return;
|
||||
case .Float: layer.data = read_array(r, f32le, data_len) or_return;
|
||||
case .Double: layer.data = read_array(r, f64le, data_len) or_return;
|
||||
case .Uint8: layer.data = read_array(r, u8, data_len) or_return
|
||||
case .Int32: layer.data = read_array(r, i32le, data_len) or_return
|
||||
case .Float: layer.data = read_array(r, f32le, data_len) or_return
|
||||
case .Double: layer.data = read_array(r, f64le, data_len) or_return
|
||||
}
|
||||
layer_count += 1;
|
||||
layer_count += 1
|
||||
}
|
||||
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
if len(data) < size_of(Header) {
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
context.allocator = allocator;
|
||||
context.allocator = allocator
|
||||
|
||||
header := cast(^Header)raw_data(data);
|
||||
assert(header.magic_number == MAGIC_NUMBER);
|
||||
header := cast(^Header)raw_data(data)
|
||||
assert(header.magic_number == MAGIC_NUMBER)
|
||||
|
||||
r := &Reader{
|
||||
filename = filename,
|
||||
data = data[:],
|
||||
offset = size_of(Header),
|
||||
print_error = print_error,
|
||||
};
|
||||
|
||||
node_count := 0;
|
||||
file.nodes = make([]Node, header.internal_node_count);
|
||||
defer if err != nil {
|
||||
nodes_destroy(file.nodes);
|
||||
file.nodes = nil;
|
||||
}
|
||||
defer file.nodes = file.nodes[:node_count];
|
||||
|
||||
node_count := 0
|
||||
file.nodes = make([]Node, header.internal_node_count)
|
||||
defer if err != nil {
|
||||
nodes_destroy(file.nodes)
|
||||
file.nodes = nil
|
||||
}
|
||||
defer file.nodes = file.nodes[:node_count]
|
||||
|
||||
for node_idx in 0..<header.internal_node_count {
|
||||
node := &file.nodes[node_count];
|
||||
type := read_value(r, Node_Type) or_return;
|
||||
node := &file.nodes[node_count]
|
||||
type := read_value(r, Node_Type) or_return
|
||||
if type > max(Node_Type) {
|
||||
if r.print_error {
|
||||
fmt.eprintf("HxA Error: file '%s' has node type %d. Maximum value is ", r.filename, u8(type), u8(max(Node_Type)));
|
||||
fmt.eprintf("HxA Error: file '%s' has node type %d. Maximum value is ", r.filename, u8(type), u8(max(Node_Type)))
|
||||
}
|
||||
err = .Invalid_Data;
|
||||
return;
|
||||
err = .Invalid_Data
|
||||
return
|
||||
}
|
||||
node_count += 1;
|
||||
node_count += 1
|
||||
|
||||
node.meta_data = read_meta(r, read_value(r, u32le) or_return) or_return;
|
||||
node.meta_data = read_meta(r, read_value(r, u32le) or_return) or_return
|
||||
|
||||
switch type {
|
||||
case .Meta_Only:
|
||||
// Okay
|
||||
case .Geometry:
|
||||
g: Node_Geometry;
|
||||
g: Node_Geometry
|
||||
|
||||
g.vertex_count = read_value(r, u32le) or_return;
|
||||
g.vertex_stack = read_layer_stack(r, g.vertex_count) or_return;
|
||||
g.edge_corner_count = read_value(r, u32le) or_return;
|
||||
g.corner_stack = read_layer_stack(r, g.edge_corner_count) or_return;
|
||||
g.vertex_count = read_value(r, u32le) or_return
|
||||
g.vertex_stack = read_layer_stack(r, g.vertex_count) or_return
|
||||
g.edge_corner_count = read_value(r, u32le) or_return
|
||||
g.corner_stack = read_layer_stack(r, g.edge_corner_count) or_return
|
||||
if header.version > 2 {
|
||||
g.edge_stack = read_layer_stack(r, g.edge_corner_count) or_return;
|
||||
g.edge_stack = read_layer_stack(r, g.edge_corner_count) or_return
|
||||
}
|
||||
g.face_count = read_value(r, u32le) or_return;
|
||||
g.face_stack = read_layer_stack(r, g.face_count) or_return;
|
||||
g.face_count = read_value(r, u32le) or_return
|
||||
g.face_stack = read_layer_stack(r, g.face_count) or_return
|
||||
|
||||
node.content = g;
|
||||
node.content = g
|
||||
|
||||
case .Image:
|
||||
img: Node_Image;
|
||||
img: Node_Image
|
||||
|
||||
img.type = read_value(r, Image_Type) or_return;
|
||||
dimensions := int(img.type);
|
||||
img.type = read_value(r, Image_Type) or_return
|
||||
dimensions := int(img.type)
|
||||
if img.type == .Image_Cube {
|
||||
dimensions = 2;
|
||||
dimensions = 2
|
||||
}
|
||||
img.resolution = {1, 1, 1};
|
||||
img.resolution = {1, 1, 1}
|
||||
for d in 0..<dimensions {
|
||||
img.resolution[d] = read_value(r, u32le) or_return;
|
||||
img.resolution[d] = read_value(r, u32le) or_return
|
||||
}
|
||||
size := img.resolution[0]*img.resolution[1]*img.resolution[2];
|
||||
size := img.resolution[0]*img.resolution[1]*img.resolution[2]
|
||||
if img.type == .Image_Cube {
|
||||
size *= 6;
|
||||
size *= 6
|
||||
}
|
||||
img.image_stack = read_layer_stack(r, size) or_return;
|
||||
img.image_stack = read_layer_stack(r, size) or_return
|
||||
|
||||
node.content = img;
|
||||
node.content = img
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
@@ -10,36 +10,36 @@ Write_Error :: enum {
|
||||
}
|
||||
|
||||
write_to_file :: proc(filepath: string, file: File) -> (err: Write_Error) {
|
||||
required := required_write_size(file);
|
||||
buf, alloc_err := make([]byte, required);
|
||||
required := required_write_size(file)
|
||||
buf, alloc_err := make([]byte, required)
|
||||
if alloc_err == .Out_Of_Memory {
|
||||
return .Failed_File_Write;
|
||||
return .Failed_File_Write
|
||||
}
|
||||
defer delete(buf);
|
||||
defer delete(buf)
|
||||
|
||||
write_internal(&Writer{data = buf}, file);
|
||||
write_internal(&Writer{data = buf}, file)
|
||||
if !os.write_entire_file(filepath, buf) {
|
||||
err =.Failed_File_Write;
|
||||
err =.Failed_File_Write
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
write :: proc(buf: []byte, file: File) -> (n: int, err: Write_Error) {
|
||||
required := required_write_size(file);
|
||||
required := required_write_size(file)
|
||||
if len(buf) < required {
|
||||
err = .Buffer_Too_Small;
|
||||
return;
|
||||
err = .Buffer_Too_Small
|
||||
return
|
||||
}
|
||||
n = required;
|
||||
write_internal(&Writer{data = buf}, file);
|
||||
return;
|
||||
n = required
|
||||
write_internal(&Writer{data = buf}, file)
|
||||
return
|
||||
}
|
||||
|
||||
required_write_size :: proc(file: File) -> (n: int) {
|
||||
writer := &Writer{dummy_pass = true};
|
||||
write_internal(writer, file);
|
||||
n = writer.offset;
|
||||
return;
|
||||
writer := &Writer{dummy_pass = true}
|
||||
write_internal(writer, file)
|
||||
n = writer.offset
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -48,146 +48,146 @@ Writer :: struct {
|
||||
data: []byte,
|
||||
offset: int,
|
||||
dummy_pass: bool,
|
||||
};
|
||||
}
|
||||
|
||||
@(private)
|
||||
write_internal :: proc(w: ^Writer, file: File) {
|
||||
write_value :: proc(w: ^Writer, value: $T) {
|
||||
if !w.dummy_pass {
|
||||
remaining := len(w.data) - w.offset;
|
||||
assert(size_of(T) <= remaining);
|
||||
ptr := raw_data(w.data[w.offset:]);
|
||||
(^T)(ptr)^ = value;
|
||||
remaining := len(w.data) - w.offset
|
||||
assert(size_of(T) <= remaining)
|
||||
ptr := raw_data(w.data[w.offset:])
|
||||
(^T)(ptr)^ = value
|
||||
}
|
||||
w.offset += size_of(T);
|
||||
w.offset += size_of(T)
|
||||
}
|
||||
write_array :: proc(w: ^Writer, array: []$T) {
|
||||
if !w.dummy_pass {
|
||||
remaining := len(w.data) - w.offset;
|
||||
assert(size_of(T)*len(array) <= remaining);
|
||||
ptr := raw_data(w.data[w.offset:]);
|
||||
dst := mem.slice_ptr((^T)(ptr), len(array));
|
||||
copy(dst, array);
|
||||
remaining := len(w.data) - w.offset
|
||||
assert(size_of(T)*len(array) <= remaining)
|
||||
ptr := raw_data(w.data[w.offset:])
|
||||
dst := mem.slice_ptr((^T)(ptr), len(array))
|
||||
copy(dst, array)
|
||||
}
|
||||
w.offset += size_of(T)*len(array);
|
||||
w.offset += size_of(T)*len(array)
|
||||
}
|
||||
write_string :: proc(w: ^Writer, str: string) {
|
||||
if !w.dummy_pass {
|
||||
remaining := len(w.data) - w.offset;
|
||||
assert(size_of(byte)*len(str) <= remaining);
|
||||
ptr := raw_data(w.data[w.offset:]);
|
||||
dst := mem.slice_ptr((^byte)(ptr), len(str));
|
||||
copy(dst, str);
|
||||
remaining := len(w.data) - w.offset
|
||||
assert(size_of(byte)*len(str) <= remaining)
|
||||
ptr := raw_data(w.data[w.offset:])
|
||||
dst := mem.slice_ptr((^byte)(ptr), len(str))
|
||||
copy(dst, str)
|
||||
}
|
||||
w.offset += size_of(byte)*len(str);
|
||||
w.offset += size_of(byte)*len(str)
|
||||
}
|
||||
|
||||
write_metadata :: proc(w: ^Writer, meta_data: []Meta) {
|
||||
for m in meta_data {
|
||||
name_len := max(len(m.name), 255);
|
||||
write_value(w, u8(name_len));
|
||||
write_string(w, m.name[:name_len]);
|
||||
name_len := max(len(m.name), 255)
|
||||
write_value(w, u8(name_len))
|
||||
write_string(w, m.name[:name_len])
|
||||
|
||||
meta_data_type: Meta_Value_Type;
|
||||
length: u32le = 0;
|
||||
meta_data_type: Meta_Value_Type
|
||||
length: u32le = 0
|
||||
switch v in m.value {
|
||||
case []i64le:
|
||||
meta_data_type = .Int64;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Int64
|
||||
length = u32le(len(v))
|
||||
case []f64le:
|
||||
meta_data_type = .Double;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Double
|
||||
length = u32le(len(v))
|
||||
case []Node_Index:
|
||||
meta_data_type = .Node;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Node
|
||||
length = u32le(len(v))
|
||||
case string:
|
||||
meta_data_type = .Text;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Text
|
||||
length = u32le(len(v))
|
||||
case []byte:
|
||||
meta_data_type = .Binary;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Binary
|
||||
length = u32le(len(v))
|
||||
case []Meta:
|
||||
meta_data_type = .Meta;
|
||||
length = u32le(len(v));
|
||||
meta_data_type = .Meta
|
||||
length = u32le(len(v))
|
||||
}
|
||||
write_value(w, meta_data_type);
|
||||
write_value(w, length);
|
||||
write_value(w, meta_data_type)
|
||||
write_value(w, length)
|
||||
|
||||
switch v in m.value {
|
||||
case []i64le: write_array(w, v);
|
||||
case []f64le: write_array(w, v);
|
||||
case []Node_Index: write_array(w, v);
|
||||
case string: write_string(w, v);
|
||||
case []byte: write_array(w, v);
|
||||
case []Meta: write_metadata(w, v);
|
||||
case []i64le: write_array(w, v)
|
||||
case []f64le: write_array(w, v)
|
||||
case []Node_Index: write_array(w, v)
|
||||
case string: write_string(w, v)
|
||||
case []byte: write_array(w, v)
|
||||
case []Meta: write_metadata(w, v)
|
||||
}
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
write_layer_stack :: proc(w: ^Writer, layers: Layer_Stack) {
|
||||
write_value(w, u32(len(layers)));
|
||||
write_value(w, u32(len(layers)))
|
||||
for layer in layers {
|
||||
name_len := max(len(layer.name), 255);
|
||||
write_value(w, u8(name_len));
|
||||
write_string(w, layer .name[:name_len]);
|
||||
name_len := max(len(layer.name), 255)
|
||||
write_value(w, u8(name_len))
|
||||
write_string(w, layer .name[:name_len])
|
||||
|
||||
write_value(w, layer.components);
|
||||
write_value(w, layer.components)
|
||||
|
||||
layer_data_type: Layer_Data_Type;
|
||||
layer_data_type: Layer_Data_Type
|
||||
switch v in layer.data {
|
||||
case []u8: layer_data_type = .Uint8;
|
||||
case []i32le: layer_data_type = .Int32;
|
||||
case []f32le: layer_data_type = .Float;
|
||||
case []f64le: layer_data_type = .Double;
|
||||
case []u8: layer_data_type = .Uint8
|
||||
case []i32le: layer_data_type = .Int32
|
||||
case []f32le: layer_data_type = .Float
|
||||
case []f64le: layer_data_type = .Double
|
||||
}
|
||||
write_value(w, layer_data_type);
|
||||
write_value(w, layer_data_type)
|
||||
|
||||
switch v in layer.data {
|
||||
case []u8: write_array(w, v);
|
||||
case []i32le: write_array(w, v);
|
||||
case []f32le: write_array(w, v);
|
||||
case []f64le: write_array(w, v);
|
||||
case []u8: write_array(w, v)
|
||||
case []i32le: write_array(w, v)
|
||||
case []f32le: write_array(w, v)
|
||||
case []f64le: write_array(w, v)
|
||||
}
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
write_value(w, &Header{
|
||||
magic_number = MAGIC_NUMBER,
|
||||
version = LATEST_VERSION,
|
||||
internal_node_count = u32le(len(file.nodes)),
|
||||
});
|
||||
})
|
||||
|
||||
for node in file.nodes {
|
||||
node_type: Node_Type;
|
||||
node_type: Node_Type
|
||||
switch content in node.content {
|
||||
case Node_Geometry: node_type = .Geometry;
|
||||
case Node_Image: node_type = .Image;
|
||||
case Node_Geometry: node_type = .Geometry
|
||||
case Node_Image: node_type = .Image
|
||||
}
|
||||
write_value(w, node_type);
|
||||
write_value(w, node_type)
|
||||
|
||||
write_value(w, u32(len(node.meta_data)));
|
||||
write_metadata(w, node.meta_data);
|
||||
write_value(w, u32(len(node.meta_data)))
|
||||
write_metadata(w, node.meta_data)
|
||||
|
||||
switch content in node.content {
|
||||
case Node_Geometry:
|
||||
write_value(w, content.vertex_count);
|
||||
write_layer_stack(w, content.vertex_stack);
|
||||
write_value(w, content.edge_corner_count);
|
||||
write_layer_stack(w, content.corner_stack);
|
||||
write_layer_stack(w, content.edge_stack);
|
||||
write_value(w, content.face_count);
|
||||
write_layer_stack(w, content.face_stack);
|
||||
write_value(w, content.vertex_count)
|
||||
write_layer_stack(w, content.vertex_stack)
|
||||
write_value(w, content.edge_corner_count)
|
||||
write_layer_stack(w, content.corner_stack)
|
||||
write_layer_stack(w, content.edge_stack)
|
||||
write_value(w, content.face_count)
|
||||
write_layer_stack(w, content.face_stack)
|
||||
case Node_Image:
|
||||
write_value(w, content.type);
|
||||
dimensions := int(content.type);
|
||||
write_value(w, content.type)
|
||||
dimensions := int(content.type)
|
||||
if content.type == .Image_Cube {
|
||||
dimensions = 2;
|
||||
dimensions = 2
|
||||
}
|
||||
for d in 0..<dimensions {
|
||||
write_value(w, content.resolution[d]);
|
||||
write_value(w, content.resolution[d])
|
||||
}
|
||||
write_layer_stack(w, content.image_stack);
|
||||
write_layer_stack(w, content.image_stack)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+153
-153
@@ -13,305 +13,305 @@ Marshal_Error :: enum {
|
||||
}
|
||||
|
||||
marshal :: proc(v: any, allocator := context.allocator) -> ([]byte, Marshal_Error) {
|
||||
b: strings.Builder;
|
||||
strings.init_builder(&b, allocator);
|
||||
b: strings.Builder
|
||||
strings.init_builder(&b, allocator)
|
||||
|
||||
err := marshal_arg(&b, v);
|
||||
err := marshal_arg(&b, v)
|
||||
|
||||
if err != .None {
|
||||
strings.destroy_builder(&b);
|
||||
return nil, err;
|
||||
strings.destroy_builder(&b)
|
||||
return nil, err
|
||||
}
|
||||
if len(b.buf) == 0 {
|
||||
strings.destroy_builder(&b);
|
||||
return nil, err;
|
||||
strings.destroy_builder(&b)
|
||||
return nil, err
|
||||
}
|
||||
return b.buf[:], err;
|
||||
return b.buf[:], err
|
||||
}
|
||||
|
||||
|
||||
marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
|
||||
if v == nil {
|
||||
strings.write_string(b, "null");
|
||||
return .None;
|
||||
strings.write_string(b, "null")
|
||||
return .None
|
||||
}
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(v.id));
|
||||
a := any{v.data, ti.id};
|
||||
ti := runtime.type_info_base(type_info_of(v.id))
|
||||
a := any{v.data, ti.id}
|
||||
|
||||
switch info in ti.variant {
|
||||
case runtime.Type_Info_Named:
|
||||
unreachable();
|
||||
unreachable()
|
||||
|
||||
case runtime.Type_Info_Integer:
|
||||
buf: [21]byte;
|
||||
u: u64;
|
||||
buf: [21]byte
|
||||
u: u64
|
||||
switch i in a {
|
||||
case i8: u = u64(i);
|
||||
case i16: u = u64(i);
|
||||
case i32: u = u64(i);
|
||||
case i64: u = u64(i);
|
||||
case int: u = u64(i);
|
||||
case u8: u = u64(i);
|
||||
case u16: u = u64(i);
|
||||
case u32: u = u64(i);
|
||||
case u64: u = u64(i);
|
||||
case uint: u = u64(i);
|
||||
case uintptr: u = u64(i);
|
||||
case i8: u = u64(i)
|
||||
case i16: u = u64(i)
|
||||
case i32: u = u64(i)
|
||||
case i64: u = u64(i)
|
||||
case int: u = u64(i)
|
||||
case u8: u = u64(i)
|
||||
case u16: u = u64(i)
|
||||
case u32: u = u64(i)
|
||||
case u64: u = u64(i)
|
||||
case uint: u = u64(i)
|
||||
case uintptr: u = u64(i)
|
||||
|
||||
case i16le: u = u64(i);
|
||||
case i32le: u = u64(i);
|
||||
case i64le: u = u64(i);
|
||||
case u16le: u = u64(i);
|
||||
case u32le: u = u64(i);
|
||||
case u64le: u = u64(i);
|
||||
case i16le: u = u64(i)
|
||||
case i32le: u = u64(i)
|
||||
case i64le: u = u64(i)
|
||||
case u16le: u = u64(i)
|
||||
case u32le: u = u64(i)
|
||||
case u64le: u = u64(i)
|
||||
|
||||
case i16be: u = u64(i);
|
||||
case i32be: u = u64(i);
|
||||
case i64be: u = u64(i);
|
||||
case u16be: u = u64(i);
|
||||
case u32be: u = u64(i);
|
||||
case u64be: u = u64(i);
|
||||
case i16be: u = u64(i)
|
||||
case i32be: u = u64(i)
|
||||
case i64be: u = u64(i)
|
||||
case u16be: u = u64(i)
|
||||
case u32be: u = u64(i)
|
||||
case u64be: u = u64(i)
|
||||
}
|
||||
|
||||
s := strconv.append_bits(buf[:], u, 10, info.signed, 8*ti.size, "0123456789", nil);
|
||||
strings.write_string(b, s);
|
||||
s := strconv.append_bits(buf[:], u, 10, info.signed, 8*ti.size, "0123456789", nil)
|
||||
strings.write_string(b, s)
|
||||
|
||||
|
||||
case runtime.Type_Info_Rune:
|
||||
r := a.(rune);
|
||||
strings.write_byte(b, '"');
|
||||
strings.write_escaped_rune(b, r, '"', true);
|
||||
strings.write_byte(b, '"');
|
||||
r := a.(rune)
|
||||
strings.write_byte(b, '"')
|
||||
strings.write_escaped_rune(b, r, '"', true)
|
||||
strings.write_byte(b, '"')
|
||||
|
||||
case runtime.Type_Info_Float:
|
||||
val: f64;
|
||||
val: f64
|
||||
switch f in a {
|
||||
case f16: val = f64(f);
|
||||
case f32: val = f64(f);
|
||||
case f64: val = f64(f);
|
||||
case f16: val = f64(f)
|
||||
case f32: val = f64(f)
|
||||
case f64: val = f64(f)
|
||||
}
|
||||
|
||||
buf: [386]byte;
|
||||
buf: [386]byte
|
||||
|
||||
str := strconv.append_float(buf[1:], val, 'f', 2*ti.size, 8*ti.size);
|
||||
s := buf[:len(str)+1];
|
||||
str := strconv.append_float(buf[1:], val, 'f', 2*ti.size, 8*ti.size)
|
||||
s := buf[:len(str)+1]
|
||||
if s[1] == '+' || s[1] == '-' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
} else {
|
||||
s[0] = '+';
|
||||
s[0] = '+'
|
||||
}
|
||||
if s[0] == '+' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
}
|
||||
|
||||
strings.write_string(b, string(s));
|
||||
strings.write_string(b, string(s))
|
||||
|
||||
case runtime.Type_Info_Complex:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Quaternion:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_String:
|
||||
switch s in a {
|
||||
case string: strings.write_quoted_string(b, s);
|
||||
case cstring: strings.write_quoted_string(b, string(s));
|
||||
case string: strings.write_quoted_string(b, s)
|
||||
case cstring: strings.write_quoted_string(b, string(s))
|
||||
}
|
||||
|
||||
case runtime.Type_Info_Boolean:
|
||||
val: bool;
|
||||
val: bool
|
||||
switch b in a {
|
||||
case bool: val = bool(b);
|
||||
case b8: val = bool(b);
|
||||
case b16: val = bool(b);
|
||||
case b32: val = bool(b);
|
||||
case b64: val = bool(b);
|
||||
case bool: val = bool(b)
|
||||
case b8: val = bool(b)
|
||||
case b16: val = bool(b)
|
||||
case b32: val = bool(b)
|
||||
case b64: val = bool(b)
|
||||
}
|
||||
strings.write_string(b, val ? "true" : "false");
|
||||
strings.write_string(b, val ? "true" : "false")
|
||||
|
||||
case runtime.Type_Info_Any:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Type_Id:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Pointer:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Multi_Pointer:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Procedure:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Tuple:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Enumerated_Array:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Simd_Vector:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Relative_Pointer:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Relative_Slice:
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
|
||||
case runtime.Type_Info_Array:
|
||||
strings.write_byte(b, '[');
|
||||
strings.write_byte(b, '[')
|
||||
for i in 0..<info.count {
|
||||
if i > 0 { strings.write_string(b, ", "); }
|
||||
|
||||
data := uintptr(v.data) + uintptr(i*info.elem_size);
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id});
|
||||
data := uintptr(v.data) + uintptr(i*info.elem_size)
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id})
|
||||
}
|
||||
strings.write_byte(b, ']');
|
||||
strings.write_byte(b, ']')
|
||||
|
||||
case runtime.Type_Info_Dynamic_Array:
|
||||
strings.write_byte(b, '[');
|
||||
array := cast(^mem.Raw_Dynamic_Array)v.data;
|
||||
strings.write_byte(b, '[')
|
||||
array := cast(^mem.Raw_Dynamic_Array)v.data
|
||||
for i in 0..<array.len {
|
||||
if i > 0 { strings.write_string(b, ", "); }
|
||||
|
||||
data := uintptr(array.data) + uintptr(i*info.elem_size);
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id});
|
||||
data := uintptr(array.data) + uintptr(i*info.elem_size)
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id})
|
||||
}
|
||||
strings.write_byte(b, ']');
|
||||
strings.write_byte(b, ']')
|
||||
|
||||
case runtime.Type_Info_Slice:
|
||||
strings.write_byte(b, '[');
|
||||
slice := cast(^mem.Raw_Slice)v.data;
|
||||
strings.write_byte(b, '[')
|
||||
slice := cast(^mem.Raw_Slice)v.data
|
||||
for i in 0..<slice.len {
|
||||
if i > 0 { strings.write_string(b, ", "); }
|
||||
|
||||
data := uintptr(slice.data) + uintptr(i*info.elem_size);
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id});
|
||||
data := uintptr(slice.data) + uintptr(i*info.elem_size)
|
||||
marshal_arg(b, any{rawptr(data), info.elem.id})
|
||||
}
|
||||
strings.write_byte(b, ']');
|
||||
strings.write_byte(b, ']')
|
||||
|
||||
case runtime.Type_Info_Map:
|
||||
m := (^mem.Raw_Map)(v.data);
|
||||
m := (^mem.Raw_Map)(v.data)
|
||||
|
||||
strings.write_byte(b, '{');
|
||||
strings.write_byte(b, '{')
|
||||
if m != nil {
|
||||
if info.generated_struct == nil {
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
}
|
||||
entries := &m.entries;
|
||||
gs := runtime.type_info_base(info.generated_struct).variant.(runtime.Type_Info_Struct);
|
||||
ed := runtime.type_info_base(gs.types[1]).variant.(runtime.Type_Info_Dynamic_Array);
|
||||
entry_type := ed.elem.variant.(runtime.Type_Info_Struct);
|
||||
entry_size := ed.elem_size;
|
||||
entries := &m.entries
|
||||
gs := runtime.type_info_base(info.generated_struct).variant.(runtime.Type_Info_Struct)
|
||||
ed := runtime.type_info_base(gs.types[1]).variant.(runtime.Type_Info_Dynamic_Array)
|
||||
entry_type := ed.elem.variant.(runtime.Type_Info_Struct)
|
||||
entry_size := ed.elem_size
|
||||
|
||||
for i in 0..<entries.len {
|
||||
if i > 0 { strings.write_string(b, ", "); }
|
||||
|
||||
data := uintptr(entries.data) + uintptr(i*entry_size);
|
||||
key := rawptr(data + entry_type.offsets[2]);
|
||||
value := rawptr(data + entry_type.offsets[3]);
|
||||
data := uintptr(entries.data) + uintptr(i*entry_size)
|
||||
key := rawptr(data + entry_type.offsets[2])
|
||||
value := rawptr(data + entry_type.offsets[3])
|
||||
|
||||
marshal_arg(b, any{key, info.key.id});
|
||||
strings.write_string(b, ": ");
|
||||
marshal_arg(b, any{value, info.value.id});
|
||||
marshal_arg(b, any{key, info.key.id})
|
||||
strings.write_string(b, ": ")
|
||||
marshal_arg(b, any{value, info.value.id})
|
||||
}
|
||||
}
|
||||
strings.write_byte(b, '}');
|
||||
strings.write_byte(b, '}')
|
||||
|
||||
case runtime.Type_Info_Struct:
|
||||
strings.write_byte(b, '{');
|
||||
strings.write_byte(b, '{')
|
||||
for name, i in info.names {
|
||||
if i > 0 { strings.write_string(b, ", "); }
|
||||
strings.write_quoted_string(b, name);
|
||||
strings.write_string(b, ": ");
|
||||
strings.write_quoted_string(b, name)
|
||||
strings.write_string(b, ": ")
|
||||
|
||||
id := info.types[i].id;
|
||||
data := rawptr(uintptr(v.data) + info.offsets[i]);
|
||||
marshal_arg(b, any{data, id});
|
||||
id := info.types[i].id
|
||||
data := rawptr(uintptr(v.data) + info.offsets[i])
|
||||
marshal_arg(b, any{data, id})
|
||||
}
|
||||
strings.write_byte(b, '}');
|
||||
strings.write_byte(b, '}')
|
||||
|
||||
case runtime.Type_Info_Union:
|
||||
tag_ptr := uintptr(v.data) + info.tag_offset;
|
||||
tag_any := any{rawptr(tag_ptr), info.tag_type.id};
|
||||
tag_ptr := uintptr(v.data) + info.tag_offset
|
||||
tag_any := any{rawptr(tag_ptr), info.tag_type.id}
|
||||
|
||||
tag: i64 = -1;
|
||||
tag: i64 = -1
|
||||
switch i in tag_any {
|
||||
case u8: tag = i64(i);
|
||||
case i8: tag = i64(i);
|
||||
case u16: tag = i64(i);
|
||||
case i16: tag = i64(i);
|
||||
case u32: tag = i64(i);
|
||||
case i32: tag = i64(i);
|
||||
case u64: tag = i64(i);
|
||||
case i64: tag = i64(i);
|
||||
case: panic("Invalid union tag type");
|
||||
case u8: tag = i64(i)
|
||||
case i8: tag = i64(i)
|
||||
case u16: tag = i64(i)
|
||||
case i16: tag = i64(i)
|
||||
case u32: tag = i64(i)
|
||||
case i32: tag = i64(i)
|
||||
case u64: tag = i64(i)
|
||||
case i64: tag = i64(i)
|
||||
case: panic("Invalid union tag type")
|
||||
}
|
||||
|
||||
if v.data == nil || tag == 0 {
|
||||
strings.write_string(b, "null");
|
||||
strings.write_string(b, "null")
|
||||
} else {
|
||||
id := info.variants[tag-1].id;
|
||||
marshal_arg(b, any{v.data, id});
|
||||
id := info.variants[tag-1].id
|
||||
marshal_arg(b, any{v.data, id})
|
||||
}
|
||||
|
||||
case runtime.Type_Info_Enum:
|
||||
return marshal_arg(b, any{v.data, info.base.id});
|
||||
return marshal_arg(b, any{v.data, info.base.id})
|
||||
|
||||
case runtime.Type_Info_Bit_Set:
|
||||
is_bit_set_different_endian_to_platform :: proc(ti: ^runtime.Type_Info) -> bool {
|
||||
if ti == nil {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
t := runtime.type_info_base(ti);
|
||||
t := runtime.type_info_base(ti)
|
||||
#partial switch info in t.variant {
|
||||
case runtime.Type_Info_Integer:
|
||||
switch info.endianness {
|
||||
case .Platform: return false;
|
||||
case .Little: return ODIN_ENDIAN != "little";
|
||||
case .Big: return ODIN_ENDIAN != "big";
|
||||
case .Platform: return false
|
||||
case .Little: return ODIN_ENDIAN != "little"
|
||||
case .Big: return ODIN_ENDIAN != "big"
|
||||
}
|
||||
}
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
bit_data: u64;
|
||||
bit_size := u64(8*ti.size);
|
||||
bit_data: u64
|
||||
bit_size := u64(8*ti.size)
|
||||
|
||||
do_byte_swap := is_bit_set_different_endian_to_platform(info.underlying);
|
||||
do_byte_swap := is_bit_set_different_endian_to_platform(info.underlying)
|
||||
|
||||
switch bit_size {
|
||||
case 0: bit_data = 0;
|
||||
case 0: bit_data = 0
|
||||
case 8:
|
||||
x := (^u8)(v.data)^;
|
||||
bit_data = u64(x);
|
||||
x := (^u8)(v.data)^
|
||||
bit_data = u64(x)
|
||||
case 16:
|
||||
x := (^u16)(v.data)^;
|
||||
x := (^u16)(v.data)^
|
||||
if do_byte_swap {
|
||||
x = bits.byte_swap(x);
|
||||
x = bits.byte_swap(x)
|
||||
}
|
||||
bit_data = u64(x);
|
||||
bit_data = u64(x)
|
||||
case 32:
|
||||
x := (^u32)(v.data)^;
|
||||
x := (^u32)(v.data)^
|
||||
if do_byte_swap {
|
||||
x = bits.byte_swap(x);
|
||||
x = bits.byte_swap(x)
|
||||
}
|
||||
bit_data = u64(x);
|
||||
bit_data = u64(x)
|
||||
case 64:
|
||||
x := (^u64)(v.data)^;
|
||||
x := (^u64)(v.data)^
|
||||
if do_byte_swap {
|
||||
x = bits.byte_swap(x);
|
||||
x = bits.byte_swap(x)
|
||||
}
|
||||
bit_data = u64(x);
|
||||
case: panic("unknown bit_size size");
|
||||
bit_data = u64(x)
|
||||
case: panic("unknown bit_size size")
|
||||
}
|
||||
strings.write_u64(b, bit_data);
|
||||
strings.write_u64(b, bit_data)
|
||||
|
||||
|
||||
return .Unsupported_Type;
|
||||
return .Unsupported_Type
|
||||
}
|
||||
|
||||
return .None;
|
||||
return .None
|
||||
}
|
||||
|
||||
+203
-203
@@ -15,235 +15,235 @@ Parser :: struct {
|
||||
}
|
||||
|
||||
make_parser :: proc(data: []byte, spec := Specification.JSON, parse_integers := false, allocator := context.allocator) -> Parser {
|
||||
p: Parser;
|
||||
p.tok = make_tokenizer(data, spec, parse_integers);
|
||||
p.spec = spec;
|
||||
p.allocator = allocator;
|
||||
assert(p.allocator.procedure != nil);
|
||||
advance_token(&p);
|
||||
return p;
|
||||
p: Parser
|
||||
p.tok = make_tokenizer(data, spec, parse_integers)
|
||||
p.spec = spec
|
||||
p.allocator = allocator
|
||||
assert(p.allocator.procedure != nil)
|
||||
advance_token(&p)
|
||||
return p
|
||||
}
|
||||
|
||||
parse :: proc(data: []byte, spec := Specification.JSON, parse_integers := false, allocator := context.allocator) -> (Value, Error) {
|
||||
context.allocator = allocator;
|
||||
p := make_parser(data, spec, parse_integers, allocator);
|
||||
context.allocator = allocator
|
||||
p := make_parser(data, spec, parse_integers, allocator)
|
||||
|
||||
if p.spec == Specification.JSON5 {
|
||||
return parse_value(&p);
|
||||
return parse_value(&p)
|
||||
}
|
||||
return parse_object(&p);
|
||||
return parse_object(&p)
|
||||
}
|
||||
|
||||
token_end_pos :: proc(tok: Token) -> Pos {
|
||||
end := tok.pos;
|
||||
end.offset += len(tok.text);
|
||||
return end;
|
||||
end := tok.pos
|
||||
end.offset += len(tok.text)
|
||||
return end
|
||||
}
|
||||
|
||||
advance_token :: proc(p: ^Parser) -> (Token, Error) {
|
||||
err: Error;
|
||||
p.prev_token = p.curr_token;
|
||||
p.curr_token, err = get_token(&p.tok);
|
||||
return p.prev_token, err;
|
||||
err: Error
|
||||
p.prev_token = p.curr_token
|
||||
p.curr_token, err = get_token(&p.tok)
|
||||
return p.prev_token, err
|
||||
}
|
||||
|
||||
|
||||
allow_token :: proc(p: ^Parser, kind: Token_Kind) -> bool {
|
||||
if p.curr_token.kind == kind {
|
||||
advance_token(p);
|
||||
return true;
|
||||
advance_token(p)
|
||||
return true
|
||||
}
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
expect_token :: proc(p: ^Parser, kind: Token_Kind) -> Error {
|
||||
prev := p.curr_token;
|
||||
advance_token(p);
|
||||
prev := p.curr_token
|
||||
advance_token(p)
|
||||
if prev.kind == kind {
|
||||
return .None;
|
||||
return .None
|
||||
}
|
||||
return .Unexpected_Token;
|
||||
return .Unexpected_Token
|
||||
}
|
||||
|
||||
|
||||
|
||||
parse_value :: proc(p: ^Parser) -> (value: Value, err: Error) {
|
||||
token := p.curr_token;
|
||||
token := p.curr_token
|
||||
#partial switch token.kind {
|
||||
case .Null:
|
||||
value = Null{};
|
||||
advance_token(p);
|
||||
return;
|
||||
value = Null{}
|
||||
advance_token(p)
|
||||
return
|
||||
case .False:
|
||||
value = Boolean(false);
|
||||
advance_token(p);
|
||||
return;
|
||||
value = Boolean(false)
|
||||
advance_token(p)
|
||||
return
|
||||
case .True:
|
||||
value = Boolean(true);
|
||||
advance_token(p);
|
||||
return;
|
||||
value = Boolean(true)
|
||||
advance_token(p)
|
||||
return
|
||||
|
||||
case .Integer:
|
||||
i, _ := strconv.parse_i64(token.text);
|
||||
value = Integer(i);
|
||||
advance_token(p);
|
||||
return;
|
||||
i, _ := strconv.parse_i64(token.text)
|
||||
value = Integer(i)
|
||||
advance_token(p)
|
||||
return
|
||||
case .Float:
|
||||
f, _ := strconv.parse_f64(token.text);
|
||||
value = Float(f);
|
||||
advance_token(p);
|
||||
return;
|
||||
f, _ := strconv.parse_f64(token.text)
|
||||
value = Float(f)
|
||||
advance_token(p)
|
||||
return
|
||||
case .String:
|
||||
value = String(unquote_string(token, p.spec, p.allocator));
|
||||
advance_token(p);
|
||||
return;
|
||||
value = String(unquote_string(token, p.spec, p.allocator))
|
||||
advance_token(p)
|
||||
return
|
||||
|
||||
case .Open_Brace:
|
||||
return parse_object(p);
|
||||
return parse_object(p)
|
||||
|
||||
case .Open_Bracket:
|
||||
return parse_array(p);
|
||||
return parse_array(p)
|
||||
|
||||
case:
|
||||
if p.spec == Specification.JSON5 {
|
||||
#partial switch token.kind {
|
||||
case .Infinity:
|
||||
inf: u64 = 0x7ff0000000000000;
|
||||
inf: u64 = 0x7ff0000000000000
|
||||
if token.text[0] == '-' {
|
||||
inf = 0xfff0000000000000;
|
||||
inf = 0xfff0000000000000
|
||||
}
|
||||
value = transmute(f64)inf;
|
||||
advance_token(p);
|
||||
return;
|
||||
value = transmute(f64)inf
|
||||
advance_token(p)
|
||||
return
|
||||
case .NaN:
|
||||
nan: u64 = 0x7ff7ffffffffffff;
|
||||
nan: u64 = 0x7ff7ffffffffffff
|
||||
if token.text[0] == '-' {
|
||||
nan = 0xfff7ffffffffffff;
|
||||
nan = 0xfff7ffffffffffff
|
||||
}
|
||||
value = transmute(f64)nan;
|
||||
advance_token(p);
|
||||
return;
|
||||
value = transmute(f64)nan
|
||||
advance_token(p)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
err = .Unexpected_Token;
|
||||
advance_token(p);
|
||||
return;
|
||||
err = .Unexpected_Token
|
||||
advance_token(p)
|
||||
return
|
||||
}
|
||||
|
||||
parse_array :: proc(p: ^Parser) -> (value: Value, err: Error) {
|
||||
expect_token(p, .Open_Bracket) or_return;
|
||||
expect_token(p, .Open_Bracket) or_return
|
||||
|
||||
array: Array;
|
||||
array.allocator = p.allocator;
|
||||
array: Array
|
||||
array.allocator = p.allocator
|
||||
defer if err != .None {
|
||||
for elem in array {
|
||||
destroy_value(elem);
|
||||
destroy_value(elem)
|
||||
}
|
||||
delete(array);
|
||||
delete(array)
|
||||
}
|
||||
|
||||
for p.curr_token.kind != .Close_Bracket {
|
||||
elem := parse_value(p) or_return;
|
||||
append(&array, elem);
|
||||
elem := parse_value(p) or_return
|
||||
append(&array, elem)
|
||||
|
||||
// Disallow trailing commas for the time being
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
} else {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
expect_token(p, .Close_Bracket) or_return;
|
||||
value = array;
|
||||
return;
|
||||
expect_token(p, .Close_Bracket) or_return
|
||||
value = array
|
||||
return
|
||||
}
|
||||
|
||||
clone_string :: proc(s: string, allocator: mem.Allocator) -> string {
|
||||
n := len(s);
|
||||
b := make([]byte, n+1, allocator);
|
||||
copy(b, s);
|
||||
b[n] = 0;
|
||||
return string(b[:n]);
|
||||
n := len(s)
|
||||
b := make([]byte, n+1, allocator)
|
||||
copy(b, s)
|
||||
b[n] = 0
|
||||
return string(b[:n])
|
||||
}
|
||||
|
||||
parse_object_key :: proc(p: ^Parser) -> (key: string, err: Error) {
|
||||
tok := p.curr_token;
|
||||
tok := p.curr_token
|
||||
if p.spec == Specification.JSON5 {
|
||||
if tok.kind == .String {
|
||||
expect_token(p, .String);
|
||||
key = unquote_string(tok, p.spec, p.allocator);
|
||||
return;
|
||||
expect_token(p, .String)
|
||||
key = unquote_string(tok, p.spec, p.allocator)
|
||||
return
|
||||
} else if tok.kind == .Ident {
|
||||
expect_token(p, .Ident);
|
||||
key = clone_string(tok.text, p.allocator);
|
||||
return;
|
||||
expect_token(p, .Ident)
|
||||
key = clone_string(tok.text, p.allocator)
|
||||
return
|
||||
}
|
||||
}
|
||||
if tok_err := expect_token(p, .String); tok_err != .None {
|
||||
err = .Expected_String_For_Object_Key;
|
||||
return;
|
||||
err = .Expected_String_For_Object_Key
|
||||
return
|
||||
}
|
||||
key = unquote_string(tok, p.spec, p.allocator);
|
||||
return;
|
||||
key = unquote_string(tok, p.spec, p.allocator)
|
||||
return
|
||||
}
|
||||
|
||||
parse_object :: proc(p: ^Parser) -> (value: Value, err: Error) {
|
||||
expect_token(p, .Open_Brace) or_return;
|
||||
expect_token(p, .Open_Brace) or_return
|
||||
|
||||
obj: Object;
|
||||
obj.allocator = p.allocator;
|
||||
obj: Object
|
||||
obj.allocator = p.allocator
|
||||
defer if err != .None {
|
||||
for key, elem in obj {
|
||||
delete(key, p.allocator);
|
||||
destroy_value(elem);
|
||||
delete(key, p.allocator)
|
||||
destroy_value(elem)
|
||||
}
|
||||
delete(obj);
|
||||
delete(obj)
|
||||
}
|
||||
|
||||
for p.curr_token.kind != .Close_Brace {
|
||||
key: string;
|
||||
key, err = parse_object_key(p);
|
||||
key: string
|
||||
key, err = parse_object_key(p)
|
||||
if err != .None {
|
||||
delete(key, p.allocator);
|
||||
return;
|
||||
delete(key, p.allocator)
|
||||
return
|
||||
}
|
||||
|
||||
if colon_err := expect_token(p, .Colon); colon_err != .None {
|
||||
err = .Expected_Colon_After_Key;
|
||||
return;
|
||||
err = .Expected_Colon_After_Key
|
||||
return
|
||||
}
|
||||
|
||||
elem := parse_value(p) or_return;
|
||||
elem := parse_value(p) or_return
|
||||
|
||||
if key in obj {
|
||||
err = .Duplicate_Object_Key;
|
||||
delete(key, p.allocator);
|
||||
return;
|
||||
err = .Duplicate_Object_Key
|
||||
delete(key, p.allocator)
|
||||
return
|
||||
}
|
||||
|
||||
obj[key] = elem;
|
||||
obj[key] = elem
|
||||
|
||||
if p.spec == Specification.JSON5 {
|
||||
// Allow trailing commas
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
// Disallow trailing commas
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
} else {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
expect_token(p, .Close_Brace) or_return;
|
||||
value = obj;
|
||||
return;
|
||||
expect_token(p, .Close_Brace) or_return
|
||||
value = obj
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -251,177 +251,177 @@ parse_object :: proc(p: ^Parser) -> (value: Value, err: Error) {
|
||||
unquote_string :: proc(token: Token, spec: Specification, allocator := context.allocator) -> string {
|
||||
get_u2_rune :: proc(s: string) -> rune {
|
||||
if len(s) < 4 || s[0] != '\\' || s[1] != 'x' {
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
|
||||
r: rune;
|
||||
r: rune
|
||||
for c in s[2:4] {
|
||||
x: rune;
|
||||
x: rune
|
||||
switch c {
|
||||
case '0'..='9': x = c - '0';
|
||||
case 'a'..='f': x = c - 'a' + 10;
|
||||
case 'A'..='F': x = c - 'A' + 10;
|
||||
case: return -1;
|
||||
case '0'..='9': x = c - '0'
|
||||
case 'a'..='f': x = c - 'a' + 10
|
||||
case 'A'..='F': x = c - 'A' + 10
|
||||
case: return -1
|
||||
}
|
||||
r = r*16 + x;
|
||||
r = r*16 + x
|
||||
}
|
||||
return r;
|
||||
return r
|
||||
}
|
||||
get_u4_rune :: proc(s: string) -> rune {
|
||||
if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
|
||||
r: rune;
|
||||
r: rune
|
||||
for c in s[2:6] {
|
||||
x: rune;
|
||||
x: rune
|
||||
switch c {
|
||||
case '0'..='9': x = c - '0';
|
||||
case 'a'..='f': x = c - 'a' + 10;
|
||||
case 'A'..='F': x = c - 'A' + 10;
|
||||
case: return -1;
|
||||
case '0'..='9': x = c - '0'
|
||||
case 'a'..='f': x = c - 'a' + 10
|
||||
case 'A'..='F': x = c - 'A' + 10
|
||||
case: return -1
|
||||
}
|
||||
r = r*16 + x;
|
||||
r = r*16 + x
|
||||
}
|
||||
return r;
|
||||
return r
|
||||
}
|
||||
|
||||
if token.kind != .String {
|
||||
return "";
|
||||
return ""
|
||||
}
|
||||
s := token.text;
|
||||
s := token.text
|
||||
if len(s) <= 2 {
|
||||
return "";
|
||||
return ""
|
||||
}
|
||||
quote := s[0];
|
||||
quote := s[0]
|
||||
if s[0] != s[len(s)-1] {
|
||||
// Invalid string
|
||||
return "";
|
||||
return ""
|
||||
}
|
||||
s = s[1:len(s)-1];
|
||||
s = s[1:len(s)-1]
|
||||
|
||||
i := 0;
|
||||
i := 0
|
||||
for i < len(s) {
|
||||
c := s[i];
|
||||
c := s[i]
|
||||
if c == '\\' || c == quote || c < ' ' {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if c < utf8.RUNE_SELF {
|
||||
i += 1;
|
||||
continue;
|
||||
i += 1
|
||||
continue
|
||||
}
|
||||
r, w := utf8.decode_rune_in_string(s);
|
||||
r, w := utf8.decode_rune_in_string(s)
|
||||
if r == utf8.RUNE_ERROR && w == 1 {
|
||||
break;
|
||||
break
|
||||
}
|
||||
i += w;
|
||||
i += w
|
||||
}
|
||||
if i == len(s) {
|
||||
return clone_string(s, allocator);
|
||||
return clone_string(s, allocator)
|
||||
}
|
||||
|
||||
b := make([]byte, len(s) + 2*utf8.UTF_MAX, allocator);
|
||||
w := copy(b, s[0:i]);
|
||||
b := make([]byte, len(s) + 2*utf8.UTF_MAX, allocator)
|
||||
w := copy(b, s[0:i])
|
||||
loop: for i < len(s) {
|
||||
c := s[i];
|
||||
c := s[i]
|
||||
switch {
|
||||
case c == '\\':
|
||||
i += 1;
|
||||
i += 1
|
||||
if i >= len(s) {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
switch s[i] {
|
||||
case: break loop;
|
||||
case: break loop
|
||||
case '"', '\'', '\\', '/':
|
||||
b[w] = s[i];
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = s[i]
|
||||
i += 1
|
||||
w += 1
|
||||
|
||||
case 'b':
|
||||
b[w] = '\b';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\b'
|
||||
i += 1
|
||||
w += 1
|
||||
case 'f':
|
||||
b[w] = '\f';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\f'
|
||||
i += 1
|
||||
w += 1
|
||||
case 'r':
|
||||
b[w] = '\r';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\r'
|
||||
i += 1
|
||||
w += 1
|
||||
case 't':
|
||||
b[w] = '\t';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\t'
|
||||
i += 1
|
||||
w += 1
|
||||
case 'n':
|
||||
b[w] = '\n';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\n'
|
||||
i += 1
|
||||
w += 1
|
||||
case 'u':
|
||||
i -= 1; // Include the \u in the check for sanity sake
|
||||
r := get_u4_rune(s[i:]);
|
||||
i -= 1 // Include the \u in the check for sanity sake
|
||||
r := get_u4_rune(s[i:])
|
||||
if r < 0 {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
i += 6;
|
||||
i += 6
|
||||
|
||||
buf, buf_width := utf8.encode_rune(r);
|
||||
copy(b[w:], buf[:buf_width]);
|
||||
w += buf_width;
|
||||
buf, buf_width := utf8.encode_rune(r)
|
||||
copy(b[w:], buf[:buf_width])
|
||||
w += buf_width
|
||||
|
||||
|
||||
case '0':
|
||||
if spec == Specification.JSON5 {
|
||||
b[w] = '\x00';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\x00'
|
||||
i += 1
|
||||
w += 1
|
||||
} else {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
case 'v':
|
||||
if spec == Specification.JSON5 {
|
||||
b[w] = '\v';
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = '\v'
|
||||
i += 1
|
||||
w += 1
|
||||
} else {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
|
||||
case 'x':
|
||||
if spec == Specification.JSON5 {
|
||||
i -= 1; // Include the \x in the check for sanity sake
|
||||
r := get_u2_rune(s[i:]);
|
||||
i -= 1 // Include the \x in the check for sanity sake
|
||||
r := get_u2_rune(s[i:])
|
||||
if r < 0 {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
i += 4;
|
||||
i += 4
|
||||
|
||||
buf, buf_width := utf8.encode_rune(r);
|
||||
copy(b[w:], buf[:buf_width]);
|
||||
w += buf_width;
|
||||
buf, buf_width := utf8.encode_rune(r)
|
||||
copy(b[w:], buf[:buf_width])
|
||||
w += buf_width
|
||||
} else {
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
}
|
||||
|
||||
case c == quote, c < ' ':
|
||||
break loop;
|
||||
break loop
|
||||
|
||||
case c < utf8.RUNE_SELF:
|
||||
b[w] = c;
|
||||
i += 1;
|
||||
w += 1;
|
||||
b[w] = c
|
||||
i += 1
|
||||
w += 1
|
||||
|
||||
case:
|
||||
r, width := utf8.decode_rune_in_string(s[i:]);
|
||||
i += width;
|
||||
r, width := utf8.decode_rune_in_string(s[i:])
|
||||
i += width
|
||||
|
||||
buf, buf_width := utf8.encode_rune(r);
|
||||
assert(buf_width <= width);
|
||||
copy(b[w:], buf[:buf_width]);
|
||||
w += buf_width;
|
||||
buf, buf_width := utf8.encode_rune(r)
|
||||
assert(buf_width <= width)
|
||||
copy(b[w:], buf[:buf_width])
|
||||
w += buf_width
|
||||
}
|
||||
}
|
||||
|
||||
return string(b[:w]);
|
||||
return string(b[:w])
|
||||
}
|
||||
|
||||
+152
-152
@@ -54,22 +54,22 @@ Tokenizer :: struct {
|
||||
|
||||
|
||||
make_tokenizer :: proc(data: []byte, spec := Specification.JSON, parse_integers := false) -> Tokenizer {
|
||||
t := Tokenizer{pos = {line=1}, data = data, spec = spec, parse_integers = parse_integers};
|
||||
next_rune(&t);
|
||||
t := Tokenizer{pos = {line=1}, data = data, spec = spec, parse_integers = parse_integers}
|
||||
next_rune(&t)
|
||||
if t.r == utf8.RUNE_BOM {
|
||||
next_rune(&t);
|
||||
next_rune(&t)
|
||||
}
|
||||
return t;
|
||||
return t
|
||||
}
|
||||
|
||||
next_rune :: proc(t: ^Tokenizer) -> rune #no_bounds_check {
|
||||
if t.offset >= len(t.data) {
|
||||
return utf8.RUNE_EOF;
|
||||
return utf8.RUNE_EOF
|
||||
}
|
||||
t.offset += t.w;
|
||||
t.r, t.w = utf8.decode_rune(t.data[t.offset:]);
|
||||
t.pos.column = t.offset - t.curr_line_offset;
|
||||
return t.r;
|
||||
t.offset += t.w
|
||||
t.r, t.w = utf8.decode_rune(t.data[t.offset:])
|
||||
t.pos.column = t.offset - t.curr_line_offset
|
||||
return t.r
|
||||
}
|
||||
|
||||
|
||||
@@ -79,19 +79,19 @@ get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {
|
||||
if '0' <= t.r && t.r <= '9' {
|
||||
// Okay
|
||||
} else {
|
||||
return;
|
||||
return
|
||||
}
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
}
|
||||
}
|
||||
skip_hex_digits :: proc(t: ^Tokenizer) {
|
||||
for t.offset < len(t.data) {
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
switch t.r {
|
||||
case '0'..='9', 'a'..='f', 'A'..='F':
|
||||
// Okay
|
||||
case:
|
||||
return;
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -99,56 +99,56 @@ get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {
|
||||
scan_espace :: proc(t: ^Tokenizer) -> bool {
|
||||
switch t.r {
|
||||
case '"', '\'', '\\', '/', 'b', 'n', 'r', 't', 'f':
|
||||
next_rune(t);
|
||||
return true;
|
||||
next_rune(t)
|
||||
return true
|
||||
case 'u':
|
||||
// Expect 4 hexadecimal digits
|
||||
for i := 0; i < 4; i += 1 {
|
||||
r := next_rune(t);
|
||||
r := next_rune(t)
|
||||
switch r {
|
||||
case '0'..='9', 'a'..='f', 'A'..='F':
|
||||
// Okay
|
||||
case:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
case:
|
||||
// Ignore the next rune regardless
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
}
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
skip_whitespace :: proc(t: ^Tokenizer) -> rune {
|
||||
loop: for t.offset < len(t.data) {
|
||||
switch t.r {
|
||||
case ' ', '\t', '\v', '\f', '\r':
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
case '\n':
|
||||
t.line += 1;
|
||||
t.curr_line_offset = t.offset;
|
||||
t.pos.column = 1;
|
||||
next_rune(t);
|
||||
t.line += 1
|
||||
t.curr_line_offset = t.offset
|
||||
t.pos.column = 1
|
||||
next_rune(t)
|
||||
case:
|
||||
if t.spec == .JSON5 {
|
||||
switch t.r {
|
||||
case 0x2028, 0x2029, 0xFEFF:
|
||||
next_rune(t);
|
||||
continue loop;
|
||||
next_rune(t)
|
||||
continue loop
|
||||
}
|
||||
}
|
||||
break loop;
|
||||
break loop
|
||||
}
|
||||
}
|
||||
return t.r;
|
||||
return t.r
|
||||
}
|
||||
|
||||
skip_to_next_line :: proc(t: ^Tokenizer) {
|
||||
for t.offset < len(t.data) {
|
||||
r := next_rune(t);
|
||||
r := next_rune(t)
|
||||
if r == '\n' {
|
||||
return;
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -157,53 +157,53 @@ get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {
|
||||
for t.offset < len(t.data) {
|
||||
switch next_rune(t) {
|
||||
case 'A'..='Z', 'a'..='z', '0'..='9', '_':
|
||||
continue;
|
||||
continue
|
||||
}
|
||||
|
||||
return;
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
skip_whitespace(t);
|
||||
skip_whitespace(t)
|
||||
|
||||
token.pos = t.pos;
|
||||
token.pos = t.pos
|
||||
|
||||
token.kind = .Invalid;
|
||||
token.kind = .Invalid
|
||||
|
||||
curr_rune := t.r;
|
||||
next_rune(t);
|
||||
curr_rune := t.r
|
||||
next_rune(t)
|
||||
|
||||
block: switch curr_rune {
|
||||
case utf8.RUNE_ERROR:
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
case utf8.RUNE_EOF, '\x00':
|
||||
token.kind = .EOF;
|
||||
err = .EOF;
|
||||
token.kind = .EOF
|
||||
err = .EOF
|
||||
|
||||
case 'A'..='Z', 'a'..='z', '_':
|
||||
token.kind = .Ident;
|
||||
token.kind = .Ident
|
||||
|
||||
skip_alphanum(t);
|
||||
skip_alphanum(t)
|
||||
|
||||
switch str := string(t.data[token.offset:t.offset]); str {
|
||||
case "null": token.kind = .Null;
|
||||
case "false": token.kind = .False;
|
||||
case "true": token.kind = .True;
|
||||
case "null": token.kind = .Null
|
||||
case "false": token.kind = .False
|
||||
case "true": token.kind = .True
|
||||
case:
|
||||
if t.spec == .JSON5 {
|
||||
switch str {
|
||||
case "Infinity": token.kind = .Infinity;
|
||||
case "NaN": token.kind = .NaN;
|
||||
case "Infinity": token.kind = .Infinity
|
||||
case "NaN": token.kind = .NaN
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
case '+':
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
if t.spec != .JSON5 {
|
||||
break;
|
||||
break
|
||||
}
|
||||
fallthrough;
|
||||
fallthrough
|
||||
|
||||
case '-':
|
||||
switch t.r {
|
||||
@@ -211,281 +211,281 @@ get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {
|
||||
// Okay
|
||||
case:
|
||||
// Illegal use of +/-
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
|
||||
if t.spec == .JSON5 {
|
||||
if t.r == 'I' || t.r == 'N' {
|
||||
skip_alphanum(t);
|
||||
skip_alphanum(t)
|
||||
}
|
||||
switch string(t.data[token.offset:t.offset]) {
|
||||
case "-Infinity": token.kind = .Infinity;
|
||||
case "-NaN": token.kind = .NaN;
|
||||
case "-Infinity": token.kind = .Infinity
|
||||
case "-NaN": token.kind = .NaN
|
||||
}
|
||||
}
|
||||
break block;
|
||||
break block
|
||||
}
|
||||
fallthrough;
|
||||
fallthrough
|
||||
|
||||
case '0'..='9':
|
||||
token.kind = t.parse_integers ? .Integer : .Float;
|
||||
token.kind = t.parse_integers ? .Integer : .Float
|
||||
if t.spec == .JSON5 { // Hexadecimal Numbers
|
||||
if curr_rune == '0' && (t.r == 'x' || t.r == 'X') {
|
||||
next_rune(t);
|
||||
skip_hex_digits(t);
|
||||
break;
|
||||
next_rune(t)
|
||||
skip_hex_digits(t)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
skip_digits(t);
|
||||
skip_digits(t)
|
||||
|
||||
if t.r == '.' {
|
||||
token.kind = .Float;
|
||||
next_rune(t);
|
||||
skip_digits(t);
|
||||
token.kind = .Float
|
||||
next_rune(t)
|
||||
skip_digits(t)
|
||||
}
|
||||
if t.r == 'e' || t.r == 'E' {
|
||||
switch r := next_rune(t); r {
|
||||
case '+', '-':
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
}
|
||||
skip_digits(t);
|
||||
skip_digits(t)
|
||||
}
|
||||
|
||||
str := string(t.data[token.offset:t.offset]);
|
||||
str := string(t.data[token.offset:t.offset])
|
||||
if !is_valid_number(str, t.spec) {
|
||||
err = .Invalid_Number;
|
||||
err = .Invalid_Number
|
||||
}
|
||||
|
||||
case '.':
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
if t.spec == .JSON5 { // Allow leading decimal point
|
||||
skip_digits(t);
|
||||
skip_digits(t)
|
||||
if t.r == 'e' || t.r == 'E' {
|
||||
switch r := next_rune(t); r {
|
||||
case '+', '-':
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
}
|
||||
skip_digits(t);
|
||||
skip_digits(t)
|
||||
}
|
||||
str := string(t.data[token.offset:t.offset]);
|
||||
str := string(t.data[token.offset:t.offset])
|
||||
if !is_valid_number(str, t.spec) {
|
||||
err = .Invalid_Number;
|
||||
err = .Invalid_Number
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
case '\'':
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
if t.spec != .JSON5 {
|
||||
break;
|
||||
break
|
||||
}
|
||||
fallthrough;
|
||||
fallthrough
|
||||
case '"':
|
||||
token.kind = .String;
|
||||
quote := curr_rune;
|
||||
token.kind = .String
|
||||
quote := curr_rune
|
||||
for t.offset < len(t.data) {
|
||||
r := t.r;
|
||||
r := t.r
|
||||
if r == '\n' || r < 0 {
|
||||
err = .String_Not_Terminated;
|
||||
break;
|
||||
err = .String_Not_Terminated
|
||||
break
|
||||
}
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
if r == quote {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if r == '\\' {
|
||||
scan_espace(t);
|
||||
scan_espace(t)
|
||||
}
|
||||
}
|
||||
|
||||
str := string(t.data[token.offset : t.offset]);
|
||||
str := string(t.data[token.offset : t.offset])
|
||||
if !is_valid_string_literal(str, t.spec) {
|
||||
err = .Invalid_String;
|
||||
err = .Invalid_String
|
||||
}
|
||||
|
||||
|
||||
case ',': token.kind = .Comma;
|
||||
case ':': token.kind = .Colon;
|
||||
case '{': token.kind = .Open_Brace;
|
||||
case '}': token.kind = .Close_Brace;
|
||||
case '[': token.kind = .Open_Bracket;
|
||||
case ']': token.kind = .Close_Bracket;
|
||||
case ',': token.kind = .Comma
|
||||
case ':': token.kind = .Colon
|
||||
case '{': token.kind = .Open_Brace
|
||||
case '}': token.kind = .Close_Brace
|
||||
case '[': token.kind = .Open_Bracket
|
||||
case ']': token.kind = .Close_Bracket
|
||||
|
||||
case '/':
|
||||
err = .Illegal_Character;
|
||||
err = .Illegal_Character
|
||||
if t.spec == .JSON5 {
|
||||
switch t.r {
|
||||
case '/':
|
||||
// Single-line comments
|
||||
skip_to_next_line(t);
|
||||
return get_token(t);
|
||||
skip_to_next_line(t)
|
||||
return get_token(t)
|
||||
case '*':
|
||||
// None-nested multi-line comments
|
||||
for t.offset < len(t.data) {
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
if t.r == '*' {
|
||||
next_rune(t);
|
||||
next_rune(t)
|
||||
if t.r == '/' {
|
||||
next_rune(t);
|
||||
return get_token(t);
|
||||
next_rune(t)
|
||||
return get_token(t)
|
||||
}
|
||||
}
|
||||
}
|
||||
err = .EOF;
|
||||
err = .EOF
|
||||
}
|
||||
}
|
||||
|
||||
case: err = .Illegal_Character;
|
||||
case: err = .Illegal_Character
|
||||
}
|
||||
|
||||
token.text = string(t.data[token.offset : t.offset]);
|
||||
token.text = string(t.data[token.offset : t.offset])
|
||||
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
|
||||
is_valid_number :: proc(str: string, spec: Specification) -> bool {
|
||||
s := str;
|
||||
s := str
|
||||
if s == "" {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
if s[0] == '-' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
if s == "" {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
} else if spec == .JSON5 {
|
||||
if s[0] == '+' { // Allow positive sign
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
if s == "" {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch s[0] {
|
||||
case '0':
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
case '1'..='9':
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
}
|
||||
case '.':
|
||||
if spec == .JSON5 { // Allow leading decimal point
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
} else {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
case:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
if spec == .JSON5 {
|
||||
if len(s) == 1 && s[0] == '.' { // Allow trailing decimal point
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
|
||||
s = s[2:];
|
||||
s = s[2:]
|
||||
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
}
|
||||
}
|
||||
|
||||
if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
switch s[0] {
|
||||
case '+', '-':
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
if s == "" {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
|
||||
s = s[1:];
|
||||
s = s[1:]
|
||||
}
|
||||
}
|
||||
|
||||
// The string should be empty now to be valid
|
||||
return s == "";
|
||||
return s == ""
|
||||
}
|
||||
|
||||
is_valid_string_literal :: proc(str: string, spec: Specification) -> bool {
|
||||
s := str;
|
||||
s := str
|
||||
if len(s) < 2 {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
quote := s[0];
|
||||
quote := s[0]
|
||||
if s[0] != s[len(s)-1] {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
if s[0] != '"' || s[len(s)-1] != '"' {
|
||||
if spec == .JSON5 {
|
||||
if s[0] != '\'' || s[len(s)-1] != '\'' {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
s = s[1 : len(s)-1];
|
||||
s = s[1 : len(s)-1]
|
||||
|
||||
i := 0;
|
||||
i := 0
|
||||
for i < len(s) {
|
||||
c := s[i];
|
||||
c := s[i]
|
||||
switch {
|
||||
case c == '\\':
|
||||
i += 1;
|
||||
i += 1
|
||||
if i >= len(s) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
switch s[i] {
|
||||
case '"', '\'', '\\', '/', 'b', 'n', 'r', 't', 'f':
|
||||
i += 1;
|
||||
i += 1
|
||||
case 'u':
|
||||
if i >= len(s) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
hex := s[i+1:];
|
||||
hex := s[i+1:]
|
||||
if len(hex) < 4 {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
hex = hex[:4];
|
||||
i += 5;
|
||||
hex = hex[:4]
|
||||
i += 5
|
||||
|
||||
for j := 0; j < 4; j += 1 {
|
||||
c2 := hex[j];
|
||||
c2 := hex[j]
|
||||
switch c2 {
|
||||
case '0'..='9', 'a'..='z', 'A'..='Z':
|
||||
// Okay
|
||||
case:
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
case: return false;
|
||||
case: return false
|
||||
}
|
||||
|
||||
case c == quote, c < ' ':
|
||||
return false;
|
||||
return false
|
||||
|
||||
case c < utf8.RUNE_SELF:
|
||||
i += 1;
|
||||
i += 1
|
||||
|
||||
case:
|
||||
r, width := utf8.decode_rune_in_string(s[i:]);
|
||||
r, width := utf8.decode_rune_in_string(s[i:])
|
||||
if r == utf8.RUNE_ERROR && width == 1 {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
i += width;
|
||||
i += width
|
||||
}
|
||||
}
|
||||
if i == len(s) {
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
@@ -6,13 +6,13 @@ Specification :: enum {
|
||||
// MJSON, // http://bitsquid.blogspot.com/2009/09/json-configuration-data.html
|
||||
}
|
||||
|
||||
Null :: distinct rawptr;
|
||||
Integer :: i64;
|
||||
Float :: f64;
|
||||
Boolean :: bool;
|
||||
String :: string;
|
||||
Array :: distinct [dynamic]Value;
|
||||
Object :: distinct map[string]Value;
|
||||
Null :: distinct rawptr
|
||||
Integer :: i64
|
||||
Float :: f64
|
||||
Boolean :: bool
|
||||
String :: string
|
||||
Array :: distinct [dynamic]Value
|
||||
Object :: distinct map[string]Value
|
||||
|
||||
Value :: union {
|
||||
Null,
|
||||
@@ -50,17 +50,17 @@ destroy_value :: proc(value: Value) {
|
||||
#partial switch v in value {
|
||||
case Object:
|
||||
for key, elem in v {
|
||||
delete(key);
|
||||
destroy_value(elem);
|
||||
delete(key)
|
||||
destroy_value(elem)
|
||||
}
|
||||
delete(v);
|
||||
delete(v)
|
||||
case Array:
|
||||
for elem in v {
|
||||
destroy_value(elem);
|
||||
destroy_value(elem)
|
||||
}
|
||||
delete(v);
|
||||
delete(v)
|
||||
case String:
|
||||
delete(v);
|
||||
delete(v)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -4,119 +4,119 @@ import "core:mem"
|
||||
|
||||
// NOTE(bill): is_valid will not check for duplicate keys
|
||||
is_valid :: proc(data: []byte, spec := Specification.JSON, parse_integers := false) -> bool {
|
||||
p := make_parser(data, spec, parse_integers, mem.nil_allocator());
|
||||
p := make_parser(data, spec, parse_integers, mem.nil_allocator())
|
||||
if p.spec == Specification.JSON5 {
|
||||
return validate_value(&p);
|
||||
return validate_value(&p)
|
||||
}
|
||||
return validate_object(&p);
|
||||
return validate_object(&p)
|
||||
}
|
||||
|
||||
validate_object_key :: proc(p: ^Parser) -> bool {
|
||||
tok := p.curr_token;
|
||||
tok := p.curr_token
|
||||
if p.spec == Specification.JSON5 {
|
||||
if tok.kind == .String {
|
||||
expect_token(p, .String);
|
||||
return true;
|
||||
expect_token(p, .String)
|
||||
return true
|
||||
} else if tok.kind == .Ident {
|
||||
expect_token(p, .Ident);
|
||||
return true;
|
||||
expect_token(p, .Ident)
|
||||
return true
|
||||
}
|
||||
}
|
||||
err := expect_token(p, .String);
|
||||
return err == Error.None;
|
||||
err := expect_token(p, .String)
|
||||
return err == Error.None
|
||||
}
|
||||
validate_object :: proc(p: ^Parser) -> bool {
|
||||
if err := expect_token(p, .Open_Brace); err != Error.None {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
for p.curr_token.kind != .Close_Brace {
|
||||
if !validate_object_key(p) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
if colon_err := expect_token(p, .Colon); colon_err != Error.None {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
if !validate_value(p) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
if p.spec == Specification.JSON5 {
|
||||
// Allow trailing commas
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
// Disallow trailing commas
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
} else {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if err := expect_token(p, .Close_Brace); err != Error.None {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
validate_array :: proc(p: ^Parser) -> bool {
|
||||
if err := expect_token(p, .Open_Bracket); err != Error.None {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
for p.curr_token.kind != .Close_Bracket {
|
||||
if !validate_value(p) {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
// Disallow trailing commas for the time being
|
||||
if allow_token(p, .Comma) {
|
||||
continue;
|
||||
continue
|
||||
} else {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if err := expect_token(p, .Close_Bracket); err != Error.None {
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
return true;
|
||||
return true
|
||||
}
|
||||
|
||||
validate_value :: proc(p: ^Parser) -> bool {
|
||||
token := p.curr_token;
|
||||
token := p.curr_token
|
||||
|
||||
#partial switch token.kind {
|
||||
case .Null, .False, .True:
|
||||
advance_token(p);
|
||||
return true;
|
||||
advance_token(p)
|
||||
return true
|
||||
case .Integer, .Float:
|
||||
advance_token(p);
|
||||
return true;
|
||||
advance_token(p)
|
||||
return true
|
||||
case .String:
|
||||
advance_token(p);
|
||||
return is_valid_string_literal(token.text, p.spec);
|
||||
advance_token(p)
|
||||
return is_valid_string_literal(token.text, p.spec)
|
||||
|
||||
case .Open_Brace:
|
||||
return validate_object(p);
|
||||
return validate_object(p)
|
||||
|
||||
case .Open_Bracket:
|
||||
return validate_array(p);
|
||||
return validate_array(p)
|
||||
|
||||
case:
|
||||
if p.spec == Specification.JSON5 {
|
||||
#partial switch token.kind {
|
||||
case .Infinity, .NaN:
|
||||
advance_token(p);
|
||||
return true;
|
||||
advance_token(p)
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user