3 # Copyright 2002 Patrik Stridvall
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU Lesser General Public
7 # License as published by the Free Software Foundation; either
8 # version 2.1 of the License, or (at your option) any later version.
10 # This library is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 # Lesser General Public License for more details.
15 # You should have received a copy of the GNU Lesser General Public
16 # License along with this library; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 $0 =~ m%^(.*?/?tools)/winapi/winapi_test$%;
24 require "$1/winapi/setup.pm";
28 file_type files_skip files_filter
29 $current_dir $wine_dir $winapi_dir
31 use output qw($output);
32 use winapi_test_options qw($options);
34 if($options->progress) {
35 $output->enable_progress;
37 $output->disable_progress;
43 use util qw(replace_file);
55 foreach my $test (@tests) {
56 my @test_dirs = $tests->get_test_dirs($test);
57 foreach my $test_dir (@test_dirs) {
58 my @headers = $tests->get_section($test_dir, $test, "header");
59 foreach my $header (@headers) {
60 $files{"include/$header"} = 1;
65 foreach my $test (@tests) {
66 my @test_dirs = $tests->get_test_dirs($test);
67 foreach my $test_dir (@test_dirs) {
68 my @headers = $tests->get_section($test_dir, $test, "header");
69 foreach my $header (@headers) {
70 if($files{"include/$header"}) {
71 push @files, "include/$header";
72 $files{"include/$header"} = 0;
80 my $file = "tests.dat";
82 $file .= "2"; # FIXME: For tests
84 open(OUT, "> $winapi_dir/$file") || die "$winapi_dir/$file: $!\n";
87 my @test_dirs = $tests->get_test_dirs();
88 foreach my $test_dir (@test_dirs) {
89 print OUT "\n" if $x++;
90 print OUT "%%%$test_dir\n";
94 my @tests = $tests->get_tests($test_dir);
95 foreach my $test (@tests) {
96 print OUT "\n" if $y++;
97 print OUT "%%$test\n";
103 my @sections = $tests->get_sections($test_dir, $test);
104 foreach my $section (@sections) {
105 my @lines = $tests->get_section($test_dir, $test, $section);
107 if ($section =~ /^(?:struct|type)$/) {
108 foreach my $line (@lines) {
114 print OUT "\n" if $z++;
115 print OUT "%$section\n";
117 foreach my $line (@lines) {
122 @types = sort { $x = $a; $y = $b; $x =~ s/^!//; $y =~ s/^!//; $x cmp $y } @types;
124 print OUT "\n" if $z++;
127 foreach my $type (@types) {
141 my $progress_current = 0;
142 my $progress_max = scalar(@files);
144 ########################################################################
150 "ANYSIZE_ARRAY" => 1,
151 "CCHDEVICENAME" => 32,
152 "CCHILDREN_TITLEBAR+1" => 6,
153 "ELF_VENDOR_SIZE" => 4,
154 "EXCEPTION_MAXIMUM_PARAMETERS" => 15,
155 "HW_PROFILE_GUIDLEN" => 39,
156 "IMAGE_NUMBEROF_DIRECTORY_ENTRIES" => 16,
157 "IMAGE_SIZEOF_SHORT_NAME" => 8,
159 "LF_FULLFACESIZE" => 64,
160 "MAXIMUM_SUPPORTED_EXTENSION" => 512,
161 "MAX_GOPHER_DISPLAY_TEXT + 1" => 129,
162 "MAX_GOPHER_LOCATOR_LENGTH + 1" => 654,
164 "MAX_PROFILE_LEN" => 80,
166 "OFS_MAXPATHNAME" => 128,
167 "SIZE_OF_80387_REGISTERS" => 80,
168 "TOKEN_SOURCE_LENGTH" => 8,
171 my %align_kludge_reported = ("FILETIME" => 1, "LARGE_INTEGER" => 1);
172 my %size_kludge_reported = ("FILETIME" => 1, "LARGE_INTEGER" => 1);
173 my %size_parse_reported;
175 sub _find_align_kind_size($) {
176 my $type_name = shift;
178 local $_ = $type_name;
189 } elsif(/^(?:(signed|unsigned)\s+)?(?:__int8|char|byte)$/) {
191 $kind = defined($1) ? $1 : "signed";
193 } elsif (/^(?:(signed|unsigned)\s+)?(?:__int16|short(?:\s+int)?)$/) {
195 $kind = defined($1) ? $1 : "signed";
197 } elsif (/^(?:wchar_t)$/) {
201 } elsif (/^(signed|unsigned)$/) {
203 $kind = defined($1) ? $1 : "signed";
205 } elsif (/^(?:(signed|unsigned)\s+)?(?:__int32|int|long(?:\s+int)?)$/) {
207 $kind = defined($1) ? $1 : "signed";
209 } elsif (/^(?:float)$/) {
213 } elsif (/^(?:(signed|unsigned)\s+)?__int64$/) {
215 $kind = defined($1) ? $1 : "signed";
217 } elsif (/^(?:double|DOUBLE|DATE)$/) {
221 } elsif (/^(?:long\s+double)$/) {
225 } elsif (/^H(?:DC|BITMAP|BRUSH|ICON|INSTANCE|KEY|MENU|METAFILE|RESULT|WND)$/) {
229 } elsif (/^LP(?:BYTE|CSTR|CWSTR|DWORD|STR|VOID|WSTR)$/) {
233 } elsif (/^(?:FILETIME)$/) {
237 } elsif (/^(?:VOID)$/) {
241 } elsif (/^(?:SHORT)$/) {
245 } elsif (/^(?:BYTE)$/) {
249 } elsif (/^(?:DWORD)$/) {
253 } elsif (/^(?:WORD)$/) {
257 } elsif (/^(?:INT64|LONG64|LONGLONG)$/) {
261 } elsif (/^(?:UINT64|ULONG64|DWORD64|ULONGLONG|DWORDLONG)$/) {
265 } elsif (/^(?:LARGE_INTEGER)$/) {
269 } elsif (/^(struct|union)$/) {
271 if (!$size_parse_reported{$_}) {
272 $output->write("$type_name: can't parse type\n");
273 $size_parse_reported{$_} = 1;
275 } elsif (/^\w+\s*\((?:\s*CALLBACK|\s*NTAPI|\s*WINAPI)?\s*\*\s*\)\s*\(.*?\)$/) {
282 if (defined(my $type = $type_name2type{$_})) {
283 $align2 = $type->align;
286 if (!defined($align)) {
288 } elsif (defined($align2) && !$align_kludge_reported{$_}) {
289 $align_kludge_reported{$_} = 1;
290 $output->write("$type_name: type needn't be kludged\n");
293 if (!defined($align)) {
294 # $output->write("$type_name: can't find type\n");
298 if (defined(my $type = $type_name2type{$_})) {
299 $size2 = $type->size;
302 if (!defined($size)) {
304 } elsif (defined($size2) && !$size_kludge_reported{$_}) {
305 $size_kludge_reported{$_} = 1;
306 $output->write("$type_name: type needn't be kludged\n");
309 return ($align, $kind, $size);
313 my $type_name = shift;
314 (my $align, my $kind, my $size) = _find_align_kind_size($type_name);
319 my $type_name = shift;
320 (my $align, my $kind, my $size) = _find_align_kind_size($type_name);
326 my $type_name = shift;
327 (my $align, my $kind, my $size) = _find_align_kind_size($type_name);
333 return $defines{$count};
336 foreach my $file (@files) {
340 open(IN, "< $wine_dir/$file");
349 while(s/^.*?\n//) { $max_line++; }
350 if($_) { $max_line++; }
353 my $parser = new c_parser($file);
359 my $update_output = sub {
363 $progress .= "$file (file $progress_current of $progress_max)";
364 $prefix .= "$file: ";
367 $progress .= ": line $line of $max_line";
370 $output->progress($progress);
371 $output->prefix($prefix);
376 my $found_line = sub {
381 $parser->set_found_line_callback($found_line);
383 my $found_preprocessor = sub {
384 my $begin_line = shift;
385 my $begin_column = shift;
386 my $preprocessor = shift;
388 #print "found_preprocessor: $begin_line: [$_]\n";
389 if ($preprocessor =~ /^\#\s*include\s+[\"<]pshpack(\d+)\.h[\">]$/) {
391 #print "found pack $1 on line $begin_line\n";
392 } elsif($preprocessor =~ /^\#\s*include\s+[\"<]poppack\.h[\">]$/) {
394 #print "found poppack on line $begin_line\n";
399 $parser->set_found_preprocessor_callback($found_preprocessor);
401 my $found_type = sub {
406 my $name = $type->name;
407 $file2types{$file}{$name} = $type;
409 $type->set_find_align_callback(\&find_align);
410 $type->set_find_kind_callback(\&find_kind);
411 $type->set_find_size_callback(\&find_size);
412 $type->set_find_count_callback(\&find_count);
414 my $pack = $packs[$#packs];
415 if (!defined($type->pack) && $type->kind =~ /^(?:struct|union)$/) {
418 my $size = $type->size();
419 if (defined($size)) {
420 my $max_field_base_size = 0;
422 foreach my $field ($type->fields()) {
423 my $field_type_name = $field->type_name;
424 my $field_name = $field->name;
425 my $field_size = $field->size;
426 my $field_base_size = $field->base_size;
427 my $field_offset = $field->offset;
428 my $field_align = $field->align;
430 # $output->write("$name: $field_type_name: $field_name: $field_offset: $field_size($field_base_size): $field_align\n");
432 # $output->write("$name: $size\n");
434 $type_name2type{$name} = $type;
436 # $output->write("$name: can't find size\n");
441 $parser->set_found_type_callback($found_type);
446 if(!$parser->parse_c_file(\$_, \$line, \$column)) {
447 $output->write("can't parse file\n");
454 ########################################################################
457 sub output_header($$$) {
460 my $test_dir = shift;
461 my @tests = @{(shift)};
463 print OUT "/* File generated automatically from tools/winapi/test.dat; do not edit! */\n";
464 print OUT "/* This file can be copied, modified and distributed without restriction. */\n";
468 foreach my $test (@tests) {
469 my @description = $tests->get_section($test_dir, $test, "description");
470 foreach my $description (@description) {
471 print OUT " * $description\n";
477 print OUT "#define WINVER 0x0501\n";
478 print OUT "#define _WIN32_IE 0x0501\n";
479 print OUT "#define _WIN32_WINNT 0x0501\n";
481 print OUT "#define WINE_NOWINSOCK\n";
483 foreach my $test (@tests) {
484 my @includes = $tests->get_section($test_dir, $test, "include");
485 foreach my $include (@includes) {
486 print OUT "#include $include\n";
490 print OUT "#include \"wine/test.h\"\n";
493 print OUT "/***********************************************************************\n";
494 print OUT " * Compability macros\n";
497 print OUT "#define DWORD_PTR UINT_PTR\n";
498 print OUT "#define LONG_PTR INT_PTR\n";
499 print OUT "#define ULONG_PTR UINT_PTR\n";
502 print OUT "/***********************************************************************\n";
503 print OUT " * Windows API extension\n";
506 print OUT "#if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)\n";
507 print OUT "# define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)\n";
508 print OUT "#elif defined(__GNUC__)\n";
509 print OUT "# define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)\n";
511 print OUT "/* FIXME: Not sure if is possible to do without compiler extension */\n";
512 print OUT "#endif\n";
514 print OUT "#if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)\n";
515 print OUT "# define _TYPE_ALIGNMENT(type) __alignof(type)\n";
516 print OUT "#elif defined(__GNUC__)\n";
517 print OUT "# define _TYPE_ALIGNMENT(type) __alignof__(type)\n";
520 print OUT " * FIXME: Not sure if is possible to do without compiler extension\n";
521 print OUT " * (if type is not just a name that is, if so the normal)\n";
522 print OUT " * TYPE_ALIGNMENT can be used)\n";
524 print OUT "#endif\n";
526 print OUT "#if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)\n";
527 print OUT "#pragma warning(disable:4116)\n";
528 print OUT "#endif\n";
530 print OUT "#if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)\n";
531 print OUT "# define TYPE_ALIGNMENT _TYPE_ALIGNMENT\n";
532 print OUT "#endif\n";
535 print OUT "/***********************************************************************\n";
536 print OUT " * Test helper macros\n";
539 print OUT "#ifdef FIELD_ALIGNMENT\n";
540 print OUT "# define TEST_FIELD_ALIGNMENT(type, field, align) \\\n";
541 print OUT " ok(FIELD_ALIGNMENT(type, field) == align, \\\n";
542 print OUT " \"FIELD_ALIGNMENT(\" #type \", \" #field \") == %d (expected \" #align \")\\n\", \\\n";
543 print OUT " (int)FIELD_ALIGNMENT(type, field))\n";
545 print OUT "# define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)\n";
546 print OUT "#endif\n";
548 print OUT "#define TEST_FIELD_OFFSET(type, field, offset) \\\n";
549 print OUT " ok(FIELD_OFFSET(type, field) == offset, \\\n";
550 print OUT " \"FIELD_OFFSET(\" #type \", \" #field \") == %ld (expected \" #offset \")\\n\", \\\n";
551 print OUT " (long int)FIELD_OFFSET(type, field))\n";
553 print OUT "#ifdef _TYPE_ALIGNMENT\n";
554 print OUT "#define TEST__TYPE_ALIGNMENT(type, align) \\\n";
555 print OUT " ok(_TYPE_ALIGNMENT(type) == align, \"TYPE_ALIGNMENT(\" #type \") == %d (expected \" #align \")\\n\", (int)_TYPE_ALIGNMENT(type))\n";
557 print OUT "# define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)\n";
558 print OUT "#endif\n";
560 print OUT "#ifdef TYPE_ALIGNMENT\n";
561 print OUT "#define TEST_TYPE_ALIGNMENT(type, align) \\\n";
562 print OUT " ok(TYPE_ALIGNMENT(type) == align, \"TYPE_ALIGNMENT(\" #type \") == %d (expected \" #align \")\\n\", (int)TYPE_ALIGNMENT(type))\n";
564 print OUT "# define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)\n";
565 print OUT "#endif\n";
567 print OUT "#define TEST_TYPE_SIZE(type, size) \\\n";
568 print OUT " ok(sizeof(type) == size, \"sizeof(\" #type \") == %d (expected \" #size \")\\n\", ((int) sizeof(type)))\n";
570 print OUT "/***********************************************************************\n";
571 print OUT " * Test macros\n";
574 print OUT "#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \\\n";
575 print OUT " TEST_TYPE_SIZE(field_type, field_size); \\\n";
576 print OUT " TEST_FIELD_ALIGNMENT(type, field_name, field_align); \\\n";
577 print OUT " TEST_FIELD_OFFSET(type, field_name, field_offset); \\\n";
579 print OUT "#define TEST_TYPE(type, size, align) \\\n";
580 print OUT " TEST_TYPE_ALIGNMENT(type, align); \\\n";
581 print OUT " TEST_TYPE_SIZE(type, size)\n";
583 print OUT "#define TEST_TYPE_POINTER(type, size, align) \\\n";
584 print OUT " TEST__TYPE_ALIGNMENT(*(type)0, align); \\\n";
585 print OUT " TEST_TYPE_SIZE(*(type)0, size)\n";
587 print OUT "#define TEST_TYPE_SIGNED(type) \\\n";
588 print OUT " ok((type) -1 < 0, \"(\" #type \") -1 < 0\\n\");\n";
590 print OUT "#define TEST_TYPE_UNSIGNED(type) \\\n";
591 print OUT " ok((type) -1 > 0, \"(\" #type \") -1 > 0\\n\");\n";
595 ########################################################################
598 sub output_footer($$$) {
601 my $test_dir = shift;
602 my @tests = @{(shift)};
604 print OUT "START_TEST(generated)\n";
606 foreach my $test (@tests) {
607 print OUT " test_$test();\n";
612 ########################################################################
613 # output_test_pack_type
615 sub output_test_pack_type($$$$$$) {
618 my $type_name2type = shift;
619 my $type_name2optional = shift;
620 my $type_name2optional_fields = shift;
621 my $type_name = shift;
624 my $optional_fields = $$type_name2optional_fields{$type_name};
626 my $type_align = $type->align;
627 my $type_pack = $type->pack;
628 my $type_size = $type->size;
629 my $type_kind = $type->kind;
631 if (defined($type_pack)) {
632 print OUT " /* $type_name (pack $type_pack) */\n";
634 print OUT " /* $type_name */\n";
637 if (!scalar(keys(%$optional_fields)) && defined($type_align) && defined($type_size)) {
638 print OUT " TEST_TYPE($type_name, $type_size, $type_align);\n";
641 if ($type_kind eq "float") {
643 } elsif ($type_kind eq "pointer") {
644 my $dereference_type;
645 $dereference_type = sub {
648 my @fields = $type->fields;
649 my $type_name2 =$fields[0]->type_name;
651 if ($type_name2 =~ s/\s*\*$//) {
652 my $type2 = $$type_name2type{$type_name2};
653 if (defined($type2)) {
656 if ($type_name2 !~ /^(?:PVOID|VOID|void)$/) {
657 $output->write("$type_name2: warning: type not found 1\n");
661 } elsif ($type_name2 =~ /^\w+$/) {
662 my $type2 = $$type_name2type{$type_name2};
663 if (defined($type2)) {
664 return &$dereference_type($type2);
666 $output->write("$type_name2: warning: type not found\n");
669 } elsif ($type_name2 =~ /^\w+\s*\((?:\s*CALLBACK|\s*NTAPI|\s*WINAPI)?\s*\*\s*\)\s*\(.*?\)$/) {
672 $output->write("$type_name2: warning: type can't be parsed\n");
677 my $type2 = &$dereference_type($type);
678 if (defined($type2)) {
679 my $type_name2 = $type2->name;
680 my $type_align2 = $type2->align;
681 my $type_size2 = $type2->size;
683 my $optional = $$type_name2optional{$type_name};
684 my $optional_fields2 = $$type_name2optional_fields{$type_name2};
686 if (!$optional && !scalar(keys(%$optional_fields2)) && defined($type_align2) && defined($type_size2)) {
687 print OUT " TEST_TYPE_POINTER($type_name, $type_size2, $type_align2);\n";
689 # $output->write("$type_name: warning: type size not found\n");
692 } elsif ($type_kind eq "signed") {
693 print OUT " TEST_TYPE_SIGNED($type_name);\n";
694 } elsif ($type_kind eq "unsigned") {
695 print OUT " TEST_TYPE_UNSIGNED($type_name);\n";
699 sub output_test_pack_fields($$$$$$$);
700 sub output_test_pack_fields($$$$$$$) {
703 my $type_name2type = shift;
704 my $type_name2optional = shift;
705 my $type_name2optional_fields = shift;
706 my $type_name = shift;
710 my $optional_fields = $$type_name2optional_fields{$type_name};
712 foreach my $field ($type->fields()) {
713 my $field_type_name = $field->type_name;
714 $field_type_name =~ s/\s+DECLSPEC_ALIGN\(\d+\)//;
715 my $field_name = $field->name;
716 my $field_size = $field->size;
717 my $field_offset = $field->offset;
718 my $field_align = $field->align;
720 next if $field_name eq "" || (defined($field_size) && $field_size < 0);
721 # We cannot take the address of a bitfield with MSVC
722 next if ($field_type_name =~ /:/);
724 if ($$optional_fields{$field_name}) {
726 } elsif (defined($field_size) && defined($field_offset)) {
727 $field_offset += $offset;
728 if ($field_name eq "DUMMYSTRUCTNAME") {
729 print OUT "#ifdef NONAMELESSSTRUCT\n";
730 print OUT " TEST_FIELD($type_name, $field_type_name, $field_name, ";
731 print OUT "$field_offset, $field_size, $field_align);\n";
733 output_test_pack_fields(\*OUT, $type_name2type, $type_name2optional, $type_name2optional_fields,
734 $type_name, $$type_name2type{$field_type_name}, $field_offset);
735 print OUT "#endif\n";
737 print OUT " TEST_FIELD($type_name, $field_type_name, $field_name, ";
738 print OUT "$field_offset, $field_size, $field_align);\n";
741 # $output->write("$type_name: $field_type_name: $field_name: test not generated (offset not defined)\n");
746 ########################################################################
749 sub output_test_pack($$$$) {
752 my $test_dir = shift;
755 my $type_names_used = shift;
757 $output->prefix("$test_dir: $test: ");
759 my @headers = $tests->get_section($test_dir, $test, "header");
760 my @type_names = $tests->get_section($test_dir, $test, "type");
762 my %type_name2optional;
763 my %type_name2optional_fields;
765 foreach my $_type_name (@type_names) {
766 my $type_name = $_type_name;
768 if ($type_name =~ s/^!//) {
769 $type_name2optional{$type_name}++;
772 my $optional_fields = {};
773 if ($type_name =~ s/:\s*(.*?)$//) {
774 my @fields = split /\s+/, $1;
775 foreach my $field (@fields) {
776 if ($field =~ s/^!//) {
777 $$optional_fields{$field}++;
782 $type_name2optional_fields{$type_name} = $optional_fields;
785 foreach my $header (@headers) {
786 my $type_name2type = $file2types{"include/$header"};
788 foreach my $_type_name (@type_names) {
789 my $type_name = $_type_name;
791 my $skip = ($type_name =~ s/^!//);
792 $type_name =~ s/:.*?$//;
793 my $type = $$type_name2type{$type_name};
794 if (!defined($type)) {
797 $$type_names_used{$type_name} = $skip ? -1 : 1;
800 print OUT "static void test_${test}_$type_name(void)\n";
802 output_test_pack_type(\*OUT, $type_name2type, \%type_name2optional, \%type_name2optional_fields,
804 output_test_pack_fields(\*OUT, $type_name2type, \%type_name2optional, \%type_name2optional_fields,
805 $type_name, $type, 0);
813 ########################################################################
816 sub output_file($$$$) {
819 my $test_dir = shift;
820 my @tests = @{(shift)};
822 my $type_names_used = shift;
824 output_header(\*OUT, $test_dir, \@tests);
826 foreach my $test (@tests) {
827 my %type_names_used2;
829 if ($test eq "pack") {
830 output_test_pack(\*OUT, $test_dir, $test, \%type_names_used2);
832 die "no such test ($test)\n";
835 print OUT "static void test_$test(void)\n";
837 foreach my $type_name (sort(keys(%type_names_used2))) {
838 $$type_names_used{$type_name} = $type_names_used2{$type_name};
839 if ($type_names_used2{$type_name} > 0) {
840 print OUT " test_${test}_$type_name();\n";
847 output_footer(\*OUT, $test_dir, \@tests);
852 ########################################################################
855 my %type_names_used = ();
857 my @test_dirs = $tests->get_test_dirs();
858 foreach my $test_dir (@test_dirs) {
859 my $file = "$wine_dir/$test_dir/generated.c";
860 replace_file($file, \&output_file, $test_dir, \@tests, \%type_names_used);
863 foreach my $header (sort(keys(%file2types))) {
864 $output->prefix("$header: ");
865 $header =~ s%^include/%%;
866 my $type_name2type = $file2types{"include/$header"};
867 foreach my $_type_name (sort(keys(%$type_name2type))) {
868 my $type_name = $_type_name;
870 if (!exists($type_names_used{$type_name})) {
871 $output->write("$type_name: type not used\n");
876 $output->prefix("$winapi_dir/tests.dat: ");
877 foreach my $type_name (sort(keys(%type_names_used))) {
879 foreach my $header (sort(keys(%file2types))) {
880 my $type_name2type = $file2types{"include/$header"};
881 if (exists($type_name2type{$type_name})) {
887 $output->write("$type_name: type not used\n");