mirror of
https://github.com/qbittorrent/qBittorrent
synced 2024-11-07 17:16:45 +01:00
1638 lines
37 KiB
Bash
Executable File
1638 lines
37 KiB
Bash
Executable File
#!/bin/sh
|
|
#
|
|
# Generated by qconf 1.4 ( http://delta.affinix.com/qconf/ )
|
|
#
|
|
|
|
show_usage() {
|
|
cat <<EOT
|
|
Usage: $0 [OPTION]...
|
|
|
|
This script creates necessary configuration files to build/install.
|
|
|
|
Main options:
|
|
--prefix=[path] Base path for build/install. Default: /usr/local
|
|
--bindir=[path] Directory for binaries. Default: PREFIX/bin
|
|
--datadir=[path] Directory for data. Default: PREFIX/share
|
|
--qtdir=[path] Directory where Qt is installed.
|
|
--verbose Show extra configure output.
|
|
--help This help text.
|
|
|
|
Dependency options:
|
|
--enable-debug Enable debug mode
|
|
--disable-gui Disable qBittorrent
|
|
Graphical user interface for
|
|
headless running
|
|
--disable-qt-dbus Disable use of qt-dbus
|
|
--with-libboost-inc=[path] Path to libboost include
|
|
files
|
|
--with-libboost-lib=[path] Path to libboost library
|
|
files
|
|
--disable-geoip-database Disable use of geoip-database
|
|
--with-geoip-database-embedded Geoip Database will be
|
|
embedded in qBittorrent
|
|
executable (please follow
|
|
instructions in
|
|
src/geoip/README)
|
|
--with-qtsingleapplication=[system|shipped] Use the shipped
|
|
qtsingleapplication library
|
|
or the system one
|
|
|
|
EOT
|
|
}
|
|
|
|
# which/make detection adapted from Qt
|
|
which_command() {
|
|
OLD_HOME=$HOME
|
|
HOME=/dev/null
|
|
export HOME
|
|
|
|
WHICH=`which which 2>/dev/null`
|
|
if echo $WHICH | grep 'shell built-in command' >/dev/null 2>&1; then
|
|
WHICH=which
|
|
elif [ -z "$WHICH" ]; then
|
|
if which which >/dev/null 2>&1; then
|
|
WHICH=which
|
|
else
|
|
for a in /usr/ucb /usr/bin /bin /usr/local/bin; do
|
|
if [ -x $a/which ]; then
|
|
WHICH=$a/which
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$WHICH" ]; then
|
|
OLD_IFS=$IFS
|
|
IFS=:
|
|
for a in $PATH; do
|
|
if [ -x $a/$1 ]; then
|
|
echo "$a/$1"
|
|
IFS=$OLD_IFS
|
|
export IFS
|
|
HOME=$OLD_HOME
|
|
export HOME
|
|
return 0
|
|
fi
|
|
done
|
|
IFS=$OLD_IFS
|
|
export IFS
|
|
else
|
|
a=`"$WHICH" "$1" 2>/dev/null`
|
|
if [ ! -z "$a" -a -x "$a" ]; then
|
|
echo "$a"
|
|
HOME=$OLD_HOME
|
|
export HOME
|
|
return 0
|
|
fi
|
|
fi
|
|
HOME=$OLD_HOME
|
|
export HOME
|
|
return 1
|
|
}
|
|
WHICH=which_command
|
|
|
|
# find a make command
|
|
if [ -z "$MAKE" ]; then
|
|
MAKE=
|
|
for mk in gmake make; do
|
|
if $WHICH $mk >/dev/null 2>&1; then
|
|
MAKE=`$WHICH $mk`
|
|
break
|
|
fi
|
|
done
|
|
if [ -z "$MAKE" ]; then
|
|
echo "You don't seem to have 'make' or 'gmake' in your PATH."
|
|
echo "Cannot proceed."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
show_qt_info() {
|
|
printf "Be sure you have a proper Qt 4.0 build environment set up. This means not\n"
|
|
printf "just Qt, but also a C++ compiler, a make tool, and any other packages\n"
|
|
printf "necessary for compiling C++ programs.\n"
|
|
printf "\n"
|
|
printf "If you are certain everything is installed, then it could be that Qt 4 is not\n"
|
|
printf "being recognized or that a different version of Qt is being detected by\n"
|
|
printf "mistake (for example, this could happen if \$QTDIR is pointing to a Qt 3\n"
|
|
printf "installation). At least one of the following conditions must be satisfied:\n"
|
|
printf "\n"
|
|
printf " 1) --qtdir is set to the location of Qt\n"
|
|
printf " 2) \$QTDIR is set to the location of Qt\n"
|
|
printf " 3) QtCore is in the pkg-config database\n"
|
|
printf " 4) qmake is in the \$PATH\n"
|
|
printf "\n"
|
|
printf "This script will use the first one it finds to be true, checked in the above\n"
|
|
printf "order. #3 and #4 are the recommended options. #1 and #2 are mainly for\n"
|
|
printf "overriding the system configuration.\n"
|
|
printf "\n"
|
|
}
|
|
|
|
while [ $# -gt 0 ]; do
|
|
optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
|
|
case "$1" in
|
|
--prefix=*)
|
|
PREFIX=$optarg
|
|
shift
|
|
;;
|
|
|
|
--bindir=*)
|
|
BINDIR=$optarg
|
|
shift
|
|
;;
|
|
|
|
--datadir=*)
|
|
DATADIR=$optarg
|
|
shift
|
|
;;
|
|
|
|
--qtdir=*)
|
|
EX_QTDIR=$optarg
|
|
shift
|
|
;;
|
|
|
|
--enable-debug)
|
|
QC_ENABLE_DEBUG="Y"
|
|
shift
|
|
;;
|
|
|
|
--disable-gui)
|
|
QC_DISABLE_GUI="Y"
|
|
shift
|
|
;;
|
|
|
|
--disable-qt-dbus)
|
|
QC_DISABLE_qt_dbus="Y"
|
|
shift
|
|
;;
|
|
|
|
--with-libboost-inc=*)
|
|
QC_WITH_LIBBOOST_INC=$optarg
|
|
shift
|
|
;;
|
|
|
|
--with-libboost-lib=*)
|
|
QC_WITH_LIBBOOST_LIB=$optarg
|
|
shift
|
|
;;
|
|
|
|
--disable-geoip-database)
|
|
QC_DISABLE_geoip_database="Y"
|
|
shift
|
|
;;
|
|
|
|
--with-geoip-database-embedded)
|
|
QC_WITH_GEOIP_DATABASE_EMBEDDED="Y"
|
|
shift
|
|
;;
|
|
|
|
--with-qtsingleapplication=*)
|
|
QC_WITH_QTSINGLEAPPLICATION=$optarg
|
|
shift
|
|
;;
|
|
|
|
--verbose)
|
|
QC_VERBOSE="Y"
|
|
shift
|
|
;;
|
|
--help) show_usage; exit ;;
|
|
*) show_usage; exit ;;
|
|
esac
|
|
done
|
|
|
|
PREFIX=${PREFIX:-/usr/local}
|
|
BINDIR=${BINDIR:-$PREFIX/bin}
|
|
DATADIR=${DATADIR:-$PREFIX/share}
|
|
|
|
echo "Configuring qbittorrent ..."
|
|
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo
|
|
echo PREFIX=$PREFIX
|
|
echo BINDIR=$BINDIR
|
|
echo DATADIR=$DATADIR
|
|
echo EX_QTDIR=$EX_QTDIR
|
|
echo QC_ENABLE_DEBUG=$QC_ENABLE_DEBUG
|
|
echo QC_DISABLE_GUI=$QC_DISABLE_GUI
|
|
echo QC_DISABLE_qt_dbus=$QC_DISABLE_qt_dbus
|
|
echo QC_WITH_LIBBOOST_INC=$QC_WITH_LIBBOOST_INC
|
|
echo QC_WITH_LIBBOOST_LIB=$QC_WITH_LIBBOOST_LIB
|
|
echo QC_DISABLE_geoip_database=$QC_DISABLE_geoip_database
|
|
echo QC_WITH_GEOIP_DATABASE_EMBEDDED=$QC_WITH_GEOIP_DATABASE_EMBEDDED
|
|
echo QC_WITH_QTSINGLEAPPLICATION=$QC_WITH_QTSINGLEAPPLICATION
|
|
echo
|
|
fi
|
|
|
|
printf "Verifying Qt 4 build environment ... "
|
|
|
|
# run qmake -v and check version
|
|
qmake_check_v4() {
|
|
if [ -x "$1" ]; then
|
|
if echo `$1 -v 2>&1` | grep "Qt version 4\." >/dev/null 2>&1; then
|
|
return 0
|
|
elif [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "Warning: $1 not for Qt 4"
|
|
fi
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo
|
|
fi
|
|
|
|
qm=""
|
|
names="qmake-qt4 qmake4 qmake"
|
|
|
|
# qt4 check: --qtdir
|
|
if [ -z "$qm" ] && [ ! -z "$EX_QTDIR" ]; then
|
|
for n in $names; do
|
|
qstr=$EX_QTDIR/bin/$n
|
|
if qmake_check_v4 "$qstr"; then
|
|
qm=$qstr
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
if [ -z "$qm" ] && [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "Warning: qmake not found via --qtdir"
|
|
fi
|
|
|
|
# qt4 check: QTDIR
|
|
if [ -z "$qm" ] && [ ! -z "$QTDIR" ]; then
|
|
for n in $names; do
|
|
qstr=$QTDIR/bin/$n
|
|
if qmake_check_v4 "$qstr"; then
|
|
qm=$qstr
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
if [ -z "$qm" ] && [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "Warning: qmake not found via \$QTDIR"
|
|
fi
|
|
|
|
# qt4 check: pkg-config
|
|
if [ -z "$qm" ]; then
|
|
str=`pkg-config QtCore --variable=exec_prefix 2>/dev/null`
|
|
if [ ! -z "$str" ]; then
|
|
for n in $names; do
|
|
qstr=$str/bin/$n
|
|
if qmake_check_v4 "$qstr"; then
|
|
qm=$qstr
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
if [ -z "$qm" ] && [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "Warning: qmake not found via pkg-config"
|
|
fi
|
|
|
|
# qt4 check: PATH
|
|
if [ -z "$qm" ]; then
|
|
for n in $names; do
|
|
qstr=`$WHICH $n 2>/dev/null`
|
|
if qmake_check_v4 "$qstr"; then
|
|
qm=$qstr
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
if [ -z "$qm" ] && [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "Warning: qmake not found via \$PATH"
|
|
fi
|
|
|
|
if [ -z "$qm" ]; then
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo " -> fail"
|
|
else
|
|
echo "fail"
|
|
fi
|
|
printf "\n"
|
|
printf "Reason: Unable to find the 'qmake' tool for Qt 4.\n"
|
|
printf "\n"
|
|
show_qt_info
|
|
exit 1;
|
|
fi
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo qmake found in $qm
|
|
fi
|
|
|
|
gen_files() {
|
|
cat >$1/modules.cpp <<EOT
|
|
#line 1 "qt4.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: Qt >= 4.6
|
|
arg: enable-debug, Enable debug mode
|
|
arg: disable-gui, Disable qBittorrent Graphical user interface for headless running
|
|
-----END QCMOD-----
|
|
*/
|
|
class qc_qt4 : public ConfObj
|
|
{
|
|
public:
|
|
qc_qt4(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "Qt >= 4.6"; }
|
|
QString shortname() const { return "Qt 4.6"; }
|
|
bool exec()
|
|
{
|
|
// NOX mode
|
|
if(!conf->getenv("QC_DISABLE_GUI").isEmpty()) {
|
|
conf->addExtra("CONFIG += nox");
|
|
}
|
|
// Debug mode
|
|
if(!conf->getenv("QC_ENABLE_DEBUG").isEmpty()) {
|
|
conf->addExtra("CONFIG -= release");
|
|
conf->addExtra("CONFIG += debug");
|
|
} else {
|
|
conf->addExtra("CONFIG -= debug");
|
|
conf->addExtra("CONFIG += release");
|
|
}
|
|
#ifdef Q_OS_FREEBSD
|
|
conf->addLib("-lexecinfo");
|
|
conf->addExtra("MANPREFIX = \$\$PREFIX");
|
|
#else
|
|
conf->addExtra("MANPREFIX = \$\$PREFIX/share");
|
|
#endif
|
|
return(QT_VERSION >= 0x040600);
|
|
}
|
|
};
|
|
#line 1 "qt-dbus.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: qt-dbus
|
|
-----END QCMOD-----
|
|
*/
|
|
// see Conf::findPkgConfig
|
|
class qc_qt_dbus : public ConfObj
|
|
{
|
|
public:
|
|
qc_qt_dbus(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "QtDBus >= 4.5"; }
|
|
QString shortname() const { return "qt-dbus"; }
|
|
QString checkString() const {
|
|
if(!conf->getenv("QC_DISABLE_qt_dbus").isEmpty() || !conf->getenv("QC_DISABLE_GUI").isEmpty())
|
|
return "";
|
|
return ConfObj::checkString();
|
|
}
|
|
bool exec(){
|
|
if(!conf->getenv("QC_DISABLE_qt_dbus").isEmpty() || !conf->getenv("QC_DISABLE_GUI").isEmpty())
|
|
return false;
|
|
QStringList incs;
|
|
QString req_ver = "4.5.0";
|
|
QString version, libs, other;
|
|
VersionMode mode = VersionMin;
|
|
if(conf->findPkgConfig("QtDBus", mode, req_ver, &version, &incs, &libs, &other)) {
|
|
conf->addExtra("CONFIG += dbus");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
#line 1 "pkg-config.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: pkg-config
|
|
-----END QCMOD-----
|
|
*/
|
|
#include <QProcess>
|
|
class qc_pkg_config : public ConfObj
|
|
{
|
|
public:
|
|
qc_pkg_config(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "pkg-config executable"; }
|
|
QString shortname() const { return "pkg-config"; }
|
|
bool exec(){
|
|
return !conf->findProgram("pkg-config").isEmpty();
|
|
}
|
|
};
|
|
#line 1 "libtorrent-rasterbar.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: libtorrent-rasterbar
|
|
-----END QCMOD-----
|
|
*/
|
|
// see Conf::findPkgConfig
|
|
class qc_libtorrent_rasterbar : public ConfObj
|
|
{
|
|
public:
|
|
qc_libtorrent_rasterbar(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "libtorrent-rasterbar >= 0.15.0"; }
|
|
QString shortname() const { return "libtorrent-rasterbar"; }
|
|
bool exec(){
|
|
QStringList incs;
|
|
QString req_ver = "0.15.0";
|
|
QString version, libs, other;
|
|
VersionMode mode = VersionMin;
|
|
if(!conf->findPkgConfig("libtorrent-rasterbar", mode, req_ver, &version, &incs, &libs, &other))
|
|
return false;
|
|
for(int n = 0; n < incs.count(); ++n)
|
|
conf->addIncludePath(incs[n]);
|
|
return true;
|
|
}
|
|
};
|
|
#line 1 "libboost.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: libboost
|
|
arg: with-libboost-inc=[path], Path to libboost include files
|
|
arg: with-libboost-lib=[path], Path to libboost library files
|
|
-----END QCMOD-----
|
|
*/
|
|
#include <boost/version.hpp>
|
|
#include <libtorrent/version.hpp>
|
|
|
|
class qc_libboost : public ConfObj
|
|
{
|
|
public:
|
|
qc_libboost(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "libboost"; }
|
|
QString shortname() const { return "libboost"; }
|
|
|
|
QString findBoostLib(QString path, QString lib) const {
|
|
QString name;
|
|
QDir libDir(path);
|
|
QStringList filters;
|
|
filters << "libboost_"+lib+"*-mt*.so";
|
|
QStringList result = libDir.entryList(filters, QDir::Files);
|
|
if(!result.empty()) {
|
|
name = result.first().mid(3);
|
|
// Remove .so
|
|
name.chop(3);
|
|
} else {
|
|
// Fall back to non -mt boost lib
|
|
filters.clear();
|
|
filters << "libboost_"+lib+"*.so";
|
|
result = libDir.entryList(filters, QDir::Files);
|
|
if(!result.empty()) {
|
|
name = result.first().mid(3);
|
|
// Remove .so
|
|
name.chop(3);
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
|
|
bool exec(){
|
|
QStringList sl;
|
|
QString s = conf->getenv("QC_WITH_LIBBOOST_INC");
|
|
if (!s.isEmpty())
|
|
sl << s;
|
|
sl << "/usr/include";
|
|
sl << "/usr/local/include";
|
|
bool found = false;
|
|
foreach (s, sl) {
|
|
if (conf->checkHeader(s, "boost/format.hpp")
|
|
#if LIBTORRENT_VERSION_MAJOR == 0 && LIBTORRENT_VERSION_MINOR < 16
|
|
&& conf->checkHeader(s, "boost/filesystem/path.hpp")
|
|
#endif
|
|
) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
return false;
|
|
|
|
conf->addIncludePath(s);
|
|
|
|
// Find library
|
|
s = conf->getenv("QC_WITH_LIBBOOST_LIB");
|
|
QStringList required_libs;
|
|
#if BOOST_VERSION >= 103500
|
|
required_libs << "system";
|
|
#endif
|
|
#if LIBTORRENT_VERSION_MAJOR == 0 && LIBTORRENT_VERSION_MINOR < 16
|
|
required_libs << "filesystem" ;
|
|
#endif
|
|
required_libs << "thread";
|
|
QStringList libDirs;
|
|
if (!s.isEmpty())
|
|
libDirs << s;
|
|
libDirs << "/usr/lib/" << "/usr/lib64/" << "/usr/local/lib/" << "/usr/local/lib64/";
|
|
|
|
foreach(const QString& lib, required_libs) {
|
|
bool found = false;
|
|
foreach(const QString& libDir, libDirs) {
|
|
QString detected_name = findBoostLib(libDir, lib);
|
|
if(!detected_name.isEmpty()) {
|
|
conf->addLib("-l"+detected_name);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!found) {
|
|
printf("Could not find boost %s library!\n", qPrintable(lib));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
#line 1 "geoip-database.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: geoip-database
|
|
arg: with-geoip-database-embedded, Geoip Database will be embedded in qBittorrent executable (please follow instructions in src/geoip/README)
|
|
-----END QCMOD-----
|
|
*/
|
|
// see Conf::findPkgConfig
|
|
class qc_geoip_database : public ConfObj
|
|
{
|
|
public:
|
|
qc_geoip_database(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "GeoIP Database (optional)"; }
|
|
QString shortname() const { return "GeoIP Database"; }
|
|
QString checkString() const {
|
|
if(!conf->getenv("QC_DISABLE_geoip_database").isEmpty() || !conf->getenv("QC_DISABLE_GUI").isEmpty())
|
|
return "";
|
|
return ConfObj::checkString();
|
|
}
|
|
bool exec() {
|
|
if(!conf->getenv("QC_DISABLE_geoip_database").isEmpty() || !conf->getenv("QC_DISABLE_GUI").isEmpty()) {
|
|
return false;
|
|
}
|
|
#ifdef Q_WS_X11
|
|
if(!conf->getenv("QC_WITH_GEOIP_DATABASE_EMBEDDED").isEmpty()) {
|
|
#endif
|
|
conf->addDefine("WITH_GEOIP_EMBEDDED");
|
|
printf(" embedded and");
|
|
return true;
|
|
#ifdef Q_WS_X11
|
|
}
|
|
if(QFile::exists("/usr/share/GeoIP/GeoIP.dat") || QFile::exists("/usr/local/share/GeoIP/GeoIP.dat") || QFile::exists("/var/lib/GeoIP/GeoIP.dat"))
|
|
return true;
|
|
printf("\nWarning: GeoIP database was not found at /usr/share/GeoIP/GeoIP.dat or /var/lib/GeoIP/GeoIP.dat\nCountry resolution will be slow.");
|
|
return false;
|
|
#endif
|
|
}
|
|
};
|
|
#line 1 "qtsingleapplication.qcm"
|
|
/*
|
|
-----BEGIN QCMOD-----
|
|
name: qtsingleapplication
|
|
arg: with-qtsingleapplication=[system|shipped], Use the shipped qtsingleapplication library or the system one
|
|
-----END QCMOD-----
|
|
*/
|
|
class qc_qtsingleapplication : public ConfObj
|
|
{
|
|
public:
|
|
qc_qtsingleapplication(Conf *c) : ConfObj(c) {}
|
|
QString name() const { return "qtsingleapplication library"; }
|
|
QString shortname() const { return "qtsingleapplication"; }
|
|
|
|
bool exec(){
|
|
QString s;
|
|
s = conf->getenv("QC_WITH_QTSINGLEAPPLICATION");
|
|
if(s.compare("system", Qt::CaseInsensitive) == 0) {
|
|
// System
|
|
conf->addExtra("CONFIG += usesystemqtsingleapplication");
|
|
printf(" [system] ");
|
|
} else {
|
|
printf(" [shipped] ");
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
EOT
|
|
cat >$1/modules_new.cpp <<EOT
|
|
o = new qc_qt4(conf);
|
|
o->required = true;
|
|
o->disabled = false;
|
|
o = new qc_qt_dbus(conf);
|
|
o->required = false;
|
|
o->disabled = false;
|
|
o = new qc_pkg_config(conf);
|
|
o->required = true;
|
|
o->disabled = false;
|
|
o = new qc_libtorrent_rasterbar(conf);
|
|
o->required = true;
|
|
o->disabled = false;
|
|
o = new qc_libboost(conf);
|
|
o->required = true;
|
|
o->disabled = false;
|
|
o = new qc_geoip_database(conf);
|
|
o->required = false;
|
|
o->disabled = false;
|
|
o = new qc_qtsingleapplication(conf);
|
|
o->required = true;
|
|
o->disabled = false;
|
|
|
|
EOT
|
|
cat >$1/conf4.h <<EOT
|
|
// For license information, see the COPYING file in the qconf base directory.
|
|
|
|
#ifndef QC_CONF4_H
|
|
#define QC_CONF4_H
|
|
|
|
#include <QtCore>
|
|
|
|
class Conf;
|
|
|
|
enum VersionMode { VersionMin, VersionExact, VersionMax, VersionAny };
|
|
|
|
// ConfObj
|
|
//
|
|
// Subclass ConfObj to create a new configuration module.
|
|
class ConfObj
|
|
{
|
|
public:
|
|
Conf *conf;
|
|
bool required;
|
|
bool disabled;
|
|
bool success;
|
|
|
|
ConfObj(Conf *c);
|
|
virtual ~ConfObj();
|
|
|
|
// long or descriptive name of what is being checked/performed
|
|
// example: "KDE >= 3.3"
|
|
virtual QString name() const = 0;
|
|
|
|
// short name
|
|
// example: "kde"
|
|
virtual QString shortname() const = 0;
|
|
|
|
// string to display during check
|
|
// default: "Checking for [name] ..."
|
|
virtual QString checkString() const;
|
|
|
|
// string to display after check
|
|
// default: "yes" or "no", based on result of exec()
|
|
virtual QString resultString() const;
|
|
|
|
// this is where the checking code goes
|
|
virtual bool exec() = 0;
|
|
};
|
|
|
|
// Conf
|
|
//
|
|
// Interact with this class from your ConfObj to perform detection
|
|
// operations and to output configuration parameters.
|
|
class Conf
|
|
{
|
|
public:
|
|
bool debug_enabled;
|
|
QString qmake_path;
|
|
QString maketool;
|
|
|
|
QString DEFINES;
|
|
QString INCLUDEPATH;
|
|
QString LIBS;
|
|
QString extra;
|
|
|
|
QList<ConfObj*> list;
|
|
QMap<QString,QString> vars;
|
|
|
|
Conf();
|
|
~Conf();
|
|
|
|
QString getenv(const QString &var);
|
|
QString qvar(const QString &s);
|
|
|
|
bool exec();
|
|
|
|
void debug(const QString &s);
|
|
|
|
QString expandIncludes(const QString &inc);
|
|
QString expandLibs(const QString &lib);
|
|
|
|
int doCommand(const QString &s, QByteArray *out = 0);
|
|
int doCommand(const QString &prog, const QStringList &args, QByteArray *out = 0);
|
|
|
|
bool doCompileAndLink(const QString &filedata, const QStringList &incs, const QString &libs, const QString &proextra, int *retcode = 0);
|
|
bool checkHeader(const QString &path, const QString &h);
|
|
bool findHeader(const QString &h, const QStringList &ext, QString *inc);
|
|
bool checkLibrary(const QString &path, const QString &name);
|
|
bool findLibrary(const QString &name, QString *lib);
|
|
QString findProgram(const QString &prog);
|
|
bool findSimpleLibrary(const QString &incvar, const QString &libvar, const QString &incname, const QString &libname, QString *incpath, QString *libs);
|
|
bool findFooConfig(const QString &path, QString *version, QStringList *incs, QString *libs, QString *otherflags);
|
|
bool findPkgConfig(const QString &name, VersionMode mode, const QString &req_version, QString *version, QStringList *incs, QString *libs, QString *otherflags);
|
|
|
|
void addDefine(const QString &str);
|
|
void addLib(const QString &str);
|
|
void addIncludePath(const QString &str);
|
|
void addExtra(const QString &str);
|
|
|
|
private:
|
|
bool first_debug;
|
|
|
|
friend class ConfObj;
|
|
void added(ConfObj *o);
|
|
};
|
|
|
|
#endif
|
|
|
|
EOT
|
|
cat >$1/conf4.cpp <<EOT
|
|
// For license information, see the COPYING file in the qconf base directory.
|
|
|
|
#include "conf4.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
class MocTestObject : public QObject
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
MocTestObject() {}
|
|
};
|
|
|
|
QString qc_getenv(const QString &var)
|
|
{
|
|
char *p = ::getenv(var.toLatin1().data());
|
|
if(!p)
|
|
return QString();
|
|
return QString(p);
|
|
}
|
|
|
|
QStringList qc_pathlist()
|
|
{
|
|
QStringList list;
|
|
QString path = qc_getenv("PATH");
|
|
if(!path.isEmpty())
|
|
list = path.split(':', QString::SkipEmptyParts);
|
|
return list;
|
|
}
|
|
|
|
QString qc_findprogram(const QString &prog)
|
|
{
|
|
QString out;
|
|
QStringList list = qc_pathlist();
|
|
for(int n = 0; n < list.count(); ++n)
|
|
{
|
|
QFileInfo fi(list[n] + '/' + prog);
|
|
if(fi.exists() && fi.isExecutable())
|
|
{
|
|
out = fi.filePath();
|
|
break;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
QString qc_findself(const QString &argv0)
|
|
{
|
|
if(argv0.contains('/'))
|
|
return argv0;
|
|
else
|
|
return qc_findprogram(argv0);
|
|
}
|
|
|
|
int qc_runcommand(const QString &command, QByteArray *out, bool showOutput)
|
|
{
|
|
QString fullcmd = command;
|
|
if(!showOutput)
|
|
fullcmd += " 2>/dev/null";
|
|
FILE *f = popen(fullcmd.toLatin1().data(), "r");
|
|
if(!f)
|
|
return -1;
|
|
if(out)
|
|
out->clear();
|
|
while(1)
|
|
{
|
|
char c = (char)fgetc(f);
|
|
if(feof(f))
|
|
break;
|
|
if(out)
|
|
out->append(c);
|
|
if(showOutput)
|
|
fputc(c, stdout);
|
|
}
|
|
int ret = pclose(f);
|
|
if(ret == -1)
|
|
return -1;
|
|
return ret;
|
|
}
|
|
|
|
int qc_runprogram(const QString &prog, const QStringList &args, QByteArray *out, bool showOutput)
|
|
{
|
|
QString fullcmd = prog;
|
|
QString argstr = args.join(" ");
|
|
if(!argstr.isEmpty())
|
|
fullcmd += QString(" ") + argstr;
|
|
return qc_runcommand(fullcmd, out, showOutput);
|
|
|
|
// TODO: use QProcess once it is fixed
|
|
/*
|
|
QProcess process;
|
|
if(showOutput)
|
|
process.setReadChannelMode(ForwardedChannels);
|
|
process.start(prog, args);
|
|
process.waitForFinished(-1);
|
|
return process.exitCode();
|
|
*/
|
|
}
|
|
|
|
bool qc_removedir(const QString &dirPath)
|
|
{
|
|
QDir dir(dirPath);
|
|
if(!dir.exists())
|
|
return false;
|
|
QStringList list = dir.entryList();
|
|
foreach(QString s, list)
|
|
{
|
|
if(s == "." || s == "..")
|
|
continue;
|
|
QFileInfo fi(dir.filePath(s));
|
|
if(fi.isDir())
|
|
{
|
|
if(!qc_removedir(fi.filePath()))
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if(!dir.remove(s))
|
|
return false;
|
|
}
|
|
}
|
|
QString dirName = dir.dirName();
|
|
if(!dir.cdUp())
|
|
return false;
|
|
if(!dir.rmdir(dirName))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void qc_splitcflags(const QString &cflags, QStringList *incs, QStringList *otherflags)
|
|
{
|
|
incs->clear();
|
|
otherflags->clear();
|
|
|
|
QStringList cflagsList = cflags.split(" ");
|
|
for(int n = 0; n < cflagsList.count(); ++n)
|
|
{
|
|
QString str = cflagsList[n];
|
|
if(str.startsWith("-I"))
|
|
{
|
|
// we want everything except the leading "-I"
|
|
incs->append(str.remove(0, 2));
|
|
}
|
|
else
|
|
{
|
|
// we want whatever is left
|
|
otherflags->append(str);
|
|
}
|
|
}
|
|
}
|
|
|
|
QString qc_escapeArg(const QString &str)
|
|
{
|
|
QString out;
|
|
for(int n = 0; n < (int)str.length(); ++n) {
|
|
if(str[n] == '-')
|
|
out += '_';
|
|
else
|
|
out += str[n];
|
|
}
|
|
return out;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// ConfObj
|
|
//----------------------------------------------------------------------------
|
|
ConfObj::ConfObj(Conf *c)
|
|
{
|
|
conf = c;
|
|
conf->added(this);
|
|
required = false;
|
|
disabled = false;
|
|
success = false;
|
|
}
|
|
|
|
ConfObj::~ConfObj()
|
|
{
|
|
}
|
|
|
|
QString ConfObj::checkString() const
|
|
{
|
|
return QString("Checking for %1 ...").arg(name());
|
|
}
|
|
|
|
QString ConfObj::resultString() const
|
|
{
|
|
if(success)
|
|
return "yes";
|
|
else
|
|
return "no";
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// qc_internal_pkgconfig
|
|
//----------------------------------------------------------------------------
|
|
class qc_internal_pkgconfig : public ConfObj
|
|
{
|
|
public:
|
|
QString pkgname, desc;
|
|
VersionMode mode;
|
|
QString req_ver;
|
|
|
|
qc_internal_pkgconfig(Conf *c, const QString &_name, const QString &_desc, VersionMode _mode, const QString &_req_ver) : ConfObj(c)
|
|
{
|
|
pkgname = _name;
|
|
desc = _desc;
|
|
mode = _mode;
|
|
req_ver = _req_ver;
|
|
}
|
|
|
|
QString name() const { return desc; }
|
|
QString shortname() const { return pkgname; }
|
|
|
|
bool exec()
|
|
{
|
|
QStringList incs;
|
|
QString version, libs, other;
|
|
if(!conf->findPkgConfig(pkgname, mode, req_ver, &version, &incs, &libs, &other))
|
|
return false;
|
|
|
|
for(int n = 0; n < incs.count(); ++n)
|
|
conf->addIncludePath(incs[n]);
|
|
if(!libs.isEmpty())
|
|
conf->addLib(libs);
|
|
//if(!other.isEmpty())
|
|
// conf->addExtra(QString("QMAKE_CFLAGS += %1\n").arg(other));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Conf
|
|
//----------------------------------------------------------------------------
|
|
Conf::Conf()
|
|
{
|
|
// TODO: no more vars?
|
|
//vars.insert("QMAKE_INCDIR_X11", new QString(X11_INC));
|
|
//vars.insert("QMAKE_LIBDIR_X11", new QString(X11_LIBDIR));
|
|
//vars.insert("QMAKE_LIBS_X11", new QString(X11_LIB));
|
|
//vars.insert("QMAKE_CC", CC);
|
|
|
|
debug_enabled = false;
|
|
}
|
|
|
|
Conf::~Conf()
|
|
{
|
|
qDeleteAll(list);
|
|
}
|
|
|
|
void Conf::added(ConfObj *o)
|
|
{
|
|
list.append(o);
|
|
}
|
|
|
|
QString Conf::getenv(const QString &var)
|
|
{
|
|
return qc_getenv(var);
|
|
}
|
|
|
|
void Conf::debug(const QString &s)
|
|
{
|
|
if(debug_enabled)
|
|
{
|
|
if(first_debug)
|
|
printf("\n");
|
|
first_debug = false;
|
|
printf(" * %s\n", qPrintable(s));
|
|
}
|
|
}
|
|
|
|
bool Conf::exec()
|
|
{
|
|
for(int n = 0; n < list.count(); ++n)
|
|
{
|
|
ConfObj *o = list[n];
|
|
|
|
// if this was a disabled-by-default option, check if it was enabled
|
|
if(o->disabled)
|
|
{
|
|
QString v = QString("QC_ENABLE_") + qc_escapeArg(o->shortname());
|
|
if(getenv(v) != "Y")
|
|
continue;
|
|
}
|
|
// and the opposite?
|
|
else
|
|
{
|
|
QString v = QString("QC_DISABLE_") + qc_escapeArg(o->shortname());
|
|
if(getenv(v) == "Y")
|
|
continue;
|
|
}
|
|
|
|
bool output = true;
|
|
QString check = o->checkString();
|
|
if(check.isEmpty())
|
|
output = false;
|
|
|
|
if(output)
|
|
{
|
|
printf("%s", check.toLatin1().data());
|
|
fflush(stdout);
|
|
}
|
|
|
|
first_debug = true;
|
|
bool ok = o->exec();
|
|
o->success = ok;
|
|
|
|
if(output)
|
|
{
|
|
QString result = o->resultString();
|
|
if(!first_debug)
|
|
printf(" -> %s\n", result.toLatin1().data());
|
|
else
|
|
printf(" %s\n", result.toLatin1().data());
|
|
}
|
|
|
|
if(!ok && o->required)
|
|
{
|
|
printf("\nError: need %s!\n", o->name().toLatin1().data());
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QString Conf::qvar(const QString &s)
|
|
{
|
|
return vars.value(s);
|
|
}
|
|
|
|
QString Conf::expandIncludes(const QString &inc)
|
|
{
|
|
return QString("-I") + inc;
|
|
}
|
|
|
|
QString Conf::expandLibs(const QString &lib)
|
|
{
|
|
return QString("-L") + lib;
|
|
}
|
|
|
|
int Conf::doCommand(const QString &s, QByteArray *out)
|
|
{
|
|
debug(QString("[%1]").arg(s));
|
|
int r = qc_runcommand(s, out, debug_enabled);
|
|
debug(QString("returned: %1").arg(r));
|
|
return r;
|
|
}
|
|
|
|
int Conf::doCommand(const QString &prog, const QStringList &args, QByteArray *out)
|
|
{
|
|
QString fullcmd = prog;
|
|
QString argstr = args.join(" ");
|
|
if(!argstr.isEmpty())
|
|
fullcmd += QString(" ") + argstr;
|
|
debug(QString("[%1]").arg(fullcmd));
|
|
int r = qc_runprogram(prog, args, out, debug_enabled);
|
|
debug(QString("returned: %1").arg(r));
|
|
return r;
|
|
}
|
|
|
|
bool Conf::doCompileAndLink(const QString &filedata, const QStringList &incs, const QString &libs, const QString &proextra, int *retcode)
|
|
{
|
|
QDir tmp(".qconftemp");
|
|
if(!tmp.mkdir("atest"))
|
|
{
|
|
debug("unable to create atest dir");
|
|
return false;
|
|
}
|
|
QDir dir(tmp.filePath("atest"));
|
|
if(!dir.exists())
|
|
{
|
|
debug("atest dir does not exist");
|
|
return false;
|
|
}
|
|
|
|
QString fname = dir.filePath("atest.cpp");
|
|
QString out = "atest";
|
|
QFile f(fname);
|
|
if(!f.open(QFile::WriteOnly | QFile::Truncate))
|
|
{
|
|
debug("unable to open atest.cpp for writing");
|
|
return false;
|
|
}
|
|
if(f.write(filedata.toLatin1()) == -1)
|
|
{
|
|
debug("error writing to atest.cpp");
|
|
return false;
|
|
}
|
|
f.close();
|
|
|
|
debug(QString("Wrote atest.cpp:\n%1").arg(filedata));
|
|
|
|
QString pro = QString(
|
|
"CONFIG += console\n"
|
|
"CONFIG -= qt app_bundle\n"
|
|
"SOURCES += atest.cpp\n");
|
|
QString inc = incs.join(" ");
|
|
if(!inc.isEmpty())
|
|
pro += "INCLUDEPATH += " + inc + '\n';
|
|
if(!libs.isEmpty())
|
|
pro += "LIBS += " + libs + '\n';
|
|
pro += proextra;
|
|
|
|
fname = dir.filePath("atest.pro");
|
|
f.setFileName(fname);
|
|
if(!f.open(QFile::WriteOnly | QFile::Truncate))
|
|
{
|
|
debug("unable to open atest.pro for writing");
|
|
return false;
|
|
}
|
|
if(f.write(pro.toLatin1()) == -1)
|
|
{
|
|
debug("error writing to atest.pro");
|
|
return false;
|
|
}
|
|
f.close();
|
|
|
|
debug(QString("Wrote atest.pro:\n%1").arg(pro));
|
|
|
|
QString oldpath = QDir::currentPath();
|
|
QDir::setCurrent(dir.path());
|
|
|
|
bool ok = false;
|
|
int r = doCommand(qmake_path, QStringList() << "atest.pro");
|
|
if(r == 0)
|
|
{
|
|
r = doCommand(maketool, QStringList());
|
|
if(r == 0)
|
|
{
|
|
ok = true;
|
|
if(retcode)
|
|
*retcode = doCommand(QString("./") + out, QStringList());
|
|
}
|
|
r = doCommand(maketool, QStringList() << "distclean");
|
|
if(r != 0)
|
|
debug("error during atest distclean");
|
|
}
|
|
|
|
QDir::setCurrent(oldpath);
|
|
|
|
// cleanup
|
|
//dir.remove("atest.pro");
|
|
//dir.remove("atest.cpp");
|
|
//tmp.rmdir("atest");
|
|
|
|
// remove whole dir since distclean doesn't always work
|
|
qc_removedir(tmp.filePath("atest"));
|
|
|
|
if(!ok)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool Conf::checkHeader(const QString &path, const QString &h)
|
|
{
|
|
QFileInfo fi(path + '/' + h);
|
|
if(fi.exists())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool Conf::findHeader(const QString &h, const QStringList &ext, QString *inc)
|
|
{
|
|
if(checkHeader("/usr/include", h))
|
|
{
|
|
*inc = "";
|
|
return true;
|
|
}
|
|
QStringList dirs;
|
|
dirs += "/usr/local/include";
|
|
dirs += ext;
|
|
for(QStringList::ConstIterator it = dirs.begin(); it != dirs.end(); ++it)
|
|
{
|
|
if(checkHeader(*it, h))
|
|
{
|
|
*inc = *it;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Conf::checkLibrary(const QString &path, const QString &name)
|
|
{
|
|
QString str =
|
|
//"#include <stdio.h>\n"
|
|
"int main()\n"
|
|
"{\n"
|
|
//" printf(\"library checker running\\\\n\");\n"
|
|
" return 0;\n"
|
|
"}\n";
|
|
|
|
QString libs;
|
|
if(!path.isEmpty())
|
|
libs += QString("-L") + path + ' ';
|
|
libs += QString("-l") + name;
|
|
if(!doCompileAndLink(str, QStringList(), libs, QString()))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool Conf::findLibrary(const QString &name, QString *lib)
|
|
{
|
|
if(checkLibrary("", name))
|
|
{
|
|
*lib = "";
|
|
return true;
|
|
}
|
|
if(checkLibrary("/usr/local/lib", name))
|
|
{
|
|
*lib = "/usr/local/lib";
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
QString Conf::findProgram(const QString &prog)
|
|
{
|
|
return qc_findprogram(prog);
|
|
}
|
|
|
|
bool Conf::findSimpleLibrary(const QString &incvar, const QString &libvar, const QString &incname, const QString &libname, QString *incpath, QString *libs)
|
|
{
|
|
QString inc, lib;
|
|
QString s;
|
|
|
|
s = getenv(incvar);
|
|
if(!s.isEmpty()) {
|
|
if(!checkHeader(s, incname))
|
|
return false;
|
|
inc = s;
|
|
}
|
|
else {
|
|
if(!findHeader(incname, QStringList(), &s))
|
|
return false;
|
|
inc = s;
|
|
}
|
|
|
|
s = getenv(libvar);
|
|
if(!s.isEmpty()) {
|
|
if(!checkLibrary(s, libname))
|
|
return false;
|
|
lib = s;
|
|
}
|
|
else {
|
|
if(!findLibrary(libname, &s))
|
|
return false;
|
|
lib = s;
|
|
}
|
|
|
|
QString lib_out;
|
|
if(!lib.isEmpty())
|
|
lib_out += QString("-L") + s;
|
|
lib_out += QString("-l") + libname;
|
|
|
|
*incpath = inc;
|
|
*libs = lib_out;
|
|
return true;
|
|
}
|
|
|
|
bool Conf::findFooConfig(const QString &path, QString *version, QStringList *incs, QString *libs, QString *otherflags)
|
|
{
|
|
QStringList args;
|
|
QByteArray out;
|
|
int ret;
|
|
|
|
args += "--version";
|
|
ret = doCommand(path, args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString version_out = QString::fromLatin1(out).trimmed();
|
|
|
|
args.clear();
|
|
args += "--libs";
|
|
ret = doCommand(path, args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString libs_out = QString::fromLatin1(out).trimmed();
|
|
|
|
args.clear();
|
|
args += "--cflags";
|
|
ret = doCommand(path, args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString cflags = QString::fromLatin1(out).trimmed();
|
|
|
|
QStringList incs_out, otherflags_out;
|
|
qc_splitcflags(cflags, &incs_out, &otherflags_out);
|
|
|
|
*version = version_out;
|
|
*incs = incs_out;
|
|
*libs = libs_out;
|
|
*otherflags = otherflags_out.join(" ");
|
|
return true;
|
|
}
|
|
|
|
bool Conf::findPkgConfig(const QString &name, VersionMode mode, const QString &req_version, QString *version, QStringList *incs, QString *libs, QString *otherflags)
|
|
{
|
|
QStringList args;
|
|
QByteArray out;
|
|
int ret;
|
|
|
|
args += name;
|
|
args += "--exists";
|
|
ret = doCommand("pkg-config", args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
if(mode != VersionAny)
|
|
{
|
|
args.clear();
|
|
args += name;
|
|
if(mode == VersionMin)
|
|
args += QString("--atleast-version=%1").arg(req_version);
|
|
else if(mode == VersionMax)
|
|
args += QString("--max-version=%1").arg(req_version);
|
|
else
|
|
args += QString("--exact-version=%1").arg(req_version);
|
|
ret = doCommand("pkg-config", args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
}
|
|
|
|
args.clear();
|
|
args += name;
|
|
args += "--modversion";
|
|
ret = doCommand("pkg-config", args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString version_out = QString::fromLatin1(out).trimmed();
|
|
|
|
args.clear();
|
|
args += name;
|
|
args += "--libs";
|
|
ret = doCommand("pkg-config", args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString libs_out = QString::fromLatin1(out).trimmed();
|
|
|
|
args.clear();
|
|
args += name;
|
|
args += "--cflags";
|
|
ret = doCommand("pkg-config", args, &out);
|
|
if(ret != 0)
|
|
return false;
|
|
|
|
QString cflags = QString::fromLatin1(out).trimmed();
|
|
|
|
QStringList incs_out, otherflags_out;
|
|
qc_splitcflags(cflags, &incs_out, &otherflags_out);
|
|
|
|
*version = version_out;
|
|
*incs = incs_out;
|
|
*libs = libs_out;
|
|
*otherflags = otherflags_out.join(" ");
|
|
return true;
|
|
}
|
|
|
|
void Conf::addDefine(const QString &str)
|
|
{
|
|
if(DEFINES.isEmpty())
|
|
DEFINES = str;
|
|
else
|
|
DEFINES += QString(" ") + str;
|
|
debug(QString("DEFINES += %1").arg(str));
|
|
}
|
|
|
|
void Conf::addLib(const QString &str)
|
|
{
|
|
if(LIBS.isEmpty())
|
|
LIBS = str;
|
|
else
|
|
LIBS += QString(" ") + str;
|
|
debug(QString("LIBS += %1").arg(str));
|
|
}
|
|
|
|
void Conf::addIncludePath(const QString &str)
|
|
{
|
|
if(INCLUDEPATH.isEmpty())
|
|
INCLUDEPATH = str;
|
|
else
|
|
INCLUDEPATH += QString(" ") + str;
|
|
debug(QString("INCLUDEPATH += %1").arg(str));
|
|
}
|
|
|
|
void Conf::addExtra(const QString &str)
|
|
{
|
|
extra += str + '\n';
|
|
debug(QString("extra += %1").arg(str));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// main
|
|
//----------------------------------------------------------------------------
|
|
#include "conf4.moc"
|
|
|
|
#ifdef HAVE_MODULES
|
|
# include"modules.cpp"
|
|
#endif
|
|
|
|
int main()
|
|
{
|
|
Conf *conf = new Conf;
|
|
ConfObj *o;
|
|
o = 0;
|
|
#ifdef HAVE_MODULES
|
|
# include"modules_new.cpp"
|
|
#endif
|
|
|
|
conf->debug_enabled = (qc_getenv("QC_VERBOSE") == "Y") ? true: false;
|
|
if(conf->debug_enabled)
|
|
printf(" -> ok\n");
|
|
else
|
|
printf("ok\n");
|
|
|
|
QString confCommand = qc_getenv("QC_COMMAND");
|
|
QString proName = qc_getenv("QC_PROFILE");
|
|
conf->qmake_path = qc_getenv("QC_QMAKE");
|
|
conf->maketool = qc_getenv("QC_MAKETOOL");
|
|
|
|
if(conf->debug_enabled)
|
|
printf("conf command: [%s]\n", qPrintable(confCommand));
|
|
|
|
QString confPath = qc_findself(confCommand);
|
|
if(confPath.isEmpty())
|
|
{
|
|
printf("Error: cannot find myself; rerun with an absolute path\n");
|
|
return 1;
|
|
}
|
|
|
|
QString srcdir = QFileInfo(confPath).absolutePath();
|
|
QString builddir = QDir::current().absolutePath();
|
|
QString proPath = QDir(srcdir).filePath(proName);
|
|
|
|
if(conf->debug_enabled)
|
|
{
|
|
printf("conf path: [%s]\n", qPrintable(confPath));
|
|
printf("srcdir: [%s]\n", qPrintable(srcdir));
|
|
printf("builddir: [%s]\n", qPrintable(builddir));
|
|
printf("profile: [%s]\n", qPrintable(proPath));
|
|
printf("qmake path: [%s]\n", qPrintable(conf->qmake_path));
|
|
printf("make tool: [%s]\n", qPrintable(conf->maketool));
|
|
printf("\n");
|
|
}
|
|
|
|
bool success = false;
|
|
if(conf->exec())
|
|
{
|
|
QFile f("conf.pri");
|
|
if(!f.open(QFile::WriteOnly | QFile::Truncate))
|
|
{
|
|
printf("Error writing %s\n", qPrintable(f.fileName()));
|
|
return 1;
|
|
}
|
|
|
|
QString str;
|
|
str += "# qconf\n\n";
|
|
|
|
QString var;
|
|
var = qc_getenv("PREFIX");
|
|
if(!var.isEmpty())
|
|
str += QString("PREFIX = %1\n").arg(var);
|
|
var = qc_getenv("BINDIR");
|
|
if(!var.isEmpty())
|
|
str += QString("BINDIR = %1\n").arg(var);
|
|
var = qc_getenv("INCDIR");
|
|
if(!var.isEmpty())
|
|
str += QString("INCDIR = %1\n").arg(var);
|
|
var = qc_getenv("LIBDIR");
|
|
if(!var.isEmpty())
|
|
str += QString("LIBDIR = %1\n").arg(var);
|
|
var = qc_getenv("DATADIR");
|
|
if(!var.isEmpty())
|
|
str += QString("DATADIR = %1\n").arg(var);
|
|
str += '\n';
|
|
|
|
if(qc_getenv("QC_STATIC") == "Y")
|
|
str += "CONFIG += staticlib\n";
|
|
|
|
// TODO: don't need this?
|
|
//str += "QT_PATH_PLUGINS = " + QString(qInstallPathPlugins()) + '\n';
|
|
|
|
if(!conf->DEFINES.isEmpty())
|
|
str += "DEFINES += " + conf->DEFINES + '\n';
|
|
if(!conf->INCLUDEPATH.isEmpty())
|
|
str += "INCLUDEPATH += " + conf->INCLUDEPATH + '\n';
|
|
if(!conf->LIBS.isEmpty())
|
|
str += "LIBS += " + conf->LIBS + '\n';
|
|
if(!conf->extra.isEmpty())
|
|
str += conf->extra;
|
|
str += '\n';
|
|
|
|
QByteArray cs = str.toLatin1();
|
|
f.write(cs);
|
|
f.close();
|
|
success = true;
|
|
}
|
|
QString qmake_path = conf->qmake_path;
|
|
delete conf;
|
|
|
|
if(!success)
|
|
return 1;
|
|
|
|
// run qmake on the project file
|
|
int ret = qc_runprogram(qmake_path, QStringList() << proPath, 0, true);
|
|
if(ret != 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
EOT
|
|
cat >$1/conf4.pro <<EOT
|
|
CONFIG += console
|
|
CONFIG -= app_bundle
|
|
QT -= gui
|
|
TARGET = conf
|
|
|
|
HEADERS += conf4.h
|
|
SOURCES += conf4.cpp
|
|
|
|
|
|
DEFINES += HAVE_MODULES
|
|
|
|
EOT
|
|
}
|
|
|
|
export PREFIX
|
|
export BINDIR
|
|
export DATADIR
|
|
export EX_QTDIR
|
|
export QC_ENABLE_DEBUG
|
|
export QC_DISABLE_GUI
|
|
export QC_DISABLE_qt_dbus
|
|
export QC_WITH_LIBBOOST_INC
|
|
export QC_WITH_LIBBOOST_LIB
|
|
export QC_DISABLE_geoip_database
|
|
export QC_WITH_GEOIP_DATABASE_EMBEDDED
|
|
export QC_WITH_QTSINGLEAPPLICATION
|
|
export QC_VERBOSE
|
|
rm -rf .qconftemp
|
|
(
|
|
mkdir .qconftemp
|
|
gen_files .qconftemp
|
|
cd .qconftemp
|
|
$qm conf4.pro >/dev/null
|
|
$MAKE clean >/dev/null 2>&1
|
|
$MAKE >../conf.log 2>&1
|
|
)
|
|
|
|
if [ "$?" != "0" ]; then
|
|
rm -rf .qconftemp
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo " -> fail"
|
|
else
|
|
echo "fail"
|
|
fi
|
|
printf "\n"
|
|
printf "Reason: There was an error compiling 'conf'. See conf.log for details.\n"
|
|
printf "\n"
|
|
show_qt_info
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo "conf.log:"
|
|
cat conf.log
|
|
fi
|
|
exit 1;
|
|
fi
|
|
|
|
QC_COMMAND=$0
|
|
export QC_COMMAND
|
|
QC_PROFILE=qbittorrent.pro
|
|
export QC_PROFILE
|
|
QC_QMAKE=$qm
|
|
export QC_QMAKE
|
|
QC_MAKETOOL=$MAKE
|
|
export QC_MAKETOOL
|
|
.qconftemp/conf
|
|
ret="$?"
|
|
if [ "$ret" = "1" ]; then
|
|
rm -rf .qconftemp
|
|
echo
|
|
exit 1;
|
|
else
|
|
if [ "$ret" != "0" ]; then
|
|
rm -rf .qconftemp
|
|
if [ "$QC_VERBOSE" = "Y" ]; then
|
|
echo " -> fail"
|
|
else
|
|
echo "fail"
|
|
fi
|
|
echo
|
|
echo "Reason: Unexpected error launching 'conf'"
|
|
echo
|
|
exit 1;
|
|
fi
|
|
fi
|
|
rm -rf .qconftemp
|
|
|
|
echo
|
|
echo "Good, your configure finished. Now run $MAKE."
|
|
echo
|