4 use File::Basename qw(basename dirname);
7 # List explicitly here the variables you want Configure to
8 # generate. Metaconfig only looks for shell variables, so you
9 # have to mention them as if they were shell variables, not
10 # %Config entries. Thus you write
12 # to ensure Configure will look for $Config{startperl}.
15 # This forces PL files to create target in same directory as PL file.
16 # This is so that make depend always knows where to find PL derivatives.
19 $file = basename($0, '.PL');
20 $file .= '.com' if $^O eq 'VMS';
22 open OUT,">$file" or die "Can't create $file: $!";
24 print "Extracting $file (with variable substitutions)\n";
26 # In this section, perl variables will be expanded during extraction.
27 # You can use $Config{...} to use Configure variables.
29 print OUT <<"!GROK!THIS!";
31 eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
32 if \$running_under_some_shell;
35 # In the following, perl variables are not expanded during extraction.
37 print OUT <<'!NO!SUBS!';
42 use File::Path qw(mkpath);
45 # Make sure read permissions for all are set:
46 if (defined umask && (umask() & 0444)) {
47 umask (umask() & ~0444);
51 use vars qw($opt_D $opt_d $opt_r $opt_l $opt_h $opt_a $opt_Q $opt_e);
52 die "-r and -a options are mutually exclusive\n" if ($opt_r and $opt_a);
53 my @inc_dirs = inc_dirs() if $opt_a;
57 my $Dest_dir = $opt_d || $Config{installsitearch};
58 die "Destination directory $Dest_dir doesn't exist or isn't a directory\n"
71 @isatype{@isatype} = (1) x @isatype;
76 @ARGV = ('-') unless @ARGV;
78 build_preamble_if_necessary();
87 my ($t, $tab, %curargs, $new, $eval_index, $dir, $name, $args, $outfile);
88 my ($incl, $incl_type, $next);
89 while (defined (my $file = next_file())) {
90 if (-l $file and -d $file) {
91 link_if_possible($file) if ($opt_l);
95 # Recover from header files with unbalanced cpp directives
99 # $eval_index goes into ``#line'' directives, to help locate syntax errors:
106 ($outfile = $file) =~ s/\.h$/.ph/ || next;
107 print "$file -> $outfile\n" unless $opt_Q;
108 if ($file =~ m|^(.*)/|) {
110 mkpath "$Dest_dir/$dir";
113 if ($opt_a) { # automagic mode: locate header file in @inc_dirs
114 foreach (@inc_dirs) {
120 open(IN,"$file") || (($Exit = 1),(warn "Can't open $file: $!\n"),next);
121 open(OUT,">$Dest_dir/$outfile") || die "Can't create $outfile: $!\n";
125 "require '_h2ph_pre.ph';\n\n",
126 "no warnings 'redefine';\n\n";
128 while (defined (local $_ = next_line($file))) {
130 if (s/^define\s+(\w+)//) {
134 s/\(\w+\s*\(\*\)\s*\(\w*\)\)\s*(-?\d+)/$1/; # (int (*)(foo_t))0
135 if (s/^\(([\w,\s]*)\)//) {
140 foreach my $arg (split(/,\s*/,$args)) {
141 $arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;
144 $args =~ s/\b(\w)/\$$1/g;
145 $args = "local($args) = \@_;\n$t ";
149 $new =~ s/(["\\])/\\$1/g; #"]);
151 $new = reindent($new);
152 $args = reindent($args);
154 $new =~ s/(['\\])/\\$1/g; #']);
157 "eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
161 "eval 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
164 print OUT "unless(defined(\&$name)) {\n sub $name $proto\{\n\t${args}eval q($new);\n }\n}\n";
170 $new = 1 if $new eq '';
171 $new = reindent($new);
172 $args = reindent($args);
174 $new =~ s/(['\\])/\\$1/g; #']);
177 print OUT $t,"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name () {",$new,";}' unless defined(\&$name);\n";
180 print OUT $t,"eval 'sub $name () {",$new,";}' unless defined(\&$name);\n";
183 # Shunt around such directives as `#define FOO FOO':
184 next if " \&$name" eq $new;
186 print OUT $t,"unless(defined(\&$name)) {\n sub $name () {\t",$new,";}\n}\n";
189 } elsif (/^(include|import|include_next)\s*[<\"](.*)[>\"]/) {
192 if (($incl_type eq 'include_next') ||
193 ($opt_e && exists($bad_file{$incl}))) {
194 $incl =~ s/\.h$/.ph/;
198 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
199 print OUT ($t, "my(\@REM);\n");
200 if ($incl_type eq 'include_next') {
202 "my(\%INCD) = map { \$INC{\$_} => 1 } ",
203 "(grep { \$_ eq \"$incl\" } ",
206 "\@REM = map { \"\$_/$incl\" } ",
207 "(grep { not exists(\$INCD{\"\$_/$incl\"})",
208 " and -f \"\$_/$incl\" } \@INC);\n");
211 "\@REM = map { \"\$_/$incl\" } ",
212 "(grep {-r \"\$_/$incl\" } \@INC);\n");
215 "require \"\$REM[0]\" if \@REM;\n");
217 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
221 "warn(\$\@) if \$\@;\n");
223 $incl =~ s/\.h$/.ph/;
224 print OUT $t,"require '$incl';\n";
226 } elsif (/^ifdef\s+(\w+)/) {
227 print OUT $t,"if(defined(&$1)) {\n";
229 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
230 } elsif (/^ifndef\s+(\w+)/) {
231 print OUT $t,"unless(defined(&$1)) {\n";
233 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
234 } elsif (s/^if\s+//) {
239 print OUT $t,"if($new) {\n";
241 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
242 } elsif (s/^elif\s+//) {
248 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
249 print OUT $t,"}\n elsif($new) {\n";
251 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
254 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
255 print OUT $t,"} else {\n";
257 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
260 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
262 } elsif(/^undef\s+(\w+)/) {
263 print OUT $t, "undef(&$1) if defined(&$1);\n";
264 } elsif(/^error\s+(".*")/) {
265 print OUT $t, "die($1);\n";
266 } elsif(/^error\s+(.*)/) {
267 print OUT $t, "die(\"", quotemeta($1), "\");\n";
268 } elsif(/^warning\s+(.*)/) {
269 print OUT $t, "warn(\"", quotemeta($1), "\");\n";
270 } elsif(/^ident\s+(.*)/) {
271 print OUT $t, "# $1\n";
273 } elsif (/^\s*(typedef\s*)?enum\s*(\s+[a-zA-Z_]\w*\s*)?/) { # { for vi
274 until(/\{[^}]*\}.*;/ || /;/) {
275 last unless defined ($next = next_line($file));
277 # drop "#define FOO FOO" in enums
278 $next =~ s/^\s*#\s*define\s+(\w+)\s+\1\s*$//;
280 print OUT "# $next\n" if $opt_D;
282 s/#\s*if.*?#\s*endif//g; # drop #ifdefs
285 next unless /^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w*)?\s?\{(.*)\}\s?([a-zA-Z_]\w*)?\s?;/;
286 (my $enum_subs = $3) =~ s/\s//g;
287 my @enum_subs = split(/,/, $enum_subs);
289 foreach my $enum (@enum_subs) {
290 my ($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;
291 $enum_value =~ s/^=//;
292 $enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);
295 "eval(\"\\n#line $eval_index $outfile\\n",
296 "sub $enum_name () \{ $enum_val; \}\") ",
297 "unless defined(\&$enum_name);\n");
301 "eval(\"sub $enum_name () \{ $enum_val; \}\") ",
302 "unless defined(\&$enum_name);\n");
305 } elsif (/^(?:__extension__\s+)?(?:extern|static)\s+(?:__)?inline(?:__)?\s+/) { # { for vi
306 # This is a hack to parse the inline functions in the glibc headers.
307 # Warning: massive kludge ahead. We suppose inline functions are mainly
308 # constructed like macros.
310 last unless defined ($next = next_line($file));
312 undef $_, last if $next =~ /__THROW\s*;/;
314 print OUT "# $next\n" if $opt_D;
315 last if $next =~ /^}|^{.*}\s*$/;
317 next if not defined; # because it's only a prototype
318 s/\b(__extension__|extern|static|(?:__)?inline(?:__)?)\b//g;
319 # violently drop #ifdefs
320 s/#\s*if.*?#\s*endif//g
321 and print OUT "# some #ifdef were dropped here -- fill in the blanks\n";
322 if (s/^(?:\w|\s|\*)*\s(\w+)\s*//) {
325 warn "name not found"; next; # shouldn't occur...
328 if (s/^\(([^()]*)\)\s*(\w+\s*)*//) {
329 for my $arg (split /,/, $1) {
330 if ($arg =~ /(\w+)\s*$/) {
338 ? "local(" . (join ',', map "\$$_", @args) . ") = \@_;\n$t "
341 my $proto = @args ? '' : '() ';
343 s/\breturn\b//g; # "return" doesn't occur in macros usually...
345 # try to find and perlify local C variables
346 our @local_variables = (); # needs to be a our(): (?{...}) bug workaround
349 my $typelist = join '|', keys %isatype;
351 (?:(?:un)?signed\s+)?
355 (?{ push @local_variables, $1 })
359 (?:(?:un)?signed\s+)?
363 (?{ push @local_variables, $1 })
367 $new =~ s/&$_\b/\$$_/g for @local_variables;
368 $new =~ s/(["\\])/\\$1/g; #"]);
369 # now that's almost like a macro (we hope)
373 $Is_converted{$file} = 1;
374 if ($opt_e && exists($bad_file{$file})) {
375 unlink($Dest_dir . '/' . $outfile);
379 queue_includes_from($file) if $opt_a;
383 if ($opt_e && (scalar(keys %bad_file) > 0)) {
384 warn "Was unable to convert the following files:\n";
385 warn "\t" . join("\n\t",sort(keys %bad_file)) . "\n";
393 $joined_args = join('|', keys(%curargs));
396 s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator
397 s/^\&([\(a-z\)]+)/$1/i; # hack for things that take the address of
398 s/^(\s+)// && do {$new .= ' '; next;};
399 s/^0X([0-9A-F]+)[UL]*//i
402 if (length $hex > 8 && !$Config{use64bitint}) {
403 # Croak if nv_preserves_uv_bits < 64 ?
404 $new .= hex(substr($hex, -8)) +
405 2**32 * hex(substr($hex, 0, -8));
406 # The above will produce "errorneus" code
407 # if the hex constant was e.g. inside UINT64_C
408 # macro, but then again, h2ph is an approximation.
410 $new .= lc("0x$hex");
413 s/^(-?\d+\.\d+E[-+]?\d+)[FL]?//i && do {$new .= $1; next;};
414 s/^(\d+)\s*[LU]*//i && do {$new .= $1; next;};
415 s/^("(\\"|[^"])*")// && do {$new .= $1; next;};
416 s/^'((\\"|[^"])*)'// && do {
418 $new .= "ord('\$$1')";
424 # replace "sizeof(foo)" with "{foo}"
425 # also, remove * (C dereference operator) to avoid perl syntax
426 # problems. Where the %sizeof array comes from is anyone's
427 # guess (c2ph?), but this at least avoids fatal syntax errors.
428 # Behavior is undefined if sizeof() delimiters are unbalanced.
429 # This code was modified to able to handle constructs like this:
430 # sizeof(*(p)), which appear in the HP-UX 10.01 header files.
431 s/^sizeof\s*\(// && do {
433 my $lvl = 1; # already saw one open paren
434 # tack { on the front, and skip it in the loop
437 # find balanced closing paren
438 while ($index <= length($_) && $lvl > 0) {
439 $lvl++ if substr($_, $index, 1) eq "(";
440 $lvl-- if substr($_, $index, 1) eq ")";
443 # tack } on the end, replacing )
444 substr($_, $index - 1, 1) = "}";
445 # remove pesky * operators within the sizeof argument
446 substr($_, 0, $index - 1) =~ s/\*//g;
450 /\(([\w\s]+)[\*\s]*\)\s*[\w\(]/ && do {
452 foreach (split /\s+/, $1) { # Make sure all the words are types,
453 unless($isatype{$_} or $_ eq 'struct' or $_ eq 'union'){
459 s/\([\w\s]+[\*\s]*\)// && next; # then eliminate them.
462 # struct/union member, including arrays:
463 s/^([_A-Z]\w*(\[[^\]]+\])?((\.|->)[_A-Z]\w*(\[[^\]]+\])?)+)//i && do {
465 $id =~ s/(\.|(->))([^\.\-]*)/->\{$3\}/g;
466 $id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);
467 while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {
470 if(exists($curargs{$index})) {
475 $id =~ s/\[\s*([^\$\&\d\]]+)\]/[$index]/;
479 s/^([_a-zA-Z]\w*)// && do {
481 if ($id eq 'struct' || $id eq 'union') {
485 } elsif ($id =~ /^((un)?signed)|(long)|(short)$/) {
486 while (s/^\s+(\w+)//) { $id .= ' ' . $1; }
491 $new .= '->' if /^[\[\{]/;
492 } elsif ($id eq 'defined') {
495 s/^\s*\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i; # cheat
497 } elsif ($isatype{$id}) {
498 if ($new =~ /{\s*$/) {
500 } elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {
504 $new .= q(').$id.q(');
507 if ($inif && $new !~ /defined\s*\($/) {
508 $new .= '(defined(&' . $id . ') ? &' . $id . ' : 0)';
517 s/^(.)// && do { if ($1 ne '#') { $new .= $1; } next;};
526 my $pre_sub_tri_graphs = 1;
528 READ: while (not eof IN) {
531 next unless length $in;
534 if ($pre_sub_tri_graphs) {
535 # Preprocess all tri-graphs
536 # including things stuck in quoted string constants.
537 $in =~ s/\?\?=/#/g; # | ??=| #|
538 $in =~ s/\?\?\!/|/g; # | ??!| ||
539 $in =~ s/\?\?'/^/g; # | ??'| ^|
540 $in =~ s/\?\?\(/[/g; # | ??(| [|
541 $in =~ s/\?\?\)/]/g; # | ??)| ]|
542 $in =~ s/\?\?\-/~/g; # | ??-| ~|
543 $in =~ s/\?\?\//\\/g; # | ??/| \|
544 $in =~ s/\?\?</{/g; # | ??<| {|
545 $in =~ s/\?\?>/}/g; # | ??>| }|
547 if ($in =~ /^\#ifdef __LANGUAGE_PASCAL__/) {
548 # Tru64 disassembler.h evilness: mixed C and Pascal.
554 if ($in =~ /^extern inline / && # Inlined assembler.
555 $^O eq 'linux' && $file =~ m!(?:^|/)asm/[^/]+\.h$!) {
561 if ($in =~ s/\\$//) { # \-newline
564 } elsif ($in =~ s/^([^"'\\\/]+)//) { # Passthrough
566 } elsif ($in =~ s/^(\\.)//) { # \...
568 } elsif ($in =~ /^'/) { # '...
569 if ($in =~ s/^('(\\.|[^'\\])*')//) {
574 } elsif ($in =~ /^"/) { # "...
575 if ($in =~ s/^("(\\.|[^"\\])*")//) {
580 } elsif ($in =~ s/^\/\/.*//) { # //...
582 } elsif ($in =~ m/^\/\*/) { # /*...
583 # C comment removal adapted from perlfaq6:
584 if ($in =~ s/^\/\*[^*]*\*+([^\/*][^*]*\*+)*\///) {
586 } else { # Incomplete /* */
589 } elsif ($in =~ s/^(\/)//) { # /...
591 } elsif ($in =~ s/^([^\'\"\\\/]+)//) {
593 } elsif ($^O eq 'linux' &&
594 $file =~ m!(?:^|/)linux/byteorder/pdp_endian\.h$! &&
595 $in =~ s!\'T KNOW!!) {
596 $out =~ s!I DON$!I_DO_NOT_KNOW!;
599 warn "Cannot parse $file:\n$in\n";
600 $bad_file{$file} = 1;
605 die "Cannot parse:\n$in\n";
610 last READ if $out =~ /\S/;
617 # Handle recursive subdirectories without getting a grotesquely big stack.
618 # Could this be implemented using File::Find?
626 if ($file eq '-' or -f $file or -l $file) {
632 print STDERR "Skipping directory `$file'\n";
637 print STDERR "Skipping `$file': not a file or directory\n";
645 # Put all the files in $directory into @ARGV for processing.
648 my ($directory) = @_;
650 $directory =~ s:/$::;
652 opendir DIR, $directory;
653 foreach (readdir DIR) {
654 next if ($_ eq '.' or $_ eq '..');
656 # expand_glob() is going to be called until $ARGV[0] isn't a
657 # directory; so push directories, and unshift everything else.
658 if (-d "$directory/$_") { push @ARGV, "$directory/$_" }
659 else { unshift @ARGV, "$directory/$_" }
665 # Given $file, a symbolic link to a directory in the C include directory,
666 # make an equivalent symbolic link in $Dest_dir, if we can figure out how.
667 # Otherwise, just duplicate the file or directory.
671 my $target = eval 'readlink($dirlink)';
673 if ($target =~ m:^\.\./: or $target =~ m:^/:) {
674 # The target of a parent or absolute link could leave the $Dest_dir
675 # hierarchy, so let's put all of the contents of $dirlink (actually,
676 # the contents of $target) into @ARGV; as a side effect down the
677 # line, $dirlink will get created as an _actual_ directory.
678 expand_glob($dirlink);
680 if (-l "$Dest_dir/$dirlink") {
681 unlink "$Dest_dir/$dirlink" or
682 print STDERR "Could not remove link $Dest_dir/$dirlink: $!\n";
685 if (eval 'symlink($target, "$Dest_dir/$dirlink")') {
686 print "Linking $target -> $Dest_dir/$dirlink\n";
688 # Make sure that the link _links_ to something:
689 if (! -e "$Dest_dir/$target") {
690 mkpath("$Dest_dir/$target", 0755) or
691 print STDERR "Could not create $Dest_dir/$target/\n";
694 print STDERR "Could not symlink $target -> $Dest_dir/$dirlink: $!\n";
700 # Push all #included files in $file onto our stack, except for STDIN
701 # and files we've already processed.
702 sub queue_includes_from
707 return if ($file eq "-");
709 open HEADER, $file or return;
710 while (defined($line = <HEADER>)) {
711 while (/\\$/) { # Handle continuation lines
716 if ($line =~ /^#\s*include\s+<(.*?)>/) {
717 push(@ARGV, $1) unless $Is_converted{$1};
724 # Determine include directories; $Config{usrinc} should be enough for (all
725 # non-GCC?) C compilers, but gcc uses an additional include directory.
728 my $from_gcc = `$Config{cc} -v 2>&1`;
729 $from_gcc =~ s:^Reading specs from (.*?)/specs\b.*:$1/include:s;
731 length($from_gcc) ? ($from_gcc, $Config{usrinc}) : ($Config{usrinc});
735 # Create "_h2ph_pre.ph", if it doesn't exist or was built by a different
737 sub build_preamble_if_necessary
739 # Increment $VERSION every time this function is modified:
741 my $preamble = "$Dest_dir/_h2ph_pre.ph";
743 # Can we skip building the preamble file?
745 # Extract version number from first line of preamble:
746 open PREAMBLE, $preamble or die "Cannot open $preamble: $!";
747 my $line = <PREAMBLE>;
748 $line =~ /(\b\d+\b)/;
749 close PREAMBLE or die "Cannot close $preamble: $!";
751 # Don't build preamble if a compatible preamble exists:
752 return if $1 == $VERSION;
755 my (%define) = _extract_cc_defines();
757 open PREAMBLE, ">$preamble" or die "Cannot open $preamble: $!";
758 print PREAMBLE "# This file was created by h2ph version $VERSION\n";
760 foreach (sort keys %define) {
762 print PREAMBLE "# $_=$define{$_}\n";
765 if ($define{$_} =~ /^(\d+)U?L{0,2}$/i) {
767 "unless (defined &$_) { sub $_() { $1 } }\n\n";
768 } elsif ($define{$_} =~ /^\w+$/) {
770 "unless (defined &$_) { sub $_() { &$define{$_} } }\n\n";
773 "unless (defined &$_) { sub $_() { \"",
774 quotemeta($define{$_}), "\" } }\n\n";
777 close PREAMBLE or die "Cannot close $preamble: $!";
781 # %Config contains information on macros that are pre-defined by the
782 # system's compiler. We need this information to make the .ph files
783 # function with perl as the .h files do with cc.
784 sub _extract_cc_defines
787 my $allsymbols = join " ",
788 @Config{'ccsymbols', 'cppsymbols', 'cppccsymbols'};
790 # Split compiler pre-definitions into `key=value' pairs:
791 foreach (split /\s+/, $allsymbols) {
792 /(.+?)=(.+)/ and $define{$1} = $2;
795 print STDERR "$_: $1 -> $2\n";
805 ##############################################################################
810 h2ph - convert .h C header files to .ph Perl header files
814 B<h2ph [-d destination directory] [-r | -a] [-l] [headerfiles]>
819 converts any C header files specified to the corresponding Perl header file
821 It is most easily run while in /usr/include:
823 cd /usr/include; h2ph * sys/*
827 cd /usr/include; h2ph * sys/* arpa/* netinet/*
831 cd /usr/include; h2ph -r -l .
833 The output files are placed in the hierarchy rooted at Perl's
834 architecture dependent library directory. You can specify a different
835 hierarchy with a B<-d> switch.
837 If run with no arguments, filters standard input to standard output.
843 =item -d destination_dir
845 Put the resulting B<.ph> files beneath B<destination_dir>, instead of
846 beneath the default Perl library location (C<$Config{'installsitsearch'}>).
850 Run recursively; if any of B<headerfiles> are directories, then run I<h2ph>
851 on all files in those directories (and their subdirectories, etc.). B<-r>
852 and B<-a> are mutually exclusive.
856 Run automagically; convert B<headerfiles>, as well as any B<.h> files
857 which they include. This option will search for B<.h> files in all
858 directories which your C compiler ordinarily uses. B<-a> and B<-r> are
863 Symbolic links will be replicated in the destination directory. If B<-l>
864 is not specified, then links are skipped over.
868 Put ``hints'' in the .ph files which will help in locating problems with
869 I<h2ph>. In those cases when you B<require> a B<.ph> file containing syntax
870 errors, instead of the cryptic
872 [ some error condition ] at (eval mmm) line nnn
874 you will see the slightly more helpful
876 [ some error condition ] at filename.ph line nnn
878 However, the B<.ph> files almost double in size when built using B<-h>.
882 Include the code from the B<.h> file as a comment in the B<.ph> file.
883 This is primarily used for debugging I<h2ph>.
887 ``Quiet'' mode; don't print out the names of the files being converted.
893 No environment variables are used.
912 The usual warnings if it can't read or write the files involved.
916 Doesn't construct the %sizeof array for you.
918 It doesn't handle all C constructs, but it does attempt to isolate
919 definitions inside evals so that you can get at the definitions
920 that it can translate.
922 It's only intended as a rough tool.
923 You may need to dicker with the files produced.
925 You have to run this program by hand; it's not run as part of the Perl
928 Doesn't handle complicated expressions built piecemeal, a la:
938 Doesn't necessarily locate all of your C compiler's internally-defined
945 close OUT or die "Can't close $file: $!";
946 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
947 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';