mirror of https://github.com/mgba-emu/mgba.git
585 lines
16 KiB
C
585 lines
16 KiB
C
/* Copyright (c) 2013-2022 Jeffrey Pfau
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
#include <mgba/core/core.h>
|
|
#include <mgba/core/scripting.h>
|
|
#include <mgba/core/version.h>
|
|
#include <mgba/script/context.h>
|
|
#include <mgba-util/string.h>
|
|
|
|
struct mScriptContext context;
|
|
struct Table types;
|
|
FILE* out;
|
|
|
|
const struct mScriptType* const baseTypes[] = {
|
|
mSCRIPT_TYPE_MS_S8,
|
|
mSCRIPT_TYPE_MS_U8,
|
|
mSCRIPT_TYPE_MS_S16,
|
|
mSCRIPT_TYPE_MS_U16,
|
|
mSCRIPT_TYPE_MS_S32,
|
|
mSCRIPT_TYPE_MS_U32,
|
|
mSCRIPT_TYPE_MS_F32,
|
|
mSCRIPT_TYPE_MS_S64,
|
|
mSCRIPT_TYPE_MS_U64,
|
|
mSCRIPT_TYPE_MS_F64,
|
|
mSCRIPT_TYPE_MS_STR,
|
|
mSCRIPT_TYPE_MS_CHARP,
|
|
mSCRIPT_TYPE_MS_LIST,
|
|
mSCRIPT_TYPE_MS_TABLE,
|
|
mSCRIPT_TYPE_MS_WRAPPER,
|
|
NULL
|
|
};
|
|
|
|
void explainValue(struct mScriptValue* value, const char* name, int level);
|
|
void explainValueScoped(struct mScriptValue* value, const char* name, const char* scope, int level);
|
|
void explainType(struct mScriptType* type, int level);
|
|
|
|
void addTypesFromTuple(const struct mScriptTypeTuple*);
|
|
void addTypesFromTable(struct Table*);
|
|
|
|
void addType(const struct mScriptType* type) {
|
|
if (HashTableLookup(&types, type->name) || type->isConst) {
|
|
return;
|
|
}
|
|
HashTableInsert(&types, type->name, (struct mScriptType*) type);
|
|
switch (type->base) {
|
|
case mSCRIPT_TYPE_FUNCTION:
|
|
addTypesFromTuple(&type->details.function.parameters);
|
|
addTypesFromTuple(&type->details.function.returnType);
|
|
break;
|
|
case mSCRIPT_TYPE_OBJECT:
|
|
mScriptClassInit(type->details.cls);
|
|
if (type->details.cls->parent) {
|
|
addType(type->details.cls->parent);
|
|
}
|
|
addTypesFromTable(&type->details.cls->instanceMembers);
|
|
break;
|
|
case mSCRIPT_TYPE_OPAQUE:
|
|
case mSCRIPT_TYPE_WRAPPER:
|
|
if (type->details.type) {
|
|
addType(type->details.type);
|
|
}
|
|
case mSCRIPT_TYPE_VOID:
|
|
case mSCRIPT_TYPE_SINT:
|
|
case mSCRIPT_TYPE_UINT:
|
|
case mSCRIPT_TYPE_FLOAT:
|
|
case mSCRIPT_TYPE_STRING:
|
|
case mSCRIPT_TYPE_LIST:
|
|
case mSCRIPT_TYPE_TABLE:
|
|
case mSCRIPT_TYPE_WEAKREF:
|
|
// No subtypes
|
|
break;
|
|
}
|
|
}
|
|
|
|
void addTypesFromTuple(const struct mScriptTypeTuple* tuple) {
|
|
size_t i;
|
|
for (i = 0; i < tuple->count; ++i) {
|
|
addType(tuple->entries[i]);
|
|
}
|
|
}
|
|
|
|
void addTypesFromTable(struct Table* table) {
|
|
struct TableIterator iter;
|
|
if (!HashTableIteratorStart(table, &iter)) {
|
|
return;
|
|
}
|
|
do {
|
|
struct mScriptClassMember* member = HashTableIteratorGetValue(table, &iter);
|
|
addType(member->type);
|
|
} while(HashTableIteratorNext(table, &iter));
|
|
}
|
|
|
|
void printchomp(const char* string, int level) {
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
|
|
const char* start = string;
|
|
char lineBuffer[1024];
|
|
while (true) {
|
|
const char* end = strchr(start, '\n');
|
|
if (end) {
|
|
size_t size = end - start;
|
|
if (sizeof(lineBuffer) - 1 < size) {
|
|
size = sizeof(lineBuffer) - 1;
|
|
}
|
|
strncpy(lineBuffer, start, size);
|
|
lineBuffer[size] = '\0';
|
|
fprintf(out, "%s%s\n", indent, lineBuffer);
|
|
} else {
|
|
fprintf(out, "%s%s\n", indent, start);
|
|
break;
|
|
}
|
|
start = end + 1;
|
|
if (!*end) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool printval(const struct mScriptValue* value, char* buffer, size_t bufferSize) {
|
|
struct mScriptValue sval;
|
|
switch (value->type->base) {
|
|
case mSCRIPT_TYPE_SINT:
|
|
if (value->type->size <= 4) {
|
|
snprintf(buffer, bufferSize, "%"PRId32, value->value.s32);
|
|
return true;
|
|
}
|
|
if (value->type->size == 8) {
|
|
snprintf(buffer, bufferSize, "%"PRId64, value->value.s64);
|
|
return true;
|
|
}
|
|
return false;
|
|
case mSCRIPT_TYPE_UINT:
|
|
if (value->type->size <= 4) {
|
|
snprintf(buffer, bufferSize, "%"PRIu32, value->value.u32);
|
|
return true;
|
|
}
|
|
if (value->type->size == 8) {
|
|
snprintf(buffer, bufferSize, "%"PRIu64, value->value.u64);
|
|
return true;
|
|
}
|
|
return false;
|
|
case mSCRIPT_TYPE_FLOAT:
|
|
if (value->type->size <= 4) {
|
|
snprintf(buffer, bufferSize, "%g", value->value.f32);
|
|
return true;
|
|
}
|
|
if (value->type->size == 8) {
|
|
snprintf(buffer, bufferSize, "%g", value->value.f64);
|
|
return true;
|
|
}
|
|
return false;
|
|
case mSCRIPT_TYPE_STRING:
|
|
if (!mScriptCast(mSCRIPT_TYPE_MS_CHARP, value, &sval)) {
|
|
return false;
|
|
}
|
|
if (sval.value.copaque) {
|
|
snprintf(buffer, bufferSize, "\"%s\"", (const char*) sval.value.copaque);
|
|
} else {
|
|
snprintf(buffer, bufferSize, "null");
|
|
}
|
|
return true;
|
|
case mSCRIPT_TYPE_VOID:
|
|
snprintf(buffer, bufferSize, "null");
|
|
return true;
|
|
case mSCRIPT_TYPE_OPAQUE:
|
|
case mSCRIPT_TYPE_LIST:
|
|
case mSCRIPT_TYPE_TABLE:
|
|
// Not scalar or string values
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void explainTable(struct mScriptValue* value, const char* name, const char* scope, int level) {
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
|
|
struct TableIterator iter;
|
|
if (mScriptTableIteratorStart(value, &iter)) {
|
|
do {
|
|
char keyval[1024];
|
|
struct mScriptValue* k = mScriptTableIteratorGetKey(value, &iter);
|
|
printval(k, keyval, sizeof(keyval));
|
|
fprintf(out, "%s- key: %s\n", indent, keyval);
|
|
struct mScriptValue* v = mScriptTableIteratorGetValue(value, &iter);
|
|
|
|
struct mScriptValue string;
|
|
if (mScriptCast(mSCRIPT_TYPE_MS_CHARP, k, &string)) {
|
|
snprintf(keyval, sizeof(keyval), "%s.%s", name, (const char*) string.value.opaque);
|
|
explainValueScoped(v, keyval, scope, level + 1);
|
|
} else {
|
|
explainValueScoped(v, NULL, scope, level + 1);
|
|
}
|
|
} while (mScriptTableIteratorNext(value, &iter));
|
|
}
|
|
}
|
|
|
|
void explainClass(struct mScriptTypeClass* cls, int level) {
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
|
|
if (cls->parent) {
|
|
fprintf(out, "%sparent: %s\n", indent, cls->parent->name);
|
|
}
|
|
if (cls->internal) {
|
|
fprintf(out, "%sinternal: true\n", indent);
|
|
}
|
|
if (cls->docstring) {
|
|
if (strchr(cls->docstring, '\n')) {
|
|
fprintf(out, "%scomment: |-\n", indent);
|
|
printchomp(cls->docstring, level + 1);
|
|
} else {
|
|
fprintf(out, "%scomment: \"%s\"\n", indent, cls->docstring);
|
|
}
|
|
}
|
|
|
|
fprintf(out, "%smembers:\n", indent);
|
|
const char* docstring = NULL;
|
|
const struct mScriptClassInitDetails* details;
|
|
size_t i;
|
|
for (i = 0; cls->details[i].type != mSCRIPT_CLASS_INIT_END; ++i) {
|
|
details = &cls->details[i];
|
|
switch (details->type) {
|
|
case mSCRIPT_CLASS_INIT_DOCSTRING:
|
|
docstring = details->info.comment;
|
|
break;
|
|
case mSCRIPT_CLASS_INIT_INSTANCE_MEMBER:
|
|
fprintf(out, "%s %s:\n", indent, details->info.member.name);
|
|
if (docstring) {
|
|
if (strchr(docstring, '\n')) {
|
|
fprintf(out, "%s comment: |-\n", indent);
|
|
printchomp(docstring, level + 3);
|
|
} else {
|
|
fprintf(out, "%s comment: \"%s\"\n", indent, docstring);
|
|
}
|
|
docstring = NULL;
|
|
}
|
|
fprintf(out, "%s type: %s\n", indent, details->info.member.type->name);
|
|
break;
|
|
case mSCRIPT_CLASS_INIT_END:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void explainObject(struct mScriptValue* value, int level) {
|
|
char indent[(level + 2) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
|
|
struct mScriptTypeClass* cls = value->type->details.cls;
|
|
const struct mScriptClassInitDetails* details;
|
|
size_t i;
|
|
for (i = 0; cls->details[i].type != mSCRIPT_CLASS_INIT_END; ++i) {
|
|
struct mScriptValue member;
|
|
details = &cls->details[i];
|
|
|
|
if (cls->details[i].type != mSCRIPT_CLASS_INIT_INSTANCE_MEMBER) {
|
|
continue;
|
|
}
|
|
fprintf(out, "%s%s:\n", indent, details->info.member.name);
|
|
addType(details->info.member.type);
|
|
if (mScriptObjectGet(value, details->info.member.name, &member)) {
|
|
struct mScriptValue* unwrappedMember;
|
|
if (member.type->base == mSCRIPT_TYPE_WRAPPER) {
|
|
unwrappedMember = mScriptValueUnwrap(&member);
|
|
explainValue(unwrappedMember, NULL, level + 2);
|
|
} else {
|
|
explainValue(&member, NULL, level + 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void explainValue(struct mScriptValue* value, const char* name, int level) {
|
|
explainValueScoped(value, name, NULL, level);
|
|
}
|
|
|
|
void explainValueScoped(struct mScriptValue* value, const char* name, const char* scope, int level) {
|
|
char valstring[1024];
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
value = mScriptContextAccessWeakref(&context, value);
|
|
addType(value->type);
|
|
fprintf(out, "%stype: %s\n", indent, value->type->name);
|
|
|
|
const char* docstring = NULL;
|
|
if (name) {
|
|
if (scope) {
|
|
snprintf(valstring, sizeof(valstring), "%s::%s", scope, name);
|
|
docstring = mScriptContextGetDocstring(&context, valstring);
|
|
} else {
|
|
docstring = mScriptContextGetDocstring(&context, name);
|
|
}
|
|
}
|
|
if (docstring) {
|
|
if (strchr(docstring, '\n')) {
|
|
fprintf(out, "%scomment: |-\n", indent);
|
|
printchomp(docstring, level + 1);
|
|
} else {
|
|
fprintf(out, "%scomment: \"%s\"\n", indent, docstring);
|
|
}
|
|
}
|
|
|
|
switch (value->type->base) {
|
|
case mSCRIPT_TYPE_TABLE:
|
|
fprintf(out, "%svalue:\n", indent);
|
|
explainTable(value, name, scope, level);
|
|
break;
|
|
case mSCRIPT_TYPE_SINT:
|
|
case mSCRIPT_TYPE_UINT:
|
|
case mSCRIPT_TYPE_STRING:
|
|
printval(value, valstring, sizeof(valstring));
|
|
fprintf(out, "%svalue: %s\n", indent, valstring);
|
|
break;
|
|
case mSCRIPT_TYPE_OBJECT:
|
|
fprintf(out, "%svalue:\n", indent);
|
|
explainObject(value, level);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void explainTypeTuple(struct mScriptTypeTuple* tuple, int level) {
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
fprintf(out, "%svariable: %s\n", indent, tuple->variable ? "yes" : "no");
|
|
fprintf(out, "%slist:\n", indent);
|
|
size_t i;
|
|
for (i = 0; i < tuple->count; ++i) {
|
|
if (tuple->names[i]) {
|
|
fprintf(out, "%s- name: %s\n", indent, tuple->names[i]);
|
|
fprintf(out, "%s type: %s\n", indent, tuple->entries[i]->name);
|
|
} else {
|
|
fprintf(out, "%s- type: %s\n", indent, tuple->entries[i]->name);
|
|
}
|
|
if (tuple->defaults && tuple->defaults[i].type) {
|
|
char defaultValue[128];
|
|
printval(&tuple->defaults[i], defaultValue, sizeof(defaultValue));
|
|
fprintf(out, "%s default: %s\n", indent, defaultValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
void explainType(struct mScriptType* type, int level) {
|
|
char indent[(level + 1) * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
fprintf(out, "%sbase: ", indent);
|
|
switch (type->base) {
|
|
case mSCRIPT_TYPE_SINT:
|
|
fputs("sint\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_UINT:
|
|
fputs("uint\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_FLOAT:
|
|
fputs("float\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_STRING:
|
|
fputs("string\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_FUNCTION:
|
|
fputs("function\n", out);
|
|
fprintf(out, "%sparameters:\n", indent);
|
|
explainTypeTuple(&type->details.function.parameters, level + 1);
|
|
fprintf(out, "%sreturn:\n", indent);
|
|
explainTypeTuple(&type->details.function.returnType, level + 1);
|
|
break;
|
|
case mSCRIPT_TYPE_OPAQUE:
|
|
fputs("opaque\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_OBJECT:
|
|
fputs("object\n", out);
|
|
explainClass(type->details.cls, level);
|
|
break;
|
|
case mSCRIPT_TYPE_LIST:
|
|
fputs("list\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_TABLE:
|
|
fputs("table\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_WRAPPER:
|
|
fputs("wrapper\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_WEAKREF:
|
|
fputs("weakref\n", out);
|
|
break;
|
|
case mSCRIPT_TYPE_VOID:
|
|
fputs("void\n", out);
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool call(struct mScriptValue* obj, const char* method, struct mScriptFrame* frame) {
|
|
struct mScriptValue fn;
|
|
if (!mScriptObjectGet(obj, method, &fn)) {
|
|
return false;
|
|
}
|
|
struct mScriptValue* this = mScriptListAppend(&frame->arguments);
|
|
this->type = mSCRIPT_TYPE_MS_WRAPPER;
|
|
this->refs = mSCRIPT_VALUE_UNREF;
|
|
this->flags = 0;
|
|
this->value.opaque = obj;
|
|
return mScriptInvoke(&fn, frame);
|
|
}
|
|
|
|
void explainCore(struct mCore* core) {
|
|
struct mScriptValue wrapper;
|
|
size_t size;
|
|
size_t i;
|
|
mScriptContextAttachCore(&context, core);
|
|
|
|
struct mScriptValue* emu = mScriptContextGetGlobal(&context, "emu");
|
|
addType(emu->type);
|
|
|
|
if (mScriptObjectGet(emu, "memory", &wrapper)) {
|
|
struct mScriptValue* memory = mScriptValueUnwrap(&wrapper);
|
|
struct TableIterator iter;
|
|
fputs(" memory:\n", out);
|
|
if (mScriptTableIteratorStart(memory, &iter)) {
|
|
do {
|
|
struct mScriptValue* name = mScriptTableIteratorGetKey(memory, &iter);
|
|
struct mScriptValue* value = mScriptTableIteratorGetValue(memory, &iter);
|
|
|
|
fprintf(out, " %s:\n", name->value.string->buffer);
|
|
value = mScriptContextAccessWeakref(&context, value);
|
|
addType(value->type);
|
|
|
|
struct mScriptFrame frame;
|
|
uint32_t baseVal;
|
|
struct mScriptValue* shortName;
|
|
|
|
mScriptFrameInit(&frame);
|
|
call(value, "base", &frame);
|
|
mScriptPopU32(&frame.returnValues, &baseVal);
|
|
mScriptFrameDeinit(&frame);
|
|
|
|
mScriptFrameInit(&frame);
|
|
call(value, "name", &frame);
|
|
shortName = mScriptValueUnwrap(mScriptListGetPointer(&frame.returnValues, 0));
|
|
mScriptFrameDeinit(&frame);
|
|
|
|
fprintf(out, " base: 0x%x\n", baseVal);
|
|
fprintf(out, " name: \"%s\"\n", shortName->value.string->buffer);
|
|
|
|
mScriptValueDeref(shortName);
|
|
} while (mScriptTableIteratorNext(memory, &iter));
|
|
}
|
|
}
|
|
|
|
const struct mCoreRegisterInfo* registers;
|
|
size = core->listRegisters(core, ®isters);
|
|
if (size) {
|
|
fputs(" registers:\n", out);
|
|
for (i = 0; i < size; ++i) {
|
|
if (strncmp(registers[i].name, "spsr", 4) == 0) {
|
|
// SPSR access is not implemented yet
|
|
continue;
|
|
}
|
|
fprintf(out, " - name: \"%s\"\n", registers[i].name);
|
|
if (registers[i].aliases && registers[i].aliases[0]) {
|
|
size_t alias;
|
|
fputs(" aliases:\n", out);
|
|
for (alias = 0; registers[i].aliases[alias]; ++alias) {
|
|
fprintf(out, " - \"%s\"\n", registers[i].aliases[alias]);
|
|
}
|
|
}
|
|
fprintf(out, " width: %u\n", registers[i].width);
|
|
}
|
|
}
|
|
mScriptContextDetachCore(&context);
|
|
}
|
|
|
|
void initTypes(void) {
|
|
HashTableInit(&types, 0, NULL);
|
|
|
|
size_t i;
|
|
for (i = 0; baseTypes[i]; ++i) {
|
|
addType(baseTypes[i]);
|
|
}
|
|
}
|
|
|
|
void explainTypes(int level, const char* prefix) {
|
|
char indent[level * 2 + 1];
|
|
memset(indent, ' ', sizeof(indent) - 1);
|
|
indent[sizeof(indent) - 1] = '\0';
|
|
fprintf(out, "%stypes:\n", indent);
|
|
|
|
struct TableIterator iter;
|
|
if (HashTableIteratorStart(&types, &iter)) {
|
|
do {
|
|
const char* name = HashTableIteratorGetKey(&types, &iter);
|
|
struct mScriptType* type = HashTableIteratorGetValue(&types, &iter);
|
|
if (prefix && !startswith(name, prefix)) {
|
|
continue;
|
|
}
|
|
fprintf(out, "%s %s:\n", indent, name);
|
|
explainType(type, level + 1);
|
|
} while (HashTableIteratorNext(&types, &iter));
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
out = stdout;
|
|
if (argc > 1) {
|
|
out = fopen(argv[1], "w");
|
|
if (!out) {
|
|
perror("Couldn't open output");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
mScriptContextInit(&context);
|
|
mScriptContextAttachStdlib(&context);
|
|
mScriptContextAttachSocket(&context);
|
|
mScriptContextSetTextBufferFactory(&context, NULL, NULL);
|
|
|
|
initTypes();
|
|
|
|
fputs("version:\n", out);
|
|
fprintf(out, " string: \"%s\"\n", projectVersion);
|
|
fprintf(out, " commit: \"%s\"\n", gitCommit);
|
|
fputs("root:\n", out);
|
|
struct TableIterator iter;
|
|
if (HashTableIteratorStart(&context.rootScope, &iter)) {
|
|
do {
|
|
const char* name = HashTableIteratorGetKey(&context.rootScope, &iter);
|
|
fprintf(out, " %s:\n", name);
|
|
struct mScriptValue* value = HashTableIteratorGetValue(&context.rootScope, &iter);
|
|
explainValue(value, name, 1);
|
|
} while (HashTableIteratorNext(&context.rootScope, &iter));
|
|
}
|
|
fputs("emu:\n", out);
|
|
struct mCore* core;
|
|
core = mCoreCreate(mPLATFORM_GBA);
|
|
if (core) {
|
|
fputs(" gba:\n", out);
|
|
core->init(core);
|
|
explainCore(core);
|
|
core->deinit(core);
|
|
}
|
|
core = mCoreCreate(mPLATFORM_GB);
|
|
if (core) {
|
|
fputs(" gb:\n", out);
|
|
core->init(core);
|
|
explainCore(core);
|
|
core->deinit(core);
|
|
}
|
|
explainTypes(0, NULL);
|
|
|
|
mScriptContextRegisterEngines(&context);
|
|
fputs("engines:\n", out);
|
|
if (HashTableIteratorStart(&context.engines, &iter)) {
|
|
do {
|
|
struct TableIterator rootIter;
|
|
struct mScriptEngineContext* engine = HashTableIteratorGetValue(&context.engines, &iter);
|
|
const char* name = HashTableIteratorGetKey(&context.engines, &iter);
|
|
fprintf(out, " %s:\n root:\n", name);
|
|
if (HashTableIteratorStart(&engine->docroot, &rootIter)) {
|
|
do {
|
|
const char* key = HashTableIteratorGetKey(&engine->docroot, &rootIter);
|
|
struct mScriptValue* value = HashTableIteratorGetValue(&engine->docroot, &rootIter);
|
|
fprintf(out, " %s:\n", key);
|
|
explainValueScoped(value, key, name, 3);
|
|
} while (HashTableIteratorNext(&engine->docroot, &rootIter));
|
|
}
|
|
|
|
explainTypes(2, name);
|
|
} while (HashTableIteratorNext(&context.engines, &iter));
|
|
}
|
|
HashTableDeinit(&types);
|
|
mScriptContextDeinit(&context);
|
|
return 0;
|
|
}
|