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

305 lines
8.7 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
#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)) {
printf (" +%s\n", name);
Hash_Add (processed_types, (void *) name);
[queue addObject: self];
}
}
[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
-(void) forEachFieldCall: (varfunc) func
{
qfot_struct_t *strct =&type.strct;
for (int i = 0; i < strct.num_fields; i++) {
func (&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
-(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;
}
-(void) writeTable: (PLItem *) parse
{
[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
string name = [self name];
PLItem *field_dict = [parse getObjectForKey:name];
[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
PLItem *field_defs = [field_dict allKeys];
Type *field_type;
[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"];
if (new_name) {
name = [new_name 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
if (field_defs) {
PLItem *field_def;
qfot_var_t *field;
for (int i = [field_defs count]; i-- > 0; ) {
string field_name = [[field_defs getObjectAtIndex:i] string];
field_def = [field_dict getObjectForKey:field_name];
PLItem *type_desc = [field_def getObjectForKey:"type"];
string type_record;
string type_type;
string size_field = nil;
string value_field = nil;
[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 (!type_desc || str_mid(field_name, 0, 1) == ".") {
[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
continue;
}
type_record = [[type_desc getObjectAtIndex:0] string];
type_type = [[type_desc getObjectAtIndex:1] string];
field_type = [[Type lookup: type_type] dereference];
fprintf (output_file, "static parse_%s_t parse_%s_%s_data = {\n",
[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
type_record, name, field_name);
[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 (type_record == "single") {
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
fprintf (output_file, "\t%s,\n", [field_type parseType]);
fprintf (output_file, "\tsizeof (%s),\n", type_type);
fprintf (output_file, "\tparse_%s,\n", type_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
value_field = [[field_def getObjectForKey:"value"] string];
fprintf (output_file, "\tfield_offset (%s, %s),\n",
[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
name, value_field);
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "array") {
fprintf (output_file, "\t%s,\n", [field_type parseType]);
fprintf (output_file, "\tsizeof (%s),\n", type_type);
fprintf (output_file, "\tparse_%s,\n", type_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
value_field = [[field_def getObjectForKey:"values"] string];
size_field = [[field_def getObjectForKey:"size"] string];
fprintf (output_file, "\tfield_offset (%s, %s),\n",
[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
name, value_field);
[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 (size_field) {
fprintf (output_file, "\tfield_offset (%s, %s),\n",
[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
name, size_field);
[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 {
fprintf (output_file, "\t-1,\n");
}
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "data") {
value_field = [[field_def getObjectForKey:"data"] string];
size_field = [[field_def getObjectForKey:"size"] string];
fprintf (output_file, "\tfield_offset (%s, %s),\n",
name, value_field);
if (size_field) {
fprintf (output_file, "\tfield_offset (%s, %s),\n",
name, size_field);
} else {
fprintf (output_file, "\t-1,\n");
}
} else {
fprintf (output_file, "\tno type,\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
}
fprintf (output_file, "};\n");
}
}
[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
fprintf (output_file, "static plfield_t %s_fields[] = {\n", name);
[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 (field_defs) {
PLItem *field_def;
qfot_var_t *field;
for (int i = [field_defs count]; i-- > 0; ) {
string field_name = [[field_defs getObjectAtIndex:i] 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
if (str_mid(field_name, 0, 1) == ".") {
continue;
}
[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
field_def = [field_dict getObjectForKey:field_name];
if ([field_def string] == "auto") {
field = [self findField:field_name];
if (!field) {
continue;
}
field_type = [Type findType: field.type];
fprintf (output_file,
"\t{\"%s\", field_offset (%s, %s), %s, %s, %s},\n",
[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
field_name, name, field_name,
[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
[field_type parseType], [field_type parseFunc],
[field_type parseData]);
} else {
PLItem *type_desc = [field_def getObjectForKey:"type"];
string type_record;
string type_type;
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
string parseType = "no 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
type_record = [[type_desc getObjectAtIndex:0] string];
type_type = [[type_desc getObjectAtIndex:1] string];
field_type = [[Type lookup: type_type] dereference];
if (type_record == "single") {
parseType = [field_type parseType];
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "array") {
[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
parseType = "QFArray";
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "data") {
parseType = "QFBinary";
[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,
"\t{\"%s\", 0, %s, parse_%s, &parse_%s_%s_data},\n",
field_name, parseType, type_record,
[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
name, field_name);
[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;
}
field_type = [Type findType: field.type];
fprintf (output_file,
"\t{\"%s\", field_offset (%s, %s), %s, %s, %s},\n",
[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
field.name, name, field.name,
[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
[field_type parseType], [field_type parseFunc],
[field_type parseData]);
[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",
name);
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",
name);
[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");
fprintf (output_file,
[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
"\treturn PL_ParseDictionary (%s_fields, item, data, messages,"
" context);\n",
name);
[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
fprintf (output_file, "static exprsym_t %s_symbols[] = {\n", name);
if (field_defs) {
PLItem *field_def;
qfot_var_t *field;
for (int i = [field_defs count]; i-- > 0; ) {
string field_name = [[field_defs getObjectAtIndex:i] string];
field_def = [field_dict getObjectForKey:field_name];
PLItem *type_desc = [field_def getObjectForKey:"type"];
string type_record;
string type_type;
string size_field = nil;
string value_field = nil;
if (str_mid(field_name, 0, 1) == ".") {
continue;
}
field_def = [field_dict getObjectForKey:field_name];
if ([field_def string] == "auto") {
field = [self findField:field_name];
if (!field) {
continue;
}
field_type = [Type findType: field.type];
fprintf (output_file,
"\t{\"%s\", &%s, (void *) field_offset (%s, %s)},\n",
field_name, [field_type cexprType], name, field_name);
} else {
type_record = [[type_desc getObjectAtIndex:0] string];
if (type_record == "single") {
value_field = [[field_def getObjectForKey:"value"] string];
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "array") {
[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
value_field = [[field_def getObjectForKey:"values"] string];
[vulkan] Add support for parsing binary data
2020-12-23 05:08:53 +00:00
} else if (type_record == "data") {
value_field = [[field_def getObjectForKey:"data"] string];
[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 (!value_field) {
value_field = field_name;
}
fprintf (output_file,
"\t{\"%s\", 0/*FIXME*/,"
" (void *) field_offset (%s, %s)},\n",
field_name, name, value_field);
}
}
} 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;
}
field_type = [Type findType: field.type];
fprintf (output_file,
"\t{\"%s\", &%s, (void *) field_offset (%s, %s)},\n",
field.name, [field_type cexprType], name, field.name);
}
}
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
fprintf (output_file, "static exprtab_t %s_symtab = {\n", name);
fprintf (output_file, "\t%s_symbols,\n", name);
fprintf (output_file, "};\n");
fprintf (output_file, "exprtype_t %s_type = {\n", name);
fprintf (output_file, "\t\"%s\",\n", name);
fprintf (output_file, "\tsizeof (%s),\n", name);
fprintf (output_file, "\tcexpr_struct_binops,\n");
fprintf (output_file, "\t0,\n");
fprintf (output_file, "\t&%s_symtab,\n", name);
fprintf (output_file, "};\n");
fprintf (header_file, "extern exprtype_t %s_type;\n", name);
}
-(void) writeSymtabInit:(PLItem *) parse
{
string name = [self name];
PLItem *field_dict = [parse getObjectForKey:name];
PLItem *new_name = [field_dict getObjectForKey:".name"];
if (new_name) {
name = [new_name string];
}
fprintf (output_file, "\tcexpr_init_symtab (&%s_symtab, context);\n", name);
}
-(string) cexprType
{
return [self name] + "_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
{
return "QFDictionary";
}
-(string) parseFunc
{
return "fix me";
}
-(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