7 $standard = "XOPEN2K8";
10 GetOptions
('headers=s' => \
@headers, 'standard=s' => \
$standard,
11 'flags=s' => \
$flags, 'cc=s' => \
$CC, 'tmpdir=s' => \
$tmpdir);
12 @headers = split(/,/,join(',',@headers));
14 # List of the headers we are testing.
16 @headers = ("wordexp.h", "wctype.h", "wchar.h", "varargs.h", "utmpx.h",
17 "utime.h", "unistd.h", "ulimit.h", "ucontext.h", "uchar.h",
18 "time.h", "tgmath.h", "termios.h", "tar.h", "sys/wait.h",
19 "sys/utsname.h", "sys/un.h", "sys/uio.h", "sys/types.h",
20 "sys/times.h", "sys/timeb.h", "sys/time.h", "sys/statvfs.h",
21 "sys/stat.h", "sys/socket.h", "sys/shm.h", "sys/sem.h",
22 "sys/select.h", "sys/resource.h", "sys/msg.h", "sys/mman.h",
23 "sys/ipc.h", "syslog.h", "stropts.h", "strings.h", "string.h",
24 "stdnoreturn.h", "stdlib.h", "stdio.h", "stdint.h", "stddef.h",
25 "stdbool.h", "stdarg.h", "stdalign.h", "spawn.h", "signal.h",
26 "setjmp.h", "semaphore.h", "search.h", "sched.h", "regex.h",
27 "pwd.h", "pthread.h", "poll.h", "nl_types.h", "netinet/tcp.h",
28 "netinet/in.h", "net/if.h", "netdb.h", "ndbm.h", "mqueue.h",
29 "monetary.h", "math.h", "locale.h", "libgen.h", "limits.h",
30 "langinfo.h", "iso646.h", "inttypes.h", "iconv.h", "grp.h",
31 "glob.h", "ftw.h", "fnmatch.h", "fmtmsg.h", "float.h", "fenv.h",
32 "fcntl.h", "errno.h", "dlfcn.h", "dirent.h", "ctype.h", "cpio.h",
33 "complex.h", "assert.h", "arpa/inet.h", "aio.h");
36 $CFLAGS_namespace = "$flags -fno-builtin $CFLAGS{$standard} -D_ISOMAC";
37 $CFLAGS = "$CFLAGS_namespace '-D__attribute__(x)='";
39 # Check standard name for validity.
40 die "unknown standard \"$standard\"" if ($CFLAGS{$standard} eq "");
42 # if ($standard ne "XOPEN2K8" && $standard ne "POSIX2008") {
43 # # Some headers need a bit more attention. At least with XPG7
44 # # all headers should be self-contained.
45 # $mustprepend{'inttypes.h'} = "#include <stddef.h>\n";
46 # $mustprepend{'glob.h'} = "#include <sys/types.h>\n";
47 # $mustprepend{'grp.h'} = "#include <sys/types.h>\n";
48 # $mustprepend{'regex.h'} = "#include <sys/types.h>\n";
49 # $mustprepend{'pwd.h'} = "#include <sys/types.h>\n";
50 # $mustprepend{'sched.h'} = "#include <sys/types.h>\n";
51 # $mustprepend{'signal.h'} = "#include <pthread.h>\n#include <sys/types.h>\n";
52 # $mustprepend{'stdio.h'} = "#include <sys/types.h>\n";
53 # $mustprepend{'sys/stat.h'} = "#include <sys/types.h>\n";
54 # $mustprepend{'wchar.h'} = "#include <stdarg.h>\n";
55 # $mustprepend{'wordexp.h'} = "#include <stddef.h>\n";
58 # These are the ISO C90 keywords.
59 @keywords = ('auto', 'break', 'case', 'char', 'const', 'continue', 'default',
60 'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto',
61 'if', 'int', 'long', 'register', 'return',
62 'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
63 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while');
64 if ($CFLAGS{$standard} =~ /-std=(c99|c1x)/) {
65 push (@keywords, 'inline', 'restrict');
68 # Make a hash table from this information.
69 while ($#keywords >= 0) {
70 $iskeyword{pop (@keywords)} = 1;
84 printf ("Ignoring this failure.\n");
92 my($pattern, $string) = @_;
93 my($strlen) = length ($string);
96 if (substr ($pattern, 0, 1) eq '*') {
97 my($patlen) = length ($pattern) - 1;
98 $res = ($strlen >= $patlen
99 && substr ($pattern, -$patlen, $patlen) eq substr ($string, -$patlen, $patlen));
100 } elsif (substr ($pattern, -1, 1) eq '*') {
101 if (substr ($pattern, -2, 1) eq ']') {
102 my($patlen) = index ($pattern, '[');
103 my($range) = substr ($pattern, $patlen + 1, -2);
104 $res = ($strlen > $patlen
105 && substr ($pattern, 0, $patlen) eq substr ($string, 0, $patlen)
106 && index ($range, substr ($string, $patlen, 1)) != -1);
108 my($patlen) = length ($pattern) - 1;
109 $res = ($strlen >= $patlen
110 && substr ($pattern, 0, $patlen) eq substr ($string, 0, $patlen));
113 $res = $pattern eq $string;
121 my($fnamebase, $msg, $errmsg, $skip, $optional, $xfail) = @_;
132 $ret = system "$CC $CFLAGS -c $fnamebase.c -o $fnamebase.o > $fnamebase.out 2>&1";
134 if ($optional != 0) {
135 printf (" $errmsg\n");
140 printf (" $errmsg Compiler message:\n");
148 if ($verbose > 1 && -s
"$fnamebase.out") {
149 # We print all warnings issued.
153 if ($printlog != 0) {
154 printf (" " . "-" x
71 . "\n");
155 open (MESSAGE
, "< $fnamebase.out");
160 printf (" " . "-" x
71 . "\n");
163 unlink "$fnamebase.c";
164 unlink "$fnamebase.o";
165 unlink "$fnamebase.out";
173 my($fnamebase, $msg, $errmsg, $skip, $xfail) = @_;
184 $ret = system "$CC $CFLAGS -o $fnamebase $fnamebase.c > $fnamebase.out 2>&1";
188 printf (" $errmsg Compiler message:\n");
194 # Now run the program. If the exit code is not zero something is wrong.
195 $result = system "$fnamebase > $fnamebase.out2 2>&1";
198 if ($verbose > 1 && -s
"$fnamebase.out") {
199 # We print all warnings issued.
201 system "cat $fnamebase.out2 >> $fnamebase.out";
207 unlink "$fnamebase.out";
208 rename "$fnamebase.out2", "$fnamebase.out";
211 if ($printlog != 0) {
212 printf (" " . "-" x
71 . "\n");
213 open (MESSAGE
, "< $fnamebase.out");
218 printf (" " . "-" x
71 . "\n");
222 unlink "$fnamebase.c";
223 unlink "$fnamebase.o";
224 unlink "$fnamebase.out";
225 unlink "$fnamebase.out2";
232 my($token, @allow) = @_;
235 return if ($token =~ /^[0-9_]/ || $iskeyword{$token});
237 for ($idx = 0; $idx <= $#allow; ++$idx) {
238 return if (poorfnmatch
($allow[$idx], $token));
249 return if ($token =~ /^[0-9_]/ || $iskeyword{$token});
251 if (exists $errors{$token}) {
252 undef $errors{$token};
258 my($h, $fnamebase, @allow) = @_;
262 # Generate a program to get the contents of this header.
263 open (TESTFILE
, ">$fnamebase.c");
264 print TESTFILE
"#include <$h>\n";
268 open (CONTENT
, "$CC $CFLAGS_namespace -E $fnamebase.c -P -Wp,-dN | sed -e '/^# [1-9]/d' -e '/^[[:space:]]*\$/d' |");
269 loop: while (<CONTENT
>) {
271 if (/^#define (.*)/) {
272 newtoken
($1, @allow);
273 } elsif (/^#undef (.*)/) {
276 # We have to tokenize the line.
279 my($len) = length ($str);
281 foreach $token (split(/[^a-zA-Z0-9_]/, $str)) {
283 newtoken
($token, @allow);
289 unlink "$fnamebase.c";
292 # Sort the output list so it's easier to compare results with diff.
293 foreach $f (sort keys(%errors)) {
294 if ($errors{$f} == 1) {
295 if ($realerror == 0) {
296 printf ("FAIL\n " . "-" x
72 . "\n");
300 printf (" Namespace violation: \"%s\"\n", $f);
303 printf (" " . "-" x
72 . "\n") if ($realerror != 0);
306 if ($realerror == 0) {
312 while ($#headers >= 0) {
313 my($h) = pop (@headers);
316 my($fnamebase) = "$tmpdir/$hf-test";
319 my(@allowheader) = ();
320 my(%seenheader) = ();
321 my($prepend) = $mustprepend{$h};
324 printf ("Testing <$h>\n");
325 printf ("----------" . "-" x
length ($h) . "\n");
327 open (CONTROL
, "$CC -E -D$standard -std=c99 -x c data/$h-data |");
328 control
: while (<CONTROL
>) {
330 next control
if (/^#/);
331 next control
if (/^[ ]*$/);
335 # Generate a program to test for the availability of this header.
336 open (TESTFILE
, ">$fnamebase.c");
337 print TESTFILE
"$prepend";
338 print TESTFILE
"#include <$h>\n";
341 $missing = compiletest
($fnamebase, "Checking whether <$h> is available",
342 "Header <$h> not available", 0, 0, 0);
344 last control
if ($missing);
357 if (/^element *({([^}]*)}|([^{ ]*)) *({([^}]*)}|([^{ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
358 my($struct) = "$2$3";
364 # Remember that this name is allowed.
365 push @allow, $member;
367 # Generate a program to test for the availability of this member.
368 open (TESTFILE
, ">$fnamebase.c");
369 print TESTFILE
"$prepend";
370 print TESTFILE
"#include <$h>\n";
371 print TESTFILE
"$struct a;\n";
372 print TESTFILE
"$struct b;\n";
373 print TESTFILE
"extern void xyzzy (__typeof__ (&b.$member), __typeof__ (&a.$member), unsigned);\n";
374 print TESTFILE
"void foobarbaz (void) {\n";
375 print TESTFILE
" xyzzy (&a.$member, &b.$member, sizeof (a.$member));\n";
376 print TESTFILE
"}\n";
379 $res = compiletest
($fnamebase, "Testing for member $member",
382 : "Member \"$member\" not available."), $res,
385 if ($res == 0 || $missing != 0 || !$optional) {
386 # Test the types of the members.
387 open (TESTFILE
, ">$fnamebase.c");
388 print TESTFILE
"$prepend";
389 print TESTFILE
"#include <$h>\n";
390 print TESTFILE
"$struct a;\n";
391 print TESTFILE
"extern $type b$rest;\n";
392 print TESTFILE
"extern __typeof__ (a.$member) b;\n";
395 compiletest
($fnamebase, "Testing for type of member $member",
396 "Member \"$member\" does not have the correct type.",
399 } elsif (/^(macro|constant|macro-constant|macro-int-constant) +([a-zA-Z0-9_]*) *(?:{([^}]*)} *)?(?:([>=<!]+) ([A-Za-z0-9_\\'-]*))?/) {
400 my($symbol_type) = $1;
406 my($mres) = $missing;
407 my($cres) = $missing;
409 # Remember that this name is allowed.
410 push @allow, $symbol;
412 if ($symbol_type =~ /macro/) {
413 # Generate a program to test for availability of this macro.
414 open (TESTFILE
, ">$fnamebase.c");
415 print TESTFILE
"$prepend";
416 print TESTFILE
"#include <$h>\n";
417 print TESTFILE
"#ifndef $symbol\n";
418 print TESTFILE
"# error \"Macro $symbol not defined\"\n";
419 print TESTFILE
"#endif\n";
422 $mres = compiletest
($fnamebase, "Test availability of macro $symbol",
425 : "Macro \"$symbol\" is not available."), $res,
429 if ($symbol_type =~ /constant/) {
430 # Generate a program to test for the availability of this constant.
431 open (TESTFILE
, ">$fnamebase.c");
432 print TESTFILE
"$prepend";
433 print TESTFILE
"#include <$h>\n";
434 print TESTFILE
"__typeof__ ($symbol) a = $symbol;\n";
437 $cres = compiletest
($fnamebase, "Testing for constant $symbol",
440 : "Constant \"$symbol\" not available."), $res,
444 $res = $res || $mres || $cres;
446 if ($symbol_type eq "macro-int-constant" && ($res == 0 || !$optional)) {
447 # Test that the symbol is usable in #if.
448 open (TESTFILE
, ">$fnamebase.c");
449 print TESTFILE
"$prepend";
450 print TESTFILE
"#include <$h>\n";
451 print TESTFILE
"#if $symbol < 0\n";
452 print TESTFILE
"# define conformtest_negative 1\n";
454 for (my $i = 0; $i < 63; $i++) {
455 print TESTFILE
"# if $symbol & (1LL << $i)\n";
456 print TESTFILE
"# define conformtest_bit_$i 0LL\n";
457 print TESTFILE
"# else\n";
458 print TESTFILE
"# define conformtest_bit_$i (1LL << $i)\n";
459 print TESTFILE
"# endif\n";
460 $s .= "|conformtest_bit_$i";
462 print TESTFILE
"# define conformtest_value ~($s)\n";
463 print TESTFILE
"#else\n";
464 print TESTFILE
"# define conformtest_negative 0\n";
466 for (my $i = 0; $i < 64; $i++) {
467 print TESTFILE
"# if $symbol & (1ULL << $i)\n";
468 print TESTFILE
"# define conformtest_bit_$i (1ULL << $i)\n";
469 print TESTFILE
"# else\n";
470 print TESTFILE
"# define conformtest_bit_$i 0ULL\n";
471 print TESTFILE
"# endif\n";
472 $s .= "|conformtest_bit_$i";
474 print TESTFILE
"# define conformtest_value ($s)\n";
475 print TESTFILE
"#endif\n";
476 print TESTFILE
"int main (void) { return !((($symbol < 0) == conformtest_negative) && ($symbol == conformtest_value)); }\n";
479 runtest
($fnamebase, "Testing for #if usability of symbol $symbol",
480 "Symbol \"$symbol\" not usable in #if.", $res, $xfail);
483 if (defined ($type) && ($res == 0 || !$optional)) {
484 # Test the type of the symbol.
485 open (TESTFILE
, ">$fnamebase.c");
486 print TESTFILE
"$prepend";
487 print TESTFILE
"#include <$h>\n";
488 if ($type =~ /^promoted:/) {
489 $type =~ s/^promoted://;
490 print TESTFILE
"__typeof__ (($type) 0 + ($type) 0) a;\n";
492 print TESTFILE
"__typeof__ (($type) 0) a;\n";
494 print TESTFILE
"extern __typeof__ ($symbol) a;\n";
497 compiletest
($fnamebase, "Testing for type of symbol $symbol",
498 "Symbol \"$symbol\" does not have the correct type.",
502 if (defined ($op) && ($res == 0 || !$optional)) {
503 # Generate a program to test for the value of this symbol.
504 open (TESTFILE
, ">$fnamebase.c");
505 print TESTFILE
"$prepend";
506 print TESTFILE
"#include <$h>\n";
507 # Negate the value since 0 means ok
508 print TESTFILE
"int main (void) { return !($symbol $op $value); }\n";
511 $res = runtest
($fnamebase, "Testing for value of symbol $symbol",
512 "Symbol \"$symbol\" has not the right value.", $res,
515 } elsif (/^symbol *([a-zA-Z0-9_]*) *([A-Za-z0-9_-]*)?/) {
520 # Remember that this name is allowed.
521 push @allow, $symbol;
523 # Generate a program to test for the availability of this constant.
524 open (TESTFILE
, ">$fnamebase.c");
525 print TESTFILE
"$prepend";
526 print TESTFILE
"#include <$h>\n";
527 print TESTFILE
"void foobarbaz (void) {\n";
528 print TESTFILE
"__typeof__ ($symbol) a = $symbol;\n";
529 print TESTFILE
"}\n";
532 $res = compiletest
($fnamebase, "Testing for symbol $symbol",
533 "Symbol \"$symbol\" not available.", $res, 0, $xfail);
536 # Generate a program to test for the value of this constant.
537 open (TESTFILE
, ">$fnamebase.c");
538 print TESTFILE
"$prepend";
539 print TESTFILE
"#include <$h>\n";
540 print TESTFILE
"int main (void) { return $symbol != $value; }\n";
543 $res = runtest
($fnamebase, "Testing for value of symbol $symbol",
544 "Symbol \"$symbol\" has not the right value.", $res,
547 } elsif (/^type *({([^}]*)|([a-zA-Z0-9_]*))/) {
549 my($maybe_opaque) = 0;
551 # Remember that this name is allowed.
552 if ($type =~ /^struct *(.*)/) {
554 } elsif ($type =~ /^union *(.*)/) {
561 # Generate a program to test for the availability of this type.
562 open (TESTFILE
, ">$fnamebase.c");
563 print TESTFILE
"$prepend";
564 print TESTFILE
"#include <$h>\n";
565 if ($maybe_opaque == 1) {
566 print TESTFILE
"$type *a;\n";
568 print TESTFILE
"$type a;\n";
572 compiletest
($fnamebase, "Testing for type $type",
575 : "Type \"$type\" not available."), $missing, $optional,
577 } elsif (/^tag *({([^}]*)|([a-zA-Z0-9_]*))/) {
580 # Remember that this name is allowed.
581 if ($type =~ /^struct *(.*)/) {
583 } elsif ($type =~ /^union *(.*)/) {
589 # Generate a program to test for the availability of this type.
590 open (TESTFILE
, ">$fnamebase.c");
591 print TESTFILE
"$prepend";
592 print TESTFILE
"#include <$h>\n";
593 print TESTFILE
"$type;\n";
596 compiletest
($fnamebase, "Testing for type $type",
597 "Type \"$type\" not available.", $missing, 0, $xfail);
598 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
599 my($rettype) = "$2$3";
604 # Remember that this name is allowed.
607 # Generate a program to test for availability of this function.
608 open (TESTFILE
, ">$fnamebase.c");
609 print TESTFILE
"$prepend";
610 print TESTFILE
"#include <$h>\n";
611 # print TESTFILE "#undef $fname\n";
612 print TESTFILE
"$rettype (*(*foobarbaz) $args = $fname;\n";
615 $res = compiletest
($fnamebase, "Test availability of function $fname",
618 : "Function \"$fname\" is not available."), $res,
621 if ($res == 0 || $missing == 1 || !$optional) {
622 # Generate a program to test for the type of this function.
623 open (TESTFILE
, ">$fnamebase.c");
624 print TESTFILE
"$prepend";
625 print TESTFILE
"#include <$h>\n";
626 # print TESTFILE "#undef $fname\n";
627 print TESTFILE
"extern $rettype (*(*foobarbaz) $args;\n";
628 print TESTFILE
"extern __typeof__ (&$fname) foobarbaz;\n";
631 compiletest
($fnamebase, "Test for type of function $fname",
632 "Function \"$fname\" has incorrect type.", $res, 0,
635 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
636 my($rettype) = "$2$3";
641 # Remember that this name is allowed.
644 # Generate a program to test for availability of this function.
645 open (TESTFILE
, ">$fnamebase.c");
646 print TESTFILE
"$prepend";
647 print TESTFILE
"#include <$h>\n";
648 # print TESTFILE "#undef $fname\n";
649 print TESTFILE
"$rettype (*foobarbaz) $args = $fname;\n";
652 $res = compiletest
($fnamebase, "Test availability of function $fname",
655 : "Function \"$fname\" is not available."), $res,
658 if ($res == 0 || $missing != 0 || !$optional) {
659 # Generate a program to test for the type of this function.
660 open (TESTFILE
, ">$fnamebase.c");
661 print TESTFILE
"$prepend";
662 print TESTFILE
"#include <$h>\n";
663 # print TESTFILE "#undef $fname\n";
664 print TESTFILE
"extern $rettype (*foobarbaz) $args;\n";
665 print TESTFILE
"extern __typeof__ (&$fname) foobarbaz;\n";
668 compiletest
($fnamebase, "Test for type of function $fname",
669 "Function \"$fname\" has incorrect type.", $res, 0,
672 } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) *(.*)/) {
678 # Remember that this name is allowed.
681 # Generate a program to test for availability of this function.
682 open (TESTFILE
, ">$fnamebase.c");
683 print TESTFILE
"$prepend";
684 print TESTFILE
"#include <$h>\n";
685 # print TESTFILE "#undef $fname\n";
686 print TESTFILE
"typedef $type xyzzy$rest;\n";
687 print TESTFILE
"$xyzzy *foobarbaz = &$vname;\n";
690 $res = compiletest
($fnamebase, "Test availability of variable $vname",
691 "Variable \"$vname\" is not available.", $res, 0,
694 # Generate a program to test for the type of this function.
695 open (TESTFILE
, ">$fnamebase.c");
696 print TESTFILE
"$prepend";
697 print TESTFILE
"#include <$h>\n";
698 # print TESTFILE "#undef $fname\n";
699 print TESTFILE
"extern $type $vname$rest;\n";
702 compiletest
($fnamebase, "Test for type of variable $fname",
703 "Variable \"$vname\" has incorrect type.", $res, 0, $xfail);
704 } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
705 my($rettype) = "$2$3";
710 # Remember that this name is allowed.
713 # Generate a program to test for availability of this function.
714 open (TESTFILE
, ">$fnamebase.c");
715 print TESTFILE
"$prepend";
716 print TESTFILE
"#include <$h>\n";
717 print TESTFILE
"#ifndef $fname\n";
718 print TESTFILE
"$rettype (*foobarbaz) $args = $fname;\n";
719 print TESTFILE
"#endif\n";
722 $res = compiletest
($fnamebase, "Test availability of macro $fname",
723 "Function \"$fname\" is not available.", $res, 0,
726 # Generate a program to test for the type of this function.
727 open (TESTFILE
, ">$fnamebase.c");
728 print TESTFILE
"$prepend";
729 print TESTFILE
"#include <$h>\n";
730 print TESTFILE
"#ifndef $fname\n";
731 print TESTFILE
"extern $rettype (*foobarbaz) $args;\n";
732 print TESTFILE
"extern __typeof__ (&$fname) foobarbaz;\n";
733 print TESTFILE
"#endif\n";
736 compiletest
($fnamebase, "Test for type of macro $fname",
737 "Function \"$fname\" has incorrect type.", $res, 0, $xfail);
738 } elsif (/^macro-str *([^ ]*) *(\".*\")/) {
739 # The above regex doesn't handle a \" in a string.
744 # Remember that this name is allowed.
747 # Generate a program to test for availability of this macro.
748 open (TESTFILE
, ">$fnamebase.c");
749 print TESTFILE
"$prepend";
750 print TESTFILE
"#include <$h>\n";
751 print TESTFILE
"#ifndef $macro\n";
752 print TESTFILE
"# error \"Macro $macro not defined\"\n";
753 print TESTFILE
"#endif\n";
756 compiletest
($fnamebase, "Test availability of macro $macro",
757 "Macro \"$macro\" is not available.", $missing, 0, $xfail);
759 # Generate a program to test for the value of this macro.
760 open (TESTFILE
, ">$fnamebase.c");
761 print TESTFILE
"$prepend";
762 print TESTFILE
"#include <$h>\n";
763 # We can't include <string.h> here.
764 print TESTFILE
"extern int (strcmp)(const char *, const char *);\n";
765 print TESTFILE
"int main (void) { return (strcmp) ($macro, $string) != 0;}\n";
768 $res = runtest
($fnamebase, "Testing for value of macro $macro",
769 "Macro \"$macro\" has not the right value.", $res,
771 } elsif (/^allow-header *(.*)/) {
773 if ($seenheader{$pattern} != 1) {
774 push @allowheader, $pattern;
775 $seenheader{$pattern} = 1;
778 } elsif (/^allow *(.*)/) {
780 push @allow, $pattern;
783 # printf ("line is `%s'\n", $_);
791 # Read the data files for the header files which are allowed to be included.
792 while ($#allowheader >= 0) {
793 my($ah) = pop @allowheader;
795 open (ALLOW
, "$CC -E -D$standard -x c data/$ah-data |");
796 acontrol
: while (<ALLOW
>) {
798 next acontrol
if (/^#/);
799 next acontrol
if (/^[ ]*$/);
803 if (/^element *({([^}]*)}|([^ ]*)) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
805 } elsif (/^(macro|constant|macro-constant|macro-int-constant) +([a-zA-Z0-9_]*) *(?:{([^}]*)} *)?(?:([>=<!]+) ([A-Za-z0-9_-]*))?/) {
807 } elsif (/^(type|tag) *({([^}]*)|([a-zA-Z0-9_]*))/) {
810 # Remember that this name is allowed.
811 if ($type =~ /^struct *(.*)/) {
813 } elsif ($type =~ /^union *(.*)/) {
818 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
820 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
822 } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*)/) {
824 } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
826 } elsif (/^symbol *([a-zA-Z0-9_]*) *([A-Za-z0-9_-]*)?/) {
828 } elsif (/^allow-header *(.*)/) {
829 if ($seenheader{$1} != 1) {
830 push @allowheader, $1;
833 } elsif (/^allow *(.*)/) {
841 printf (" Not defined\n");
843 # Now check the namespace.
844 printf (" Checking the namespace of \"%s\"... ", $h);
849 checknamespace
($h, $fnamebase, @allow);
856 printf "-" x
76 . "\n";
857 printf (" Total number of tests : %4d\n", $total);
859 printf (" Number of failed tests : %4d (", $errors);
860 $percent = ($errors * 100) / $total;
861 if ($errors > 0 && $percent < 1.0) {
864 printf ("%3d%%)\n", $percent);
867 printf (" Number of xfailed tests : %4d (", $xerrors);
868 $percent = ($xerrors * 100) / $total;
869 if ($xerrors > 0 && $percent < 1.0) {
872 printf ("%3d%%)\n", $percent);
875 printf (" Number of skipped tests : %4d (", $skipped);
876 $percent = ($skipped * 100) / $total;
877 if ($skipped > 0 && $percent < 1.0) {
880 printf ("%3d%%)\n", $percent);
885 # perl-indent-level: 2