[perl5.git] / utils / h2ph.PL

#!/usr/local/bin/perl

use Config;
use File::Basename qw(basename dirname);
use Cwd;

# List explicitly here the variables you want Configure to
# generate.  Metaconfig only looks for shell variables, so you
# have to mention them as if they were shell variables, not
# %Config entries.  Thus you write
#  $startperl
# to ensure Configure will look for $Config{startperl}.
# Wanted:  $archlibexp

# This forces PL files to create target in same directory as PL file.
# This is so that make depend always knows where to find PL derivatives.
$origdir = cwd;
chdir dirname($0);
$file = basename($0, '.PL');
$file .= '.com' if $^O eq 'VMS';

open OUT,">$file" or die "Can't create $file: $!";

print "Extracting $file (with variable substitutions)\n";

# In this section, perl variables will be expanded during extraction.
# You can use $Config{...} to use Configure variables.

print OUT <<"!GROK!THIS!";
$Config{startperl}
    eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
	if \$running_under_some_shell;
!GROK!THIS!

# In the following, perl variables are not expanded during extraction.

print OUT <<'!NO!SUBS!';

use Config;
use File::Path qw(mkpath);
use Getopt::Std;

getopts('Dd:rlhaQ');
die "-r and -a options are mutually exclusive\n" if ($opt_r and $opt_a);
@inc_dirs = inc_dirs() if $opt_a;

my $Exit = 0;

my $Dest_dir = $opt_d || $Config{installsitearch};
die "Destination directory $Dest_dir doesn't exist or isn't a directory\n"
    unless -d $Dest_dir;

@isatype = split(' ',<<END);
	char	uchar	u_char
	short	ushort	u_short
	int	uint	u_int
	long	ulong	u_long
	FILE	key_t	caddr_t
END

@isatype{@isatype} = (1) x @isatype;
$inif = 0;

@ARGV = ('-') unless @ARGV;

while (defined ($file = next_file())) {
    if (-l $file and -d $file) {
        link_if_possible($file) if ($opt_l);
        next;
    }

    # Recover from header files with unbalanced cpp directives
    $t = '';
    $tab = 0;

    # $eval_index goes into ``#line'' directives, to help locate syntax errors:
    $eval_index = 1;

    if ($file eq '-') {
	open(IN, "-");
	open(OUT, ">-");
    } else {
	($outfile = $file) =~ s/\.h$/.ph/ || next;
	print "$file -> $outfile\n" unless $opt_Q;
	if ($file =~ m|^(.*)/|) {
	    $dir = $1;
	    mkpath "$Dest_dir/$dir";
	}

	if ($opt_a) { # automagic mode:  locate header file in @inc_dirs
	    foreach (@inc_dirs) {
		chdir $_;
		last if -f $file;
	    }
	}

	open(IN,"$file") || (($Exit = 1),(warn "Can't open $file: $!\n"),next);
	open(OUT,">$Dest_dir/$outfile") || die "Can't create $outfile: $!\n";
    }
    while (<IN>) {
	chop;
	while (/\\$/) {
	    chop;
	    $_ .= <IN>;
	    chop;
	}
	print OUT "# $_\n" if $opt_D;
	if (s:/\*:\200:g) {
	    s:\*/:\201:g;
	    s/\200[^\201]*\201//g;	# delete single line comments
	    if (s/\200.*//) {		# begin multi-line comment?
		$_ .= '/*';
		$_ .= <IN>;
		redo;
	    }
	}
	if (s/^\s*\#\s*//) {
	    if (s/^define\s+(\w+)//) {
		$name = $1;
		$new = '';
		s/\s+$//;
		if (s/^\(([\w,\s]*)\)//) {
		    $args = $1;
    	    	    my $proto = '() ';
		    if ($args ne '') {
    	    	    	$proto = '';
			foreach $arg (split(/,\s*/,$args)) {
			    $arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;
			    $curargs{$arg} = 1;
			}
			$args =~ s/\b(\w)/\$$1/g;
			$args = "local($args) = \@_;\n$t    ";
		    }
		    s/^\s+//;
		    expr();
		    $new =~ s/(["\\])/\\$1/g;       #"]);
		    $new = reindent($new);
		    $args = reindent($args);
		    if ($t ne '') {
			$new =~ s/(['\\])/\\$1/g;   #']);
			if ($opt_h) {
			    print OUT $t,
                            "eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name $proto\{\n$t    ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
                            $eval_index++;
			} else {
			    print OUT $t,
                            "eval 'sub $name $proto\{\n$t    ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
			}
		    } else {
                      print OUT "unless(defined(\&$name)) {\n    sub $name $proto\{\n\t${args}eval q($new);\n    }\n}\n";
		    }
		    %curargs = ();
		} else {
		    s/^\s+//;
		    expr();
		    $new = 1 if $new eq '';
		    $new = reindent($new);
		    $args = reindent($args);
		    if ($t ne '') {
			$new =~ s/(['\\])/\\$1/g;        #']);
			if ($opt_h) {
			    print OUT $t,"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name () {",$new,";}' unless defined(\&$name);\n";
			    $eval_index++;
			} else {
			    print OUT $t,"eval 'sub $name () {",$new,";}' unless defined(\&$name);\n";
			}
		    } else {
                      print OUT $t,"unless(defined(\&$name)) {\n    sub $name () {\t",$new,";}\n}\n";
		    }
		}
	    } elsif (/^(include|import)\s*[<"](.*)[>"]/) {
		($incl = $2) =~ s/\.h$/.ph/;
		print OUT $t,"require '$incl';\n";
	    } elsif(/^include_next\s*[<"](.*)[>"]/) {
		($incl = $1) =~ s/\.h$/.ph/;
		print OUT ($t,
			   "eval {\n");
                $tab += 4;
                $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
		print OUT ($t,
			   "my(\%INCD) = map { \$INC{\$_} => 1 } ",
			   "(grep { \$_ eq \"$incl\" } keys(\%INC));\n");
		print OUT ($t,
			   "my(\@REM) = map { \"\$_/$incl\" } ",
			   "(grep { not exists(\$INCD{\"\$_/$incl\"})",
			   "and -f \"\$_/$incl\" } \@INC);\n");
		print OUT ($t,
			   "require \"\$REM[0]\" if \@REM;\n");
                $tab -= 4;
                $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
                print OUT ($t,
			   "};\n");
		print OUT ($t,
			   "warn(\$\@) if \$\@;\n");
	    } elsif (/^ifdef\s+(\w+)/) {
		print OUT $t,"if(defined(&$1)) {\n";
		$tab += 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	    } elsif (/^ifndef\s+(\w+)/) {
		print OUT $t,"unless(defined(&$1)) {\n";
		$tab += 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	    } elsif (s/^if\s+//) {
		$new = '';
		$inif = 1;
		expr();
		$inif = 0;
		print OUT $t,"if($new) {\n";
		$tab += 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	    } elsif (s/^elif\s+//) {
		$new = '';
		$inif = 1;
		expr();
		$inif = 0;
		$tab -= 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
		print OUT $t,"}\n elsif($new) {\n";
		$tab += 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	    } elsif (/^else/) {
		$tab -= 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
		print OUT $t,"} else {\n";
		$tab += 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	    } elsif (/^endif/) {
		$tab -= 4;
		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
		print OUT $t,"}\n";
	    } elsif(/^undef\s+(\w+)/) {
		print OUT $t, "undef(&$1) if defined(&$1);\n";
	    } elsif(/^error\s+(.*)/) {
		print OUT $t, "die(\"$1\");\n";
	    } elsif(/^warning\s+(.*)/) {
		print OUT $t, "warn(\"$1\");\n";
	    } elsif(/^ident\s+(.*)/) {
		print OUT $t, "# $1\n";
	    }
 	} elsif(/^\s*(typedef\s*)?enum\s*(\s+[a-zA-Z_]\w*\s*)?\{/) {
	    until(/\}.*?;/) {
		chomp($next = <IN>);
		$_ .= $next;
		print OUT "# $next\n" if $opt_D;
	    }
	    s@/\*.*?\*/@@g;
	    s/\s+/ /g;
	    /^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w*)?\s?\{(.*)\}\s?([a-zA-Z_]\w*)?\s?;/;
	    ($enum_subs = $3) =~ s/\s//g;
	    @enum_subs = split(/,/, $enum_subs);
	    $enum_val = -1;
	    for $enum (@enum_subs) {
		($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;
		$enum_value =~ s/^=//;
		$enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);
		if ($opt_h) {
		    print OUT ($t,
			       "eval(\"\\n#line $eval_index $outfile\\n",
			       "sub $enum_name () \{ $enum_val; \}\") ",
			       "unless defined(\&$enum_name);\n");
		    ++ $eval_index;
		} else {
		    print OUT ($t,
			       "eval(\"sub $enum_name () \{ $enum_val; \}\") ",
			       "unless defined(\&$enum_name);\n");
		}
	    }
	}
    }
    print OUT "1;\n";

    $is_converted{$file} = 1;
    queue_includes_from($file) if ($opt_a);
}

