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, $incl_quote, $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 qw(redefine misc);\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 = "my($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*([<\"])(.*)[>\"]/) {
193 if (($incl_type eq 'include_next') ||
194 ($opt_e && exists($bad_file{$incl}))) {
195 $incl =~ s/\.h$/.ph/;
199 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
200 print OUT ($t, "my(\@REM);\n");
201 if ($incl_type eq 'include_next') {
203 "my(\%INCD) = map { \$INC{\$_} => 1 } ",
204 "(grep { \$_ eq \"$incl\" } ",
207 "\@REM = map { \"\$_/$incl\" } ",
208 "(grep { not exists(\$INCD{\"\$_/$incl\"})",
209 " and -f \"\$_/$incl\" } \@INC);\n");
212 "\@REM = map { \"\$_/$incl\" } ",
213 "(grep {-r \"\$_/$incl\" } \@INC);\n");
216 "require \"\$REM[0]\" if \@REM;\n");
218 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
222 "warn(\$\@) if \$\@;\n");
224 $incl =~ s/\.h$/.ph/;
225 # copy the prefix in the quote syntax (#include "x.h") case
226 if ($incl !~ m|/| && $incl_quote eq q{"} && $file =~ m|^(.*)/|) {
229 print OUT $t,"require '$incl';\n";
231 } elsif (/^ifdef\s+(\w+)/) {
232 print OUT $t,"if(defined(&$1)) {\n";
234 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
235 } elsif (/^ifndef\s+(\w+)/) {
236 print OUT $t,"unless(defined(&$1)) {\n";
238 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
239 } elsif (s/^if\s+//) {
244 print OUT $t,"if($new) {\n";
246 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
247 } elsif (s/^elif\s+//) {
253 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
254 print OUT $t,"}\n elsif($new) {\n";
256 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
259 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
260 print OUT $t,"} else {\n";
262 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
265 $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
267 } elsif(/^undef\s+(\w+)/) {
268 print OUT $t, "undef(&$1) if defined(&$1);\n";
269 } elsif(/^error\s+(".*")/) {
270 print OUT $t, "die($1);\n";
271 } elsif(/^error\s+(.*)/) {
272 print OUT $t, "die(\"", quotemeta($1), "\");\n";
273 } elsif(/^warning\s+(.*)/) {
274 print OUT $t, "warn(\"", quotemeta($1), "\");\n";
275 } elsif(/^ident\s+(.*)/) {
276 print OUT $t, "# $1\n";
278 } elsif (/^\s*(typedef\s*)?enum\s*(\s+[a-zA-Z_]\w*\s*)?/) { # { for vi
279 until(/\{[^}]*\}.*;/ || /;/) {
280 last unless defined ($next = next_line($file));
282 # drop "#define FOO FOO" in enums
283 $next =~ s/^\s*#\s*define\s+(\w+)\s+\1\s*$//;
284 # #defines in enums (aliases)
285 $next =~ s/^\s*#\s*define\s+(\w+)\s+(\w+)\s*$/$1 = $2,/;
287 print OUT "# $next\n" if $opt_D;
289 s/#\s*if.*?#\s*endif//g; # drop #ifdefs
292 next unless /^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w*)?\s?\{(.*)\}\s?([a-zA-Z_]\w*)?\s?;/;
293 (my $enum_subs = $3) =~ s/\s//g;
294 my @enum_subs = split(/,/, $enum_subs);
296 foreach my $enum (@enum_subs) {
297 my ($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;
299 $enum_value =~ s/^=//;
300 $enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);
303 "eval(\"\\n#line $eval_index $outfile\\n",
304 "sub $enum_name () \{ $enum_val; \}\") ",
305 "unless defined(\&$enum_name);\n");
309 "eval(\"sub $enum_name () \{ $enum_val; \}\") ",
310 "unless defined(\&$enum_name);\n");
313 } elsif (/^(?:__extension__\s+)?(?:extern|static)\s+(?:__)?inline(?:__)?\s+/
314 and !/;\s*$/ and !/{\s*}\s*$/)
316 # This is a hack to parse the inline functions in the glibc headers.
317 # Warning: massive kludge ahead. We suppose inline functions
318 # are mainly constructed like macros.
320 last unless defined ($next = next_line($file));
322 undef $_, last if $next =~ /__THROW\s*;/
323 or $next =~ /^(__extension__|extern|static)\b/;
325 print OUT "# $next\n" if $opt_D;
326 last if $next =~ /^}|^{.*}\s*$/;
328 next if not defined; # because it's only a prototype
329 s/\b(__extension__|extern|static|(?:__)?inline(?:__)?)\b//g;
330 # violently drop #ifdefs
331 s/#\s*if.*?#\s*endif//g
332 and print OUT "# some #ifdef were dropped here -- fill in the blanks\n";
333 if (s/^(?:\w|\s|\*)*\s(\w+)\s*//) {
336 warn "name not found"; next; # shouldn't occur...
339 if (s/^\(([^()]*)\)\s*(\w+\s*)*//) {
340 for my $arg (split /,/, $1) {
341 if ($arg =~ /(\w+)\s*$/) {
349 ? "my(" . (join ',', map "\$$_", @args) . ") = \@_;\n$t "
352 my $proto = @args ? '' : '() ';
354 s/\breturn\b//g; # "return" doesn't occur in macros usually...
356 # try to find and perlify local C variables
357 our @local_variables = (); # needs to be a our(): (?{...}) bug workaround
360 my $typelist = join '|', keys %isatype;
362 (?:(?:__)?const(?:__)?\s+)?
363 (?:(?:un)?signed\s+)?
367 (?{ push @local_variables, $1 })
371 (?:(?:__)?const(?:__)?\s+)?
372 (?:(?:un)?signed\s+)?
376 (?{ push @local_variables, $1 })
380 $new =~ s/&$_\b/\$$_/g for @local_variables;
381 $new =~ s/(["\\])/\\$1/g; #"]);
382 # now that's almost like a macro (we hope)
386 $Is_converted{$file} = 1;
387 if ($opt_e && exists($bad_file{$file})) {
388 unlink($Dest_dir . '/' . $outfile);
392 queue_includes_from($file) if $opt_a;
396 if ($opt_e && (scalar(keys %bad_file) > 0)) {
397 warn "Was unable to convert the following files:\n";
398 warn "\t" . join("\n\t",sort(keys %bad_file)) . "\n";
404 $new = '"(assembly code)"' and return if /\b__asm__\b/; # freak out.
407 $joined_args = join('|', keys(%curargs));
410 s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator
411 s/^\&([\(a-z\)]+)/$1/i; # hack for things that take the address of
412 s/^(\s+)// && do {$new .= ' '; next;};
413 s/^0X([0-9A-F]+)[UL]*//i
416 if (length $hex > 8 && !$Config{use64bitint}) {
417 # Croak if nv_preserves_uv_bits < 64 ?
418 $new .= hex(substr($hex, -8)) +
419 2**32 * hex(substr($hex, 0, -8));
420 # The above will produce "errorneus" code
421 # if the hex constant was e.g. inside UINT64_C
422 # macro, but then again, h2ph is an approximation.
424 $new .= lc("0x$hex");
427 s/^(-?\d+\.\d+E[-+]?\d+)[FL]?//i && do {$new .= $1; next;};
428 s/^(\d+)\s*[LU]*//i && do {$new .= $1; next;};
429 s/^("(\\"|[^"])*")// && do {$new .= $1; next;};
430 s/^'((\\"|[^"])*)'// && do {
432 $new .= "ord('\$$1')";
438 # replace "sizeof(foo)" with "{foo}"
439 # also, remove * (C dereference operator) to avoid perl syntax
440 # problems. Where the %sizeof array comes from is anyone's
441 # guess (c2ph?), but this at least avoids fatal syntax errors.
442 # Behavior is undefined if sizeof() delimiters are unbalanced.
443 # This code was modified to able to handle constructs like this:
444 # sizeof(*(p)), which appear in the HP-UX 10.01 header files.
445 s/^sizeof\s*\(// && do {
447 my $lvl = 1; # already saw one open paren
448 # tack { on the front, and skip it in the loop
451 # find balanced closing paren
452 while ($index <= length($_) && $lvl > 0) {
453 $lvl++ if substr($_, $index, 1) eq "(";
454 $lvl-- if substr($_, $index, 1) eq ")";
457 # tack } on the end, replacing )
458 substr($_, $index - 1, 1) = "}";
459 # remove pesky * operators within the sizeof argument
460 substr($_, 0, $index - 1) =~ s/\*//g;
464 /\(([\w\s]+)[\*\s]*\)\s*[\w\(]/ && do {
466 foreach (split /\s+/, $1) { # Make sure all the words are types,
467 unless($isatype{$_} or $_ eq 'struct' or $_ eq 'union'){
473 s/\([\w\s]+[\*\s]*\)// && next; # then eliminate them.
476 # struct/union member, including arrays:
477 s/^([_A-Z]\w*(\[[^\]]+\])?((\.|->)[_A-Z]\w*(\[[^\]]+\])?)+)//i && do {
479 $id =~ s/(\.|(->))([^\.\-]*)/->\{$3\}/g;
480 $id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);
481 while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {
484 if(exists($curargs{$index})) {
489 $id =~ s/\[\s*([^\$\&\d\]]+)\]/[$index]/;
493 s/^([_a-zA-Z]\w*)// && do {
495 if ($id eq 'struct' || $id eq 'union') {
499 } elsif ($id =~ /^((un)?signed)|(long)|(short)$/) {
500 while (s/^\s+(\w+)//) { $id .= ' ' . $1; }
505 $new .= '->' if /^[\[\{]/;
506 } elsif ($id eq 'defined') {
509 s/^\s*\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i; # cheat
511 } elsif ($isatype{$id}) {
512 if ($new =~ /{\s*$/) {
514 } elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {
518 $new .= q(').$id.q(');
521 if ($inif && $new !~ /defined\s*\($/) {
522 $new .= '(defined(&' . $id . ') ? &' . $id . ' : undef)';
531 s/^(.)// && do { if ($1 ne '#') { $new .= $1; } next;};
540 my $pre_sub_tri_graphs = 1;
542 READ: while (not eof IN) {
545 next unless length $in;
548 if ($pre_sub_tri_graphs) {
549 # Preprocess all tri-graphs
550 # including things stuck in quoted string constants.
551 $in =~ s/\?\?=/#/g; # | ??=| #|
552 $in =~ s/\?\?\!/|/g; # | ??!| ||
553 $in =~ s/\?\?'/^/g; # | ??'| ^|
554 $in =~ s/\?\?\(/[/g; # | ??(| [|
555 $in =~ s/\?\?\)/]/g; # | ??)| ]|
556 $in =~ s/\?\?\-/~/g; # | ??-| ~|
557 $in =~ s/\?\?\//\\/g; # | ??/| \|
558 $in =~ s/\?\?</{/g; # | ??<| {|
559 $in =~ s/\?\?>/}/g; # | ??>| }|
561 if ($in =~ /^\#ifdef __LANGUAGE_PASCAL__/) {
562 # Tru64 disassembler.h evilness: mixed C and Pascal.
569 if ($in =~ /^extern inline / && # Inlined assembler.
570 $^O eq 'linux' && $file =~ m!(?:^|/)asm/[^/]+\.h$!) {
577 if ($in =~ s/\\$//) { # \-newline
580 } elsif ($in =~ s/^([^"'\\\/]+)//) { # Passthrough
582 } elsif ($in =~ s/^(\\.)//) { # \...
584 } elsif ($in =~ /^'/) { # '...
585 if ($in =~ s/^('(\\.|[^'\\])*')//) {
590 } elsif ($in =~ /^"/) { # "...
591 if ($in =~ s/^("(\\.|[^"\\])*")//) {
596 } elsif ($in =~ s/^\/\/.*//) { # //...
598 } elsif ($in =~ m/^\/\*/) { # /*...
599 # C comment removal adapted from perlfaq6:
600 if ($in =~ s/^\/\*[^*]*\*+([^\/*][^*]*\*+)*\///) {
602 } else { # Incomplete /* */
605 } elsif ($in =~ s/^(\/)//) { # /...
607 } elsif ($in =~ s/^([^\'\"\\\/]+)//) {
609 } elsif ($^O eq 'linux' &&
610 $file =~ m!(?:^|/)linux/byteorder/pdp_endian\.h$! &&
611 $in =~ s!\'T KNOW!!) {
612 $out =~ s!I DON$!I_DO_NOT_KNOW!;
615 warn "Cannot parse $file:\n$in\n";
616 $bad_file{$file} = 1;
621 die "Cannot parse:\n$in\n";
626 last READ if $out =~ /\S/;
633 # Handle recursive subdirectories without getting a grotesquely big stack.
634 # Could this be implemented using File::Find?
642 if ($file eq '-' or -f $file or -l $file) {
648 print STDERR "Skipping directory `$file'\n";
653 print STDERR "Skipping `$file': not a file or directory\n";
661 # Put all the files in $directory into @ARGV for processing.
664 my ($directory) = @_;
666 $directory =~ s:/$::;
668 opendir DIR, $directory;
669 foreach (readdir DIR) {
670 next if ($_ eq '.' or $_ eq '..');
672 # expand_glob() is going to be called until $ARGV[0] isn't a
673 # directory; so push directories, and unshift everything else.
674 if (-d "$directory/$_") { push @ARGV, "$directory/$_" }
675 else { unshift @ARGV, "$directory/$_" }
681 # Given $file, a symbolic link to a directory in the C include directory,
682 # make an equivalent symbolic link in $Dest_dir, if we can figure out how.
683 # Otherwise, just duplicate the file or directory.
687 my $target = eval 'readlink($dirlink)';
689 if ($target =~ m:^\.\./: or $target =~ m:^/:) {
690 # The target of a parent or absolute link could leave the $Dest_dir
691 # hierarchy, so let's put all of the contents of $dirlink (actually,
692 # the contents of $target) into @ARGV; as a side effect down the
693 # line, $dirlink will get created as an _actual_ directory.
694 expand_glob($dirlink);
696 if (-l "$Dest_dir/$dirlink") {
697 unlink "$Dest_dir/$dirlink" or
698 print STDERR "Could not remove link $Dest_dir/$dirlink: $!\n";
701 if (eval 'symlink($target, "$Dest_dir/$dirlink")') {
702 print "Linking $target -> $Dest_dir/$dirlink\n";
704 # Make sure that the link _links_ to something:
705 if (! -e "$Dest_dir/$target") {
706 mkpath("$Dest_dir/$target", 0755) or
707 print STDERR "Could not create $Dest_dir/$target/\n";
710 print STDERR "Could not symlink $target -> $Dest_dir/$dirlink: $!\n";
716 # Push all #included files in $file onto our stack, except for STDIN
717 # and files we've already processed.
718 sub queue_includes_from
723 return if ($file eq "-");
725 open HEADER, $file or return;
726 while (defined($line = <HEADER>)) {
727 while (/\\$/) { # Handle continuation lines
732 if ($line =~ /^#\s*include\s+([<"])(.*?)[>"]/) {
733 my ($delimiter, $new_file) = ($1, $2);
734 # copy the prefix in the quote syntax (#include "x.h") case
735 if ($delimiter eq q{"} && $file =~ m|^(.*)/|) {
736 $new_file = "$1/$new_file";
738 push(@ARGV, $new_file) unless $Is_converted{$new_file};
745 # Determine include directories; $Config{usrinc} should be enough for (all
746 # non-GCC?) C compilers, but gcc uses additional include directories.
749 my $from_gcc = `LC_ALL=C $Config{cc} -v 2>&1`;
750 if( !( $from_gcc =~ s:^Reading specs from (.*?)/specs\b.*:$1/include:s ) )
752 $from_gcc = `LC_ALL=C $Config{cc} -print-search-dirs 2>&1`;
753 if ( !($from_gcc =~ s/^install:\s*([^\s]+[^\s\/])([\s\/]*).*$/$1\/include/s) )
758 length($from_gcc) ? ($from_gcc, $from_gcc . "-fixed", $Config{usrinc}) : ($Config{usrinc});
762 # Create "_h2ph_pre.ph", if it doesn't exist or was built by a different
764 sub build_preamble_if_necessary
766 # Increment $VERSION every time this function is modified:
768 my $preamble = "$Dest_dir/_h2ph_pre.ph";
770 # Can we skip building the preamble file?
772 # Extract version number from first line of preamble:
773 open PREAMBLE, $preamble or die "Cannot open $preamble: $!";
774 my $line = <PREAMBLE>;
775 $line =~ /(\b\d+\b)/;
776 close PREAMBLE or die "Cannot close $preamble: $!";
778 # Don't build preamble if a compatible preamble exists:
779 return if $1 == $VERSION;
782 my (%define) = _extract_cc_defines();
784 open PREAMBLE, ">$preamble" or die "Cannot open $preamble: $!";
785 print PREAMBLE "# This file was created by h2ph version $VERSION\n";
787 foreach (sort keys %define) {
789 print PREAMBLE "# $_=$define{$_}\n";
791 if ($define{$_} =~ /^\((.*)\)$/) {
792 # parenthesized value: d=(v)
795 if ($define{$_} =~ /^([+-]?(\d+)?\.\d+([eE][+-]?\d+)?)[FL]?$/) {
798 "unless (defined &$_) { sub $_() { $1 } }\n\n";
799 } elsif ($define{$_} =~ /^([+-]?\d+)U?L{0,2}$/i) {
802 "unless (defined &$_) { sub $_() { $1 } }\n\n";
803 } elsif ($define{$_} =~ /^\w+$/) {
805 "unless (defined &$_) { sub $_() { &$define{$_} } }\n\n";
808 "unless (defined &$_) { sub $_() { \"",
809 quotemeta($define{$_}), "\" } }\n\n";
812 print PREAMBLE "\n1;\n"; # avoid 'did not return a true value' when empty
813 close PREAMBLE or die "Cannot close $preamble: $!";
817 # %Config contains information on macros that are pre-defined by the
818 # system's compiler. We need this information to make the .ph files
819 # function with perl as the .h files do with cc.
820 sub _extract_cc_defines
823 my $allsymbols = join " ",
824 @Config{'ccsymbols', 'cppsymbols', 'cppccsymbols'};
826 # Split compiler pre-definitions into `key=value' pairs:
827 while ($allsymbols =~ /([^\s]+)=((\\\s|[^\s])+)/g) {
830 print STDERR "$_: $1 -> $2\n";
840 ##############################################################################
845 h2ph - convert .h C header files to .ph Perl header files
849 B<h2ph [-d destination directory] [-r | -a] [-l] [headerfiles]>
854 converts any C header files specified to the corresponding Perl header file
856 It is most easily run while in /usr/include:
858 cd /usr/include; h2ph * sys/*
862 cd /usr/include; h2ph * sys/* arpa/* netinet/*
866 cd /usr/include; h2ph -r -l .
868 The output files are placed in the hierarchy rooted at Perl's
869 architecture dependent library directory. You can specify a different
870 hierarchy with a B<-d> switch.
872 If run with no arguments, filters standard input to standard output.
878 =item -d destination_dir
880 Put the resulting B<.ph> files beneath B<destination_dir>, instead of
881 beneath the default Perl library location (C<$Config{'installsitearch'}>).
885 Run recursively; if any of B<headerfiles> are directories, then run I<h2ph>
886 on all files in those directories (and their subdirectories, etc.). B<-r>
887 and B<-a> are mutually exclusive.
891 Run automagically; convert B<headerfiles>, as well as any B<.h> files
892 which they include. This option will search for B<.h> files in all
893 directories which your C compiler ordinarily uses. B<-a> and B<-r> are
898 Symbolic links will be replicated in the destination directory. If B<-l>
899 is not specified, then links are skipped over.
903 Put ``hints'' in the .ph files which will help in locating problems with
904 I<h2ph>. In those cases when you B<require> a B<.ph> file containing syntax
905 errors, instead of the cryptic
907 [ some error condition ] at (eval mmm) line nnn
909 you will see the slightly more helpful
911 [ some error condition ] at filename.ph line nnn
913 However, the B<.ph> files almost double in size when built using B<-h>.
917 Include the code from the B<.h> file as a comment in the B<.ph> file.
918 This is primarily used for debugging I<h2ph>.
922 ``Quiet'' mode; don't print out the names of the files being converted.
928 No environment variables are used.
947 The usual warnings if it can't read or write the files involved.
951 Doesn't construct the %sizeof array for you.
953 It doesn't handle all C constructs, but it does attempt to isolate
954 definitions inside evals so that you can get at the definitions
955 that it can translate.
957 It's only intended as a rough tool.
958 You may need to dicker with the files produced.
960 You have to run this program by hand; it's not run as part of the Perl
963 Doesn't handle complicated expressions built piecemeal, a la:
973 Doesn't necessarily locate all of your C compiler's internally-defined
980 close OUT or die "Can't close $file: $!";
981 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
982 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';