Logo Search packages:      
Sourcecode: qconf version File versions  Download package

conf.cpp

// For license information, see the COPYING file in the qconf base directory.

#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));
            vars.insert("QMAKE_CXX",        new QString(CXX));

            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_VERBOSE") == "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_CXX") + ' ' + 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"


Generated by  Doxygen 1.6.0   Back to index