| 1 | #!/usr/local/bin/perl
|
|---|
| 2 |
|
|---|
| 3 | use Config;
|
|---|
| 4 | use File::Basename qw(basename dirname);
|
|---|
| 5 | use Cwd;
|
|---|
| 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.
|
|---|
| 17 | $origdir = cwd;
|
|---|
| 18 | chdir dirname($0);
|
|---|
| 19 | $file = basename($0, '.PL');
|
|---|
| 20 | $file .= '.com' if $^O eq 'VMS';
|
|---|
| 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!";
|
|---|
| 30 | $Config{startperl}
|
|---|
| 31 | eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
|
|---|
| 32 | if \$running_under_some_shell;
|
|---|
| 33 | !GROK!THIS!
|
|---|
| 34 |
|
|---|
| 35 | # In the following, perl variables are not expanded during extraction.
|
|---|
| 36 |
|
|---|
| 37 | print OUT <<'!NO!SUBS!';
|
|---|
| 38 |
|
|---|
| 39 | use strict;
|
|---|
| 40 |
|
|---|
| 41 | use Config;
|
|---|
| 42 | use File::Path qw(mkpath);
|
|---|
| 43 | use Getopt::Std;
|
|---|
| 44 |
|
|---|
| 45 | # Make sure read permissions for all are set:
|
|---|
| 46 | if (defined umask && (umask() & 0444)) {
|
|---|
| 47 | umask (umask() & ~0444);
|
|---|
| 48 | }
|
|---|
| 49 |
|
|---|
| 50 | getopts('Dd:rlhaQe');
|
|---|
| 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;
|
|---|
| 54 |
|
|---|
| 55 | my $Exit = 0;
|
|---|
| 56 |
|
|---|
| 57 | my $Dest_dir = $opt_d || $Config{installsitearch};
|
|---|
| 58 | die "Destination directory $Dest_dir doesn't exist or isn't a directory\n"
|
|---|
| 59 | unless -d $Dest_dir;
|
|---|
| 60 |
|
|---|
| 61 | my @isatype = qw(
|
|---|
| 62 | char uchar u_char
|
|---|
| 63 | short ushort u_short
|
|---|
| 64 | int uint u_int
|
|---|
| 65 | long ulong u_long
|
|---|
| 66 | FILE key_t caddr_t
|
|---|
| 67 | float double size_t
|
|---|
| 68 | );
|
|---|
| 69 |
|
|---|
| 70 | my %isatype;
|
|---|
| 71 | @isatype{@isatype} = (1) x @isatype;
|
|---|
| 72 | my $inif = 0;
|
|---|
| 73 | my %Is_converted;
|
|---|
| 74 | my %bad_file = ();
|
|---|
| 75 |
|
|---|
| 76 | @ARGV = ('-') unless @ARGV;
|
|---|
| 77 |
|
|---|
| 78 | build_preamble_if_necessary();
|
|---|
| 79 |
|
|---|
| 80 | sub reindent($) {
|
|---|
| 81 | my($text) = shift;
|
|---|
| 82 | $text =~ s/\n/\n /g;
|
|---|
| 83 | $text =~ s/ /\t/g;
|
|---|
| 84 | $text;
|
|---|
| 85 | }
|
|---|
| 86 |
|
|---|
| 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);
|
|---|
| 92 | next;
|
|---|
| 93 | }
|
|---|
| 94 |
|
|---|
| 95 | # Recover from header files with unbalanced cpp directives
|
|---|
| 96 | $t = '';
|
|---|
| 97 | $tab = 0;
|
|---|
| 98 |
|
|---|
| 99 | # $eval_index goes into ``#line'' directives, to help locate syntax errors:
|
|---|
| 100 | $eval_index = 1;
|
|---|
| 101 |
|
|---|
| 102 | if ($file eq '-') {
|
|---|
| 103 | open(IN, "-");
|
|---|
| 104 | open(OUT, ">-");
|
|---|
| 105 | } else {
|
|---|
| 106 | ($outfile = $file) =~ s/\.h$/.ph/ || next;
|
|---|
| 107 | print "$file -> $outfile\n" unless $opt_Q;
|
|---|
| 108 | if ($file =~ m|^(.*)/|) {
|
|---|
| 109 | $dir = $1;
|
|---|
| 110 | mkpath "$Dest_dir/$dir";
|
|---|
| 111 | }
|
|---|
| 112 |
|
|---|
| 113 | if ($opt_a) { # automagic mode: locate header file in @inc_dirs
|
|---|
| 114 | foreach (@inc_dirs) {
|
|---|
| 115 | chdir $_;
|
|---|
| 116 | last if -f $file;
|
|---|
| 117 | }
|
|---|
| 118 | }
|
|---|
| 119 |
|
|---|
| 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";
|
|---|
| 122 | }
|
|---|
| 123 |
|
|---|
| 124 | print OUT
|
|---|
| 125 | "require '_h2ph_pre.ph';\n\n",
|
|---|
| 126 | "no warnings 'redefine';\n\n";
|
|---|
| 127 |
|
|---|
| 128 | while (defined (local $_ = next_line($file))) {
|
|---|
| 129 | if (s/^\s*\#\s*//) {
|
|---|
| 130 | if (s/^define\s+(\w+)//) {
|
|---|
| 131 | $name = $1;
|
|---|
| 132 | $new = '';
|
|---|
| 133 | s/\s+$//;
|
|---|
| 134 | s/\(\w+\s*\(\*\)\s*\(\w*\)\)\s*(-?\d+)/$1/; # (int (*)(foo_t))0
|
|---|
| 135 | if (s/^\(([\w,\s]*)\)//) {
|
|---|
| 136 | $args = $1;
|
|---|
| 137 | my $proto = '() ';
|
|---|
| 138 | if ($args ne '') {
|
|---|
| 139 | $proto = '';
|
|---|
| 140 | foreach my $arg (split(/,\s*/,$args)) {
|
|---|
| 141 | $arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;
|
|---|
| 142 | $curargs{$arg} = 1;
|
|---|
| 143 | }
|
|---|
| 144 | $args =~ s/\b(\w)/\$$1/g;
|
|---|
| 145 | $args = "my($args) = \@_;\n$t ";
|
|---|
| 146 | }
|
|---|
| 147 | s/^\s+//;
|
|---|
| 148 | expr();
|
|---|
| 149 | $new =~ s/(["\\])/\\$1/g; #"]);
|
|---|
| 150 | EMIT:
|
|---|
| 151 | $new = reindent($new);
|
|---|
| 152 | $args = reindent($args);
|
|---|
| 153 | if ($t ne '') {
|
|---|
| 154 | $new =~ s/(['\\])/\\$1/g; #']);
|
|---|
| 155 | if ($opt_h) {
|
|---|
| 156 | print OUT $t,
|
|---|
| 157 | "eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
|
|---|
| 158 | $eval_index++;
|
|---|
| 159 | } else {
|
|---|
| 160 | print OUT $t,
|
|---|
| 161 | "eval 'sub $name $proto\{\n$t ${args}eval q($new);\n$t}' unless defined(\&$name);\n";
|
|---|
| 162 | }
|
|---|
| 163 | } else {
|
|---|
| 164 | print OUT "unless(defined(\&$name)) {\n sub $name $proto\{\n\t${args}eval q($new);\n }\n}\n";
|
|---|
| 165 | }
|
|---|
| 166 | %curargs = ();
|
|---|
| 167 | } else {
|
|---|
| 168 | s/^\s+//;
|
|---|
| 169 | expr();
|
|---|
| 170 | $new = 1 if $new eq '';
|
|---|
| 171 | $new = reindent($new);
|
|---|
| 172 | $args = reindent($args);
|
|---|
| 173 | if ($t ne '') {
|
|---|
| 174 | $new =~ s/(['\\])/\\$1/g; #']);
|
|---|
| 175 |
|
|---|
| 176 | if ($opt_h) {
|
|---|
| 177 | print OUT $t,"eval \"\\n#line $eval_index $outfile\\n\" . 'sub $name () {",$new,";}' unless defined(\&$name);\n";
|
|---|
| 178 | $eval_index++;
|
|---|
| 179 | } else {
|
|---|
| 180 | print OUT $t,"eval 'sub $name () {",$new,";}' unless defined(\&$name);\n";
|
|---|
| 181 | }
|
|---|
| 182 | } else {
|
|---|
| 183 | # Shunt around such directives as `#define FOO FOO':
|
|---|
| 184 | next if " \&$name" eq $new;
|
|---|
| 185 |
|
|---|
| 186 | print OUT $t,"unless(defined(\&$name)) {\n sub $name () {\t",$new,";}\n}\n";
|
|---|
| 187 | }
|
|---|
| 188 | }
|
|---|
| 189 | } elsif (/^(include|import|include_next)\s*[<\"](.*)[>\"]/) {
|
|---|
| 190 | $incl_type = $1;
|
|---|
| 191 | $incl = $2;
|
|---|
| 192 | if (($incl_type eq 'include_next') ||
|
|---|
| 193 | ($opt_e && exists($bad_file{$incl}))) {
|
|---|
| 194 | $incl =~ s/\.h$/.ph/;
|
|---|
| 195 | print OUT ($t,
|
|---|
| 196 | "eval {\n");
|
|---|
| 197 | $tab += 4;
|
|---|
| 198 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 199 | print OUT ($t, "my(\@REM);\n");
|
|---|
| 200 | if ($incl_type eq 'include_next') {
|
|---|
| 201 | print OUT ($t,
|
|---|
| 202 | "my(\%INCD) = map { \$INC{\$_} => 1 } ",
|
|---|
| 203 | "(grep { \$_ eq \"$incl\" } ",
|
|---|
| 204 | "keys(\%INC));\n");
|
|---|
| 205 | print OUT ($t,
|
|---|
| 206 | "\@REM = map { \"\$_/$incl\" } ",
|
|---|
| 207 | "(grep { not exists(\$INCD{\"\$_/$incl\"})",
|
|---|
| 208 | " and -f \"\$_/$incl\" } \@INC);\n");
|
|---|
| 209 | } else {
|
|---|
| 210 | print OUT ($t,
|
|---|
| 211 | "\@REM = map { \"\$_/$incl\" } ",
|
|---|
| 212 | "(grep {-r \"\$_/$incl\" } \@INC);\n");
|
|---|
| 213 | }
|
|---|
| 214 | print OUT ($t,
|
|---|
| 215 | "require \"\$REM[0]\" if \@REM;\n");
|
|---|
| 216 | $tab -= 4;
|
|---|
| 217 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 218 | print OUT ($t,
|
|---|
| 219 | "};\n");
|
|---|
| 220 | print OUT ($t,
|
|---|
| 221 | "warn(\$\@) if \$\@;\n");
|
|---|
| 222 | } else {
|
|---|
| 223 | $incl =~ s/\.h$/.ph/;
|
|---|
| 224 | print OUT $t,"require '$incl';\n";
|
|---|
| 225 | }
|
|---|
| 226 | } elsif (/^ifdef\s+(\w+)/) {
|
|---|
| 227 | print OUT $t,"if(defined(&$1)) {\n";
|
|---|
| 228 | $tab += 4;
|
|---|
| 229 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 230 | } elsif (/^ifndef\s+(\w+)/) {
|
|---|
| 231 | print OUT $t,"unless(defined(&$1)) {\n";
|
|---|
| 232 | $tab += 4;
|
|---|
| 233 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 234 | } elsif (s/^if\s+//) {
|
|---|
| 235 | $new = '';
|
|---|
| 236 | $inif = 1;
|
|---|
| 237 | expr();
|
|---|
| 238 | $inif = 0;
|
|---|
| 239 | print OUT $t,"if($new) {\n";
|
|---|
| 240 | $tab += 4;
|
|---|
| 241 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 242 | } elsif (s/^elif\s+//) {
|
|---|
| 243 | $new = '';
|
|---|
| 244 | $inif = 1;
|
|---|
| 245 | expr();
|
|---|
| 246 | $inif = 0;
|
|---|
| 247 | $tab -= 4;
|
|---|
| 248 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 249 | print OUT $t,"}\n elsif($new) {\n";
|
|---|
| 250 | $tab += 4;
|
|---|
| 251 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 252 | } elsif (/^else/) {
|
|---|
| 253 | $tab -= 4;
|
|---|
| 254 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 255 | print OUT $t,"} else {\n";
|
|---|
| 256 | $tab += 4;
|
|---|
| 257 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 258 | } elsif (/^endif/) {
|
|---|
| 259 | $tab -= 4;
|
|---|
| 260 | $t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
|
|---|
| 261 | print OUT $t,"}\n";
|
|---|
| 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";
|
|---|
| 272 | }
|
|---|
| 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));
|
|---|
| 276 | chomp $next;
|
|---|
| 277 | # drop "#define FOO FOO" in enums
|
|---|
| 278 | $next =~ s/^\s*#\s*define\s+(\w+)\s+\1\s*$//;
|
|---|
| 279 | # #defines in enums (aliases)
|
|---|
| 280 | $next =~ s/^\s*#\s*define\s+(\w+)\s+(\w+)\s*$/$1 = $2,/;
|
|---|
| 281 | $_ .= $next;
|
|---|
| 282 | print OUT "# $next\n" if $opt_D;
|
|---|
| 283 | }
|
|---|
| 284 | s/#\s*if.*?#\s*endif//g; # drop #ifdefs
|
|---|
| 285 | s@/\*.*?\*/@@g;
|
|---|
| 286 | s/\s+/ /g;
|
|---|
| 287 | next unless /^\s?(typedef\s?)?enum\s?([a-zA-Z_]\w*)?\s?\{(.*)\}\s?([a-zA-Z_]\w*)?\s?;/;
|
|---|
| 288 | (my $enum_subs = $3) =~ s/\s//g;
|
|---|
| 289 | my @enum_subs = split(/,/, $enum_subs);
|
|---|
| 290 | my $enum_val = -1;
|
|---|
| 291 | foreach my $enum (@enum_subs) {
|
|---|
| 292 | my ($enum_name, $enum_value) = $enum =~ /^([a-zA-Z_]\w*)(=.+)?$/;
|
|---|
| 293 | $enum_name or next;
|
|---|
| 294 | $enum_value =~ s/^=//;
|
|---|
| 295 | $enum_val = (length($enum_value) ? $enum_value : $enum_val + 1);
|
|---|
| 296 | if ($opt_h) {
|
|---|
| 297 | print OUT ($t,
|
|---|
| 298 | "eval(\"\\n#line $eval_index $outfile\\n",
|
|---|
| 299 | "sub $enum_name () \{ $enum_val; \}\") ",
|
|---|
| 300 | "unless defined(\&$enum_name);\n");
|
|---|
| 301 | ++ $eval_index;
|
|---|
| 302 | } else {
|
|---|
| 303 | print OUT ($t,
|
|---|
| 304 | "eval(\"sub $enum_name () \{ $enum_val; \}\") ",
|
|---|
| 305 | "unless defined(\&$enum_name);\n");
|
|---|
| 306 | }
|
|---|
| 307 | }
|
|---|
| 308 | } elsif (/^(?:__extension__\s+)?(?:extern|static)\s+(?:__)?inline(?:__)?\s+/
|
|---|
| 309 | and !/;\s*$/ and !/{\s*}\s*$/)
|
|---|
| 310 | { # { for vi
|
|---|
| 311 | # This is a hack to parse the inline functions in the glibc headers.
|
|---|
| 312 | # Warning: massive kludge ahead. We suppose inline functions
|
|---|
| 313 | # are mainly constructed like macros.
|
|---|
| 314 | while (1) {
|
|---|
| 315 | last unless defined ($next = next_line($file));
|
|---|
| 316 | chomp $next;
|
|---|
| 317 | undef $_, last if $next =~ /__THROW\s*;/
|
|---|
| 318 | or $next =~ /^(__extension__|extern|static)\b/;
|
|---|
| 319 | $_ .= " $next";
|
|---|
| 320 | print OUT "# $next\n" if $opt_D;
|
|---|
| 321 | last if $next =~ /^}|^{.*}\s*$/;
|
|---|
| 322 | }
|
|---|
| 323 | next if not defined; # because it's only a prototype
|
|---|
| 324 | s/\b(__extension__|extern|static|(?:__)?inline(?:__)?)\b//g;
|
|---|
| 325 | # violently drop #ifdefs
|
|---|
| 326 | s/#\s*if.*?#\s*endif//g
|
|---|
| 327 | and print OUT "# some #ifdef were dropped here -- fill in the blanks\n";
|
|---|
| 328 | if (s/^(?:\w|\s|\*)*\s(\w+)\s*//) {
|
|---|
| 329 | $name = $1;
|
|---|
| 330 | } else {
|
|---|
| 331 | warn "name not found"; next; # shouldn't occur...
|
|---|
| 332 | }
|
|---|
| 333 | my @args;
|
|---|
| 334 | if (s/^\(([^()]*)\)\s*(\w+\s*)*//) {
|
|---|
| 335 | for my $arg (split /,/, $1) {
|
|---|
| 336 | if ($arg =~ /(\w+)\s*$/) {
|
|---|
| 337 | $curargs{$1} = 1;
|
|---|
| 338 | push @args, $1;
|
|---|
| 339 | }
|
|---|
| 340 | }
|
|---|
| 341 | }
|
|---|
| 342 | $args = (
|
|---|
| 343 | @args
|
|---|
| 344 | ? "my(" . (join ',', map "\$$_", @args) . ") = \@_;\n$t "
|
|---|
| 345 | : ""
|
|---|
| 346 | );
|
|---|
| 347 | my $proto = @args ? '' : '() ';
|
|---|
| 348 | $new = '';
|
|---|
| 349 | s/\breturn\b//g; # "return" doesn't occur in macros usually...
|
|---|
| 350 | expr();
|
|---|
| 351 | # try to find and perlify local C variables
|
|---|
| 352 | our @local_variables = (); # needs to be a our(): (?{...}) bug workaround
|
|---|
| 353 | {
|
|---|
| 354 | use re "eval";
|
|---|
| 355 | my $typelist = join '|', keys %isatype;
|
|---|
| 356 | $new =~ s['
|
|---|
| 357 | (?:(?:__)?const(?:__)?\s+)?
|
|---|
| 358 | (?:(?:un)?signed\s+)?
|
|---|
| 359 | (?:long\s+)?
|
|---|
| 360 | (?:$typelist)\s+
|
|---|
| 361 | (\w+)
|
|---|
| 362 | (?{ push @local_variables, $1 })
|
|---|
| 363 | ']
|
|---|
| 364 | [my \$$1]gx;
|
|---|
| 365 | $new =~ s['
|
|---|
| 366 | (?:(?:__)?const(?:__)?\s+)?
|
|---|
| 367 | (?:(?:un)?signed\s+)?
|
|---|
| 368 | (?:long\s+)?
|
|---|
| 369 | (?:$typelist)\s+
|
|---|
| 370 | ' \s+ &(\w+) \s* ;
|
|---|
| 371 | (?{ push @local_variables, $1 })
|
|---|
| 372 | ]
|
|---|
| 373 | [my \$$1;]gx;
|
|---|
| 374 | }
|
|---|
| 375 | $new =~ s/&$_\b/\$$_/g for @local_variables;
|
|---|
| 376 | $new =~ s/(["\\])/\\$1/g; #"]);
|
|---|
| 377 | # now that's almost like a macro (we hope)
|
|---|
| 378 | goto EMIT;
|
|---|
| 379 | }
|
|---|
| 380 | }
|
|---|
| 381 | $Is_converted{$file} = 1;
|
|---|
| 382 | if ($opt_e && exists($bad_file{$file})) {
|
|---|
| 383 | unlink($Dest_dir . '/' . $outfile);
|
|---|
| 384 | $next = '';
|
|---|
| 385 | } else {
|
|---|
| 386 | print OUT "1;\n";
|
|---|
| 387 | queue_includes_from($file) if $opt_a;
|
|---|
| 388 | }
|
|---|
| 389 | }
|
|---|
| 390 |
|
|---|
| 391 | if ($opt_e && (scalar(keys %bad_file) > 0)) {
|
|---|
| 392 | warn "Was unable to convert the following files:\n";
|
|---|
| 393 | warn "\t" . join("\n\t",sort(keys %bad_file)) . "\n";
|
|---|
| 394 | }
|
|---|
| 395 |
|
|---|
| 396 | exit $Exit;
|
|---|
| 397 |
|
|---|
| 398 | sub expr {
|
|---|
| 399 | $new = '"(assembly code)"' and return if /\b__asm__\b/; # freak out.
|
|---|
| 400 | my $joined_args;
|
|---|
| 401 | if(keys(%curargs)) {
|
|---|
| 402 | $joined_args = join('|', keys(%curargs));
|
|---|
| 403 | }
|
|---|
| 404 | while ($_ ne '') {
|
|---|
| 405 | s/^\&\&// && do { $new .= " &&"; next;}; # handle && operator
|
|---|
| 406 | s/^\&([\(a-z\)]+)/$1/i; # hack for things that take the address of
|
|---|
| 407 | s/^(\s+)// && do {$new .= ' '; next;};
|
|---|
| 408 | s/^0X([0-9A-F]+)[UL]*//i
|
|---|
| 409 | && do {my $hex = $1;
|
|---|
| 410 | $hex =~ s/^0+//;
|
|---|
| 411 | if (length $hex > 8 && !$Config{use64bitint}) {
|
|---|
| 412 | # Croak if nv_preserves_uv_bits < 64 ?
|
|---|
| 413 | $new .= hex(substr($hex, -8)) +
|
|---|
| 414 | 2**32 * hex(substr($hex, 0, -8));
|
|---|
| 415 | # The above will produce "errorneus" code
|
|---|
| 416 | # if the hex constant was e.g. inside UINT64_C
|
|---|
| 417 | # macro, but then again, h2ph is an approximation.
|
|---|
| 418 | } else {
|
|---|
| 419 | $new .= lc("0x$hex");
|
|---|
| 420 | }
|
|---|
| 421 | next;};
|
|---|
| 422 | s/^(-?\d+\.\d+E[-+]?\d+)[FL]?//i && do {$new .= $1; next;};
|
|---|
| 423 | s/^(\d+)\s*[LU]*//i && do {$new .= $1; next;};
|
|---|
| 424 | s/^("(\\"|[^"])*")// && do {$new .= $1; next;};
|
|---|
| 425 | s/^'((\\"|[^"])*)'// && do {
|
|---|
| 426 | if ($curargs{$1}) {
|
|---|
| 427 | $new .= "ord('\$$1')";
|
|---|
| 428 | } else {
|
|---|
| 429 | $new .= "ord('$1')";
|
|---|
| 430 | }
|
|---|
| 431 | next;
|
|---|
| 432 | };
|
|---|
| 433 | # replace "sizeof(foo)" with "{foo}"
|
|---|
| 434 | # also, remove * (C dereference operator) to avoid perl syntax
|
|---|
| 435 | # problems. Where the %sizeof array comes from is anyone's
|
|---|
| 436 | # guess (c2ph?), but this at least avoids fatal syntax errors.
|
|---|
| 437 | # Behavior is undefined if sizeof() delimiters are unbalanced.
|
|---|
| 438 | # This code was modified to able to handle constructs like this:
|
|---|
| 439 | # sizeof(*(p)), which appear in the HP-UX 10.01 header files.
|
|---|
| 440 | s/^sizeof\s*\(// && do {
|
|---|
| 441 | $new .= '$sizeof';
|
|---|
| 442 | my $lvl = 1; # already saw one open paren
|
|---|
| 443 | # tack { on the front, and skip it in the loop
|
|---|
| 444 | $_ = "{" . "$_";
|
|---|
| 445 | my $index = 1;
|
|---|
| 446 | # find balanced closing paren
|
|---|
| 447 | while ($index <= length($_) && $lvl > 0) {
|
|---|
| 448 | $lvl++ if substr($_, $index, 1) eq "(";
|
|---|
| 449 | $lvl-- if substr($_, $index, 1) eq ")";
|
|---|
| 450 | $index++;
|
|---|
| 451 | }
|
|---|
| 452 | # tack } on the end, replacing )
|
|---|
| 453 | substr($_, $index - 1, 1) = "}";
|
|---|
| 454 | # remove pesky * operators within the sizeof argument
|
|---|
| 455 | substr($_, 0, $index - 1) =~ s/\*//g;
|
|---|
| 456 | next;
|
|---|
| 457 | };
|
|---|
| 458 | # Eliminate typedefs
|
|---|
| 459 | /\(([\w\s]+)[\*\s]*\)\s*[\w\(]/ && do {
|
|---|
| 460 | my $doit = 1;
|
|---|
| 461 | foreach (split /\s+/, $1) { # Make sure all the words are types,
|
|---|
| 462 | unless($isatype{$_} or $_ eq 'struct' or $_ eq 'union'){
|
|---|
| 463 | $doit = 0;
|
|---|
| 464 | last;
|
|---|
| 465 | }
|
|---|
| 466 | }
|
|---|
| 467 | if( $doit ){
|
|---|
| 468 | s/\([\w\s]+[\*\s]*\)// && next; # then eliminate them.
|
|---|
| 469 | }
|
|---|
| 470 | };
|
|---|
| 471 | # struct/union member, including arrays:
|
|---|
| 472 | s/^([_A-Z]\w*(\[[^\]]+\])?((\.|->)[_A-Z]\w*(\[[^\]]+\])?)+)//i && do {
|
|---|
| 473 | my $id = $1;
|
|---|
| 474 | $id =~ s/(\.|(->))([^\.\-]*)/->\{$3\}/g;
|
|---|
| 475 | $id =~ s/\b([^\$])($joined_args)/$1\$$2/g if length($joined_args);
|
|---|
| 476 | while($id =~ /\[\s*([^\$\&\d\]]+)\]/) {
|
|---|
| 477 | my($index) = $1;
|
|---|
| 478 | $index =~ s/\s//g;
|
|---|
| 479 | if(exists($curargs{$index})) {
|
|---|
| 480 | $index = "\$$index";
|
|---|
| 481 | } else {
|
|---|
|
|---|
