#!/bin/sh

show_usage() {
cat <<EOT
Usage: ./configure [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
  --libdir=[path]    Directory for libraries.  Default: PREFIX/share/psi
  --qtdir=[path]     Directory where Qt is installed.
  --debug            Enable debug output.
  --help             This help text.

Dependency options:
  --with-qca-inc=[path]     Path to QCA include files
  --with-qca-lib=[path]     Path to QCA library files
  --with-zlib-inc=[path]    Path to zlib include files
  --with-zlib-lib=[path]    Path to zlib library files
  --disable-xss             Disable use of the XScreenSaver extension
  --disable-dnotify         Disable use of Linux Directory Notification
  --disable-ghbnr           Disable use of gethostbyname_r()
  --disable-kde             Disable use of KDE

EOT
}

while [ $# -gt 0 ]; do
	case "$1" in
		--prefix=*)
			PREFIX="${1#--prefix=}"
			shift
			;;

		--bindir=*)
			BINDIR="${1#--bindir=}"
			shift
			;;

		--libdir=*)
			LIBDIR="${1#--libdir=}"
			shift
			;;

		--qtdir=*)
			QTDIR="${1#--qtdir=}"
			shift
			;;

		--with-qca-inc=*)
			QC_WITH_QCA_INC="${1#--with-qca-inc=}"
			shift
			;;

		--with-qca-lib=*)
			QC_WITH_QCA_LIB="${1#--with-qca-lib=}"
			shift
			;;

		--with-zlib-inc=*)
			QC_WITH_ZLIB_INC="${1#--with-zlib-inc=}"
			shift
			;;

		--with-zlib-lib=*)
			QC_WITH_ZLIB_LIB="${1#--with-zlib-lib=}"
			shift
			;;

		--disable-xss)
			QC_DISABLE_xss="Y"
			shift
			;;

		--disable-dnotify)
			QC_DISABLE_dnotify="Y"
			shift
			;;

		--disable-ghbnr)
			QC_DISABLE_ghbnr="Y"
			shift
			;;

		--disable-kde)
			QC_DISABLE_kde="Y"
			shift
			;;

		--debug)
			QC_DEBUG="Y"
			shift
			;;
		--help) show_usage; exit ;;
		*) show_usage; exit ;;
	esac
done

PREFIX=${PREFIX:-/usr/local}
BINDIR=${BINDIR:-$PREFIX/bin}
LIBDIR=${LIBDIR:-$PREFIX/share/psi}

echo "Configuring Psi ..."

if [ "$QC_DEBUG" = "Y" ]; then
echo
echo PREFIX=$PREFIX
echo BINDIR=$BINDIR
echo LIBDIR=$LIBDIR
echo QTDIR=$QTDIR
echo QC_WITH_QCA_INC=$QC_WITH_QCA_INC
echo QC_WITH_QCA_LIB=$QC_WITH_QCA_LIB
echo QC_WITH_ZLIB_INC=$QC_WITH_ZLIB_INC
echo QC_WITH_ZLIB_LIB=$QC_WITH_ZLIB_LIB
echo QC_DISABLE_xss=$QC_DISABLE_xss
echo QC_DISABLE_dnotify=$QC_DISABLE_dnotify
echo QC_DISABLE_ghbnr=$QC_DISABLE_ghbnr
echo QC_DISABLE_kde=$QC_DISABLE_kde
echo
fi

printf "Verifying Qt 3.x Multithreaded (MT) build environment ... "

