qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-24 05:11:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/vulkan/vkgen/vkstruct.r

348 lines
8.8 KiB
R
Raw Normal View History

[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
#include <hash.h>
#include <qfile.h>
#include <runtime.h>
#include <string.h>
#include <types.h>
#include <Array.h>
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
#include <PropertyList.h>
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
#include "vkfielddef.h"
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
#include "vkgen.h"
#include "vkstruct.h"
@implementation Struct
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
-(void) dealloc
{
str_free (outname);
str_free (label_field);
}
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
-(string) name
{
return str_mid(type.strct.tag, 4);
}
[vulkan] Rework vkgen alias handling This is much cleaner and now that all the types are there properly, doing a parser generator should be easier.
2020-07-03 16:40:02 +00:00
-(void) addToQueue
{
string name = [self name];
if (!Hash_Find (processed_types, name)) {
[vulkan] Silence vkgen's debug output It was hidden by qwaq-curses, but the switch to using qwaq-cmd made it pretty obvious.
2021-07-06 03:27:21 +00:00
//printf (" +%s\n", name);
[vulkan] Rework vkgen alias handling This is much cleaner and now that all the types are there properly, doing a parser generator should be easier.
2020-07-03 16:40:02 +00:00
Hash_Add (processed_types, (void *) name);
[queue addObject: self];
}
}
[vkgen] Clean up an unnecessary function redirect I think it was mostly a holdover from early development, but it certainly makes sense to tuck the functionality away in Struct.
2021-12-04 00:18:57 +00:00
-(void) queueFieldTypes
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
{
qfot_struct_t *strct =&type.strct;
[vkgen] Don't queue types for fields with custom parsers This ensures that unused parser blocks do not get emitted. In the testing of the upcoming support for fixed arrays, the blend color constants were being double emitted (both as custom and normal parser) due to being an array. gcc did not like that (what with all those warning flags).
2021-12-04 00:29:38 +00:00
PLItem *field_dict = [parse getObjectForKey:[self name]];
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
int readonly = [field_dict string] == "readonly";
if (readonly) {
return;
}
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
for (int i = 0; i < strct.num_fields; i++) {
[vkgen] Don't queue types for fields with custom parsers This ensures that unused parser blocks do not get emitted. In the testing of the upcoming support for fixed arrays, the blend color constants were being double emitted (both as custom and normal parser) due to being an array. gcc did not like that (what with all those warning flags).
2021-12-04 00:29:38 +00:00
qfot_var_t *var = &strct.fields[i];
if (field_dict) {
PLItem *item = [field_dict getObjectForKey:var.name];
FieldDef *def = [FieldDef fielddef:item
struct:self
field:var.name];
if (![def searchType]) {
continue;
}
}
[vkgen] Clean up an unnecessary function redirect I think it was mostly a holdover from early development, but it certainly makes sense to tuck the functionality away in Struct.
2021-12-04 00:18:57 +00:00
Type *type = [Type findType:var.type];
[type addToQueue];
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
}
}
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
-(qfot_var_t *)findField:(string) fieldName
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
{
for (int i = 0; i < type.strct.num_fields; i++) {
qfot_var_t *var = &type.strct.fields[i];
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
if (var.name == fieldName) {
return var;
}
}
return nil;
}
[vulkan] Initialize sType in parsed structures This fixes a lot of validation issues, but still some fun with uninitialized memory and bad accesses.
2021-01-05 09:26:01 +00:00
-(string)sTypeName
{
string s = "VK_STRUCTURE_TYPE";
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
string name = [self outname];
[vulkan] Initialize sType in parsed structures This fixes a lot of validation issues, but still some fun with uninitialized memory and bad accesses.
2021-01-05 09:26:01 +00:00
int length = strlen (name);
int start, end, c;
for (start = 2; start < length; start = end) {
for (end = start + 1; end < length; end++) {
c = str_char (name, end);
if (c >= 'A' && c <= 'Z') {
break;
}
}
s += "_" + str_mid (name, start, end);
}
str_free (name);
return str_upper (s);
}
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
-(void) setLabelField:(string)label_field
{
self.label_field = label_field;
}
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
-(void) writeForward
{
PLItem *field_dict = [parse getObjectForKey:[self name]];
int readonly = [field_dict string] == "readonly";
if (!readonly) {
fprintf (output_file, "static int %s (const plfield_t *field,"
" const plitem_t *item, void *data, plitem_t *messages,"
" void *context);\n",
[self parseFunc]);
}
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
-(void) writeTable
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
{
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
PLItem *field_dict = [parse getObjectForKey:[self name]];
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
PLItem *new_name = [field_dict getObjectForKey:".name"];
[vkgen] Support direct parsing of a single struct field This is most useful when parsing a labeled array where the key/value pairs go into a simple array: key = value; going to: struct foo { const char *key; enumtype value; };
2023-02-10 10:41:05 +00:00
PLItem *only = [field_dict getObjectForKey:".only"];
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
Array *field_defs = [Array array];
[vulkan] Initialize sType in parsed structures This fixes a lot of validation issues, but still some fun with uninitialized memory and bad accesses.
2021-01-05 09:26:01 +00:00
int have_sType = 0;
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
int have_pNext = 0;
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
int readonly = [field_dict string] == "readonly";
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
if ([parse string] == "skip") {
return;
}
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
if (new_name) {
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
outname = str_hold ([new_name string]);
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
}
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
[vulkan] Initialize sType in parsed structures This fixes a lot of validation issues, but still some fun with uninitialized memory and bad accesses.
2021-01-05 09:26:01 +00:00
for (int i = 0; i < type.strct.num_fields; i++) {
qfot_var_t *field = &type.strct.fields[i];
if (field.name == "sType") {
have_sType = 1;
}
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
if (field.name == "pNext") {
have_pNext = 1;
write_symtab = 1;
}
[vulkan] Initialize sType in parsed structures This fixes a lot of validation issues, but still some fun with uninitialized memory and bad accesses.
2021-01-05 09:26:01 +00:00
}
[vkgen] Support direct parsing of a single struct field This is most useful when parsing a labeled array where the key/value pairs go into a simple array: key = value; going to: struct foo { const char *key; enumtype value; };
2023-02-10 10:41:05 +00:00
if (only) {
string field_name = [only string];
qfot_var_t *field = nil;
for (int i = 0; i < type.strct.num_fields; i++) {
qfot_var_t *f = &type.strct.fields[i];
if (f.name == field_name) {
field = f;
break;
}
}
Type *field_type = [Type findType: field.type];
FieldDef *field_def = [field_type fielddef:self field:field.name];
if (!field_def) {
field_def = [FieldDef fielddef:nil
struct:self
field:field.name];
}
[field_defs addObject: field_def];
} else if (field_dict) {
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
PLItem *field_keys = [field_dict allKeys];
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
for (int i = [field_keys count]; i-- > 0; ) {
string field_name = [[field_keys getObjectAtIndex:i] string];
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
[build] Fix a pile of gcc 10 issues gcc got stricter about array accesses, complicating progs macros, and much better at detecting buffer overflows.
2020-12-20 17:12:51 +00:00
if (str_mid(field_name, 0, 1) == ".") {
continue;
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
PLItem *field_item = [field_dict getObjectForKey:field_name];
FieldDef *field_def = [FieldDef fielddef:field_item
struct:self
field:field_name];
[field_defs addObject: field_def];
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
}
} else {
for (int i = 0; i < type.strct.num_fields; i++) {
qfot_var_t *field = &type.strct.fields[i];
if (field.name == "sType" || field.name == "pNext") {
continue;
}
[vkgen] Recognize `char *` as a string Ruamoko currently doesn't support `const`, so that's not relevant, but recognizing `char *` (via a hack to work around what looks like a bug with type aliasing) allows strings to be handled without having to use a custom parser. Things are still a little clunky for custom parsers, but this seems to be a good start.
2023-02-09 02:32:38 +00:00
Type *field_type = [Type findType: field.type];
FieldDef *field_def = [field_type fielddef:self field:field.name];
if (!field_def) {
field_def = [FieldDef fielddef:nil
struct:self
field:field.name];
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
[field_defs addObject: field_def];
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
}
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
for (int i = [field_defs count]; i-- > 0; ) {
FieldDef *field_def = [field_defs objectAtIndex:i];
[field_def writeParseData];
}
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
if (!readonly) {
[vkgen] Fix some whitespace I thought I'd indented that block, but I guess I'd gotten confused while doing some before and after checks of the indent.
2023-02-10 00:39:13 +00:00
fprintf (output_file, "static plfield_t %s_fields[] = {\n",
[self outname]);
[vkgen] Support direct parsing of a single struct field This is most useful when parsing a labeled array where the key/value pairs go into a simple array: key = value; going to: struct foo { const char *key; enumtype value; };
2023-02-10 10:41:05 +00:00
if (!only) {
fprintf (output_file,
"\t{\"@inherit\", 0, QFString, parse_inherit, "
"&%s_fields},\n", [self outname]);
}
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
if (have_pNext) {
[vkgen] Fix some whitespace I thought I'd indented that block, but I guess I'd gotten confused while doing some before and after checks of the indent.
2023-02-10 00:39:13 +00:00
fprintf (output_file,
"\t{\"@next\", field_offset (%s, pNext), "
"QFArray, parse_next, 0},", [self outname]);
}
for (int i = [field_defs count]; i-- > 0; ) {
FieldDef *field_def = [field_defs objectAtIndex:i];
[field_def writeField];
[vkgen] Clean up most of the generated header I'll probably completely remove it as only vkparse.c includes it, but this tidies things up a bit and even simplifies vkgen's loops a little.
2023-02-09 12:20:27 +00:00
}
[vkgen] Fix some whitespace I thought I'd indented that block, but I guess I'd gotten confused while doing some before and after checks of the indent.
2023-02-10 00:39:13 +00:00
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
fprintf (output_file, "static int %s (const plfield_t *field,"
" const plitem_t *item, void *data, plitem_t *messages,"
" void *context)\n",
[self parseFunc]);
fprintf (output_file, "{\n");
if (have_sType) {
fprintf (output_file, "\t((%s *) data)->sType", [self outname]);
fprintf (output_file, " = %s;\n", [self sTypeName]);
}
[vkgen] Add support for labeled array elements This treats dictionary items as arrays ordered by key creation (ie, the order of the key/value pairs in the dictionary is preserved). The label is written to the specified field when parsing the struct. Both actual arrays and single element "arrays" are supported.
2023-02-10 10:36:53 +00:00
if (label_field) {
fprintf (output_file, "\t((%s *) data)->%s", [self outname],
label_field);
fprintf (output_file, " = vkstrdup (context, field->name);\n");
}
[vkgen] Support direct parsing of a single struct field This is most useful when parsing a labeled array where the key/value pairs go into a simple array: key = value; going to: struct foo { const char *key; enumtype value; };
2023-02-10 10:41:05 +00:00
if (only) {
fprintf (output_file, "\tplfield_t *f = &%s_fields[0];\n",
[self outname]);
fprintf (output_file,
"\tif (!PL_CheckType (PL_Type (item), f->type)) {\n"
"\t\tPL_TypeMismatch (messages, item, "
"f->name, f->type, PL_Type (item));\n"
"\t\treturn 0;\n"
"\t}\n"
"\tvoid *flddata = (byte *)data + f->offset;\n"
"\treturn f->parser (f, item, flddata, messages, "
"context);\n");
} else {
fprintf (output_file,
"\tif (PL_Type (item) == QFString\n"
"\t\t&& !(item = parse_reference (item, \"%s\", "
"messages, context))) {\n"
"\t\treturn 0;\n"
"\t}\n"
"\treturn PL_ParseStruct (%s_fields, item, data, "
"messages, context);\n",
[self outname], [self outname]);
}
[vkgen] Fix some whitespace I thought I'd indented that block, but I guess I'd gotten confused while doing some before and after checks of the indent.
2023-02-10 00:39:13 +00:00
fprintf (output_file, "}\n");
if (have_pNext) {
fprintf (output_file, "static parserref_t %s_parser = ",
[self outname]);
fprintf (output_file, "{\"%s\", %s, sizeof(%s)};\n",
[self outname], [self parseFunc], [self outname]);
}
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
}
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
fprintf (output_file, "static exprsym_t %s_symbols[] = {\n", [self outname]);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
if (field_defs) {
PLItem *field_def;
qfot_var_t *field;
for (int i = [field_defs count]; i-- > 0; ) {
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
FieldDef *field_def = [field_defs objectAtIndex:i];
[field_def writeSymbol];
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
}
} else {
for (int i = 0; i < type.strct.num_fields; i++) {
qfot_var_t *field = &type.strct.fields[i];
if (field.name == "sType" || field.name == "pNext") {
continue;
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
Type *field_type = [Type findType: field.type];
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
fprintf (output_file,
"\t{\"%s\", &%s, (void *) field_offset (%s, %s)},\n",
[vkgen] Recognize `char *` as a string Ruamoko currently doesn't support `const`, so that's not relevant, but recognizing `char *` (via a hack to work around what looks like a bug with type aliasing) allows strings to be handled without having to use a custom parser. Things are still a little clunky for custom parsers, but this seems to be a good start.
2023-02-09 02:32:38 +00:00
field.name, [field_type cexprType], [self outname],
field.name);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
}
}
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
fprintf (output_file, "static exprtab_t %s_symtab = {\n", [self outname]);
fprintf (output_file, "\t%s_symbols,\n", [self outname]);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
fprintf (output_file, "};\n");
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
fprintf (output_file, "exprtype_t %s_type = {\n", [self outname]);
[cexpr] Require designated initializers for exprtype_t This will make expanding it much safer in the future.
2022-04-24 05:55:35 +00:00
fprintf (output_file, "\t.name = \"%s\",\n", [self outname]);
fprintf (output_file, "\t.size = sizeof (%s),\n", [self outname]);
fprintf (output_file, "\t.binops = cexpr_struct_binops,\n");
fprintf (output_file, "\t.unops = 0,\n");
fprintf (output_file, "\t.data = &%s_symtab,\n", [self outname]);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
fprintf (output_file, "};\n");
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
fprintf (output_file, "\n");
fprintf (header_file, "extern exprtype_t %s_type;\n", [self outname]);
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
-(void) writeSymtabInit
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
{
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
PLItem *field_dict = [parse getObjectForKey:[self outname]];
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
if ([parse string] == "skip") {
return;
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
fprintf (output_file, "\tcexpr_init_symtab (&%s_symtab, context);\n",
[self outname]);
}
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
-(void) writeSymtabEntry
{
[vulkan] Support Vulkan's pNext in vkparse/vkgen The real reason for the delay in implementing support for pNext is I didn't know how to approach it at the time, but with the experience I've gained using and modifying vkparse, the solution turned out to be fairly simple. This allows for the use of various extensions (eg, multiview, which was used for testing, though none of the hookup is in this commit). No checking is done on the struct type being valid other than it must be of a chainable type (ie, have its own pNext).
2022-05-29 12:53:38 +00:00
if (!write_symtab || [parse string] == "skip") {
return;
}
fprintf (output_file,
"\tHash_Add (parser_table, &%s_parser);\n",
[self outname]);
[vulkan] Clean up some tangled dependencies Dependencies on vkparse.hinc were spreading through the code which I didn't want as that removes a lot of the automation from the automake files. This keeps all parser code internal to vkparse.c's scope, and any accesses required for enum and struct (not yet) definitions can be fetched by name.
2021-01-04 08:26:39 +00:00
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
-(string) outname
{
if (outname) {
return outname;
}
[vkgen] Use typedef name for structs Using the typedef name makes using structs declared as typedef struct foo_s { ... } foo_t; easier and cleaner. Sure, I could have written the "struct foo_s" for the output name, but I'm much more likely to look for foo_t than foo_s when checking the generated code.
2023-02-08 08:32:20 +00:00
if (alias) {
return [alias name];
}
[vulkan] Refactor vkgen struct generation The addition of data an then string support made keeping track of things in struct's writeTable a nightmare.
2020-12-23 13:13:50 +00:00
return [self name];
[vulkan] Hook up the expression parser The pipeline parser still isn't hooked up yet as something isn't quite right, but it seems all the parsing works.
2020-12-21 09:38:31 +00:00
}
-(string) cexprType
{
[vulkan] Fix a few code generation issues QC's int type is named "integer" (didn't feel like changing that right now), so special case it to be "int". Output the parse func name (instead of "fix me"). Output a parse func for enums (needed for arrays of enums (VkDynamicState)).
2020-12-24 15:17:20 +00:00
return [self outname] + "_type";
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
}
-(string) parseType
{
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
return "QFMultiType | (1 << QFString) | (1 << QFDictionary)";
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
}
-(string) parseFunc
{
[vulkan] Fix a few code generation issues QC's int type is named "integer" (didn't feel like changing that right now), so special case it to be "int". Output the parse func name (instead of "fix me"). Output a parse func for enums (needed for arrays of enums (VkDynamicState)).
2020-12-24 15:17:20 +00:00
return "parse_" + [self outname];
[vulkan] Use a property list to drive code gen The property list specifies the base structures for which parser code will be generated (along with any structures and enums upon which those structures depend). It also defines option specialized parsers for better control.
2020-07-05 05:59:56 +00:00
}
-(string) parseData
{
return "0";
[vulkan] Split up vkgen It worked as a proof of concept, but as the code itself needs to be a bit smarter, it would be a lot smarter to break up that code to make it easier to work on the individual parts.
2020-07-02 05:24:39 +00:00
}
@end
Reference in a new issue Copy permalink