build-aux/autotroll.m4

   1 # Build Qt apps with the autotools (Autoconf/Automake).
   2 # M4 macros.
   3 # This file is part of AutoTroll.
   4 # Copyright (C) 2006  Benoit Sigoure <benoit.sigoure@lrde.epita.fr>
   5 #
   6 # AutoTroll is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU General Public License
   8 # as published by the Free Software Foundation; either version 2
   9 # of the License, or (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19 # USA.
  20 #
  21 # In addition, as a special exception, the copyright holders of AutoTroll
  22 # give you unlimited permission to copy, distribute and modify the configure
  23 # scripts that are the output of Autoconf when processing the macros of
  24 # AutoTroll.  You need not follow the terms of the GNU General Public License
  25 # when using or distributing such scripts, even though portions of the text of
  26 # AutoTroll appear in them. The GNU General Public License (GPL) does govern
  27 # all other use of the material that constitutes AutoTroll.
  28 #
  29 # This special exception to the GPL applies to versions of AutoTroll
  30 # released by the copyright holders of AutoTroll.  Note that people who make
  31 # modified versions of AutoTroll are not obligated to grant this special
  32 # exception for their modified versions; it is their choice whether to do so.
  33 # The GNU General Public License gives permission to release a modified version
  34 # without this exception; this exception also makes it possible to release a
  35 # modified version which carries forward this exception.
  36
  37  # ------------- #
  38  # DOCUMENTATION #
  39  # ------------- #
  40
  41 # Disclaimer: Never tested with anything else than Qt 4.2! Feedback welcome.
  42 # Simply invoke AT_WITH_QT in your configure.ac. AT_WITH_QT can take
  43 # arguments which are documented in depth below. The default arguments are
  44 # equivalent to the default .pro file generated by qmake.
  45 #
  46 # Invoking AT_WITH_QT will do the following:
  47 #  - Add a --with-qt option to your configure
  48 #  - Find qmake, moc and uic and save them in the make variables $(QMAKE),
  49 #    $(MOC), $(UIC).
  50 #  - Save the path to Qt in $(QT_PATH)
  51 #  - Find the flags to use Qt, that is:
  52 #     * $(QT_DEFINES): -D's defined by qmake.
  53 #     * $(QT_CFLAGS): CFLAGS as defined by qmake (C?!)
  54 #     * $(QT_CXXFLAGS): CXXFLAGS as defined by qmake.
  55 #     * $(QT_INCPATH): -I's defined by qmake.
  56 #     * $(QT_CPPFLAGS): Same as $(QT_DEFINES) + $(QT_INCPATH)
  57 #     * $(QT_LFLAGS): LFLAGS defined by qmake.
  58 #     * $(QT_LDFLAGS): Same thing as $(QT_LFLAGS).
  59 #     * $(QT_LIBS): LIBS defined by qmake.
  60 #
  61 # You *MUST* invoke $(MOC) and/or $(UIC) where necessary. AutoTroll provides
  62 # you with Makerules to ease this, here is a sample Makefile.am to use with
  63 # AutoTroll which builds the code given in the chapter 7 of the Qt Tutorial:
  64 # http://doc.trolltech.com/4.2/tutorial-t7.html
  65 #
  66 # -------------------------------------------------------------------------
  67 # include $(top_srcdir)/build-aux/autotroll.mk
  68 #
  69 # ACLOCAL_AMFLAGS = -I build-aux
  70 #
  71 # bin_PROGRAMS = lcdrange
  72 # lcdrange_SOURCES =  $(BUILT_SOURCES) lcdrange.cpp lcdrange.h main.cpp
  73 # lcdrange_CXXFLAGS = $(QT_CXXFLAGS) $(AM_CXXFLAGS)
  74 # lcdrange_CPPFLAGS = $(QT_CPPFLAGS) $(AM_CPPFLAGS)
  75 # lcdrange_LDFLAGS  = $(QT_LDFLAGS) $(LDFLAGS)
  76 # lcdrange_LDADD    = $(QT_LIBS) $(LDADD)
  77 #
  78 # BUILT_SOURCES = lcdrange.moc.cpp
  79 # -------------------------------------------------------------------------
  80 #
  81 # Note that your MOC, UIC and QRC files *MUST* be listed manually in
  82 # BUILT_SOURCES. If you name them properly (eg: .moc.cc, .qrc.cc, .ui.cc -- of
  83 # course you can use .cpp or .cxx or .C rather than .cc) AutoTroll will build
  84 # them automagically for you (using implicit rules defined in autotroll.mk).
  85
  86 m4_pattern_forbid([^AT_])dnl
  87 m4_pattern_forbid([^_AT_])dnl
  88
  89 # AT_WITH_QT([QT_modules], [QT_config], [QT_misc])
  90 # ------------------------------------------------
  91 # Enable Qt support and add an option --with-qt to the configure script.
  92 #
  93 # The QT_modules argument is optional and defines extra modules to enable or
  94 # disable (it's equivalent to the QT variable in .pro files). Modules can be
  95 # specified as follows:
  96 #
  97 # AT_WITH_QT   => No argument -> No QT value.
  98 #                                Qmake sets it to "core gui" by default.
  99 # AT_WITH_QT([xml])   => QT += xml
 100 # AT_WITH_QT([+xml])  => QT += xml
 101 # AT_WITH_QT([-gui])  => QT -= gui
 102 # AT_WITH_QT([xml -gui +sql svg])  => QT += xml sql svg
 103 #                                     QT -= gui
 104 #
 105 # The QT_config argument is also optional and follows the same convention as
 106 # QT_modules. Instead of changing the QT variable, it changes the CONFIG
 107 # variable, which is used to tweak configuration and compiler options.
 108 #
 109 # The last argument, QT_misc (also optional) will be copied as-is the .pro
 110 # file used to guess how to compile Qt apps. You may use it to further tweak
 111 # the build process of Qt apps if tweaking the QT or CONFIG variables isn't
 112 # enough for you.
 113 AC_DEFUN([AT_WITH_QT],
 114 [ AC_REQUIRE([AC_CANONICAL_HOST])
 115   AC_REQUIRE([AC_CANONICAL_BUILD])
 116   AC_REQUIRE([AC_PROG_CXX])
 117
 118   test x"$TROLL" != x && echo 'ViM rox emacs.'
 119
 120 dnl Memo: AC_ARG_WITH(package, help-string, [if-given], [if-not-given])
 121   AC_ARG_WITH([qt],
 122               [AS_HELP_STRING([--with-qt],
 123                  [Path to Qt @<:@Look in PATH and /usr/local/Trolltech@:>@])],
 124               [QT_PATH=$withval], [QT_PATH=])
 125
 126   # Find Qt.
 127   AC_ARG_VAR([QT_PATH], [Path to the Qt installation])
 128   if test -d /usr/local/Trolltech; then
 129     # Try to find the latest version.
 130     tmp_qt_paths=`echo /usr/local/Trolltech/*/bin | tr ' ' '\n' | sort -nr \
 131                                               | xargs | sed 's/  */:/g'`
 132   fi
 133
 134   # Find qmake.
 135   AC_ARG_VAR([QMAKE], [Qt Makefile generator command])
 136   AC_PATH_PROGS([QMAKE], [qmake qmake-qt4 qmake-qt3], [missing],
 137                 [$QT_DIR:$QT_PATH:$PATH:$tmp_qt_paths])
 138   if test x"$QMAKE" = xmissing; then
 139     AC_MSG_ERROR([Cannot find qmake in your PATH. Try using --with-qt.])
 140   fi
 141
 142   # Find moc (Meta Object Compiler).
 143   AC_ARG_VAR([MOC], [Qt Meta Object Compiler command])
 144   AC_PATH_PROGS([MOC], [moc moc-qt4 moc-qt3], [missing],
 145                 [$QT_PATH:$PATH:$tmp_qt_paths])
 146   if test x"$MOC" = xmissing; then
 147     AC_MSG_ERROR([Cannot find moc (Meta Object Compiler) in your PATH. Try using --with-qt.])
 148   fi
 149
 150   # Find uic (User Interface Compiler).
 151   AC_ARG_VAR([UIC], [Qt User Interface Compiler command])
 152   AC_PATH_PROGS([UIC], [uic uic-qt4 uic-qt3 uic3], [missing],
 153                 [$QT_PATH:$PATH:$tmp_qt_paths])
 154   if test x"$UIC" = xmissing; then
 155     AC_MSG_ERROR([Cannot find uic (User Interface Compiler) in your PATH. Try using --with-qt.])
 156   fi
 157
 158   # Find rcc (Qt Resource Compiler).
 159   AC_ARG_VAR([RCC], [Qt Resource Compiler command])
 160   AC_PATH_PROGS([RCC], [rcc], [false], [$QT_PATH:$PATH:$tmp_qt_paths])
 161   if test x"$UIC" = xfalse; then
 162     AC_MSG_WARN([Cannot find rcc (Qt Resource Compiler) in your PATH. Try using --with-qt.])
 163   fi
 164
 165   # If we don't know the path to Qt, guess it from the path to qmake.
 166   if test x"$QT_PATH" = x; then
 167     QT_PATH=`dirname "$QMAKE"`
 168   fi
 169   if test x"$QT_PATH" = x; then
 170     AC_MSG_ERROR([Cannot find the path to your Qt install. Use --with-qt.])
 171   fi
 172   AC_SUBST([QT_PATH])
 173
 174   # Get ready to build a test-app with Qt.
 175   if mkdir conftest.dir && cd conftest.dir; then :; else
 176     AC_MSG_ERROR([Cannot mkdir conftest.dir or cd to that directory.])
 177   fi
 178
 179   cat >conftest.h <<_ASEOF
 180 #include <QObject>
 181
 182 class Foo: public QObject
 183 {
 184   Q_OBJECT;
 185 public:
 186   Foo();
 187   ~Foo() {}
 188 public slots:
 189   void setValue(int value);
 190 signals:
 191   void valueChanged(int newValue);
 192 private:
 193   int value_;
 194 };
 195 _ASEOF
 196
 197   cat >conftest.cpp <<_ASEOF
 198 #include "conftest.h"
 199 Foo::Foo()
 200   : value_ (42)
 201 {
 202   connect(this, SIGNAL(valueChanged(int)), this, SLOT(setValue(int)));
 203 }
 204
 205 void Foo::setValue(int value)
 206 {
 207   value_ = value;
 208 }
 209
 210 int main()
 211 {
 212   Foo f;
 213 }
 214 _ASEOF
 215   if $QMAKE -project; then :; else
 216     AC_MSG_ERROR([Calling $QMAKE -project failed.])
 217   fi
 218
 219   # Find the .pro file generated by qmake.
 220   pro_file='conftest.dir.pro'
 221   test -f $pro_file || pro_file=`echo *.pro`
 222   if test -f "$pro_file"; then :; else
 223     AC_MSG_ERROR([Can't find the .pro file generated by Qmake.])
 224   fi
 225
 226 dnl Tweak the value of QT in the .pro if have been the 1st arg.
 227 m4_ifval([$1], [_AT_TWEAK_PRO_FILE([QT], [$1])])
 228
 229 dnl Tweak the value of CONFIG in the .pro if have been given a 2nd arg.
 230 m4_ifval([$2], [_AT_TWEAK_PRO_FILE([CONFIG], [$2])])
 231
 232 m4_ifval([$3],
 233 [ # Add the extra-settings the user wants to set in the .pro
 234   echo "$3" >>"$pro_file"
 235 ])
 236
 237   echo "$as_me:$LINENO: Invoking $QMAKE on $pro_file" >&AS_MESSAGE_LOG_FD
 238   sed 's/^/| /' "$pro_file" >&AS_MESSAGE_LOG_FD
 239
 240   if $QMAKE; then :; else
 241     AC_MSG_ERROR([Calling $QMAKE failed.])
 242   fi
 243
 244   # QMake has a very annoying misfeature: sometimes it generates Makefiles
 245   # where all the references to the files from the Qt installation are
 246   # relative.  We can't use them as-is because if we take, say, a
 247   # -I../../usr/include/Qt from that Makefile, the flag is invalid as soon
 248   # as we use it in another (sub) directory.  So what this perl pass does is
 249   # that it rewrite all relative paths to absolute paths.  Another problem
 250   # when building on Cygwin is that QMake mixes paths with blackslashes and
 251   # forward slashes and paths must be handled with extra care because of the
 252   # stupid Windows drive letters.
 253   echo "$as_me:$LINENO: fixing the Makefiles:" Makefile* >&AS_MESSAGE_LOG_FD
 254   cat >fixmk.pl <<\EOF
 255 [use strict;
 256 use Cwd qw(cwd abs_path);
 257 # This variable is useful on Cygwin for the following reason: Say that you are
 258 # in `/' (that is, in fact you are in C:/cygwin, or something like that) if you
 259 # `cd ..' then obviously you remain in `/' (that is in C:/cygwin).  QMake
 260 # generates paths that are relative to C:/ (or another driver letter, whatever)
 261 # so the trick to get the `..' resolved properly is to prepend the absolute
 262 # path of the current working directory in a Windows-style.  C:/cygwin/../ will
 263 # properly become C:/.
 264 my $d = "";
 265 my $r2a = 0;
 266 my $b2f = 0;
 267
 268 my $cygwin = 0;
 269 if ($^O eq "cygwin") {
 270   $cygwin = 1;
 271   $d = cwd();
 272   $d = `cygpath --mixed '$d'`;
 273   chomp($d);
 274   $d .= "/";
 275 }
 276
 277 sub rel2abs($)
 278 {
 279   my $p = $d . shift;
 280   # print "r2a p=$p";
 281   -e $p || return $p;
 282   if ($cygwin) {
 283     $p = `cygpath --mixed '$p'`;
 284     chomp($p);
 285   }
 286   else {
 287     # Do not use abs_path on Cygwin: it incorrectly resolves the paths that are
 288     # relative to C:/ rather than `/'.
 289     $p = abs_path($p);
 290   }
 291   # print " -> $p\n";
 292   ++$r2a;
 293   return $p;
 294 }
 295
 296 # Only useful on Cygwin.
 297 sub back2forward($)
 298 {
 299   my $p = shift;
 300   # print "b2f p=$p";
 301   -e $p || return $p;
 302   $p = `cygpath --mixed '$p'`;
 303   chomp($p);
 304   # print " -> $p\n";
 305   ++$b2f;
 306   return $p;
 307 }
 308
 309 foreach my $mk (@ARGV)
 310 {
 311   next if $mk =~ /~$/;
 312   open(MK, $mk) or die("open $mk: $!");
 313   # print "mk=$mk\n";
 314   my $file = join("", <MK>);
 315   close(MK) or die("close $mk: $!");
 316   rename $mk, $mk . "~" or die("rename $mk: $!");
 317   $file =~ s{(?:\.\.[\\/])+(?:[^"'\s:]+)}{rel2abs($&)}gse;
 318   $file =~ s{(?:[a-zA-Z]:[\\/])?(?:[^"\s]+\\[^"\s:]+)+}
 319             {back2forward($&)}gse if $cygwin;
 320   open(MK, ">", $mk) or die("open >$mk: $!");
 321   print MK $file;
 322   close(MK) or die("close >$mk: $!");
 323   print "$mk: updated $r2a relative paths and $b2f backslash-style paths\n";
 324   $r2a = 0;
 325   $b2f = 0;
 326 }]
 327 EOF
 328
 329   perl >&AS_MESSAGE_LOG_FD -w fixmk.pl Makefile* ||
 330   AC_MSG_WARN([failed to fix the Makefiles generated by $QMAKE])
 331   rm -f fixmk.pl
 332
 333   # Try to compile a simple Qt app.
 334   AC_CACHE_CHECK([whether we can build a simple Qt app], [at_cv_qt_build],
 335   [at_cv_qt_build=ko
 336   : ${MAKE=make}
 337
 338   if $MAKE >&AS_MESSAGE_LOG_FD 2>&1; then
 339     at_cv_qt_build='ok, looks like Qt 4'
 340   else
 341     echo "$as_me:$LINENO: Build failed, trying to #include <qobject.h> \
 342 instead" >&AS_MESSAGE_LOG_FD
 343     sed 's/<QObject>/<qobject.h>/' conftest.h > tmp.h && mv tmp.h conftest.h
 344     if $MAKE >&AS_MESSAGE_LOG_FD 2>&1; then
 345       at_cv_qt_build='ok, looks like Qt 3'
 346     else
 347       # Sometimes (such as on Debian) build will fail because Qt hasn't been
 348       # installed in debug mode and qmake tries (by default) to build apps in
 349       # debug mode => Try again in release mode.
 350       echo "$as_me:$LINENO: Build failed, trying to enforce release mode" \
 351             >&AS_MESSAGE_LOG_FD
 352
 353       _AT_TWEAK_PRO_FILE([CONFIG], [+release])
 354
 355       sed 's/<qobject.h>/<QObject>/' conftest.h > tmp.h && mv tmp.h conftest.h
 356       if $MAKE >&AS_MESSAGE_LOG_FD 2>&1; then
 357         at_cv_qt_build='ok, looks like Qt 4, release mode forced'
 358       else
 359         echo "$as_me:$LINENO: Build failed, trying to #include <qobject.h> \
 360 instead" >&AS_MESSAGE_LOG_FD
 361         sed 's/<QObject>/<qobject.h>/' conftest.h > tmp.h && mv tmp.h conftest.h
 362         if $MAKE >&AS_MESSAGE_LOG_FD 2>&1; then
 363           at_cv_qt_build='ok, looks like Qt 3, release mode forced'
 364         else
 365           at_cv_qt_build=ko
 366           echo "$as_me:$LINENO: failed program was:" >&AS_MESSAGE_LOG_FD
 367           sed 's/^/| /' conftest.h >&AS_MESSAGE_LOG_FD
 368           echo "$as_me:$LINENO: failed program was:" >&AS_MESSAGE_LOG_FD
 369           sed 's/^/| /' conftest.cpp >&AS_MESSAGE_LOG_FD
 370         fi # if make with Qt3-style #include and release mode forced.
 371       fi # if make with Qt4-style #include and release mode forced.
 372     fi # if make with Qt3-style #include.
 373   fi # if make with Qt4-style #include.
 374   ])dnl end: AC_CACHE_CHECK(at_cv_qt_build)
 375
 376   if test x"$at_cv_qt_build" = xko; then
 377     AC_MSG_ERROR([Cannot build a test Qt program])
 378   fi
 379   QT_VERSION_MAJOR=`echo "$at_cv_qt_build" | sed 's/^[^0-9]*//'`
 380   AC_SUBST([QT_VERSION_MAJOR])
 381
 382   # This sed filter is applied after an expression of the form: /^FOO.*=/!d;
 383   # It starts by removing the beginning of the line, removing references to
 384   # SUBLIBS, removing unnecessary whitespaces at the beginning, and prefixes
 385   # all variable uses by QT_.
 386   qt_sed_filter='s///;
 387                  s/$(SUBLIBS)//g;
 388                  s/^ *//;
 389                  s/\$(\(@<:@A-Z_@:>@@<:@A-Z_@:>@*\))/$(QT_\1)/g'
 390
 391   # Find the Makefile (qmake happens to generate a fake Makefile which invokes
 392   # a Makefile.Debug or Makefile.Release). We we have both, we'll pick the
 393   # Makefile.Release. The reason is that the main difference is that release
 394   # uses -Os and debug -g. We can override -Os by passing another -O but we
 395   # usually don't override -g.
 396   if test -f Makefile.Release; then
 397     at_mfile='Makefile.Release'
 398   else
 399     at_mfile='Makefile'
 400   fi
 401   if test -f $at_mfile; then :; else
 402     AC_MSG_ERROR([Cannot find the Makefile generated by qmake.])
 403   fi
 404
 405   # Find the DEFINES of Qt (should have been named CPPFLAGS).
 406   AC_CACHE_CHECK([for the DEFINES to use with Qt], [at_cv_env_QT_DEFINES],
 407   [at_cv_env_QT_DEFINES=`sed "/^DEFINES@<:@^A-Z=@:>@*=/!d;$qt_sed_filter" $at_mfile`])
 408   AC_SUBST([QT_DEFINES], [$at_cv_env_QT_DEFINES])
 409
 410   # Find the CFLAGS of Qt (We can use Qt in C?!)
 411   AC_CACHE_CHECK([for the CFLAGS to use with Qt], [at_cv_env_QT_CFLAGS],
 412   [at_cv_env_QT_CFLAGS=`sed "/^CFLAGS@<:@^A-Z=@:>@*=/!d;$qt_sed_filter" $at_mfile`])
 413   AC_SUBST([QT_CFLAGS], [$at_cv_env_QT_CFLAGS])
 414
 415   # Find the CXXFLAGS of Qt.
 416   AC_CACHE_CHECK([for the CXXFLAGS to use with Qt], [at_cv_env_QT_CXXFLAGS],
 417   [at_cv_env_QT_CXXFLAGS=`sed "/^CXXFLAGS@<:@^A-Z=@:>@*=/!d;$qt_sed_filter" $at_mfile`])
 418   AC_SUBST([QT_CXXFLAGS], [$at_cv_env_QT_CXXFLAGS])
 419
 420   # Find the INCPATH of Qt.
 421   AC_CACHE_CHECK([for the INCPATH to use with Qt], [at_cv_env_QT_INCPATH],
 422   [at_cv_env_QT_INCPATH=`sed "/^INCPATH@<:@^A-Z=@:>@*=/!d;$qt_sed_filter" $at_mfile`])
 423   AC_SUBST([QT_INCPATH], [$at_cv_env_QT_INCPATH])
 424
 425   AC_SUBST([QT_CPPFLAGS], ["$at_cv_env_QT_DEFINES $at_cv_env_QT_INCPATH"])
 426
 427   # Find the LFLAGS of Qt (Should have been named LDFLAGS)
 428   AC_CACHE_CHECK([for the LDFLAGS to use with Qt], [at_cv_env_QT_LDFLAGS],
 429   [at_cv_env_QT_LDFLAGS=`sed "/^LFLAGS@<:@^A-Z=@:>@*=/!d;$qt_sed_filter" $at_mfile`])
 430   AC_SUBST([QT_LFLAGS], [$at_cv_env_QT_LDFLAGS])
 431   AC_SUBST([QT_LDFLAGS], [$at_cv_env_QT_LDFLAGS])
 432
 433   AC_MSG_CHECKING([whether host operating system is Darwin])
 434   at_darwin="no"
 435   case $host_os in
 436     darwin*)
 437       at_darwin="yes"
 438       ;;
 439   esac
 440   AC_MSG_RESULT([$at_darwin])
 441
 442   # Find the LIBS of Qt.
 443   AC_CACHE_CHECK([for the LIBS to use with Qt], [at_cv_env_QT_LIBS],
 444   [at_cv_env_QT_LIBS=`sed "/^LIBS@<:@^A-Z@:>@*=/!d;$qt_sed_filter" $at_mfile`
 445    if test x$at_darwin = xyes; then
 446      # Fix QT_LIBS: as of today Libtool (GNU Libtool 1.5.23a) doesn't handle
 447      # -F properly. The "bug" has been fixed on 22 October 2006
 448      # by Peter O'Gorman but we provide backward compatibility here.
 449      at_cv_env_QT_LIBS=`echo "$at_cv_env_QT_LIBS" \
 450                              | sed 's/^-F/-Wl,-F/;s/ -F/ -Wl,-F/g'`
 451    fi
 452   ])
 453   AC_SUBST([QT_LIBS], [$at_cv_env_QT_LIBS])
 454
 455   cd .. && rm -rf conftest.dir
 456 ])
 457
 458 # AT_REQUIRE_QT_VERSION(QT_version)
 459 # ---------------------------------
 460 # Check (using qmake) that Qt's version "matches" QT_version.
 461 # Must be run AFTER AT_WITH_QT. Requires autoconf 2.60.
 462 AC_DEFUN([AT_REQUIRE_QT_VERSION],
 463 [ AC_PREREQ([2.60])
 464   if test x"$QMAKE" = x; then
 465     AC_MSG_ERROR([\$QMAKE is empty. \
 466 Did you invoke AT@&t@_WITH_QT before AT@&t@_REQUIRE_QT_VERSION?])
 467   fi
 468   AC_CACHE_CHECK([for Qt's version], [at_cv_QT_VERSION],
 469   [echo "$as_me:$LINENO: Running $QMAKE --version:" >&AS_MESSAGE_LOG_FD
 470   $QMAKE --version >&AS_MESSAGE_LOG_FD 2>&1
 471   qmake_version_sed=['/^.*\([0-9]\.[0-9]\.[0-9]\).*$/!d;s//\1/']
 472   at_cv_QT_VERSION=`$QMAKE --version 2>&1 | sed "$qmake_version_sed"`])
 473   if test x"$at_cv_QT_VERSION" = x; then
 474     AC_MSG_ERROR([Cannot detect Qt's version.])
 475   fi
 476   AC_SUBST([QT_VERSION], [$at_cv_QT_VERSION])
 477   AS_VERSION_COMPARE([$QT_VERSION], [$1],
 478     [AC_MSG_ERROR([This package requires Qt $1 or above.])])
 479 ])
 480
 481 # _AT_TWEAK_PRO_FILE(QT_VAR, VALUE)
 482 # ---------------------------
 483 # @internal. Tweak the variable QT_VAR in the .pro.
 484 # VALUE is an IFS-separated list of value and each value is rewritten
 485 # as follows:
 486 #   +value  => QT_VAR += value
 487 #   -value  => QT_VAR -= value
 488 #    value  => QT_VAR += value
 489 AC_DEFUN([_AT_TWEAK_PRO_FILE],
 490 [ # Tweak the value of $1 in the .pro file for $2.
 491
 492   qt_conf=''
 493   for at_mod in $2; do
 494     at_mod=`echo "$at_mod" | sed 's/^-//; tough
 495                                   s/^+//; beef
 496                                   :ough
 497                                   s/^/$1 -= /;n
 498                                   :eef
 499                                   s/^/$1 += /'`
 500     qt_conf="$qt_conf
 501 $at_mod"
 502   done
 503   echo "$qt_conf" | sed 1d >>"$pro_file"
 504 ])