Try to auto-detect some simple-type query functions.
[panamaz] / src / notzed.vulkan / gen / generate-vulkan
1 #!/usr/bin/perl
2
3 use Data::Dumper;
4
5 use File::Path qw(make_path);
6 use File::Basename;
7
8 use strict;
9
10 use Carp 'verbose';
11 use FindBin;
12 use lib "$FindBin::Bin", 'bin/linux-amd64/lib';
13
14 use vulkan;
15 use config;
16 use code;
17
18 $SIG{__DIE__} = sub { Carp::confess( @_ ) };
19 $SIG{'INT'} = sub { Carp::confess() };
20 $Data::Dumper::Indent = 1;
21
22 # ###################################################################### #
23
24 my $enumInfo = {
25         'uint32_t' => {
26                 type => 'int'
27         },
28                 'uint64_t' => {
29                         type => 'long',
30                         suffix => 'L'
31         },
32                 'float' => {
33                         type => 'float',
34                         suffix => 'f'
35         },
36         'const char *' => {
37                 type => 'String'
38         },
39 };
40
41 my %primitiveMap = (
42         'char' => 'byte',
43         'uint8_t' => 'byte',
44         'uint16_t' => 'short',
45         'int32_t' => 'int',
46         'uint32_t' => 'int',
47         'int' => 'int',
48         'int64_t' => 'long',
49         'uint64_t' => 'long',
50         'size_t' => 'long',
51         'float' => 'float',
52         'double' => 'double',
53 );
54
55 # ###################################################################### #
56 my $sys = {};
57
58 $sys->{output} = 'bin/gen/notzed.vulkan/classes';
59 $sys->{package} = 'vulkan';
60 $sys->{verbose} = 0;
61
62 my $vk = new vulkan($sys);
63
64 my $api = $vk->buildFeatures(
65         [ 'VK_VERSION_1_0', 'VK_VERSION_1_1', 'VK_VERSION_1_2' ],
66         [ 'xlib',
67           #'wayland',
68           'xcb' ]);
69
70 my $structTypes = loadTypes($api, 'struct-types.api');
71 my $commandTypes = loadTypes($api, 'command-types.api');
72
73 analyseTypes($vk, $api);
74
75 # Use some heuristics to create overrides for improving the api
76
77 # - object constructor functions return values rather take pointer* values
78 # - array query functions perform the query and return the array
79 # - extension functions use a different invocation mechanism
80 # - drop any 'ignore' types from argument lists
81
82 # - [attempt to] determine which types need to be read/write/arrays
83
84 # Scan structs
85 my %defaultTemplate;
86
87 foreach my $s (values %{$api->{types}}) {
88         my $overrides = $structTypes->{overrides};
89         my $types = $structTypes->{types};
90
91         next if (defined($overrides->{$s->{name}}));
92
93         foreach my $m (@{$s->{items}}) {
94                 my $nstar = $m->{deref} =~ tr/*/*/;
95
96                 if ($m->{deref} eq 'struct*-length') {
97                         $defaultTemplate{$m->{baseType}}->{array} = 1;
98                 } elsif ($m->{deref} eq 'struct[]') {
99                         $defaultTemplate{$m->{baseType}}->{array} = 1;
100                 }
101         }
102
103         $defaultTemplate{$s->{name}}->{name} = 'struct-readonly' if ($s->{returnedonly} eq 'true');
104 }
105
106 # build default overrides for commands
107 foreach my $s (values %{$api->{commands}}) {
108         my $overrides = $commandTypes->{overrides};
109         my $types = $commandTypes->{types};
110         my $first = $s->{items}->[0];
111         my $last = $s->{items}->[$#{$s->{items}}];
112         my $llast = $s->{items}->[$#{$s->{items}}-1];
113         my $result = $s->{proto};
114         my $index = $s->{index};
115
116         # check type updates anyway
117         foreach my $m (@{$s->{items}}) {
118                 if ($m->{deref} eq 'struct*-length') {
119                         $defaultTemplate{$m->{baseType}}->{name} = 'struct-readwrite' if !($m->{fullType} =~ m/const/n) && $api->{types}->{$m->{baseType}}->{returnedonly} ne 'true';
120                         $defaultTemplate{$m->{baseType}}->{array} = 1;
121                 } elsif ($m->{deref} eq 'struct*') {
122                         $defaultTemplate{$m->{baseType}}->{name} = 'struct-readwrite' if !($m->{fullType} =~ m/const/n);
123                 }
124         }
125
126         next if (defined($overrides->{$s->{name}}));
127
128         my $override = {};
129
130         # force handles to be instance types
131         if ($first->{deref} eq 'handle') {
132                 $override->{$first->{name}}->{type} = 'instance';
133         }
134
135         # extension function default template
136         if (defined($s->{extensions})) {
137                 $override->{template} = 'method-extension';
138         }
139
140         # Constructor
141         if ($last->{deref} eq 'handle*') {
142                 if (!$last->{len}) {
143                         my $t = $api->{handles}->{$last->{baseType}};
144                         print "constructor: $s->{name}\n" if $sys->{verbose};
145                         $override->{$last->{name}}->{type} =
146                                 $t->{type} eq 'VK_DEFINE_HANDLE' && $t->{name} ne 'VkInstance' ?
147                                 'dispatch*-output' : 'handle*-output';
148                 } elsif ($index->{$last->{len}}) {
149                         print "constructor?: $s->{name}\n";# if $sys->{verbose};
150                         die;
151                 } else {
152                         print "allocate-constructor?: $s->{name} $last->{len}\n";# if $sys->{verbose};
153                 }
154         }
155
156         # turn array-query functions into auto-allocate/return types
157         # ones we care about with output
158         #       handle*-length
159         #       struct*-length
160         #       uint32_t*-length
161         #       void*-length
162
163         if ($last->{deref} =~ m/-length$/ && (my $len = $index->{$last->{len}})) {
164                 if (index($len->{deref}, '*') >= 0) {
165                         my $protoa = "$result->{fullType} $s->{name}("
166                                 .join(', ', map { "$_->{fullType}" } @{$s->{items}})
167                                 .")";
168                         print "array-constructor: $protoa\n" if $sys->{verbose} > 1;
169
170                         my $otype = ($last->{deref} eq 'handle*-length' && $api->{handles}->{$last->{baseType}}->{type} eq 'VK_DEFINE_HANDLE')
171                                 ? 'dispatch*-length-query' : $last->{deref}.'-query';
172                         my $ltype = $len->{deref}.'-querylen';
173
174                         die "no template $otype" if !defined($commandTypes->{types}->{$otype});
175                         die "no template $ltype" if !defined($commandTypes->{types}->{$ltype});
176
177                         $override->{template} = defined($s->{extensions}) ? 'method-extension-query' : 'method-query';
178                         $override->{$last->{name}}->{type} = $otype;
179                         $override->{$len->{name}}->{type} = $ltype;
180                 }
181         }
182
183         # A whole bunch of query functions
184         if ($s->{name} =~ m/^vkGet/ && !($last->{fullType} =~ m/const/n) && !(defined($override->{$last->{name}}) && defined($override->{$last->{name}}->{type}))) {
185                 if ($last->{fullType} eq 'VkBool32 *') {
186                         print "output: [$last->{fullType}] [$last->{deref}] $s->{name}\n" if $sys->{verbose};
187                         $override->{$last->{name}}->{type} = 'VkBool32*-output';
188                 } elsif ($last->{deref} =~ m/^(int|uint32_t|uint64_t|void)\*$/on) {
189                         print "output: [$last->{fullType}] [$last->{deref}] $s->{name}\n" if $sys->{verbose};
190                         $override->{$last->{name}}->{type} = $last->{deref}."-output";
191                 } else {
192                         print "output? [$last->{fullType}] [$last->{deref}] $s->{name}\n" if $sys->{verbose};
193                 }
194         }
195
196         # other per-item things
197         foreach my $m (@{$s->{items}}) {
198                 my $so = $structTypes->{overrides}->{$m->{baseType}};
199
200                 if ($so->{ignore}) {
201                         die "No type '$m->{deref}-ignore'" if !defined($types->{$m->{deref}.'-ignore'});
202                         $override->{$m->{name}}->{type} = $m->{deref}.'-ignore';
203                 }
204         }
205
206         $overrides->{$s->{name}} = $override if %{$override};
207 }
208
209 {
210         my $overrides = $structTypes->{overrides};
211         my $templates = $structTypes->{templates};
212
213         foreach my $k (keys %defaultTemplate) {
214                 print "what?: ".Dumper($overrides->{$k}->{template}) if defined($overrides->{$k}) && defined($overrides->{$k}->{template});
215                 next if defined($overrides->{$k}) && defined($overrides->{$k}->{template});
216
217                 my $t = $defaultTemplate{$k};
218                 my $name = $t->{name} || "struct-writeonly";
219
220                 $name .= "-array" if $t->{array};
221
222                 print "$name: $k\n" if $sys->{verbose} > 1;
223                 die "No override $k $name" if !$templates->{$name};
224                 $overrides->{$k}->{template} = $name;
225         }
226 }
227
228 if (0) {
229         analyseAccessors($api);
230         exit 1;
231 }
232
233 if (0) {
234         open(my $f, '>', 'types.pm');
235         print $f Dumper($commandTypes, $structTypes);
236         close $f;
237 }
238
239 if (0) {
240         open(my $f, '>', 'api.pm');
241         print $f Dumper($api);
242         close $f;
243         die;
244 }
245
246 if (0) {
247         open(my $f, '>', 'vk.pm');
248         print $f Dumper($vk);
249         close $f;
250         die;
251 }
252
253 exportVulkan($vk, $api, $structTypes);
254
255 # dump out the extension function-pointer tables
256 {
257         my $f = openOutput($sys, 'DispatchInstance');
258         my $template = $structTypes->{templates}->{dispatch};
259         my @init = ();
260         my @fieldInit = ();
261
262         foreach my $k (sort keys %{$api->{commands}}) {
263                 my $c = $api->{commands}->{$k};
264
265                 next if !defined($c->{extensions});
266
267                 push @fieldInit, code::formatTemplate($template->{'field-init'}, $c);
268                 push @init, code::formatTemplate($template->{'init'}, $c);
269
270         }
271
272         my $vars = {
273                 package => 'vulkan',
274                 Name => 'DispatchInstance',
275                 init => join("\n\t\t", @init),
276                 'field-init' => join("\n\t", @fieldInit),
277         };
278         print $f code::formatTemplateStream($template->{class}, $vars);
279
280         closeOutput($sys, 'DispatchInstance', $f);
281 }
282
283 # structs and unions
284 foreach my $k (sort keys %{$api->{types}}) {
285         my $s = $api->{data}->{$k};
286
287         die if !defined $s;
288         next if $s->{alias};
289
290         my $override = $structTypes->{overrides}->{$s->{name}};
291
292         next if $override->{ignore};
293
294         my $f = openOutput($sys, $s->{Name});
295         print $f formatStruct($vk, $api, $s);
296         closeOutput($sys, $s->{Name}, $f);
297 }
298
299 # handles
300 foreach my $k (sort keys %{$api->{handles}}) {
301         my $s = $api->{data}->{$k};
302
303         die if !defined $s;
304         next if $s->{alias};
305
306         my $f = openOutput($sys, $s->{name});
307         print $f formatHandle($vk, $api, $s);
308         closeOutput($sys, $s->{name}, $f);
309 }
310
311 # upcalls
312 foreach my $k (sort keys %{$api->{funcpointers}}) {
313         my $s = $api->{data}->{$k};
314
315         die if !defined $s;
316         next if $s->{alias};
317
318         my $override = $commandTypes->{overrides}->{$s->{name}};
319
320         next if $override->{ignore};
321
322         my $f = openOutput($sys, $s->{name});
323         print $f formatFunctionPointer($vk, $api, $s);
324         closeOutput($sys, $s->{name}, $f);
325 }
326
327 exit 0;
328
329 # ###################################################################### #
330
331 sub formatStructLayout {
332         my $types = shift;
333         my $s = shift;
334         my $offset = 0;
335         my @fields = ();
336
337         # This doens't need to worry about overrides
338
339         if ($s->{category} eq 'struct') {
340                 foreach my $m (@{$s->{items}}) {
341                         my $type = $types->{$m->{deref}};
342                         my $diff = $m->{bitOffset} - $offset;
343
344                         push @fields, "MemoryLayout.paddingLayout($diff)" if $diff;
345
346                         if ($type) {
347                                 my $v = buildVars($s, $m, $type);
348
349                                 push @fields, code::formatTemplate($v->{layout}, $v).".withName(\"$m->{name}\") /* $m->{deref} $m->{fullType} */";
350                                 $offset = $m->{bitOffset} + $m->{bitSize};
351                         } else {
352                                 push @fields, "/* Missing: $m->{deref} $m->{name} */";
353                         }
354                 }
355         } else {
356                 foreach my $m (@{$s->{items}}) {
357                         my $type = $types->{$m->{deref}};
358
359                         if ($type) {
360                                 my $v = buildVars($s, $m, $type);
361
362                                 push @fields, code::formatTemplate($v->{layout}, $v).".withName(\"$m->{name}\") /* $m->{deref} $m->{fullType} */";
363                                 $offset = ($m->{bitOffset} + $m->{bitSize}) if ($m->{bitOffset} + $m->{bitSize}) > $offset;
364                         } else {
365                                 push @fields, "/* Missing: $m->{deref} $m->{name} */";
366                         }
367                 }
368         }
369
370         my $diff = $s->{bitSize} - $offset;
371
372         push @fields, "MemoryLayout.paddingLayout($diff)" if $diff;
373
374         return "MemoryLayout.".$s->{category}."Layout(\n\t\t".join(",\n\t\t", @fields).").withName(\"$s->{name}\")";
375 }
376
377 # Experiment: see if sharing varhandles would be of any benefit
378 #  - analyse all pointer/int fields for cross-overs
379 # for vulkan 1.3:
380 #  Total fields: 3370
381 #  Unique fields: 368
382 # so very significant savings possible
383 sub analyseAccessors {
384         my $api = shift;
385         my %handles;
386         my $total;
387         my %lookat;
388
389         map { $lookat{$_} = 1 } qw(Memory.POINTER Memory.BYTE Memory.SHORT Memory.INT Memory.LONG Memory.FLOAT Memory.DOUBLE);
390
391         foreach my $s (values %{$api->{types}}) {
392                 my $override = $structTypes->{overrides}->{$s->{name}};
393
394                 next if $s->{alias};
395                 next if $override->{ignore};
396
397                 foreach my $m (@{$s->{items}}) {
398                         my $deref = $m->{deref};
399                         my $type = $structTypes->{types}->{$deref};
400                         my $v = buildVars($s, $m, $type);
401                         my $layout = code::formatTemplate($v->{layout}, $v);
402                         my $index = $m->{bitOffset} / 8;
403
404                         die if ($m->{bitoffset} & ($m->{bitSize}-1));
405
406                         if ($lookat{$layout}) {
407                                 $index = $m->{bitOffset} / $m->{bitSize};
408                         }
409
410                         my $k = sprintf "$layout \@ %03d", $index;
411
412                         $handles{$k}++;
413                         $total++;
414                 }
415         }
416
417         print "Other unique handles =\n";
418         foreach my $h (sort keys %handles) {
419                 $h =~ m/^(.*) \@/;
420                 my $x = $lookat{$1};
421                 if (!$lookat{$1}) {
422                         printf " %5d $h\n", $handles{$h};
423                 }
424         }
425         print "Unique handles of interest =\n";
426         foreach my $h (sort keys %handles) {
427                 $h =~ m/^(.*) \@/;
428                 if ($lookat{$1}) {
429                         printf " %5d $h\n", $handles{$h};
430                 }
431         }
432         my @keys = keys %handles;
433         print "Total fields: $total\n";
434         print "Unique fields: $#keys\n";
435 }
436
437 # ###################################################################### #
438
439 sub loadTypes {
440         my $api = shift;
441         my $file = shift;
442         my $config = new config({ includes=>[ $FindBin::Bin ] }, "$FindBin::Bin/$file");
443
444         my $types = {};
445         my $templates = {};
446         my $overrides = {};
447
448         foreach my $t (@{$config->{objects}}) {
449                 if ($t->{type} eq 'type') {
450                         my $nopts = $#{$t->{options}};
451                         my $type = {};
452
453                         die ("No prototype provided/found for empty type ".Dumper($t)) if ($#{$t->{items}} < 0 && $#{$t->{options}} < 0);
454
455                         # Check options / load inherited values
456                         foreach my $o (@{$t->{options}}) {
457                                 if ($o =~ m/^accessor=(.*)$/o) {
458                                         die "No template $1" if !defined($templates->{$1});
459                                         $type->{accessor} = $templates->{$1};
460                                 } elsif ($o eq 'need-frame') {
461                                         $type->{'need-frame'} = 1;
462                                 } elsif ($o eq 'need-scope') {
463                                         $type->{'need-scope'} = 1;
464                                 } elsif ($o eq 'trampoline-scope') {
465                                         $type->{'trampoline-scope'} = 1;
466                                 } elsif ($o eq 'need-alloc') {
467                                         $type->{'need-alloc'} = 1;
468                                 } elsif ($o eq 'is-instance') {
469                                         $type->{'is-instance'} = 1;
470                                 } elsif (defined($types->{$o})) {
471                                         $type = { %$type, %{$types->{$o}} };
472                                 } else {
473                                         die "Unknown option '$o' in ".Dumper($t);
474                                 }
475                         }
476
477                         # Load the fields
478                         foreach my $s (@{$t->{items}}) {
479                                 if (defined $s->{literal}) {
480                                         $type->{$s->{match}} = $s->{literal};
481                                 } elsif ($#{$s->{options}} >= 0) {
482                                         $type->{$s->{match}} = $s->{options}->[$#{$s->{options}}];
483                                 } else {
484                                         $type->{$s->{match}} = 0;
485                                 }
486
487                                 $type->{"$s->{match}:eval"} = 1 if config::optionFlag('eval', $s);
488                         }
489
490                         # Write to all aliases
491                         foreach my $k (split /,/,$t->{name}) {
492                                 $types->{$k} = $type;
493                         }
494                 } elsif ($t->{type} eq 'code') {
495                         my $code = {
496                                 insert => {},
497                         };
498
499                         foreach my $o (@{$t->{options}}) {
500                                 if ($o =~ m/insert=(.*)/) {
501                                         foreach my $x (split /,/,$1) {
502                                                 if ($x =~ m/(.*):(.*)/) {
503                                                         die "$x $t->{name} ".Dumper($templates->{$1}) if !defined $templates->{$1}->{$2};
504                                                         $code->{insert}->{$2} = $templates->{$1}->{$2};
505                                                 }
506                                         }
507                                 } elsif ($o =~ m/^fields=(.*)/) {
508                                         $code->{fields} = $1;
509                                 } elsif (defined($templates->{$o})) {
510                                         $code = { %$code, %{$templates->{$o}} };
511                                 } else {
512                                         die ("Unknown option '$o'");
513                                 }
514                         }
515
516                         foreach my $s (@{$t->{items}}) {
517                                 if (defined  $s->{literal}) {
518                                         my $t = $s->{literal};
519
520                                         $t =~ s/^\t//gm;
521                                         $code->{$s->{match}} = $t;
522                                 } else {
523                                         delete $code->{$s->{match}};
524                                 }
525
526                                 $code->{"$s->{match}:eval"} = 1 if config::optionFlag('eval', $s);
527                         }
528
529                         $templates->{$t->{name}} = $code;
530                 } elsif ($t->{type} eq 'override') {
531                         foreach my $s (@{$t->{items}}) {
532                                 my $c = { };
533                                 foreach my $o (@{$s->{options}}) {
534                                         if ($o =~ m/^(.*)=type:(.*)/) {
535                                                 die "No such type $s->{match} $2\n" if !defined $types->{$2};
536                                                 $c->{$1}->{type} = $2;
537                                         } elsif ($o =~ m/^(.*)=accessor:(.*)/) {
538                                                 die "No accessor template $o" if !defined($templates->{$2});
539                                                 $c->{$1}->{accessor} = $templates->{$2};
540                                         } elsif ($o =~ m/^template=(.*)/) {
541                                                 die "No template $o" if !defined($templates->{$1});
542                                                 $c->{template} = $1;
543                                         } elsif ($o eq 'expand') {
544                                                 $c->{expand} = 1;
545                                         } elsif ($o eq 'ignore') {
546                                                 $c->{ignore} = 1;
547                                         }
548                                 }
549                                 $overrides->{$s->{match}} = $c;
550                         }
551                 }
552         }
553
554         # templates should probably just go in one
555         {
556                 types => $types,
557                 templates => $templates,
558                 overrides => $overrides,
559         };
560 }
561
562 sub uniq {
563   my %seen;
564   return grep { !$seen{$_}++ } @_;
565 }
566
567 # generate Vulkan.java
568 sub exportVulkan {
569         my $vk = shift;
570         my $api = shift;
571         my $structTypes = shift;
572         my $seen = {};
573         my $template = $structTypes->{templates}->{Vulkan};
574
575         my @constants = ();
576         my @defines = ();
577
578         # special case for api constants
579         {
580                 my $s = $api->{data}->{'API Constants'};
581
582                 push @constants, "// API Constants\n";
583
584                 foreach my $m (@{$s->{items}}) {
585                         next if defined($m->{alias});
586                         next if $seen->{$m->{name}}++;
587
588                         my $i = $enumInfo->{$m->{type}};
589                         my $v = $m->{value};
590
591                         # convert to java
592                         $v =~ s/[()ULF]+//gon if (!($v =~ m/^"/));
593
594                         push @constants,"public final static $i->{type} $m->{name} = $v$i->{suffix};";
595                 }
596         }
597
598         # include any defines we have a template for
599         foreach my $k (sort keys %{$api->{defines}}) {
600                 if ($template->{$k}) {
601                         push @defines, $template->{$k};
602                 } else {
603                         print "Ignored: $k\n";
604                 }
605         }
606
607         foreach my $k (sort keys %{$api->{enums}}) {
608                 my $s = $api->{data}->{$k};
609                 my $type = $s->{fullType} ? $s->{fullType} : 'VkFlags';
610                 my $i = $enumInfo->{$vk->{data}->{$type}->{type}};
611
612                 next if $s->{alias};
613
614                 push @constants, "";
615                 push @constants, "// $s->{name} $type";
616
617                 foreach my $m (@{$s->{items}}) {
618                         next if defined($m->{alias});
619                         next if $seen->{$m->{name}}++;
620
621                         my $v = $m->{value};
622
623                         $v = 1<<$m->{bitpos} if !defined($v) && defined($m->{bitpos});
624
625                         die Dumper("Ca't work out value", $m, $s) if !defined($v);
626                         push @constants, "public final static $i->{type} $m->{name} = $v$i->{suffix};";
627                 }
628         }
629
630         my $v = {
631                 package => $sys->{package},
632                 defines => join("\n\t", @defines),
633                 constants => join("\n\t", @constants),
634         };
635
636         my $f = openOutput($sys, 'Vulkan');
637
638         print $f code::formatTemplateStream($template->{class}, $v);
639
640         closeOutput($sys, 'Vulkan', $f);
641 }
642
643 # ###################################################################### #
644 # class.name to class/name.java
645 sub classToPath {
646         my $sys = shift;
647         my $name = shift;
648
649         $name = $sys->{package}.'.'.$name;
650         $name =~ s@\.@/@g;
651         $name = $sys->{output}.'/'.$name.'.java';
652         $name;
653 }
654
655 sub closeOutput {
656         my $sys = shift;
657         my $name = shift;
658         my $f = shift;
659         my $path = classToPath($sys, $name);
660
661         close($f) || die;
662         rename($path.'~', $path) || die ("rename failed: $!");
663 }
664
665 sub openOutput {
666         my $sys = shift;
667         my $name = shift;
668
669         my $path = classToPath($sys, $name);
670         my $dir = dirname($path);
671
672         make_path($dir) if (!-d $dir);
673
674         open(my $f, ">", $path.'~') || die ("Cannot open '$path' for writing");
675         print "writing '$path'\n" if $sys->{verbose} > 0;
676         $f;
677 }
678
679
680 # Calculate canonical derefernce types for each field and parameter
681 sub analyseFields {
682         my $vk = shift;
683         my $api = shift;
684         my $seen = shift;
685         my $s = shift;
686
687         # what about const?
688         # FIXME: bitfields
689
690         my $index = {};
691
692         map { $index->{$_->{name}} = $_ } @_;
693
694         $s->{index} = $index;
695
696         foreach my $m (@_) {
697                 my $t = $api->{data}->{$m->{baseType}};
698                 my $nstar = $m->{fullType} =~ tr/*/*/;
699                 my $type;
700                 my $array = '';
701
702                 # Check array sizes
703                 if ($m->{fullType} =~ m/\[(.*)\]\[(.*)\]$/o) {
704                         $array = '[][]';
705                         $m->{len1} = $1;
706                         $m->{len2} = $2;
707                 } elsif ($m->{fullType} =~ m/\[(.*)\]$/o) {
708                         my $isize = $1;
709                         my $size;
710                         if ($isize =~ m/^\d+$/n) {
711                                 $size = $isize;
712                         } else {
713                                 $size = $vk->{data}->{'API Constants'}->{index}->{$isize}->{value};
714                         }
715                         $array = '[]';
716                         $m->{len1} = $size;
717                 } elsif ($m->{fullType} =~ m/[\[\]]/on) {
718                         die Dumper($m)
719                 }
720
721                 if (!defined($t)) {
722                         # will be primitive or external
723                         $type = $m->{baseType} if ($nstar == 0);
724                         $type = "$m->{baseType}*" if ($nstar == 1);
725                         $type = "$m->{baseType}**" if ($nstar == 2);
726                         die if $nstar > 2;
727                 } else {
728                         # unmap aliases
729                         while ($t->{alias}) {
730                                 print "alias $t->{name} -> $t->{alias}\n";
731                                 $t = $api->{data}->{$t->{alias}};
732                                 die if !defined $t;
733                                 $m->{baseType} = $t->{name};
734                         }
735
736                         if ($t->{category} =~ m/enum|bitmask/on) {
737                                 $t = $vk->{data}->{$t->{fullType}};
738                                 $type = $t->{type} if ($nstar == 0);
739                                 $type = "$t->{type}*" if ($nstar == 1);
740                                 die if $nstar > 1;
741                         } elsif ($t->{category} =~ m/struct|union/on) {
742                                 $m->{type} = $t->{name};
743                                 $type = 'struct' if ($nstar == 0);
744                                 $type = 'struct*' if ($nstar == 1);
745                                 $type = 'struct**' if ($nstar == 2);
746                                 die if $nstar > 2;
747                         } elsif ($t->{category} eq 'handle') {
748                                 $m->{type} = $t->{name};
749                                 #if ($t->{type} eq 'VK_DEFINE_HANDLE') {
750                                 #       $type = 'dhandle' if ($nstar == 0);
751                                 #       $type = 'dhandle*' if ($nstar == 1);
752                                 #} else {
753                                         $type = 'handle' if ($nstar == 0);
754                                         $type = 'handle*' if ($nstar == 1);
755                                 #}
756                                 die if $nstar > 1;
757                         } elsif ($t->{category} eq 'basetype') {
758                                 # ??
759                                 $type = $t->{type} if ($nstar == 0);
760                                 $type = "$t->{type}*" if ($nstar == 1);
761                                 die Dumper($m, $t) if $nstar > 1;
762                         } elsif ($t->{category} eq 'funcpointer') {
763                                 $m->{type} = $t->{name};
764                                 $type = "funcpointer" if ($nstar == 0);
765                                 die if $nstar > 0;
766                         } else {
767                                 die Dumper($m, $t);
768                         }
769                 }
770
771                 if ($s->{category} eq 'struct') {
772                         my $mover = $structTypes->{overrides}->{$m->{baseType}};
773                         $type .= "-expand" if $nstar == 0 && $mover->{expand};
774                 }
775
776                 # an array type with a length
777                 if ($nstar > 0 && $m->{len}) {
778                         if ($s->{category} =~ m/struct|union/on) {
779                                 if ($m->{altlen}) {
780                                         if ($m->{altlen} =~ m/^(.*)(VK_UUID_SIZE)(.*)$/) {
781                                                 $m->{length} = $1.'Vulkan.'.$2.$3;
782                                         } elsif ($m->{altlen} =~ m/^([^a-zA-Z_]*)([a-zA-Z_]+)(.*)$/) {
783                                                 my $len = $index->{$2};
784                                                 if (defined $len) {
785                                                         $m->{length} = $1.'get'.ucfirst($2).'()'.$3;
786                                                 }
787                                         } else {
788                                                 die "Unhandled len/altlen: ".Dumper($m);
789                                         }
790                                 } elsif ($m->{len} =~ m/(.*),null-terminated/) {
791                                         my $len = $index->{$1};
792                                         if (defined $len) {
793                                                 $m->{length} = "get$len->{Name}()";
794                                         }
795                                 } elsif ($m->{len} eq 'null-terminated') {
796                                         # ignore
797                                 } elsif ($m->{len} =~ m/^(.*),(\d+)$/) {
798                                         # ignore?
799                                 } else {
800                                         my $len = $index->{$m->{len}};
801                                         if (defined $len) {
802                                                 my $cast = ($len->{fullType} eq 'uint32_t') ? '(int)' : '';
803
804                                                 die "Not simple type" if ($len->{fullType} ne $len->{baseType});
805                                                 $m->{length} = "get$len->{Name}()";
806                                         } else {
807                                                 die "what?".Dumper($m);
808                                         }
809                                 }
810                         } elsif ($s->{category} eq 'command') {
811                                 if ($m->{altlen}) {
812                                         die;
813                                 } else {
814                                         $m->{length} = $m->{len} if $index->{$m->{len}};
815                                         $index->{$m->{len}}->{lengthfor} = $m->{name} if $index->{$m->{len}};
816                                 }
817                         } else {
818                                 die Dumper($s);
819                         }
820                         $type = $type.'-length' if $m->{length};
821                 }
822
823                 $seen->{$m->{fullType}} = $type.$array;
824                 $m->{deref} = $type.$array;
825
826                 # Calculate name, with some fixup hacks
827                 my $name = $m->{name};
828                 #if ($s->{type} =~ m/struct|union/on)
829                 {
830                         # Strip leading 'p' for pointers
831                         if ($name eq 'ppGeometries') { # && $s->{name} eq 'VkAccelerationStructureBuildGeometryInfoKHR') {
832                                 $name = 'PGeometries';
833                         } elsif ($nstar > 0 && $name =~ m/^p{$nstar}/) {
834                                 my $strip = $nstar;
835
836                                 if ($t->{category} eq 'handle' && $type ne 'handle*-length') {
837                                         $strip -= 1;
838                                 }
839
840                                 $name = substr $name, $strip;
841                         }
842
843                         $name =~ s/^pfn//o if $type eq 'funcpointer';
844                         # CamelCase
845                         $name =~ s/(?:^|_)(.)/\U$1/og;
846                 }
847                 $m->{Name} = $name;
848         }
849 }
850
851 sub analyseTypes {
852         my $vk = shift;
853         my $api = shift;
854         my $seen = {};
855
856         foreach my $s (grep { $_->{items} } values %{$api->{types}}) {
857                 analyseFields($vk, $api, $seen, $s, @{$s->{items}});
858
859                 my $name = $s->{name};
860                 $name =~ s/(?:^|_)(.)/\U$1/og;
861                 $s->{Name} = $name;
862
863                 my $first = $s->{items}->[0];
864                 my $second = $s->{items}->[1];
865
866                 if ($first->{name} eq 'sType' && $second && $second->{name} eq 'pNext') {
867                         $first->{'no-setall'} = 1;
868                         $second->{'no-setall'} = 1;
869                         print "typed: $s->{name}\n" if $sys->{verbose} > 1;
870                 } else {
871                         print "untyped: $s->{name}\n" if $sys->{verbose} > 1;
872                 }
873         }
874
875         foreach my $c (values %{$api->{funcpointers}}) {
876                 analyseFields($vk, $api, $seen, $c, $c->{proto}, @{$c->{items}});
877         }
878
879         foreach my $c (values %{$api->{commands}}) {
880                 $c->{proto}->{name} = 'result$';
881                 $c->{proto}->{Name} = 'result$';
882                 analyseFields($vk, $api, $seen, $c, $c->{proto}, @{$c->{items}});
883
884                 # collect all member functions on handles
885                 my $first = $c->{items}->[0];
886                 my $last = $c->{items}->[$#{$c->{items}}];
887                 if ($first->{deref} eq 'handle') {
888                         my $t = $api->{handles}->{$first->{baseType}};
889                         while ($t->{alias}) {
890                                 $t = $api->{handles}->{$t->{alias}};
891                         }
892                         die "No handle found ".Dumper($c) if !defined $t;
893                         push @{$t->{commands}}, $c->{name};
894                 } elsif ($c->{name} =~ m/vkEnumerateInstance|vkCreateInstance/) {
895                         push @{$api->{handles}->{'VkInstance'}->{commands}}, $c->{name};
896                 } else {
897                         die "No owner for call ".Dumper($c);
898                 }
899         }
900
901         print "Unique Types:\n";
902         my $base = {};
903         map { $base->{$_} = 1 } values %$seen;
904
905         foreach my $k (sort keys %$base) {
906                 print "$k\n";
907         }
908 }
909
910 # what else?
911 # vk? api?
912 # this way-over-evaluates, probably only call once on every field and member instead
913 sub buildVars {
914         my $s = shift;
915         my $m = shift;
916         my $type = shift;
917         my $v = { %{$m} };
918
919         foreach my $k (grep { index($_, ':') == -1 } keys %$type) {
920                 my $t = $type->{$k};
921
922                 if ($type->{"$k:eval"}) {
923                         $v->{$k} = $t;
924                         die "Eval failed: $! $@: ".Dumper($m, $type) if !defined($v->{$k});
925                 } elsif ($t) {
926                         $v->{$k} = $t;
927                 }
928         }
929
930         $v;
931 }
932
933 sub formatStructLayout {
934         my $types = shift;
935         my $s = shift;
936         my $offset = 0;
937         my @fields = ();
938
939         # This doens't need to worry about overrides
940
941         if ($s->{category} eq 'struct') {
942                 foreach my $m (@{$s->{items}}) {
943                         my $type = $types->{$m->{deref}};
944                         my $diff = $m->{bitOffset} - $offset;
945
946                         push @fields, "MemoryLayout.paddingLayout($diff)" if $diff;
947
948                         if ($type) {
949                                 my $v = buildVars($s, $m, $type);
950
951                                 push @fields, code::formatTemplate($v->{layout}, $v).".withName(\"$m->{name}\") /* $m->{deref} $m->{fullType} */";
952                                 $offset = $m->{bitOffset} + $m->{bitSize};
953                         } else {
954                                 push @fields, "/* Missing: $m->{deref} $m->{name} */";
955                         }
956                 }
957         } else {
958                 foreach my $m (@{$s->{items}}) {
959                         my $type = $types->{$m->{deref}};
960
961                         if ($type) {
962                                 my $v = buildVars($s, $m, $type);
963
964                                 push @fields, code::formatTemplate($v->{layout}, $v).".withName(\"$m->{name}\") /* $m->{deref} $m->{fullType} */";
965                                 $offset = ($m->{bitOffset} + $m->{bitSize}) if ($m->{bitOffset} + $m->{bitSize}) > $offset;
966                         } else {
967                                 push @fields, "/* Missing: $m->{deref} $m->{name} */";
968                         }
969                 }
970         }
971
972         my $diff = $s->{bitSize} - $offset;
973
974         push @fields, "MemoryLayout.paddingLayout($diff)" if $diff;
975
976         return "MemoryLayout.".$s->{category}."Layout(\n\t\t".join(",\n\t\t", @fields).").withName(\"$s->{name}\")";
977 }
978
979 sub formatAccessorIf {
980         my $s = shift;
981         my $m = shift;
982         my $info = shift;
983         my $type = shift;
984         my $field = shift;
985         my $v = shift;
986         my $accessor = $type->{accessor};
987         my $template = $accessor->{$field};
988
989         if ($template) {
990                 $template = eval($template) if ($accessor->{"$field:eval"});
991
992                 die "Error executing template $field $accessor->{$field}: $@" if (!defined($template));
993
994                 push @{$info->{$field}}, code::formatTemplate($template, $v) if $template;
995         }
996 }
997
998 sub formatStruct {
999         my $vk = shift;
1000         my $api = shift;
1001         my $s = shift;
1002         my $templates = $structTypes->{templates};
1003         my $types = $structTypes->{types};
1004         my $overrides = $structTypes->{overrides};
1005
1006         my $override = $overrides->{$s->{name}};
1007         my $tempname = $override->{template} ? $override->{template} : 'struct-writeonly';
1008         my $template = $templates->{$tempname};
1009         my @fields = split(/,/, $template->{fields});
1010         my $info;
1011
1012         map { $info->{$_} = [] } @fields;
1013
1014         my $setall = defined $info->{'java-setall'};
1015
1016         # unions need multiple constructors
1017         if ($setall) {
1018                 if ($s->{category} eq 'struct') {
1019                         $info->{create}->{create} = {
1020                                 'setall-arg' => [],
1021                                 setall => [],
1022                                 setallat => [],
1023                         };
1024                 } elsif ($s->{category} eq 'union') {
1025                         foreach my $m (@{$s->{items}}) {
1026                                 $info->{create}->{"create$m->{Name}"} = {
1027                                         'setall-arg' => [],
1028                                         setall => [],
1029                                         setallat => [],
1030                                 };
1031                         }
1032                 } else {
1033                         die;
1034                 }
1035         }
1036
1037         # Collect all fields
1038         foreach my $m (@{$s->{items}}) {
1039                 my $nstar = $m->{deref} =~ tr/*/*/;
1040                 my $mover = $override->{$m->{name}};
1041                 my $deref = defined($mover->{type}) ? $mover->{type} : $m->{deref};
1042                 my $type = $types->{$deref};
1043
1044                 die "No type $deref ".Dumper($m, $s) if !$type;
1045                 die Dumper($mover, $type) if $mover->{accessor};
1046
1047                 if ($type->{accessor}) {
1048                         my $v = buildVars($s, $m, $type);
1049                         my @todump;
1050
1051                         if ($m->{values}) {
1052                                 @todump = qw(init initat init-array set setat);
1053                         } else {
1054                                 @todump = qw(get getat set setat getorset getorsetat);
1055
1056                                 if ($setall && !$m->{'no-setall'}) {
1057                                         my $create = $s->{category} eq 'struct' ? $info->{create}->{create} : $info->{create}->{"create$m->{Name}"};
1058                                         formatAccessorIf($s, $m, $create, $type, 'setall-arg', $v);
1059                                         formatAccessorIf($s, $m, $create, $type, 'setall', $v);
1060                                         formatAccessorIf($s, $m, $create, $type, 'setallat', $v);
1061                                 }
1062                         }
1063
1064                         push @{$info->{handle}}, code::formatTemplate($v->{handle}, $v)." /* $m->{name} $m->{fullType} ($m->{deref}) */" if $info->{handle} && $v->{handle};
1065                         push @{$info->{handleat}}, code::formatTemplate($v->{handleat}, $v) if $info->{handleat} && $v->{handleat};
1066
1067                         foreach my $field (@todump) {
1068                                 if ($info->{$field} && $type->{accessor}->{$field}) {
1069                                         my $t = $type->{accessor}->{$field};
1070
1071                                         $t = eval $t if $type->{accessor}->{"$field:eval"};
1072                                         die "$@" if !defined($t);
1073
1074                                         push @{$info->{$field}}, code::formatTemplate($t, $v);
1075                                 }
1076                         }
1077                 }
1078         }
1079
1080         # create constructors
1081         my $v = {
1082                 package => 'vulkan',
1083                 name => $s->{name},
1084                 Name => $s->{Name},
1085                 layout => formatStructLayout($types, $s),
1086         };
1087
1088         foreach my $field (@fields) {
1089                 $v->{$field} = join("\n", @{$info->{$field}});
1090         }
1091
1092         # build sub-components using the full $v
1093         my @createAll = ();
1094         foreach my $k (keys %{$template->{insert}}) {
1095                 my $t = $template->{insert}->{$k};
1096
1097                 die if (!defined($t));
1098
1099                 if ($k eq 'create-all' || $k eq 'set-all' || $k eq 'setat-all') {
1100                         if ($setall) {
1101                                 foreach my $kk (keys %{$info->{create}}) {
1102                                         my $create = $info->{create}->{$kk};
1103
1104                                         if ($#{$create->{'setall-arg'}} >= 0) {
1105                                                 my $v = {
1106                                                         create => $kk,
1107                                                         set => $kk =~ s/create/set/r,
1108                                                         Name => $s->{Name},
1109                                                         'java-setall-arguments' => join (', ', @{$create->{'setall-arg'}}),
1110                                                         'java-setall' => join ("\n\t\t", @{$create->{setall}}),
1111                                                         'java-setallat' => join ("\n\t\t", @{$create->{setallat}}),
1112                                                 };
1113                                                 push @createAll, code::formatTemplateStream($t, $v);
1114                                         }
1115                                 }
1116                         }
1117                 } else {
1118                         $v->{$k} = code::formatTemplate($t, $v);
1119                 }
1120         }
1121         $v->{'create-all'} = join("\n", @createAll) if $setall;
1122
1123         #die Dumper($info, $v) if $s->{name} eq 'VkRect2D';
1124
1125         join("\n", map { '// '.$_ } split(/\n/,Dumper($s)))."\n".
1126                 code::formatTemplateStream($template->{class}, $v);
1127 }
1128
1129 # TODO: the template here could be mapped from types.api perhaps?
1130 # also same for the various fields, init/getset/etc.
1131 sub formatHandle {
1132         my $vk = shift;
1133         my $api = shift;
1134         my $s = shift;
1135         my $templates = $structTypes->{templates};
1136         my $overrides = $structTypes->{overrides};
1137         my $override = $overrides->{$s->{name}};
1138         my $tempname = $override->{template} ? $override->{template} : 'handle';
1139         my $template = $templates->{$tempname};
1140
1141         my $info = {
1142                 init => [],
1143                 commands => [],
1144         };
1145
1146         if (defined $s->{commands}) {
1147                 foreach my $k (sort @{$s->{commands}}) {
1148                         my $c = $api->{commands}->{$k};
1149                         push @{$info->{commands}}, formatFunction($api, $commandTypes, $c);
1150                 }
1151         }
1152
1153         my $v = {
1154                 package => 'vulkan',
1155                 name => $s->{name},
1156                 Name => $s->{Name},
1157                 init => join ("\n", @{$info->{init}}),
1158                 commands => join ("\n", @{$info->{commands}}),
1159         };
1160
1161         code::formatTemplateStream($template->{class}, $v);
1162 }
1163
1164 sub formatSignature {
1165         my $s = shift;
1166         my $types = $commandTypes->{types};
1167         my $d = '(';
1168
1169         foreach my $m (@{$s->{items}}) {
1170                 my $x = $types->{$m->{deref}};
1171
1172                 die "No sig defined ".Dumper($m) if !defined($x) || !defined($x->{sig});
1173
1174                 $d .= $x->{sig};
1175         }
1176         $d .= ')';
1177
1178         my $m = $s->{proto};
1179         my $x = $types->{$m->{deref}};
1180         die "No sig defined ".Dumper($m) if !defined($x) || !defined($x->{sig});
1181         $d .= $x->{sig};
1182 }
1183
1184 # Forms all the parameter templates
1185 sub collectFunctionInfo {
1186         my $api = shift;
1187         my $ct = shift;
1188         my $s = shift;
1189         my $types = $ct->{types};
1190         my $overrides = $ct->{overrides};
1191         my $void = $s->{proto}->{fullType} eq 'void';
1192         my $override = $overrides->{$s->{name}};
1193
1194         my @javaArgs = ();
1195         my @invokeArgs = ();
1196         my @nativeInit = ();
1197         my @queryInit = ();
1198         my @queryArgs = ();
1199
1200         my @nativeArgs = ();
1201         my @trampArgs = ();
1202
1203         my $info = {
1204                 rename => $s->{name},
1205                 name => $s->{name},
1206                 'function-descriptor' => formatFunctionDescriptor($ct, $s),
1207                 'native-result-define' => '',
1208                 'native-result-assign' => '',
1209                 'native-result' => 'void',
1210                 'trampoline-result-define' => '',
1211                 'trampoline-result-assign' => '',
1212                 'trampoline-scope' => '',
1213                 'result-test' => '',
1214                 'create-frame' => '',
1215                 'java-result' => 'void',
1216                 'java-result-assign' => '',
1217                 'result-throw' => '',
1218
1219                 'java-result-return' => 'return;',
1220                 'trampoline-result-return' => 'return;',
1221         };
1222
1223         my $hasInstance = 0;
1224         my $needFrame = 0;
1225         my $needAlloc = 0;
1226         my $needScope = 0;
1227         my $trampScope = 0;
1228
1229         my @arrayFields = qw(java-arg invoke-arg native-init query-init query-arg native-arg trampoline-arg);
1230         my @fixedFields = qw(java-result java-result-return java-result-assign);
1231
1232         map { $info->{$_} = [] } @arrayFields;
1233
1234         # Calculate parameters
1235         foreach my $m (@{$s->{items}}) {
1236                 my $deref = defined($override->{$m->{name}}) && defined($override->{$m->{name}}->{type}) ? $override->{$m->{name}}->{type} : $m->{deref};
1237                 my $type = $types->{$deref};
1238
1239                 die "No type found ".Dumper($m, $s, $override) if !$type;
1240
1241                 my $v = buildVars($s, $m, $type);
1242
1243                 foreach my $field (@arrayFields) {
1244                         if ($v->{$field}) {
1245                                 push @{$info->{$field}}, code::formatTemplate($v->{$field}, $v);
1246                         } elsif ($field eq 'query-arg') {
1247                                 push @{$info->{$field}}, code::formatTemplate($v->{'invoke-arg'}, $v);
1248                         }
1249                 }
1250
1251                 foreach my $field (@fixedFields) {
1252                         $info->{$field} = code::formatTemplate($v->{$field}, $v) if ($v->{$field});
1253                 }
1254
1255                 $needScope = 1 if $type->{'need-scope'};
1256                 $needFrame = 1 if $type->{'need-frame'};
1257                 $needAlloc = 1 if $type->{'need-alloc'};
1258                 $hasInstance = 1 if $type->{'is-instance'};
1259                 $trampScope = 1 if $type->{'trampoline-scope'};
1260         }
1261
1262         $info->{'static'} = $hasInstance ? '' : 'static ';
1263
1264         # Handle default return types, others are handled by the fixedFields above
1265         if ($s->{successcodes}) {
1266                 my @codes = split(/,/,$s->{successcodes});
1267
1268                 $info->{'native-result-define'} = 'int result$;';
1269                 $info->{'native-result-assign'} = 'result$ = (int)';
1270                 $info->{'result-test'} = 'if ('.join("||", map { '(result$ == Vulkan.'.$_.')' } @codes).')';
1271                 $info->{'result-throw'} = 'throw new RuntimeException("error " + result$);';
1272
1273                 if ($#codes > 0 && $info->{'java-result'} eq 'void') {
1274                         $info->{'java-result'} = 'int';
1275                         $info->{'java-result-return'} = 'return result$;';
1276                 }
1277         } elsif ($s->{proto}->{fullType} ne 'void') {
1278                 my $m = $s->{proto};
1279                 my $type = defined($override->{$m->{name}}) ? $override->{$m->{name}}->{type} : $types->{$m->{deref}.'-return'};
1280
1281                 die "No type '$m->{deref}-return' ".Dumper($m, $s) if !defined($type);
1282                 die Dumper($m, $s) if !defined($type->{'java-result-return'});
1283
1284                 my $v = buildVars($s, $m, $type);
1285
1286                 $info->{'native-result-define'} = code::formatTemplate($v->{'native-result-define'}, $v);
1287                 $info->{'native-result-assign'} = code::formatTemplate($v->{'native-result-assign'}, $v);
1288                 #$info->{'native-result-define'}.= join("", map { "// $_\n" } split(/\n/, Dumper($m)));
1289                 $info->{'java-result'} = code::formatTemplate($v->{type}, $v);
1290                 $info->{'java-result-return'} = code::formatTemplate($v->{'java-result-return'}, $v);
1291
1292                 $info->{'native-result'} = code::formatTemplate($v->{'carrier'}, $v);
1293                 $info->{'trampoline-result-define'} = code::formatTemplate($v->{'trampoline-result-define'}, $v);
1294                 $info->{'trampoline-result-assign'} = code::formatTemplate($v->{'trampoline-result-assign'}, $v);
1295                 $info->{'trampoline-result-return'} = code::formatTemplate($v->{'trampoline-result-return'}, $v);
1296
1297                 $needScope = 1 if $type->{'need-scope'};
1298         }
1299
1300         $info->{'create-frame'} = '(Frame frame$ = Frame.frame())' if $needFrame;
1301         $info->{'trampoline-scope'} = '(ResourceScope scope$$ = ResourceScope.newConfinedScope())' if $trampScope;
1302
1303         push @{$info->{'java-arg'}}, 'SegmentAllocator alloc$' if $needAlloc;
1304         push @{$info->{'java-arg'}}, 'ResourceScope scope$' if $needScope;
1305
1306         foreach my $field (@arrayFields) {
1307                 my $with = $field =~ m/-arg$/n ? ",\n\t" : "\n\t";
1308                 $info->{$field} = join $with, @{$info->{$field}};
1309         }
1310
1311         $info->{successcodes} = $s->{successcodes} ? $s->{successcodes} : '';
1312         $info->{errorcodes} = $s->{errorcodes} ? $s->{errorcodes}: '';
1313
1314         if ($s->{category} eq 'funcpointer') {
1315                 $info->{'trampoline-signature'} = formatSignature($s);
1316         }
1317
1318         $info;
1319 }
1320
1321 sub formatFunctionPointer {
1322         my $vk = shift;
1323         my $api = shift;
1324         my $s = shift;
1325         my $template = $commandTypes->{templates}->{'funcpointer-readwrite'};
1326         my $info = collectFunctionInfo($api, $commandTypes, $s);
1327
1328         my $v = {
1329                 package => 'vulkan',
1330                 name => $s->{name},
1331                 Name => $s->{Name},
1332         };
1333
1334         foreach my $k (keys %{$template->{insert}}) {
1335                 my $t = $template->{insert}->{$k};
1336
1337                 $v->{$k} = code::formatTemplate($t, $info);
1338         }
1339
1340         code::formatTemplateStream($template->{class}, $v);
1341 }
1342
1343 sub formatFunctionDescriptor {
1344         my $ct = shift;
1345         my $s = shift;
1346         my $types = $ct->{types};
1347         my @fields = ();
1348         my $void = $s->{proto}->{fullType} eq 'void';
1349         my $override = $ct->{overrides}->{$s->{name}};
1350
1351         foreach my $m ($void ? () : $s->{proto}, @{$s->{items}}) {
1352                 my $deref = defined($override->{$m->{name}}) && defined($override->{$m->{name}}->{type}) ? $override->{$m->{name}}->{type} : $m->{deref};
1353                 my $type = $types->{$deref};
1354
1355                 die "No type '$deref' found ".Dumper($m, $s, $override) if !$type;
1356
1357                 my $v = buildVars($s, $m, $type);
1358
1359                 push @fields, code::formatTemplate($v->{layout}, $v)." /* $m->{deref} $m->{name} */";
1360         }
1361
1362         return ($void ? 'FunctionDescriptor.ofVoid(' : 'FunctionDescriptor.of(')
1363                 .join(",\n\t\t", @fields).')';
1364 }
1365
1366 sub formatFunction {
1367         my $api = shift;
1368         my $ct = shift;
1369         my $s = shift;
1370         my $void = $s->{proto}->{fullType} eq 'void';
1371         my $override = $ct->{overrides}->{$s->{name}};
1372         my $tempname = $override->{template} ? $override->{template} : 'method';
1373         my $template = $ct->{templates}->{$tempname};
1374
1375         my $info = collectFunctionInfo($api, $ct, $s);
1376
1377         #join("\n", map { '// '.$_ } split(/\n/,Dumper($s)))."\n".
1378         " /* template: $tempname */\n".
1379                 code::formatTemplate($template->{invoke}, $info);
1380 }