]> git.ipfire.org Git - thirdparty/glibc.git/blame - conform/conformtest.pl
projects / thirdparty / glibc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove NOTES.
[thirdparty/glibc.git] / conform / conformtest.pl
CommitLineData
da1067a9
UD		 1#! /usr/bin/perl
2
ad4f2ebf 3use Getopt::Long;
f095bb72 4use POSIX;
ad4f2ebf 5
da1067a9 6$CC = "gcc";
ad4f2ebf 7
31341567
UD		 8$standard="XOPEN2K8";
9GetOptions ('headers=s' => \@headers, 'standard=s' => \$standard,
10 'flags=s' => \$flags, 'cc=s' => \$CC);
ad4f2ebf 11@headers = split(/,/,join(',',@headers));
da1067a9
UD		 12
13# List of the headers we are testing.
ad4f2ebf
UD		 14if (@headers == ()) {
15 @headers = ("wordexp.h", "wctype.h", "wchar.h", "varargs.h", "utmpx.h",
31341567
UD		 16 "utime.h", "unistd.h", "ulimit.h", "ucontext.h", "uchar.h",
17 "time.h", "tgmath.h", "termios.h", "tar.h", "sys/wait.h",
18 "sys/utsname.h", "sys/un.h", "sys/uio.h", "sys/types.h",
19 "sys/times.h", "sys/timeb.h", "sys/time.h", "sys/statvfs.h",
20 "sys/stat.h", "sys/socket.h", "sys/shm.h", "sys/sem.h",
21 "sys/select.h", "sys/resource.h", "sys/msg.h", "sys/mman.h",
22 "sys/ipc.h", "syslog.h", "stropts.h", "strings.h", "string.h",
23 "stdlib.h", "stdio.h", "stdint.h", "stddef.h", "stdarg.h",
24 "spawn.h", "signal.h", "setjmp.h", "semaphore.h", "search.h",
25 "sched.h", "regex.h", "pwd.h", "pthread.h", "poll.h",
26 "nl_types.h", "netinet/tcp.h", "netinet/in.h", "net/if.h",
27 "netdb.h", "ndbm.h", "mqueue.h", "monetary.h", "math.h",
28 "locale.h", "libgen.h", "limits.h", "langinfo.h", "iso646.h",
29 "inttypes.h", "iconv.h", "grp.h", "glob.h", "ftw.h", "fnmatch.h",
30 "fmtmsg.h", "float.h", "fcntl.h", "errno.h", "dlfcn.h",
31 "dirent.h", "ctype.h", "cpio.h", "complex.h", "assert.h",
32 "arpa/inet.h", "aio.h");
ad4f2ebf
UD		 33}
34
31341567
UD		 35$CFLAGS{"ISO"} = "-ansi";
36$CFLAGS{"ISO99"} = "-std=c99";
37$CFLAGS{"ISO11"} = "-std=c1x -D_ISOC11_SOURCE";
4efeffc1 38$CFLAGS{"POSIX"} = "-D_POSIX_C_SOURCE=199912 -ansi";
31341567
UD		 39$CFLAGS{"XPG3"} = "-D_XOPEN_SOURCE";
40$CFLAGS{"XPG4"} = "-D_XOPEN_SOURCE_EXTENDED";
41$CFLAGS{"UNIX98"} = "-D_XOPEN_SOURCE=500";
42$CFLAGS{"XOPEN2K"} = "-D_XOPEN_SOURCE=600";
d94a4670
UD		 43$CFLAGS{"XOPEN2K8"} = "-std=c99 -D_XOPEN_SOURCE=700";
44$CFLAGS{"POSIX2008"} = "-std=c99 -D_POSIX_C_SOURCE=200809L";
31341567
UD		 45
46$CFLAGS = "$flags -fno-builtin '-D__attribute__(x)=' $CFLAGS{$standard} -D_ISOMAC";
47
4efeffc1
UD		 48# Check standard name for validity.
49die "unknown standard \"$standard\"" if ($CFLAGS{$standard} eq "");
50
51# if ($standard ne "XOPEN2K8" && $standard ne "POSIX2008") {
52# # Some headers need a bit more attention. At least with XPG7
53# # all headers should be self-contained.
54# $mustprepend{'inttypes.h'} = "#include <stddef.h>\n";
55# $mustprepend{'glob.h'} = "#include <sys/types.h>\n";
56# $mustprepend{'grp.h'} = "#include <sys/types.h>\n";
57# $mustprepend{'regex.h'} = "#include <sys/types.h>\n";
58# $mustprepend{'pwd.h'} = "#include <sys/types.h>\n";
59# $mustprepend{'sched.h'} = "#include <sys/types.h>\n";
60# $mustprepend{'signal.h'} = "#include <pthread.h>\n#include <sys/types.h>\n";
61# $mustprepend{'stdio.h'} = "#include <sys/types.h>\n";
62# $mustprepend{'sys/stat.h'} = "#include <sys/types.h>\n";
63# $mustprepend{'wchar.h'} = "#include <stdarg.h>\n";
64# $mustprepend{'wordexp.h'} = "#include <stddef.h>\n";
65# }
66
67# These are the ISO C99 keywords.
68@keywords = ('auto', 'break', 'case', 'char', 'const', 'continue', 'default',
69 'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto',
70 'if', 'inline', 'int', 'long', 'register', 'restrict', 'return',
71 'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
72 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while');
77faa354 73
7287c36d
UD		 74# Make a hash table from this information.
75while ($#keywords >= 0) {
da1067a9
UD		 76 $iskeyword{pop (@keywords)} = 1;
77}
78
4efeffc1
UD		 79# These are symbols which are known to pollute the namespace.
80@knownproblems = ('unix', 'linux', 'i386');
81
7287c36d
UD		 82# Make a hash table from the known problems.
83while ($#knownproblems >= 0) {
84 $isknown{pop (@knownproblems)} = 1;
85}
86
f095bb72
UD		 87$uid = getuid();
88($pwname,$pwpasswd,$pwuid,$pwgid,
89 $pwquota,$pwcomment,$pwgcos,$pwdir,$pwshell,$pwexpire) = getpwuid($uid);
90$tmpdir = "$pwdir";
da1067a9
UD		 91
92$verbose = 1;
93
94$total = 0;
95$skipped = 0;
96$errors = 0;
97
da1067a9
UD		 98
99sub poorfnmatch {
100 my($pattern, $string) = @_;
101 my($strlen) = length ($string);
102 my($res);
103
104 if (substr ($pattern, 0, 1) eq '*') {
105 my($patlen) = length ($pattern) - 1;
106 $res = ($strlen >= $patlen
107 && substr ($pattern, -$patlen, $patlen) eq substr ($string, -$patlen, $patlen));
108 } elsif (substr ($pattern, -1, 1) eq '*') {
31341567
UD		 109 if (substr ($pattern, -2, 1) eq ']') {
110 my($patlen) = index ($pattern, '[');
111 my($range) = substr ($pattern, $patlen + 1, -2);
112 $res = ($strlen > $patlen
113 && substr ($pattern, 0, $patlen) eq substr ($string, 0, $patlen)
114 && index ($range, substr ($string, $patlen, 1)) != -1);
115 } else {
116 my($patlen) = length ($pattern) - 1;
117 $res = ($strlen >= $patlen
118 && substr ($pattern, 0, $patlen) eq substr ($string, 0, $patlen));
119 }
da1067a9
UD		 120 } else {
121 $res = $pattern eq $string;
122 }
123 return $res;
124}
125
126
127sub compiletest
128{
2eba94b2 129 my($fnamebase, $msg, $errmsg, $skip, $optional) = @_;
da1067a9
UD		 130 my($result) = $skip;
131 my($printlog) = 0;
132
133 ++$total;
134 printf (" $msg...");
135
136 if ($skip != 0) {
137 ++$skipped;
138 printf (" SKIP\n");
139 } else {
31341567 140 $ret = system "$CC $CFLAGS -c $fnamebase.c -o $fnamebase.o > $fnamebase.out 2>&1";
da1067a9 141 if ($ret != 0) {
2eba94b2
UD		 142 if ($optional != 0) {
143 printf (" $errmsg\n");
144 $result = 1;
145 } else {
146 printf (" FAIL\n");
147 if ($verbose != 0) {
148 printf (" $errmsg Compiler message:\n");
149 $printlog = 1;
150 }
151 ++$errors;
152 $result = 1;
da1067a9 153 }
da1067a9
UD		 154 } else {
155 printf (" OK\n");
156 if ($verbose > 1 && -s "$fnamebase.out") {
157 # We print all warnings issued.
158 $printlog = 1;
159 }
160 }
161 if ($printlog != 0) {
162 printf (" " . "-" x 71 . "\n");
163 open (MESSAGE, "< $fnamebase.out");
164 while (<MESSAGE>) {
165 printf (" %s", $_);
166 }
167 close (MESSAGE);
168 printf (" " . "-" x 71 . "\n");
169 }
170 }
171 unlink "$fnamebase.c";
172 unlink "$fnamebase.o";
173 unlink "$fnamebase.out";
174
175 $result;
176}
177
178
179sub runtest
180{
181 my($fnamebase, $msg, $errmsg, $skip) = @_;
182 my($result) = $skip;
183 my($printlog) = 0;
184
185 ++$total;
186 printf (" $msg...");
187
188 if ($skip != 0) {
189 ++$skipped;
190 printf (" SKIP\n");
191 } else {
31341567 192 $ret = system "$CC $CFLAGS -o $fnamebase $fnamebase.c > $fnamebase.out 2>&1";
da1067a9
UD		 193 if ($ret != 0) {
194 printf (" FAIL\n");
195 if ($verbose != 0) {
196 printf (" $errmsg Compiler message:\n");
197 $printlog = 1;
198 }
199 ++$errors;
200 $result = 1;
201 } else {
202 # Now run the program. If the exit code is not zero something is wrong.
203 $result = system "$fnamebase > $fnamebase.out2 2>&1";
204 if ($result == 0) {
205 printf (" OK\n");
206 if ($verbose > 1 && -s "$fnamebase.out") {
207 # We print all warnings issued.
208 $printlog = 1;
209 system "cat $fnamebase.out2 >> $fnamebase.out";
210 }
211 } else {
212 printf (" FAIL\n");
020275b5 213 ++$errors;
da1067a9
UD		 214 $printlog = 1;
215 unlink "$fnamebase.out";
216 rename "$fnamebase.out2", "$fnamebase.out";
217 }
218 }
219 if ($printlog != 0) {
220 printf (" " . "-" x 71 . "\n");
221 open (MESSAGE, "< $fnamebase.out");
222 while (<MESSAGE>) {
223 printf (" %s", $_);
224 }
225 close (MESSAGE);
226 printf (" " . "-" x 71 . "\n");
227 }
228 }
229 unlink "$fnamebase";
230 unlink "$fnamebase.c";
231 unlink "$fnamebase.o";
232 unlink "$fnamebase.out";
233 unlink "$fnamebase.out2";
234
235 $result;
236}
237
238
239sub newtoken {
7287c36d 240 my($token, @allow) = @_;
da1067a9
UD		 241 my($idx);
242
7287c36d 243 return if ($token =~ /^[0-9_]/ || $iskeyword{$token});
8ce9ea0c 244
da1067a9 245 for ($idx = 0; $idx <= $#allow; ++$idx) {
7287c36d 246 return if (poorfnmatch ($allow[$idx], $token));
da1067a9
UD		 247 }
248
31341567 249 unless ($isknown{$token}) {
9c777dfe
UD		 250 $errors{$token} = 1;
251 }
252}
253
254
255sub removetoken {
256 my($token) = @_;
257 my($idx);
258
259 return if ($token =~ /^[0-9_]/ || $iskeyword{$token});
260
261 if (exists $errors{$token}) {
262 undef $errors{$token};
da1067a9 263 }
da1067a9
UD		 264}
265
266
267sub checknamespace {
268 my($h, $fnamebase, @allow) = @_;
da1067a9
UD		 269
270 ++$total;
271
272 # Generate a program to get the contents of this header.
273 open (TESTFILE, ">$fnamebase.c");
274 print TESTFILE "#include <$h>\n";
275 close (TESTFILE);
276
9c777dfe 277 undef %errors;
7287c36d 278 $nknown = 0;
31341567 279 open (CONTENT, "$CC $CFLAGS -E $fnamebase.c -P -Wp,-dN | sed -e '/^# [1-9]/d' -e '/^[[:space:]]*\$/d' |");
19533127 280 loop: while (<CONTENT>) {
da1067a9
UD		 281 chop;
282 if (/^#define (.*)/) {
7287c36d 283 newtoken ($1, @allow);
9c777dfe
UD		 284 } elsif (/^#undef (.*)/) {
285 removetoken ($1);
da1067a9
UD		 286 } else {
287 # We have to tokenize the line.
288 my($str) = $_;
289 my($index) = 0;
290 my($len) = length ($str);
291
292 foreach $token (split(/[^a-zA-Z0-9_]/, $str)) {
293 if ($token ne "") {
7287c36d 294 newtoken ($token, @allow);
da1067a9
UD		 295 }
296 }
297 }
298 }
299 close (CONTENT);
300 unlink "$fnamebase.c";
9c777dfe
UD		 301 $realerror = 0;
302 if ($#errors != 0) {
d9022567
RM		 303 # Sort the output list so it's easier to compare results with diff.
304 foreach $f (sort keys(%errors)) {
9c777dfe
UD		 305 if ($errors{$f} == 1) {
306 if ($realerror == 0) {
307 printf ("FAIL\n " . "-" x 72 . "\n");
308 $realerror = 1;
309 ++$errors;
310 }
311 printf (" Namespace violation: \"%s\"\n", $f);
312 }
313 }
314 printf (" " . "-" x 72 . "\n") if ($realerror != 0);
315 }
316
317 if ($realerror == 0) {
31341567 318 printf ("OK\n");
da1067a9
UD		 319 }
320}
321
322
323while ($#headers >= 0) {
324 my($h) = pop (@headers);
bba09d23
UD		 325 my($hf) = $h;
326 $hf =~ s|/|-|;
327 my($fnamebase) = "$tmpdir/$hf-test";
31341567 328 my($missing) = 1;
da1067a9 329 my(@allow) = ();
0ed99ce4 330 my(@allowheader) = ();
9d48fef0 331 my(%seenheader) = ();
77faa354 332 my($prepend) = $mustprepend{$h};
31341567 333 my($test_exist) = 1;
da1067a9
UD		 334
335 printf ("Testing <$h>\n");
336 printf ("----------" . "-" x length ($h) . "\n");
337
31341567 338 open (CONTROL, "$CC -E -D$standard -x c data/$h-data |");
da1067a9
UD		 339 control: while (<CONTROL>) {
340 chop;
341 next control if (/^#/);
20d49639 342 next control if (/^[ ]*$/);
da1067a9 343
31341567
UD		 344 if ($test_exist) {
345 $test_exist = 0;
346 # Generate a program to test for the availability of this header.
347 open (TESTFILE, ">$fnamebase.c");
348 print TESTFILE "$prepend";
349 print TESTFILE "#include <$h>\n";
350 close (TESTFILE);
351
352 $missing = compiletest ($fnamebase, "Checking whether <$h> is available",
353 "Header <$h> not available", 0, 0);
354 printf ("\n");
355 last control if ($missing);
356 }
357
7287c36d 358 if (/^element *({([^}]*)}|([^{ ]*)) *({([^}]*)}|([^{ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
da1067a9
UD		 359 my($struct) = "$2$3";
360 my($type) = "$5$6";
361 my($member) = "$7";
362 my($rest) = "$8";
363 my($res) = $missing;
364
365 # Remember that this name is allowed.
366 push @allow, $member;
367
368 # Generate a program to test for the availability of this member.
369 open (TESTFILE, ">$fnamebase.c");
77faa354 370 print TESTFILE "$prepend";
da1067a9
UD		 371 print TESTFILE "#include <$h>\n";
372 print TESTFILE "$struct a;\n";
373 print TESTFILE "$struct b;\n";
374 print TESTFILE "extern void xyzzy (__typeof__ (&b.$member), __typeof__ (&a.$member), unsigned);\n";
375 print TESTFILE "void foobarbaz (void) {\n";
376 print TESTFILE " xyzzy (&a.$member, &b.$member, sizeof (a.$member));\n";
377 print TESTFILE "}\n";
378 close (TESTFILE);
379
380 $res = compiletest ($fnamebase, "Testing for member $member",
2eba94b2 381 "Member \"$member\" not available.", $res, 0);
da1067a9
UD		 382
383
384 # Test the types of the members.
385 open (TESTFILE, ">$fnamebase.c");
77faa354 386 print TESTFILE "$prepend";
da1067a9
UD		 387 print TESTFILE "#include <$h>\n";
388 print TESTFILE "$struct a;\n";
389 print TESTFILE "extern $type b$rest;\n";
390 print TESTFILE "extern __typeof__ (a.$member) b;\n";
391 close (TESTFILE);
392
393 compiletest ($fnamebase, "Testing for type of member $member",
da238298
UD		 394 "Member \"$member\" does not have the correct type.",
395 $res, 0);
396 } elsif (/^optional-element *({([^}]*)}|([^{ ]*)) *({([^}]*)}|([^{ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
397 my($struct) = "$2$3";
398 my($type) = "$5$6";
399 my($member) = "$7";
400 my($rest) = "$8";
401 my($res) = $missing;
402
403 # Remember that this name is allowed.
404 push @allow, $member;
405
406 # Generate a program to test for the availability of this member.
407 open (TESTFILE, ">$fnamebase.c");
408 print TESTFILE "$prepend";
409 print TESTFILE "#include <$h>\n";
410 print TESTFILE "$struct a;\n";
411 print TESTFILE "$struct b;\n";
412 print TESTFILE "extern void xyzzy (__typeof__ (&b.$member), __typeof__ (&a.$member), unsigned);\n";
413 print TESTFILE "void foobarbaz (void) {\n";
414 print TESTFILE " xyzzy (&a.$member, &b.$member, sizeof (a.$member));\n";
415 print TESTFILE "}\n";
416 close (TESTFILE);
417
418 $res = compiletest ($fnamebase, "Testing for member $member",
419 "NOT AVAILABLE.", $res, 1);
420
421 if ($res == 0 || $missing != 0) {
422 # Test the types of the members.
423 open (TESTFILE, ">$fnamebase.c");
424 print TESTFILE "$prepend";
425 print TESTFILE "#include <$h>\n";
426 print TESTFILE "$struct a;\n";
427 print TESTFILE "extern $type b$rest;\n";
428 print TESTFILE "extern __typeof__ (a.$member) b;\n";
429 close (TESTFILE);
430
431 compiletest ($fnamebase, "Testing for type of member $member",
432 "Member \"$member\" does not have the correct type.",
433 $res, 0);
434 }
4efeffc1 435 } elsif (/^optional-constant *([a-zA-Z0-9_]*) ([>=<!]+) ([A-Za-z0-9_-]*)/) {
2eba94b2
UD		 436 my($const) = $1;
437 my($op) = $2;
438 my($value) = $3;
439 my($res) = $missing;
440
441 # Remember that this name is allowed.
442 push @allow, $const;
443
444 # Generate a program to test for the availability of this constant.
445 open (TESTFILE, ">$fnamebase.c");
446 print TESTFILE "$prepend";
447 print TESTFILE "#include <$h>\n";
448 print TESTFILE "__typeof__ ($const) a = $const;\n";
449 close (TESTFILE);
450
451 $res = compiletest ($fnamebase, "Testing for constant $const",
452 "NOT PRESENT", $res, 1);
453
12b64309 454 if ($value ne "" && $res == 0) {
2eba94b2
UD		 455 # Generate a program to test for the value of this constant.
456 open (TESTFILE, ">$fnamebase.c");
457 print TESTFILE "$prepend";
458 print TESTFILE "#include <$h>\n";
459 # Negate the value since 0 means ok
460 print TESTFILE "int main (void) { return !($const $op $value); }\n";
461 close (TESTFILE);
462
463 $res = runtest ($fnamebase, "Testing for value of constant $const",
464 "Constant \"$const\" has not the right value.", $res);
465 }
4efeffc1 466 } elsif (/^constant *([a-zA-Z0-9_]*) *([>=<!]+) ([A-Za-z0-9_-]*)/) {
20d49639
AJ		 467 my($const) = $1;
468 my($op) = $2;
469 my($value) = $3;
470 my($res) = $missing;
471
472 # Remember that this name is allowed.
473 push @allow, $const;
474
475 # Generate a program to test for the availability of this constant.
476 open (TESTFILE, ">$fnamebase.c");
477 print TESTFILE "$prepend";
478 print TESTFILE "#include <$h>\n";
479 print TESTFILE "__typeof__ ($const) a = $const;\n";
480 close (TESTFILE);
481
482 $res = compiletest ($fnamebase, "Testing for constant $const",
2eba94b2 483 "Constant \"$const\" not available.", $res, 0);
20d49639
AJ		 484
485 if ($value ne "") {
486 # Generate a program to test for the value of this constant.
487 open (TESTFILE, ">$fnamebase.c");
488 print TESTFILE "$prepend";
489 print TESTFILE "#include <$h>\n";
490 # Negate the value since 0 means ok
491 print TESTFILE "int main (void) { return !($const $op $value); }\n";
492 close (TESTFILE);
493
494 $res = runtest ($fnamebase, "Testing for value of constant $const",
495 "Constant \"$const\" has not the right value.", $res);
496 }
31341567 497 } elsif (/^typed-constant *([a-zA-Z0-9_]*) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_-]*)?/) {
20d49639
AJ		 498 my($const) = $1;
499 my($type) = "$3$4";
500 my($value) = $5;
501 my($res) = $missing;
502
503 # Remember that this name is allowed.
504 push @allow, $const;
505
506 # Generate a program to test for the availability of this constant.
507 open (TESTFILE, ">$fnamebase.c");
508 print TESTFILE "$prepend";
509 print TESTFILE "#include <$h>\n";
510 print TESTFILE "__typeof__ ($const) a = $const;\n";
511 close (TESTFILE);
512
513 $res = compiletest ($fnamebase, "Testing for constant $const",
2eba94b2 514 "Constant \"$const\" not available.", $res, 0);
20d49639
AJ		 515
516 # Test the types of the members.
517 open (TESTFILE, ">$fnamebase.c");
518 print TESTFILE "$prepend";
519 print TESTFILE "#include <$h>\n";
520 print TESTFILE "__typeof__ (($type) 0) a;\n";
521 print TESTFILE "extern __typeof__ ($const) a;\n";
522 close (TESTFILE);
523
524 compiletest ($fnamebase, "Testing for type of constant $const",
525 "Constant \"$const\" does not have the correct type.",
2eba94b2
UD		 526 $res, 0);
527
528 if ($value ne "") {
529 # Generate a program to test for the value of this constant.
530 open (TESTFILE, ">$fnamebase.c");
531 print TESTFILE "$prepend";
532 print TESTFILE "#include <$h>\n";
533 print TESTFILE "int main (void) { return $const != $value; }\n";
534 close (TESTFILE);
535
536 $res = runtest ($fnamebase, "Testing for value of constant $const",
537 "Constant \"$const\" has not the right value.", $res);
538 }
31341567 539 } elsif (/^optional-constant *([a-zA-Z0-9_]*) *([A-Za-z0-9_-]*)?/) {
2eba94b2
UD		 540 my($const) = $1;
541 my($value) = $2;
542 my($res) = $missing;
543
544 # Remember that this name is allowed.
545 push @allow, $const;
546
547 # Generate a program to test for the availability of this constant.
548 open (TESTFILE, ">$fnamebase.c");
549 print TESTFILE "$prepend";
550 print TESTFILE "#include <$h>\n";
551 print TESTFILE "__typeof__ ($const) a = $const;\n";
552 close (TESTFILE);
553
554 $res = compiletest ($fnamebase, "Testing for constant $const",
555 "NOT PRESENT", $res, 1);
20d49639 556
12b64309 557 if ($value ne "" && $res == 0) {
20d49639
AJ		 558 # Generate a program to test for the value of this constant.
559 open (TESTFILE, ">$fnamebase.c");
560 print TESTFILE "$prepend";
561 print TESTFILE "#include <$h>\n";
562 print TESTFILE "int main (void) { return $const != $value; }\n";
563 close (TESTFILE);
564
565 $res = runtest ($fnamebase, "Testing for value of constant $const",
566 "Constant \"$const\" has not the right value.", $res);
567 }
31341567 568 } elsif (/^constant *([a-zA-Z0-9_]*) *([A-Za-z0-9_-]*)?/) {
da1067a9
UD		 569 my($const) = $1;
570 my($value) = $2;
571 my($res) = $missing;
572
573 # Remember that this name is allowed.
574 push @allow, $const;
575
576 # Generate a program to test for the availability of this constant.
577 open (TESTFILE, ">$fnamebase.c");
77faa354 578 print TESTFILE "$prepend";
da1067a9
UD		 579 print TESTFILE "#include <$h>\n";
580 print TESTFILE "__typeof__ ($const) a = $const;\n";
581 close (TESTFILE);
582
583 $res = compiletest ($fnamebase, "Testing for constant $const",
2eba94b2 584 "Constant \"$const\" not available.", $res, 0);
da1067a9 585
8ce9ea0c
UD		 586 if ($value ne "") {
587 # Generate a program to test for the value of this constant.
588 open (TESTFILE, ">$fnamebase.c");
589 print TESTFILE "$prepend";
590 print TESTFILE "#include <$h>\n";
591 print TESTFILE "int main (void) { return $const != $value; }\n";
592 close (TESTFILE);
593
594 $res = runtest ($fnamebase, "Testing for value of constant $const",
595 "Constant \"$const\" has not the right value.", $res);
596 }
31341567 597 } elsif (/^symbol *([a-zA-Z0-9_]*) *([A-Za-z0-9_-]*)?/) {
257abbe2
UD		 598 my($symbol) = $1;
599 my($value) = $2;
600 my($res) = $missing;
601
602 # Remember that this name is allowed.
603 push @allow, $symbol;
604
605 # Generate a program to test for the availability of this constant.
606 open (TESTFILE, ">$fnamebase.c");
607 print TESTFILE "$prepend";
608 print TESTFILE "#include <$h>\n";
609 print TESTFILE "void foobarbaz (void) {\n";
610 print TESTFILE "__typeof__ ($symbol) a = $symbol;\n";
611 print TESTFILE "}\n";
612 close (TESTFILE);
613
614 $res = compiletest ($fnamebase, "Testing for symbol $symbol",
615 "Symbol \"$symbol\" not available.", $res, 0);
616
617 if ($value ne "") {
618 # Generate a program to test for the value of this constant.
619 open (TESTFILE, ">$fnamebase.c");
620 print TESTFILE "$prepend";
621 print TESTFILE "#include <$h>\n";
622 print TESTFILE "int main (void) { return $symbol != $value; }\n";
623 close (TESTFILE);
624
625 $res = runtest ($fnamebase, "Testing for value of symbol $symbol",
626 "Symbol \"$symbol\" has not the right value.", $res);
627 }
31341567 628 } elsif (/^typed-constant *([a-zA-Z0-9_]*) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_-]*)?/) {
8ce9ea0c
UD		 629 my($const) = $1;
630 my($type) = "$3$4";
631 my($value) = $5;
632 my($res) = $missing;
633
634 # Remember that this name is allowed.
635 push @allow, $const;
636
637 # Generate a program to test for the availability of this constant.
638 open (TESTFILE, ">$fnamebase.c");
639 print TESTFILE "$prepend";
640 print TESTFILE "#include <$h>\n";
641 print TESTFILE "__typeof__ ($const) a = $const;\n";
642 close (TESTFILE);
643
644 $res = compiletest ($fnamebase, "Testing for constant $const",
2eba94b2 645 "Constant \"$const\" not available.", $res, 0);
8ce9ea0c
UD		 646
647 # Test the types of the members.
648 open (TESTFILE, ">$fnamebase.c");
649 print TESTFILE "$prepend";
650 print TESTFILE "#include <$h>\n";
651 print TESTFILE "__typeof__ (($type) 0) a;\n";
652 print TESTFILE "extern __typeof__ ($const) a;\n";
653 close (TESTFILE);
654
655 compiletest ($fnamebase, "Testing for type of constant $const",
656 "Constant \"$const\" does not have the correct type.",
2eba94b2 657 $res, 0);
8ce9ea0c 658
da1067a9
UD		 659 if ($value ne "") {
660 # Generate a program to test for the value of this constant.
661 open (TESTFILE, ">$fnamebase.c");
77faa354 662 print TESTFILE "$prepend";
da1067a9
UD		 663 print TESTFILE "#include <$h>\n";
664 print TESTFILE "int main (void) { return $const != $value; }\n";
665 close (TESTFILE);
666
667 $res = runtest ($fnamebase, "Testing for value of constant $const",
668 "Constant \"$const\" has not the right value.", $res);
669 }
ccd4b479
UD		 670 } elsif (/^optional-type *({([^}]*)|([a-zA-Z0-9_]*))/) {
671 my($type) = "$2$3";
2ff458eb 672 my($maybe_opaque) = 0;
ccd4b479
UD		 673
674 # Remember that this name is allowed.
675 if ($type =~ /^struct *(.*)/) {
676 push @allow, $1;
677 } elsif ($type =~ /^union *(.*)/) {
678 push @allow, $1;
679 } else {
680 push @allow, $type;
2ff458eb 681 $maybe_opaque = 1;
ccd4b479
UD		 682 }
683
ccd4b479
UD		 684 # Generate a program to test for the availability of this constant.
685 open (TESTFILE, ">$fnamebase.c");
686 print TESTFILE "$prepend";
687 print TESTFILE "#include <$h>\n";
2ff458eb
UD		 688 if ($maybe_opaque == 1) {
689 print TESTFILE "$type *a;\n";
690 } else {
691 print TESTFILE "$type a;\n";
692 }
ccd4b479
UD		 693 close (TESTFILE);
694
695 compiletest ($fnamebase, "Testing for type $type",
2ff458eb 696 "NOT AVAILABLE", $missing, 1);
da1067a9
UD		 697 } elsif (/^type *({([^}]*)|([a-zA-Z0-9_]*))/) {
698 my($type) = "$2$3";
2ff458eb 699 my($maybe_opaque) = 0;
da1067a9
UD		 700
701 # Remember that this name is allowed.
702 if ($type =~ /^struct *(.*)/) {
703 push @allow, $1;
704 } elsif ($type =~ /^union *(.*)/) {
705 push @allow, $1;
706 } else {
707 push @allow, $type;
2ff458eb 708 $maybe_opaque = 1;
da1067a9
UD		 709 }
710
3bf3d361 711 # Generate a program to test for the availability of this type.
da1067a9 712 open (TESTFILE, ">$fnamebase.c");
5d916713 713 print TESTFILE "$prepend";
da1067a9 714 print TESTFILE "#include <$h>\n";
2ff458eb
UD		 715 if ($maybe_opaque == 1) {
716 print TESTFILE "$type *a;\n";
717 } else {
718 print TESTFILE "$type a;\n";
719 }
da1067a9
UD		 720 close (TESTFILE);
721
f095bb72
UD		 722 compiletest ($fnamebase, "Testing for type $type",
723 "Type \"$type\" not available.", $missing, 0);
724 } elsif (/^tag *({([^}]*)|([a-zA-Z0-9_]*))/) {
725 my($type) = "$2$3";
726
727 # Remember that this name is allowed.
728 if ($type =~ /^struct *(.*)/) {
729 push @allow, $1;
730 } elsif ($type =~ /^union *(.*)/) {
731 push @allow, $1;
732 } else {
733 push @allow, $type;
734 }
735
736 # Generate a program to test for the availability of this type.
737 open (TESTFILE, ">$fnamebase.c");
738 print TESTFILE "$prepend";
739 print TESTFILE "#include <$h>\n";
740 print TESTFILE "$type;\n";
741 close (TESTFILE);
742
da1067a9 743 compiletest ($fnamebase, "Testing for type $type",
2eba94b2 744 "Type \"$type\" not available.", $missing, 0);
2ff458eb
UD		 745 } elsif (/^optional-function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
746 my($rettype) = "$2$3";
747 my($fname) = "$4";
748 my($args) = "$5";
749 my($res) = $missing;
750
751 # Remember that this name is allowed.
752 push @allow, $fname;
753
754 # Generate a program to test for availability of this function.
755 open (TESTFILE, ">$fnamebase.c");
756 print TESTFILE "$prepend";
757 print TESTFILE "#include <$h>\n";
758 # print TESTFILE "#undef $fname\n";
759 print TESTFILE "$rettype (*(*foobarbaz) $args = $fname;\n";
760 close (TESTFILE);
761
762 $res = compiletest ($fnamebase, "Test availability of function $fname",
763 "NOT AVAILABLE", $res, 1);
764
765 if ($res == 0 || $missing == 1) {
766 # Generate a program to test for the type of this function.
767 open (TESTFILE, ">$fnamebase.c");
768 print TESTFILE "$prepend";
769 print TESTFILE "#include <$h>\n";
770 # print TESTFILE "#undef $fname\n";
771 print TESTFILE "extern $rettype (*(*foobarbaz) $args;\n";
772 print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
773 close (TESTFILE);
774
775 compiletest ($fnamebase, "Test for type of function $fname",
776 "Function \"$fname\" has incorrect type.", $res, 0);
777 }
8ce9ea0c
UD		 778 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
779 my($rettype) = "$2$3";
780 my($fname) = "$4";
781 my($args) = "$5";
782 my($res) = $missing;
783
784 # Remember that this name is allowed.
785 push @allow, $fname;
786
787 # Generate a program to test for availability of this function.
788 open (TESTFILE, ">$fnamebase.c");
789 print TESTFILE "$prepend";
790 print TESTFILE "#include <$h>\n";
791 # print TESTFILE "#undef $fname\n";
792 print TESTFILE "$rettype (*(*foobarbaz) $args = $fname;\n";
793 close (TESTFILE);
794
795 $res = compiletest ($fnamebase, "Test availability of function $fname",
2eba94b2 796 "Function \"$fname\" is not available.", $res, 0);
8ce9ea0c
UD		 797
798 # Generate a program to test for the type of this function.
799 open (TESTFILE, ">$fnamebase.c");
800 print TESTFILE "$prepend";
801 print TESTFILE "#include <$h>\n";
802 # print TESTFILE "#undef $fname\n";
803 print TESTFILE "extern $rettype (*(*foobarbaz) $args;\n";
804 print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
805 close (TESTFILE);
806
807 compiletest ($fnamebase, "Test for type of function $fname",
2eba94b2 808 "Function \"$fname\" has incorrect type.", $res, 0);
2ff458eb
UD		 809 } elsif (/^optional-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
810 my($rettype) = "$2$3";
811 my($fname) = "$4";
812 my($args) = "$5";
813 my($res) = $missing;
814
815 # Remember that this name is allowed.
816 push @allow, $fname;
817
818 # Generate a program to test for availability of this function.
819 open (TESTFILE, ">$fnamebase.c");
820 print TESTFILE "$prepend";
821 print TESTFILE "#include <$h>\n";
822 # print TESTFILE "#undef $fname\n";
823 print TESTFILE "$rettype (*foobarbaz) $args = $fname;\n";
824 close (TESTFILE);
825
826 $res = compiletest ($fnamebase, "Test availability of function $fname",
827 "NOT AVAILABLE", $res, 1);
828
829 if ($res == 0 || $missing != 0) {
830 # Generate a program to test for the type of this function.
831 open (TESTFILE, ">$fnamebase.c");
832 print TESTFILE "$prepend";
833 print TESTFILE "#include <$h>\n";
834 # print TESTFILE "#undef $fname\n";
835 print TESTFILE "extern $rettype (*foobarbaz) $args;\n";
836 print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
837 close (TESTFILE);
838
839 compiletest ($fnamebase, "Test for type of function $fname",
840 "Function \"$fname\" has incorrect type.", $res, 0);
841 }
8ce9ea0c 842 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
da1067a9
UD		 843 my($rettype) = "$2$3";
844 my($fname) = "$4";
845 my($args) = "$5";
846 my($res) = $missing;
847
848 # Remember that this name is allowed.
849 push @allow, $fname;
850
851 # Generate a program to test for availability of this function.
852 open (TESTFILE, ">$fnamebase.c");
77faa354 853 print TESTFILE "$prepend";
da1067a9 854 print TESTFILE "#include <$h>\n";
52cf7d34 855 # print TESTFILE "#undef $fname\n";
da1067a9
UD		 856 print TESTFILE "$rettype (*foobarbaz) $args = $fname;\n";
857 close (TESTFILE);
858
859 $res = compiletest ($fnamebase, "Test availability of function $fname",
2eba94b2 860 "Function \"$fname\" is not available.", $res, 0);
da1067a9
UD		 861
862 # Generate a program to test for the type of this function.
863 open (TESTFILE, ">$fnamebase.c");
77faa354 864 print TESTFILE "$prepend";
da1067a9 865 print TESTFILE "#include <$h>\n";
52cf7d34 866 # print TESTFILE "#undef $fname\n";
da1067a9
UD		 867 print TESTFILE "extern $rettype (*foobarbaz) $args;\n";
868 print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
869 close (TESTFILE);
870
8ce9ea0c 871 compiletest ($fnamebase, "Test for type of function $fname",
2eba94b2 872 "Function \"$fname\" has incorrect type.", $res, 0);
73b6bffc 873 } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) *(.*)/) {
8ce9ea0c
UD		 874 my($type) = "$2$3";
875 my($vname) = "$4";
73b6bffc 876 my($rest) = "$5";
8ce9ea0c
UD		 877 my($res) = $missing;
878
879 # Remember that this name is allowed.
880 push @allow, $vname;
881
882 # Generate a program to test for availability of this function.
883 open (TESTFILE, ">$fnamebase.c");
884 print TESTFILE "$prepend";
885 print TESTFILE "#include <$h>\n";
886 # print TESTFILE "#undef $fname\n";
73b6bffc
UD		 887 print TESTFILE "typedef $type xyzzy$rest;\n";
888 print TESTFILE "$xyzzy *foobarbaz = &$vname;\n";
8ce9ea0c
UD		 889 close (TESTFILE);
890
891 $res = compiletest ($fnamebase, "Test availability of variable $vname",
2eba94b2 892 "Variable \"$vname\" is not available.", $res, 0);
8ce9ea0c
UD		 893
894 # Generate a program to test for the type of this function.
895 open (TESTFILE, ">$fnamebase.c");
896 print TESTFILE "$prepend";
897 print TESTFILE "#include <$h>\n";
898 # print TESTFILE "#undef $fname\n";
73b6bffc 899 print TESTFILE "extern $type $vname$rest;\n";
8ce9ea0c
UD		 900 close (TESTFILE);
901
902 compiletest ($fnamebase, "Test for type of variable $fname",
2eba94b2 903 "Variable \"$vname\" has incorrect type.", $res, 0);
8ce9ea0c
UD		 904 } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
905 my($rettype) = "$2$3";
906 my($fname) = "$4";
907 my($args) = "$5";
908 my($res) = $missing;
909
910 # Remember that this name is allowed.
911 push @allow, $fname;
912
913 # Generate a program to test for availability of this function.
914 open (TESTFILE, ">$fnamebase.c");
915 print TESTFILE "$prepend";
916 print TESTFILE "#include <$h>\n";
917 print TESTFILE "#ifndef $fname\n";
918 print TESTFILE "$rettype (*foobarbaz) $args = $fname;\n";
919 print TESTFILE "#endif\n";
920 close (TESTFILE);
921
31341567 922 $res = compiletest ($fnamebase, "Test availability of macro $fname",
2eba94b2 923 "Function \"$fname\" is not available.", $res, 0);
8ce9ea0c
UD		 924
925 # Generate a program to test for the type of this function.
926 open (TESTFILE, ">$fnamebase.c");
927 print TESTFILE "$prepend";
928 print TESTFILE "#include <$h>\n";
929 print TESTFILE "#ifndef $fname\n";
930 print TESTFILE "extern $rettype (*foobarbaz) $args;\n";
931 print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
932 print TESTFILE "#endif\n";
933 close (TESTFILE);
934
31341567 935 compiletest ($fnamebase, "Test for type of macro $fname",
2eba94b2 936 "Function \"$fname\" has incorrect type.", $res, 0);
7cc9fcf4 937 } elsif (/^macro-str *([^ ]*) *(\".*\")/) {
20d49639
AJ		 938 # The above regex doesn't handle a \" in a string.
939 my($macro) = "$1";
940 my($string) = "$2";
941 my($res) = $missing;
942
943 # Remember that this name is allowed.
944 push @allow, $macro;
945
946 # Generate a program to test for availability of this macro.
947 open (TESTFILE, ">$fnamebase.c");
948 print TESTFILE "$prepend";
949 print TESTFILE "#include <$h>\n";
950 print TESTFILE "#ifndef $macro\n";
951 print TESTFILE "# error \"Macro $macro not defined\"\n";
952 print TESTFILE "#endif\n";
953 close (TESTFILE);
954
955 compiletest ($fnamebase, "Test availability of macro $macro",
2eba94b2 956 "Macro \"$macro\" is not available.", $missing, 0);
20d49639
AJ		 957
958 # Generate a program to test for the value of this macro.
959 open (TESTFILE, ">$fnamebase.c");
960 print TESTFILE "$prepend";
961 print TESTFILE "#include <$h>\n";
962 # We can't include <string.h> here.
963 print TESTFILE "extern int (strcmp)(const char *, const char *);\n";
7cc9fcf4 964 print TESTFILE "int main (void) { return (strcmp) ($macro, $string) != 0;}\n";
20d49639
AJ		 965 close (TESTFILE);
966
967 $res = runtest ($fnamebase, "Testing for value of macro $macro",
968 "Macro \"$macro\" has not the right value.", $res);
12b64309
UD		 969 } elsif (/^optional-macro *([^ ]*)/) {
970 my($macro) = "$1";
971
972 # Remember that this name is allowed.
973 push @allow, $macro;
974
975 # Generate a program to test for availability of this macro.
976 open (TESTFILE, ">$fnamebase.c");
977 print TESTFILE "$prepend";
978 print TESTFILE "#include <$h>\n";
979 print TESTFILE "#ifndef $macro\n";
980 print TESTFILE "# error \"Macro $macro not defined\"\n";
981 print TESTFILE "#endif\n";
982 close (TESTFILE);
983
984 compiletest ($fnamebase, "Test availability of macro $macro",
985 "NOT PRESENT", $missing, 1);
4efeffc1 986 } elsif (/^macro *([a-zA-Z0-9_]*) *([>=<!]+) ([A-Za-z0-9_]*)/) {
12b64309
UD		 987 my($macro) = "$1";
988 my($op) = $2;
989 my($value) = $3;
990 my($res) = $missing;
991
992 # Remember that this name is allowed.
993 push @allow, $macro;
994
995 # Generate a program to test for availability of this macro.
996 open (TESTFILE, ">$fnamebase.c");
997 print TESTFILE "$prepend";
998 print TESTFILE "#include <$h>\n";
999 print TESTFILE "#ifndef $macro\n";
1000 print TESTFILE "# error \"Macro $macro not defined\"\n";
1001 print TESTFILE "#endif\n";
1002 close (TESTFILE);
1003
1004 $res = compiletest ($fnamebase, "Test availability of macro $macro",
1005 "Macro \"$macro\" is not available.", $res, 0);
1006
1007 if ($value ne "") {
1008 # Generate a program to test for the value of this constant.
1009 open (TESTFILE, ">$fnamebase.c");
1010 print TESTFILE "$prepend";
1011 print TESTFILE "#include <$h>\n";
1012 # Negate the value since 0 means ok
1013 print TESTFILE "int main (void) { return !($macro $op $value); }\n";
1014 close (TESTFILE);
1015
31341567
UD		 1016 $res = runtest ($fnamebase, "Testing for value of macro $macro",
1017 "Macro \"$macro\" has not the right value.", $res);
1018 }
1019 } elsif (/^macro *([a-zA-Z0-9_]*) *([A-Za-z0-9_]*)/) {
1020 my($macro) = "$1";
1021 my($value) = $2;
1022 my($res) = $missing;
1023
1024 # Remember that this name is allowed.
1025 push @allow, $macro;
1026
1027 # Generate a program to test for availability of this macro.
1028 open (TESTFILE, ">$fnamebase.c");
1029 print TESTFILE "$prepend";
1030 print TESTFILE "#include <$h>\n";
1031 print TESTFILE "#ifndef $macro\n";
1032 print TESTFILE "# error \"Macro $macro not defined\"\n";
1033 print TESTFILE "#endif\n";
1034 close (TESTFILE);
1035
1036 $res = compiletest ($fnamebase, "Test availability of macro $macro",
1037 "Macro \"$macro\" is not available.", $res, 0);
1038
1039 if ($value ne "") {
1040 # Generate a program to test for the value of this constant.
1041 open (TESTFILE, ">$fnamebase.c");
1042 print TESTFILE "$prepend";
1043 print TESTFILE "#include <$h>\n";
1044 # Negate the value since 0 means ok
1045 print TESTFILE "int main (void) { return !($macro == $value); }\n";
1046 close (TESTFILE);
1047
1048 $res = runtest ($fnamebase, "Testing for value of macro $macro",
12b64309
UD		 1049 "Macro \"$macro\" has not the right value.", $res);
1050 }
20d49639 1051 } elsif (/^macro *([^ ]*)/) {
da1067a9
UD		 1052 my($macro) = "$1";
1053
1054 # Remember that this name is allowed.
1055 push @allow, $macro;
1056
1057 # Generate a program to test for availability of this macro.
1058 open (TESTFILE, ">$fnamebase.c");
77faa354 1059 print TESTFILE "$prepend";
da1067a9
UD		 1060 print TESTFILE "#include <$h>\n";
1061 print TESTFILE "#ifndef $macro\n";
1062 print TESTFILE "# error \"Macro $macro not defined\"\n";
1063 print TESTFILE "#endif\n";
1064 close (TESTFILE);
1065
1066 compiletest ($fnamebase, "Test availability of macro $macro",
2eba94b2 1067 "Macro \"$macro\" is not available.", $missing, 0);
0ed99ce4
UD		 1068 } elsif (/^allow-header *(.*)/) {
1069 my($pattern) = $1;
9d48fef0
UD		 1070 if ($seenheader{$pattern} != 1) {
1071 push @allowheader, $pattern;
1072 $seenheader{$pattern} = 1;
1073 }
0ed99ce4 1074 next control;
d753ffef
UD		 1075 } elsif (/^allow *(.*)/) {
1076 my($pattern) = $1;
1077 push @allow, $pattern;
1078 next control;
da1067a9
UD		 1079 } else {
1080 # printf ("line is `%s'\n", $_);
1081 next control;
1082 }
1083
1084 printf ("\n");
1085 }
1086 close (CONTROL);
1087
0ed99ce4
UD		 1088 # Read the data files for the header files which are allowed to be included.
1089 while ($#allowheader >= 0) {
1090 my($ah) = pop @allowheader;
1091
31341567 1092 open (ALLOW, "$CC -E -D$standard - < data/$ah-data |");
0ed99ce4 1093 acontrol: while (<ALLOW>) {
505cf2c0 1094 chop;
0ed99ce4 1095 next acontrol if (/^#/);
20d49639 1096 next acontrol if (/^[ ]*$/);
0ed99ce4
UD		 1097
1098 if (/^element *({([^}]*)}|([^ ]*)) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
1099 push @allow, $7;
1100 } elsif (/^constant *([a-zA-Z0-9_]*) *([A-Za-z0-9_]*)?/) {
1101 push @allow, $1;
1102 } elsif (/^typed-constant *([a-zA-Z0-9_]*) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*)?/) {
1103 push @allow, 1;
a9625ea9
UD		 1104 } elsif (/^(type|tag) *({([^}]*)|([a-zA-Z0-9_]*))/) {
1105 my($type) = "$3$4";
0ed99ce4
UD		 1106
1107 # Remember that this name is allowed.
1108 if ($type =~ /^struct *(.*)/) {
1109 push @allow, $1;
1110 } elsif ($type =~ /^union *(.*)/) {
1111 push @allow, $1;
1112 } else {
1113 push @allow, $type;
1114 }
1115 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
1116 push @allow, $4;
1117 } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
1118 push @allow, $4;
1119 } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*)/) {
1120 push @allow, $4;
1121 } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
1122 push @allow, $4;
20d49639 1123 } elsif (/^macro *([^ ]*)/) {
0ed99ce4 1124 push @allow, $1;
0ed99ce4 1125 } elsif (/^allow-header *(.*)/) {
9d48fef0
UD		 1126 if ($seenheader{$1} != 1) {
1127 push @allowheader, $1;
1128 $seenheader{$1} = 1;
1129 }
bec7805d
UD		 1130 } elsif (/^allow *(.*)/) {
1131 push @allow, $1;
0ed99ce4
UD		 1132 }
1133 }
1134 close (ALLOW);
1135 }
1136
31341567
UD		 1137 if ($test_exist) {
1138 printf (" Not defined\n");
da1067a9 1139 } else {
31341567
UD		 1140 # Now check the namespace.
1141 printf (" Checking the namespace of \"%s\"... ", $h);
1142 if ($missing) {
1143 ++$skipped;
1144 printf ("SKIP\n");
1145 } else {
1146 checknamespace ($h, $fnamebase, @allow);
1147 }
da1067a9
UD		 1148 }
1149
1150 printf ("\n\n");
1151}
1152
1153printf "-" x 76 . "\n";
7287c36d
UD		 1154printf (" Total number of tests : %4d\n", $total);
1155
7287c36d
UD		 1156printf (" Number of failed tests : %4d (", $errors);
1157$percent = ($errors * 100) / $total;
6b3e8333 1158if ($errors > 0 && $percent < 1.0) {
7287c36d
UD		 1159 printf (" <1%%)\n");
1160} else {
1161 printf ("%3d%%)\n", $percent);
1162}
1163
1164printf (" Number of skipped tests : %4d (", $skipped);
1165$percent = ($skipped * 100) / $total;
6b3e8333 1166if ($skipped > 0 && $percent < 1.0) {
7287c36d
UD		 1167 printf (" <1%%)\n");
1168} else {
1169 printf ("%3d%%)\n", $percent);
1170}
da1067a9
UD		 1171
1172exit $errors != 0;
31341567
UD		 1173# Local Variables:
1174# perl-indent-level: 2
1175# End:
A mirror of the official glibc repository