exit $Exit;

sub reindent($) {
    my($text) = shift;
    $text =~ s/\n/\n    /g;
    $text =~ s/        /\t/g;
    $text;
}

sub expr {
    if(keys(%curargs)) {
	my($joined_args) = join('|', keys(%curargs));
    }
    while ($_ ne '') {
	s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator
	s/^\&([\(a-z\)]+)/$1/i;	# hack for things that take the address of
	s/^(\s+)//		&& do {$new .= ' '; next;};
	s/^(0X[0-9A-F]+)[UL]*//i	&& do {$new .= lc($1); next;};
	s/^(-?\d+\.\d+E[-+]\d+)F?//i	&& do {$new .= $1; next;};
	s/^(\d+)\s*[LU]*//i	&& do {$new .= $1; next;};
	s/^("(\\"|[^"])*")//	&& do {$new .= $1; next;};
	s/^'((\\"|[^"])*)'//	&& do {
	    if ($curargs{$1}) {
		$new .= "ord('\$$1')";
	    } else {
		$new .= "ord('$1')";
	    }
	    next;
	};
        # replace "sizeof(foo)" with "{foo}"
        # also, remove * (C dereference operator) to avoid perl syntax
        # problems.  Where the %sizeof array comes from is anyone's
        # guess (c2ph?), but this at least avoids fatal syntax errors.
        # Behavior is undefined if sizeof() delimiters are unbalanced.
        # This code was modified to able to handle constructs like this:
        #   sizeof(*(p)), which appear in the HP-UX 10.01 header files.
        s/^sizeof\s*\(// && do {
            $new .= '$sizeof';
            my $lvl = 1;  # already saw one open paren
            # tack { on the front, and skip it in the loop
            $_ = "{" . "$_";
            my $index = 1;
            # find balanced closing paren
            while ($index <= length($_) && $lvl > 0) {
                $lvl++ if substr($_, $index, 1) eq "(";
                $lvl-- if substr($_, $index, 1) eq ")";
                $index++;
            }
            # tack } on the end, replacing )
            substr($_, $index - 1, 1) = "}";
            # remove pesky * operators within the sizeof argument
            substr($_, 0, $index - 1) =~ s/\*//g;
            next;
        };
	# Eliminate typedefs
	/\(([\w\s]+)[\*\s]*\)\s*[\w\(]/ && do {
	    foreach (split /\s+/, $1) {  # Make sure all the words are types,
		last unless ($isatype{$_} or $_ eq 'struct');
	    }
	    s/\([\w\s]+[\*\s]*\)// && next;      # then eliminate them.
	};
	# struct/union member, including arrays:
	s/^([_A-Z]\w*(\[[^\]]+\])?((\.|->)[_A-Z]\w*(\[[^\]]+\])?)+)//i && do {
	    $id = $1;
	    $id =~ s/(\.|(->))([^\.\-]*)/->\{$3\}/g;
	    $id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);
	    while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {
		my($index) = $1;
		$index =~ s/\s//g;
		if(exists($curargs{$index})) {
		    $index = "\$$index";
		} else {
		    $index = "&$index";
		}
		$id =~ s/\[\s*([^\$\&\d\]]+)\]/[$index]/;
	    }
	    $new .= " (\$$id)";
	};
	s/^([_a-zA-Z]\w*)//	&& do {
	    $id = $1;
	    if ($id eq 'struct') {
		s/^\s+(\w+)//;
		$id .= ' ' . $1;
		$isatype{$id} = 1;
	    } elsif ($id =~ /^((un)?signed)|(long)|(short)$/) {
		while (s/^\s+(\w+)//) { $id .= ' ' . $1; }
		$isatype{$id} = 1;
	    }
	    if ($curargs{$id}) {
		$new .= "\$$id";
		$new .= '->' if /^[\[\{]/;
	    } elsif ($id eq 'defined') {
		$new .= 'defined';
	    } elsif (/^\(/) {
		s/^\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i;	# cheat
		$new .= " &$id";
	    } elsif ($isatype{$id}) {
		if ($new =~ /{\s*$/) {
		    $new .= "'$id'";
		} elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {
		    $new =~ s/\(\s*$//;
		    s/^[\s*]*\)//;
		} else {
		    $new .= q(').$id.q(');
		}
	    } else {
		if ($inif && $new !~ /defined\s*\($/) {
		    $new .= '(defined(&' . $id . ') ? &' . $id . ' : 0)';
		} elsif (/^\[/) {
		    $new .= " \$$id";
		} else {
		    $new .= ' &' . $id;
		}
	    }
	    next;
	};
	s/^(.)// && do { if ($1 ne '#') { $new .= $1; } next;};
    }
}


# Handle recursive subdirectories without getting a grotesquely big stack.
# Could this be implemented using File::Find?
sub next_file
{
    my $file;

    while (@ARGV) {
        $file = shift @ARGV;

        if ($file eq '-' or -f $file or -l $file) {
            return $file;
        } elsif (-d $file) {
            if ($opt_r) {
                expand_glob($file);
            } else {
                print STDERR "Skipping directory `$file'\n";
            }
        } elsif ($opt_a) {
            return $file;
        } else {
            print STDERR "Skipping `$file':  not a file or directory\n";
        }
    }

    return undef;
}


# Put all the files in $directory into @ARGV for processing.
sub expand_glob
{
    my ($directory)  = @_;

    $directory =~ s:/$::;

    opendir DIR, $directory;
        foreach (readdir DIR) {
            next if ($_ eq '.' or $_ eq '..');

            # expand_glob() is going to be called until $ARGV[0] isn't a
            # directory; so push directories, and unshift everything else.
            if (-d "$directory/$_") { push    @ARGV, "$directory/$_" }
            else                    { unshift @ARGV, "$directory/$_" }
        }
    closedir DIR;
}


# Given $file, a symbolic link to a directory in the C include directory,
# make an equivalent symbolic link in $Dest_dir, if we can figure out how.
# Otherwise, just duplicate the file or directory.
sub link_if_possible
{
    my ($dirlink)  = @_;
    my $target  = eval 'readlink($dirlink)';

    if ($target =~ m:^\.\./: or $target =~ m:^/:) {
        # The target of a parent or absolute link could leave the $Dest_dir
        # hierarchy, so let's put all of the contents of $dirlink (actually,
        # the contents of $target) into @ARGV; as a side effect down the
        # line, $dirlink will get created as an _actual_ directory.
        expand_glob($dirlink);
    } else {
        if (-l "$Dest_dir/$dirlink") {
            unlink "$Dest_dir/$dirlink" or
                print STDERR "Could not remove link $Dest_dir/$dirlink:  $!\n";
        }

        if (eval 'symlink($target, "$Dest_dir/$dirlink")') {
            print "Linking $target -> $Dest_dir/$dirlink\n";

            # Make sure that the link _links_ to something:
            if (! -e "$Dest_dir/$target") {
                mkpath("$Dest_dir/$target", 0755) or
                    print STDERR "Could not create $Dest_dir/$target/\n";
            }
        } else {
            print STDERR "Could not symlink $target -> $Dest_dir/$dirlink:  $!\n";
        }
    }
}


# Push all #included files in $file onto our stack, except for STDIN
# and files we've already processed.
sub queue_includes_from
{
    my ($file)    = @_;
    my $line;

    return if ($file eq "-");

    open HEADER, $file or return;
        while (defined($line = <HEADER>)) {
            while (/\\$/) { # Handle continuation lines
                chop $line;
                $line .= <HEADER>;
            }

            if ($line =~ /^#\s*include\s+<(.*?)>/) {
                push(@ARGV, $1) unless $is_converted{$1};
            }
        }
    close HEADER;
}


# Determine include directories; $Config{usrinc} should be enough for (all
# non-GCC?) C compilers, but gcc uses an additional include directory.
sub inc_dirs
{
    my $from_gcc    = `$Config{cc} -v 2>&1`;
    $from_gcc       =~ s:^Reading specs from (.*?)/specs\b.*:$1/include:s;

    length($from_gcc) ? ($from_gcc, $Config{usrinc}) : ($Config{usrinc});
}


1;

##############################################################################
__END__

=head1 NAME

h2ph - convert .h C header files to .ph Perl header files

=head1 SYNOPSIS

B<h2ph [-d destination directory] [-r | -a] [-l] [headerfiles]>

=head1 DESCRIPTION

I<h2ph>
converts any C header files specified to the corresponding Perl header file
format.
It is most easily run while in /usr/include:

	cd /usr/include; h2ph * sys/*

or

	cd /usr/include; h2ph -r -l .

The output files are placed in the hierarchy rooted at Perl's
architecture dependent library directory.  You can specify a different
hierarchy with a B<-d> switch.

If run with no arguments, filters standard input to standard output.

=head1 OPTIONS

=over 4

=item -d destination_dir

Put the resulting B<.ph> files beneath B<destination_dir>, instead of
beneath the default Perl library location (C<$Config{'installsitsearch'}>).

=item -r

Run recursively; if any of B<headerfiles> are directories, then run I<h2ph>
on all files in those directories (and their subdirectories, etc.).  B<-r>
and B<-a> are mutually exclusive.

=item -a

Run automagically; convert B<headerfiles>, as well as any B<.h> files
which they include.  This option will search for B<.h> files in all
directories which your C compiler ordinarily uses.  B<-a> and B<-r> are
mutually exclusive.

=item -l

Symbolic links will be replicated in the destination directory.  If B<-l>
is not specified, then links are skipped over.

=item -h

Put ``hints'' in the .ph files which will help in locating problems with
I<h2ph>.  In those cases when you B<require> a B<.ph> file containing syntax
errors, instead of the cryptic

	[ some error condition ] at (eval mmm) line nnn

you will see the slightly more helpful

	[ some error condition ] at filename.ph line nnn

However, the B<.ph> files almost double in size when built using B<-h>.

=item -D

Include the code from the B<.h> file as a comment in the B<.ph> file.
This is primarily used for debugging I<h2ph>.

=back

=head1 ENVIRONMENT

No environment variables are used.

=head1 FILES

 /usr/include/*.h
 /usr/include/sys/*.h

etc.

=head1 AUTHOR

Larry Wall

=head1 SEE ALSO

perl(1)

=head1 DIAGNOSTICS

The usual warnings if it can't read or write the files involved.

=head1 BUGS

Doesn't construct the %sizeof array for you.

It doesn't handle all C constructs, but it does attempt to isolate
definitions inside evals so that you can get at the definitions
that it can translate.

It's only intended as a rough tool.
You may need to dicker with the files produced.

=cut

!NO!SUBS!

close OUT or die "Can't close $file: $!";
chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
chdir $origdir;
Commit	Line	Data
4633a7c4 LW	1	#!/usr/local/bin/perl
	2
	3	use Config;
ee580363	4	use File::Basename qw(basename dirname);
8a5546a1	5	use Cwd;
4633a7c4 LW	6
	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
	11	# $startperl
	12	# to ensure Configure will look for $Config{startperl}.
	13	# Wanted: $archlibexp
	14
	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.
8a5546a1	17	$origdir = cwd;
44a8e56a	18	chdir dirname($0);
44a8e56a	19	$file = basename($0, '.PL');
774d564b	20	$file .= '.com' if $^O eq 'VMS';
4633a7c4 LW	21
	22	open OUT,">$file" or die "Can't create $file: $!";
	23
	24	print "Extracting $file (with variable substitutions)\n";
	25
	26	# In this section, perl variables will be expanded during extraction.
	27	# You can use $Config{...} to use Configure variables.
	28
	29	print OUT <<"!GROK!THIS!";
5f05dabc	30	$Config{startperl}
	31	eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
	32	if \$running_under_some_shell;
154e51a4 LW	33	!GROK!THIS!
154e51a4 LW	34
4633a7c4 LW	35	# In the following, perl variables are not expanded during extraction.
	36
	37	print OUT <<'!NO!SUBS!';
154e51a4	38
2c2acf7e	39	use Config;
b306bf39	40	use File::Path qw(mkpath);
50f6e060 KS	41	use Getopt::Std;
50f6e060 KS	42
625ca0ef	43	getopts('Dd:rlhaQ');
1d3434b8 GS	44	die "-r and -a options are mutually exclusive\n" if ($opt_r and $opt_a);
1d3434b8 GS	45	@inc_dirs = inc_dirs() if $opt_a;
2c2acf7e	46
b306bf39 RS	47	my $Exit = 0;
b306bf39 RS	48
50f6e060	49	my $Dest_dir = $opt_d \|\| $Config{installsitearch};
b306bf39 RS	50	die "Destination directory $Dest_dir doesn't exist or isn't a directory\n"
b306bf39 RS	51	unless -d $Dest_dir;
154e51a4	52
fe14fcc3 LW	53	@isatype = split(' ',<<END);
	54	char uchar u_char
	55	short ushort u_short
	56	int uint u_int
	57	long ulong u_long
fb73857a	58	FILE key_t caddr_t
fe14fcc3 LW	59	END
fe14fcc3 LW	60
55204971	61	@isatype{@isatype} = (1) x @isatype;
748a9306	62	$inif = 0;
fe14fcc3 LW	63
fe14fcc3 LW	64	@ARGV = ('-') unless @ARGV;
154e51a4	65
50f6e060 KS	66	while (defined ($file = next_file())) {
	67	if (-l $file and -d $file) {
	68	link_if_possible($file) if ($opt_l);
	69	next;
	70	}
	71
5f05dabc	72	# Recover from header files with unbalanced cpp directives
	73	$t = '';
	74	$tab = 0;
	75
50f6e060 KS	76	# $eval_index goes into ``#line'' directives, to help locate syntax errors:
	77	$eval_index = 1;
	78
fe14fcc3 LW	79	if ($file eq '-') {
	80	open(IN, "-");
	81	open(OUT, ">-");
ee580363	82	} else {
fe14fcc3	83	($outfile = $file) =~ s/\.h$/.ph/ \|\| next;
625ca0ef	84	print "$file -> $outfile\n" unless $opt_Q;
fe14fcc3 LW	85	if ($file =~ m\|^(.*)/\|) {
fe14fcc3 LW	86	$dir = $1;
b306bf39	87	mkpath "$Dest_dir/$dir";
154e51a4	88	}
1d3434b8 GS	89
	90	if ($opt_a) { # automagic mode: locate header file in @inc_dirs
	91	foreach (@inc_dirs) {
	92	chdir $_;
	93	last if -f $file;
	94	}
	95	}
	96
b306bf39 RS	97	open(IN,"$file") \|\| (($Exit = 1),(warn "Can't open $file: $!\n"),next);
b306bf39 RS	98	open(OUT,">$Dest_dir/$outfile") \|\| die "Can't create $outfile: $!\n";
154e51a4	99	}
154e51a4 LW	100	while (<IN>) {
	101	chop;
	102	while (/\\$/) {
	103	chop;
	104	$_ .= <IN>;
	105	chop;
	106	}
ee580363	107	print OUT "# $_\n" if $opt_D;
154e51a4 LW	108	if (s:/\*:\200:g) {
	109	s:\*/:\201:g;
	110	s/\200[^\201]*\201//g; # delete single line comments
	111	if (s/\200.*//) { # begin multi-line comment?
	112	$_ .= '/*';
	113	$_ .= <IN>;
	114	redo;
	115	}
	116	}
1d2dff63	117	if (s/^\s\#\s//) {
154e51a4 LW	118	if (s/^define\s+(\w+)//) {
	119	$name = $1;
	120	$new = '';
	121	s/\s+$//;
	122	if (s/^\(([\w,\s]*)\)//) {
	123	$args = $1;
b306bf39	124	my $proto = '() ';
154e51a4	125	if ($args ne '') {
b306bf39	126	$proto = '';
154e51a4	127	foreach $arg (split(/,\s*/,$args)) {
55204971	128	$arg =~ s/^\s([^\s].[^\s])\s*$/$1/;
154e51a4 LW	129	$curargs{$arg} = 1;
	130	}
	131	$args =~ s/\b(\w)/\$$1/g;
	132	$args = "local($args) = \@_;\n$t ";
	133	}
	134	s/^\s+//;
5f05dabc	135	expr();
ee580363 GS	136	$new =~ s/(["\\])/\\$1/g; #"]);
	137	$new = reindent($new);
	138	$args = reindent($args);
154e51a4	139	if ($t ne '') {
ee580363	140	$new =~ s/(['\\])/\\$1/g; #']);
50f6e060 KS	141	if ($opt_h) {
50f6e060 KS	142	print OUT $t,
ee580363	143	"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
50f6e060 KS	144	$eval_index++;
	145	} else {
	146	print OUT $t,
ee580363	147	"eval 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
50f6e060	148	}
ee580363 GS	149	} else {
ee580363 GS	150	print OUT "unless(defined(\&$name)) {\n sub $name $proto\{\n\t${args}eval q($new);\n }\n}\n";
154e51a4 LW	151	}
154e51a4 LW	152	%curargs = ();
ee580363	153	} else {
154e51a4	154	s/^\s+//;
5f05dabc	155	expr();
154e51a4	156	$new = 1 if $new eq '';
ee580363 GS	157	$new = reindent($new);
ee580363 GS	158	$args = reindent($args);
154e51a4	159	if ($t ne '') {
ee580363	160	$new =~ s/(['\\])/\\$1/g; #']);
50f6e060 KS	161	if ($opt_h) {
	162	print OUT $t,"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name () {",$new,";}' unless defined(\&$name);\n";
	163	$eval_index++;
	164	} else {
	165	print OUT $t,"eval 'sub $name () {",$new,";}' unless defined(\&$name);\n";
	166	}
ee580363 GS	167	} else {
ee580363 GS	168	print OUT $t,"unless(defined(\&$name)) {\n sub $name () {\t",$new,";}\n}\n";
154e51a4 LW	169	}
154e51a4 LW	170	}
ee580363 GS	171	} elsif (/^(include\|import)\s[<"](.)[>"]/) {
ee580363 GS	172	($incl = $2) =~ s/\.h$/.ph/;
d9d8d8de	173	print OUT $t,"require '$incl';\n";
ee580363 GS	174	} elsif(/^include_next\s[<"](.)[>"]/) {
ee580363 GS	175	($incl = $1) =~ s/\.h$/.ph/;
ee580363	176	print OUT ($t,
1d2dff63 GS	177	"eval {\n");
	178	$tab += 4;
	179	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	180	print OUT ($t,
	181	"my(\%INCD) = map { \$INC{\$_} => 1 } ",
	182	"(grep { \$_ eq \"$incl\" } keys(\%INC));\n");
	183	print OUT ($t,
	184	"my(\@REM) = map { \"\$_/$incl\" } ",
	185	"(grep { not exists(\$INCD{\"\$_/$incl\"})",
	186	"and -f \"\$_/$incl\" } \@INC);\n");
	187	print OUT ($t,
	188	"require \"\$REM[0]\" if \@REM;\n");
	189	$tab -= 4;
	190	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	191	print OUT ($t,
	192	"};\n");
	193	print OUT ($t,
	194	"warn(\$\@) if \$\@;\n");
ee580363 GS	195	} elsif (/^ifdef\s+(\w+)/) {
ee580363 GS	196	print OUT $t,"if(defined(&$1)) {\n";
154e51a4 LW	197	$tab += 4;
154e51a4 LW	198	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363 GS	199	} elsif (/^ifndef\s+(\w+)/) {
	200	print OUT $t,"unless(defined(&$1)) {\n";
	201	$tab += 4;
	202	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	203	} elsif (s/^if\s+//) {
154e51a4	204	$new = '';
748a9306	205	$inif = 1;
5f05dabc	206	expr();
748a9306	207	$inif = 0;
ee580363	208	print OUT $t,"if($new) {\n";
154e51a4 LW	209	$tab += 4;
154e51a4 LW	210	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363	211	} elsif (s/^elif\s+//) {
154e51a4	212	$new = '';
748a9306	213	$inif = 1;
5f05dabc	214	expr();
748a9306	215	$inif = 0;
154e51a4 LW	216	$tab -= 4;
154e51a4 LW	217	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363	218	print OUT $t,"}\n elsif($new) {\n";
154e51a4 LW	219	$tab += 4;
154e51a4 LW	220	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363	221	} elsif (/^else/) {
154e51a4 LW	222	$tab -= 4;
154e51a4 LW	223	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363	224	print OUT $t,"} else {\n";
154e51a4 LW	225	$tab += 4;
154e51a4 LW	226	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
ee580363	227	} elsif (/^endif/) {
154e51a4 LW	228	$tab -= 4;
	229	$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
	230	print OUT $t,"}\n";
ee580363 GS	231	} elsif(/^undef\s+(\w+)/) {
	232	print OUT $t, "undef(&$1) if defined(&$1);\n";
	233	} elsif(/^error\s+(.*)/) {
	234	print OUT $t, "die(\"$1\");\n";
	235	} elsif(/^warning\s+(.*)/) {
	236	print OUT $t, "warn(\"$1\");\n";
	237	} elsif(/^ident\s+(.*)/) {
	238	print OUT $t, "# $1\n";
154e51a4	239	}
625ca0ef	240	} elsif(/^\s(typedef\s)?enum\s(\s+[a-zA-Z_]\w\s*)?\{/) {
1d2dff63 GS	241	until(/\}.*?;/) {
	242	chomp($next = <IN>);
	243	$_ .= $next;
	244	print OUT "# $next\n" if $opt_D;
	245	}
	246	s@/\.?\*/@@g;
	247	s/\s+/ /g;
	248	/^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w)?\s?\{(.)\}\s?([a-zA-Z_]\w*)?\s?;/;
	249	($enum_subs = $3) =~ s/\s//g;
	250	@enum_subs = split(/,/, $enum_subs);
	251	$enum_val = -1;
	252	for $enum (@enum_subs) {
	253	($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;
	254	$enum_value =~ s/^=//;
	255	$enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);
	256	if ($opt_h) {
	257	print OUT ($t,
	258	"eval(\"\\n#line $eval_index $outfile\\n",
	259	"sub $enum_name () \{ $enum_val; \}\") ",
	260	"unless defined(\&$enum_name);\n");
	261	++ $eval_index;
	262	} else {
	263	print OUT ($t,
	264	"eval(\"sub $enum_name () \{ $enum_val; \}\") ",
	265	"unless defined(\&$enum_name);\n");
	266	}
	267	}
154e51a4 LW	268	}
	269	}
	270	print OUT "1;\n";
1d3434b8 GS	271
	272	$is_converted{$file} = 1;
	273	queue_includes_from($file) if ($opt_a);
154e51a4 LW	274	}
154e51a4 LW	275
b306bf39 RS	276	exit $Exit;
b306bf39 RS	277
ee580363 GS	278	sub reindent($) {
	279	my($text) = shift;
	280	$text =~ s/\n/\n /g;
	281	$text =~ s/ /\t/g;
	282	$text;
	283	}
	284
