Data to test net/if.h.
[kopensolaris-gnu/glibc.git] / conform / conformtest.pl
1 #! /usr/bin/perl
2
3 $CC = "gcc";
4 $CFLAGS = "-I. '-D__attribute__(x)=' -D_XOPEN_SOURCE=500";
5
6 # List of the headers we are testing.
7 @headers = ("wordexp.h", "wctype.h", "wchar.h", "varargs.h", "utmpx.h",
8             "utime.h", "unistd.h", "ulimit.h", "ucontext.h", "time.h",
9             "termios.h", "tar.h", "sys/wait.h", "sys/utsname.h", "sys/un.h",
10             "sys/uio.h", "sys/types.h", "sys/times.h", "sys/timeb.h",
11             "sys/time.h", "sys/statvfs.h", "sys/stat.h", "sys/socket.h",
12             "sys/shm.h", "sys/sem.h", "sys/resource.h", "sys/msg.h",
13             "sys/mman.h", "sys/ipc.h", "syslog.h", "stropts.h", "strings.h",
14             "string.h", "stdlib.h", "stdio.h", "stddef.h", "stdarg.h",
15             "spawn.h", "signal.h", "setjmp.h", "semaphore.h",
16             "search.h", "sched.h", "regex.h", "pwd.h", "pthread.h",
17             "poll.h", "nl_types.h", "netinet/tcp.h", "netinet/in.h",
18             "net/if.h", "netdb.h", "ndbm.h", "mqueue.h", "monetary.h",
19             "math.h", "locale.h", "libgen.h", "langinfo.h", "iso646.h",
20             "inttypes.h", "iconv.h", "grp.h", "glob.h", "ftw.h", "fnmatch.h",
21             "fmtmsg.h", "float.h", "fcntl.h", "errno.h", "dlfcn.h", "dirent.h",
22             "ctype.h", "cpio.h", "assert.h", "arpa/inet.h", "aio.h");
23
24 # These are the ISO C99 keywords.
25 @keywords = ('auto', 'break', 'case', 'char', 'const', 'continue', 'default',
26              'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto',
27              'if', 'inline', 'int', 'long', 'register', 'restrict', 'return',
28              'short', 'signed', 'sizeof', 'static', 'struct', 'switch',
29              'typedef', 'union', 'unsigned', 'void', 'volatile', 'while');
30
31 # Some headers need a bit more attention.
32 $mustprepend{'regex.h'} = "#include <sys/types.h>\n";
33
34 # Make an hash table from this information.
35 while ($#keywords) {
36   $iskeyword{pop (@keywords)} = 1;
37 }
38
39 $tmpdir = "/tmp";
40
41 $verbose = 1;
42
43 $total = 0;
44 $skipped = 0;
45 $errors = 0;
46
47 #$dialect = "ISO";
48 #$dialect = "POSIX";
49 #$dialect = "XPG3";
50 #$dialect = "XPG4";
51 $dialect = "UNIX98";
52
53
54 sub poorfnmatch {
55   my($pattern, $string) = @_;
56   my($strlen) = length ($string);
57   my($res);
58
59   if (substr ($pattern, 0, 1) eq '*') {
60     my($patlen) = length ($pattern) - 1;
61     $res = ($strlen >= $patlen
62             && substr ($pattern, -$patlen, $patlen) eq substr ($string, -$patlen, $patlen));
63   } elsif (substr ($pattern, -1, 1) eq '*') {
64     my($patlen) = length ($pattern) - 1;
65     $res = ($strlen >= $patlen
66             && substr ($pattern, 0, $patlen) eq substr ($string, 0, $patlen));
67   } else {
68     $res = $pattern eq $string;
69   }
70   return $res;
71 }
72
73
74 sub compiletest
75 {
76   my($fnamebase, $msg, $errmsg, $skip) = @_;
77   my($result) = $skip;
78   my($printlog) = 0;
79
80   ++$total;
81   printf ("  $msg...");
82
83   if ($skip != 0) {
84     ++$skipped;
85     printf (" SKIP\n");
86   } else {
87     $ret = system "$CC $CFLAGS -c $fnamebase.c -o $fnamebase.o > $fnamebase.out 2>&1";
88     if ($ret != 0) {
89       printf (" FAIL\n");
90       if ($verbose != 0) {
91         printf ("    $errmsg  Compiler message:\n");
92         $printlog = 1;
93       }
94       ++$errors;
95       $result = 1;
96     } else {
97       printf (" OK\n");
98       if ($verbose > 1 && -s "$fnamebase.out") {
99         # We print all warnings issued.
100         $printlog = 1;
101       }
102     }
103     if ($printlog != 0) {
104       printf ("    " . "-" x 71 . "\n");
105       open (MESSAGE, "< $fnamebase.out");
106       while (<MESSAGE>) {
107         printf ("    %s", $_);
108       }
109       close (MESSAGE);
110       printf ("    " . "-" x 71 . "\n");
111     }
112   }
113   unlink "$fnamebase.c";
114   unlink "$fnamebase.o";
115   unlink "$fnamebase.out";
116
117   $result;
118 }
119
120
121 sub runtest
122 {
123   my($fnamebase, $msg, $errmsg, $skip) = @_;
124   my($result) = $skip;
125   my($printlog) = 0;
126
127   ++$total;
128   printf ("  $msg...");
129
130   if ($skip != 0) {
131     ++$skipped;
132     printf (" SKIP\n");
133   } else {
134     $ret = system "$CC $CFLAGS -o $fnamebase $fnamebase.c > $fnamebase.out 2>&1";
135     if ($ret != 0) {
136       printf (" FAIL\n");
137       if ($verbose != 0) {
138         printf ("    $errmsg  Compiler message:\n");
139         $printlog = 1;
140       }
141       ++$errors;
142       $result = 1;
143     } else {
144       # Now run the program.  If the exit code is not zero something is wrong.
145       $result = system "$fnamebase > $fnamebase.out2 2>&1";
146       if ($result == 0) {
147         printf (" OK\n");
148         if ($verbose > 1 && -s "$fnamebase.out") {
149           # We print all warnings issued.
150           $printlog = 1;
151           system "cat $fnamebase.out2 >> $fnamebase.out";
152         }
153       } else {
154         printf (" FAIL\n");
155         $printlog = 1;
156         unlink "$fnamebase.out";
157         rename "$fnamebase.out2", "$fnamebase.out";
158       }
159     }
160     if ($printlog != 0) {
161       printf ("    " . "-" x 71 . "\n");
162       open (MESSAGE, "< $fnamebase.out");
163       while (<MESSAGE>) {
164         printf ("    %s", $_);
165       }
166       close (MESSAGE);
167       printf ("    " . "-" x 71 . "\n");
168     }
169   }
170   unlink "$fnamebase";
171   unlink "$fnamebase.c";
172   unlink "$fnamebase.o";
173   unlink "$fnamebase.out";
174   unlink "$fnamebase.out2";
175
176   $result;
177 }
178
179
180 sub newtoken {
181   my($token, $nerrors, @allow) = @_;
182   my($idx);
183
184   if ($token =~ /^[0-9_]/ || $iskeyword{$token}) {
185     return $nerrors;
186   }
187
188   for ($idx = 0; $idx <= $#allow; ++$idx) {
189     if (poorfnmatch ($allow[$idx], $token)) {
190       return $nerrors;
191     }
192   }
193
194   ++$nerrors;
195   if ($nerrors == 1) {
196     printf ("FAIL\n    " . "-" x 72 . "\n");
197   }
198   printf ("    Namespace violation: \"%s\"\n", $token);
199   return $nerrors;
200 }
201
202
203 sub checknamespace {
204   my($h, $fnamebase, @allow) = @_;
205   my($nerrors) = 0;
206
207   ++$total;
208
209   # Generate a program to get the contents of this header.
210   open (TESTFILE, ">$fnamebase.c");
211   print TESTFILE "#include <$h>\n";
212   close (TESTFILE);
213
214   open (CONTENT, "$CC $CFLAGS -E $fnamebase.c -Wp,-dN | sed -e '/^# [1-9]/d' -e '/^[[:space:]]*\$/d' |");
215   while (<CONTENT>) {
216     chop;
217     if (/^#define (.*)/) {
218       $nerrors = newtoken ($1, $nerrors, @allow);
219     } else {
220       # We have to tokenize the line.
221       my($str) = $_;
222       my($index) = 0;
223       my($len) = length ($str);
224
225       foreach $token (split(/[^a-zA-Z0-9_]/, $str)) {
226         if ($token ne "") {
227           $nerrors = newtoken ($token, $nerrors, @allow);
228         }
229       }
230     }
231   }
232   close (CONTENT);
233   unlink "$fnamebase.c";
234   if ($nerrors != 0) {
235     printf ("    " . "-" x 72 . "\n");
236     ++$errors;
237   } else {
238     printf ("OK\n");
239   }
240 }
241
242
243 while ($#headers >= 0) {
244   my($h) = pop (@headers);
245   my($hf) = $h;
246   $hf =~ s|/|-|;
247   my($fnamebase) = "$tmpdir/$hf-test";
248   my($missing);
249   my(@allow) = ();
250   my(@allowheader) = ();
251   my($prepend) = $mustprepend{$h};
252
253   printf ("Testing <$h>\n");
254   printf ("----------" . "-" x length ($h) . "\n");
255
256   # Generate a program to test for the availability of this header.
257   open (TESTFILE, ">$fnamebase.c");
258   print TESTFILE "$prepend";
259   print TESTFILE "#include <$h>\n";
260   close (TESTFILE);
261
262   $missing = compiletest ($fnamebase, "Checking whether <$h> is available",
263                           "Header <$h> not available", 0);
264
265   printf ("\n");
266
267   open (CONTROL, "$CC -E -D$dialect - < data/$h-data |");
268   control: while (<CONTROL>) {
269     chop;
270     next control if (/^#/);
271     next control if (/^[        ]*$/);
272
273     if (/^element *({([^}]*)}|([^ ]*)) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
274       my($struct) = "$2$3";
275       my($type) = "$5$6";
276       my($member) = "$7";
277       my($rest) = "$8";
278       my($res) = $missing;
279
280       # Remember that this name is allowed.
281       push @allow, $member;
282
283       # Generate a program to test for the availability of this member.
284       open (TESTFILE, ">$fnamebase.c");
285       print TESTFILE "$prepend";
286       print TESTFILE "#include <$h>\n";
287       print TESTFILE "$struct a;\n";
288       print TESTFILE "$struct b;\n";
289       print TESTFILE "extern void xyzzy (__typeof__ (&b.$member), __typeof__ (&a.$member), unsigned);\n";
290       print TESTFILE "void foobarbaz (void) {\n";
291       print TESTFILE "  xyzzy (&a.$member, &b.$member, sizeof (a.$member));\n";
292       print TESTFILE "}\n";
293       close (TESTFILE);
294
295       $res = compiletest ($fnamebase, "Testing for member $member",
296                           "Member \"$member\" not available.", $res);
297
298
299       # Test the types of the members.
300       open (TESTFILE, ">$fnamebase.c");
301       print TESTFILE "$prepend";
302       print TESTFILE "#include <$h>\n";
303       print TESTFILE "$struct a;\n";
304       print TESTFILE "extern $type b$rest;\n";
305       print TESTFILE "extern __typeof__ (a.$member) b;\n";
306       close (TESTFILE);
307
308       compiletest ($fnamebase, "Testing for type of member $member",
309                    "Member \"$member\" does not have the correct type.", $res);
310     } elsif (/^constant *([a-zA-Z0-9_]*) *([A-Za-z0-9_]*)?/) {
311       my($const) = $1;
312       my($value) = $2;
313       my($res) = $missing;
314
315       # Remember that this name is allowed.
316       push @allow, $const;
317
318       # Generate a program to test for the availability of this constant.
319       open (TESTFILE, ">$fnamebase.c");
320       print TESTFILE "$prepend";
321       print TESTFILE "#include <$h>\n";
322       print TESTFILE "__typeof__ ($const) a = $const;\n";
323       close (TESTFILE);
324
325       $res = compiletest ($fnamebase, "Testing for constant $const",
326                           "Constant \"$const\" not available.", $res);
327
328       if ($value ne "") {
329         # Generate a program to test for the value of this constant.
330         open (TESTFILE, ">$fnamebase.c");
331         print TESTFILE "$prepend";
332         print TESTFILE "#include <$h>\n";
333         print TESTFILE "int main (void) { return $const != $value; }\n";
334         close (TESTFILE);
335
336         $res = runtest ($fnamebase, "Testing for value of constant $const",
337                         "Constant \"$const\" has not the right value.", $res);
338       }
339     } elsif (/^typed-constant *([a-zA-Z0-9_]*) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*)?/) {
340       my($const) = $1;
341       my($type) = "$3$4";
342       my($value) = $5;
343       my($res) = $missing;
344
345       # Remember that this name is allowed.
346       push @allow, $const;
347
348       # Generate a program to test for the availability of this constant.
349       open (TESTFILE, ">$fnamebase.c");
350       print TESTFILE "$prepend";
351       print TESTFILE "#include <$h>\n";
352       print TESTFILE "__typeof__ ($const) a = $const;\n";
353       close (TESTFILE);
354
355       $res = compiletest ($fnamebase, "Testing for constant $const",
356                           "Constant \"$const\" not available.", $res);
357
358       # Test the types of the members.
359       open (TESTFILE, ">$fnamebase.c");
360       print TESTFILE "$prepend";
361       print TESTFILE "#include <$h>\n";
362       print TESTFILE "__typeof__ (($type) 0) a;\n";
363       print TESTFILE "extern __typeof__ ($const) a;\n";
364       close (TESTFILE);
365
366       compiletest ($fnamebase, "Testing for type of constant $const",
367                    "Constant \"$const\" does not have the correct type.",
368                    $res);
369
370       if ($value ne "") {
371         # Generate a program to test for the value of this constant.
372         open (TESTFILE, ">$fnamebase.c");
373         print TESTFILE "$prepend";
374         print TESTFILE "#include <$h>\n";
375         print TESTFILE "int main (void) { return $const != $value; }\n";
376         close (TESTFILE);
377
378         $res = runtest ($fnamebase, "Testing for value of constant $const",
379                         "Constant \"$const\" has not the right value.", $res);
380       }
381     } elsif (/^type *({([^}]*)|([a-zA-Z0-9_]*))/) {
382       my($type) = "$2$3";
383
384       # Remember that this name is allowed.
385       if ($type =~ /^struct *(.*)/) {
386         push @allow, $1;
387       } elsif ($type =~ /^union *(.*)/) {
388         push @allow, $1;
389       } else {
390         push @allow, $type;
391       }
392
393       # Remember that this name is allowed.
394       push @allow, $type;
395
396       # Generate a program to test for the availability of this constant.
397       open (TESTFILE, ">$fnamebase.c");
398       print TESTFILE "$prepend";
399       print TESTFILE "#include <$h>\n";
400       print TESTFILE "$type *a;\n";
401       close (TESTFILE);
402
403       compiletest ($fnamebase, "Testing for type $type",
404                    "Type \"$type\" not available.", $missing);
405     } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
406       my($rettype) = "$2$3";
407       my($fname) = "$4";
408       my($args) = "$5";
409       my($res) = $missing;
410
411       # Remember that this name is allowed.
412       push @allow, $fname;
413
414       # Generate a program to test for availability of this function.
415       open (TESTFILE, ">$fnamebase.c");
416       print TESTFILE "$prepend";
417       print TESTFILE "#include <$h>\n";
418       # print TESTFILE "#undef $fname\n";
419       print TESTFILE "$rettype (*(*foobarbaz) $args = $fname;\n";
420       close (TESTFILE);
421
422       $res = compiletest ($fnamebase, "Test availability of function $fname",
423                           "Function \"$fname\" is not available.", $res);
424
425       # Generate a program to test for the type of this function.
426       open (TESTFILE, ">$fnamebase.c");
427       print TESTFILE "$prepend";
428       print TESTFILE "#include <$h>\n";
429       # print TESTFILE "#undef $fname\n";
430       print TESTFILE "extern $rettype (*(*foobarbaz) $args;\n";
431       print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
432       close (TESTFILE);
433
434       compiletest ($fnamebase, "Test for type of function $fname",
435                    "Function \"$fname\" has incorrect type.", $res);
436     } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
437       my($rettype) = "$2$3";
438       my($fname) = "$4";
439       my($args) = "$5";
440       my($res) = $missing;
441
442       # Remember that this name is allowed.
443       push @allow, $fname;
444
445       # Generate a program to test for availability of this function.
446       open (TESTFILE, ">$fnamebase.c");
447       print TESTFILE "$prepend";
448       print TESTFILE "#include <$h>\n";
449       # print TESTFILE "#undef $fname\n";
450       print TESTFILE "$rettype (*foobarbaz) $args = $fname;\n";
451       close (TESTFILE);
452
453       $res = compiletest ($fnamebase, "Test availability of function $fname",
454                           "Function \"$fname\" is not available.", $res);
455
456       # Generate a program to test for the type of this function.
457       open (TESTFILE, ">$fnamebase.c");
458       print TESTFILE "$prepend";
459       print TESTFILE "#include <$h>\n";
460       # print TESTFILE "#undef $fname\n";
461       print TESTFILE "extern $rettype (*foobarbaz) $args;\n";
462       print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
463       close (TESTFILE);
464
465       compiletest ($fnamebase, "Test for type of function $fname",
466                    "Function \"$fname\" has incorrect type.", $res);
467     } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*)/) {
468       my($type) = "$2$3";
469       my($vname) = "$4";
470       my($res) = $missing;
471
472       # Remember that this name is allowed.
473       push @allow, $vname;
474
475       # Generate a program to test for availability of this function.
476       open (TESTFILE, ">$fnamebase.c");
477       print TESTFILE "$prepend";
478       print TESTFILE "#include <$h>\n";
479       # print TESTFILE "#undef $fname\n";
480       print TESTFILE "$type *foobarbaz = &$vname;\n";
481       close (TESTFILE);
482
483       $res = compiletest ($fnamebase, "Test availability of variable $vname",
484                           "Variable \"$vname\" is not available.", $res);
485
486       # Generate a program to test for the type of this function.
487       open (TESTFILE, ">$fnamebase.c");
488       print TESTFILE "$prepend";
489       print TESTFILE "#include <$h>\n";
490       # print TESTFILE "#undef $fname\n";
491       print TESTFILE "extern $type $vname;\n";
492       close (TESTFILE);
493
494       compiletest ($fnamebase, "Test for type of variable $fname",
495                    "Variable \"$vname\" has incorrect type.", $res);
496     } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
497       my($rettype) = "$2$3";
498       my($fname) = "$4";
499       my($args) = "$5";
500       my($res) = $missing;
501
502       # Remember that this name is allowed.
503       push @allow, $fname;
504
505       # Generate a program to test for availability of this function.
506       open (TESTFILE, ">$fnamebase.c");
507       print TESTFILE "$prepend";
508       print TESTFILE "#include <$h>\n";
509       print TESTFILE "#ifndef $fname\n";
510       print TESTFILE "$rettype (*foobarbaz) $args = $fname;\n";
511       print TESTFILE "#endif\n";
512       close (TESTFILE);
513
514       $res = compiletest ($fnamebase, "Test availability of function $fname",
515                           "Function \"$fname\" is not available.", $res);
516
517       # Generate a program to test for the type of this function.
518       open (TESTFILE, ">$fnamebase.c");
519       print TESTFILE "$prepend";
520       print TESTFILE "#include <$h>\n";
521       print TESTFILE "#ifndef $fname\n";
522       print TESTFILE "extern $rettype (*foobarbaz) $args;\n";
523       print TESTFILE "extern __typeof__ (&$fname) foobarbaz;\n";
524       print TESTFILE "#endif\n";
525       close (TESTFILE);
526
527       compiletest ($fnamebase, "Test for type of function $fname",
528                    "Function \"$fname\" has incorrect type.", $res);
529     } elsif (/^macro *([^       ]*)/) {
530       my($macro) = "$1";
531
532       # Remember that this name is allowed.
533       push @allow, $macro;
534
535       # Generate a program to test for availability of this macro.
536       open (TESTFILE, ">$fnamebase.c");
537       print TESTFILE "$prepend";
538       print TESTFILE "#include <$h>\n";
539       print TESTFILE "#ifndef $macro\n";
540       print TESTFILE "# error \"Macro $macro not defined\"\n";
541       print TESTFILE "#endif\n";
542       close (TESTFILE);
543
544       compiletest ($fnamebase, "Test availability of macro $macro",
545                    "Macro \"$macro\" is not available.", $missing);
546     } elsif (/^allow *(.*)/) {
547       my($pattern) = $1;
548       push @allow, $pattern;
549       next control;
550     } elsif (/^allow-header *(.*)/) {
551       my($pattern) = $1;
552       push @allowheader, $pattern;
553       next control;
554     } else {
555       # printf ("line is `%s'\n", $_);
556       next control;
557     }
558
559     printf ("\n");
560   }
561   close (CONTROL);
562
563   # Read the data files for the header files which are allowed to be included.
564   while ($#allowheader >= 0) {
565     my($ah) = pop @allowheader;
566
567     open (ALLOW, "$CC -E -D$dialect - < data/$ah-data |");
568     acontrol: while (<ALLOW>) {
569       next acontrol if (/^#/);
570       next acontrol if (/^[     ]*$/);
571
572       if (/^element *({([^}]*)}|([^ ]*)) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*) *(.*)/) {
573         push @allow, $7;
574       } elsif (/^constant *([a-zA-Z0-9_]*) *([A-Za-z0-9_]*)?/) {
575         push @allow, $1;
576       } elsif (/^typed-constant *([a-zA-Z0-9_]*) *({([^}]*)}|([^ ]*)) *([A-Za-z0-9_]*)?/) {
577         push @allow, 1;
578       } elsif (/^type *({([^}]*)|([a-zA-Z0-9_]*))/) {
579         my($type) = "$2$3";
580
581         # Remember that this name is allowed.
582         if ($type =~ /^struct *(.*)/) {
583           push @allow, $1;
584         } elsif ($type =~ /^union *(.*)/) {
585           push @allow, $1;
586         } else {
587           push @allow, $type;
588         }
589       } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) [(][*]([a-zA-Z0-9_]*) ([(].*[)])/) {
590         push @allow, $4;
591       } elsif (/^function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
592         push @allow, $4;
593       } elsif (/^variable *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*)/) {
594         push @allow, $4;
595       } elsif (/^macro-function *({([^}]*)}|([a-zA-Z0-9_]*)) ([a-zA-Z0-9_]*) ([(].*[)])/) {
596         push @allow, $4;
597       } elsif (/^macro *([^     ]*)/) {
598         push @allow, $1;
599       } elsif (/^allow *(.*)/) {
600         push @allow, $1;
601       } elsif (/^allow-header *(.*)/) {
602         push @allowheader, $1;
603       }
604     }
605     close (ALLOW);
606   }
607
608   # Now check the namespace.
609   printf ("  Checking the namespace of \"%s\"... ", $h);
610   if ($missing) {
611     ++$skipped;
612     printf ("SKIP\n");
613   } else {
614     checknamespace ($h, $fnamebase, @allow);
615   }
616
617   printf ("\n\n");
618 }
619
620 printf "-" x 76 . "\n";
621 printf ("  Total number of tests  : %4d\n", $total);
622 printf ("  Number of failed tests : %4d (%3d%%)\n", $errors, ($errors * 100) / $total);
623 printf ("  Number of skipped tests: %4d (%3d%%)\n", $skipped, ($skipped * 100) / $total);
624
625 exit $errors != 0;