Archive/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project.git synced 2024-10-20 11:26:18 -04:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

[Decompiler] WIP new type analysis tools (#601)

Browse source 
* add multi-lookup

* use multi-lookup
This commit is contained in:
water111 2021-06-17 21:50:36 -04:00 committed by GitHub
parent af49ac60cd
commit 409c1f5a7d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
42 changed files with 765 additions and 659 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
common/type_system/Type.h
View file

@ -222,6 +222,9 @@ class Field {
return m_array_size;
}
double field_score() const { return m_field_score; }
void set_field_score(double value) { m_field_score = value; }
private:
friend class TypeSystem;
void set_alignment(int alignment) { m_alignment = alignment; }
@ -239,6 +242,8 @@ class Field {
int m_alignment = -1;
bool m_skip_in_static_decomp = false;
bool m_placed_by_user = false; // was this field placed manually by the user?
double m_field_score = 0.;
};
class StructureType : public ReferenceType {

528
common/type_system/TypeFieldLookup.cpp
View file

@ -3,6 +3,7 @@
* Reverse field lookup used in the decompiler.
*/
#include <algorithm>
#include "third-party/fmt/core.h"
#include "TypeSystem.h"
@ -31,6 +32,24 @@ bool deref_matches(const DerefInfo& expected,
}
} // namespace
/*!
* Convert the linked list to a vector of tokens.
*/
std::vector<FieldReverseLookupOutput::Token> ReverseLookupNode::to_vector() const {
std::vector<const ReverseLookupNode*> nodes_reversed = {};
std::vector<FieldReverseLookupOutput::Token> result;
const ReverseLookupNode* node = this;
while (node) {
nodes_reversed.push_back(node);
node = node->prev;
}
for (auto it = nodes_reversed.rbegin(); it != nodes_reversed.rend(); it++) {
result.push_back((*it)->token);
}
return result;
}
/*!
* Convert a Token in a field path to a string for debugging.
*/
@ -48,227 +67,140 @@ std::string FieldReverseLookupOutput::Token::print() const {
}
}
/*!
* Main reverse lookup. Check the success field of the result to see if it was successful.
* Will return the type of result as well as the path taken to get there.
* The path can be arbitrarily long because we could be looking through nested inline structures.
* The result is _always_ an actual dereference and there is no way for this to return "no deref".
* The "offset" should always be the actual memory offset in the load instruction.
* This is the "offset into memory" - "boxed offset"
*/
FieldReverseLookupOutput TypeSystem::reverse_field_lookup(
const FieldReverseLookupInput& input) const {
if (debug_reverse_lookup) {
fmt::print("reverse_field_lookup on {} offset {} deref {} stride {}\n", input.base_type.print(),
input.offset, input.deref.has_value(), input.stride);
}
FieldReverseLookupOutput result;
result.success = try_reverse_lookup(input, &result.tokens, &result.addr_of, &result.result_type);
// todo check for only one var lookup.
return result;
}
namespace {
void try_reverse_lookup(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count);
void try_reverse_lookup_other(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count);
/*!
* Reverse lookup helper. Returns true if successful. It's okay to call this an have it fail.
* Will set path/addr_of/result_type if successful.
*/
bool TypeSystem::try_reverse_lookup(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const {
if (debug_reverse_lookup) {
fmt::print(" try_reverse_lookup on {} offset {} deref {} stride {}\n", input.base_type.print(),
input.offset, input.deref.has_value(), input.stride);
}
auto base_input_type = input.base_type.base_type();
if (base_input_type == "pointer") {
return try_reverse_lookup_pointer(input, path, addr_of, result_type);
} else if (base_input_type == "inline-array") {
return try_reverse_lookup_inline_array(input, path, addr_of, result_type);
} else if (base_input_type == "array" && input.base_type.has_single_arg()) {
return try_reverse_lookup_array(input, path, addr_of, result_type);
} else {
return try_reverse_lookup_other(input, path, addr_of, result_type);
}
return false;
}
/*!
* Handle a dereference of a pointer. This can be:
* Handle a dereference of a pointer/boxed array. This can be:
* - just dereferencing a pointer
* - accessing a variable element of a pointer-style array
* - getting the address of a variable element of a pointer-style array
* - accessing a constant element of a pointer-style array
* - getting the address of a constant element of a pointer-style array
*/
bool TypeSystem::try_reverse_lookup_pointer(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const {
if (!input.base_type.has_single_arg()) {
return false;
void try_reverse_lookup_array_like(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count,
bool boxed_array) {
if ((int)output->results.size() >= max_count) {
return;
}
auto di = get_deref_info(input.base_type);
bool is_integer = tc(TypeSpec("integer"), input.base_type.get_single_arg());
bool is_basic = tc(TypeSpec("basic"), input.base_type.get_single_arg());
if (!input.base_type.has_single_arg()) {
// not a typed pointer.
return;
}
if (boxed_array && input.offset < ARRAY_DATA_OFFSET) {
// we are accessing a field in an array so we can treat this like any other structure.
// this will add the basic offset, so we can pass in the input unchanged.
try_reverse_lookup_other(input, ts, parent, output, max_count);
return;
}
auto array_data_type =
boxed_array ? ts.make_pointer_typespec(input.base_type.get_single_arg()) : input.base_type;
auto di = ts.get_deref_info(array_data_type);
bool is_integer = ts.tc(TypeSpec("integer"), input.base_type.get_single_arg());
bool is_basic = ts.tc(TypeSpec("basic"), input.base_type.get_single_arg());
assert(di.mem_deref); // it's accessing a pointer.
auto elt_type = di.result_type;
if (input.stride) {
// variable access to the array.
// this is an array of values, nothing inline, so we must get an _exact_ match for this to work.
if (input.stride != di.stride) {
// mismatched array strides, fail!
return false;
}
if (input.offset != 0) {
// can't access within an element of a pointer array.
// todo - this could be some sort of constant folding for the next operation.
return false;
return;
}
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::VAR_IDX;
path->push_back(token);
if (input.offset != (boxed_array ? ARRAY_DATA_OFFSET : 0)) {
// can't access within an element of a pointer array.
// todo - this could be some sort of constant folding for the next operation.
// for example, something like (&+ (&-> array-of-uint32s 3) 1)
return;
}
// add this to our path.
ReverseLookupNode variable_node;
variable_node.prev = parent;
variable_node.token.kind = FieldReverseLookupOutput::Token::Kind::VAR_IDX;
if (input.deref.has_value()) {
// input did a load or store, we need to check the size/signed/kind.
if (deref_matches(di, input.deref.value(), is_integer, is_basic)) {
// access element of array
*addr_of = false;
*result_type = elt_type;
return true;
// success!
output->results.emplace_back(false, elt_type, variable_node.to_vector());
// no other way to access an array with the given type.
return;
} else {
// this isn't the right type of dereference.
return false;
// this isn't the right type of dereference, no way to make this work.
return;
}
} else {
// get the address of a variable indexed element of a pointer-style array
*addr_of = true;
*result_type = make_pointer_typespec(elt_type);
return true;
output->results.emplace_back(true, ts.make_pointer_typespec(elt_type),
variable_node.to_vector());
return;
}
} else {
// either access array or just plain deref a pointer.
int elt_idx = input.offset / di.stride;
int offset_into_elt = input.offset - (elt_idx * di.stride);
int offset = input.offset - (boxed_array ? ARRAY_DATA_OFFSET : 0);
int elt_idx = offset / di.stride;
int offset_into_elt = offset - (elt_idx * di.stride);
if (offset_into_elt) {
// should line up correctly.
return false;
// shouldn't have a weird offset.
return;
}
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::CONSTANT_IDX;
token.idx = elt_idx;
ReverseLookupNode constant_node;
constant_node.prev = parent;
constant_node.token.kind = FieldReverseLookupOutput::Token::Kind::CONSTANT_IDX;
constant_node.token.idx = elt_idx;
if (input.deref.has_value()) {
if (!deref_matches(di, input.deref.value(), is_integer, is_basic)) {
// this isn't the right type of dereference
return false;
return;
}
// always push back an index so we're never ambiguous.
path->push_back(token);
// access constant idx element of array
*addr_of = false;
*result_type = elt_type;
return true;
output->results.emplace_back(false, elt_type, constant_node.to_vector());
return;
} else {
// we want (&-> arr 0)
path->push_back(token);
// get address of constant idx element of array
*addr_of = true;
*result_type = make_pointer_typespec(elt_type);
return true;
}
}
}
output->results.emplace_back(true, ts.make_pointer_typespec(elt_type),
constant_node.to_vector());
/*!
* Handle a dereference with an "array" type.
* This has two cases:
* - accessing a field of the array class, not including the array data. Like any other structure.
* - accessing the data array part of the array class, very similar to the pointer-style array.
*/
bool TypeSystem::try_reverse_lookup_array(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const {
// type should be (array elt-type)
if (!input.base_type.has_single_arg()) {
return false;
}
if (input.offset < ARRAY_DATA_OFFSET) {
// we are accessing a field in an array so we can treat this like any other structure.
// this will add the basic offset, so we can pass in the input unchanged.
return try_reverse_lookup_other(input, path, addr_of, result_type);
}
// this is the data type - (pointer elt-type). this is stored at an offset of ARRAY_DATA_OFFSET.
auto array_data_type = make_pointer_typespec(input.base_type.get_single_arg());
auto di = get_deref_info(array_data_type);
bool is_integer = tc(TypeSpec("integer"), input.base_type.get_single_arg());
bool is_basic = tc(TypeSpec("basic"), input.base_type.get_single_arg());
assert(di.mem_deref); // it's accessing a pointer.
auto elt_type = di.result_type;
if (input.stride) {
if (input.offset != ARRAY_DATA_OFFSET) {
// might be constant propagated other offsets here?
return false;
}
// variable access to the array.
if (input.stride != di.stride) {
// mismatched array strides, fail!
return false;
}
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::VAR_IDX;
path->push_back(token);
if (input.deref.has_value()) {
if (deref_matches(di, input.deref.value(), is_integer, is_basic)) {
// access element of array
*addr_of = false;
*result_type = elt_type;
return true;
} else {
// this isn't the right type of dereference.
return false;
}
} else {
// get the address of a variable indexed element of a pointer-style array
*addr_of = true;
*result_type = make_pointer_typespec(elt_type);
return true;
}
} else {
// either access array or just plain deref a pointer.
int elt_idx = (input.offset - ARRAY_DATA_OFFSET) / di.stride;
int offset_into_elt = (input.offset - ARRAY_DATA_OFFSET) - (elt_idx * di.stride);
if (offset_into_elt) {
// should line up correctly.
return false;
}
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::CONSTANT_IDX;
token.idx = elt_idx;
// always put array index, even if it's zero.
path->push_back(token);
if (input.deref.has_value()) {
if (!deref_matches(di, input.deref.value(), is_integer, is_basic)) {
// this isn't the right type of dereference
return false;
// also just return the array
if (elt_idx == 0) {
if (boxed_array) {
auto vec = parent->to_vector();
FieldReverseLookupOutput::Token tok;
tok.kind = FieldReverseLookupOutput::Token::Kind::FIELD;
tok.field_score = 0.0; // don't bother
tok.name = "data";
vec.push_back(tok);
output->results.emplace_back(false, array_data_type, vec);
} else {
output->results.emplace_back(false, input.base_type, parent->to_vector());
}
}
// access constant idx element of array
*addr_of = false;
*result_type = elt_type;
return true;
} else {
// get address of constant idx element of array
*addr_of = true;
*result_type = make_pointer_typespec(elt_type);
return true;
return;
}
}
}
@ -281,24 +213,33 @@ bool TypeSystem::try_reverse_lookup_array(const FieldReverseLookupInput& input,
* - get a constant idx reference object (we pick this over just getting the array for idx = 0)
* - get something inside a constant idx reference object
*/
bool TypeSystem::try_reverse_lookup_inline_array(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const {
auto di = get_deref_info(input.base_type);
void try_reverse_lookup_inline_array(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count) {
if ((int)output->results.size() >= max_count) {
return;
}
auto di = ts.get_deref_info(input.base_type);
assert(di.can_deref);
assert(!di.mem_deref); // if we make integer arrays allowed to be inline-array, this will break.
assert(!di.mem_deref);
if (input.stride && input.stride == di.stride && input.offset < di.stride) {
// variable lookup.
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::VAR_IDX;
path->push_back(token);
ReverseLookupNode var_idx_node;
var_idx_node.prev = parent;
var_idx_node.token.kind = FieldReverseLookupOutput::Token::Kind::VAR_IDX;
if (input.offset == 0 && !input.deref.has_value()) {
*addr_of = false;
*result_type = di.result_type;
return true;
// put the element first, to match the old behavior.
output->results.emplace_back(false, di.result_type, var_idx_node.to_vector());
// keep trying!
}
if ((int)output->results.size() >= max_count) {
return;
}
FieldReverseLookupInput next_input;
@ -306,7 +247,8 @@ bool TypeSystem::try_reverse_lookup_inline_array(const FieldReverseLookupInput&
next_input.stride = 0;
next_input.offset = input.offset;
next_input.base_type = di.result_type;
return try_reverse_lookup(next_input, path, addr_of, result_type);
try_reverse_lookup(next_input, ts, &var_idx_node, output, max_count);
return;
}
// constant lookup, or accessing within the first one
@ -315,24 +257,33 @@ bool TypeSystem::try_reverse_lookup_inline_array(const FieldReverseLookupInput&
// how many bytes into the element we look
int offset_into_elt = input.offset - (elt_idx * di.stride);
// the expected number of bytes into the element we would look to grab a ref to the elt.
int expected_offset_into_elt = lookup_type(di.result_type)->get_offset();
int expected_offset_into_elt = ts.lookup_type(di.result_type)->get_offset();
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::CONSTANT_IDX;
token.idx = elt_idx;
ReverseLookupNode const_idx_node;
const_idx_node.prev = parent;
const_idx_node.token.kind = FieldReverseLookupOutput::Token::Kind::CONSTANT_IDX;
const_idx_node.token.idx = elt_idx;
if (offset_into_elt == expected_offset_into_elt && !input.deref.has_value()) {
// just get an element (possibly zero, and we want to include the 0 if so)
// for the degenerate inline-array case, it seems more likely that we get the zeroth object
// rather than the array? Either way, this code should be compatible with both approaches.
path->push_back(token);
*addr_of = false;
*result_type = di.result_type;
return true;
// rather than the array, so this goes before that case.
output->results.emplace_back(false, di.result_type, const_idx_node.to_vector());
if ((int)output->results.size() >= max_count) {
return;
}
// keep trying more stuff.
}
// can we just return the array?
if (expected_offset_into_elt == offset_into_elt && !input.deref.has_value() && elt_idx == 0) {
output->results.emplace_back(false, input.base_type, parent->to_vector());
if ((int)output->results.size() >= max_count) {
return;
}
}
// otherwise access within the element
path->push_back(token);
FieldReverseLookupInput next_input;
next_input.deref = input.deref;
@ -340,7 +291,7 @@ bool TypeSystem::try_reverse_lookup_inline_array(const FieldReverseLookupInput&
// try_reverse_lookup expects "offset_into_field - boxed_offset"
next_input.offset = offset_into_elt - expected_offset_into_elt;
next_input.base_type = di.result_type;
return try_reverse_lookup(next_input, path, addr_of, result_type);
try_reverse_lookup(next_input, ts, &const_idx_node, output, max_count);
}
/*!
@ -348,24 +299,30 @@ bool TypeSystem::try_reverse_lookup_inline_array(const FieldReverseLookupInput&
* - Access a field which requires mem deref.
* - Get address of a field which requires mem deref.
*/
bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const {
auto type_info = lookup_type(input.base_type);
void try_reverse_lookup_other(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count) {
auto type_info = ts.lookup_type(input.base_type);
auto structure_type = dynamic_cast<StructureType*>(type_info);
if (!structure_type) {
return false;
return;
}
auto corrected_offset = input.offset + type_info->get_offset();
// loop over fields. We may need to try multiple fields.
for (auto& field : structure_type->fields()) {
// todo, remove this and replace with score.
if (field.skip_in_decomp()) {
continue;
}
auto field_deref = lookup_field_info(type_info->get_name(), field.name());
if ((int)output->results.size() >= max_count) {
return;
}
auto field_deref = ts.lookup_field_info(type_info->get_name(), field.name());
// how many bytes do we look at? In the case where we're just getting an address, we assume
// one byte, so we'll always pass the size check.
@ -375,7 +332,7 @@ bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
}
if (corrected_offset >= field.offset() &&
(corrected_offset + effective_load_size <= field.offset() + get_size_in_type(field) ||
(corrected_offset + effective_load_size <= field.offset() + ts.get_size_in_type(field) ||
field.is_dynamic())) {
// the field size looks okay.
int offset_into_field = corrected_offset - field.offset();
@ -383,6 +340,7 @@ bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
FieldReverseLookupOutput::Token token;
token.kind = FieldReverseLookupOutput::Token::Kind::FIELD;
token.name = field.name();
token.field_score = field.field_score();
if (field_deref.needs_deref) {
if (offset_into_field == 0) {
@ -390,10 +348,10 @@ bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
// needs deref, offset is 0, did a deref.
// Check the deref is right...
// (pointer <field-type>)
TypeSpec loc_type = make_pointer_typespec(field_deref.type);
auto di = get_deref_info(loc_type);
bool is_integer = tc(TypeSpec("integer"), field_deref.type);
bool is_basic = tc(TypeSpec("basic"), field_deref.type);
TypeSpec loc_type = ts.make_pointer_typespec(field_deref.type);
auto di = ts.get_deref_info(loc_type);
bool is_integer = ts.tc(TypeSpec("integer"), field_deref.type);
bool is_basic = ts.tc(TypeSpec("basic"), field_deref.type);
if (!deref_matches(di, input.deref.value(), is_integer, is_basic)) {
continue; // try another field!
}
@ -401,20 +359,23 @@ bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
if (input.stride) {
continue;
}
path->push_back(token);
*addr_of = false;
*result_type = field_deref.type;
return true;
ReverseLookupNode node;
node.prev = parent;
node.token = token;
output->results.emplace_back(false, field_deref.type, node.to_vector());
continue; // try more!
} else {
// needs a deref, offset is 0, didn't do a deref.
// we're taking the address
if (input.stride) {
continue;
}
path->push_back(token);
*addr_of = true;
*result_type = make_pointer_typespec(field_deref.type);
return true;
ReverseLookupNode node;
node.prev = parent;
node.token = token;
output->results.emplace_back(true, ts.make_pointer_typespec(field_deref.type),
node.to_vector());
continue; // try more!
}
} else {
if (input.deref.has_value()) {
@ -431,32 +392,121 @@ bool TypeSystem::try_reverse_lookup_other(const FieldReverseLookupInput& input,
// no deref needed
int expected_offset_into_field = 0;
if (field.is_inline()) {
expected_offset_into_field = lookup_type(field.type())->get_offset();
expected_offset_into_field = ts.lookup_type(field.type())->get_offset();
}
if (offset_into_field == expected_offset_into_field && !input.deref.has_value() &&
!input.stride) {
// get the inline field exactly
path->push_back(token);
*result_type = field_deref.type;
*addr_of = false;
return true;
ReverseLookupNode node;
node.prev = parent;
node.token = token;
output->results.emplace_back(false, field_deref.type, node.to_vector());
continue; // try more!
} else {
FieldReverseLookupInput next_input;
next_input.deref = input.deref;
next_input.offset = offset_into_field - expected_offset_into_field;
next_input.stride = input.stride;
next_input.base_type = field_deref.type;
auto old_path = *path;
path->push_back(token);
if (try_reverse_lookup(next_input, path, addr_of, result_type)) {
return true;
} else {
*path = old_path;
continue;
}
ReverseLookupNode node;
node.prev = parent;
node.token = token;
try_reverse_lookup(next_input, ts, &node, output, max_count);
}
}
}
}
return false;
}
/*!
* Reverse lookup helper. Returns true if successful. It's okay to call this an have it fail.
* Will set path/addr_of/result_type if successful.
*/
void try_reverse_lookup(const FieldReverseLookupInput& input,
const TypeSystem& ts,
const ReverseLookupNode* parent,
FieldReverseMultiLookupOutput* output,
int max_count) {
if (debug_reverse_lookup) {
fmt::print(" try_reverse_lookup on {} offset {} deref {} stride {}\n", input.base_type.print(),
input.offset, input.deref.has_value(), input.stride);
}
auto base_input_type = input.base_type.base_type();
if (base_input_type == "pointer") {
try_reverse_lookup_array_like(input, ts, parent, output, max_count, false);
} else if (base_input_type == "inline-array") {
return try_reverse_lookup_inline_array(input, ts, parent, output, max_count);
} else if (base_input_type == "array" && input.base_type.has_single_arg()) {
try_reverse_lookup_array_like(input, ts, parent, output, max_count, true);
} else {
return try_reverse_lookup_other(input, ts, parent, output, max_count);
}
}
} // namespace
/*!
* Old single reverse lookup. Check the success field of the result to see if it was successful.
* Will return the type of result as well as the path taken to get there.
* The path can be arbitrarily long because we could be looking through nested inline structures.
* The result is _always_ an actual dereference and there is no way for this to return "no deref".
* The "offset" should always be the actual memory offset in the load instruction.
* This is the "offset into memory" - "boxed offset"
*/
FieldReverseLookupOutput TypeSystem::reverse_field_lookup(
const FieldReverseLookupInput& input) const {
// just use the multi-lookup set to 1 and grab the first result.
auto multi_result = reverse_field_multi_lookup(input, 100);
for (auto& result : multi_result.results) {
// compute the score.
result.total_score = 0;
for (auto& tok : result.tokens) {
result.total_score += tok.score();
}
}
// use stable sort to make sure we break ties by being first in the order.
std::stable_sort(multi_result.results.begin(), multi_result.results.end(),
[](const FieldReverseLookupOutput& a, const FieldReverseLookupOutput& b) {
return a.total_score > b.total_score;
});
/*
if (multi_result.results.size() > 1) {
fmt::print("Multiple:\n");
for (auto& result : multi_result.results) {
fmt::print(" [{}] [{}] ", result.total_score, result.result_type.print());
for (auto& tok : result.tokens) {
fmt::print("{} ", tok.print());
}
fmt::print("\n");
}
fmt::print("\n\n\n");
}
*/
FieldReverseLookupOutput result;
if (multi_result.success) {
result = multi_result.results.at(0);
result.success = true;
} else {
result.success = false;
}
return result;
}
FieldReverseMultiLookupOutput TypeSystem::reverse_field_multi_lookup(
const FieldReverseLookupInput& input,
int max_count) const {
if (debug_reverse_lookup) {
fmt::print("reverse_field_lookup on {} offset {} deref {} stride {}\n", input.base_type.print(),
input.offset, input.deref.has_value(), input.stride);
}
FieldReverseMultiLookupOutput result;
try_reverse_lookup(input, *this, nullptr, &result, max_count);
if (!result.results.empty()) {
result.success = true;
}
return result;
}

4
common/type_system/TypeSystem.cpp
View file

@ -767,7 +767,8 @@ int TypeSystem::add_field_to_type(StructureType* type,
bool is_dynamic,
int array_size,
int offset_override,
bool skip_in_static_decomp) {
bool skip_in_static_decomp,
double score) {
if (type->lookup_field(field_name, nullptr)) {
throw_typesystem_error("Type {} already has a field named {}\n", type->get_name(), field_name);
}
@ -807,6 +808,7 @@ int TypeSystem::add_field_to_type(StructureType* type,
if (skip_in_static_decomp) {
field.set_skip_in_static_decomp();
}
field.set_field_score(score);
int after_field = offset + get_size_in_type(field);
if (type->get_size_in_memory() < after_field) {

59
common/type_system/TypeSystem.h
View file

@ -71,21 +71,53 @@ struct FieldReverseLookupInput {
TypeSpec base_type; // the type of the thing we're accessing
};
constexpr double CONSTANT_INDEX_SCORE = -10.0;
struct FieldReverseLookupOutput {
struct Token {
enum class Kind { FIELD, CONSTANT_IDX, VAR_IDX } kind;
std::string name;
int idx;
int idx = -1;
double field_score = 0.0;
double score() {
switch (kind) {
case Kind::FIELD:
return field_score;
case Kind::CONSTANT_IDX:
return CONSTANT_INDEX_SCORE;
case Kind::VAR_IDX: // this is unavoidable, so don't bother with a score.
default:
return 0.;
}
}
std::string print() const;
};
FieldReverseLookupOutput() = default;
FieldReverseLookupOutput(bool addr, TypeSpec type, std::vector<Token> tok)
: success(true), addr_of(addr), result_type(std::move(type)), tokens(std::move(tok)) {}
bool success = false;
bool addr_of = false; // do we take the address of this result?
double total_score = 0.;
TypeSpec result_type;
std::vector<Token> tokens;
};
struct FieldReverseMultiLookupOutput {
std::vector<FieldReverseLookupOutput> results;
bool success = false;
};
struct ReverseLookupNode {
const ReverseLookupNode* prev = nullptr;
FieldReverseLookupOutput::Token token;
std::vector<FieldReverseLookupOutput::Token> to_vector() const;
};
class TypeSystem {
public:
TypeSystem();
@ -97,6 +129,8 @@ class TypeSystem {
DerefInfo get_deref_info(const TypeSpec& ts) const;
FieldReverseLookupOutput reverse_field_lookup(const FieldReverseLookupInput& input) const;
FieldReverseMultiLookupOutput reverse_field_multi_lookup(const FieldReverseLookupInput& input,
int max_count = 100) const;
bool fully_defined_type_exists(const std::string& name) const;
bool fully_defined_type_exists(const TypeSpec& type) const;
@ -158,7 +192,8 @@ class TypeSystem {
bool is_dynamic = false,
int array_size = -1,
int offset_override = -1,
bool skip_in_static_decomp = false);
bool skip_in_static_decomp = false,
double score = 0.0);
void add_builtin_types();
@ -204,26 +239,6 @@ class TypeSystem {
int get_size_in_type(const Field& field) const;
private:
bool try_reverse_lookup(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const;
bool try_reverse_lookup_pointer(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const;
bool try_reverse_lookup_inline_array(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const;
bool try_reverse_lookup_array(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const;
bool try_reverse_lookup_other(const FieldReverseLookupInput& input,
std::vector<FieldReverseLookupOutput::Token>* path,
bool* addr_of,
TypeSpec* result_type) const;
std::string lca_base(const std::string& a, const std::string& b) const;
bool typecheck_base_types(const std::string& expected, const std::string& actual) const;
int get_alignment_in_type(const Field& field);

15
common/type_system/deftype.cpp
View file

@ -71,6 +71,15 @@ int64_t get_int(const goos::Object& obj) {
throw std::runtime_error(obj.print() + " was supposed to be an integer, but isn't");
}
double get_float(const goos::Object& obj) {
if (obj.is_int()) {
return obj.integer_obj.value;
} else if (obj.is_float()) {
return obj.float_obj.value;
}
throw std::runtime_error(obj.print() + " was supposed to be an number, but isn't");
}
void add_field(StructureType* structure, TypeSystem* ts, const goos::Object& def) {
auto rest = &def;
@ -85,6 +94,7 @@ void add_field(StructureType* structure, TypeSystem* ts, const goos::Object& def
bool is_dynamic = false;
int offset_override = -1;
int offset_assert = -1;
double score = 0;
bool skip_in_decomp = false;
if (!rest->is_empty_list()) {
@ -104,6 +114,9 @@ void add_field(StructureType* structure, TypeSystem* ts, const goos::Object& def
} else if (opt_name == ":offset") {
offset_override = get_int(car(rest));
rest = cdr(rest);
} else if (opt_name == ":score") {
score = get_float(car(rest));
rest = cdr(rest);
} else if (opt_name == ":offset-assert") {
offset_assert = get_int(car(rest));
if (offset_assert == -1) {
@ -119,7 +132,7 @@ void add_field(StructureType* structure, TypeSystem* ts, const goos::Object& def
}
int actual_offset = ts->add_field_to_type(structure, name, type, is_inline, is_dynamic,
array_size, offset_override, skip_in_decomp);
array_size, offset_override, skip_in_decomp, score);
if (offset_assert != -1 && actual_offset != offset_assert) {
throw std::runtime_error("Field " + name + " was placed at " + std::to_string(actual_offset) +
" but offset-assert was set to " + std::to_string(offset_assert));

11
decompiler/config/all-types.gc
View file

@ -1540,7 +1540,7 @@
(word uint32 4 :offset 0)
(dword uint64 2 :offset 0)
(quad uint128 :offset 0)
(vector vector :inline :offset 0)
(vector vector :inline :offset 0 :score -100)
(vector4w vector4w :inline :offset 0)
)
:method-count-assert 9
@ -4654,10 +4654,11 @@
(hvdf-off vector :inline :offset-assert 736)
(guard vector :inline :offset-assert 752)
(vis-gifs vis-gif-tag 4 :inline :offset-assert 768)
(giftex uint128 :offset 768)
(gifgr uint128 :offset 784)
(giftex-trans uint128 :offset 800)
(gifgr-trans uint128 :offset 816)
(vis-gifs-quads uint128 4 :offset 768) ;; added
(giftex vis-gif-tag :offset 768)
(gifgr vis-gif-tag :offset 784)
(giftex-trans vis-gif-tag :offset 800)
(gifgr-trans vis-gif-tag :offset 816)
(pfog0 float :offset-assert 832)
(pfog1 float :offset-assert 836)
(trans vector :inline :offset-assert 848)

9
goal_src/engine/camera/math-camera-h.gc
View file

@ -79,10 +79,11 @@
(hvdf-off vector :inline :offset-assert 736)
(guard vector :inline :offset-assert 752)
(vis-gifs vis-gif-tag 4 :inline :offset-assert 768)
(giftex uint128 :offset 768)
(gifgr uint128 :offset 784)
(giftex-trans uint128 :offset 800)
(gifgr-trans uint128 :offset 816)
(vis-gifs-quads uint128 4 :offset 768)
(giftex vis-gif-tag :offset 768)
(gifgr vis-gif-tag :offset 784)
(giftex-trans vis-gif-tag :offset 800)
(gifgr-trans vis-gif-tag :offset 816)
(pfog0 float :offset-assert 832)
(pfog1 float :offset-assert 836)
(trans vector :inline :offset-assert 848)

51
goal_src/engine/camera/math-camera.gc
View file

@ -241,31 +241,34 @@
(let ((v1-20 (make-u128 0 (shl #x301ec000 32)))))
(let ((v1-23 (make-u128 0 (shl #x303ec000 32)))))
(let ((pfog (-> math-cam pfog0)))
(let ((vis-gif-0 (-> math-cam vis-gifs)))
(set! (-> vis-gif-0 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-0 0 strip) (the-as uint #x301e4000))
(set! (-> vis-gif-0 0 regs) (the-as uint 1042))
(set! (-> vis-gif-0 0 fan) (the-as uint #x301ec000))
)
(let ((vis-gif-1 (-> math-cam vis-gifs 1)))
(set! (-> vis-gif-1 fog0) (the-as uint pfog))
(set! (-> vis-gif-1 strip) (make-u128 0 (shl #x20164000 32)))
(set! (-> vis-gif-1 regs) (the-as uint 65))
(set! (-> vis-gif-1 fan) (the-as uint #x301ec000))
)
(let ((vis-gif-1-again (-> math-cam vis-gifs)))
(set! (-> vis-gif-1-again 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-1-again 0 strip) (the-as uint #x303e4000))
(set! (-> vis-gif-1-again 0 regs) (the-as uint 1042))
(set! (-> vis-gif-1-again 0 fan) (the-as uint #x303ec000))
)
(let ((vis-gif-1-again-again (-> math-cam vis-gifs)))
(set! (-> vis-gif-1-again-again 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-1-again-again 0 strip) (the-as uint #x303e4000))
(set! (-> vis-gif-1-again-again 0 regs) (the-as uint 1042))
(set! (-> vis-gif-1-again-again 0 fan) (the-as uint #x303ec000))
)
(let ((vis-gif-0 (-> math-cam vis-gifs)))
(set! (-> vis-gif-0 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-0 0 strip) (the-as uint #x301e4000))
(set! (-> vis-gif-0 0 regs) (the-as uint 1042))
(set! (-> vis-gif-0 0 fan) (the-as uint #x301ec000))
)
(let ((vis-gif-1 (&-> math-cam gifgr)))
(set! (-> vis-gif-1 0) (the-as vis-gif-tag pfog))
(set!
(-> vis-gif-1 1)
(the-as vis-gif-tag (make-u128 0 (shl #x20164000 32)))
)
(set! (-> vis-gif-1 2) (the-as vis-gif-tag 65))
(set! (-> vis-gif-1 3) (the-as vis-gif-tag #x301ec000))
)
(let ((vis-gif-1-again (-> math-cam vis-gifs)))
(set! (-> vis-gif-1-again 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-1-again 0 strip) (the-as uint #x303e4000))
(set! (-> vis-gif-1-again 0 regs) (the-as uint 1042))
(set! (-> vis-gif-1-again 0 fan) (the-as uint #x303ec000))
)
(let ((vis-gif-1-again-again (-> math-cam vis-gifs)))
(set! (-> vis-gif-1-again-again 0 fog0) (the-as uint pfog))
(set! (-> vis-gif-1-again-again 0 strip) (the-as uint #x303e4000))
(set! (-> vis-gif-1-again-again 0 regs) (the-as uint 1042))
(set! (-> vis-gif-1-again-again 0 fan) (the-as uint #x303ec000))
)
)
;; update sprite stuff.
(if (nonzero? sprite-distorter-generate-tables)

18
test/decompiler/reference/engine/anim/joint-h_REF.gc
View file

@ -87,15 +87,15 @@
(format #t "~Tpostbind-function: ~A~%" (-> obj postbind-function))
(format #t "~Teffect: ~A~%" (-> obj effect))
(format #t "~Tchannel[0] @ #x~X~%" (-> obj channel))
(format #t "~Tframe-group0: ~A~%" (-> obj channel 0 frame-group))
(format #t "~Tframe-num0: ~f~%" (-> obj channel 0 frame-num))
(format #t "~Tframe-interp0: ~f~%" (-> obj channel 0 frame-interp))
(format #t "~Tframe-group1: ~A~%" (-> obj channel 1 frame-group))
(format #t "~Tframe-num1: ~f~%" (-> obj channel 1 frame-num))
(format #t "~Tframe-interp1: ~f~%" (-> obj channel 1 frame-interp))
(format #t "~Tframe-group2: ~A~%" (-> obj channel 2 frame-group))
(format #t "~Tframe-num2: ~f~%" (-> obj channel 2 frame-num))
(format #t "~Tframe-interp2: ~f~%" (-> obj channel 2 frame-interp))
(format #t "~Tframe-group0: ~A~%" (-> obj frame-group0))
(format #t "~Tframe-num0: ~f~%" (-> obj frame-num0))
(format #t "~Tframe-interp0: ~f~%" (-> obj frame-interp0))
(format #t "~Tframe-group1: ~A~%" (-> obj frame-group1))
(format #t "~Tframe-num1: ~f~%" (-> obj frame-num1))
(format #t "~Tframe-interp1: ~f~%" (-> obj frame-interp1))
(format #t "~Tframe-group2: ~A~%" (-> obj frame-group2))
(format #t "~Tframe-num2: ~f~%" (-> obj frame-num2))
(format #t "~Tframe-interp2: ~f~%" (-> obj frame-interp2))
obj
)

2
test/decompiler/reference/engine/anim/mspace-h_REF.gc
View file

@ -61,7 +61,7 @@
(defmethod inspect bone ((obj bone))
(format #t "[~8x] ~A~%" obj 'bone)
(format #t "~Ttransform: #<matrix @ #x~X>~%" (-> obj transform))
(format #t "~Tposition: #<vector @ #x~X>~%" (-> obj transform vector 3))
(format #t "~Tposition: #<vector @ #x~X>~%" (-> obj position))
(format #t "~Tscale: #<vector @ #x~X>~%" (-> obj scale))
(format #t "~Tcache: #<bone-cache @ #x~X>~%" (-> obj cache))
obj

94
test/decompiler/reference/engine/camera/camera-h_REF.gc
View file

@ -563,21 +563,21 @@
(t9-0 obj)
)
(format #t "~T~Ttrans: ~`vector`P~%" (-> obj stack))
(format #t "~T~Tinv-camera-rot: ~`matrix`P~%" (&-> obj stack 16))
(format #t "~T~Tinv-camera-rot: ~`matrix`P~%" (-> obj inv-camera-rot))
(format #t "~T~Tfov: ~f~%" (-> obj fov))
(format #t "~T~Tinterp-val: ~f~%" (-> obj interp-val))
(format #t "~T~Tinterp-step: ~f~%" (-> obj interp-step))
(format #t "~T~Tdist-from-src: ~f~%" (-> obj dist-from-src))
(format #t "~T~Tdist-from-dest: ~f~%" (-> obj dist-from-dest))
(format #t "~T~Tflip-control-axis: #<vector @ #x~X>~%" (&-> obj stack 112))
(format #t "~T~Tvelocity: #<vector @ #x~X>~%" (&-> obj stack 128))
(format #t "~T~Ttracking-status: ~D~%" (-> obj tracking-status))
(format #t "~T~Ttracking-options: ~D~%" (-> obj tracking-options))
(format
#t
"~T~Ttracking: #<cam-rotation-tracker @ #x~X>~%"
(&-> obj stack 160)
"~T~Tflip-control-axis: #<vector @ #x~X>~%"
(-> obj flip-control-axis)
)
(format #t "~T~Tvelocity: #<vector @ #x~X>~%" (-> obj velocity))
(format #t "~T~Ttracking-status: ~D~%" (-> obj tracking-status))
(format #t "~T~Ttracking-options: ~D~%" (-> obj tracking-options))
(format #t "~T~Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
obj
)
@ -649,52 +649,48 @@
(format #t "~T~Tfov: ~f~%" (-> obj fov))
(format #t "~T~Tfov0: ~f~%" (-> obj fov0))
(format #t "~T~Tfov1: ~f~%" (-> obj fov1))
(format #t "~T~Tfov-index: #<cam-index @ #x~X>~%" (&-> obj stack 32))
(format
#t
"~T~Ttracking: #<cam-rotation-tracker @ #x~X>~%"
(&-> obj stack 80)
)
(format #t "~T~Tfov-index: #<cam-index @ #x~X>~%" (-> obj fov-index))
(format #t "~T~Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
(format #t "~T~Tview-off-param: ~f~%" (-> obj view-off-param))
(format #t "~T~Tview-off: ~`vector`P~%" (&-> obj stack 304))
(format #t "~T~Tview-off: ~`vector`P~%" (-> obj view-off))
(format #t "~T~Tmin-z-override: ~f~%" (-> obj min-z-override))
(format #t "~T~Tview-flat: ~`vector`P~%" (&-> obj stack 336))
(format #t "~T~Tview-flat: ~`vector`P~%" (-> obj view-flat))
(format #t "~T~Tstring-vel-dir: ~D~%" (-> obj string-vel-dir))
(format #t "~T~Tstring-trans: ~`vector`P~%" (&-> obj stack 368))
(format #t "~T~Tstring-trans: ~`vector`P~%" (-> obj string-trans))
(format
#t
"~T~Tposition-spline: #<tracking-spline @ #x~X>~%"
(&-> obj stack 384)
(-> obj position-spline)
)
(format #t "~T~Tpivot-pt: ~`vector`P~%" (&-> obj stack 2032))
(format #t "~T~Tpivot-pt: ~`vector`P~%" (-> obj pivot-pt))
(format #t "~T~Tpivot-rad: ~f~%" (-> obj pivot-rad))
(format #t "~T~Tcircular-follow: #<vector @ #x~X>~%" (&-> obj stack 2064))
(format #t "~T~Tcircular-follow: #<vector @ #x~X>~%" (-> obj circular-follow))
(format #t "~T~Tmax-angle-offset: ~f~%" (-> obj max-angle-offset))
(format #t "~T~Tmax-angle-curr: ~f~%" (-> obj max-angle-curr))
(format #t "~T~Toptions: ~D~%" (-> obj options))
(format #t "~T~Tcam-entity: ~A~%" (-> obj cam-entity))
(format #t "~T~Tvelocity: ~`vector`P~%" (&-> obj stack 2096))
(format #t "~T~Tdesired-pos: ~`vector`P~%" (&-> obj stack 2112))
(format #t "~T~Tvelocity: ~`vector`P~%" (-> obj velocity))
(format #t "~T~Tdesired-pos: ~`vector`P~%" (-> obj desired-pos))
(format #t "~T~Ttime-dist-too-far: ~D~%" (-> obj time-dist-too-far))
(format #t "~T~Tlos-state: ~D~%" (-> obj los-state))
(format #t "~T~Tgood-point: ~`vector`P~%" (&-> obj stack 2144))
(format #t "~T~Tgood-point: ~`vector`P~%" (-> obj good-point))
(format #t "~T~Tlos-tgt-spline-pt: ~D~%" (-> obj los-tgt-spline-pt))
(format
#t
"~T~Tlos-tgt-spline-pt-incarnation: ~D~%"
(-> obj los-tgt-spline-pt-incarnation)
)
(format #t "~T~Tlos-last-pos: ~`vector`P~%" (&-> obj stack 2176))
(format #t "~T~Tintro-curve: #<curve @ #x~X>~%" (&-> obj stack 2192))
(format #t "~T~Tintro-offset: #<vector @ #x~X>~%" (&-> obj stack 2224))
(format #t "~T~Tlos-last-pos: ~`vector`P~%" (-> obj los-last-pos))
(format #t "~T~Tintro-curve: #<curve @ #x~X>~%" (-> obj intro-curve))
(format #t "~T~Tintro-offset: #<vector @ #x~X>~%" (-> obj intro-offset))
(format #t "~T~Tintro-t: ~f~%" (-> obj intro-t))
(format #t "~T~Tintro-t-step: ~f~%" (-> obj intro-t-step))
(format #t "~T~Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
(format #t "~T~Tspline-exists: ~A~%" (-> obj spline-exists))
(format #t "~T~Tspline-curve: #<curve @ #x~X>~%" (&-> obj stack 2256))
(format #t "~T~Tspline-offset: #<vector @ #x~X>~%" (&-> obj stack 2288))
(format #t "~T~Tindex: #<cam-index @ #x~X>~%" (&-> obj stack 2304))
(format #t "~T~Tsaved-pt: #<vector @ #x~X>~%" (&-> obj stack 2352))
(format #t "~T~Tspline-curve: #<curve @ #x~X>~%" (-> obj spline-curve))
(format #t "~T~Tspline-offset: #<vector @ #x~X>~%" (-> obj spline-offset))
(format #t "~T~Tindex: #<cam-index @ #x~X>~%" (-> obj index))
(format #t "~T~Tsaved-pt: #<vector @ #x~X>~%" (-> obj saved-pt))
(format #t "~T~Tspline-tt: ~f~%" (-> obj spline-tt))
(format #t "~T~Tspline-follow-dist: ~f~%" (-> obj spline-follow-dist))
(format #t "~T~Tchange-event-from: #x~X~%" (-> obj change-event-from))
@ -704,8 +700,8 @@
(format #t "~T~Thave-phony-joystick: ~A~%" (-> obj have-phony-joystick))
(format #t "~T~Tphony-joystick-x: ~f~%" (-> obj phony-joystick-x))
(format #t "~T~Tphony-joystick-y: ~f~%" (-> obj phony-joystick-y))
(format #t "~T~Tstring-min-val: #<vector @ #x~X>~%" (&-> obj stack 2416))
(format #t "~T~Tstring-max-val: #<vector @ #x~X>~%" (&-> obj stack 2432))
(format #t "~T~Tstring-min-val: #<vector @ #x~X>~%" (-> obj string-min-val))
(format #t "~T~Tstring-max-val: #<vector @ #x~X>~%" (-> obj string-max-val))
(format #t "~T~Tstring-val-locked: ~A~%" (-> obj string-val-locked))
obj
)
@ -779,7 +775,7 @@
)
(format #t "~T~Tmaster-options: ~D~%" (-> obj master-options))
(format #t "~T~Tnum-slaves: ~D~%" (-> obj num-slaves))
(format #t "~T~Tslave[2] @ #x~X~%" (&-> obj stack 8))
(format #t "~T~Tslave[2] @ #x~X~%" (-> obj slave))
(format #t "~T~Tslave-options: ~D~%" (-> obj slave-options))
(format #t "~T~Tview-off-param-save: ~f~%" (-> obj view-off-param-save))
(format #t "~T~Tchanger: #x~X~%" (-> obj changer))
@ -788,18 +784,22 @@
(format #t "~T~TstringMaxLength: ~f~%" (-> obj stringMaxLength))
(format #t "~T~TstringMinHeight: ~f~%" (-> obj stringMinHeight))
(format #t "~T~TstringMaxHeight: ~f~%" (-> obj stringMaxHeight))
(format #t "~T~Tstring-min: #<cam-vector-seeker @ #x~X>~%" (&-> obj stack 48))
(format
#t
"~T~Tstring-min: #<cam-vector-seeker @ #x~X>~%"
(-> obj string-min)
)
(format
#t
"~T~Tstring-max: #<cam-vector-seeker @ #x~X>~%"
(&-> obj stack 112)
(-> obj string-max)
)
(format #t "~T~Tstring-push-z: ~f~%" (-> obj string-push-z))
(format #t "~T~TstringCliffHeight: ~f~%" (-> obj stringCliffHeight))
(format #t "~T~Tno-intro: ~D~%" (-> obj no-intro))
(format #t "~T~Tforce-blend: ~D~%" (-> obj force-blend))
(format #t "~T~Tforce-blend-time: ~D~%" (-> obj force-blend-time))
(format #t "~T~Tlocal-down: ~`vector`P~%" (&-> obj stack 192))
(format #t "~T~Tlocal-down: ~`vector`P~%" (-> obj local-down))
(format #t "~T~Tdrawable-target: ~D~%" (-> obj drawable-target))
(format #t "~T~Twhich-bone: ~D~%" (-> obj which-bone))
(format #t "~T~Tpov-handle: ~D~%" (-> obj pov-handle))
@ -809,28 +809,28 @@
(format #t "~T~Ton-ground: ~A~%" (-> obj on-ground))
(format #t "~T~Tunder-water: ~D~%" (-> obj under-water))
(format #t "~T~Ton-pole: ~A~%" (-> obj on-pole))
(format #t "~T~Ttgt-rot-mat: ~`matrix`P~%" (&-> obj stack 272))
(format #t "~T~Ttgt-face-mat: ~`matrix`P~%" (&-> obj stack 336))
(format #t "~T~Ttpos-old: ~`vector`P~%" (&-> obj stack 400))
(format #t "~T~Ttpos-curr: ~`vector`P~%" (&-> obj stack 416))
(format #t "~T~Ttgt-rot-mat: ~`matrix`P~%" (-> obj tgt-rot-mat))
(format #t "~T~Ttgt-face-mat: ~`matrix`P~%" (-> obj tgt-face-mat))
(format #t "~T~Ttpos-old: ~`vector`P~%" (-> obj tpos-old))
(format #t "~T~Ttpos-curr: ~`vector`P~%" (-> obj tpos-curr))
(format #t "~T~Ttarget-height: ~f~%" (-> obj target-height))
(format #t "~T~Ttpos-old-adj: ~`vector`P~%" (&-> obj stack 448))
(format #t "~T~Ttpos-curr-adj: ~`vector`P~%" (&-> obj stack 464))
(format #t "~T~Ttpos-tgt: ~`vector`P~%" (&-> obj stack 480))
(format #t "~T~Ttpos-old-adj: ~`vector`P~%" (-> obj tpos-old-adj))
(format #t "~T~Ttpos-curr-adj: ~`vector`P~%" (-> obj tpos-curr-adj))
(format #t "~T~Ttpos-tgt: ~`vector`P~%" (-> obj tpos-tgt))
(format #t "~T~Tupspeed: ~f~%" (-> obj upspeed))
(format #t "~T~Tpitch-off: ~`vector`P~%" (&-> obj stack 512))
(format #t "~T~Tpitch-off: ~`vector`P~%" (-> obj pitch-off))
(format #t "~T~Tfoot-offset: ~f~%" (-> obj foot-offset))
(format #t "~T~Thead-offset: ~f~%" (-> obj head-offset))
(format
#t
"~T~Ttarget-spline: #<tracking-spline @ #x~X>~%"
(&-> obj stack 544)
(-> obj target-spline)
)
(format #t "~T~Tease-from: #<vector @ #x~X>~%" (&-> obj stack 2192))
(format #t "~T~Tease-from: #<vector @ #x~X>~%" (-> obj ease-from))
(format #t "~T~Tease-t: ~f~%" (-> obj ease-t))
(format #t "~T~Tease-step: ~f~%" (-> obj ease-step))
(format #t "~T~Tease-to: #<vector @ #x~X>~%" (&-> obj stack 2224))
(format #t "~T~Toutro-curve: #<curve @ #x~X>~%" (&-> obj stack 2240))
(format #t "~T~Tease-to: #<vector @ #x~X>~%" (-> obj ease-to))
(format #t "~T~Toutro-curve: #<curve @ #x~X>~%" (-> obj outro-curve))
(format #t "~T~Toutro-t: ~f~%" (-> obj outro-t))
(format #t "~T~Toutro-t-step: ~f~%" (-> obj outro-t-step))
(format #t "~T~Toutro-exit-value: ~f~%" (-> obj outro-exit-value))

103
test/decompiler/reference/engine/camera/math-camera-h_REF.gc
View file

@ -72,53 +72,54 @@
;; definition of type math-camera
(deftype math-camera (basic)
((d float :offset-assert 4)
(f float :offset-assert 8)
(fov float :offset-assert 12)
(x-ratio float :offset-assert 16)
(y-ratio float :offset-assert 20)
(x-pix float :offset-assert 24)
(x-clip float :offset-assert 28)
(x-clip-ratio-in float :offset-assert 32)
(x-clip-ratio-over float :offset-assert 36)
(y-pix float :offset-assert 40)
(y-clip float :offset-assert 44)
(y-clip-ratio-in float :offset-assert 48)
(y-clip-ratio-over float :offset-assert 52)
(cull-info cull-info :inline :offset-assert 56)
(fog-start float :offset-assert 120)
(fog-end float :offset-assert 124)
(fog-max float :offset-assert 128)
(fog-min float :offset-assert 132)
(reset int32 :offset-assert 136)
(smooth-step float :offset-assert 140)
(smooth-t float :offset-assert 144)
(perspective matrix :inline :offset-assert 160)
(isometric matrix :inline :offset-assert 224)
(sprite-2d matrix :inline :offset-assert 288)
(sprite-2d-hvdf vector :inline :offset-assert 352)
(camera-rot matrix :inline :offset-assert 368)
(inv-camera-rot matrix :inline :offset-assert 432)
(inv-camera-rot-smooth matrix :inline :offset-assert 496)
(inv-camera-rot-smooth-from quaternion :inline :offset-assert 560)
(camera-temp matrix :inline :offset-assert 576)
(prev-camera-temp matrix :inline :offset-assert 640)
(hmge-scale vector :inline :offset-assert 704)
(inv-hmge-scale vector :inline :offset-assert 720)
(hvdf-off vector :inline :offset-assert 736)
(guard vector :inline :offset-assert 752)
(vis-gifs vis-gif-tag 4 :inline :offset-assert 768)
(giftex uint128 :offset 768)
(gifgr uint128 :offset 784)
(giftex-trans uint128 :offset 800)
(gifgr-trans uint128 :offset 816)
(pfog0 float :offset-assert 832)
(pfog1 float :offset-assert 836)
(trans vector :inline :offset-assert 848)
(plane uint128 4 :offset-assert 864)
(guard-plane uint128 4 :offset-assert 928)
(shrub-mat matrix :inline :offset-assert 992)
(fov-correction-factor float :offset-assert 1056)
((d float :offset-assert 4)
(f float :offset-assert 8)
(fov float :offset-assert 12)
(x-ratio float :offset-assert 16)
(y-ratio float :offset-assert 20)
(x-pix float :offset-assert 24)
(x-clip float :offset-assert 28)
(x-clip-ratio-in float :offset-assert 32)
(x-clip-ratio-over float :offset-assert 36)
(y-pix float :offset-assert 40)
(y-clip float :offset-assert 44)
(y-clip-ratio-in float :offset-assert 48)
(y-clip-ratio-over float :offset-assert 52)
(cull-info cull-info :inline :offset-assert 56)
(fog-start float :offset-assert 120)
(fog-end float :offset-assert 124)
(fog-max float :offset-assert 128)
(fog-min float :offset-assert 132)
(reset int32 :offset-assert 136)
(smooth-step float :offset-assert 140)
(smooth-t float :offset-assert 144)
(perspective matrix :inline :offset-assert 160)
(isometric matrix :inline :offset-assert 224)
(sprite-2d matrix :inline :offset-assert 288)
(sprite-2d-hvdf vector :inline :offset-assert 352)
(camera-rot matrix :inline :offset-assert 368)
(inv-camera-rot matrix :inline :offset-assert 432)
(inv-camera-rot-smooth matrix :inline :offset-assert 496)
(inv-camera-rot-smooth-from quaternion :inline :offset-assert 560)
(camera-temp matrix :inline :offset-assert 576)
(prev-camera-temp matrix :inline :offset-assert 640)
(hmge-scale vector :inline :offset-assert 704)
(inv-hmge-scale vector :inline :offset-assert 720)
(hvdf-off vector :inline :offset-assert 736)
(guard vector :inline :offset-assert 752)
(vis-gifs vis-gif-tag 4 :inline :offset-assert 768)
(vis-gifs-quads uint128 4 :offset 768)
(giftex vis-gif-tag :offset 768)
(gifgr vis-gif-tag :offset 784)
(giftex-trans vis-gif-tag :offset 800)
(gifgr-trans vis-gif-tag :offset 816)
(pfog0 float :offset-assert 832)
(pfog1 float :offset-assert 836)
(trans vector :inline :offset-assert 848)
(plane uint128 4 :offset-assert 864)
(guard-plane uint128 4 :offset-assert 928)
(shrub-mat matrix :inline :offset-assert 992)
(fov-correction-factor float :offset-assert 1056)
)
:method-count-assert 9
:size-assert #x424
@ -176,10 +177,10 @@
(format #t "~Thvdf-off: #<vector @ #x~X>~%" (-> obj hvdf-off))
(format #t "~Tguard: #<vector @ #x~X>~%" (-> obj guard))
(format #t "~Tvis-gifs[4] @ #x~X~%" (-> obj vis-gifs))
(format #t "~Tgiftex: ~D~%" (-> obj giftex))
(format #t "~Tgifgr: ~D~%" (-> obj gifgr))
(format #t "~Tgiftex-trans: ~D~%" (-> obj giftex-trans))
(format #t "~Tgifgr-trans: ~D~%" (-> obj gifgr-trans))
(format #t "~Tgiftex: ~D~%" (-> obj vis-gifs-quads 0))
(format #t "~Tgifgr: ~D~%" (-> obj vis-gifs-quads 1))
(format #t "~Tgiftex-trans: ~D~%" (-> obj vis-gifs-quads 2))
(format #t "~Tgifgr-trans: ~D~%" (-> obj vis-gifs-quads 3))
(format #t "~Tpfog0: ~f~%" (-> obj pfog0))
(format #t "~Tpfog1: ~f~%" (-> obj pfog1))
(format #t "~Ttrans: ~`vector`P~%" (-> obj trans))

15
test/decompiler/reference/engine/camera/math-camera_REF.gc
View file

@ -288,11 +288,14 @@
(set! (-> vis-gif-0 0 regs) (the-as uint 1042))
(set! (-> vis-gif-0 0 fan) (the-as uint #x301ec000))
)
(let ((vis-gif-1 (-> math-cam vis-gifs 1)))
(set! (-> vis-gif-1 fog0) (the-as uint pfog))
(set! (-> vis-gif-1 strip) (make-u128 0 (shl #x20164000 32)))
(set! (-> vis-gif-1 regs) (the-as uint 65))
(set! (-> vis-gif-1 fan) (the-as uint #x301ec000))
(let ((vis-gif-1 (&-> math-cam gifgr)))
(set! (-> vis-gif-1 0) (the-as vis-gif-tag pfog))
(set!
(-> vis-gif-1 1)
(the-as vis-gif-tag (make-u128 0 (shl #x20164000 32)))
)
(set! (-> vis-gif-1 2) (the-as vis-gif-tag 65))
(set! (-> vis-gif-1 3) (the-as vis-gif-tag #x301ec000))
)
(let ((vis-gif-1-again (-> math-cam vis-gifs)))
(set! (-> vis-gif-1-again 0 fog0) (the-as uint pfog))
@ -699,7 +702,7 @@
)
(.lvf vf7 (&-> *math-camera* hmge-scale quad))
(.lvf vf8 (&-> *math-camera* hvdf-off quad))
(.lvf vf9 (&-> *math-camera* giftex))
(.lvf vf9 (&-> *math-camera* vis-gifs-quads 0))
(let ((v1-13 255))
(.mov vf6 v1-13)
)

12
test/decompiler/reference/engine/collide/collide-edge-grab-h_REF.gc
View file

@ -38,8 +38,8 @@
(format #t "~Tactor-handle: ~D~%" (-> obj actor-handle))
(format #t "~Thanging-matrix: #<matrix @ #x~X>~%" (-> obj hanging-matrix))
(format #t "~Tedge-vertex[2] @ #x~X~%" (-> obj world-vertex))
(format #t "~Tcenter-hold: ~`vector`P~%" (-> obj world-vertex 2))
(format #t "~Ttri-vertex[3] @ #x~X~%" (-> obj world-vertex 3))
(format #t "~Tcenter-hold: ~`vector`P~%" (-> obj center-hold))
(format #t "~Ttri-vertex[3] @ #x~X~%" (-> obj tri-vertex))
(format #t "~Tleft-hand-hold: #<vector @ #x~X>~%" (-> obj left-hand-hold))
(format #t "~Tright-hand-hold: #<vector @ #x~X>~%" (-> obj right-hand-hold))
(format #t "~Tcenter-hold-old: ~`vector`P~%" (-> obj center-hold-old))
@ -256,12 +256,12 @@
(format
#t
"~Tlocal-player-leap-up-spheres[6] @ #x~X~%"
(-> obj local-player-spheres 6)
(-> obj local-player-leap-up-spheres)
)
(format
#t
"~Tworld-player-leap-up-spheres[6] @ #x~X~%"
(-> obj world-player-spheres 6)
(-> obj world-player-leap-up-spheres)
)
(format #t "~Tverts[64] @ #x~X~%" (-> obj verts))
(format #t "~Tedges[96] @ #x~X~%" (-> obj edges))
@ -318,7 +318,3 @@
;; definition (perm) for symbol *edge-grab-info*, type edge-grab-info
(define-perm *edge-grab-info* edge-grab-info (new 'global 'edge-grab-info))

20
test/decompiler/reference/engine/game/generic-obs-h_REF.gc
View file

@ -38,8 +38,8 @@
(format #t "~T~Tanim-mode: ~A~%" (-> obj anim-mode))
(format #t "~T~Tcur-grab-handle: ~D~%" (-> obj cur-grab-handle))
(format #t "~T~Tcur-target-handle: ~D~%" (-> obj cur-target-handle))
(format #t "~T~Told-grab-pos: ~`vector`P~%" (&-> obj stack 112))
(format #t "~T~Tjoint[4] @ #x~X~%" (&-> obj stack 128))
(format #t "~T~Told-grab-pos: ~`vector`P~%" (-> obj old-grab-pos))
(format #t "~T~Tjoint[4] @ #x~X~%" (-> obj joint))
(format #t "~T~Tnew-post-hook: ~A~%" (-> obj new-post-hook))
(format #t "~T~Tcur-post-hook: ~A~%" (-> obj cur-post-hook))
(format #t "~T~Tclone-copy-trans: ~A~%" (-> obj clone-copy-trans))
@ -72,7 +72,7 @@
(format #t "~T~Tmode: #x~X~%" (-> obj mode))
(format #t "~T~Tenable: ~A~%" (-> obj enable))
(format #t "~T~Tradius: (meters ~m)~%" (-> obj radius))
(format #t "~T~Tworld-sphere: #<sphere @ #x~X>~%" (&-> obj stack 80))
(format #t "~T~Tworld-sphere: #<sphere @ #x~X>~%" (-> obj world-sphere))
obj
)
@ -111,11 +111,11 @@
(format #t "~T~Tduration: ~D~%" (-> obj duration))
(format #t "~T~Tlinger-duration: ~D~%" (-> obj linger-duration))
(format #t "~T~Tstart-time: ~D~%" (-> obj start-time))
(format #t "~T~Toffset: ~`vector`P~%" (&-> obj stack 48))
(format #t "~T~Toffset: ~`vector`P~%" (-> obj offset))
(format #t "~T~Tuserdata: ~A~%" (-> obj userdata))
(format #t "~T~Tuser-time[2] @ #x~X~%" (&-> obj stack 72))
(format #t "~T~Tuser-vector[2] @ #x~X~%" (&-> obj stack 96))
(format #t "~T~Tuser-handle[2] @ #x~X~%" (&-> obj stack 128))
(format #t "~T~Tuser-time[2] @ #x~X~%" (-> obj user-time))
(format #t "~T~Tuser-vector[2] @ #x~X~%" (-> obj user-vector))
(format #t "~T~Tuser-handle[2] @ #x~X~%" (-> obj user-handle))
obj
)
@ -226,7 +226,7 @@
(t9-0 obj)
)
(format #t "~T~Troot: ~A~%" (-> obj root))
(format #t "~T~Tdir: ~`vector`P~%" (&-> obj stack 16))
(format #t "~T~Tdir: ~`vector`P~%" (-> obj dir))
(format #t "~T~Trange: (meters ~m)~%" (-> obj range))
(format #t "~T~Tedge-length: (meters ~m)~%" (-> obj edge-length))
obj
@ -294,8 +294,8 @@
(format #t "~T~Told-global-mask: ~D~%" (-> obj old-global-mask))
(format #t "~T~Tmask-to-clear: ~D~%" (-> obj mask-to-clear))
(format #t "~T~Tcam-joint-index: ~D~%" (-> obj cam-joint-index))
(format #t "~T~Told-pos: #<vector @ #x~X>~%" (&-> obj stack 32))
(format #t "~T~Told-mat-z: #<vector @ #x~X>~%" (&-> obj stack 48))
(format #t "~T~Told-pos: #<vector @ #x~X>~%" (-> obj old-pos))
(format #t "~T~Told-mat-z: #<vector @ #x~X>~%" (-> obj old-mat-z))
(format #t "~T~Thad-valid-frame: ~A~%" (-> obj had-valid-frame))
(format #t "~T~Tborder-value: ~A~%" (-> obj border-value))
(format #t "~T~Tdie?: ~A~%" (-> obj die?))

18
test/decompiler/reference/engine/game/projectiles-h_REF.gc
View file

@ -48,19 +48,19 @@
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 obj)
)
(format #t "~T~Tbase-trans: ~`vector`P~%" (&-> obj stack 64))
(format #t "~T~Ttarget: ~`vector`P~%" (&-> obj stack 80))
(format #t "~T~Ttarget-base: ~`vector`P~%" (&-> obj stack 96))
(format #t "~T~Tparent-base: ~`vector`P~%" (&-> obj stack 112))
(format #t "~T~Tparent-quat: ~`vector`P~%" (&-> obj stack 128))
(format #t "~T~Tbase-vector: ~`vector`P~%" (&-> obj stack 144))
(format #t "~T~Tbase-trans: ~`vector`P~%" (-> obj base-trans))
(format #t "~T~Ttarget: ~`vector`P~%" (-> obj target))
(format #t "~T~Ttarget-base: ~`vector`P~%" (-> obj target-base))
(format #t "~T~Tparent-base: ~`vector`P~%" (-> obj parent-base))
(format #t "~T~Tparent-quat: ~`vector`P~%" (-> obj parent-quat))
(format #t "~T~Tbase-vector: ~`vector`P~%" (-> obj base-vector))
(format #t "~T~Ttimeout: ~D~%" (-> obj timeout))
(format #t "~T~Toptions: ~D~%" (-> obj options))
(format #t "~T~Tlast-target: ~D~%" (-> obj last-target))
(format #t "~T~Tnotify-handle: ~D~%" (-> obj notify-handle))
(format #t "~T~Tmax-speed: ~f~%" (-> obj max-speed))
(format #t "~T~Tmax-turn: ~f~%" (-> obj max-turn))
(format #t "~T~Told-dist[16] @ #x~X~%" (&-> obj stack 200))
(format #t "~T~Told-dist[16] @ #x~X~%" (-> obj old-dist))
(format #t "~T~Told-dist-count: ~D~%" (-> obj old-dist-count))
(format #t "~T~Thits: ~D~%" (-> obj hits))
(format #t "~T~Tmax-hits: ~D~%" (-> obj max-hits))
@ -118,7 +118,3 @@
;; failed to figure out what this is:
(let ((v0-6 0))
)

14
test/decompiler/reference/engine/game/task/task-control-h_REF.gc
View file

@ -162,9 +162,13 @@
(t9-0 obj)
)
(format #t "~T~Ttasks: ~A~%" (-> obj tasks))
(format #t "~T~Tquery: #<gui-query @ #x~X>~%" (&-> obj stack 68))
(format #t "~T~Told-target-pos: #<transformq @ #x~X>~%" (&-> obj stack 96))
(format #t "~T~Tcell-for-task: ~D~%" (-> obj stack 144))
(format #t "~T~Tquery: #<gui-query @ #x~X>~%" (-> obj query))
(format
#t
"~T~Told-target-pos: #<transformq @ #x~X>~%"
(-> obj old-target-pos)
)
(format #t "~T~Tcell-for-task: ~D~%" (-> obj cell-for-task))
(format #t "~T~Tcell-x: ~D~%" (-> obj cell-x))
(format #t "~T~Tcam-joint-index: ~D~%" (-> obj cam-joint-index))
(format #t "~T~Tskippable: ~A~%" (-> obj skippable))
@ -174,12 +178,12 @@
(format #t "~T~Ttalk-message: ~D~%" (-> obj talk-message))
(format #t "~T~Tlast-talk: ~D~%" (-> obj last-talk))
(format #t "~T~Tbounce-away: ~A~%" (-> obj bounce-away))
(format #t "~T~Tambient: #<ambient-control @ #x~X>~%" (&-> obj stack 208))
(format #t "~T~Tambient: #<ambient-control @ #x~X>~%" (-> obj ambient))
(format #t "~T~Tcenter-joint-index: ~D~%" (-> obj center-joint-index))
(format #t "~T~Tdraw-bounds-y-offset: ~f~%" (-> obj draw-bounds-y-offset))
(format #t "~T~Tneck-joint-index: ~D~%" (-> obj neck-joint-index))
(format #t "~T~Tfuel-cell-anim: ~A~%" (-> obj fuel-cell-anim))
(format #t "~T~Tsound-flava: ~D~%" (-> obj stack 240))
(format #t "~T~Tsound-flava: ~D~%" (-> obj sound-flava))
(format #t "~T~Thave-flava: ~A~%" (-> obj have-flava))
(format #t "~T~Tmusic: ~A~%" (-> obj music))
(format #t "~T~Thave-music: ~A~%" (-> obj have-music))

36
test/decompiler/reference/engine/gfx/generic/generic-h_REF.gc
View file

@ -29,12 +29,12 @@
(format #t "~Tquad[2] @ #x~X~%" (-> obj data))
(format #t "~Tvt: #<qword @ #x~X>~%" (-> obj data))
(format #t "~Tpos: #<vector3s @ #x~X>~%" (-> obj data))
(format #t "~Ttex: #<vector2uh @ #x~X>~%" (&-> obj data 3))
(format #t "~Tnrm: #<vector3s @ #x~X>~%" (&-> obj data 4))
(format #t "~Tnc: #<qword @ #x~X>~%" (&-> obj data 4))
(format #t "~Tclr: #<vector4ub @ #x~X>~%" (&-> obj data 7))
(format #t "~Tdtex: #<vector2uh @ #x~X>~%" (&-> obj data 4))
(format #t "~Tdclr: #<vector4ub @ #x~X>~%" (&-> obj data 5))
(format #t "~Ttex: #<vector2uh @ #x~X>~%" (&-> obj vt vector4w w))
(format #t "~Tnrm: #<vector3s @ #x~X>~%" (-> obj nrm))
(format #t "~Tnc: #<qword @ #x~X>~%" (-> obj nrm))
(format #t "~Tclr: #<vector4ub @ #x~X>~%" (&-> obj nc vector4w w))
(format #t "~Tdtex: #<vector2uh @ #x~X>~%" (-> obj nrm))
(format #t "~Tdclr: #<vector4ub @ #x~X>~%" (&-> obj nrm y))
obj
)
@ -169,8 +169,8 @@
(format #t "[~8x] ~A~%" obj 'gsf-buffer)
(format #t "~Tdata[8192] @ #x~X~%" (-> obj data))
(format #t "~Tinfo: #<gsf-info @ #x~X>~%" (-> obj data))
(format #t "~Theader: #<gsf-header @ #x~X>~%" (&-> obj data 16))
(format #t "~Twork-area[0] @ #x~X~%" (&-> obj data 32))
(format #t "~Theader: #<gsf-header @ #x~X>~%" (-> obj header))
(format #t "~Twork-area[0] @ #x~X~%" (-> obj work-area))
obj
)
@ -346,10 +346,10 @@
(format #t "[~8x] ~A~%" obj 'generic-gif-tag)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tqword: #<qword @ #x~X>~%" (-> obj data))
(format #t "~Tfan-prim: ~D~%" (-> obj data 0))
(format #t "~Tstr-prim: ~D~%" (-> obj data 1))
(format #t "~Tregs: ~D~%" (-> obj data 2))
(format #t "~Tnum-strips: ~D~%" (-> obj data 3))
(format #t "~Tfan-prim: ~D~%" (-> obj fan-prim))
(format #t "~Tstr-prim: ~D~%" (-> obj str-prim))
(format #t "~Tregs: ~D~%" (-> obj regs))
(format #t "~Tnum-strips: ~D~%" (-> obj num-strips))
obj
)
@ -379,10 +379,10 @@
(format #t "~Tdata: ~D~%" (-> obj data))
(format #t "~Tcmds: ~D~%" (-> obj cmds))
(format #t "~Tcmd: ~D~%" (-> obj cmd))
(format #t "~Tx: ~D~%" (-> obj word 0))
(format #t "~Ty: ~D~%" (-> obj word 1))
(format #t "~Tz: ~D~%" (-> obj word 2))
(format #t "~Tw: ~D~%" (-> obj word 3))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tw: ~D~%" (-> obj w))
obj
)
@ -495,7 +495,3 @@
*gsf-buffer*
(the-as gsf-buffer (kmalloc global 9216 (kmalloc-flags align-64) "malloc"))
)

4
test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc
View file

@ -20,8 +20,8 @@
(format #t "~Tdata[32] @ #x~X~%" (-> obj data))
(format #t "~Tvector[8] @ #x~X~%" (-> obj data))
(format #t "~Tt-mtx: #<matrix @ #x~X>~%" (-> obj data))
(format #t "~Tn-mtx: #<matrix3 @ #x~X>~%" (&-> obj data 16))
(format #t "~Tscale: #<vector @ #x~X>~%" (&-> obj data 28))
(format #t "~Tn-mtx: #<matrix3 @ #x~X>~%" (-> obj n-mtx))
(format #t "~Tscale: #<vector @ #x~X>~%" (-> obj scale))
obj
)

2
test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc
View file

@ -75,7 +75,7 @@
(format #t "~Tadnop2: #<ad-cmd @ #x~X>~%" (-> obj adnop2))
(format #t "~Tdps: ~D~%" (-> obj dps))
(format #t "~Tkickoff: ~D~%" (-> obj kickoff))
(format #t "~Tstrips: ~D~%" (-> obj strgif qword hword 6))
(format #t "~Tstrips: ~D~%" (-> obj strips))
obj
)

4
test/decompiler/reference/engine/gfx/hw/vu1-user-h_REF.gc
View file

@ -103,8 +103,8 @@
(defmethod inspect dma-foreground-sink-group ((obj dma-foreground-sink-group))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tsink[3] @ #x~X~%" (-> obj sink))
(format #t "~Tmerc-sink: ~A~%" (-> obj sink 0))
(format #t "~Tgeneric-sink: ~A~%" (-> obj sink 1))
(format #t "~Tmerc-sink: ~A~%" (-> obj merc-sink))
(format #t "~Tgeneric-sink: ~A~%" (-> obj generic-sink))
(format #t "~Tlevel: ~A~%" (-> obj level))
obj
)

8
test/decompiler/reference/engine/gfx/lights-h_REF.gc
View file

@ -66,10 +66,10 @@
(format #t "[~8x] ~A~%" obj 'light-ellipse)
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
(format #t "~Tcolor: #<rgbaf @ #x~X>~%" (-> obj color))
(format #t "~Tname: ~A~%" (-> obj matrix vector 0 w))
(format #t "~Tdecay-start: ~f~%" (-> obj matrix vector 1 w))
(format #t "~Tambient-point-ratio: ~f~%" (-> obj matrix vector 2 w))
(format #t "~Tlevel: ~f~%" (-> obj matrix vector 3 w))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tdecay-start: ~f~%" (-> obj decay-start))
(format #t "~Tambient-point-ratio: ~f~%" (-> obj ambient-point-ratio))
(format #t "~Tlevel: ~f~%" (-> obj level))
(format #t "~Tfunc-symbol: ~A~%" (-> obj color w))
(format #t "~Tfunc: ~A~%" (-> obj color w))
obj

10
test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc
View file

@ -23,7 +23,7 @@
(format #t "~Tvertex-skip: ~D~%" (-> obj vertex-skip))
(format #t "~Tvertex-count: ~D~%" (-> obj vertex-count))
(format #t "~Tcurrent-loc: ~D~%" (-> obj current-loc))
(format #t "~Tdata[0] @ #x~X~%" (&-> obj _data 16))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data2))
obj
)
@ -548,10 +548,10 @@
(format #t "~Tdummy-bytes[48] @ #x~X~%" (&-> obj fragment-count))
(format #t "~Tenvmap-tint: ~D~%" (-> obj envmap-tint))
(format #t "~Tquery: ~A~%" (-> obj query))
(format #t "~Tneeds-clip: ~D~%" (-> obj dummy-bytes 8))
(format #t "~Tuse-isometric: ~D~%" (-> obj dummy-bytes 9))
(format #t "~Tuse-attached-shader: ~D~%" (-> obj dummy-bytes 10))
(format #t "~Tdisplay-triangles: ~D~%" (-> obj dummy-bytes 11))
(format #t "~Tneeds-clip: ~D~%" (-> obj needs-clip))
(format #t "~Tuse-isometric: ~D~%" (-> obj use-isometric))
(format #t "~Tuse-attached-shader: ~D~%" (-> obj use-attached-shader))
(format #t "~Tdisplay-triangles: ~D~%" (-> obj display-triangles))
(format #t "~Tdeath-vertex-skip: ~D~%" (-> obj two-mat-count))
(format #t "~Tdeath-start-vertex: ~D~%" (-> obj two-mat-reuse-count))
(format #t "~Tdeath-effect: ~D~%" (-> obj death-effect))

10
test/decompiler/reference/engine/gfx/shrub/shrubbery-h_REF.gc
View file

@ -44,8 +44,8 @@
(format #t "[~8x] ~A~%" obj 'shrub-view-data)
(format #t "~Tdata[3] @ #x~X~%" (-> obj data))
(format #t "~Ttexture-giftag: #<qword @ #x~X>~%" (-> obj data))
(format #t "~Tconsts: #<vector @ #x~X>~%" (&-> obj data 1))
(format #t "~Tfog-clamp: #<vector @ #x~X>~%" (&-> obj data 2))
(format #t "~Tconsts: #<vector @ #x~X>~%" (-> obj consts))
(format #t "~Tfog-clamp: #<vector @ #x~X>~%" (-> obj fog-clamp))
(format #t "~Ttex-start-ptr: ~D~%" (-> obj consts x))
(format #t "~Tgifbufsum: ~f~%" (-> obj consts x))
(format #t "~Tmtx-buf-ptr: ~D~%" (-> obj consts y))
@ -240,9 +240,9 @@
(let ((text-dst2 (the-as qword (+ (the-as int tex-dst) 16)))
(src-2 (the-as qword (&+ (the-as pointer src) 16)))
)
(set! (-> dst data 0) (-> src-2 data 0))
(set! (-> dst data 1) (-> src-2 data 1))
(set! (-> dst data 2) (-> src-2 data 2))
(set! (-> dst vector4w x) (the-as int (-> src-2 data 0)))
(set! (-> dst vector4w y) (the-as int (-> src-2 data 1)))
(set! (-> dst vector4w z) (the-as int (-> src-2 data 2)))
(set! dst (the-as qword (+ (the-as int dst) 16)))
(let ((src-3 (the-as qword (&+ (the-as pointer src-2) 16))))
(dotimes (t0-4 3)

2
test/decompiler/reference/engine/gfx/sky/sky-h_REF.gc
View file

@ -107,7 +107,7 @@
(format #t "[~8x] ~A~%" obj 'sky-moon-data)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj data))
(format #t "~Tscale: #<vector @ #x~X>~%" (&-> obj data 1))
(format #t "~Tscale: #<vector @ #x~X>~%" (-> obj scale))
obj
)

4
test/decompiler/reference/engine/gfx/sparticle/sparticle-launcher-h_REF.gc
View file

@ -206,8 +206,8 @@
(format #t "~Tmatrix: ~D~%" (-> obj matrix))
(format #t "~Tlast-spawn-frame: ~D~%" (-> obj last-spawn-frame))
(format #t "~Tlast-spawn-time: ~D~%" (-> obj last-spawn-time))
(format #t "~Tcenter: ~`vector`P~%" (&-> obj _data 32))
(format #t "~Tdata[0] @ #x~X~%" (&-> obj _data 48))
(format #t "~Tcenter: ~`vector`P~%" (-> obj center))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
obj
)

18
test/decompiler/reference/engine/gfx/texture-h_REF.gc
View file

@ -334,15 +334,15 @@
(format #t "[~8x] ~A~%" obj 'adgif-shader)
(format #t "~Tquad[5] @ #x~X~%" (-> obj quad))
(format #t "~Tprims[10] @ #x~X~%" (-> obj quad))
(format #t "~Ttex0: #x~X~%" (-> obj quad 0 dword 0))
(format #t "~Ttex1: #x~X~%" (-> obj quad 1 dword 0))
(format #t "~Tmiptbp1: #x~X~%" (-> obj quad 2 dword 0))
(format #t "~Tclamp: #x~X~%" (-> obj quad 3 dword 0))
(format #t "~Tclamp-reg: ~D~%" (-> obj quad 3 dword 1))
(format #t "~Talpha: #x~X~%" (-> obj quad 4 dword 0))
(format #t "~Tlink-test: ~D~%" (-> obj quad 0 data 2))
(format #t "~Ttexture-id: ~D~%" (-> obj quad 1 data 2))
(format #t "~Tnext: #x~X~%" (-> obj quad 2 data 2))
(format #t "~Ttex0: #x~X~%" (-> obj tex0))
(format #t "~Ttex1: #x~X~%" (-> obj tex1))
(format #t "~Tmiptbp1: #x~X~%" (-> obj miptbp1))
(format #t "~Tclamp: #x~X~%" (-> obj clamp))
(format #t "~Tclamp-reg: ~D~%" (-> obj clamp-reg))
(format #t "~Talpha: #x~X~%" (-> obj alpha))
(format #t "~Tlink-test: ~D~%" (-> obj link-test))
(format #t "~Ttexture-id: ~D~%" (-> obj texture-id))
(format #t "~Tnext: #x~X~%" (-> obj next))
obj
)

24
test/decompiler/reference/engine/gfx/tfrag/subdivide-h_REF.gc
View file

@ -62,7 +62,7 @@
(format #t "~Tdata[32] @ #x~X~%" (-> obj data))
(format #t "~Tvector[8] @ #x~X~%" (-> obj data))
(format #t "~Tk0s[4] @ #x~X~%" (-> obj data))
(format #t "~Tk1s[4] @ #x~X~%" (&-> obj data 16))
(format #t "~Tk1s[4] @ #x~X~%" (-> obj k1s))
obj
)
@ -83,10 +83,10 @@
(defmethod inspect gs-packed-rgba ((obj gs-packed-rgba))
(format #t "[~8x] ~A~%" obj 'gs-packed-rgba)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tred: ~D~%" (-> obj data 0))
(format #t "~Tgreen: ~D~%" (-> obj data 1))
(format #t "~Tblue: ~D~%" (-> obj data 2))
(format #t "~Talpha: ~D~%" (-> obj data 3))
(format #t "~Tred: ~D~%" (-> obj red))
(format #t "~Tgreen: ~D~%" (-> obj green))
(format #t "~Tblue: ~D~%" (-> obj blue))
(format #t "~Talpha: ~D~%" (-> obj alpha))
obj
)
@ -109,10 +109,10 @@
(defmethod inspect gs-packed-xyzw ((obj gs-packed-xyzw))
(format #t "[~8x] ~A~%" obj 'gs-packed-xyzw)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tz: ~D~%" (-> obj data 2))
(format #t "~Tw: ~D~%" (-> obj data 3))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tw: ~D~%" (-> obj w))
(format #t "~Tquad: ~D~%" (-> obj quad))
obj
)
@ -135,9 +135,9 @@
(defmethod inspect gs-packed-stq ((obj gs-packed-stq))
(format #t "[~8x] ~A~%" obj 'gs-packed-stq)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Ttex-s: ~f~%" (-> obj data 0))
(format #t "~Ttex-t: ~f~%" (-> obj data 1))
(format #t "~Ttex-q: ~f~%" (-> obj data 2))
(format #t "~Ttex-s: ~f~%" (-> obj tex-s))
(format #t "~Ttex-t: ~f~%" (-> obj tex-t))
(format #t "~Ttex-q: ~f~%" (-> obj tex-q))
(format #t "~Tquad: ~D~%" (-> obj quad))
obj
)

36
test/decompiler/reference/engine/gfx/tfrag/tfrag-h_REF.gc
View file

@ -95,12 +95,12 @@
(format #t "~Tcolor-indices: #x~X~%" (-> obj color-indices))
(format #t "~Tcolors: #x~X~%" (-> obj color-indices))
(format #t "~Tdma-chain[3] @ #x~X~%" (-> obj dma-chain))
(format #t "~Tdma-common: #x~X~%" (-> obj dma-chain 0))
(format #t "~Tdma-level-0: #x~X~%" (-> obj dma-chain 0))
(format #t "~Tdma-base: #x~X~%" (-> obj dma-chain 1))
(format #t "~Tdma-level-1: #x~X~%" (-> obj dma-chain 2))
(format #t "~Tdma-common: #x~X~%" (-> obj dma-common))
(format #t "~Tdma-level-0: #x~X~%" (-> obj dma-common))
(format #t "~Tdma-base: #x~X~%" (-> obj dma-base))
(format #t "~Tdma-level-1: #x~X~%" (-> obj dma-level-1))
(format #t "~Tdma-qwc[4] @ #x~X~%" (-> obj dma-qwc))
(format #t "~Tshader: #x~X~%" (-> obj dma-qwc 1))
(format #t "~Tshader: #x~X~%" (-> obj shader))
(format #t "~Tnum-shaders: ~D~%" (-> obj num-shaders))
(format #t "~Tnum-base-colors: ~D~%" (-> obj num-base-colors))
(format #t "~Tnum-level0-colors: ~D~%" (-> obj num-level0-colors))
@ -199,7 +199,7 @@
(format #t "~Tdata[16] @ #x~X~%" (-> obj data))
(format #t "~Tvector[4] @ #x~X~%" (-> obj data))
(format #t "~Tk0s[2] @ #x~X~%" (-> obj data))
(format #t "~Tk1s[2] @ #x~X~%" (&-> obj data 8))
(format #t "~Tk1s[2] @ #x~X~%" (-> obj k1s))
obj
)
@ -232,18 +232,18 @@
(format #t "~Tdata[56] @ #x~X~%" (-> obj data))
(format #t "~Tvector[14] @ #x~X~%" (-> obj data))
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj data))
(format #t "~Tval: #<vector @ #x~X>~%" (&-> obj data 4))
(format #t "~Tstrgif: #<qword @ #x~X>~%" (&-> obj data 8))
(format #t "~Tfangif: #<qword @ #x~X>~%" (&-> obj data 12))
(format #t "~Tadgif: #<qword @ #x~X>~%" (&-> obj data 16))
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (&-> obj data 20))
(format #t "~Thmge-scale: #<vector @ #x~X>~%" (&-> obj data 24))
(format #t "~Tinvh-scale: #<vector @ #x~X>~%" (&-> obj data 28))
(format #t "~Tambient: #<vector @ #x~X>~%" (&-> obj data 32))
(format #t "~Tguard: #<vector @ #x~X>~%" (&-> obj data 36))
(format #t "~Tdists: #<tfrag-dists @ #x~X>~%" (&-> obj data 40))
(format #t "~Tk0s[2] @ #x~X~%" (&-> obj data 40))
(format #t "~Tk1s[2] @ #x~X~%" (&-> obj data 48))
(format #t "~Tval: #<vector @ #x~X>~%" (-> obj val))
(format #t "~Tstrgif: #<qword @ #x~X>~%" (-> obj strgif))
(format #t "~Tfangif: #<qword @ #x~X>~%" (-> obj fangif))
(format #t "~Tadgif: #<qword @ #x~X>~%" (-> obj adgif))
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (-> obj hvdf-offset))
(format #t "~Thmge-scale: #<vector @ #x~X>~%" (-> obj hmge-scale))
(format #t "~Tinvh-scale: #<vector @ #x~X>~%" (-> obj invh-scale))
(format #t "~Tambient: #<vector @ #x~X>~%" (-> obj ambient))
(format #t "~Tguard: #<vector @ #x~X>~%" (-> obj guard))
(format #t "~Tdists: #<tfrag-dists @ #x~X>~%" (-> obj dists))
(format #t "~Tk0s[2] @ #x~X~%" (-> obj dists))
(format #t "~Tk1s[2] @ #x~X~%" (-> obj dists k1s))
obj
)

20
test/decompiler/reference/engine/gfx/tie/prototype_REF.gc
View file

@ -16,14 +16,14 @@
(let ((s4-1 (-> s4-0 envmap-shader)))
(when (nonzero? s4-1)
(adgif-shader-login-no-remap s4-1)
(set! (-> s4-1 quad 1 dword 0) (the-as uint 96))
(set! (-> s4-1 quad 3 dword 0) (the-as uint 5))
(set! (-> s4-1 quad 4 dword 0) (the-as uint 88))
(set! (-> s4-1 quad 0 dword 1) (the-as uint 6))
(set! (-> s4-1 quad 1 dword 1) (the-as uint 20))
(set! (-> s4-1 quad 2 dword 1) (the-as uint 52))
(set! (-> s4-1 quad 3 dword 1) (the-as uint 8))
(set! (-> s4-1 quad 4 dword 1) (the-as uint 66))
(set! (-> s4-1 tex1) (the-as uint 96))
(set! (-> s4-1 clamp) (the-as uint 5))
(set! (-> s4-1 alpha) (the-as uint 88))
(set! (-> s4-1 prims 1) (the-as uint 6))
(set! (-> s4-1 prims 3) (the-as uint 20))
(set! (-> s4-1 prims 5) (the-as uint 52))
(set! (-> s4-1 clamp-reg) (the-as uint 8))
(set! (-> s4-1 prims 9) (the-as uint 66))
)
)
)
@ -168,7 +168,3 @@
)
obj
)

8
test/decompiler/reference/engine/gfx/water/water-h_REF.gc
View file

@ -74,10 +74,10 @@
(format #t "~Tbottom-height: (meters ~m)~%" (-> obj bottom-height))
(format #t "~Theight: (meters ~m)~%" (-> obj height))
(format #t "~Theight-offset[4] @ #x~X~%" (-> obj height-offset))
(format #t "~Treal-ocean-offset: (meters ~m)~%" (-> obj height-offset 0))
(format #t "~Tocean-offset: (meters ~m)~%" (-> obj height-offset 1))
(format #t "~Tbob-offset: (meters ~m)~%" (-> obj height-offset 2))
(format #t "~Talign-offset: (meters ~m)~%" (-> obj height-offset 3))
(format #t "~Treal-ocean-offset: (meters ~m)~%" (-> obj real-ocean-offset))
(format #t "~Tocean-offset: (meters ~m)~%" (-> obj ocean-offset))
(format #t "~Tbob-offset: (meters ~m)~%" (-> obj bob-offset))
(format #t "~Talign-offset: (meters ~m)~%" (-> obj align-offset))
(format #t "~Tswim-depth: (meters ~m)~%" (-> obj swim-depth))
(format #t "~Tbob: #<smush-control @ #x~X>~%" (-> obj bob))
(format #t "~Tvolume: ~D~%" (-> obj volume))

6
test/decompiler/reference/engine/level/level-h_REF.gc
View file

@ -87,9 +87,9 @@
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname-list[3] @ #x~X~%" (-> obj name-list))
(format #t "~Tindex: ~D~%" (-> obj index))
(format #t "~Tname: ~A~%" (-> obj name-list 0))
(format #t "~Tvisname: ~A~%" (-> obj name-list 1))
(format #t "~Tnickname: ~A~%" (-> obj name-list 2))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tvisname: ~A~%" (-> obj visname))
(format #t "~Tnickname: ~A~%" (-> obj nickname))
(format #t "~Tpackages: ~A~%" (-> obj packages))
(format #t "~Tsound-banks: ~A~%" (-> obj sound-banks))
(format #t "~Tmusic-bank: ~A~%" (-> obj music-bank))

24
test/decompiler/reference/engine/math/matrix_REF.gc
View file

@ -223,15 +223,15 @@
(defun vector3s-matrix*! ((dst vector3s) (vec vector3s) (mat matrix))
(let ((temp-vec3 (new-stack-vector0)))
(let ((v1-0 temp-vec3))
(set! (-> v1-0 x) (-> vec data 0))
(set! (-> v1-0 y) (-> vec data 1))
(set! (-> v1-0 z) (-> vec data 2))
(set! (-> v1-0 x) (-> vec x))
(set! (-> v1-0 y) (-> vec y))
(set! (-> v1-0 z) (-> vec z))
(set! (-> v1-0 w) 1.0)
)
(vector-matrix*! temp-vec3 temp-vec3 mat)
(set! (-> dst data 0) (-> temp-vec3 x))
(set! (-> dst data 1) (-> temp-vec3 y))
(set! (-> dst data 2) (-> temp-vec3 z))
(set! (-> dst x) (-> temp-vec3 x))
(set! (-> dst y) (-> temp-vec3 y))
(set! (-> dst z) (-> temp-vec3 z))
)
dst
)
@ -241,15 +241,15 @@
(defun vector3s-rotate*! ((dst vector3s) (vec vector3s) (mat matrix))
(let ((temp-vec3 (new-stack-vector0)))
(let ((v1-0 temp-vec3))
(set! (-> v1-0 x) (-> vec data 0))
(set! (-> v1-0 y) (-> vec data 1))
(set! (-> v1-0 z) (-> vec data 2))
(set! (-> v1-0 x) (-> vec x))
(set! (-> v1-0 y) (-> vec y))
(set! (-> v1-0 z) (-> vec z))
(set! (-> v1-0 w) 1.0)
)
(vector-rotate*! temp-vec3 temp-vec3 mat)
(set! (-> dst data 0) (-> temp-vec3 x))
(set! (-> dst data 1) (-> temp-vec3 y))
(set! (-> dst data 2) (-> temp-vec3 z))
(set! (-> dst x) (-> temp-vec3 x))
(set! (-> dst y) (-> temp-vec3 y))
(set! (-> dst z) (-> temp-vec3 z))
)
dst
)

52
test/decompiler/reference/engine/math/vector-h_REF.gc
View file

@ -125,10 +125,10 @@
(defmethod inspect vector4ub ((obj vector4ub))
(format #t "[~8x] ~A~%" obj 'vector4ub)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tz: ~D~%" (-> obj data 2))
(format #t "~Tw: ~D~%" (-> obj data 3))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tw: ~D~%" (-> obj w))
(format #t "~Tclr: ~D~%" (-> obj clr))
obj
)
@ -150,10 +150,10 @@
(defmethod inspect vector4b ((obj vector4b))
(format #t "[~8x] ~A~%" obj 'vector4b)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tz: ~D~%" (-> obj data 2))
(format #t "~Tw: ~D~%" (-> obj data 3))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tw: ~D~%" (-> obj w))
obj
)
@ -173,8 +173,8 @@
(defmethod inspect vector2h ((obj vector2h))
(format #t "[~8x] ~A~%" obj 'vector2h)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
obj
)
@ -195,8 +195,8 @@
(defmethod inspect vector2uh ((obj vector2uh))
(format #t "[~8x] ~A~%" obj 'vector2uh)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tval: ~D~%" (-> obj val))
obj
)
@ -217,8 +217,8 @@
(defmethod inspect vector3h ((obj vector3h))
(format #t "[~8x] ~A~%" obj 'vector3h)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
obj
)
@ -239,8 +239,8 @@
(defmethod inspect vector2w ((obj vector2w))
(format #t "[~8x] ~A~%" obj 'vector2w)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
obj
)
@ -388,10 +388,10 @@
(defmethod inspect vector4h ((obj vector4h))
(format #t "[~8x] ~A~%" obj 'vector4h)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~D~%" (-> obj data 0))
(format #t "~Ty: ~D~%" (-> obj data 1))
(format #t "~Tz: ~D~%" (-> obj data 2))
(format #t "~Tw: ~D~%" (-> obj data 3))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tw: ~D~%" (-> obj w))
(format #t "~Tlong: ~D~%" (-> obj long))
obj
)
@ -658,7 +658,7 @@
(format #t "~Tquad[2] @ #x~X~%" (-> obj data))
(format #t "~Tvector[2] @ #x~X~%" (-> obj data))
(format #t "~Tmin: #<vector @ #x~X>~%" (-> obj data))
(format #t "~Tmax: #<vector @ #x~X>~%" (&-> obj data 4))
(format #t "~Tmax: #<vector @ #x~X>~%" (-> obj max))
obj
)
@ -815,9 +815,9 @@
(defmethod inspect vector3s ((obj vector3s))
(format #t "[~8x] ~A~%" obj 'vector3s)
(format #t "~Tdata[3] @ #x~X~%" (-> obj data))
(format #t "~Tx: ~f~%" (-> obj data 0))
(format #t "~Ty: ~f~%" (-> obj data 1))
(format #t "~Tz: ~f~%" (-> obj data 2))
(format #t "~Tx: ~f~%" (-> obj x))
(format #t "~Ty: ~f~%" (-> obj y))
(format #t "~Tz: ~f~%" (-> obj z))
obj
)
@ -963,7 +963,3 @@
;; definition for symbol *zero-vector*, type vector
(define *zero-vector* (new 'static 'vector))

10
test/decompiler/reference/engine/ps2/memcard-h_REF.gc
View file

@ -32,11 +32,11 @@
(format #t "~Tpresent: ~D~%" (-> obj present))
(format #t "~Tblind-data[16] @ #x~X~%" (-> obj blind-data))
(format #t "~Tblind-data-int8[64] @ #x~X~%" (-> obj blind-data))
(format #t "~Tlevel-index: ~D~%" (-> obj blind-data 0))
(format #t "~Tfuel-cell-count: ~f~%" (-> obj blind-data 1))
(format #t "~Tmoney-count: ~f~%" (-> obj blind-data 2))
(format #t "~Tbuzzer-count: ~f~%" (-> obj blind-data 3))
(format #t "~Tcompletion-percentage: ~f~%" (-> obj blind-data 4))
(format #t "~Tlevel-index: ~D~%" (-> obj level-index))
(format #t "~Tfuel-cell-count: ~f~%" (-> obj fuel-cell-count))
(format #t "~Tmoney-count: ~f~%" (-> obj money-count))
(format #t "~Tbuzzer-count: ~f~%" (-> obj buzzer-count))
(format #t "~Tcompletion-percentage: ~f~%" (-> obj completion-percentage))
(format #t "~Tminute: #x~X~%" (-> obj minute))
(format #t "~Thour: #x~X~%" (-> obj hour))
(format #t "~Tweek: #x~X~%" (-> obj week))

76
test/decompiler/reference/engine/sound/gsound-h_REF.gc
View file

@ -617,63 +617,95 @@
(defmethod inspect sound-rpc-union ((obj sound-rpc-union))
(format #t "[~8x] ~A~%" obj 'sound-rpc-union)
(format #t "~Tdata[20] @ #x~X~%" (-> obj data))
(format #t "~Tload-bank: #<sound-rpc-load-bank @ #x~X>~%" (-> obj data 0))
(format #t "~Tunload-bank: #<sound-rpc-unload-bank @ #x~X>~%" (-> obj data 0))
(format #t "~Tplay: #<sound-rpc-play @ #x~X>~%" (-> obj data 0))
(format #t "~Tpause-sound: #<sound-rpc-pause-sound @ #x~X>~%" (-> obj data 0))
(format #t "~Tstop-sound: #<sound-rpc-stop-sound @ #x~X>~%" (-> obj data 0))
(format #t "~Tload-bank: #<sound-rpc-load-bank @ #x~X>~%" (-> obj load-bank))
(format
#t
"~Tunload-bank: #<sound-rpc-unload-bank @ #x~X>~%"
(-> obj load-bank)
)
(format #t "~Tplay: #<sound-rpc-play @ #x~X>~%" (-> obj load-bank))
(format
#t
"~Tpause-sound: #<sound-rpc-pause-sound @ #x~X>~%"
(-> obj load-bank)
)
(format
#t
"~Tstop-sound: #<sound-rpc-stop-sound @ #x~X>~%"
(-> obj load-bank)
)
(format
#t
"~Tcontinue-sound: #<sound-rpc-continue-sound @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format #t "~Tset-param: #<sound-rpc-set-param @ #x~X>~%" (-> obj data 0))
(format #t "~Tset-param: #<sound-rpc-set-param @ #x~X>~%" (-> obj load-bank))
(format
#t
"~Tset-master-volume: #<sound-rpc-set-master-volume @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Tpause-group: #<sound-rpc-pause-group @ #x~X>~%"
(-> obj load-bank)
)
(format
#t
"~Tstop-group: #<sound-rpc-stop-group @ #x~X>~%"
(-> obj load-bank)
)
(format #t "~Tpause-group: #<sound-rpc-pause-group @ #x~X>~%" (-> obj data 0))
(format #t "~Tstop-group: #<sound-rpc-stop-group @ #x~X>~%" (-> obj data 0))
(format
#t
"~Tcontinue-group: #<sound-rpc-continue-group @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Tget-irx-version: #<sound-rpc-get-irx-version @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Tset-falloff-curve: #<sound-rpc-set-falloff-curve @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Tset-sound-falloff: #<sound-rpc-set-sound-falloff @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Treload-info: #<sound-rpc-reload-info @ #x~X>~%"
(-> obj load-bank)
)
(format #t "~Treload-info: #<sound-rpc-reload-info @ #x~X>~%" (-> obj data 0))
(format
#t
"~Tset-language: #<sound-rpc-set-language @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format
#t
"~Tset-reverb: #<sound-rpc-set-reverb @ #x~X>~%"
(-> obj load-bank)
)
(format #t "~Tset-reverb: #<sound-rpc-set-reverb @ #x~X>~%" (-> obj data 0))
(format
#t
"~Tset-ear-trans: #<sound-rpc-set-ear-trans @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
(format #t "~Tset-flava: #<sound-rpc-set-flava @ #x~X>~%" (-> obj load-bank))
(format #t "~Tshutdown: #<sound-rpc-shutdown @ #x~X>~%" (-> obj load-bank))
(format
#t
"~Tlist-sounds: #<sound-rpc-list-sounds @ #x~X>~%"
(-> obj load-bank)
)
(format #t "~Tset-flava: #<sound-rpc-set-flava @ #x~X>~%" (-> obj data 0))
(format #t "~Tshutdown: #<sound-rpc-shutdown @ #x~X>~%" (-> obj data 0))
(format #t "~Tlist-sounds: #<sound-rpc-list-sounds @ #x~X>~%" (-> obj data 0))
(format
#t
"~Tunload-music: #<sound-rpc-unload-music @ #x~X>~%"
(-> obj data 0)
(-> obj load-bank)
)
obj
)

2
test/decompiler/reference/engine/target/joint-mod-h_REF.gc
View file

@ -404,7 +404,7 @@
(a0-5 (new 'stack-no-clear 'vector))
)
(let ((v1-6 (-> gp-0 target))
(a1-5 (-> csp bone transform vector 3))
(a1-5 (-> csp bone position))
)
(.lvf vf4 (&-> v1-6 quad))
(.lvf vf5 (&-> a1-5 quad))

14
test/decompiler/reference/engine/target/target-h_REF.gc
View file

@ -52,17 +52,21 @@
(format #t "~T~Tcam-user-mode: ~A~%" (-> obj cam-user-mode))
(format #t "~T~Tsidekick: #x~X~%" (-> obj sidekick))
(format #t "~T~Tmanipy: #x~X~%" (-> obj manipy))
(format #t "~T~Tattack-info: #<attack-info @ #x~X>~%" (&-> obj stack 112))
(format #t "~T~Tattack-info-rec: #<attack-info @ #x~X>~%" (&-> obj stack 224))
(format #t "~T~Tattack-info: #<attack-info @ #x~X>~%" (-> obj attack-info))
(format
#t
"~T~Tattack-info-rec: #<attack-info @ #x~X>~%"
(-> obj attack-info-rec)
)
(format #t "~T~Tanim-seed: ~D~%" (-> obj anim-seed))
(format #t "~T~Talt-cam-pos: ~`vector`P~%" (&-> obj stack 336))
(format #t "~T~Talt-cam-pos: ~`vector`P~%" (-> obj alt-cam-pos))
(format #t "~T~Tsnowball: ~A~%" (-> obj snowball))
(format #t "~T~Ttube: ~A~%" (-> obj tube))
(format #t "~T~Tflut: ~A~%" (-> obj flut))
(format #t "~T~Tcurrent-level: ~A~%" (-> obj current-level))
(format #t "~T~Tsaved-pos: #<transformq @ #x~X>~%" (&-> obj stack 368))
(format #t "~T~Tsaved-pos: #<transformq @ #x~X>~%" (-> obj saved-pos))
(format #t "~T~Tsaved-owner: ~D~%" (-> obj saved-owner))
(format #t "~T~Talt-neck-pos: ~`vector`P~%" (&-> obj stack 432))
(format #t "~T~Talt-neck-pos: ~`vector`P~%" (-> obj alt-neck-pos))
(format #t "~T~Tfp-hud: ~D~%" (-> obj fp-hud))
(format #t "~T~Tno-load-wait: ~D~%" (-> obj no-load-wait))
(format #t "~T~Tno-look-around-wait: ~D~%" (-> obj no-look-around-wait))

4
test/decompiler/reference/engine/ui/hud-h_REF.gc
View file

@ -126,10 +126,10 @@
(format #t "~T~Ttrigger-time: ~D~%" (-> obj trigger-time))
(format #t "~T~Tlast-hide-time: ~D~%" (-> obj last-hide-time))
(format #t "~T~Tnb-of-icons: ~D~%" (-> obj nb-of-icons))
(format #t "~T~Ticons[6] @ #x~X~%" (&-> obj stack 108))
(format #t "~T~Ticons[6] @ #x~X~%" (-> obj icons))
(format #t "~T~Tmax-nb-of-particles: ~D~%" (-> obj max-nb-of-particles))
(format #t "~T~Tnb-of-particles: ~D~%" (-> obj nb-of-particles))
(format #t "~T~Tparticles[7] @ #x~X~%" (&-> obj stack 140))
(format #t "~T~Tparticles[7] @ #x~X~%" (-> obj particles))
obj
)

14
test/decompiler/reference/engine/ui/progress-h_REF.gc
View file

@ -289,15 +289,15 @@
(-> obj last-option-index-change)
)
(format #t "~T~Tvideo-mode-timeout: ~D~%" (-> obj video-mode-timeout))
(format #t "~T~Tdisplay-state-stack[5] @ #x~X~%" (&-> obj stack 200))
(format #t "~T~Toption-index-stack[5] @ #x~X~%" (&-> obj stack 240))
(format #t "~T~Tdisplay-state-stack[5] @ #x~X~%" (-> obj display-state-stack))
(format #t "~T~Toption-index-stack[5] @ #x~X~%" (-> obj option-index-stack))
(format #t "~T~Tdisplay-state-pos: ~D~%" (-> obj display-state-pos))
(format #t "~T~Tnb-of-icons: ~D~%" (-> obj nb-of-icons))
(format #t "~T~Ticons[6] @ #x~X~%" (&-> obj stack 268))
(format #t "~T~Ticons[6] @ #x~X~%" (-> obj icons))
(format #t "~T~Tmax-nb-of-particles: ~D~%" (-> obj max-nb-of-particles))
(format #t "~T~Tnb-of-particles: ~D~%" (-> obj nb-of-particles))
(format #t "~T~Tparticles[40] @ #x~X~%" (&-> obj stack 300))
(format #t "~T~Tparticle-state[40] @ #x~X~%" (&-> obj stack 460))
(format #t "~T~Tparticles[40] @ #x~X~%" (-> obj particles))
(format #t "~T~Tparticle-state[40] @ #x~X~%" (-> obj particle-state))
obj
)
@ -310,7 +310,3 @@
;; failed to figure out what this is:
(let ((v0-12 0))
)

40
test/decompiler/reference/levels/beach/air-h_REF.gc
View file

@ -21,28 +21,28 @@
(defmethod inspect air-box ((obj air-box))
(format #t "[~8x] ~A~%" obj 'air-box)
(format #t "~Tvecs[2] @ #x~X~%" (-> obj vecs))
(format #t "~Tx-pos: ~f~%" (the-as float (-> obj vecs 0 x)))
(format #t "~Theight-level: ~f~%" (the-as float (-> obj vecs 0 y)))
(format #t "~Tz-pos: ~f~%" (the-as float (-> obj vecs 0 z)))
(format #t "~Tcos-angle: ~f~%" (-> obj vecs 0 w))
(format #t "~Tx-length: ~f~%" (-> obj vecs 1 x))
(format #t "~Tz-length: ~f~%" (-> obj vecs 1 z))
(format #t "~Tsin-angle: ~f~%" (-> obj vecs 1 w))
(format #t "~Tx-pos: ~f~%" (the-as float (-> obj x-pos)))
(format #t "~Theight-level: ~f~%" (the-as float (-> obj height-level)))
(format #t "~Tz-pos: ~f~%" (the-as float (-> obj z-pos)))
(format #t "~Tcos-angle: ~f~%" (-> obj cos-angle))
(format #t "~Tx-length: ~f~%" (-> obj x-length))
(format #t "~Tz-length: ~f~%" (-> obj z-length))
(format #t "~Tsin-angle: ~f~%" (-> obj sin-angle))
obj
)
;; definition for function point-in-air-box-area?
(defun point-in-air-box-area? ((arg0 float) (arg1 float) (arg2 air-box))
(let ((v0-0 #f))
(let ((f0-2 (+ (* arg0 (-> arg2 vecs 0 w)) (* arg1 (-> arg2 vecs 1 w))))
(f1-5 (- (* arg1 (-> arg2 vecs 0 w)) (* arg0 (-> arg2 vecs 1 w))))
(let ((f0-2 (+ (* arg0 (-> arg2 cos-angle)) (* arg1 (-> arg2 sin-angle))))
(f1-5 (- (* arg1 (-> arg2 cos-angle)) (* arg0 (-> arg2 sin-angle))))
)
(if
(and
(>= f0-2 0.0)
(>= f1-5 0.0)
(< f0-2 (-> arg2 vecs 1 x))
(< f1-5 (-> arg2 vecs 1 z))
(< f0-2 (-> arg2 x-length))
(< f1-5 (-> arg2 z-length))
)
(set! v0-0 #t)
)
@ -53,21 +53,21 @@
;; definition for function point-in-air-box?
(defun point-in-air-box? ((arg0 vector) (arg1 air-box))
(when (< (-> arg1 vecs 0 y) (-> arg0 y))
(let ((f1-2 (- (-> arg0 x) (the-as float (-> arg1 vecs 0 x))))
(f2-1 (- (-> arg0 z) (-> arg1 vecs 0 z)))
(when (< (-> arg1 height-level) (-> arg0 y))
(let ((f1-2 (- (-> arg0 x) (the-as float (-> arg1 x-pos))))
(f2-1 (- (-> arg0 z) (-> arg1 z-pos)))
(v1-0 arg1)
(v0-0 #f)
)
(let ((f0-5 (+ (* f1-2 (-> v1-0 vecs 0 w)) (* f2-1 (-> v1-0 vecs 1 w))))
(f1-4 (- (* f2-1 (-> v1-0 vecs 0 w)) (* f1-2 (-> v1-0 vecs 1 w))))
(let ((f0-5 (+ (* f1-2 (-> v1-0 cos-angle)) (* f2-1 (-> v1-0 sin-angle))))
(f1-4 (- (* f2-1 (-> v1-0 cos-angle)) (* f1-2 (-> v1-0 sin-angle))))
)
(if
(and
(>= f0-5 0.0)
(>= f1-4 0.0)
(< f0-5 (-> v1-0 vecs 1 x))
(< f1-4 (-> v1-0 vecs 1 z))
(< f0-5 (-> v1-0 x-length))
(< f1-4 (-> v1-0 z-length))
)
(set! v0-0 #t)
)
@ -80,7 +80,3 @@
;; failed to figure out what this is:
(let ((v0-2 0))
)

18
test/decompiler/reference/levels/common/nav-enemy-h_REF.gc
View file

@ -233,11 +233,15 @@
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 obj)
)
(format #t "~T~Thit-from-dir: ~`vector`P~%" (&-> obj stack 64))
(format #t "~T~Tevent-param-point: ~`vector`P~%" (&-> obj stack 80))
(format #t "~T~Tfrustration-point: ~`vector`P~%" (&-> obj stack 96))
(format #t "~T~Tjump-dest: ~`vector`P~%" (&-> obj stack 112))
(format #t "~T~Tjump-trajectory: #<trajectory @ #x~X>~%" (&-> obj stack 128))
(format #t "~T~Thit-from-dir: ~`vector`P~%" (-> obj hit-from-dir))
(format #t "~T~Tevent-param-point: ~`vector`P~%" (-> obj event-param-point))
(format #t "~T~Tfrustration-point: ~`vector`P~%" (-> obj frustration-point))
(format #t "~T~Tjump-dest: ~`vector`P~%" (-> obj jump-dest))
(format
#t
"~T~Tjump-trajectory: #<trajectory @ #x~X>~%"
(-> obj jump-trajectory)
)
(format #t "~T~Tjump-time: ~D~%" (-> obj jump-time))
(format #t "~T~Tnav-info: ~A~%" (-> obj nav-info))
(format #t "~T~Ttarget-speed: ~f~%" (-> obj target-speed))
@ -263,7 +267,3 @@
;; failed to figure out what this is:
(let ((v0-4 0))
)