if [ -z "$QTDIR" ]; then
	if [ "$QC_DEBUG" = "Y" ]; then
		echo \$QTDIR not set... trying to find Qt manually
	fi
	for p in /usr/lib/qt /usr/share/qt /usr/share/qt3 /usr/local/lib/qt /usr/local/share/qt /usr/lib/qt3 /usr/local/lib/qt3 /usr/X11R6/share/qt /usr/qt/3 ; do
		if [ -d "$p/mkspecs" ]; then
			QTDIR=$p
			break;
		fi;
	done
	if [ -z "$QTDIR" ]; then
		echo fail
		echo
		echo "Unable to find Qt 'mkspecs'.  Perhaps you need to"
		echo "install the Qt 3 development utilities.  You may download"
		echo "them either from the vendor of your operating system"
		echo "or from http://www.trolltech.com/"
		echo
		echo "If you're sure you have the Qt development utilities"
		echo "installed, you might try using the --qtdir option."
		echo
		exit 1;
	fi
	if [ ! -x "$QTDIR/bin/moc" ]; then
		m=`which moc 2>/dev/null`
		if [ ! -x "$m" ]; then
			echo fail
			echo
			echo "We found Qt in $QTDIR, but we were unable to locate"
			echo "the moc utility.  It was not found in $QTDIR/bin"
			echo "nor in PATH.  This seems to be a very unusual setup."
			echo "You might try using the --qtdir option."
			echo
			exit 1;
		fi
		qtpre=`echo $m | awk '{ n = index($0, "/bin/moc"); if (!n) { exit 1; } print substr($0, 0, n-1); exit 0; }' 2>/dev/null`
		ret="$?"
		if [ "$ret" != "0" ]; then
			echo fail
			echo
			echo "We found Qt in $QTDIR, but the location of moc"
			echo "($m) is not suitable for use with this build system."
			echo "This is a VERY unusual and likely-broken setup.  You"
			echo "should contact the maintainer of your Qt package."
			echo
			exit 1;
		fi
		QTDIR=$qtpre
	fi
fi

if [ ! -x "$QTDIR/bin/qmake" ]; then
	if [ "$QC_DEBUG" = "Y" ]; then
		echo Warning: qmake not in \$QTDIR/bin/qmake
		echo trying to find it in \$PATH
	fi
	qm=`which qmake 2>/dev/null`
	if [ -x "$qm" ]; then
		if [ "$QC_DEBUG" = "Y" ]; then
			echo qmake found in $qm
		fi
	else
		echo fail
		echo
		echo Sorry, you seem to have a very unusual setup,
		echo or I missdetected \$QTDIR=$QTDIR
		echo
		echo Please set \$QTDIR manually and make sure that
		echo \$QTDIR/bin/qmake exists.
		echo
		exit 1;
	fi
else
	qm=$QTDIR/bin/qmake
fi

