1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the qmake application of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "projectgenerator.h"

    43 #include "option.h"

    44 #include <qdatetime.h>

    45 #include <qdir.h>

    46 #include <qfile.h>

    47 #include <qfileinfo.h>

    48 #include <qregexp.h>

    49 

    50 QT_BEGIN_NAMESPACE

    51 

    52 QString project_builtin_regx() //calculate the builtin regular expression..

    53 {

    54     QString ret;

    55     QStringList builtin_exts;

    56     builtin_exts << Option::c_ext << Option::ui_ext << Option::yacc_ext << Option::lex_ext << ".ts" << ".xlf" << ".qrc";

    57     builtin_exts += Option::h_ext + Option::cpp_ext;

    58     for(int i = 0; i < builtin_exts.size(); ++i) {

    59         if(!ret.isEmpty())

    60             ret += "; ";

    61         ret += QString("*") + builtin_exts[i];

    62     }

    63     return ret;

    64 }

    65 

    66 ProjectGenerator::ProjectGenerator() : MakefileGenerator(), init_flag(false)

    67 {

    68 }

    69 

    70 void

    71 ProjectGenerator::init()

    72 {

    73     if(init_flag)

    74         return;

    75     int file_count = 0;

    76     init_flag = true;

    77     verifyCompilers();

    78 

    79     project->read(QMakeProject::ReadFeatures);

    80     project->variables()["CONFIG"].clear();

    81 

    82     QMap<QString, QStringList> &v = project->variables();

    83     QString templ = Option::user_template.isEmpty() ? QString("app") : Option::user_template;

    84     if(!Option::user_template_prefix.isEmpty())

    85         templ.prepend(Option::user_template_prefix);

    86     v["TEMPLATE_ASSIGN"] += templ;

    87 

    88     //figure out target

    89     if(Option::output.fileName() == "-")

    90         v["TARGET_ASSIGN"] = QStringList("unknown");

    91     else

    92         v["TARGET_ASSIGN"] = QStringList(QFileInfo(Option::output).baseName());

    93 

    94     //the scary stuff

    95     if(project->first("TEMPLATE_ASSIGN") != "subdirs") {

    96         QString builtin_regex = project_builtin_regx();

    97         QStringList dirs = Option::projfile::project_dirs;

    98         if(Option::projfile::do_pwd) {

    99             if(!v["INCLUDEPATH"].contains("."))

   100                 v["INCLUDEPATH"] += ".";

   101             dirs.prepend(qmake_getpwd());

   102         }

   103 

   104         for(int i = 0; i < dirs.count(); ++i) {

   105             QString dir, regex, pd = dirs.at(i);

   106             bool add_depend = false;

   107             if(exists(pd)) {

   108                 QFileInfo fi(fileInfo(pd));

   109                 if(fi.isDir()) {

   110                     dir = pd;

   111                     add_depend = true;

   112                     if(dir.right(1) != Option::dir_sep)

   113                         dir += Option::dir_sep;

   114                     if(Option::recursive) {

   115                         QStringList files = QDir(dir).entryList(QDir::Files);

   116                         for(int i = 0; i < (int)files.count(); i++) {

   117                             if(files[i] != "." && files[i] != "..")

   118                                 dirs.append(dir + files[i] + QDir::separator() + builtin_regex);

   119                         }

   120                     }

   121                     regex = builtin_regex;

   122                 } else {

   123                     QString file = pd;

   124                     int s = file.lastIndexOf(Option::dir_sep);

   125                     if(s != -1)

   126                         dir = file.left(s+1);

   127                     if(addFile(file)) {

   128                         add_depend = true;

   129                         file_count++;

   130                     }

   131                 }

   132             } else { //regexp

   133                 regex = pd;

   134             }

   135             if(!regex.isEmpty()) {

   136                 int s = regex.lastIndexOf(Option::dir_sep);

   137                 if(s != -1) {

   138                     dir = regex.left(s+1);

   139                     regex = regex.right(regex.length() - (s+1));

   140                 }

   141                 if(Option::recursive) {

   142                     QStringList entries = QDir(dir).entryList(QDir::Dirs);

   143                     for(int i = 0; i < (int)entries.count(); i++) {

   144                         if(entries[i] != "." && entries[i] != "..") {

   145                             dirs.append(dir + entries[i] + QDir::separator() + regex);

   146                         }

   147                     }

   148                 }

   149                 QStringList files = QDir(dir).entryList(QDir::nameFiltersFromString(regex));

   150                 for(int i = 0; i < (int)files.count(); i++) {

   151                     QString file = dir + files[i];

   152                     if (addFile(file)) {

   153                         add_depend = true;

   154                         file_count++;

   155                     }

   156                 }

   157             }

   158             if(add_depend && !dir.isEmpty() && !v["DEPENDPATH"].contains(dir, Qt::CaseInsensitive)) {

   159                 QFileInfo fi(fileInfo(dir));

   160                 if(fi.absoluteFilePath() != qmake_getpwd())

   161                     v["DEPENDPATH"] += fileFixify(dir);

   162             }

   163         }

   164     }

   165     if(!file_count) { //shall we try a subdir?

   166         QStringList knownDirs = Option::projfile::project_dirs;

   167         if(Option::projfile::do_pwd)

   168             knownDirs.prepend(".");

   169         const QString out_file = fileFixify(Option::output.fileName());

   170         for(int i = 0; i < knownDirs.count(); ++i) {

   171             QString pd = knownDirs.at(i);

   172             if(exists(pd)) {

   173                 QString newdir = pd;

   174                 QFileInfo fi(fileInfo(newdir));

   175                 if(fi.isDir()) {

   176                     newdir = fileFixify(newdir);

   177                     QStringList &subdirs = v["SUBDIRS"];

   178                     if(exists(fi.filePath() + QDir::separator() + fi.fileName() + Option::pro_ext) &&

   179                        !subdirs.contains(newdir, Qt::CaseInsensitive)) {

   180                         subdirs.append(newdir);

   181                     } else {

   182                         QStringList profiles = QDir(newdir).entryList(QStringList("*" + Option::pro_ext), QDir::Files);

   183                         for(int i = 0; i < (int)profiles.count(); i++) {

   184                             QString nd = newdir;

   185                             if(nd == ".")

   186                                 nd = "";

   187                             else if(!nd.isEmpty() && !nd.endsWith(QString(QChar(QDir::separator()))))

   188                                 nd += QDir::separator();

   189                             nd += profiles[i];

   190                             fileFixify(nd);

   191                             if(profiles[i] != "." && profiles[i] != ".." &&

   192                                !subdirs.contains(nd, Qt::CaseInsensitive) && !out_file.endsWith(nd))

   193                                 subdirs.append(nd);

   194                         }

   195                     }

   196                     if(Option::recursive) {

   197                         QStringList dirs = QDir(newdir).entryList(QDir::Dirs);

   198                         for(int i = 0; i < (int)dirs.count(); i++) {

   199                             QString nd = fileFixify(newdir + QDir::separator() + dirs[i]);

   200                             if(dirs[i] != "." && dirs[i] != ".." && !knownDirs.contains(nd, Qt::CaseInsensitive))

   201                                 knownDirs.append(nd);

   202                         }

   203                     }

   204                 }

   205             } else { //regexp

   206                 QString regx = pd, dir;

   207                 int s = regx.lastIndexOf(Option::dir_sep);

   208                 if(s != -1) {

   209                     dir = regx.left(s+1);

   210                     regx = regx.right(regx.length() - (s+1));

   211                 }

   212                 QStringList files = QDir(dir).entryList(QDir::nameFiltersFromString(regx), QDir::Dirs);

   213                 QStringList &subdirs = v["SUBDIRS"];

   214                 for(int i = 0; i < (int)files.count(); i++) {

   215                     QString newdir(dir + files[i]);

   216                     QFileInfo fi(fileInfo(newdir));

   217                     if(fi.fileName() != "." && fi.fileName() != "..") {

   218                         newdir = fileFixify(newdir);

   219                         if(exists(fi.filePath() + QDir::separator() + fi.fileName() + Option::pro_ext) &&

   220                            !subdirs.contains(newdir)) {

   221                            subdirs.append(newdir);

   222                         } else {

   223                             QStringList profiles = QDir(newdir).entryList(QStringList("*" + Option::pro_ext), QDir::Files);

   224                             for(int i = 0; i < (int)profiles.count(); i++) {

   225                                 QString nd = newdir + QDir::separator() + files[i];

   226                                 fileFixify(nd);

   227                                 if(files[i] != "." && files[i] != ".." && !subdirs.contains(nd, Qt::CaseInsensitive)) {

   228                                     if(newdir + files[i] != Option::output_dir + Option::output.fileName())

   229                                         subdirs.append(nd);

   230                                 }

   231                             }

   232                         }

   233                         if(Option::recursive && !knownDirs.contains(newdir, Qt::CaseInsensitive))

   234                             knownDirs.append(newdir);

   235                     }

   236                 }

   237             }

   238         }

   239         v["TEMPLATE_ASSIGN"] = QStringList("subdirs");

   240         return;

   241     }

   242 

   243     //setup deplist

   244     QList<QMakeLocalFileName> deplist;

   245     {

   246         const QStringList &d = v["DEPENDPATH"];

   247         for(int i = 0; i < d.size(); ++i)

   248             deplist.append(QMakeLocalFileName(d[i]));

   249     }

   250     setDependencyPaths(deplist);

   251 

   252     QStringList &h = v["HEADERS"];

   253     bool no_qt_files = true;

   254     QString srcs[] = { "SOURCES", "YACCSOURCES", "LEXSOURCES", "FORMS", QString() };

   255     for(int i = 0; !srcs[i].isNull(); i++) {

   256         const QStringList &l = v[srcs[i]];

   257         QMakeSourceFileInfo::SourceFileType type = QMakeSourceFileInfo::TYPE_C;

   258         QMakeSourceFileInfo::addSourceFiles(l, QMakeSourceFileInfo::SEEK_DEPS, type);

   259         for(int i = 0; i < l.size(); ++i) {

   260             QStringList tmp = QMakeSourceFileInfo::dependencies(l[i]);

   261             if(!tmp.isEmpty()) {

   262                 for(int dep_it = 0; dep_it < tmp.size(); ++dep_it) {

   263                     QString dep = tmp[dep_it];

   264                     dep = fixPathToQmake(dep);

   265                     QString file_dir = dep.section(Option::dir_sep, 0, -2),

   266                         file_no_path = dep.section(Option::dir_sep, -1);

   267                     if(!file_dir.isEmpty()) {

   268                         for(int inc_it = 0; inc_it < deplist.size(); ++inc_it) {

   269                             QMakeLocalFileName inc = deplist[inc_it];

   270                             if(inc.local() == file_dir && !v["INCLUDEPATH"].contains(inc.real(), Qt::CaseInsensitive))

   271                                 v["INCLUDEPATH"] += inc.real();

   272                         }

   273                     }

   274                     if(no_qt_files && file_no_path.indexOf(QRegExp("^q[a-z_0-9].h$")) != -1)

   275                         no_qt_files = false;

   276                     QString h_ext;

   277                     for(int hit = 0; hit < Option::h_ext.size(); ++hit) {

   278                         if(dep.endsWith(Option::h_ext.at(hit))) {

   279                             h_ext = Option::h_ext.at(hit);

   280                             break;

   281                         }

   282                     }

   283                     if(!h_ext.isEmpty()) {

   284                         for(int cppit = 0; cppit < Option::cpp_ext.size(); ++cppit) {

   285                             QString src(dep.left(dep.length() - h_ext.length()) +

   286                                         Option::cpp_ext.at(cppit));

   287                             if(exists(src)) {

   288                                 QStringList &srcl = v["SOURCES"];

   289                                 if(!srcl.contains(src, Qt::CaseInsensitive))

   290                                     srcl.append(src);

   291                             }

   292                         }

   293                     } else if(dep.endsWith(Option::lex_ext) &&

   294                               file_no_path.startsWith(Option::lex_mod)) {

   295                         addConfig("lex_included");

   296                     }

   297                     if(!h.contains(dep, Qt::CaseInsensitive))

   298                         h += dep;

   299                 }

   300             }

   301         }

   302     }

   303 

   304     //strip out files that are actually output from internal compilers (ie temporary files)

   305     const QStringList &quc = project->variables()["QMAKE_EXTRA_COMPILERS"];

   306     for(QStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) {

   307         QString tmp_out = project->variables()[(*it) + ".output"].first();

   308         if(tmp_out.isEmpty())

   309             continue;

   310 

   311         QStringList var_out = project->variables()[(*it) + ".variable_out"];

   312         bool defaults = var_out.isEmpty();

   313         for(int i = 0; i < var_out.size(); ++i) {

   314             QString v = var_out.at(i);

   315             if(v.startsWith("GENERATED_")) {

   316                 defaults = true;

   317                 break;

   318             }

   319         }

   320         if(defaults) {

   321             var_out << "SOURCES";

   322             var_out << "HEADERS";

   323             var_out << "FORMS";

   324         }

   325         const QStringList &tmp = project->variables()[(*it) + ".input"];

   326         for(QStringList::ConstIterator it2 = tmp.begin(); it2 != tmp.end(); ++it2) {

   327             QStringList &inputs = project->variables()[(*it2)];

   328             for(QStringList::Iterator input = inputs.begin(); input != inputs.end(); ++input) {

   329                 QString path = replaceExtraCompilerVariables(tmp_out, (*input), QString());

   330                 path = fixPathToQmake(path).section('/', -1);

   331                 for(int i = 0; i < var_out.size(); ++i) {

   332                     QString v = var_out.at(i);

   333                     QStringList &list = project->variables()[v];

   334                     for(int src = 0; src < list.size(); ) {

   335                         if(list[src] == path || list[src].endsWith("/" + path))

   336                             list.removeAt(src);

   337                         else

   338                             ++src;

   339                     }

   340                 }

   341             }

   342         }

   343     }

   344 }

   345 

   346 bool

   347 ProjectGenerator::writeMakefile(QTextStream &t)

   348 {

   349     t << "######################################################################" << endl;

   350     t << "# Automatically generated by qmake (" << qmake_version() << ") " << QDateTime::currentDateTime().toString() << endl;

   351     t << "######################################################################" << endl << endl;

   352     if(!Option::user_configs.isEmpty())

   353         t << "CONFIG += " << Option::user_configs.join(" ") << endl;

   354     int i;

   355     for(i = 0; i < Option::before_user_vars.size(); ++i)

   356         t << Option::before_user_vars[i] << endl;

   357     t << getWritableVar("TEMPLATE_ASSIGN", false);

   358     if(project->first("TEMPLATE_ASSIGN") == "subdirs") {

   359         t << endl << "# Directories" << "\n"

   360           << getWritableVar("SUBDIRS");

   361     } else {

   362         t << getWritableVar("TARGET_ASSIGN")

   363           << getWritableVar("CONFIG", false)

   364           << getWritableVar("CONFIG_REMOVE", false)

   365           << getWritableVar("DEPENDPATH")

   366           << getWritableVar("INCLUDEPATH") << endl;

   367 

   368         t << "# Input" << "\n";

   369         t << getWritableVar("HEADERS")

   370           << getWritableVar("FORMS")

   371           << getWritableVar("LEXSOURCES")

   372           << getWritableVar("YACCSOURCES")

   373           << getWritableVar("SOURCES")

   374           << getWritableVar("RESOURCES")

   375           << getWritableVar("TRANSLATIONS");

   376     }

   377     for(i = 0; i < Option::after_user_vars.size(); ++i)

   378         t << Option::after_user_vars[i] << endl;

   379     return true;

   380 }

   381 

   382 bool

   383 ProjectGenerator::addConfig(const QString &cfg, bool add)

   384 {

   385     QString where = "CONFIG";

   386     if(!add)

   387         where = "CONFIG_REMOVE";

   388     if(!project->variables()[where].contains(cfg)) {

   389         project->variables()[where] += cfg;

   390         return true;

   391     }

   392     return false;

   393 }

   394 

   395 bool

   396 ProjectGenerator::addFile(QString file)

   397 {

   398     file = fileFixify(file, qmake_getpwd());

   399     QString dir;

   400     int s = file.lastIndexOf(Option::dir_sep);

   401     if(s != -1)

   402         dir = file.left(s+1);

   403     if(file.mid(dir.length(), Option::h_moc_mod.length()) == Option::h_moc_mod)

   404         return false;

   405 

   406     QString where;

   407     for(int cppit = 0; cppit < Option::cpp_ext.size(); ++cppit) {

   408         if(file.endsWith(Option::cpp_ext[cppit])) {

   409             where = "SOURCES";

   410             break;

   411         }

   412     }

   413     if(where.isEmpty()) {

   414         for(int hit = 0; hit < Option::h_ext.size(); ++hit)

   415             if(file.endsWith(Option::h_ext.at(hit))) {

   416                 where = "HEADERS";

   417                 break;

   418             }

   419     }

   420     if(where.isEmpty()) {

   421         for(int cit = 0; cit < Option::c_ext.size(); ++cit) {

   422             if(file.endsWith(Option::c_ext[cit])) {

   423                 where = "SOURCES";

   424                 break;

   425             }

   426         }

   427     }

   428     if(where.isEmpty()) {

   429         if(file.endsWith(Option::ui_ext))

   430             where = "FORMS";

   431         else if(file.endsWith(Option::lex_ext))

   432             where = "LEXSOURCES";

   433         else if(file.endsWith(Option::yacc_ext))

   434             where = "YACCSOURCES";

   435         else if(file.endsWith(".ts") || file.endsWith(".xlf"))

   436             where = "TRANSLATIONS";

   437         else if(file.endsWith(".qrc"))

   438             where = "RESOURCES";

   439     }

   440 

   441     QString newfile = fixPathToQmake(fileFixify(file));

   442 

   443     QStringList &endList = project->variables()[where];

   444     if(!endList.contains(newfile, Qt::CaseInsensitive)) {

   445         endList += newfile;

   446         return true;

   447     }

   448     return false;

   449 }

   450 

   451 QString

   452 ProjectGenerator::getWritableVar(const QString &v, bool)

   453 {

   454     QStringList &vals = project->variables()[v];

   455     if(vals.isEmpty())

   456         return "";

   457 

   458     // If values contain spaces, ensure that they are quoted

   459     for(QStringList::iterator it = vals.begin(); it != vals.end(); ++it) {

   460         if ((*it).contains(' ') && !(*it).startsWith(' '))

   461             *it = '\"' + *it + '\"';

   462     }

   463 

   464     QString ret;

   465     if(v.endsWith("_REMOVE"))

   466         ret = v.left(v.length() - 7) + " -= ";

   467     else if(v.endsWith("_ASSIGN"))

   468         ret = v.left(v.length() - 7) + " = ";

   469     else

   470         ret = v + " += ";

   471     QString join = vals.join(" ");

   472     if(ret.length() + join.length() > 80) {

   473         QString spaces;

   474         for(int i = 0; i < ret.length(); i++)

   475             spaces += " ";

   476         join = vals.join(" \\\n" + spaces);

   477     }

   478     return ret + join + "\n";

   479 }

   480 

   481 bool

   482 ProjectGenerator::openOutput(QFile &file, const QString &build) const

   483 {

   484     QString outdir;

   485     if(!file.fileName().isEmpty()) {

   486         QFileInfo fi(fileInfo(file.fileName()));

   487         if(fi.isDir())

   488             outdir = fi.path() + QDir::separator();

   489     }

   490     if(!outdir.isEmpty() || file.fileName().isEmpty()) {

   491         QString dir = qmake_getpwd();

   492         int s = dir.lastIndexOf('/');

   493         if(s != -1)

   494             dir = dir.right(dir.length() - (s + 1));

   495         file.setFileName(outdir + dir + Option::pro_ext);

   496     }

   497     return MakefileGenerator::openOutput(file, build);

   498 }

   499 

   500 

   501 QString

   502 ProjectGenerator::fixPathToQmake(const QString &file)

   503 {

   504     QString ret = file;

   505     if(Option::dir_sep != QLatin1String("/"))

   506         ret = ret.replace(Option::dir_sep, QLatin1String("/"));

   507     return ret;

   508 }

   509 

   510 QT_END_NAMESPACE