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

565 lines
14 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"
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
#include "vkfieldtype.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
{
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
[field_dict release];
[field_defs release];
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
[parse_def release];
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
[only release];
[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
str_free (outname);
str_free (label_field);
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
[super dealloc];
[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
}
[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]);
}
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
static void
write_function_head (Struct *self)
[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
{
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
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");
}
[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
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
static void
write_function_tail (Struct *self)
{
fprintf (output_file, "}\n");
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
static void
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
write_parse_type (Struct *self, PLItem *item)
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
{
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
if ([item string] == "auto") {
fprintf (output_file, "\t\tif (!PL_ParseStruct (%s_fields, item, "
"data, messages, context)) {\n", [self outname]);
fprintf (output_file, "\t\t\treturn 0;\n");
fprintf (output_file, "\t\t}\n");
} else {
//FieldDef *def = [FieldDef fielddef:item struct:self field:".parse"];
[self.parse_def writeParse];
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
}
static void
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
write_auto_parse (Struct *self, string field, int name)
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
{
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
string item = name ? "name" : "item";
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
fprintf (output_file, "\t\tdo {\n");
fprintf (output_file, "\t\t\tplfield_t *f = find_field (%s_fields, %s, "
"item, messages);\n", [self outname], sprintf ("\"%s\"", field));
fprintf (output_file, "\t\t\tif (!f) {\n");
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
fprintf (output_file, "\t\t\t\treturn 0;\n");
fprintf (output_file, "\t\t\t}\n");
if (name) {
fprintf (output_file, "\t\t\tplitem_t *name = "
"PL_NewString (field->name);\n");
}
fprintf (output_file, "\t\t\tf->parser (f, %s, &%s, messages, context);\n",
item, sprintf ("((%s *) data)->%s", [self outname], field));
if (name) {
fprintf (output_file, "\t\t\tPL_Release (name);\n");
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
fprintf (output_file, "\t\t} while (0);\n");
}
static int
check_need_table (Struct *self, PLItem *field_dict, string type)
{
string key = nil;
switch (type) {
case "QFDictionary": key = ".dictionary"; break;
case "QFArray": key = ".array"; break;
case "QFBinary": key = ".binary"; break;
case "QFString": key = ".string"; break;
}
PLItem *type_obj = [field_dict getObjectForKey:key];
int count = [type_obj numKeys];
if (!count) {
return 0;
}
for (int i = 0; i < count; i++) {
string field = [type_obj keyAtIndex:i];
PLItem *item = [type_obj getObjectForKey:field];
string str = [item string];
if (field == ".parse") {
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
if (str != "auto") {
self.parse_def = [[FieldDef fielddef:item
struct:self
field:"parse"] retain];
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
return 1;
}
if (str == "$auto") {
return 1;
}
}
return 0;
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
static void
write_type (Struct *self, PLItem *field_dict, string type)
{
string key = nil;
switch (type) {
case "QFDictionary": key = ".dictionary"; break;
case "QFArray": key = ".array"; break;
case "QFBinary": key = ".binary"; break;
case "QFString": key = ".string"; break;
}
PLItem *type_obj = [field_dict getObjectForKey:key];
int count = [type_obj numKeys];
if (!count) {
//FIXME errors
[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;
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
fprintf (output_file, "\tif (type == %s) {\n", type);
for (int i = 0; i < count; i++) {
string field = [type_obj keyAtIndex:i];
PLItem *item = [type_obj getObjectForKey:field];
string str = [item string];
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
if (field == ".parse") {
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
write_parse_type (self, item);
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
continue;
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
switch (str) {
case "$item.string":
str = "vkstrdup (context, PL_String (item))";
break;
case "$item.line":
str = "PL_Line (item)";
break;
case "$name":
str = "vkstrdup (context, field->name)";
break;
case "$index":
str = "field->offset";
break;
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
case "$auto":
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
write_auto_parse (self, field, 0);
continue;
case "$name.auto":
write_auto_parse (self, field, 1);
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
continue;
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
}
fprintf (output_file, "\t\t((%s *) data)->%s = %s;\n", [self outname],
field, str);
[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
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
fprintf (output_file, "\t\treturn 1;\n");
fprintf (output_file, "\t}\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
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
static void
write_parser (Struct *self, int have_sType, PLItem *only)
{
write_function_head (self);
if (have_sType) {
fprintf (output_file, "\t((%s *) data)->sType", [self outname]);
fprintf (output_file, " = %s;\n", [self sTypeName]);
}
if (self.label_field) {
fprintf (output_file, "\t((%s *) data)->%s", [self outname],
self.label_field);
fprintf (output_file, " = vkstrdup (context, field->name);\n");
}
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]);
}
write_function_tail (self);
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
static void
write_cexpr (Struct *self, Array *field_defs)
{
fprintf (output_file, "static exprsym_t %s_symbols[] = {\n",
[self outname]);
if (field_defs) {
PLItem *field_def;
qfot_var_t *field;
for (int i = [field_defs count]; i-- > 0; ) {
FieldDef *field_def = [field_defs objectAtIndex:i];
[field_def writeSymbol];
[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] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
} else {
for (int i = 0; i < self.type.strct.num_fields; i++) {
qfot_var_t *field = &self.type.strct.fields[i];
if (field.name == "sType" || field.name == "pNext") {
continue;
}
Type *field_type = [Type findType: field.type];
fprintf (output_file,
"\t{\"%s\", &%s, (void *) field_offset (%s, %s)},\n",
field.name, [field_type cexprType], [self outname],
field.name);
[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] 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] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
fprintf (output_file, "static exprtab_t %s_symtab = {\n", [self outname]);
fprintf (output_file, "\t%s_symbols,\n", [self outname]);
fprintf (output_file, "};\n");
fprintf (output_file, "exprtype_t %s_type = {\n", [self outname]);
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]);
fprintf (output_file, "};\n");
fprintf (output_file, "\n");
fprintf (header_file, "extern exprtype_t %s_type;\n", [self outname]);
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
static void
write_table (Struct *self, PLItem *field_dict, Array *field_defs,
PLItem *only, int need_parser)
{
qfot_type_t *type = self.type;
int have_sType = 0;
int have_pNext = 0;
int readonly = [field_dict string] == "readonly";
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;
}
if (field.name == "pNext") {
have_pNext = 1;
self.write_symtab = 1;
}
}
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
for (int i = [field_defs count]; i-- > 0; ) {
FieldDef *field_def = [field_defs objectAtIndex:i];
[field_def writeParseData];
}
[vkgen] Support custom parsing in multi-type fields This allows the likes of: qfv_pushconstantrangeinfo_s = { .name = qfv_pushconstantrangeinfo_t; .type = (QFDictionary); .dictionary = { .parse = { type = (labeledarray, qfv_pushconstantinfo_t, name); size = num_pushconstants; values = pushconstants; }; stageFlags = $name.auto; }; stageFlags = auto; }; Leading to: pushConstants = { vertex = { Model = mat4; blend = float; }; fragment = { colors = uint; base_color = vec4; fog = vec4; }; }; Where the label of the labeled array (which pushConstants is) is actually an enum flag and the dictionary value is another labeled array.
2023-06-16 09:53:37 +00:00
[self.parse_def writeParseData];
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
if (!readonly) {
fprintf (output_file, "static plfield_t %s_fields[] = {\n",
[self outname]);
if (!only) {
fprintf (output_file,
"\t{\"@inherit\", 0, QFString, parse_inherit, "
"&%s_fields},\n", [self outname]);
}
if (have_pNext) {
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];
}
fprintf (output_file, "\t{ }\n");
fprintf (output_file, "};\n");
if (need_parser) {
write_parser (self, have_sType, only);
}
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]);
}
}
}
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
-(void) initParse:(PLItem *)parse
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
{
if ([parse string] == "skip") {
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
skip = 1;
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
return;
}
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
field_dict = [parse retain];
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
PLItem *new_name = [field_dict getObjectForKey:".name"];
if (new_name) {
outname = str_hold ([new_name string]);
}
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
field_defs = [[Array array] retain];
only = [[field_dict getObjectForKey:".only"] retain];
[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
}
}
[vkgen] Make labeled arrays independent of struct order It turns out labeled arrays don't work if structs aren't declared in the right order (no idea what that is, though) as the struct might not have been processed when the labeled array field is initialized. Thus, do a pro-processing pass to set up any parse data prior to writing the tables.
2023-02-26 11:36:53 +00:00
}
-(void) writeTable
{
if (skip) {
return;
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
if ([field_dict getObjectForKey:".type"]) {
PLItem *type = [field_dict getObjectForKey:".type"];
string str = [type string];
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
int need_table = 0;
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
if (str) {
need_table |= check_need_table (self, field_dict, str);
} else {
for (int i = [type count]; i-- > 0; ) {
string str = [[type getObjectAtIndex:i] string];
need_table |= check_need_table (self, field_dict, str);
}
}
if (need_table) {
write_table (self, field_dict, field_defs, only, 0);
}
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
write_function_head (self);
fprintf (output_file, "\tpltype_t type = PL_Type (item);\n");
if (str) {
write_type (self, field_dict, str);
} else {
for (int i = [type count]; i-- > 0; ) {
str = [[type getObjectAtIndex:i] string];
write_type (self, field_dict, str);
}
}
fprintf (output_file,
"\tPL_TypeMismatch (messages, item, field->name, %s, type);\n",
parseItemType (type));
fprintf (output_file, "\treturn 0;\n");
write_function_tail (self);
write_cexpr (self, field_defs);
return;
}
[vkgen] Improve .type parse spec handling .dictionary can ask for standard parsing via a .parse key (value is ignored currently). Fields can use $auto to use standard parsing for that field. If either is used, the plist field descriptors are written.
2023-02-18 08:00:52 +00:00
write_table (self, field_dict, field_defs, only, 1);
[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
[vkgen] Add support for directly scripted parsing It's very early, but it does the job for what I needed (storing the string item and line number).
2023-02-11 17:35:54 +00:00
write_cexpr (self, field_defs);
[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