release/src-rt-6.x.4708/toolchains/hndtools-arm-linux-2.6.36-uclibc-4.5.3/bin/autom4te

   1 #! /usr/bin/perl -w
   2 # -*- perl -*-
   3 # Generated from autom4te.in; do not edit by hand.
   4
   5 eval 'case $# in 0) exec /usr/bin/perl -S "$0";; *) exec /usr/bin/perl -S "$0" "$@";; esac'
   6     if 0;
   7
   8 # autom4te - Wrapper around M4 libraries.
   9 # Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009 Free
  10 # Software Foundation, Inc.
  11
  12 # This program is free software: you can redistribute it and/or modify
  13 # it under the terms of the GNU General Public License as published by
  14 # the Free Software Foundation, either version 3 of the License, or
  15 # (at your option) any later version.
  16
  17 # This program is distributed in the hope that it will be useful,
  18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 # GNU General Public License for more details.
  21
  22 # You should have received a copy of the GNU General Public License
  23 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24
  25
  26 BEGIN
  27 {
  28   my $pkgdatadir = $ENV{'autom4te_perllibdir'} || '/projects/hnd/tools/linux/hndtools-arm-linux-2.6.36-uclibc-4.5.3/share/autoconf';
  29   unshift @INC, $pkgdatadir;
  30
  31   # Override SHELL.  On DJGPP SHELL may not be set to a shell
  32   # that can handle redirection and quote arguments correctly,
  33   # e.g.: COMMAND.COM.  For DJGPP always use the shell that configure
  34   # has detected.
  35   $ENV{'SHELL'} = '/bin/sh' if ($^O eq 'dos');
  36 }
  37
  38 use Autom4te::C4che;
  39 use Autom4te::ChannelDefs;
  40 use Autom4te::Channels;
  41 use Autom4te::FileUtils;
  42 use Autom4te::General;
  43 use Autom4te::XFile;
  44 use File::Basename;
  45 use strict;
  46
  47 # Data directory.
  48 my $pkgdatadir = $ENV{'AC_MACRODIR'} || '/projects/hnd/tools/linux/hndtools-arm-linux-2.6.36-uclibc-4.5.3/share/autoconf';
  49
  50 # $LANGUAGE{LANGUAGE} -- Automatic options for LANGUAGE.
  51 my %language;
  52
  53 my $output = '-';
  54
  55 # Mode of the output file except for traces.
  56 my $mode = "0666";
  57
  58 # If melt, don't use frozen files.
  59 my $melt = 0;
  60
  61 # Names of the cache directory, cache directory index, trace cache
  62 # prefix, and output cache prefix.  And the IO object for the index.
  63 my $cache;
  64 my $icache;
  65 my $tcache;
  66 my $ocache;
  67 my $icache_file;
  68
  69 my $flock_implemented = 'yes';
  70
  71 # The macros to trace mapped to their format, as specified by the
  72 # user.
  73 my %trace;
  74
  75 # The macros the user will want to trace in the future.
  76 # We need `include' to get the included file, `m4_pattern_forbid' and
  77 # `m4_pattern_allow' to check the output.
  78 #
  79 # FIXME: What about `sinclude'?
  80 my @preselect = ('include',
  81                  'm4_pattern_allow', 'm4_pattern_forbid',
  82                  '_m4_warn');
  83
  84 # M4 include path.
  85 my @include;
  86
  87 # Do we freeze?
  88 my $freeze = 0;
  89
  90 # $M4.
  91 my $m4 = $ENV{"M4"} || '/projects/hnd/tools/linux/hndtools-arm-linux-2.6.36-uclibc-4.5.3/bin/m4';
  92 # Some non-GNU m4's don't reject the --help option, so give them /dev/null.
  93 fatal "need GNU m4 1.4 or later: $m4"
  94   if system "$m4 --help </dev/null 2>&1 | grep reload-state >/dev/null";
  95
  96 # Set some high recursion limit as the default limit, 250, has already
  97 # been hit with AC_OUTPUT.  Don't override the user's choice.
  98 $m4 .= ' --nesting-limit=1024'
  99   if " $m4 " !~ / (--nesting-limit(=[0-9]+)?|-L[0-9]*) /;
 100
 101
 102 # @M4_BUILTIN -- M4 builtins and a useful comment.
 103 my @m4_builtin = `echo dumpdef | $m4 2>&1 >/dev/null`;
 104 map { s/:.*//;s/\W// } @m4_builtin;
 105
 106
 107 # %M4_BUILTIN_ALTERNATE_NAME
 108 # --------------------------
 109 # The builtins are renamed, e.g., `define' is renamed `m4_define'.
 110 # So map `define' to `m4_define' and conversely.
 111 # Some macros don't follow this scheme: be sure to properly map to their
 112 # alternate name too.
 113 #
 114 # FIXME: Trace status of renamed builtins was fixed in M4 1.4.5, which
 115 # we now depend on; do we still need to do this mapping?
 116 #
 117 # So we will merge them, i.e., tracing `BUILTIN' or tracing
 118 # `m4_BUILTIN' will be the same: tracing both, but honoring the
 119 # *last* trace specification.
 120 #
 121 # FIXME: This is not enough: in the output `$0' will be `BUILTIN'
 122 # sometimes and `m4_BUILTIN' at others.  We should return a unique name,
 123 # the one specified by the user.
 124 #
 125 # FIXME: To be absolutely rigorous, I would say that given that we
 126 # _redefine_ divert (instead of _copying_ it), divert and the like
 127 # should not be part of this list.
 128 my %m4_builtin_alternate_name;
 129 @m4_builtin_alternate_name{"$_", "m4_$_"} = ("m4_$_", "$_")
 130   foreach (grep { !/m4wrap|m4exit|dnl|ifelse|__.*__/ } @m4_builtin);
 131 @m4_builtin_alternate_name{"ifelse", "m4_if"}   = ("m4_if", "ifelse");
 132 @m4_builtin_alternate_name{"m4exit", "m4_exit"} = ("m4_exit", "m4exit");
 133 @m4_builtin_alternate_name{"m4wrap", "m4_wrap"} = ("m4_wrap", "m4wrap");
 134
 135
 136 # $HELP
 137 # -----
 138 $help = "Usage: $0 [OPTION]... [FILES]
 139
 140 Run GNU M4 on the FILES, avoiding useless runs.  Output the traces if tracing,
 141 the frozen file if freezing, otherwise the expansion of the FILES.
 142
 143 If some of the FILES are named \`FILE.m4f\' they are considered to be M4
 144 frozen files of all the previous files (which are therefore not loaded).
 145 If \`FILE.m4f\' is not found, then \`FILE.m4\' will be used, together with
 146 all the previous files.
 147
 148 Some files may be optional, i.e., will only be processed if found in the
 149 include path, but then must end in \`.m4?\';  the question mark is not part of
 150 the actual file name.
 151
 152 Operation modes:
 153   -h, --help               print this help, then exit
 154   -V, --version            print version number, then exit
 155   -v, --verbose            verbosely report processing
 156   -d, --debug              don\'t remove temporary files
 157   -o, --output=FILE        save output in FILE (defaults to \`-\', stdout)
 158   -f, --force              don\'t rely on cached values
 159   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY
 160   -l, --language=LANG      specify the set of M4 macros to use
 161   -C, --cache=DIRECTORY    preserve results for future runs in DIRECTORY
 162       --no-cache           disable the cache
 163   -m, --mode=OCTAL         change the non trace output file mode (0666)
 164   -M, --melt               don\'t use M4 frozen files
 165
 166 Languages include:
 167   \`Autoconf\'   create Autoconf configure scripts
 168   \`Autotest\'   create Autotest test suites
 169   \`M4sh\'       create M4sh shell scripts
 170   \`M4sugar\'    create M4sugar output
 171
 172 " . Autom4te::ChannelDefs::usage . "
 173
 174 The environment variables \`M4\' and \`WARNINGS\' are honored.
 175
 176 Library directories:
 177   -B, --prepend-include=DIR  prepend directory DIR to search path
 178   -I, --include=DIR          append directory DIR to search path
 179
 180 Tracing:
 181   -t, --trace=MACRO[:FORMAT]  report the MACRO invocations
 182   -p, --preselect=MACRO       prepare to trace MACRO in a future run
 183
 184 Freezing:
 185   -F, --freeze   produce an M4 frozen state file for FILES
 186
 187 FORMAT defaults to \`\$f:\$l:\$n:\$%\', and can use the following escapes:
 188   \$\$     literal \$
 189   \$f     file where macro was called
 190   \$l     line where macro was called
 191   \$d     nesting depth of macro call
 192   \$n     name of the macro
 193   \$NUM   argument NUM, unquoted and with newlines
 194   \$SEP\@  all arguments, with newlines, quoted, and separated by SEP
 195   \$SEP*  all arguments, with newlines, unquoted, and separated by SEP
 196   \$SEP%  all arguments, without newlines, unquoted, and separated by SEP
 197 SEP can be empty for the default (comma for \@ and *, colon for %),
 198 a single character for that character, or {STRING} to use a string.
 199
 200 Report bugs to <bug-autoconf\@gnu.org>.
 201 GNU Autoconf home page: <http://www.gnu.org/software/autoconf/>.
 202 General help using GNU software: <http://www.gnu.org/gethelp/>.
 203 ";
 204
 205 # $VERSION
 206 # --------
 207 $version =  <<"EOF";
 208 autom4te (GNU Autoconf) 2.65
 209 Copyright (C) 2009 Free Software Foundation, Inc.
 210 License GPLv3+/Autoconf: GNU GPL version 3 or later
 211 <http://gnu.org/licenses/gpl.html>, <http://gnu.org/licenses/exceptions.html>
 212 This is free software: you are free to change and redistribute it.
 213 There is NO WARRANTY, to the extent permitted by law.
 214
 215 Written by Akim Demaille.
 216 EOF
 217
 218
 219 ## ---------- ##
 220 ## Routines.  ##
 221 ## ---------- ##
 222
 223
 224 # $OPTION
 225 # files_to_options (@FILE)
 226 # ------------------------
 227 # Transform Autom4te conventions (e.g., using foo.m4f to designate a frozen
 228 # file) into a suitable command line for M4 (e.g., using --reload-state).
 229 # parse_args guarantees that we will see at most one frozen file, and that
 230 # if a frozen file is present, it is the first argument.
 231 sub files_to_options (@)
 232 {
 233   my (@file) = @_;
 234   my @res;
 235   foreach my $file (@file)
 236     {
 237       my $arg = shell_quote ($file);
 238       if ($file =~ /\.m4f$/)
 239         {
 240           $arg = "--reload-state=$arg";
 241           # If the user downgraded M4 from 1.6 to 1.4.x after freezing
 242           # the file, then we ensure the frozen __m4_version__ will
 243           # not cause m4_init to make the wrong decision about the
 244           # current M4 version.
 245           $arg .= " --undefine=__m4_version__"
 246             unless grep {/__m4_version__/} @m4_builtin;
 247         }
 248       push @res, $arg;
 249     }
 250   return join ' ', @res;
 251 }
 252
 253
 254 # load_configuration ($FILE)
 255 # --------------------------
 256 # Load the configuration $FILE.
 257 sub load_configuration ($)
 258 {
 259   my ($file) = @_;
 260   use Text::ParseWords;
 261
 262   my $cfg = new Autom4te::XFile ("< " . open_quote ($file));
 263   my $lang;
 264   while ($_ = $cfg->getline)
 265     {
 266       chomp;
 267       # Comments.
 268       next
 269         if /^\s*(\#.*)?$/;
 270
 271       my @words = shellwords ($_);
 272       my $type = shift @words;
 273       if ($type eq 'begin-language:')
 274         {
 275           fatal "$file:$.: end-language missing for: $lang"
 276             if defined $lang;
 277           $lang = lc $words[0];
 278         }
 279       elsif ($type eq 'end-language:')
 280         {
 281           error "$file:$.: end-language mismatch: $lang"
 282             if $lang ne lc $words[0];
 283           $lang = undef;
 284         }
 285       elsif ($type eq 'args:')
 286         {
 287           fatal "$file:$.: no current language"
 288             unless defined $lang;
 289           push @{$language{$lang}}, @words;
 290         }
 291       else
 292         {
 293           error "$file:$.: unknown directive: $type";
 294         }
 295     }
 296 }
 297
 298
 299 # parse_args ()
 300 # -------------
 301 # Process any command line arguments.
 302 sub parse_args ()
 303 {
 304   # We want to look for the early options, which should not be found
 305   # in the configuration file.  Prepend to the user arguments.
 306   # Perform this repeatedly so that we can use --language in language
 307   # definitions.  Beware that there can be several --language
 308   # invocations.
 309   my @language;
 310   do {
 311     @language = ();
 312     use Getopt::Long;
 313     Getopt::Long::Configure ("pass_through", "permute");
 314     GetOptions ("l|language=s" => \@language);
 315
 316     foreach (@language)
 317       {
 318         error "unknown language: $_"
 319           unless exists $language{lc $_};
 320         unshift @ARGV, @{$language{lc $_}};
 321       }
 322   } while @language;
 323
 324   # --debug is useless: it is parsed below.
 325   if (exists $ENV{'AUTOM4TE_DEBUG'})
 326     {
 327       print STDERR "$me: concrete arguments:\n";
 328       foreach my $arg (@ARGV)
 329         {
 330           print STDERR "| $arg\n";
 331         }
 332     }
 333
 334   # Process the arguments for real this time.
 335   my @trace;
 336   my @prepend_include;
 337   parse_WARNINGS;
 338   getopt
 339     (
 340      # Operation modes:
 341      "o|output=s"   => \$output,
 342      "W|warnings=s" => \&parse_warnings,
 343      "m|mode=s"     => \$mode,
 344      "M|melt"       => \$melt,
 345
 346      # Library directories:
 347      "B|prepend-include=s" => \@prepend_include,
 348      "I|include=s"         => \@include,
 349
 350      # Tracing:
 351      # Using a hash for traces is seducing.  Unfortunately, upon `-t FOO',
 352      # instead of mapping `FOO' to undef, Getopt maps it to `1', preventing
 353      # us from distinguishing `-t FOO' from `-t FOO=1'.  So let's do it
 354      # by hand.
 355      "t|trace=s"     => \@trace,
 356      "p|preselect=s" => \@preselect,
 357
 358      # Freezing.
 359      "F|freeze" => \$freeze,
 360
 361      # Caching.
 362      "C|cache=s" => \$cache,
 363      "no-cache"  => sub { $cache = undef; },
 364     );
 365
 366   fatal "too few arguments
 367 Try `$me --help' for more information."
 368     unless @ARGV;
 369
 370   # Freezing:
 371   # We cannot trace at the same time (well, we can, but it sounds insane).
 372   # And it implies melting: there is risk not to update properly using
 373   # old frozen files, and worse yet: we could load a frozen file and
 374   # refreeze it!  A sort of caching :)
 375   fatal "cannot freeze and trace"
 376     if $freeze && @trace;
 377   $melt = 1
 378     if $freeze;
 379
 380   # Names of the cache directory, cache directory index, trace cache
 381   # prefix, and output cache prefix.  If the cache is not to be
 382   # preserved, default to a temporary directory (automatically removed
 383   # on exit).
 384   $cache = $tmp
 385     unless $cache;
 386   $icache = "$cache/requests";
 387   $tcache = "$cache/traces.";
 388   $ocache = "$cache/output.";
 389
 390   # Normalize the includes: the first occurrence is enough, several is
 391   # a pain since it introduces a useless difference in the path which
 392   # invalidates the cache.  And strip `.' which is implicit and always
 393   # first.
 394   @include = grep { !/^\.$/ } uniq (reverse(@prepend_include), @include);
 395
 396   # Convert @trace to %trace, and work around the M4 builtins tracing
 397   # problem.
 398   # The default format is `$f:$l:$n:$%'.
 399   foreach (@trace)
 400     {
 401       /^([^:]+)(?::(.*))?$/ms;
 402       $trace{$1} = defined $2 ? $2 : '$f:$l:$n:$%';
 403       $trace{$m4_builtin_alternate_name{$1}} = $trace{$1}
 404         if exists $m4_builtin_alternate_name{$1};
 405     }
 406
 407   # Work around the M4 builtins tracing problem for @PRESELECT.
 408   # FIXME: Is this still needed, now that we rely on M4 1.4.5?
 409   push (@preselect,
 410         map { $m4_builtin_alternate_name{$_} }
 411         grep { exists $m4_builtin_alternate_name{$_} } @preselect);
 412
 413   # If we find frozen files, then all the files before it are
 414   # discarded: the frozen file is supposed to include them all.
 415   #
 416   # We don't want to depend upon m4's --include to find the top level
 417   # files, so we use `find_file' here.  Try to get a canonical name,
 418   # as it's part of the key for caching.  And some files are optional
 419   # (also handled by `find_file').
 420   my @argv;
 421   foreach (@ARGV)
 422     {
 423       if ($_ eq '-')
 424         {
 425           push @argv, $_;
 426         }
 427       elsif (/\.m4f$/)
 428         {
 429           # Frozen files are optional => pass a `?' to `find_file'.
 430           my $file = find_file ("$_?", @include);
 431           if (!$melt && $file)
 432             {
 433               @argv = ($file);
 434             }
 435           else
 436             {
 437               s/\.m4f$/.m4/;
 438               push @argv, find_file ($_, @include);
 439             }
 440         }
 441       else
 442         {
 443           my $file = find_file ($_, @include);
 444           push @argv, $file
 445             if $file;
 446         }
 447     }
 448   @ARGV = @argv;
 449 }
 450
 451
 452 # handle_m4 ($REQ, @MACRO)
 453 # ------------------------
 454 # Run m4 on the input files, and save the traces on the @MACRO.
 455 sub handle_m4 ($@)
 456 {
 457   my ($req, @macro) = @_;
 458
 459   # GNU m4 appends when using --debugfile/--error-output.
 460   unlink ($tcache . $req->id . "t");
 461
 462   # Run m4.
 463   #
 464   # We don't output directly to the cache files, to avoid problems
 465   # when we are interrupted (that leaves corrupted files).
 466   xsystem ("$m4 "
 467            . join (' --include=', '', map { shell_quote ($_) } @include)
 468            . ' --debug=aflq'
 469            . (!exists $ENV{'AUTOM4TE_NO_FATAL'} ? ' --fatal-warning' : '')
 470            . " --debugfile=" . shell_quote ("$tcache" . $req->id . "t")
 471            . join (' --trace=', '', map { shell_quote ($_) } sort @macro)
 472            . " " . files_to_options (@ARGV)
 473            . " > " . shell_quote ("$ocache" . $req->id . "t"));
 474
 475   # Everything went ok: preserve the outputs.
 476   foreach my $file (map { $_ . $req->id } ($tcache, $ocache))
 477     {
 478       use File::Copy;
 479       move ("${file}t", "$file")
 480         or fatal "cannot rename ${file}t as $file: $!";
 481     }
 482 }
 483
 484
 485 # warn_forbidden ($WHERE, $WORD, %FORBIDDEN)
 486 # ------------------------------------------
 487 # $WORD is forbidden.  Warn with a dedicated error message if in
 488 # %FORBIDDEN, otherwise a simple `error: possibly undefined macro'
 489 # will do.
 490 my $first_warn_forbidden = 1;
 491 sub warn_forbidden ($$%)
 492 {
 493   my ($where, $word, %forbidden) = @_;
 494   my $message;
 495
 496   for my $re (sort keys %forbidden)
 497     {
 498       if ($word =~ $re)
 499         {
 500           $message = $forbidden{$re};
 501           last;
 502         }
 503     }
 504   $message ||= "possibly undefined macro: $word";
 505   warn "$where: error: $message\n";
 506   if ($first_warn_forbidden)
 507     {
 508       warn <<EOF;
 509       If this token and others are legitimate, please use m4_pattern_allow.
 510       See the Autoconf documentation.
 511 EOF
 512       $first_warn_forbidden = 0;
 513     }
 514 }
 515
 516
 517 # handle_output ($REQ, $OUTPUT)
 518 # -----------------------------
 519 # Run m4 on the input files, perform quadrigraphs substitution, check for
 520 # forbidden tokens, and save into $OUTPUT.
 521 sub handle_output ($$)
 522 {
 523   my ($req, $output) = @_;
 524
 525   verb "creating $output";
 526
 527   # Load the forbidden/allowed patterns.
 528   handle_traces ($req, "$tmp/patterns",
 529                  ('m4_pattern_forbid' => 'forbid:$1:$2',
 530                   'm4_pattern_allow'  => 'allow:$1'));
 531   my @patterns = new Autom4te::XFile ("< " . open_quote ("$tmp/patterns"))->getlines;
 532   chomp @patterns;
 533   my %forbidden =
 534     map { /^forbid:([^:]+):.+$/ => /^forbid:[^:]+:(.+)$/ } @patterns;
 535   my $forbidden = join ('|', map { /^forbid:([^:]+)/ } @patterns) || "^\$";
 536   my $allowed   = join ('|', map { /^allow:([^:]+)/  } @patterns) || "^\$";
 537
 538   verb "forbidden tokens: $forbidden";
 539   verb "forbidden token : $_ => $forbidden{$_}"
 540     foreach (sort keys %forbidden);
 541   verb "allowed   tokens: $allowed";
 542
 543   # Read the (cached) raw M4 output, produce the actual result.  We
 544   # have to use the 2nd arg to have Autom4te::XFile honor the third, but then
 545   # stdout is to be handled by hand :(.  Don't use fdopen as it means
 546   # we will close STDOUT, which we already do in END.
 547   my $out = new Autom4te::XFile;
 548   if ($output eq '-')
 549     {
 550       $out->open (">$output");
 551     }
 552   else
 553     {
 554       $out->open($output, O_CREAT | O_WRONLY | O_TRUNC, oct ($mode));
 555     }
 556   fatal "cannot create $output: $!"
 557     unless $out;
 558   my $in = new Autom4te::XFile ("< " . open_quote ($ocache . $req->id));
 559
 560   my %prohibited;
 561   my $res;
 562   while ($_ = $in->getline)
 563     {
 564       s/\s+$//;
 565       s/__oline__/$./g;
 566       s/\@<:\@/[/g;
 567       s/\@:>\@/]/g;
 568       s/\@\{:\@/(/g;
 569       s/\@:\}\@/)/g;
 570       s/\@S\|\@/\$/g;
 571       s/\@%:\@/#/g;
 572
 573       $res = $_;
 574
 575       # Don't complain in comments.  Well, until we have something
 576       # better, don't consider `#include' etc. are comments.
 577       s/\#.*//
 578         unless /^\#\s*(if|include|endif|ifdef|ifndef|define)\b/;
 579       foreach (split (/\W+/))
 580         {
 581           $prohibited{$_} = $.
 582             if !/^$/ && /$forbidden/o && !/$allowed/o && ! exists $prohibited{$_};
 583         }
 584
 585       # Performed *last*: the empty quadrigraph.
 586       $res =~ s/\@&t\@//g;
 587
 588       print $out "$res\n";
 589     }
 590
 591   $out->close();
 592
 593   # If no forbidden words, we're done.
 594   return
 595     if ! %prohibited;
 596
 597   # Locate the forbidden words in the last input file.
 598   # This is unsatisfying but...
 599   $exit_code = 1;
 600   if ($ARGV[$#ARGV] ne '-')
 601     {
 602       my $prohibited = '\b(' . join ('|', keys %prohibited) . ')\b';
 603       my $file = new Autom4te::XFile ("< " . open_quote ($ARGV[$#ARGV]));
 604
 605       while ($_ = $file->getline)
 606         {
 607           # Don't complain in comments.  Well, until we have something
 608           # better, don't consider `#include' etc. to be comments.
 609           s/\#.*//
 610             unless /^\#(if|include|endif|ifdef|ifndef|define)\b/;
 611
 612           # Complain once per word, but possibly several times per line.
 613           while (/$prohibited/)
 614             {
 615               my $word = $1;
 616               warn_forbidden ("$ARGV[$#ARGV]:$.", $word, %forbidden);
 617               delete $prohibited{$word};
 618               # If we're done, exit.
 619               return
 620                 if ! %prohibited;
 621               $prohibited = '\b(' . join ('|', keys %prohibited) . ')\b';
 622             }
 623         }
 624     }
 625   warn_forbidden ("$output:$prohibited{$_}", $_, %forbidden)
 626     foreach (sort { $prohibited{$a} <=> $prohibited{$b} } keys %prohibited);
 627 }
 628
 629
 630 ## --------------------- ##
 631 ## Handling the traces.  ##
 632 ## --------------------- ##
 633
 634
 635 # $M4_MACRO
 636 # trace_format_to_m4 ($FORMAT)
 637 # ----------------------------
 638 # Convert a trace $FORMAT into a M4 trace processing macro's body.
 639 sub trace_format_to_m4 ($)
 640 {
 641   my ($format) = @_;
 642   my $underscore = $_;
 643   my %escape = (# File name.
 644                 'f' => '$1',
 645                 # Line number.
 646                 'l' => '$2',
 647                 # Depth.
 648                 'd' => '$3',
 649                 # Name (also available as $0).
 650                 'n' => '$4',
 651                 # Escaped dollar.
 652                 '$' => '$');
 653
 654   my $res = '';
 655   $_ = $format;
 656   while ($_)
 657     {
 658       # $n -> $(n + 4)
 659       if (s/^\$(\d+)//)
 660         {
 661           $res .= "\$" . ($1 + 4);
 662         }
 663       # $x, no separator given.
 664       elsif (s/^\$([fldn\$])//)
 665         {
 666           $res .= $escape{$1};
 667         }
 668       # $.x or ${sep}x.
 669       elsif (s/^\$\{([^}]*)\}([@*%])//
 670             || s/^\$(.?)([@*%])//)
 671         {
 672           # $@, list of quoted effective arguments.
 673           if ($2 eq '@')
 674             {
 675               $res .= ']at_at([' . ($1 ? $1 : ',') . '], $@)[';
 676             }
 677           # $*, list of unquoted effective arguments.
 678           elsif ($2 eq '*')
 679             {
 680               $res .= ']at_star([' . ($1 ? $1 : ',') . '], $@)[';
 681             }
 682           # $%, list of flattened unquoted effective arguments.
 683           elsif ($2 eq '%')
 684             {
 685               $res .= ']at_percent([' . ($1 ? $1 : ':') . '], $@)[';
 686             }
 687         }
 688       elsif (/^(\$.)/)
 689         {
 690           error "invalid escape: $1";
 691         }
 692       else
 693         {
 694           s/^([^\$]+)//;
 695           $res .= $1;
 696         }
 697     }
 698
 699   $_ = $underscore;
 700   return '[[' . $res . ']]';
 701 }
 702
 703
 704 # handle_traces($REQ, $OUTPUT, %TRACE)
 705 # ------------------------------------
 706 # We use M4 itself to process the traces.  But to avoid name clashes when
 707 # processing the traces, the builtins are disabled, and moved into `at_'.
 708 # Actually, all the low level processing macros are in `at_' (and `_at_').
 709 # To avoid clashes between user macros and `at_' macros, the macros which
 710 # implement tracing are in `AT_'.
 711 #
 712 # Having $REQ is needed to neutralize the macros which have been traced,
 713 # but are not wanted now.
 714 sub handle_traces ($$%)
 715 {
 716   my ($req, $output, %trace) = @_;
 717
 718   verb "formatting traces for `$output': " . join (', ', sort keys %trace);
 719
 720   # Processing the traces.
 721   my $trace_m4 = new Autom4te::XFile ("> " . open_quote ("$tmp/traces.m4"));
 722
 723   $_ = <<'EOF';
 724   divert(-1)
 725   changequote([, ])
 726   # _at_MODE(SEPARATOR, ELT1, ELT2...)
 727   # ----------------------------------
 728   # List the elements, separating then with SEPARATOR.
 729   # MODE can be:
 730   #  `at'       -- the elements are enclosed in brackets.
 731   #  `star'     -- the elements are listed as are.
 732   #  `percent'  -- the elements are `flattened': spaces are singled out,
 733   #                and no new line remains.
 734   define([_at_at],
 735   [at_ifelse([$#], [1], [],
 736              [$#], [2], [[[$2]]],
 737              [[[$2]][$1]$0([$1], at_shift(at_shift($@)))])])
 738
 739   define([_at_percent],
 740   [at_ifelse([$#], [1], [],
 741              [$#], [2], [at_flatten([$2])],
 742              [at_flatten([$2])[$1]$0([$1], at_shift(at_shift($@)))])])
 743
 744   define([_at_star],
 745   [at_ifelse([$#], [1], [],
 746              [$#], [2], [[$2]],
 747              [[$2][$1]$0([$1], at_shift(at_shift($@)))])])
 748
 749   # FLATTEN quotes its result.
 750   # Note that the second pattern is `newline, tab or space'.  Don't lose
 751   # the tab!
 752   define([at_flatten],
 753   [at_patsubst(at_patsubst([[[$1]]], [\\\n]), [[\n\t ]+], [ ])])
 754
 755   define([at_args],    [at_shift(at_shift(at_shift(at_shift(at_shift($@)))))])
 756   define([at_at],      [_$0([$1], at_args($@))])
 757   define([at_percent], [_$0([$1], at_args($@))])
 758   define([at_star],    [_$0([$1], at_args($@))])
 759
 760 EOF
 761   s/^  //mg;s/\\t/\t/mg;s/\\n/\n/mg;
 762   print $trace_m4 $_;
 763
 764   # If you trace `define', then on `define([m4_exit], defn([m4exit])' you
 765   # will produce
 766   #
 767   #    AT_define([m4sugar.m4], [115], [1], [define], [m4_exit], <m4exit>)
 768   #
 769   # Since `<m4exit>' is not quoted, the outer m4, when processing
 770   # `trace.m4' will exit prematurely.  Hence, move all the builtins to
 771   # the `at_' name space.
 772
 773   print $trace_m4 "# Copy the builtins.\n";
 774   map { print $trace_m4 "define([at_$_], defn([$_]))\n" } @m4_builtin;
 775   print $trace_m4 "\n";
 776
 777   print $trace_m4 "# Disable them.\n";
 778   map { print $trace_m4 "at_undefine([$_])\n" } @m4_builtin;
 779   print $trace_m4 "\n";
 780
 781
 782   # Neutralize traces: we don't want traces of cached requests (%REQUEST).
 783   print $trace_m4
 784    "## -------------------------------------- ##\n",
 785    "## By default neutralize all the traces.  ##\n",
 786    "## -------------------------------------- ##\n",
 787    "\n";
 788   print $trace_m4 "at_define([AT_$_], [at_dnl])\n"
 789     foreach (sort keys %{$req->macro});
 790   print $trace_m4 "\n";
 791
 792   # Implement traces for current requests (%TRACE).
 793   print $trace_m4
 794     "## ------------------------- ##\n",
 795     "## Trace processing macros.  ##\n",
 796     "## ------------------------- ##\n",
 797     "\n";
 798   foreach (sort keys %trace)
 799     {
 800       # Trace request can be embed \n.
 801       (my $comment = "Trace $_:$trace{$_}") =~ s/^/\# /;
 802       print $trace_m4 "$comment\n";
 803       print $trace_m4 "at_define([AT_$_],\n";
 804       print $trace_m4 trace_format_to_m4 ($trace{$_}) . ")\n\n";
 805     }
 806   print $trace_m4 "\n";
 807
 808   # Reenable output.
 809   print $trace_m4 "at_divert(0)at_dnl\n";
 810
 811   # Transform the traces from m4 into an m4 input file.
 812   # Typically, transform:
 813   #
 814   # | m4trace:configure.ac:3: -1- AC_SUBST([exec_prefix], [NONE])
 815   #
 816   # into
 817   #
 818   # | AT_AC_SUBST([configure.ac], [3], [1], [AC_SUBST], [exec_prefix], [NONE])
 819   #
 820   # Pay attention that the file name might include colons, if under DOS
 821   # for instance, so we don't use `[^:]+'.
 822   my $traces = new Autom4te::XFile ("< " . open_quote ($tcache . $req->id));
 823   while ($_ = $traces->getline)
 824     {
 825       # Trace with arguments, as the example above.  We don't try
 826       # to match the trailing parenthesis as it might be on a
 827       # separate line.
 828       s{^m4trace:(.+):(\d+): -(\d+)- ([^(]+)\((.*)$}
 829        {AT_$4([$1], [$2], [$3], [$4], $5};
 830       # Traces without arguments, always on a single line.
 831       s{^m4trace:(.+):(\d+): -(\d+)- ([^)]*)\n$}
 832        {AT_$4([$1], [$2], [$3], [$4])\n};
 833       print $trace_m4 "$_";
 834     }
 835   $trace_m4->close;
 836
 837   my $in = new Autom4te::XFile ("$m4 " . shell_quote ("$tmp/traces.m4") . " |");
 838   my $out = new Autom4te::XFile ("> " . open_quote ($output));
 839
 840   # This is dubious: should we really transform the quadrigraphs in
 841   # traces?  It might break balanced [ ] etc. in the output.  The
 842   # consensus seeems to be that traces are more useful this way.
 843   while ($_ = $in->getline)
 844     {
 845       # It makes no sense to try to transform __oline__.
 846       s/\@<:\@/[/g;
 847       s/\@:>\@/]/g;
 848       s/\@\{:\@/(/g;
 849       s/\@:\}\@/)/g;
 850       s/\@S\|\@/\$/g;
 851       s/\@%:\@/#/g;
 852       s/\@&t\@//g;
 853       print $out $_;
 854     }
 855 }
 856
 857
 858 # $BOOL
 859 # up_to_date ($REQ)
 860 # -----------------
 861 # Are the cache files of $REQ up to date?
 862 # $REQ is `valid' if it corresponds to the request and exists, which
 863 # does not mean it is up to date.  It is up to date if, in addition,
 864 # its files are younger than its dependencies.
 865 sub up_to_date ($)
 866 {
 867   my ($req) = @_;
 868
 869   return 0
 870     if ! $req->valid;
 871
 872   my $tfile = $tcache . $req->id;
 873   my $ofile = $ocache . $req->id;
 874
 875   # We can't answer properly if the traces are not computed since we
 876   # need to know what other files were included.  Actually, if any of
 877   # the cache files is missing, we are not up to date.
 878   return 0
 879     if ! -f $tfile || ! -f $ofile;
 880
 881   # The youngest of the cache files must be older than the oldest of
 882   # the dependencies.
 883   my $tmtime = mtime ($tfile);
 884   my $omtime = mtime ($ofile);
 885   my ($file, $mtime) = ($tmtime < $omtime
 886                         ? ($ofile, $omtime) : ($tfile, $tmtime));
 887
 888   # We depend at least upon the arguments.
 889   my @dep = @ARGV;
 890
 891   # stdin is always out of date.
 892   if (grep { $_ eq '-' } @dep)
 893     { return 0 }
 894
 895   # Files may include others.  We can use traces since we just checked
 896   # if they are available.
 897   handle_traces ($req, "$tmp/dependencies",
 898                  ('include'    => '$1',
 899                   'm4_include' => '$1'));
 900   my $deps = new Autom4te::XFile ("< " . open_quote ("$tmp/dependencies"));
 901   while ($_ = $deps->getline)
 902     {
 903       chomp;
 904       my $file = find_file ("$_?", @include);
 905       # If a file which used to be included is no longer there, then
 906       # don't say it's missing (it might no longer be included).  But
 907       # of course, that causes the output to be outdated (as if the
 908       # time stamp of that missing file was newer).
 909       return 0
 910         if ! $file;
 911       push @dep, $file;
 912     }
 913
 914   # If $FILE is younger than one of its dependencies, it is outdated.
 915   return up_to_date_p ($file, @dep);
 916 }
 917
 918
 919 ## ---------- ##
 920 ## Freezing.  ##
 921 ## ---------- ##
 922
 923 # freeze ($OUTPUT)
 924 # ----------------
 925 sub freeze ($)
 926 {
 927   my ($output) = @_;
 928
 929   # When processing the file with diversion disabled, there must be no
 930   # output but comments and empty lines.
 931   my $result = xqx ("$m4"
 932                     . ' --fatal-warning'
 933                     . join (' --include=', '', map { shell_quote ($_) } @include)
 934                     . ' --define=divert'
 935                     . " " . files_to_options (@ARGV)
 936                     . ' </dev/null');
 937   $result =~ s/#.*\n//g;
 938   $result =~ s/^\n//mg;
 939
 940   fatal "freezing produced output:\n$result"
 941     if $result;
 942
 943   # If freezing produces output, something went wrong: a bad `divert',
 944   # or an improper paren etc.
 945   xsystem ("$m4"
 946            . ' --fatal-warning'
 947            . join (' --include=', '', map { shell_quote ($_) } @include)
 948            . " --freeze-state=" . shell_quote ($output)
 949            . " " . files_to_options (@ARGV)
 950            . ' </dev/null');
 951 }
 952
 953 ## -------------- ##
 954 ## Main program.  ##
 955 ## -------------- ##
 956
 957 mktmpdir ('am4t');
 958 load_configuration ($ENV{'AUTOM4TE_CFG'} || "$pkgdatadir/autom4te.cfg");
 959 load_configuration ("$ENV{'HOME'}/.autom4te.cfg")
 960   if exists $ENV{'HOME'} && -f "$ENV{'HOME'}/.autom4te.cfg";
 961 load_configuration (".autom4te.cfg")
 962   if -f ".autom4te.cfg";
 963 parse_args;
 964
 965 # Freezing does not involve the cache.
 966 if ($freeze)
 967   {
 968     freeze ($output);
 969     exit $exit_code;
 970   }
 971
 972 # We need our cache directory.  Don't fail with parallel creation.
 973 if (! -d "$cache")
 974   {
 975     mkdir "$cache", 0755
 976       or -d "$cache"
 977       or fatal "cannot create $cache: $!";
 978   }
 979
 980 # Open the index for update, and lock it.  autom4te handles several
 981 # files, but the index is the first and last file to be updated, so
 982 # locking it is sufficient.
 983 $icache_file = new Autom4te::XFile $icache, O_RDWR|O_CREAT;
 984 $icache_file->lock (LOCK_EX)
 985   if ($flock_implemented eq "yes");
 986
 987 # Read the cache index if available and older than autom4te itself.
 988 # If autom4te is younger, then some structures such as C4che might
 989 # have changed, which would corrupt its processing.
 990 Autom4te::C4che->load ($icache_file)
 991   if -f $icache && mtime ($icache) > mtime ($0);
 992
 993 # Add the new trace requests.
 994 my $req = Autom4te::C4che->request ('input' => \@ARGV,
 995                                     'path'  => \@include,
 996                                     'macro' => [keys %trace, @preselect]);
 997
 998 # If $REQ's cache files are not up to date, or simply if the user
 999 # discarded them (-f), declare it invalid.
1000 $req->valid (0)
1001   if $force || ! up_to_date ($req);
1002
1003 # We now know whether we can trust the Request object.  Say it.
1004 verb "the trace request object is:\n" . $req->marshall;
1005
1006 # We need to run M4 if (i) the user wants it (--force), (ii) $REQ is
1007 # invalid.
1008 handle_m4 ($req, keys %{$req->macro})
1009   if $force || ! $req->valid;
1010
1011 # Issue the warnings each time autom4te was run.
1012 my $separator = "\n" . ('-' x 25) . " END OF WARNING " . ('-' x 25) . "\n\n";
1013 handle_traces ($req, "$tmp/warnings",
1014                ('_m4_warn' => "\$1::\$f:\$l::\$2::\$3$separator"));
1015 # Swallow excessive newlines.
1016 for (split (/\n*$separator\n*/o, contents ("$tmp/warnings")))
1017 {
1018   # The message looks like:
1019   # | syntax::input.as:5::ouch
1020   # | ::input.as:4: baz is expanded from...
1021   # | input.as:2: bar is expanded from...
1022   # | input.as:3: foo is expanded from...
1023   # | input.as:5: the top level
1024   my ($cat, $loc, $msg, $stacktrace) = split ('::', $_, 4);
1025   msg $cat, $loc, "warning: $msg";
1026   for (split /\n/, $stacktrace)
1027     {
1028       my ($loc, $trace) = split (': ', $_, 2);
1029       msg $cat, $loc, $trace;
1030     }
1031 }
1032
1033 # Now output...
1034 if (%trace)
1035   {
1036     # Always produce traces, since even if the output is young enough,
1037     # there is no guarantee that the traces use the same *format*
1038     # (e.g., `-t FOO:foo' and `-t FOO:bar' are both using the same M4
1039     # traces, hence the M4 traces cache is usable, but its formatting
1040     # will yield different results).
1041     handle_traces ($req, $output, %trace);
1042   }
1043 else
1044   {
1045     # Actual M4 expansion, if the user wants it, or if $output is old
1046     # (STDOUT is pretty old).
1047     handle_output ($req, $output)
1048       if $force || mtime ($output) < mtime ($ocache . $req->id);
1049   }
1050
1051 # If we ran up to here, the cache is valid.
1052 $req->valid (1);
1053 Autom4te::C4che->save ($icache_file);
1054
1055 exit $exit_code;
1056
1057 ### Setup "GNU" style for perl-mode and cperl-mode.
1058 ## Local Variables:
1059 ## perl-indent-level: 2
1060 ## perl-continued-statement-offset: 2
1061 ## perl-continued-brace-offset: 0
1062 ## perl-brace-offset: 0
1063 ## perl-brace-imaginary-offset: 0
1064 ## perl-label-offset: -2
1065 ## cperl-indent-level: 2
1066 ## cperl-brace-offset: 0
1067 ## cperl-continued-brace-offset: 0
1068 ## cperl-label-offset: -2
1069 ## cperl-extra-newline-before-brace: t
1070 ## cperl-merge-trailing-else: nil
1071 ## cperl-continued-statement-offset: 2
1072 ## End: