autoconf-patches
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

FYI: autoupdate.in


From: Akim Demaille
Subject: FYI: autoupdate.in
Date: 21 Feb 2001 10:03:55 +0100
User-agent: Gnus/5.0808 (Gnus v5.8.8) XEmacs/21.1 (Cuyahoga Valley)

Yes, I am breaking the test suite, but I don't care.  This is the way
to go.

This is a quick and hopefully not too dirty translation of
autoupdate.sh in Perl, as I'm tired of fighting with sh, sed and the
rest of the pro-bugward-compatibility world ;)

I'm very confident in the quality of this translation: I performed
several autoupdate.sh and autoupdate.pl and the $tmp files were
exactly the same.  Oh, BTW, if someone knows how to deal with tmp dirs
in Perl, go ahead!  As is $tmp is hard wired to /tmp/autoupdate
(Yeek!), and is not even removed!

The main reason the test suite fails is that `-' standing as `update
stdin' is not yet supported.  I was too tired and couldn't under the
GetOpt manpage.  If someone feels like fixing this please do!
There is also a leading empty line which origin is yet unknown to me.
Again, if someone finds it, go ahead!


The plan is of course of get rid of all those `system' calls.  I am
still in favor of keeping many little files, they proved being
precious for long debugging session.

Nonetheless the most important task now is to get rid of sed
invocations.  I confirm that it's a change in the libc which is
responsible for the new failure of autoupdate: at home \b does reject
`_'.


It is on purpose that autoupdate.sh is not cvs removed, people might
need it to adjust autoupdate.in.  Once the test suite happy again,
once we are happy with autoupdate.in, we will remove it.  Nevertheless
it is no longer part of the dist.


Index: Makefile.am
===================================================================
RCS file: /cvs/autoconf/Makefile.am,v
retrieving revision 1.40
diff -u -u -r1.40 Makefile.am
--- Makefile.am 2001/01/22 09:04:59 1.40
+++ Makefile.am 2001/02/21 08:48:50
@@ -54,7 +54,7 @@
 EXTRA_DIST = ChangeLog.0 ChangeLog.1 \
              BUGS INSTALL.txt \
              acversion.m4.in \
-             autoconf.sh autoheader.sh autoreconf.sh autoupdate.sh ifnames.sh \
+             autoconf.sh autoheader.sh autoreconf.sh autoupdate.in ifnames.sh \
              autoscan.pl \
              $(distpkgdataDATA)
 
@@ -151,9 +151,9 @@
        chmod +x autoreconf.tmp
        mv autoreconf.tmp autoreconf
 
-autoupdate: $(srcdir)/autoupdate.sh $(srcdir)/configure.in
+autoupdate: $(srcdir)/autoupdate.in $(srcdir)/configure.in
        rm -f autoupdate autoupdate.tmp
-       $(edit) $(srcdir)/autoupdate.sh >autoupdate.tmp
+       $(edit) $(srcdir)/autoupdate.in >autoupdate.tmp
        chmod +x autoupdate.tmp
        mv autoupdate.tmp autoupdate
 
Index: Makefile.in
===================================================================
RCS file: /cvs/autoconf/Makefile.in,v
retrieving revision 1.121
diff -u -u -r1.121 Makefile.in
--- Makefile.in 2001/01/23 14:11:02 1.121
+++ Makefile.in 2001/02/21 08:48:50
@@ -95,7 +95,7 @@
 
 pkgdata_DATA = $(distpkgdataDATA) $(nodistpkgdataDATA)
 
-EXTRA_DIST = ChangeLog.0 ChangeLog.1              BUGS INSTALL.txt             
 acversion.m4.in              autoconf.sh autoheader.sh autoreconf.sh 
autoupdate.sh ifnames.sh              autoscan.pl              
$(distpkgdataDATA)
+EXTRA_DIST = ChangeLog.0 ChangeLog.1              BUGS INSTALL.txt             
 acversion.m4.in              autoconf.sh autoheader.sh autoreconf.sh 
autoupdate.in ifnames.sh              autoscan.pl              
$(distpkgdataDATA)
 
 
 # Files that should be removed, but which Automake does not know:
@@ -461,9 +461,9 @@
        chmod +x autoreconf.tmp
        mv autoreconf.tmp autoreconf
 
-autoupdate: $(srcdir)/autoupdate.sh $(srcdir)/configure.in
+autoupdate: $(srcdir)/autoupdate.in $(srcdir)/configure.in
        rm -f autoupdate autoupdate.tmp
-       $(edit) $(srcdir)/autoupdate.sh >autoupdate.tmp
+       $(edit) $(srcdir)/autoupdate.in >autoupdate.tmp
        chmod +x autoupdate.tmp
        mv autoupdate.tmp autoupdate
 
Index: autoupdate.in
===================================================================
RCS file: autoupdate.in
diff -N autoupdate.in
--- /dev/null   Tue Feb 13 06:06:23 2001
+++ autoupdate.in Wed Feb 21 00:48:50 2001
@@ -0,0 +1,1029 @@
+#! @PERL@ -w
+# autoupdate - modernize an Autoconf file.
+# Copyright 1994, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+
+# Originally written by David MacKenzie <address@hidden>.
+# Rewritten by Akim Demaille <address@hidden>.
+
+use Getopt::Long;
+use strict;
+
+(my $me = $0) =~ s,.*/,,;
+
+# Lib files.
+my $autoconf_dir = $ENV{"AC_MACRODIR"} || "@datadir@";
+
+my $autoconf = '';
+my $debug = 0;
+my $localdir = '.';
+# m4.
+my $m4 = $ENV{"M4"} || "@M4@";
+my $status = 0;
+# FIXME: Ahem....
+my $tmp = '/tmp/autoupdate.tmp';
+mkdir $tmp, 0700;
+my $verbose = 0;
+my $SIMPLE_BACKUP_SUFFIX = $ENV{'SIMPLE_BACKUP_SUFFIX'} || '~';
+
+
+## ---------- ##
+## Routines.  ##
+## ---------- ##
+
+
+# END
+# ---
+# Exit nonzero whenever closing STDOUT fails.
+sub END
+{
+  use POSIX qw (_exit);
+  # This is required if the code might send any output to stdout
+  # E.g., even --version or --help.  So it's best to do it unconditionally.
+  close STDOUT
+    or (warn "$me: closing standard output: $!\n"), _exit (1);
+}
+
+
+# print_usage ()
+# --------------
+# Display usage (--help).
+sub print_usage ()
+{
+  print "\
+Usage: $0 [OPTION] ...  [TEMPLATE-FILE...]
+
+Update the TEMPLATE-FILE... if given, or \`configure.ac' if present,
+or else \`configure.in', to the syntax of the current version of
+Autoconf.  The original files are backed up.
+
+Operation modes:
+  -h, --help           print this help, then exit
+  -V, --version        print version number, then exit
+  -v, --verbose        verbosely report processing
+  -d, --debug          don't remove temporary files
+
+Library directories:
+  -A, --autoconf-dir=ACDIR  Autoconf's macro files location (rarely needed)
+  -l, --localdir=DIR        location of \`aclocal.m4' and \`acconfig.h'
+
+Environment variables:
+  M4         GNU M4 is required.
+  AUTOCONF   autoconf.
+
+Report bugs to <address@hidden>.
+";
+  exit 0;
+}
+
+
+# print_version ()
+# ----------------
+# Display version (--version).
+sub print_version
+{
+  print "\
+autoupdate (@PACKAGE_NAME@) @VERSION@
+Written by David J. MacKenzie and Akim Demaille.
+
+Copyright 1994, 1999, 2000, 2001 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+";
+  exit 0;
+}
+
+
+# $CONFIGURE_AC
+# &find_configure_ac ()
+# ---------------------
+sub find_configure_ac ()
+{
+  if (-f 'configure.ac')
+    {
+      if (-f 'configure.in')
+       {
+         warn "warning: `configure.ac' and `configure.in' both present.\n";
+         warn "warning: proceeding with `configure.ac'.\n";
+       }
+      return 'configure.ac';
+    }
+  elsif (-f 'configure.in')
+    {
+      return 'configure.in';
+    }
+  return;
+}
+
+
+# parse_args ()
+# -------------
+# Process any command line arguments.
+sub parse_args ()
+{
+  my $srcdir;
+  Getopt::Long::config ("bundling");
+  Getopt::Long::GetOptions ("A|autoconf-dir|m|macrodir=s" => \$autoconf_dir,
+                           "h|help" => \&print_usage,
+                           "V|version" => \&print_version,
+                           "v|verbose" => \$verbose)
+    or exit 1;
+  if (! @ARGV)
+    {
+      my $configure_ac = find_configure_ac;
+      die 'no input file'
+       unless $configure_ac;
+      push @ARGV, $configure_ac;
+    }
+}
+
+
+# find_slaves
+# -----------
+# Find the lib files and autoconf.
+sub find_slaves ()
+{
+  # Some non-GNU m4's don't reject the --help option, so give them /dev/null.
+  die "Autoconf requires GNU m4 1.4 or later\n"
+    if system "$m4 --help </dev/null 2>&1 | fgrep reload-state >/dev/null";
+
+  # autoconf.
+  (my $dir = $0) =~ s,[^/]*$,,;
+
+  # We test "$dir/autoconf" in case we are in the build tree, in which case
+  # the names are not transformed yet.
+  foreach my $file ($ENV{"AUTOCONF"} || '',
+                   "$dir/@autoconf-name@",
+                   "$dir/autoconf",
+                   "@bindir@/@autoconf-name@")
+    {
+      if (-x $file)
+       {
+         $autoconf = $file;
+         last;
+       }
+    }
+}
+
+
+## -------------- ##
+## Main program.  ##
+## -------------- ##
+find_slaves;
+parse_args;
+$autoconf .= " -l $localdir";
+$ENV{'autoconf_dir'} = $autoconf_dir;
+
+# m4.txt -- the builtins of m4.
+system ("echo dumpdef | "
+       . "$m4 2>&1 >/dev/null | "
+       . "sed -n 's/:.*//p' "
+       . ">$tmp/m4.txt");
+
+# m4.m4 -- enable the m4 builtins.
+system ("sed 's/^.*\$/_au_define([&], _au_defn([_au_&]))/' $tmp/m4.txt "
+       . ">$tmp/m4.m4");
+
+# unm4.m4 -- disable the m4 builtins.
+system ("sed 's/^.*\$/_au_undefine([&])/' $tmp/m4.txt >$tmp/unm4.m4");
+
+# savem4.m4 -- save the m4 builtins.
+system ("sed 's/^.*\$/define([_au_&], defn([&]))/' $tmp/m4.txt "
+       . ">$tmp/m4save.m4");
+
+# au.txt -- list of all the AU macros.
+system ("$autoconf --trace AU_DEFUN:'\$1' -i /dev/null | "
+       . "sort -u "
+       . ">$tmp/au.txt");
+
+# au-del.sed -- delete the AU macro names.
+system ("sed \"s,^.*\$,/&/d,\" $tmp/au.txt "
+       . " >$tmp/au-del.sed");
+
+# au.m4 -- definitions the AU macros.
+system ("$autoconf --trace AU_DEFUN:'_au_defun(\@<:address@hidden@:>\@,
+\@<:address@hidden@:>\@)' -i /dev/null "
+       . ">$tmp/au.m4");
+
+# quote.sed -- enable the quote `[', `]' right before any AU macro.
+# Unfortunately, I can't see a solution which does not use `\b', which
+# is a GNU extension :(.  Am I understanding we should use Perl?
+system ('sed \'s/^.*$/s!\\\\b&\\\\b!_au_changequote([,])\\&!/\'' . " 
$tmp/au.txt "
+       . ">$tmp/quote.sed");
+
+# ac.txt -- list of all the AC and m4sugar macros prefixed by the name
+# of the file which defines it.
+# Be carefull to remove the AU macros.
+system ("$autoconf --trace define:'\$f:\$1' -i /dev/null | "
+       . "sed -f $tmp/au-del.sed "
+       . ">$tmp/ac.txt");
+
+# ac.m4 -- autoquoting definitions of the AC macros.
+system ('sed -n \'/m4sugar.m4/!s/^[^:]*:\(.*\)$/_au_define([\1], 
[[$0($@)]])/p\''
+       . " $tmp/ac.txt"
+       . ">$tmp/ac.m4");
+
+# disable.m4 -- undefine the macros of AC and m4sugar.
+system ('sed \'s/^[^:]*:\\(.*\\)$/_au_undefine([\1])/\'' . " $tmp/ac.txt "
+       . ">$tmp/disable.m4");
+
+foreach my $file (@ARGV)
+  {
+    my $filename = $file;
+    # We need an actual file.
+    if ($file eq '-')
+      {
+       $file = "$tmp/stdin";
+       system "cat >$file";
+      }
+    elsif (! -r "$file")
+      {
+       die "$me: $file: No such file or directory";
+      }
+
+    # input.m4 -- m4 program to produce the updated file.
+    # Load the values, the dispatcher, neutralize m4, and the prepared
+    # input file.
+    my $input_m4 = <<EOF;
+      divert(-1)                                            -*- Autoconf -*-
+      changequote([, ])
+
+      # Move all the builtins into the \`_au_' pseudo namespace
+      include([$tmp/m4save.m4])
+
+      # _au_defun(NAME, BODY)
+      # ---------------------
+      # Define NAME to BODY, plus AU activation/deactivation.
+      _au_define([_au_defun],
+      [_au_define([\$1],
+      [_au_enable()dnl
+      \$2[]dnl
+      _au_disable()])])
+
+      # Import the definition of the obsolete macros.
+      _au_include([$tmp/au.m4])
+
+
+      ## ------------------------ ##
+      ## _au_enable/_au_disable.  ##
+      ## ------------------------ ##
+
+      # They work by pair: each time an AU macro is activated, it runs
+      # _au_enable, and at its end its runs _au_disable (see _au_defun
+      # above).  But since AU macros might use AU macros, which should
+      # enable/disable only for the outter AU macros.
+      #
+      # \`_au_enabled' is used to this end, condionning whether we really
+      # enable/disable.
+
+
+      # __au_enable
+      # -----------
+      # Reenable the builtins, and m4sugar.
+      _au_define([__au_enable],
+      [_au_divert(-1)
+      # Enable special characters.
+      _au_changecom([#])
+
+      # Enable the m4 builtins, m4sugar and the autoquoting AC macros.
+      _au_include([$tmp/m4.m4])
+      _au_include([$autoconf_dir/m4sugar.m4])
+      _au_include([$tmp/ac.m4])
+
+      _au_divert(0)])
+
+      # _au_enable
+      # ----------
+      # Called at the beginning of all the obsolete macros.  Reenable the
+      # builtins, and m4sugar if needed.
+      _au_define([_au_enable],
+      [_au_ifdef([_au_enabled],
+                 [],
+                 [__au_enable()])_au_dnl
+      _au_pushdef([_au_enabled])])
+
+
+      # __au_disable
+      # ------------
+      # Disable the builtins, and m4sugar.
+      _au_define([__au_disable],
+      [_au_divert(-1)
+      # Disable m4sugar, the AC autoquoting macros, and m4.
+      _au_include([$tmp/disable.m4])
+      _au_include([$tmp/unm4.m4])
+
+      # Disable special characters.
+      _au_changequote()
+      _au_changecom()
+
+      _au_divert(0)])
+
+      # _au_disable
+      # -----------
+      # Called at the end of all the obsolete macros.  Disable the
+      # builtins, and m4sugar if needed..
+      _au_define([_au_disable],
+      [_au_popdef([_au_enabled])_au_dnl
+      _au_ifdef([_au_enabled],
+                [],
+                [__au_disable()])])
+
+
+      ## ------------------------------- ##
+      ## Disable, and process the file.  ##
+      ## ------------------------------- ##
+      _au_disable()_au_dnl
+EOF
+
+    $input_m4 =~ s/^      //mg;
+
+    # prepared input -- input, but reenables the quote before each AU macro.
+    open INPUT_M4, ">$tmp/input.m4";
+    print INPUT_M4 "$input_m4\n";
+    close INPUT_M4;
+    system ("sed -f $tmp/quote.sed $file >>$tmp/input.m4");
+
+    # Now ask m4 to perform the update.
+    print STDERR "$me: running $m4 $tmp/input.m4"
+       if $verbose;
+    system ("$m4 $tmp/input.m4 >$tmp/updated") == 0
+       or die "$me: cannot update \`$filename'";
+
+    if ("$file" eq "$tmp/stdin")
+       {
+        system ("cat $tmp/updated");
+       }
+    elsif (! system ("cmp -s $tmp/updated $file"))
+       {
+        # File didn't change, so don't update its mod time.
+        print STDERR "$me: \`$file' is unchanged\n"
+       }
+    else
+       {
+        # Back up and install the new one.
+        if (system ("mv $file $file${SIMPLE_BACKUP_SUFFIX} && "
+                    . "mv $tmp/updated $file") == 0)
+          {
+            print STDERR "$me: \`$file' is updated\n";
+          }
+        else
+          {
+            die "$me: cannot update \`$file'";
+          }
+       }
+  }
+
+exit 0;
+
+
+#                ## ---------------------------- ##
+#                ## How `autoupdate' functions.  ##
+#                ## ---------------------------- ##
+#
+# The task of `autoupdate' is not trivial: the biggest difficulty being
+# that you must limit the changes to the parts that really need to be
+# updated.  Finding a satisfying implementation proved to be quite hard,
+# as this is the fourth implementation of `autoupdate'.
+#
+# Below, we will use a simple example of obsolete macro:
+#
+#     AU_DEFUN([OLD], [NEW([$1, $2], m4_eval([$1 + $2]))])
+#     AC_DEFUN([NEW], [echo "sum($1) = $2"])
+#
+# the input file contains
+#
+#     dnl The Unbelievable Truth
+#     OLD(1, 2)
+#     NEW([0, 0], [0])
+#
+# Of course the expected output is
+#
+#     dnl The Unbelievable Truth
+#     NEW([1, 2], [3])
+#     NEW([0, 0], [0])
+#
+#
+# # First implementation: sed
+# # =========================
+#
+# The first implementation was only able to change the name of obsolete
+# macros.
+#
+# The file `acoldnames.m4' defined the old names based on the new names.
+# It was simple then to produce a sed script such as:
+#
+#     s/OLD/NEW/g
+#
+# Updating merely consisted in running this script on the file to
+# update.
+#
+# This scheme suffers an obvious limitation: that `autoupdate' was
+# unable to cope with new macros that just swap some of its arguments
+# compared to the old macro.  Fortunately, that was enough to upgrade
+# from Autoconf 1 to Autoconf 2.  (But I have no idea whether the
+# changes in Autoconf 2 were precisely limited by this constraint.)
+#
+#
+# # Second implementation: hooks
+# # ============================
+#
+# The version 2.15 of Autoconf brought a vast number of changes compared
+# to 2.13, so a solution was needed.  One could think to extend the
+# `sed' scripts with specialized code for complex macros.  But this
+# approach is of course full of flaws:
+#
+# a. the Autoconf maintainers have to write these snippets, which we
+#    just don't want to,
+#
+# b. I really don't think you'll ever manage to handle the quoting of
+#    m4 from sed.
+#
+# To satisfy a., let's remark that the code which implements the old
+# features in term of the new feature is exactly the code which should
+# replace the old code.
+#
+# To answer point b, as usual in the history of Autoconf, the answer, at
+# least on the paper, is simple: m4 is the best tool to parse m4, so
+# let's use m4.
+#
+# Therefore the specification is:
+#
+#     I want to be able to tell Autoconf, well, m4, that the macro I
+#     am currently defining is an obsolete macro (so that the user is
+#     warned), which code is the code to use when running autoconf,
+#     but that the very same code has to be used when running
+#     autoupdate.  To summarize, the interface I want is
+#     `AU_DEFUN(OLD-NAME, NEW-CODE)'.
+#
+#
+# Now for the technical details.
+#
+# When running autoconf, except for the warning, AU_DEFUN is basically
+# AC_DEFUN.
+#
+# When running autoupdate, we want *only* OLD-NAMEs to be expanded.
+# This obviously means that acgeneral.m4 and acspecific.m4 must not be
+# loaded.  Nonetheless, because we want to use a rich set of m4
+# features, m4sugar.m4 is needed.  Please note that the fact that
+# Autoconf's macros are not loaded is positive on two points:
+#
+# - we do get an updated `configure.ac', not a `configure'!
+#
+# - the old macros are replaced by *calls* to the new-macros, not the
+#   body of the new macros, since their body is not defined!!!
+#   (Whoa, that's really beautiful!).
+#
+# Additionally we need to disable the quotes when reading the input for
+# two reasons: first because otherwise `m4' will swallow the quotes of
+# other macros:
+#
+#     NEW([1, 2], 3)
+#     => NEW(1, 2, 3)
+#
+# and second, because we want to update the macro calls which are
+# quoted, i.e., we want
+#
+#     FOO([OLD(1, 2)])
+#     => FOO([NEW([1, 2], [3])])
+#
+# If we don't disable the quotes, only the macros called at the top
+# level would be updated.
+#
+# So, let's disable the quotes.
+#
+# Well, not quite: m4sugar.m4 still needs to use quotes for some macros.
+# Well, in this case, when running in autoupdate code, each macro first
+# reestablishes the quotes, expands itself, and disables the quotes.
+#
+# Thinking a bit more, you realize that in fact, people may use `define'
+# `ifelse' etc. in their files, and you certainly don't want to process
+# them.  Another example is `dnl': you don't want to remove the
+# comments.  You then realize you don't want exactly to import m4sugar:
+# you want to specify when it is enabled (macros active), and disabled.
+# m4sugar provides m4_disable/m4_enable to this end.
+#
+# You're getting close to it.  Now remains one task: how to handle
+# twofold definitions?
+#
+# Remember that the same AU_DEFUN must be understood in two different
+# ways, the AC way, and the AU way.
+#
+# One first solution is to check whether acgeneral.m4 was loaded.  But
+# that's definitely not cute.  Another is simply to install `hooks',
+# that is to say, to keep in some place m4 knows, late `define' to be
+# triggered *only* in AU mode.
+#
+# You first think to design AU_DEFUN like this:
+#
+# 1. AC_DEFUN(OLD-NAME,
+#            [Warn the user OLD-NAME is obsolete.
+#             NEW-CODE])
+#
+# 2. Store for late AU binding([define(OLD_NAME,
+#                              [Reestablish the quotes.
+#                               NEW-CODE
+#                               Disable the quotes.])])
+#
+# but this will not work: NEW-CODE has probably $1, $2 etc. and these
+# guys will be replaced with the argument of `Store for late AU binding'
+# when you call it.
+#
+# I don't think there is a means to avoid this using this technology
+# (remember that $1 etc. are *always* expanded in m4).  You may also try
+# to replace them with $[1] to preserve them for a later evaluation, but
+# if `Store for late AU binding' is properly written, it will remain
+# quoted till the end...
+#
+# You have to change technology.  Since the problem is that `$1'
+# etc. should be `consumed' right away, one solution is to define now a
+# second macro, `AU_OLD-NAME', and to install a hook than binds OLD-NAME
+# to AU_OLD-NAME.  Then, autoupdate.m4 just need to run the hooks.  By
+# the way, the same method was used in autoheader.
+#
+#
+# # Third implementation: m4 namespaces by m4sugar
+# # ==============================================
+#
+# Actually, this implementation was just a clean up of the previous
+# implementation: instead of defining hooks by hand, m4sugar was equipped
+# with `namespaces'.  What are they?
+#
+# Sometimes we want to disable some *set* of macros, and restore them
+# later.  We provide support for this via namespaces.
+#
+# There are basically three characters playing this scene: defining a
+# macro in a namespace, disabling a namespace, and restoring a namespace
+# (i.e., all the definitions it holds).
+#
+# Technically, to define a MACRO in NAMESPACE means to define the macro
+# named `NAMESPACE::MACRO' to the VALUE.  At the same time, we append
+# `undefine(NAME)' in the macro named `m4_disable(NAMESPACE)', and
+# similarly a binding of NAME to the value of `NAMESPACE::MACRO' in
+# `m4_enable(NAMESPACE)'.  These mechanisms allow to bind the macro of
+# NAMESPACE and to unbind them at will.
+#
+# Of course this implementation is really inefficient: m4 has to grow
+# strings which can become quickly huge, which slows it significantly.
+#
+# In particular one should avoid as much as possible to use `define' for
+# temporaries.  Now that `define' as quite a complex meaning, it is an
+# expensive operations that should be limited to macros.  Use
+# `m4_define' for temporaries.
+#
+# Private copies of the macros we used in entering / exiting the m4sugar
+# namespace.  It is much more convenient than fighting with the renamed
+# version of define etc.
+#
+#
+#
+# Those two implementations suffered from serious problems:
+#
+# - namespaces were really expensive, and incurred a major performance
+#   loss on `autoconf' itself, not only `autoupdate'.  One solution
+#   would have been the limit the use of namespaces to `autoupdate', but
+#   that's again some complications on m4sugar, which really doesn't need
+#   this.  So we wanted to get rid of the namespaces.
+#
+# - since the quotes were disabled, autoupdate was sometimes making
+#   wrong guesses, for instance on:
+#
+#     foo([1, 2])
+#
+#   m4 saw 2 arguments: `[1'and `2]'.  A simple solution, somewhat
+#   fragile, is to reestablish the quotes right before all the obsolete
+#   macros, i.e., to use sed so that the previous text becomes
+#
+#     changequote([, ])foo([1, 2])
+#
+#   To this end, one wants to trace the definition of obsolete macros.
+#
+# It was there that the limitations of the namespace approach became
+# painful: because it was a complex machinery playing a lot with the
+# builtins of m4 (hence, quite fragile), tracing was almost impossible.
+#
+#
+# So this approach was dropped.
+#
+#
+# # The fourth implementation: two steps
+# # ====================================
+#
+# If you drop the uses of namespaces, you no longer can compute the
+# updated value, and replace the old call with it simultaneously.
+#
+# Obviously you will use m4 to compute the updated values, but you may
+# use some other tool to achieve the replacement.  Personally, I trust
+# nobody but m4 to parse m4, so below, m4 will perform the two tasks.
+#
+# How can m4 be used to replace *some* macros calls with newer values.
+# Well, that's dead simple: m4 should learn the definitions of obsolete
+# macros, forget its builtins, disable the quotes, and then run on the
+# input file, which amounts to doing this:
+#
+#     divert(-1)dnl
+#     changequote([, ])
+#     define([OLD], [NEW([$1, $2], m4_eval([$1 + $2]))changequote()])
+#     undefine([dnl])
+#     undefine([m4_eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     NEW([0, 0],
+#        0)
+#
+# which will result in
+#
+#     dnl The Unbelievable Truth
+#     NEW(1, 2, m4_eval(1 + 2))
+#     NEW([0, 0],
+#        0)
+#
+# Grpmh.  Two problems.  A minor problem: it would have been much better
+# to have the `m4_eval' computed, and a major problem: you lost the
+# quotation in the result.
+#
+# Let's address the big problem first.  One solution is to define any
+# modern macro to rewrite its calls with the proper quotation, thanks to
+# `$@'.  Again, tracing the `define's makes it possible to know which
+# are these macros, so you input is:
+#
+#     divert(-1)dnl
+#     changequote([, ])
+#     define([OLD], [NEW([$1, $2], m4_eval([$1 + $2]))changequote()])
+#     define([NEW], [[NEW($@)]changequote()])
+#     undefine([dnl])
+#     undefine([m4_eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     changequote([, ])NEW([0, 0],
+#        0)
+#
+# which results in
+#
+#     dnl The Unbelievable Truth
+#     NEW([1, 2],[m4_eval(1 + 2)])
+#     NEW([0, 0],[0])
+#
+# Our problem is solved, i.e., the first call to `NEW' is properly
+# quoted, but introduced another problem: we changed the layout of the
+# second calls, which can be a drama in the case of huge macro calls
+# (think of `AC_TRY_RUN' for instance).  This example didn't show it,
+# but we also introduced parens to macros which did not have some:
+#
+#     AC_INIT
+#     => AC_INIT()
+#
+# No big deal for the semantics (unless the macro depends upon $#, which
+# is bad), but the users would not be happy.
+#
+# Additionally, we introduced quotes that we not there before, which is
+# OK in most cases, but could change the semantics of the file.
+#
+# Cruel dilemma: we do want the auto-quoting definition of `NEW' when
+# evaluating `OLD', but we don't when we evaluate the second `NEW'.
+# Back to namespaces?
+#
+# No.
+#
+#
+# # Second step: replacement
+# # ------------------------
+#
+# No, as announced above, we will work in two steps: in a first step we
+# compute the updated values, and in a second step we replace them.  Our
+# goal is something like this:
+#
+#     divert(-1)dnl
+#     changequote([, ])
+#     define([OLD], [NEW([1, 2], [3])changequote()])
+#     undefine([dnl])
+#     undefine([m4_eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     NEW([0, 0],
+#        0)
+#
+# i.e., the new value of `OLD' is precomputed using the auto-quoting
+# definition of `NEW' and the m4 builtins.  We'll see how afterwards,
+# let's finish with the replacement.
+#
+# Of course the solution above is wrong: if there were other calls to
+# `OLD' with different values, we would smash them to the same value.
+# But it is quite easy to generalize the scheme above:
+#
+#     divert(-1)dnl
+#     changequote([, ])
+#     define([OLD([1],[2])], [NEW([1, 2], [3])])
+#     define([OLD], [defn([OLD($@)])changequote()])
+#     undefine([dnl])
+#     undefine([m4_eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     NEW([0, 0],
+#        0)
+#
+# i.e., for each call to obsolete macros, we build an array `call =>
+# value', and use a macro to dispatch these values.  This results in:
+#
+#     dnl The Unbelievable Truth
+#     NEW([1, 2], [3])
+#     NEW([0, 0],
+#        0)
+#
+# In French, we say `Youpi !', which you might roughly translate as
+# `yipeee!'.
+#
+#
+# # First step: computation
+# # -----------------------
+#
+# Let's study the anatomy of the file, and name its sections:
+#
+# prologue
+#     divert(-1)dnl
+#     changequote([, ])
+# values
+#     define([OLD([1],[2])], [NEW([1, 2], [3])])
+# dispatcher
+#     define([OLD], [defn([OLD($@)])changequote()])
+# disabler
+#     undefine([dnl])
+#     undefine([m4_eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+# input
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     NEW([0, 0],
+#        0)
+#
+#
+# # Computing the `values' section
+# # ..............................
+#
+# First we need to get the list of all the AU macro uses.  To this end,
+# first get the list of all the AU macros names by tracing `AU_DEFUN' in
+# the initialization of autoconf.  This list is computed in the file
+# `au.txt' below.
+#
+# Then use this list to trace all the AU macro uses in the input.  The
+# goal is obtain in the case of our example:
+#
+#     [define([OLD([1],[2])],]@<<@OLD([1],[2])@>>@[)]
+#
+# This is the file `values.in' below.
+#
+# We want to evaluate this with only the builtins (in fact m4sugar), the
+# auto-quoting definitions of the new macros (`new.m4'), and the
+# definition of the old macros (`old.m4').  Computing these last two
+# files is easy: it's just a matter of using the right `--trace' option.
+#
+# So the content of `values.in' is:
+#
+#     include($autoconf_dir/m4sugar.m4)
+#     m4_include(new.m4)
+#     m4_include(old.m4)
+#     divert(0)dnl
+#     [define([OLD([1],[2])],]@<<@OLD([1],[2])@>>@[)]
+#
+# We run m4 on it, which yields:
+#
+#     define([OLD([1],[2])],@<<@NEW([1, 2], [3])@>>@)
+#
+# Transform `@<<@' and `@>>@' into quotes and we get
+#
+#     define([OLD([1],[2])],[NEW([1, 2], [3])])
+#
+# This is `values.m4'.
+#
+#
+# # Computing the `dispatcher' section
+# # ..................................
+#
+# The `prologue', and the `disabler' are simple and need no commenting.
+#
+# To compute the `dispatcher' (`dispatch.m4'), again, it is a simple
+# matter of using the right `--trace'.
+#
+# Finally, the input is not exactly the input file, rather it is the
+# input file with the added `changequote'.  To this end, we build
+# `quote.sed'.
+#
+#
+# # Putting it all together
+# # .......................
+#
+# We build the file `input.m4' which contains:
+#
+#     divert(-1)dnl
+#     changequote([, ])
+#     include(values.m4)
+#     include(dispatch.m4)
+#     undefine([dnl])
+#     undefine([eval])
+#     # Some more undefines...
+#     changequote()
+#     divert(0)dnl
+#     dnl The Unbelievable Truth
+#     changequote([, ])OLD(1, 2)
+#     NEW([0, 0],
+#        0)
+#
+# And we just run m4 on it.  Et voila`, Monsieur !  Mais oui, mais oui.
+#
+# Well, there are a few additional technicalities.  For instance, we
+# rely on `changequote', `ifelse' and `defn', but we don't want to
+# interpret the changequotes of the user, so we simply use another name:
+# `_au_changequote' etc.
+#
+#
+# # Failure of the fourth approach
+# # ------------------------------
+#
+# This approach is heavily based on traces, but then there is an obvious
+# problem: non expanded code will never be seen/ In particular, the body
+# of a `define' definition is not seen, so on the input
+#
+#        define([idem], [OLD(0, [$1])])
+#
+# autoupdate would never see the `OLD', and wouldn't have updated it.
+# Worse yet, if `idem(0)' was used later, then autoupdate sees that
+# `OLD' is used, computes the result for `OLD(0, 0)' and sets up a
+# dispatcher for `OLD'.  Since there was no computed value for `OLD(0,
+# [$1])', the dispatcher would have replaced with... nothinhg, leading
+# to
+#
+#        define([idem], [])
+#
+# With some more thinking, you see that the two step approach is wrong,
+# the namespace approach was much saner.
+#
+# But you learned a lot, in particular you realized that using traces
+# can make it possible to simulate namespaces!
+#
+#
+#
+# # The fifth implementation: m4 namespaces by files
+# # ================================================
+#
+# The fourth implementation demonstrated something unsurprising: you
+# cannot precompute, i.e., the namespace approach was the right one.
+# Still, we no longer want them, they're too expensive.  Let's have a
+# look at the way it worked.
+#
+# When updating
+#
+#     dnl The Unbelievable Truth
+#     OLD(1, 2)
+#     NEW([0, 0], [0])
+#
+# you evaluate `input.m4':
+#
+#     divert(-1)
+#     changequote([, ])
+#     define([OLD],
+#     [m4_enable()NEW([$1, $2], m4_eval([$1 + $2]))m4_disable()])
+#     ...
+#     m4_disable()
+#     dnl The Unbelievable Truth
+#     OLD(1, 2)
+#     NEW([0, 0], [0])
+#
+# where `m4_disable' undefines the m4 and m4sugar, and disables the quotes
+# and comments:
+#
+#     define([m4_disable],
+#     [undefine([__file__])
+#     ...
+#     changecom(#)
+#     changequote()])
+#
+# `m4_enable' does the converse: reestablish quotes and comments
+# --easy--, reestablish m4sugar --easy: just load `m4sugar.m4' again-- and
+# reenable the builtins.  This later task requires that you first save
+# the builtins.  And BTW, the definition above of `m4_disable' cannot
+# work: you undefined `changequote' before using it!  So you need to use
+# your privates copies of the builtins.  Let's introduce three files for
+# this:
+#
+#  `m4save.m4'
+#    moves the m4 builtins into the `_au_' pseudo namespace
+#  `unm4.m4'
+#    undefines the builtins
+#  `m4.m4'
+#    restores them
+#
+# So `input.m4' is:
+#
+#     divert(-1)
+#     changequote([, ])
+#
+#     include([m4save.m4])
+#
+#     # Import AU.
+#     define([OLD],
+#     [m4_enable()NEW([$1, $2], m4_eval([$1 + $2]))m4_disable()])
+#
+#     define([_au_enable],
+#     [_au_changecom([#])
+#     _au_include([m4.m4])
+#     _au_include(m4sugar.m4)])
+#
+#     define([_au_disable],
+#     [# Disable m4sugar.
+#     # Disable the m4 builtins.
+#     _au_include([unm4.m4])
+#     # 1. Disable special characters.
+#     _au_changequote()
+#     _au_changecom()])
+#
+#     m4_disable()
+#     dnl The Unbelievable Truth
+#     OLD(1, 2)
+#     NEW([0, 0], [0])
+#
+# Based on what we learned in the fourth implementation we know that we
+# have to enable the quotes *before* any AU macro, and we know we need
+# to build autoquoting versions of the AC macros.  But the autoquoting
+# AC definitions must be disabled in the rest of the file, and enabled
+# inside AU macros.
+#
+# Using `autoconf --trace' it is easy to build the files
+#
+#   `ac.m4'
+#     define the autoquoting AC fake macros
+#   `disable.m4'
+#     undefine the m4sugar and AC autoquoting macros.
+#   `au.m4'
+#     definitions of the AU macros (such as `OLD' above).
+#
+# Now, `input.m4' is:
+#
+#     divert(-1)
+#     changequote([, ])
+#
+#     include([m4save.m4])
+#     # Import AU.
+#     include([au.m4])
+#
+#     define([_au_enable],
+#     [_au_changecom([#])
+#     _au_include([m4.m4])
+#     _au_include(m4sugar.m4)
+#     _au_include(ac.m4)])
+#
+#     define([_au_disable],
+#     [_au_include([disable.m4])
+#     _au_include([unm4.m4])
+#     # 1. Disable special characters.
+#     _au_changequote()
+#     _au_changecom()])
+#
+#     m4_disable()
+#     dnl The Unbelievable Truth
+#     _au_changequote([, ])OLD(1, 2)
+#     NEW([0, 0], [0])
+#
+# Finally, version V is ready.
+#
+# Well... almost.
+#
+# There is a slight problem that remains: if an AU macro OUTTER includes
+# an AU macro INNER, then _au_enable will be run when entering OUTTER
+# and when entering INNER (not good, but not too bad yet).  But when
+# getting out of INNER, _au_disable will disable everything while we
+# were still in OUTTER.  Badaboom.
+#
+# Therefore _au_enable and _au_disable have to be written to work by
+# pairs: each _au_enable pushdef's _au_enabled, and each _au_disable
+# popdef's _au_enabled.  And of course _au_enable and _au_disable are
+# effective when _au_enabled is *not* defined.
+#
+# Finally, version V' is ready.  And there is much rejoicing.  (And I
+# have free time again.  I think.  Yeah, right.)
Index: tests/tools.at
===================================================================
RCS file: /cvs/autoconf/tests/tools.at,v
retrieving revision 1.24
diff -u -u -r1.24 tools.at
--- tests/tools.at 2001/01/22 08:59:02 1.24
+++ tests/tools.at 2001/02/21 08:48:50
@@ -54,7 +54,6 @@
   # when running `sh PROG'.
   AT_CHECK([/bin/sh -n ../autoconf],   0)
   AT_CHECK([/bin/sh -n ../autoreconf], 0)
-  AT_CHECK([/bin/sh -n ../autoupdate], 0)
   AT_CHECK([/bin/sh -n ../ifnames],    0)
 
   # These are not built, they are in the src tree.




reply via email to

[Prev in Thread] Current Thread [Next in Thread]