154e51a4	285	sub expr {
ee580363 GS	286	if(keys(%curargs)) {
	287	my($joined_args) = join('\|', keys(%curargs));
	288	}
154e51a4	289	while ($_ ne '') {
ee580363 GS	290	s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator
ee580363 GS	291	s/^\&([\(a-z\)]+)/$1/i; # hack for things that take the address of
154e51a4	292	s/^(\s+)// && do {$new .= ' '; next;};
50f6e060 KS	293	s/^(0X[0-9A-F]+)[UL]*//i && do {$new .= lc($1); next;};
	294	s/^(-?\d+\.\d+E[-+]\d+)F?//i && do {$new .= $1; next;};
	295	s/^(\d+)\s[LU]//i && do {$new .= $1; next;};
154e51a4 LW	296	s/^("(\\"\|[^"])*")// && do {$new .= $1; next;};
	297	s/^'((\\"\|[^"])*)'// && do {
	298	if ($curargs{$1}) {
	299	$new .= "ord('\$$1')";
ee580363	300	} else {
154e51a4 LW	301	$new .= "ord('$1')";
	302	}
	303	next;
	304	};
5f05dabc	305	# replace "sizeof(foo)" with "{foo}"
	306	# also, remove * (C dereference operator) to avoid perl syntax
	307	# problems. Where the %sizeof array comes from is anyone's
	308	# guess (c2ph?), but this at least avoids fatal syntax errors.
	309	# Behavior is undefined if sizeof() delimiters are unbalanced.
	310	# This code was modified to able to handle constructs like this:
	311	# sizeof(*(p)), which appear in the HP-UX 10.01 header files.
	312	s/^sizeof\s*\(// && do {
	313	$new .= '$sizeof';
	314	my $lvl = 1; # already saw one open paren
	315	# tack { on the front, and skip it in the loop
	316	$_ = "{" . "$_";
	317	my $index = 1;
	318	# find balanced closing paren
	319	while ($index <= length($_) && $lvl > 0) {
	320	$lvl++ if substr($_, $index, 1) eq "(";
	321	$lvl-- if substr($_, $index, 1) eq ")";
	322	$index++;
	323	}
	324	# tack } on the end, replacing )
	325	substr($_, $index - 1, 1) = "}";
	326	# remove pesky * operators within the sizeof argument
	327	substr($_, 0, $index - 1) =~ s/\*//g;
	328	next;
	329	};
50f6e060 KS	330	# Eliminate typedefs
	331	/\(([\w\s]+)[\\s]\)\s*[\w\(]/ && do {
	332	foreach (split /\s+/, $1) { # Make sure all the words are types,
	333	last unless ($isatype{$_} or $_ eq 'struct');
	334	}
	335	s/\([\w\s]+[\\s]\)// && next; # then eliminate them.
	336	};
ee580363 GS	337	# struct/union member, including arrays:
ee580363 GS	338	s/^([_A-Z]\w(\[[^\]]+\])?((\.\|->)[_A-Z]\w(\[[^\]]+\])?)+)//i && do {
50f6e060	339	$id = $1;
ee580363 GS	340	$id =~ s/(\.\|(->))([^\.\-]*)/->\{$3\}/g;
	341	$id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);
	342	while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {
	343	my($index) = $1;
	344	$index =~ s/\s//g;
	345	if(exists($curargs{$index})) {
	346	$index = "\$$index";
	347	} else {
	348	$index = "&$index";
	349	}
	350	$id =~ s/\[\s*([^\$\&\d\]]+)\]/[$index]/;
	351	}
	352	$new .= " (\$$id)";
50f6e060	353	};
154e51a4 LW	354	s/^([_a-zA-Z]\w*)// && do {
154e51a4 LW	355	$id = $1;
fe14fcc3 LW	356	if ($id eq 'struct') {
	357	s/^\s+(\w+)//;
	358	$id .= ' ' . $1;
	359	$isatype{$id} = 1;
ee580363	360	} elsif ($id =~ /^((un)?signed)\|(long)\|(short)$/) {
50f6e060	361	while (s/^\s+(\w+)//) { $id .= ' ' . $1; }
fe14fcc3 LW	362	$isatype{$id} = 1;
fe14fcc3 LW	363	}
154e51a4	364	if ($curargs{$id}) {
ee580363 GS	365	$new .= "\$$id";
	366	$new .= '->' if /^[\[\{]/;
	367	} elsif ($id eq 'defined') {
154e51a4	368	$new .= 'defined';
ee580363	369	} elsif (/^\(/) {
e5d73d77	370	s/^\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i; # cheat
154e51a4	371	$new .= " &$id";
ee580363	372	} elsif ($isatype{$id}) {
fe14fcc3 LW	373	if ($new =~ /{\s*$/) {
fe14fcc3 LW	374	$new .= "'$id'";
ee580363	375	} elsif ($new =~ /\(\s$/ && /^[\s]*\)/) {
fe14fcc3 LW	376	$new =~ s/\(\s*$//;
fe14fcc3 LW	377	s/^[\s]\)//;
ee580363	378	} else {
b276c83d	379	$new .= q(').$id.q(');
fe14fcc3	380	}
ee580363	381	} else {
c07a80fd	382	if ($inif && $new !~ /defined\s*\($/) {
748a9306	383	$new .= '(defined(&' . $id . ') ? &' . $id . ' : 0)';
ee580363 GS	384	} elsif (/^\[/) {
	385	$new .= " \$$id";
	386	} else {
748a9306 LW	387	$new .= ' &' . $id;
748a9306 LW	388	}
154e51a4 LW	389	}
	390	next;
	391	};
fb21d8eb	392	s/^(.)// && do { if ($1 ne '#') { $new .= $1; } next;};
154e51a4 LW	393	}
154e51a4 LW	394	}
50f6e060 KS	395
	396
	397	# Handle recursive subdirectories without getting a grotesquely big stack.
	398	# Could this be implemented using File::Find?
	399	sub next_file
	400	{
	401	my $file;
	402
	403	while (@ARGV) {
	404	$file = shift @ARGV;
	405
	406	if ($file eq '-' or -f $file or -l $file) {
	407	return $file;
	408	} elsif (-d $file) {
	409	if ($opt_r) {
	410	expand_glob($file);
	411	} else {
	412	print STDERR "Skipping directory `$file'\n";
	413	}
1d3434b8 GS	414	} elsif ($opt_a) {
	415	return $file;
	416	} else {
50f6e060 KS	417	print STDERR "Skipping `$file': not a file or directory\n";
	418	}
	419	}
	420
	421	return undef;
	422	}
	423
	424
	425	# Put all the files in $directory into @ARGV for processing.
	426	sub expand_glob
	427	{
	428	my ($directory) = @_;
	429
	430	$directory =~ s:/$::;
	431
	432	opendir DIR, $directory;
	433	foreach (readdir DIR) {
	434	next if ($_ eq '.' or $_ eq '..');
	435
	436	# expand_glob() is going to be called until $ARGV[0] isn't a
	437	# directory; so push directories, and unshift everything else.
1d3434b8 GS	438	if (-d "$directory/$_") { push @ARGV, "$directory/$_" }
1d3434b8 GS	439	else { unshift @ARGV, "$directory/$_" }
50f6e060 KS	440	}
	441	closedir DIR;
	442	}
	443
	444
	445	# Given $file, a symbolic link to a directory in the C include directory,
	446	# make an equivalent symbolic link in $Dest_dir, if we can figure out how.
	447	# Otherwise, just duplicate the file or directory.
	448	sub link_if_possible
	449	{
	450	my ($dirlink) = @_;
	451	my $target = eval 'readlink($dirlink)';
	452
	453	if ($target =~ m:^\.\./: or $target =~ m:^/:) {
	454	# The target of a parent or absolute link could leave the $Dest_dir
	455	# hierarchy, so let's put all of the contents of $dirlink (actually,
	456	# the contents of $target) into @ARGV; as a side effect down the
	457	# line, $dirlink will get created as an _actual_ directory.
	458	expand_glob($dirlink);
	459	} else {
	460	if (-l "$Dest_dir/$dirlink") {
	461	unlink "$Dest_dir/$dirlink" or
	462	print STDERR "Could not remove link $Dest_dir/$dirlink: $!\n";
	463	}
1d3434b8	464
50f6e060 KS	465	if (eval 'symlink($target, "$Dest_dir/$dirlink")') {
	466	print "Linking $target -> $Dest_dir/$dirlink\n";
	467
	468	# Make sure that the link _links_ to something:
	469	if (! -e "$Dest_dir/$target") {
1d3434b8	470	mkpath("$Dest_dir/$target", 0755) or
50f6e060 KS	471	print STDERR "Could not create $Dest_dir/$target/\n";
	472	}
	473	} else {
	474	print STDERR "Could not symlink $target -> $Dest_dir/$dirlink: $!\n";
	475	}
	476	}
	477	}
	478
	479
1d3434b8 GS	480	# Push all #included files in $file onto our stack, except for STDIN
	481	# and files we've already processed.
	482	sub queue_includes_from
	483	{
	484	my ($file) = @_;
	485	my $line;
	486
	487	return if ($file eq "-");
	488
	489	open HEADER, $file or return;
	490	while (defined($line = <HEADER>)) {
	491	while (/\\$/) { # Handle continuation lines
	492	chop $line;
	493	$line .= <HEADER>;
	494	}
	495
	496	if ($line =~ /^#\sinclude\s+<(.?)>/) {
	497	push(@ARGV, $1) unless $is_converted{$1};
	498	}
	499	}
	500	close HEADER;
	501	}
	502
	503
	504	# Determine include directories; $Config{usrinc} should be enough for (all
	505	# non-GCC?) C compilers, but gcc uses an additional include directory.
	506	sub inc_dirs
	507	{
	508	my $from_gcc = `$Config{cc} -v 2>&1`;
	509	$from_gcc =~ s:^Reading specs from (.?)/specs\b.:$1/include:s;
	510
	511	length($from_gcc) ? ($from_gcc, $Config{usrinc}) : ($Config{usrinc});
	512	}
	513
	514
50f6e060 KS	515	1;
50f6e060 KS	516
154e51a4	517	##############################################################################
1fef88e7 JM	518	__END__
	519
	520	=head1 NAME
	521
	522	h2ph - convert .h C header files to .ph Perl header files
	523
	524	=head1 SYNOPSIS
	525
1d3434b8	526	B<h2ph [-d destination directory] [-r \| -a] [-l] [headerfiles]>
1fef88e7 JM	527
1fef88e7 JM	528	=head1 DESCRIPTION
154e51a4	529
1fef88e7	530	I<h2ph>
154e51a4 LW	531	converts any C header files specified to the corresponding Perl header file
	532	format.
	533	It is most easily run while in /usr/include:
154e51a4 LW	534
	535	cd /usr/include; h2ph * sys/*
	536
50f6e060 KS	537	or
	538
	539	cd /usr/include; h2ph -r -l .
	540
b306bf39 RS	541	The output files are placed in the hierarchy rooted at Perl's
	542	architecture dependent library directory. You can specify a different
	543	hierarchy with a B<-d> switch.
	544
fe14fcc3	545	If run with no arguments, filters standard input to standard output.
1fef88e7	546
50f6e060 KS	547	=head1 OPTIONS
	548
	549	=over 4
	550
	551	=item -d destination_dir
	552
	553	Put the resulting B<.ph> files beneath B<destination_dir>, instead of
	554	beneath the default Perl library location (C<$Config{'installsitsearch'}>).
	555
	556	=item -r
	557
	558	Run recursively; if any of B<headerfiles> are directories, then run I<h2ph>
1d3434b8 GS	559	on all files in those directories (and their subdirectories, etc.). B<-r>
	560	and B<-a> are mutually exclusive.
	561
	562	=item -a
	563
	564	Run automagically; convert B<headerfiles>, as well as any B<.h> files
	565	which they include. This option will search for B<.h> files in all
	566	directories which your C compiler ordinarily uses. B<-a> and B<-r> are
	567	mutually exclusive.
50f6e060 KS	568
	569	=item -l
	570
	571	Symbolic links will be replicated in the destination directory. If B<-l>
	572	is not specified, then links are skipped over.
	573
	574	=item -h
	575
	576	Put ``hints'' in the .ph files which will help in locating problems with
	577	I<h2ph>. In those cases when you B<require> a B<.ph> file containing syntax
	578	errors, instead of the cryptic
	579
	580	[ some error condition ] at (eval mmm) line nnn
	581
	582	you will see the slightly more helpful
	583
	584	[ some error condition ] at filename.ph line nnn
	585
	586	However, the B<.ph> files almost double in size when built using B<-h>.
	587
1d3434b8 GS	588	=item -D
	589
	590	Include the code from the B<.h> file as a comment in the B<.ph> file.
	591	This is primarily used for debugging I<h2ph>.
	592
50f6e060 KS	593	=back
50f6e060 KS	594
1fef88e7 JM	595	=head1 ENVIRONMENT
1fef88e7 JM	596
154e51a4	597	No environment variables are used.
1fef88e7 JM	598
	599	=head1 FILES
	600
	601	/usr/include/*.h
	602	/usr/include/sys/*.h
	603
154e51a4	604	etc.
1fef88e7 JM	605
	606	=head1 AUTHOR
	607
154e51a4	608	Larry Wall
1fef88e7 JM	609
	610	=head1 SEE ALSO
	611
154e51a4	612	perl(1)
1fef88e7 JM	613
	614	=head1 DIAGNOSTICS
	615
154e51a4	616	The usual warnings if it can't read or write the files involved.
1fef88e7 JM	617
	618	=head1 BUGS
	619
154e51a4	620	Doesn't construct the %sizeof array for you.
1fef88e7	621
154e51a4 LW	622	It doesn't handle all C constructs, but it does attempt to isolate
	623	definitions inside evals so that you can get at the definitions
	624	that it can translate.
1fef88e7	625
154e51a4 LW	626	It's only intended as a rough tool.
154e51a4 LW	627	You may need to dicker with the files produced.
1fef88e7 JM	628
	629	=cut
	630
154e51a4	631	!NO!SUBS!
4633a7c4 LW	632
	633	close OUT or die "Can't close $file: $!";
	634	chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
	635	exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
8a5546a1	636	chdir $origdir;