gen_files() {
cat >$1/modules.cpp <<EOT
#line 1 "qt31.qcm"
/*
-----BEGIN QCMOD-----
name: Qt >= 3.1
-----END QCMOD-----
*/
class qc_qt31 : public ConfObj
{
public:
	qc_qt31(Conf *c) : ConfObj(c) {}
	QString name() const { return "Qt >= 3.1"; }
	QString shortname() const { return "qt31"; }
	bool exec()
	{
		if(QT_VERSION >= 0x030100) {
			if(QT_VERSION < 0x030300)
				conf->addExtra("QXML_STATIC = Y");
			return true;
		}
		else
			return false;
	}
};
#line 1 "qca.qcm"
/*
-----BEGIN QCMOD-----
name: QCA 1.0
arg: with-qca-inc=[path],Path to QCA include files
arg: with-qca-lib=[path],Path to QCA library files
-----END QCMOD-----
*/

//----------------------------------------------------------------------------
// qc_qca
//----------------------------------------------------------------------------
class qc_qca : public ConfObj
{
public:
	qc_qca(Conf *c) : ConfObj(c) {}
	QString name() const { return "QCA 1.0"; }
	QString shortname() const { return "qca"; }
	bool exec()
	{
		QString inc, lib;
		QString s;

		s = conf->getenv("QC_WITH_QCA_INC");
		if(!s.isEmpty()) {
			if(!conf->checkHeader(s, "qca.h"))
				return false;
			inc = s;
		}
		else {
			if(!conf->findHeader("qca.h", QStringList(), &s))
				return false;
			inc = s;
		}

		s = conf->getenv("QC_WITH_QCA_LIB");
		if(!s.isEmpty()) {
			if(!conf->checkLibrary(s, "qca"))
				return false;
			lib = s;
		}
		else {
			if(!conf->findLibrary("qca", &s))
				return false;
			lib = s;
		}

		if(!inc.isEmpty())
			conf->addIncludePath(inc);
		if(!lib.isEmpty())
			conf->addLib(QString("-L") + s);
		conf->addLib("-lqca");

		return true;
	}
};
#line 1 "zlib.qcm"
/*
-----BEGIN QCMOD-----
name: zlib
arg: with-zlib-inc=[path],Path to zlib include files
arg: with-zlib-lib=[path],Path to zlib library files
-----END QCMOD-----
*/

//----------------------------------------------------------------------------
// qc_zlib
//----------------------------------------------------------------------------
class qc_zlib : public ConfObj
{
public:
	qc_zlib(Conf *c) : ConfObj(c) {}
	QString name() const { return "zlib"; }
	QString shortname() const { return "zlib"; }
	bool exec()
	{
		QString inc, lib;
		QString s;

		s = conf->getenv("QC_WITH_ZLIB_INC");
		if(!s.isEmpty()) {
			if(!conf->checkHeader(s, "zlib.h"))
				return false;
			inc = s;
		}
		else {
			if(!conf->findHeader("zlib.h", QStringList(), &s))
				return false;
			inc = s;
		}

		s = conf->getenv("QC_WITH_ZLIB_LIB");
		if(!s.isEmpty()) {
			if(!conf->checkLibrary(s, "z"))
				return false;
			lib = s;
		}
		else {
			if(!conf->findLibrary("z", &s))
				return false;
			lib = s;
		}

		if(!inc.isEmpty())
			conf->addIncludePath(inc);
		if(!lib.isEmpty())
			conf->addLib(QString("-L") + s);
		conf->addLib("-lz");

		return true;
	}
};
#line 1 "xss.qcm"
/*
-----BEGIN QCMOD-----
name: the XScreenSaver extension
-----END QCMOD-----
*/

//----------------------------------------------------------------------------
// qc_xss
//----------------------------------------------------------------------------
class qc_xss : public ConfObj
{
public:
	enum { OK, NEEDLIB, FAIL };
	qc_xss(Conf *c) : ConfObj(c)
	{
	}

	~qc_xss()
	{
		remove("xssprobe_test.c");
		remove("xssprobe_test.o");
		remove("xssprobe_test");
	}

	QString name() const
	{
		return "the XScreenSaver extension";
	}

	QString shortname() const { return "xss"; }

	int do_write()
	{
		char *xsstest =
			"#include<X11/Xlib.h>\n"
			"#include<X11/Xutil.h>\n"
			"#include<X11/extensions/scrnsaver.h>\n"
			"\n"
			"int main()\n"
			"{\n"
			"    XScreenSaverQueryExtension(NULL, NULL, NULL);\n"
			"    return 0;\n"
			"}\n";

		FILE *f;
		f = fopen("xssprobe_test.c", "w");
		if(!f)
			return 0;
		fwrite(xsstest, strlen(xsstest), 1, f);
		fclose(f);

		return 1;
	}

	int do_compile()
	{
		QString inc = conf->expandIncludes(conf->qvar("QMAKE_INCDIR_X11"));
		QString str = conf->qvar("QMAKE_CC") + " -c " + inc + " xssprobe_test.c -o xssprobe_test.o";
		int r = conf->doCommand(str);
		if(r == 0)
			return 1;
		else
			return 0;
	}

	int do_link()
	{
		QString lib = conf->expandLibs(conf->qvar("QMAKE_LIBDIR_X11"));
		QString inc = conf->expandIncludes(conf->qvar("QMAKE_INCDIR_X11"));
		QString str = conf->qvar("QMAKE_CC") + " xssprobe_test.o -o xssprobe_test " + lib + ' ' + conf->qvar("QMAKE_LIBS_X11");
		int r = conf->doCommand(str);
		if(r == 0)
			return 1;
		else
			return 0;
	}

	int do_linkLib()
	{
		QString lib = conf->expandLibs(conf->qvar("QMAKE_LIBDIR_X11"));
		QString inc = conf->expandIncludes(conf->qvar("QMAKE_INCDIR_X11"));
		QString str = conf->qvar("QMAKE_CC") + " xssprobe_test.o -o xssprobe_test " + lib + ' ' + conf->qvar("QMAKE_LIBS_X11") + " -lXss";
		int r = conf->doCommand(str);
		if(r == 0)
			return 1;
		else
			return 0;
	}

	int do_all()
	{
		if(!do_write())
			return FAIL;
		if(!do_compile())
			return FAIL;
		if(do_link())
			return OK;
		if(do_linkLib())
			return NEEDLIB;
		return FAIL;
	}

	bool exec()
	{
		int r = do_all();
		if(r == OK)
			return true;
		if(r == NEEDLIB) {
			conf->addLib("-lXss");
			return true;
		}
		else {
			conf->addDefine("NO_XSS");
			return false;
		}
	}
};
#line 1 "dnotify.qcm"
/*
-----BEGIN QCMOD-----
name: Linux Directory Notification
-----END QCMOD-----
*/

#include<unistd.h>
#include<fcntl.h>
#include<signal.h>
#include<sys/utsname.h>

//----------------------------------------------------------------------------
// qc_dnotify
//----------------------------------------------------------------------------
class qc_dnotify : public ConfObj
{
public:
	qc_dnotify(Conf *c) : ConfObj(c)
	{
	}

	~qc_dnotify()
	{
		remove("ftest.c");
		remove("ftest.o");
	}

	QString name() const { return "Linux Directory Notification"; }
	QString shortname() const { return "dnotify"; }

	bool do_write()
	{
		char *fdata =
			"#define _GNU_SOURCE\n"
			"#include<unistd.h>\n"
			"#include<fcntl.h>\n"
			"#include<signal.h>\n"
			"#include<sys/utsname.h>\n"
			"\n"
			"int main()\n"
			"{\n"
			"    DN_DELETE|DN_CREATE|DN_RENAME|DN_MULTISHOT|DN_MODIFY|DN_ATTRIB;\n"
			"    return 0;\n"
			"}\n";

		FILE *f;
		f = fopen("ftest.c", "w");
		if(!f)
			return false;
		fwrite(fdata, strlen(fdata), 1, f);
		fclose(f);

		return true;
	}

	bool do_compile()
	{
		QString str = conf->qvar("QMAKE_CC") + " -c ftest.c -o ftest.o";
		int r = conf->doCommand(str);
		if(r == 0)
			return true;
		else
			return false;
	}

	bool exec()
	{
		// taken from KDE
		bool supports_dnotify = true; // not guilty until proven guilty
		struct utsname uts;
		int major, minor, patch;
		if(uname(&uts) < 0)
			supports_dnotify = false; // *shrug*
		else if(sscanf(uts.release, "%d.%d.%d", &major, &minor, &patch) != 3)
			supports_dnotify = false; // *shrug*
		else if( major * 1000000 + minor * 1000 + patch < 2004019 ) // <2.4.19
			supports_dnotify = false;
		if(!supports_dnotify)
			return false;

		if(!do_write())
			return false;
		if(!do_compile())
			return false;

		conf->addDefine("HAVE_DNOTIFY");
		return true;
	}
};
#line 1 "ghbnr.qcm"
/*
-----BEGIN QCMOD-----
name: gethostbyname_r()
-----END QCMOD-----
*/
class qc_ghbnr : public ConfObj
{
public:
	qc_ghbnr(Conf *c) : ConfObj(c)
	{
	}

	~qc_ghbnr()
	{
		remove("ftest.c");
		remove("ftest");
	}

	QString name() const { return "gethostbyname_r()"; }
	QString shortname() const { return "ghbnr"; }

	bool exec()
	{
		char *fdata =
			"#include<netdb.h>\n"
			"\n"
			"int main()\n"
			"{\n"
			"    gethostbyname_r(\"\", 0, 0, 0, 0, 0);\n"
			"    return 0;\n"
			"}\n";

		FILE *f;
		f = fopen("ftest.c", "w");	
		if(!f)
			return false;
		fwrite(fdata, strlen(fdata), 1, f);
		fclose(f);

		QString str = conf->qvar("QMAKE_CC") + " ftest.c -o ftest";
		int r = conf->doCommand(str);
		if(r == 0) {
			conf->addDefine("HAVE_GETHOSTBYNAME_R");
			return true;
		}
		else
			return false;
	}
};
#line 1 "kde.qcm"
/*
-----BEGIN QCMOD-----
name: KDE
-----END QCMOD-----
*/

//----------------------------------------------------------------------------
// qc_kde
//----------------------------------------------------------------------------
class qc_kde : public ConfObj
{
public:
	qc_kde(Conf *c) : ConfObj(c) {}
	QString name() const { return "KDE"; }
	QString shortname() const { return "kde"; }
	bool exec()
	{
		char *p = getenv("KDEDIR");
		if(!p)
			return false;

		conf->addExtra(QString("KDE = %1").arg(p));
		return true;
	}
};

EOT
cat >$1/modules_new.cpp <<EOT
    o = new qc_qt31(conf);
    o->required = true;
    o->disabled = false;
    o = new qc_qca(conf);
    o->required = true;
    o->disabled = false;
    o = new qc_zlib(conf);
    o->required = true;
    o->disabled = false;
    o = new qc_xss(conf);
    o->required = false;
    o->disabled = false;
    o = new qc_dnotify(conf);
    o->required = false;
    o->disabled = false;
    o = new qc_ghbnr(conf);
    o->required = false;
    o->disabled = false;
    o = new qc_kde(conf);
    o->required = false;
    o->disabled = false;

EOT
cat >$1/conf.cpp <<EOT
#include<stdio.h>
#include<stdlib.h>
#include<qstring.h>
#include<qdict.h>
#include<qptrlist.h>
#include<qfileinfo.h>
#include<qfile.h>
#include<qdir.h>
#include<qstringlist.h>
#include<qobject.h>

class MocTestObject : public QObject
{
	Q_OBJECT
public:
	MocTestObject() {}
};

class Conf;

class ConfObj
{
public:
	ConfObj(Conf *c);
	virtual ~ConfObj();

	virtual QString name() const=0;
	virtual QString shortname() const=0;
	virtual QString checkString() const;
	virtual QString resultString() const;
	virtual bool exec()=0;

	Conf *conf;
	bool required;
	bool disabled;
};

typedef QPtrList<ConfObj> ConfObjList;
typedef QPtrListIterator<ConfObj> ConfObjListIt;

class Conf
{
public:
	Conf() : vars(17)
	{
		list.setAutoDelete(true);
		vars.setAutoDelete(true);

		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",         new QString(CC));

		do_debug = false;
		done_debug = false;
	}

	~Conf()
	{
	}

	void added(ConfObj *o)
	{
		list.append(o);
	}

	QString getenv(const QString &var)
	{
		char *p = ::getenv(var.latin1());
		if(!p)
			return QString::null;
		return QString(p);
	}

	void debug(const QString &s)
	{
		if(do_debug) {
			if(!done_debug)
				printf("\n");
			done_debug = true;
			printf(" * %s\n", s.latin1());
		}
	}

	bool exec()
	{
		if(getenv("QC_DEBUG") == "Y")
			do_debug = true;

		ConfObjListIt it(list);
		for(ConfObj *o; (o = it.current()); ++it) {
			// if this was a disabled-by-default option, check if it was enabled
			if(o->disabled) {
				QString v = QString("QC_ENABLE_") + o->shortname();
				if(getenv(v) != "Y")
					continue;
			}
			// and the opposite?
			else {
				QString v = QString("QC_DISABLE_") + o->shortname();
				if(getenv(v) == "Y")
					continue;
			}

			QString check = o->checkString();
			if(check.isEmpty())
				check = QString("Checking for %1 ...").arg(o->name());
			printf("%s", check.latin1());
			fflush(stdout);

			done_debug = false;
			bool ok = o->exec();

			QString result = o->resultString();
			if(result.isEmpty()) {
				if(ok)
					result = "yes";
				else
					result = "no";
			}
			if(done_debug)
				printf(" -> %s\n", result.latin1());
			else
				printf(" %s\n", result.latin1());

			if(!ok && o->required) {
				printf("\nError: need %s!\n", o->name().latin1());
				return false;
			}
		}
		return true;
	}

	const QString & qvar(const QString &s)
	{
		QString *p = vars.find(s);
		if(p)
			return *p;
		else
			return blank;
	}

	QString expandIncludes(const QString &inc)
	{
		return QString("-I") + inc;
	}

	QString expandLibs(const QString &lib)
	{
		return QString("-L") + lib;
	}

	int doCommand(const QString &s)
	{
		debug(QString("[%1]").arg(s));
		QString fullcmd;
		if(do_debug)
			fullcmd = s;
		else
			fullcmd = s + " 1>/dev/null 2>/dev/null";
		int r = system(fullcmd.latin1());
		debug(QString("returned: %1").arg(r));
		return r;
	}

	bool doCompileAndLink(const QString &filedata, const QString &flags, int *retcode=0)
	{
		QDir dir(".");
		QString fname = "atest.c";
		QString out = "atest";
		QFile f(fname);
		QCString cs = filedata.latin1();
		if(!f.open(IO_WriteOnly | IO_Truncate)) {
			debug("unable to open atest.c for writing");
			return false;
		}
		if(f.writeBlock(cs.data(), cs.length()) == -1) {
			debug("error writing to atest.c");
			return false;
		}
		f.close();

		debug(QString("Wrote atest.c:\n%1").arg(filedata));

		QString str = qvar("QMAKE_CC") + ' ' + fname + " -o " + out;
		if(!flags.isEmpty()) {
			str += ' ';
			str += flags;
		}

		int r = doCommand(str);
		if(r == 0 && retcode)
			*retcode = doCommand(QString("./") + out);
		dir.remove(fname);
		dir.remove(out);
		if(r != 0)
			return false;
		return true;
	}

	bool checkHeader(const QString &path, const QString &h)
	{
		QFileInfo fi(path + '/' + h);
		if(fi.exists())
			return true;
		return false;
	}

	bool 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 checkLibrary(const QString &path, const QString &name)
	{
		QString str =
			"int main()\n"
			"{\n"
			"    return 0;\n"
			"}\n";

		QString extra;
		if(!path.isEmpty())
			extra += QString("-L") + path + ' ';
		extra += QString("-l") + name;
		if(!doCompileAndLink(str, extra))
			return false;
		return true;
	}

	bool 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;
	}

	void addDefine(const QString &str)
	{
		if(DEFINES.isEmpty())
			DEFINES = str;
		else
			DEFINES += QString(" ") + str;
		debug(QString("DEFINES += %1").arg(str));
	}

	void addLib(const QString &str)
	{
		if(LIBS.isEmpty())
			LIBS = str;
		else
			LIBS += QString(" ") + str;
		debug(QString("LIBS += %1").arg(str));
	}

	void addIncludePath(const QString &str)
	{
		if(INCLUDEPATH.isEmpty())
			INCLUDEPATH = str;
		else
			INCLUDEPATH += QString(" ") + str;
		debug(QString("INCLUDEPATH += %1").arg(str));
	}

	void addExtra(const QString &str)
	{
		extra += str + '\n';
		debug(QString("extra += %1").arg(str));
	}

	QString DEFINES;
	QString INCLUDEPATH;
	QString LIBS;
	QString extra;

private:
	ConfObjList list;
	QDict<QString> vars;
	QString blank;
	bool do_debug, done_debug;
};

