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

249 lines
6.2 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
-(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]];
[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";
string name = str_hold ([self outname]);
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);
}
[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"];
[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;
[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] 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 (field_dict) {
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;
}
[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 = [FieldDef fielddef:nil
struct:self
field:field.name];
[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];
}
fprintf (output_file, "static plfield_t %s_fields[] = {\n", [self outname]);
[vkparse] Add support for inheriting objects It simply parses the referenced plist dictionary (via @inherit = plist.path;) into the current data block, then allows the data to be overwritten by the current plist dictionary. This may be a bit iffy for any allocated resources, so some care must be taken, but it seems to work nicely.
2022-04-03 02:11:28 +00:00
fprintf (output_file,
"\t{\"@inherit\", 0, QFString, parse_inherit, &%s_fields},\n",
[self outname]);
[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 writeField];
}
[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
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
[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] 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 (header_file, "int parse_%s (const plfield_t *field,"
" const plitem_t *item, void *data, plitem_t *messages,"
" void *context);\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
[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, "int parse_%s (const plfield_t *field,"
[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
" const plitem_t *item, void *data, plitem_t *messages,"
" void *context)\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
[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
fprintf (output_file, "{\n");
[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
if (have_sType) {
fprintf (output_file, "\t((%s *) data)->sType", [self outname]);
fprintf (output_file, " = %s;\n", [self sTypeName]);
}
[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
fprintf (output_file,
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
"\tif (PL_Type (item) == QFString\n"
"\t\t&& !(item = parse_reference (item, \"%s\", messages, context))) {\n"
"\t\treturn 0;\n"
"\t}\n"
[util] Rename PL_ParseDictionary to PL_ParseStruct Struct is far more appropriate for its function, and I need to parse a dictionary into a hash table.
2020-12-24 04:33:37 +00:00
"\treturn PL_ParseStruct (%s_fields, item, data, messages,"
[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
" context);\n",
[vulkan] Allow all struct objects to be referenced
2021-02-14 02:20:54 +00:00
[self outname], [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
fprintf (output_file, "}\n");
[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",
[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.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] 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;
}
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