ShuriZma
/
mgba
mirror of https://github.com/mgba-emu/mgba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Scripting: Get docgen to print to file, fix some warnings

This commit is contained in:
Vicki Pfau 2022-05-27 15:57:11 -07:00
parent 2471648dd0
commit 8e617556e9
1 changed files with 98 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
src/script/docgen.c
View File

@ -10,6 +10,7 @@
struct mScriptContext context; struct mScriptContext context;
struct Table types; struct Table types;
FILE* out;
void explainValue(struct mScriptValue* value, int level); void explainValue(struct mScriptValue* value, int level);
void explainType(struct mScriptType* type, int level); void explainType(struct mScriptType* type, int level);
@ -35,9 +36,20 @@ void addType(const struct mScriptType* type) {
addTypesFromTable(&type->details.cls->instanceMembers); addTypesFromTable(&type->details.cls->instanceMembers);
break; break;
case mSCRIPT_TYPE_OPAQUE: case mSCRIPT_TYPE_OPAQUE:
case mSCRIPT_TYPE_WRAPPER:
if (type->details.type) { if (type->details.type) {
addType(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;
} }
} }
@ -75,9 +87,9 @@ void printchomp(const char* string, int level) {
} }
strncpy(lineBuffer, start, size); strncpy(lineBuffer, start, size);
lineBuffer[size] = '\0'; lineBuffer[size] = '\0';
printf("%s%s\n", indent, lineBuffer); fprintf(out, "%s%s\n", indent, lineBuffer);
} else { } else {
printf("%s%s\n", indent, start); fprintf(out, "%s%s\n", indent, start);
break; break;
} }
start = end + 1; start = end + 1;
@ -110,16 +122,34 @@ bool printval(const struct mScriptValue* value, char* buffer, size_t bufferSize)
return true; return true;
} }
return false; 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: case mSCRIPT_TYPE_STRING:
if (!mScriptCast(mSCRIPT_TYPE_MS_CHARP, value, &sval)) { if (!mScriptCast(mSCRIPT_TYPE_MS_CHARP, value, &sval)) {
return false; return false;
} }
if (sval.value.opaque) { if (sval.value.copaque) {
snprintf(buffer, bufferSize, "\"%s\"", sval.value.opaque); snprintf(buffer, bufferSize, "\"%s\"", (const char*) sval.value.copaque);
} else { } else {
snprintf(buffer, bufferSize, "null"); snprintf(buffer, bufferSize, "null");
} }
return true; 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; return false;
} }
@ -135,7 +165,7 @@ void explainTable(struct mScriptValue* value, int level) {
char keyval[1024]; char keyval[1024];
struct mScriptValue* k = mScriptTableIteratorGetKey(value, &iter); struct mScriptValue* k = mScriptTableIteratorGetKey(value, &iter);
printval(k, keyval, sizeof(keyval)); printval(k, keyval, sizeof(keyval));
printf("%s- key: %s\n", indent, keyval); fprintf(out, "%s- key: %s\n", indent, keyval);
struct mScriptValue* v = mScriptTableIteratorGetValue(value, &iter); struct mScriptValue* v = mScriptTableIteratorGetValue(value, &iter);
explainValue(v, level + 1); explainValue(v, level + 1);
} while (mScriptTableIteratorNext(value, &iter)); } while (mScriptTableIteratorNext(value, &iter));
@ -148,18 +178,18 @@ void explainClass(struct mScriptTypeClass* cls, int level) {
indent[sizeof(indent) - 1] = '\0'; indent[sizeof(indent) - 1] = '\0';
if (cls->parent) { if (cls->parent) {
printf("%sparent: %s\n", indent, cls->parent->name); fprintf(out, "%sparent: %s\n", indent, cls->parent->name);
} }
if (cls->docstring) { if (cls->docstring) {
if (strchr(cls->docstring, '\n')) { if (strchr(cls->docstring, '\n')) {
printf("%scomment: |-\n", indent); fprintf(out, "%scomment: |-\n", indent);
printchomp(cls->docstring, level + 1); printchomp(cls->docstring, level + 1);
} else { } else {
printf("%scomment: \"%s\"\n", indent, cls->docstring); fprintf(out, "%scomment: \"%s\"\n", indent, cls->docstring);
} }
} }
printf("%smembers:\n", indent); fprintf(out, "%smembers:\n", indent);
const char* docstring = NULL; const char* docstring = NULL;
const struct mScriptClassInitDetails* details; const struct mScriptClassInitDetails* details;
size_t i; size_t i;
@ -170,12 +200,14 @@ void explainClass(struct mScriptTypeClass* cls, int level) {
docstring = details->info.comment; docstring = details->info.comment;
break; break;
case mSCRIPT_CLASS_INIT_INSTANCE_MEMBER: case mSCRIPT_CLASS_INIT_INSTANCE_MEMBER:
printf("%s %s:\n", indent, details->info.member.name); fprintf(out, "%s %s:\n", indent, details->info.member.name);
if (docstring) { if (docstring) {
printf("%s comment: \"%s\"\n", indent, docstring); fprintf(out, "%s comment: \"%s\"\n", indent, docstring);
docstring = NULL; docstring = NULL;
} }
printf("%s type: %s\n", indent, details->info.member.type->name); fprintf(out, "%s type: %s\n", indent, details->info.member.type->name);
break;
case mSCRIPT_CLASS_INIT_END:
break; break;
} }
} }
@ -196,7 +228,7 @@ void explainObject(struct mScriptValue* value, int level) {
if (cls->details[i].type != mSCRIPT_CLASS_INIT_INSTANCE_MEMBER) { if (cls->details[i].type != mSCRIPT_CLASS_INIT_INSTANCE_MEMBER) {
continue; continue;
} }
printf("%s%s:\n", indent, details->info.member.name); fprintf(out, "%s%s:\n", indent, details->info.member.name);
addType(details->info.member.type); addType(details->info.member.type);
if (mScriptObjectGet(value, details->info.member.name, &member)) { if (mScriptObjectGet(value, details->info.member.name, &member)) {
struct mScriptValue* unwrappedMember; struct mScriptValue* unwrappedMember;
@ -217,20 +249,20 @@ void explainValue(struct mScriptValue* value, int level) {
indent[sizeof(indent) - 1] = '\0'; indent[sizeof(indent) - 1] = '\0';
value = mScriptContextAccessWeakref(&context, value); value = mScriptContextAccessWeakref(&context, value);
addType(value->type); addType(value->type);
printf("%stype: %s\n", indent, value->type->name); fprintf(out, "%stype: %s\n", indent, value->type->name);
switch (value->type->base) { switch (value->type->base) {
case mSCRIPT_TYPE_TABLE: case mSCRIPT_TYPE_TABLE:
printf("%svalue:\n", indent); fprintf(out, "%svalue:\n", indent);
explainTable(value, level); explainTable(value, level);
break; break;
case mSCRIPT_TYPE_SINT: case mSCRIPT_TYPE_SINT:
case mSCRIPT_TYPE_UINT: case mSCRIPT_TYPE_UINT:
case mSCRIPT_TYPE_STRING: case mSCRIPT_TYPE_STRING:
printval(value, valstring, sizeof(valstring)); printval(value, valstring, sizeof(valstring));
printf("%svalue: %s\n", indent, valstring); fprintf(out, "%svalue: %s\n", indent, valstring);
break; break;
case mSCRIPT_TYPE_OBJECT: case mSCRIPT_TYPE_OBJECT:
printf("%svalue:\n", indent); fprintf(out, "%svalue:\n", indent);
explainObject(value, level); explainObject(value, level);
break; break;
default: default:
@ -242,20 +274,20 @@ void explainTypeTuple(struct mScriptTypeTuple* tuple, int level) {
char indent[(level + 1) * 2 + 1]; char indent[(level + 1) * 2 + 1];
memset(indent, ' ', sizeof(indent) - 1); memset(indent, ' ', sizeof(indent) - 1);
indent[sizeof(indent) - 1] = '\0'; indent[sizeof(indent) - 1] = '\0';
printf("%svariable: %s\n", indent, tuple->variable ? "yes" : "no"); fprintf(out, "%svariable: %s\n", indent, tuple->variable ? "yes" : "no");
printf("%slist:\n", indent); fprintf(out, "%slist:\n", indent);
size_t i; size_t i;
for (i = 0; i < tuple->count; ++i) { for (i = 0; i < tuple->count; ++i) {
if (tuple->names[i]) { if (tuple->names[i]) {
printf("%s- name: %s\n", indent, tuple->names[i]); fprintf(out, "%s- name: %s\n", indent, tuple->names[i]);
printf("%s type: %s\n", indent, tuple->entries[i]->name); fprintf(out, "%s type: %s\n", indent, tuple->entries[i]->name);
} else { } else {
printf("%s- type: %s\n", indent, tuple->entries[i]->name); fprintf(out, "%s- type: %s\n", indent, tuple->entries[i]->name);
} }
if (tuple->defaults && tuple->defaults[i].type) { if (tuple->defaults && tuple->defaults[i].type) {
char defaultValue[128]; char defaultValue[128];
printval(&tuple->defaults[i], defaultValue, sizeof(defaultValue)); printval(&tuple->defaults[i], defaultValue, sizeof(defaultValue));
printf("%s default: %s\n", indent, defaultValue); fprintf(out, "%s default: %s\n", indent, defaultValue);
} }
} }
} }
@ -264,48 +296,48 @@ void explainType(struct mScriptType* type, int level) {
char indent[(level + 1) * 2 + 1]; char indent[(level + 1) * 2 + 1];
memset(indent, ' ', sizeof(indent) - 1); memset(indent, ' ', sizeof(indent) - 1);
indent[sizeof(indent) - 1] = '\0'; indent[sizeof(indent) - 1] = '\0';
printf("%sbase: ", indent); fprintf(out, "%sbase: ", indent);
switch (type->base) { switch (type->base) {
case mSCRIPT_TYPE_SINT: case mSCRIPT_TYPE_SINT:
puts("sint"); fputs("sint\n", out);
break; break;
case mSCRIPT_TYPE_UINT: case mSCRIPT_TYPE_UINT:
puts("uint"); fputs("uint\n", out);
break; break;
case mSCRIPT_TYPE_FLOAT: case mSCRIPT_TYPE_FLOAT:
puts("float"); fputs("float\n", out);
break; break;
case mSCRIPT_TYPE_STRING: case mSCRIPT_TYPE_STRING:
puts("string"); fputs("string\n", out);
break; break;
case mSCRIPT_TYPE_FUNCTION: case mSCRIPT_TYPE_FUNCTION:
puts("function"); fputs("function\n", out);
printf("%sparameters:\n", indent); fprintf(out, "%sparameters:\n", indent);
explainTypeTuple(&type->details.function.parameters, level + 1); explainTypeTuple(&type->details.function.parameters, level + 1);
printf("%sreturn:\n", indent); fprintf(out, "%sreturn:\n", indent);
explainTypeTuple(&type->details.function.returnType, level + 1); explainTypeTuple(&type->details.function.returnType, level + 1);
break; break;
case mSCRIPT_TYPE_OPAQUE: case mSCRIPT_TYPE_OPAQUE:
puts("opaque"); fputs("opaque\n", out);
break; break;
case mSCRIPT_TYPE_OBJECT: case mSCRIPT_TYPE_OBJECT:
puts("object"); fputs("object\n", out);
explainClass(type->details.cls, level); explainClass(type->details.cls, level);
break; break;
case mSCRIPT_TYPE_LIST: case mSCRIPT_TYPE_LIST:
puts("list"); fputs("list\n", out);
break; break;
case mSCRIPT_TYPE_TABLE: case mSCRIPT_TYPE_TABLE:
puts("table"); fputs("table\n", out);
break; break;
case mSCRIPT_TYPE_WRAPPER: case mSCRIPT_TYPE_WRAPPER:
puts("wrapper"); fputs("wrapper\n", out);
break; break;
case mSCRIPT_TYPE_WEAKREF: case mSCRIPT_TYPE_WEAKREF:
puts("weakref"); fputs("weakref\n", out);
break; break;
case mSCRIPT_TYPE_VOID: case mSCRIPT_TYPE_VOID:
puts("void"); fputs("void\n", out);
break; break;
} }
} }
@ -335,13 +367,13 @@ void explainCore(struct mCore* core) {
if (mScriptObjectGet(emu, "memory", &wrapper)) { if (mScriptObjectGet(emu, "memory", &wrapper)) {
struct mScriptValue* memory = mScriptValueUnwrap(&wrapper); struct mScriptValue* memory = mScriptValueUnwrap(&wrapper);
struct TableIterator iter; struct TableIterator iter;
puts(" memory:"); fputs(" memory:\n", out);
if (mScriptTableIteratorStart(memory, &iter)) { if (mScriptTableIteratorStart(memory, &iter)) {
do { do {
struct mScriptValue* name = mScriptTableIteratorGetKey(memory, &iter); struct mScriptValue* name = mScriptTableIteratorGetKey(memory, &iter);
struct mScriptValue* value = mScriptTableIteratorGetValue(memory, &iter); struct mScriptValue* value = mScriptTableIteratorGetValue(memory, &iter);
printf(" %s:\n", name->value.string->buffer); fprintf(out, " %s:\n", name->value.string->buffer);
value = mScriptContextAccessWeakref(&context, value); value = mScriptContextAccessWeakref(&context, value);
struct mScriptFrame frame; struct mScriptFrame frame;
@ -358,8 +390,8 @@ void explainCore(struct mCore* core) {
shortName = mScriptValueUnwrap(mScriptListGetPointer(&frame.returnValues, 0)); shortName = mScriptValueUnwrap(mScriptListGetPointer(&frame.returnValues, 0));
mScriptFrameDeinit(&frame); mScriptFrameDeinit(&frame);
printf(" base: 0x%x\n", baseVal); fprintf(out, " base: 0x%x\n", baseVal);
printf(" name: \"%s\"\n", shortName->value.string->buffer); fprintf(out, " name: \"%s\"\n", shortName->value.string->buffer);
mScriptValueDeref(shortName); mScriptValueDeref(shortName);
} while (mScriptTableIteratorNext(memory, &iter)); } while (mScriptTableIteratorNext(memory, &iter));
@ -369,27 +401,36 @@ void explainCore(struct mCore* core) {
const struct mCoreRegisterInfo* registers; const struct mCoreRegisterInfo* registers;
size = core->listRegisters(core, &registers); size = core->listRegisters(core, &registers);
if (size) { if (size) {
puts(" registers:"); fputs(" registers:\n", out);
for (i = 0; i < size; ++i) { for (i = 0; i < size; ++i) {
if (strncmp(registers[i].name, "spsr", 4) == 0) { if (strncmp(registers[i].name, "spsr", 4) == 0) {
// SPSR access is not implemented yet // SPSR access is not implemented yet
continue; continue;
} }
printf(" - name: \"%s\"\n", registers[i].name); fprintf(out, " - name: \"%s\"\n", registers[i].name);
if (registers[i].aliases && registers[i].aliases[0]) { if (registers[i].aliases && registers[i].aliases[0]) {
size_t alias; size_t alias;
puts(" aliases:"); fputs(" aliases:\n", out);
for (alias = 0; registers[i].aliases[alias]; ++alias) { for (alias = 0; registers[i].aliases[alias]; ++alias) {
printf(" - \"%s\"\n", registers[i].aliases[alias]); fprintf(out, " - \"%s\"\n", registers[i].aliases[alias]);
} }
} }
printf(" width: %u\n", registers[i].width); fprintf(out, " width: %u\n", registers[i].width);
} }
} }
mScriptContextDetachCore(&context); mScriptContextDetachCore(&context);
} }
int main(int argc, char* argv[]) { 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); mScriptContextInit(&context);
mScriptContextAttachStdlib(&context); mScriptContextAttachStdlib(&context);
mScriptContextSetTextBufferFactory(&context, NULL, NULL); mScriptContextSetTextBufferFactory(&context, NULL, NULL);
@ -411,40 +452,40 @@ int main(int argc, char* argv[]) {
addType(mSCRIPT_TYPE_MS_TABLE); addType(mSCRIPT_TYPE_MS_TABLE);
addType(mSCRIPT_TYPE_MS_WRAPPER); addType(mSCRIPT_TYPE_MS_WRAPPER);
puts("version:"); fputs("version:\n", out);
printf(" string: \"%s\"\n", projectVersion); fprintf(out, " string: \"%s\"\n", projectVersion);
printf(" commit: \"%s\"\n", gitCommit); fprintf(out, " commit: \"%s\"\n", gitCommit);
puts("root:"); fputs("root:\n", out);
struct TableIterator iter; struct TableIterator iter;
if (HashTableIteratorStart(&context.rootScope, &iter)) { if (HashTableIteratorStart(&context.rootScope, &iter)) {
do { do {
const char* name = HashTableIteratorGetKey(&context.rootScope, &iter); const char* name = HashTableIteratorGetKey(&context.rootScope, &iter);
printf(" %s:\n", name); fprintf(out, " %s:\n", name);
struct mScriptValue* value = HashTableIteratorGetValue(&context.rootScope, &iter); struct mScriptValue* value = HashTableIteratorGetValue(&context.rootScope, &iter);
explainValue(value, 1); explainValue(value, 1);
} while (HashTableIteratorNext(&context.rootScope, &iter)); } while (HashTableIteratorNext(&context.rootScope, &iter));
} }
puts("emu:"); fputs("emu:\n", out);
struct mCore* core; struct mCore* core;
core = mCoreCreate(mPLATFORM_GBA); core = mCoreCreate(mPLATFORM_GBA);
if (core) { if (core) {
puts(" gba:"); fputs(" gba:\n", out);
core->init(core); core->init(core);
explainCore(core); explainCore(core);
core->deinit(core); core->deinit(core);
} }
core = mCoreCreate(mPLATFORM_GB); core = mCoreCreate(mPLATFORM_GB);
if (core) { if (core) {
puts(" gb:"); fputs(" gb:\n", out);
core->init(core); core->init(core);
explainCore(core); explainCore(core);
core->deinit(core); core->deinit(core);
} }
puts("types:"); fputs("types:\n", out);
if (HashTableIteratorStart(&types, &iter)) { if (HashTableIteratorStart(&types, &iter)) {
do { do {
const char* name = HashTableIteratorGetKey(&types, &iter); const char* name = HashTableIteratorGetKey(&types, &iter);
printf(" %s:\n", name); fprintf(out, " %s:\n", name);
struct mScriptType* type = HashTableIteratorGetValue(&types, &iter); struct mScriptType* type = HashTableIteratorGetValue(&types, &iter);
explainType(type, 1); explainType(type, 1);
} while (HashTableIteratorNext(&types, &iter)); } while (HashTableIteratorNext(&types, &iter));