ConfObj::ConfObj(Conf *c)
{
	conf = c;
	conf->added(this);
	required = false;
	disabled = false;
}

ConfObj::~ConfObj()
{
}

QString ConfObj::checkString() const
{
	return QString();
}

QString ConfObj::resultString() const
{
	return QString();
}

#include"modules.cpp"

//----------------------------------------------------------------------------
// main
//----------------------------------------------------------------------------
int main()
{
	Conf *conf = new Conf;
	ConfObj *o;
	o = 0;
#include"modules_new.cpp"

	printf("ok\n");
	bool success = false;
	if(conf->exec()) {
		QFile f("conf.pri");
		if(!f.open(IO_WriteOnly | IO_Truncate)) {
			printf("Error writing %s\n", f.name().latin1());
			return 1;
		}

		QString str;
		str += "# qconf\n";
		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';

		char *p = getenv("BINDIR");
		if(p) {
			str += QString("target.path = ") + p + '\n';
			str += "INSTALLS += target\n";
		}

		QCString cs = str.latin1();
		f.writeBlock(cs.data(), cs.length());
		f.close();
		success = true;
	}
	delete conf;

	if(success)
		return 0;
	else
		return 1;
}

#include"conf.moc"


EOT
cat >$1/conf.pro <<EOT
TEMPLATE = app
CONFIG += qt x11 thread console
TARGET = conf

