wmpmiles/Navmesher_old
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modified walker with pre/post walk callbacks and a carry_out/carry_in ptr that can be used to transfer data from pre to post.

Browse Source
This commit is contained in:
William Miles
2022-09-06 16:03:45 +10:00
parent ed613db39e
commit e9798984ff
2 changed files with 134 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
espReader/ESPReader.h
View File

@@ -175,6 +175,12 @@ extern "C" {
uint8_t day;
};
struct walker_callbacks {
void (*pre)(Node n, void *data, void **carry_out);
void (*post)(Node n, void *data, void **carry_in);
void *data;
};
//
// === BINARY DATA OVERLAYS ===
//
@@ -260,7 +266,7 @@ extern "C" {
* Data is walked sequentially. Nodes passed to `cb` will be strictly increasing
* in terms of memory location within the buffer.
*/
void espr_walk(char *data, size_t size, void (*cb)(Node n, void *pt), void *pt);
void espr_walk(char *data, size_t size, struct walker_callbacks cb);
/* `espr_print` prints the header of every group and record in the given
* esp/esm binary data.

168
espReader/Reader.c
View File

@@ -26,9 +26,9 @@ const int year_offset = 9;
void asserts(void);
// Tree walkers
char *walk_concat(char *data, size_t size, void (*cb)(Node n, void *pt), void *pt);
char *walk_group(char *data, void (*cb)(Node n, void *pt), void *pt);
char *walk_record(char *data, void (*cb)(Node n, void *pt), void *pt);
char *walk_concat(char *data, size_t size, struct walker_callbacks cb);
char *walk_group(char *data, struct walker_callbacks cb);
char *walk_record(char *data, struct walker_callbacks cb);
// Header printers
void print_group_header(Group *header);
@@ -43,10 +43,11 @@ void print_type4(Type4 val);
// Utilities
Timestamp convert_ts(uint16_t ts);
void print_callback(Node n, void *_);
void dc_size_cb(Node n, void *dc_size_ptr);
void formid_count_cb(Node n, void *count_ptr);
void decompress_cb(Node n, void *decom_ptr);
void print_callback(Node n, void *data, void **carry_out);
void dc_size_cb(Node n, void *data, void **carry_out);
void formid_count_cb(Node n, void *data, void **carry_out);
void decompress_pre(Node n, void *data, void **carry_out);
void decompress_post(Node n, void *data, void **carry_in);
//
// === FUNCTIONS ===
@@ -60,7 +61,7 @@ void asserts(void) {
assert(sizeof(Field) == 6); // Field struct incorrect size
}
void espr_walk(char *data, size_t size, void (*cb)(Node n, void *pt), void *pt) {
void espr_walk(char *data, size_t size, struct walker_callbacks cb) {
// check assertions that cannot be checked at compile time
asserts();
@@ -70,16 +71,18 @@ void espr_walk(char *data, size_t size, void (*cb)(Node n, void *pt), void *pt)
const Type4 type = *(const Type4 *)data;
assert(type.uint == rt[TES4]);
data = walk_concat(data, size, cb, pt);
data = walk_concat(data, size, cb);
assert(data == data_start + size);
}
void espr_print(char *data, size_t size) {
espr_walk(data, size, print_callback, NULL);
struct walker_callbacks cb = { .pre = print_callback };
espr_walk(data, size, cb);
}
void print_callback(Node n, void *pt) {
(void)pt;
void print_callback(Node n, void *data, void **carry_out) {
(void)data;
(void)carry_out;
switch (n.type) {
case NT_GROUP:
print_group_header(n.header.group);
@@ -94,26 +97,28 @@ void print_callback(Node n, void *pt) {
size_t espr_decompressed_size(char *data, size_t size) {
size_t dc_size = 0;
espr_walk(data, size, dc_size_cb, &dc_size);
struct walker_callbacks cb = { .pre = dc_size_cb, .data = &dc_size };
espr_walk(data, size, cb);
return dc_size;
}
// Adds the size of every node up, reading decompressed size from compressed records.
void dc_size_cb(Node n, void *dc_size_ptr) {
size_t *dcsp = dc_size_ptr;
void dc_size_cb(Node n, void *data, void **carry_out) {
(void)carry_out;
size_t *dc_size = data;
switch (n.type) {
case NT_GROUP:
// Only add header size for groups, internals will be walked
*dcsp += sizeof(Group);
*dc_size += sizeof(Group);
break;
case NT_RECORD:
// Add the whole record and header, records are leaf-ish
*dcsp += sizeof(Record);
*dc_size += sizeof(Record);
if (n.header.record->flags & COMPRESSED_FLAG) {
// Read decompressed size
*dcsp += *((uint32_t *)n.data);
*dc_size += *((uint32_t *)n.data);
} else
*dcsp += n.header.record->size;
*dc_size += n.header.record->size;
break;
default:
assert(false); // invalid node type
@@ -122,7 +127,8 @@ void dc_size_cb(Node n, void *dc_size_ptr) {
size_t espr_formid_count(char *data, size_t size) {
size_t count = 0;
espr_walk(data, size, formid_count_cb, &count);
struct walker_callbacks cb = { .pre = formid_count_cb, .data = &count };
espr_walk(data, size, cb);
return count;
}
@@ -130,47 +136,44 @@ size_t espr_formid_count(char *data, size_t size) {
* groups have formids, and every record should have a unique formid,
* otherwise there would be clashes in the id space.
*/
void formid_count_cb(Node n, void *count_ptr) {
size_t *c = count_ptr;
void formid_count_cb(Node n, void *data, void **carry_out) {
(void)carry_out;
size_t *count = data;
if (n.type == NT_RECORD) {
(*c)++;
(*count)++;
}
}
struct decom {
char *buf;
char *start;
size_t remaining;
};
void espr_decompress(char *data, size_t size, char *buf, size_t buf_size) {
struct decom s = { .buf = buf, .start = data, .remaining = buf_size };
espr_walk(data, size, decompress_cb, &s);
// handle final segment
size_t remaining = buf_size - (s.buf - buf);
assert(remaining == s.remaining);
memcpy(s.buf, s.start, remaining);
struct decom s = { .buf = buf, .remaining = buf_size };
struct walker_callbacks cb = { .pre = decompress_pre, .post = decompress_post, .data = &s };
espr_walk(data, size, cb);
}
void decompress_cb(Node n, void *decom_ptr) {
void decompress_pre(Node n, void *decom_ptr, void **carry_out) {
struct decom *d = decom_ptr;
// only need to do anything when we find a compressed flag
if (n.type == NT_RECORD && n.header.record->flags & COMPRESSED_FLAG) {
// uncompressed segment copy
size_t size = n.data - d->start;
assert(size < d->remaining);
memcpy(d->buf, d->start, size);
switch (n.type) {
case NT_RECORD:
// compressed record
if (n.header.record->flags & COMPRESSED_FLAG) {
// copy header
memcpy(d->buf, n.header.record, sizeof(Record));
// copied header reference
Record *header = (Record *)d->buf;
// update decom struct
d->remaining -= size;
d->buf += size;
// copied header
Record *header = (Record *)(d->buf) - 1;
d->remaining -= sizeof(Record);
d->buf += sizeof(Record);
// decompress directly into buffer
// first 4 bytes are the decompressed size
const size_t dc_size = *((uint32_t *)n.data);
size_t to_copy = dc_size;
size_t cur_size = n.header.record->size - sizeof(uint32_t);
@@ -183,15 +186,48 @@ void decompress_cb(Node n, void *decom_ptr) {
d->remaining -= dc_size;
d->buf += dc_size;
// update start to start of next record/group
d->start = n.data + n.header.record->size;
// update header data size
header->size = dc_size;
// unset compressed flag
header->flags &= ~COMPRESSED_FLAG;
}
else {
// copy record
size_t record_size = sizeof(Record) + n.header.record->size;
memcpy(d->buf, n.header.record, record_size);
// update decom
d->remaining -= record_size;
d->buf += record_size;
}
break;
case NT_GROUP:
// copy header, contents will be copied while walking
memcpy(d->buf, n.header.group, sizeof(Group));
// save copied header location for post-walk group size recalc
*carry_out = (void *)d->buf;
// update decom
d->buf += sizeof(Group);
d->remaining -= sizeof(Group);
break;
default:
assert(false); // invalid node type
}
}
void decompress_post(Node n, void *decom_ptr, void **carry_in) {
struct decom *d = decom_ptr;
// only need to handle group resize
if (n.type == NT_GROUP) {
Group *g = (Group *)(*carry_in);
size_t new_size = (char *)d->buf - (char *)g;
g->size = new_size;
}
}
/* Unknown data will be some concatenation of groups and records.
@@ -199,7 +235,7 @@ void decompress_cb(Node n, void *decom_ptr) {
* `walk_concat` will call the appropriate walking function
* for each segment of unknown data in this concatenation.
*/
char *walk_concat(char *data, size_t size, void (*cb)(Node n, void *pt), void *pt) {
char *walk_concat(char *data, size_t size, struct walker_callbacks cb) {
const char *end = data + size;
while (data != end) {
assert(data < end);
@@ -211,9 +247,9 @@ char *walk_concat(char *data, size_t size, void (*cb)(Node n, void *pt), void *p
// only need to distinguish between groups and records
if (type->uint == rt[GRUP])
data = walk_group(data, cb, pt);
data = walk_group(data, cb);
else
data = walk_record(data, cb, pt);
data = walk_record(data, cb);
}
return data;
}
@@ -223,7 +259,7 @@ char *walk_concat(char *data, size_t size, void (*cb)(Node n, void *pt), void *p
*
* This function will also call `cb` with the node constructed from this group record.
*/
char *walk_group(char *data, void (*cb)(Node n, void *pt), void *pt) {
char *walk_group(char *data, struct walker_callbacks cb) {
Group *const header = (Group *const)data;
// The size in the group header includes the size of the header
@@ -231,29 +267,49 @@ char *walk_group(char *data, void (*cb)(Node n, void *pt), void *pt) {
char *data_end = data + header->size;
size_t data_size = data_end - data_start;
// Callback
Node n = { .header.group = header, .data = data_start, .type = NT_GROUP };
cb(n, pt);
void *carry;
// Pre-walk callback
if (cb.pre)
cb.pre(n, cb.data, &carry);
// Walk through the concatenation of data inside the group.
data = walk_concat(data_start, data_size, cb, pt);
data = walk_concat(data_start, data_size, cb);
assert(data == data_end);
// Post-walk callback
if (cb.post)
cb.post(n, cb.data, &carry);
return data;
}
char *walk_record(char *data, void (*cb)(Node n, void *pt), void *pt) {
char *walk_record(char *data, struct walker_callbacks cb) {
Record *header = (Record *)data;
assert(header->type.uint != rt[GRUP]);
char *data_start = data + sizeof(Record);
// Callback
Node n = { .header.record = header, .data = data_start, .type = NT_RECORD };
cb(n, pt);
void *carry;
/* Pre and post walk callbacks make less sense for record walking as records
* are leaf-ish, will still call both here for now as field walking may be
* added in the future.
*/
// Pre-walk callback
if (cb.pre)
cb.pre(n, cb.data, &carry);
// Update data ptr based on record size.
data += sizeof(Record) + header->size;
// Post-walk callback
if (cb.post)
cb.post(n, cb.data, &carry);
return data;
}