DEFINES += X11_INC='"\$\$QMAKE_INCDIR_X11"'
DEFINES += X11_LIBDIR='"\$\$QMAKE_LIBDIR_X11"'
DEFINES += X11_LIB='"\$\$QMAKE_LIBS_X11"'
DEFINES += CC='"\$\$QMAKE_CC"'

SOURCES += conf.cpp

EOT
}

export PREFIX
export BINDIR
export LIBDIR
export QTDIR
export QC_WITH_QCA_INC
export QC_WITH_QCA_LIB
export QC_WITH_ZLIB_INC
export QC_WITH_ZLIB_LIB
export QC_DISABLE_xss
export QC_DISABLE_dnotify
export QC_DISABLE_ghbnr
export QC_DISABLE_kde
export QC_DEBUG
rm -rf .qconftemp
(
	mkdir .qconftemp
	gen_files .qconftemp
	cd .qconftemp
	$qm conf.pro >/dev/null
	QTDIR=$QTDIR make clean >/dev/null 2>&1
	QTDIR=$QTDIR make >../conf.log 2>&1
)

if [ "$?" != "0" ]; then
	rm -rf .qconftemp
	echo fail
	echo
	echo "There was an error compiling 'conf'.  Be sure you have a proper"
	echo "Qt 3.x Multithreaded (MT) build environment set up.  This"
	echo "means not just Qt, but also a C++ compiler, the 'make' command,"
	echo "and any other packages necessary to compile C++ programs."
	echo "See conf.log for details."
	if [ ! -f "$QTDIR/lib/libqt-mt.so.3" ]; then
		echo
		echo "One possible reason is that you don't have"
		echo "libqt-mt.so.3 installed in $QTDIR/lib/."
	fi
	echo
	exit 1;
fi

.qconftemp/conf
ret="$?"
if [ "$ret" = "1" ]; then
	rm -rf .qconftemp
	echo
	exit 1;
else
	if [ "$ret" != "0" ]; then
		rm -rf .qconftemp
		echo fail
		echo
		echo Unexpected error launching 'conf'
		echo
		exit 1;
	fi
fi
rm -rf .qconftemp

if [ -x "./qcextra" ]; then
	./qcextra
fi
# run qmake
$qm psi.pro
if [ "$?" != "0" ]; then
	echo
	exit 1;
fi
cat >Makefile.tmp <<EOT
export QTDIR = $QTDIR
export PATH = $QTDIR/bin:$PATH
EOT
cat Makefile >> Makefile.tmp
rm -f Makefile
cp -f Makefile.tmp Makefile
rm -f Makefile.tmp

echo
echo Good, your configure finished.  Now run \'make\'.
echo