bool QMakeProperty::exec() { bool ret = true; if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY) { if(Option::prop::properties.isEmpty()) { initSettings(); foreach (const QString &key, settings->childKeys()) { QString val = settings->value(key).toString(); fprintf(stdout, "%s:%s\n", qPrintable(key), qPrintable(val)); } QStringList specialProps; for (int i = 0; i < sizeof(propList)/sizeof(propList[0]); i++) specialProps.append(QString::fromLatin1(propList[i].name)); specialProps.append("QMAKE_VERSION"); #ifdef QT_VERSION_STR specialProps.append("QT_VERSION"); #endif foreach (QString prop, specialProps) { ProString val = value(ProKey(prop)); ProString pval = value(ProKey(prop + "/raw")); ProString gval = value(ProKey(prop + "/get")); fprintf(stdout, "%s:%s\n", prop.toLatin1().constData(), val.toLatin1().constData()); if (!pval.isEmpty() && pval != val) fprintf(stdout, "%s/raw:%s\n", prop.toLatin1().constData(), pval.toLatin1().constData()); if (!gval.isEmpty() && gval != (pval.isEmpty() ? val : pval)) fprintf(stdout, "%s/get:%s\n", prop.toLatin1().constData(), gval.toLatin1().constData()); } return true; }
MakefileGenerator *BuildsMetaMakefileGenerator::processBuild(const ProString &build) { if(project) { debug_msg(1, "Meta Generator: Parsing '%s' for build [%s].", project->projectFile().toLatin1().constData(),build.toLatin1().constData()); //initialize the base ProValueMap basevars; ProStringList basecfgs = project->values(ProKey(build + ".CONFIG")); basecfgs += build; basecfgs += "build_pass"; basevars["BUILD_PASS"] = ProStringList(build); ProStringList buildname = project->values(ProKey(build + ".name")); basevars["BUILD_NAME"] = (buildname.isEmpty() ? ProStringList(build) : buildname); //create project QMakeProject *build_proj = new QMakeProject; build_proj->setExtraVars(basevars); build_proj->setExtraConfigs(basecfgs); build_proj->read(project->projectFile()); //done return createMakefileGenerator(build_proj); } return 0; }
QStringList &UnixMakefileGenerator::findDependencies(const QString &f) { QStringList &ret = MakefileGenerator::findDependencies(f); if (doPrecompiledHeaders() && !project->isEmpty("PRECOMPILED_HEADER")) { ProString file = f; QString header_prefix; if(!project->isEmpty("PRECOMPILED_DIR")) header_prefix = project->first("PRECOMPILED_DIR").toQString(); header_prefix += project->first("QMAKE_ORIG_TARGET").toQString(); if (!project->isActiveConfig("clang_pch_style")) header_prefix += project->first("QMAKE_PCH_OUTPUT_EXT").toQString(); if (project->isActiveConfig("icc_pch_style")) { // icc style for(QStringList::Iterator it = Option::cpp_ext.begin(); it != Option::cpp_ext.end(); ++it) { if(file.endsWith(*it)) { ret += header_prefix; break; } } } else { // gcc style (including clang_pch_style) QString header_suffix = project->isActiveConfig("clang_pch_style") ? project->first("QMAKE_PCH_OUTPUT_EXT").toQString() : ""; header_prefix += Option::dir_sep + project->first("QMAKE_PRECOMP_PREFIX"); foreach (const ProString &compiler, project->values("QMAKE_BUILTIN_COMPILERS")) { if (project->isEmpty(ProKey("QMAKE_" + compiler + "FLAGS_PRECOMPILE"))) continue; ProString language = project->first(ProKey("QMAKE_LANGUAGE_" + compiler)); if (language.isEmpty()) continue; // Unfortunately we were not consistent about the C++ naming ProString extensionSuffix = compiler; if (extensionSuffix == "CXX") extensionSuffix = ProString("CPP"); foreach (const ProString &extension, project->values(ProKey("QMAKE_EXT_" + extensionSuffix))) { if (!file.endsWith(extension.toQString())) continue; QString precompiledHeader = header_prefix + language + header_suffix; if (!ret.contains(precompiledHeader)) ret += precompiledHeader; goto foundPrecompiledDependency; } } foundPrecompiledDependency: ; // Hurray!! } }
QMakeProperty::QMakeProperty() : settings(0) { for (int i = 0; i < sizeof(propList)/sizeof(propList[0]); i++) { QString name = QString::fromLatin1(propList[i].name); m_values[ProKey(name + "/get")] = QLibraryInfo::rawLocation(propList[i].loc, QLibraryInfo::EffectivePaths); QString val = QLibraryInfo::rawLocation(propList[i].loc, QLibraryInfo::FinalPaths); if (!propList[i].raw) { m_values[ProKey(name)] = QLibraryInfo::location(propList[i].loc); name += "/raw"; } m_values[ProKey(name)] = val; } m_values["QMAKE_VERSION"] = ProString(QMAKE_VERSION_STR); #ifdef QT_VERSION_STR m_values["QT_VERSION"] = ProString(QT_VERSION_STR); #endif }
int Win32MakefileGenerator::findHighestVersion(const QString &d, const QString &stem, const QString &ext) { QString bd = Option::fixPathToLocalOS(d, true); if(!exists(bd)) return -1; QMakeMetaInfo libinfo(project); bool libInfoRead = libinfo.readLib(bd + Option::dir_sep + stem); // If the library, for which we're trying to find the highest version // number, is a static library if (libInfoRead && libinfo.values("QMAKE_PRL_CONFIG").contains("staticlib")) return -1; const ProStringList &vover = project->values(ProKey("QMAKE_" + stem.toUpper() + "_VERSION_OVERRIDE")); if (!vover.isEmpty()) return vover.first().toInt(); int biggest=-1; if (project->isActiveConfig("link_highest_lib_version")) { static QHash<QString, QStringList> dirEntryListCache; QStringList entries = dirEntryListCache.value(bd); if (entries.isEmpty()) { QDir dir(bd); entries = dir.entryList(); dirEntryListCache.insert(bd, entries); } QRegExp regx(QString("((lib)?%1([0-9]*)).(%2|prl)$").arg(stem).arg(ext), Qt::CaseInsensitive); for(QStringList::Iterator it = entries.begin(); it != entries.end(); ++it) { if(regx.exactMatch((*it))) { if (!regx.cap(3).isEmpty()) { bool ok = true; int num = regx.cap(3).toInt(&ok); biggest = qMax(biggest, (!ok ? -1 : num)); } } } } if(libInfoRead && !libinfo.values("QMAKE_PRL_CONFIG").contains("staticlib") && !libinfo.isEmpty("QMAKE_PRL_VERSION")) biggest = qMax(biggest, libinfo.first("QMAKE_PRL_VERSION").toQString().replace(".", "").toInt()); return biggest; }
bool MingwMakefileGenerator::findLibraries() { QList<QMakeLocalFileName> dirs; static const char * const lflags[] = { "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", 0 }; for (int i = 0; lflags[i]; i++) { ProStringList &l = project->values(lflags[i]); ProStringList::Iterator it = l.begin(); while (it != l.end()) { if ((*it).startsWith("-l")) { QString steam = (*it).mid(2).toQString(); ProString out; QString suffix = project->first(ProKey("QMAKE_" + steam.toUpper() + "_SUFFIX")).toQString(); for (QList<QMakeLocalFileName>::Iterator dir_it = dirs.begin(); dir_it != dirs.end(); ++dir_it) { QString extension; int ver = findHighestVersion((*dir_it).local(), steam, "dll.a|a"); if (ver > 0) extension += QString::number(ver); extension += suffix; if(QMakeMetaInfo::libExists((*dir_it).local() + Option::dir_sep + steam) || exists((*dir_it).local() + Option::dir_sep + steam + extension + ".a") || exists((*dir_it).local() + Option::dir_sep + steam + extension + ".dll.a")) { out = *it + extension; break; } } if (!out.isEmpty()) // We assume if it never finds it that its correct (*it) = out; } else if((*it).startsWith("-L")) { dirs.append(QMakeLocalFileName((*it).mid(2).toQString())); } ++it; } } return true; }
bool Win32MakefileGenerator::findLibraries() { QList<QMakeLocalFileName> dirs; static const char * const lflags[] = { "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", 0 }; for (int i = 0; lflags[i]; i++) { ProStringList &l = project->values(lflags[i]); for (ProStringList::Iterator it = l.begin(); it != l.end();) { QChar quote; bool modified_opt = false, remove = false; QString opt = (*it).trimmed().toQString(); if((opt[0] == '\'' || opt[0] == '"') && opt[(int)opt.length()-1] == opt[0]) { quote = opt[0]; opt = opt.mid(1, opt.length()-2); } if(opt.startsWith("/LIBPATH:")) { dirs.append(QMakeLocalFileName(opt.mid(9))); } else if(opt.startsWith("-L") || opt.startsWith("/L")) { QString libpath = Option::fixPathToTargetOS(opt.mid(2), false, false); QMakeLocalFileName l(libpath); if(!dirs.contains(l)) { dirs.append(l); modified_opt = true; if (!quote.isNull()) { libpath = quote + libpath + quote; quote = QChar(); } (*it) = "/LIBPATH:" + libpath; } else { remove = true; } } else if(opt.startsWith("-l") || opt.startsWith("/l")) { QString lib = opt.right(opt.length() - 2), out; if(!lib.isEmpty()) { ProString suffix = project->first(ProKey("QMAKE_" + lib.toUpper() + "_SUFFIX")); for(QList<QMakeLocalFileName>::Iterator it = dirs.begin(); it != dirs.end(); ++it) { QString extension; int ver = findHighestVersion((*it).local(), lib); if(ver > 0) extension += QString::number(ver); extension += suffix; extension += ".lib"; if(QMakeMetaInfo::libExists((*it).local() + Option::dir_sep + lib) || exists((*it).local() + Option::dir_sep + lib + extension)) { out = (*it).real() + Option::dir_sep + lib + extension; if (out.contains(QLatin1Char(' '))) { out.prepend(QLatin1Char('\"')); out.append(QLatin1Char('\"')); } break; } } } if(out.isEmpty()) out = lib + ".lib"; modified_opt = true; (*it) = out; } else if(!exists(Option::fixPathToLocalOS(opt))) { QList<QMakeLocalFileName> lib_dirs; QString file = opt; int slsh = file.lastIndexOf(Option::dir_sep); if(slsh != -1) { lib_dirs.append(QMakeLocalFileName(file.left(slsh+1))); file = file.right(file.length() - slsh - 1); } else { lib_dirs = dirs; } if(file.endsWith(".lib")) { file = file.left(file.length() - 4); if(!file.at(file.length()-1).isNumber()) { ProString suffix = project->first(ProKey("QMAKE_" + file.section(Option::dir_sep, -1).toUpper() + "_SUFFIX")); for(QList<QMakeLocalFileName>::Iterator dep_it = lib_dirs.begin(); dep_it != lib_dirs.end(); ++dep_it) { QString lib_tmpl(file + "%1" + suffix + ".lib"); int ver = findHighestVersion((*dep_it).local(), file); if(ver != -1) { if(ver) lib_tmpl = lib_tmpl.arg(ver); else lib_tmpl = lib_tmpl.arg(""); if(slsh != -1) { QString dir = (*dep_it).real(); if(!dir.endsWith(Option::dir_sep)) dir += Option::dir_sep; lib_tmpl.prepend(dir); } modified_opt = true; (*it) = lib_tmpl; break; } } } } } if(remove) { it = l.erase(it); } else { if(!quote.isNull() && modified_opt) (*it) = quote + (*it) + quote; ++it; } } } return true; }
void ProjectGenerator::init() { if(init_flag) return; int file_count = 0; init_flag = true; verifyCompilers(); project->loadSpec(); project->evaluateFeatureFile("default_pre.prf"); project->evaluateFeatureFile("default_post.prf"); project->evaluateConfigFeatures(); project->values("CONFIG").clear(); Option::postProcessProject(project); ProValueMap &v = project->variables(); QString templ = Option::globals->user_template.isEmpty() ? QString("app") : Option::globals->user_template; if (!Option::globals->user_template_prefix.isEmpty()) templ.prepend(Option::globals->user_template_prefix); v["TEMPLATE_ASSIGN"] += templ; //the scary stuff if(project->first("TEMPLATE_ASSIGN") != "subdirs") { QString builtin_regex = project_builtin_regx(); QStringList dirs = Option::projfile::project_dirs; if(Option::projfile::do_pwd) { if(!v["INCLUDEPATH"].contains(".")) v["INCLUDEPATH"] += "."; dirs.prepend(qmake_getpwd()); } for(int i = 0; i < dirs.count(); ++i) { QString dir, regex, pd = dirs.at(i); bool add_depend = false; if(exists(pd)) { QFileInfo fi(fileInfo(pd)); if(fi.isDir()) { dir = pd; add_depend = true; if(dir.right(1) != Option::dir_sep) dir += Option::dir_sep; if (Option::recursive) { QStringList files = QDir(dir).entryList(QDir::Files); for (int i = 0; i < files.count(); i++) dirs.append(dir + files[i] + QDir::separator() + builtin_regex); } regex = builtin_regex; } else { QString file = pd; int s = file.lastIndexOf(Option::dir_sep); if(s != -1) dir = file.left(s+1); if(addFile(file)) { add_depend = true; file_count++; } } } else { //regexp regex = pd; } if(!regex.isEmpty()) { int s = regex.lastIndexOf(Option::dir_sep); if(s != -1) { dir = regex.left(s+1); regex = regex.right(regex.length() - (s+1)); } if (Option::recursive) { QStringList entries = QDir(dir).entryList(QDir::Dirs | QDir::NoDotAndDotDot); for (int i = 0; i < entries.count(); i++) dirs.append(dir + entries[i] + QDir::separator() + regex); } QStringList files = QDir(dir).entryList(QDir::nameFiltersFromString(regex)); for(int i = 0; i < (int)files.count(); i++) { QString file = dir + files[i]; if (addFile(file)) { add_depend = true; file_count++; } } } if(add_depend && !dir.isEmpty() && !v["DEPENDPATH"].contains(dir, Qt::CaseInsensitive)) { QFileInfo fi(fileInfo(dir)); if(fi.absoluteFilePath() != qmake_getpwd()) v["DEPENDPATH"] += fileFixify(dir); } } } if(!file_count) { //shall we try a subdir? QStringList knownDirs = Option::projfile::project_dirs; if(Option::projfile::do_pwd) knownDirs.prepend("."); const QString out_file = fileFixify(Option::output.fileName()); for(int i = 0; i < knownDirs.count(); ++i) { QString pd = knownDirs.at(i); if(exists(pd)) { QString newdir = pd; QFileInfo fi(fileInfo(newdir)); if(fi.isDir()) { newdir = fileFixify(newdir); ProStringList &subdirs = v["SUBDIRS"]; if(exists(fi.filePath() + QDir::separator() + fi.fileName() + Option::pro_ext) && !subdirs.contains(newdir, Qt::CaseInsensitive)) { subdirs.append(newdir); } else { QStringList profiles = QDir(newdir).entryList(QStringList("*" + Option::pro_ext), QDir::Files); for(int i = 0; i < (int)profiles.count(); i++) { QString nd = newdir; if(nd == ".") nd = ""; else if(!nd.isEmpty() && !nd.endsWith(QString(QChar(QDir::separator())))) nd += QDir::separator(); nd += profiles[i]; fileFixify(nd); if (!subdirs.contains(nd, Qt::CaseInsensitive) && !out_file.endsWith(nd)) subdirs.append(nd); } } if (Option::recursive) { QStringList dirs = QDir(newdir).entryList(QDir::Dirs | QDir::NoDotAndDotDot); for(int i = 0; i < (int)dirs.count(); i++) { QString nd = fileFixify(newdir + QDir::separator() + dirs[i]); if (!knownDirs.contains(nd, Qt::CaseInsensitive)) knownDirs.append(nd); } } } } else { //regexp QString regx = pd, dir; int s = regx.lastIndexOf(Option::dir_sep); if(s != -1) { dir = regx.left(s+1); regx = regx.right(regx.length() - (s+1)); } QStringList files = QDir(dir).entryList(QDir::nameFiltersFromString(regx), QDir::Dirs | QDir::NoDotAndDotDot); ProStringList &subdirs = v["SUBDIRS"]; for(int i = 0; i < (int)files.count(); i++) { QString newdir(dir + files[i]); QFileInfo fi(fileInfo(newdir)); { newdir = fileFixify(newdir); if(exists(fi.filePath() + QDir::separator() + fi.fileName() + Option::pro_ext) && !subdirs.contains(newdir)) { subdirs.append(newdir); } else { QStringList profiles = QDir(newdir).entryList(QStringList("*" + Option::pro_ext), QDir::Files); for(int i = 0; i < (int)profiles.count(); i++) { QString nd = newdir + QDir::separator() + files[i]; fileFixify(nd); if(files[i] != "." && files[i] != ".." && !subdirs.contains(nd, Qt::CaseInsensitive)) { if(newdir + files[i] != Option::output_dir + Option::output.fileName()) subdirs.append(nd); } } } if (Option::recursive && !knownDirs.contains(newdir, Qt::CaseInsensitive)) knownDirs.append(newdir); } } } } v["TEMPLATE_ASSIGN"] = ProStringList("subdirs"); return; } //setup deplist QList<QMakeLocalFileName> deplist; { const ProStringList &d = v["DEPENDPATH"]; for(int i = 0; i < d.size(); ++i) deplist.append(QMakeLocalFileName(d[i].toQString())); } setDependencyPaths(deplist); ProStringList &h = v["HEADERS"]; bool no_qt_files = true; static const char *srcs[] = { "SOURCES", "YACCSOURCES", "LEXSOURCES", "FORMS", 0 }; for (int i = 0; srcs[i]; i++) { const ProStringList &l = v[srcs[i]]; QMakeSourceFileInfo::SourceFileType type = QMakeSourceFileInfo::TYPE_C; QMakeSourceFileInfo::addSourceFiles(l, QMakeSourceFileInfo::SEEK_DEPS, type); for(int i = 0; i < l.size(); ++i) { QStringList tmp = QMakeSourceFileInfo::dependencies(l.at(i).toQString()); if(!tmp.isEmpty()) { for(int dep_it = 0; dep_it < tmp.size(); ++dep_it) { QString dep = tmp[dep_it]; dep = fixPathToQmake(dep); QString file_dir = dep.section(Option::dir_sep, 0, -2), file_no_path = dep.section(Option::dir_sep, -1); if(!file_dir.isEmpty()) { for(int inc_it = 0; inc_it < deplist.size(); ++inc_it) { QMakeLocalFileName inc = deplist[inc_it]; if(inc.local() == file_dir && !v["INCLUDEPATH"].contains(inc.real(), Qt::CaseInsensitive)) v["INCLUDEPATH"] += inc.real(); } } if(no_qt_files && file_no_path.indexOf(QRegExp("^q[a-z_0-9].h$")) != -1) no_qt_files = false; QString h_ext; for(int hit = 0; hit < Option::h_ext.size(); ++hit) { if(dep.endsWith(Option::h_ext.at(hit))) { h_ext = Option::h_ext.at(hit); break; } } if(!h_ext.isEmpty()) { for(int cppit = 0; cppit < Option::cpp_ext.size(); ++cppit) { QString src(dep.left(dep.length() - h_ext.length()) + Option::cpp_ext.at(cppit)); if(exists(src)) { ProStringList &srcl = v["SOURCES"]; if(!srcl.contains(src, Qt::CaseInsensitive)) srcl.append(src); } } } else if(dep.endsWith(Option::lex_ext) && file_no_path.startsWith(Option::lex_mod)) { addConfig("lex_included"); } if(!h.contains(dep, Qt::CaseInsensitive)) h += dep; } } } } //strip out files that are actually output from internal compilers (ie temporary files) const ProStringList &quc = project->values("QMAKE_EXTRA_COMPILERS"); for (ProStringList::ConstIterator it = quc.begin(); it != quc.end(); ++it) { QString tmp_out = project->first(ProKey(*it + ".output")).toQString(); if(tmp_out.isEmpty()) continue; ProStringList var_out = project->values(ProKey(*it + ".variable_out")); bool defaults = var_out.isEmpty(); for(int i = 0; i < var_out.size(); ++i) { ProString v = var_out.at(i); if(v.startsWith("GENERATED_")) { defaults = true; break; } } if(defaults) { var_out << "SOURCES"; var_out << "HEADERS"; var_out << "FORMS"; } const ProStringList &tmp = project->values(ProKey(*it + ".input")); for (ProStringList::ConstIterator it2 = tmp.begin(); it2 != tmp.end(); ++it2) { ProStringList &inputs = project->values((*it2).toKey()); for (ProStringList::Iterator input = inputs.begin(); input != inputs.end(); ++input) { QString path = replaceExtraCompilerVariables(tmp_out, (*input).toQString(), QString()); path = fixPathToQmake(path).section('/', -1); for(int i = 0; i < var_out.size(); ++i) { ProString v = var_out.at(i); ProStringList &list = project->values(v.toKey()); for(int src = 0; src < list.size(); ) { if(list[src] == path || list[src].endsWith("/" + path)) list.removeAt(src); else ++src; } } } } } }
QT_BEGIN_NAMESPACE void UnixMakefileGenerator::init() { ProStringList &configs = project->values("CONFIG"); if(project->isEmpty("ICON") && !project->isEmpty("RC_FILE")) project->values("ICON") = project->values("RC_FILE"); if(project->isEmpty("QMAKE_EXTENSION_PLUGIN")) project->values("QMAKE_EXTENSION_PLUGIN").append(project->first("QMAKE_EXTENSION_SHLIB")); project->values("QMAKE_ORIG_TARGET") = project->values("TARGET"); //version handling if (project->isEmpty("VERSION")) { project->values("VERSION").append( "1.0." + (project->isEmpty("VER_PAT") ? QString("0") : project->first("VER_PAT"))); } QStringList l = project->first("VERSION").toQString().split('.'); l << "0" << "0"; //make sure there are three project->values("VER_MAJ").append(l[0]); project->values("VER_MIN").append(l[1]); project->values("VER_PAT").append(l[2]); QString sroot = project->sourceRoot(); foreach (const ProString &iif, project->values("QMAKE_INTERNAL_INCLUDED_FILES")) { if (iif == project->cacheFile()) continue; if (iif.startsWith(sroot) && iif.at(sroot.length()) == QLatin1Char('/')) project->values("DISTFILES") += fileFixify(iif.toQString(), FileFixifyRelative); } /* this should probably not be here, but I'm using it to wrap the .t files */ if(project->first("TEMPLATE") == "app") project->values("QMAKE_APP_FLAG").append("1"); else if(project->first("TEMPLATE") == "lib") project->values("QMAKE_LIB_FLAG").append("1"); else if(project->first("TEMPLATE") == "subdirs") { MakefileGenerator::init(); if(project->isEmpty("MAKEFILE")) project->values("MAKEFILE").append("Makefile"); return; /* subdirs is done */ } project->values("QMAKE_ORIG_DESTDIR") = project->values("DESTDIR"); project->values("QMAKE_LIBS") += project->values("LIBS"); project->values("QMAKE_LIBS_PRIVATE") += project->values("LIBS_PRIVATE"); if((!project->isEmpty("QMAKE_LIB_FLAG") && !project->isActiveConfig("staticlib")) || (project->isActiveConfig("qt") && project->isActiveConfig("plugin"))) { if(configs.indexOf("dll") == -1) configs.append("dll"); } else if(!project->isEmpty("QMAKE_APP_FLAG") || project->isActiveConfig("dll")) { configs.removeAll("staticlib"); } if(!project->isEmpty("QMAKE_INCREMENTAL")) project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_INCREMENTAL"); else if(!project->isEmpty("QMAKE_LFLAGS_PREBIND") && !project->values("QMAKE_LIB_FLAG").isEmpty() && project->isActiveConfig("dll")) project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_PREBIND"); if(!project->isEmpty("QMAKE_INCDIR")) project->values("INCLUDEPATH") += project->values("QMAKE_INCDIR"); ProStringList ldadd; if(!project->isEmpty("QMAKE_LIBDIR")) { const ProStringList &libdirs = project->values("QMAKE_LIBDIR"); for(int i = 0; i < libdirs.size(); ++i) { if(!project->isEmpty("QMAKE_LFLAGS_RPATH") && project->isActiveConfig("rpath_libdirs")) project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + libdirs[i]; project->values("QMAKE_LIBDIR_FLAGS") += "-L" + escapeFilePath(libdirs[i]); } } ldadd += project->values("QMAKE_LIBDIR_FLAGS"); if (project->isActiveConfig("mac")) { if (!project->isEmpty("QMAKE_FRAMEWORKPATH")) { const ProStringList &fwdirs = project->values("QMAKE_FRAMEWORKPATH"); for (int i = 0; i < fwdirs.size(); ++i) project->values("QMAKE_FRAMEWORKPATH_FLAGS") += "-F" + escapeFilePath(fwdirs[i]); } ldadd += project->values("QMAKE_FRAMEWORKPATH_FLAGS"); } ProStringList &qmklibs = project->values("QMAKE_LIBS"); qmklibs = ldadd + qmklibs; if (!project->isEmpty("QMAKE_RPATHDIR") && !project->isEmpty("QMAKE_LFLAGS_RPATH")) { const ProStringList &rpathdirs = project->values("QMAKE_RPATHDIR"); for (int i = 0; i < rpathdirs.size(); ++i) { QString rpathdir = rpathdirs[i].toQString(); if (rpathdir.length() > 1 && rpathdir.at(0) == '$' && rpathdir.at(1) != '(') { rpathdir.replace(0, 1, "\\$$"); // Escape from make and the shell } else if (!rpathdir.startsWith('@') && fileInfo(rpathdir).isRelative()) { QString rpathbase = project->first("QMAKE_REL_RPATH_BASE").toQString(); if (rpathbase.isEmpty()) { fprintf(stderr, "Error: This platform does not support relative paths in QMAKE_RPATHDIR (%s)\n", rpathdir.toLatin1().constData()); continue; } if (rpathbase.startsWith('$')) rpathbase.replace(0, 1, "\\$$"); // Escape from make and the shell if (rpathdir == ".") rpathdir = rpathbase; else rpathdir.prepend(rpathbase + '/'); project->values("QMAKE_LFLAGS").insertUnique(project->values("QMAKE_LFLAGS_REL_RPATH")); } project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + escapeFilePath(rpathdir); } } if (!project->isEmpty("QMAKE_RPATHLINKDIR")) { const ProStringList &rpathdirs = project->values("QMAKE_RPATHLINKDIR"); for (int i = 0; i < rpathdirs.size(); ++i) { if (!project->isEmpty("QMAKE_LFLAGS_RPATHLINK")) project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATHLINK") + escapeFilePath(QFileInfo(rpathdirs[i].toQString()).absoluteFilePath()); } } if(project->isActiveConfig("GNUmake") && !project->isEmpty("QMAKE_CFLAGS_DEPS")) include_deps = true; //do not generate deps MakefileGenerator::init(); if (project->isActiveConfig("objective_c")) project->values("QMAKE_BUILTIN_COMPILERS") << "OBJC" << "OBJCXX"; foreach (const ProString &compiler, project->values("QMAKE_BUILTIN_COMPILERS")) { QString compile_flag = var("QMAKE_COMPILE_FLAG"); if(compile_flag.isEmpty()) compile_flag = "-c"; if(doPrecompiledHeaders() && !project->isEmpty("PRECOMPILED_HEADER")) { QString pchFlags = var(ProKey("QMAKE_" + compiler + "FLAGS_USE_PRECOMPILE")); QString pchBaseName; if(!project->isEmpty("PRECOMPILED_DIR")) { pchBaseName = Option::fixPathToTargetOS(project->first("PRECOMPILED_DIR").toQString()); if(!pchBaseName.endsWith(Option::dir_sep)) pchBaseName += Option::dir_sep; } pchBaseName += project->first("QMAKE_ORIG_TARGET").toQString(); // replace place holders pchFlags.replace(QLatin1String("${QMAKE_PCH_INPUT}"), escapeFilePath(project->first("PRECOMPILED_HEADER").toQString())); pchFlags.replace(QLatin1String("${QMAKE_PCH_OUTPUT_BASE}"), escapeFilePath(pchBaseName)); if (project->isActiveConfig("icc_pch_style")) { // icc style pchFlags.replace(QLatin1String("${QMAKE_PCH_OUTPUT}"), escapeFilePath(pchBaseName + project->first("QMAKE_PCH_OUTPUT_EXT"))); } else { // gcc style (including clang_pch_style) QString headerSuffix; if (project->isActiveConfig("clang_pch_style")) headerSuffix = project->first("QMAKE_PCH_OUTPUT_EXT").toQString(); else pchBaseName += project->first("QMAKE_PCH_OUTPUT_EXT").toQString(); pchBaseName += Option::dir_sep; ProString language = project->first(ProKey("QMAKE_LANGUAGE_" + compiler)); if (!language.isEmpty()) { pchFlags.replace(QLatin1String("${QMAKE_PCH_OUTPUT}"), escapeFilePath(pchBaseName + language + headerSuffix)); } } if (!pchFlags.isEmpty()) compile_flag += " " + pchFlags; } QString compilerExecutable; if (compiler == "C" || compiler == "OBJC") { compilerExecutable = "$(CC)"; compile_flag += " $(CFLAGS)"; } else { compilerExecutable = "$(CXX)"; compile_flag += " $(CXXFLAGS)"; } compile_flag += " $(INCPATH)"; ProString compilerVariable = compiler; if (compilerVariable == "C") compilerVariable = ProString("CC"); const ProKey runComp("QMAKE_RUN_" + compilerVariable); if(project->isEmpty(runComp)) project->values(runComp).append(compilerExecutable + " " + compile_flag + " " + var("QMAKE_CC_O_FLAG") + "$obj $src"); const ProKey runCompImp("QMAKE_RUN_" + compilerVariable + "_IMP"); if(project->isEmpty(runCompImp)) project->values(runCompImp).append(compilerExecutable + " " + compile_flag + " " + var("QMAKE_CC_O_FLAG") + "\"$@\" \"$<\""); } if (project->isActiveConfig("mac") && !project->isEmpty("TARGET") && ((project->isActiveConfig("build_pass") || project->isEmpty("BUILDS")))) { ProString bundle; if(project->isActiveConfig("bundle") && !project->isEmpty("QMAKE_BUNDLE_EXTENSION")) { bundle = project->first("TARGET"); if(!project->isEmpty("QMAKE_BUNDLE_NAME")) bundle = project->first("QMAKE_BUNDLE_NAME"); if(!bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); } else if(project->first("TEMPLATE") == "app" && project->isActiveConfig("app_bundle")) { bundle = project->first("TARGET"); if(!project->isEmpty("QMAKE_APPLICATION_BUNDLE_NAME")) bundle = project->first("QMAKE_APPLICATION_BUNDLE_NAME"); if(!bundle.endsWith(".app")) bundle += ".app"; if(project->isEmpty("QMAKE_BUNDLE_LOCATION")) project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS"); project->values("QMAKE_PKGINFO").append(project->first("DESTDIR") + bundle + "/Contents/PkgInfo"); project->values("QMAKE_BUNDLE_RESOURCE_FILE").append(project->first("DESTDIR") + bundle + "/Contents/Resources/empty.lproj"); } else if(project->first("TEMPLATE") == "lib" && !project->isActiveConfig("staticlib") && ((!project->isActiveConfig("plugin") && project->isActiveConfig("lib_bundle")) || (project->isActiveConfig("plugin") && project->isActiveConfig("plugin_bundle")))) { bundle = project->first("TARGET"); if(project->isActiveConfig("plugin")) { if(!project->isEmpty("QMAKE_PLUGIN_BUNDLE_NAME")) bundle = project->first("QMAKE_PLUGIN_BUNDLE_NAME"); if (project->isEmpty("QMAKE_BUNDLE_EXTENSION")) project->values("QMAKE_BUNDLE_EXTENSION").append(".plugin"); if (!bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); if(project->isEmpty("QMAKE_BUNDLE_LOCATION")) project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS"); } else { if(!project->isEmpty("QMAKE_FRAMEWORK_BUNDLE_NAME")) bundle = project->first("QMAKE_FRAMEWORK_BUNDLE_NAME"); if (project->isEmpty("QMAKE_BUNDLE_EXTENSION")) project->values("QMAKE_BUNDLE_EXTENSION").append(".framework"); if (!bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); } } if(!bundle.isEmpty()) { project->values("QMAKE_BUNDLE") = ProStringList(bundle); } else { project->values("QMAKE_BUNDLE").clear(); project->values("QMAKE_BUNDLE_LOCATION").clear(); } } else { //no bundling here project->values("QMAKE_BUNDLE").clear(); project->values("QMAKE_BUNDLE_LOCATION").clear(); } init2(); project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_LIBS"; ProString target = project->first("TARGET"); int slsh = target.lastIndexOf(Option::dir_sep); if (slsh != -1) target.chopFront(slsh + 1); project->values("LIB_TARGET").prepend(target); if(!project->isEmpty("QMAKE_MAX_FILES_PER_AR")) { bool ok; int max_files = project->first("QMAKE_MAX_FILES_PER_AR").toInt(&ok); ProStringList ar_sublibs, objs = project->values("OBJECTS"); if(ok && max_files > 5 && max_files < (int)objs.count()) { QString lib; for(int i = 0, obj_cnt = 0, lib_cnt = 0; i != objs.size(); ++i) { if((++obj_cnt) >= max_files) { if(lib_cnt) { lib.sprintf("lib%s-tmp%d.a", project->first("QMAKE_ORIG_TARGET").toLatin1().constData(), lib_cnt); ar_sublibs << lib; obj_cnt = 0; } lib_cnt++; } } } if(!ar_sublibs.isEmpty()) { project->values("QMAKE_AR_SUBLIBS") = ar_sublibs; project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_AR_SUBLIBS"; } } }
void UnixMakefileGenerator::processPrlFiles() { const QString libArg = project->first("QMAKE_L_FLAG").toQString(); QList<QMakeLocalFileName> libdirs, frameworkdirs; int libidx = 0, fwidx = 0; foreach (const ProString &dlib, project->values("QMAKE_DEFAULT_LIBDIRS")) libdirs.append(QMakeLocalFileName(dlib.toQString())); frameworkdirs.append(QMakeLocalFileName("/System/Library/Frameworks")); frameworkdirs.append(QMakeLocalFileName("/Library/Frameworks")); static const char * const lflags[] = { "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", 0 }; for (int i = 0; lflags[i]; i++) { ProStringList &l = project->values(lflags[i]); for(int lit = 0; lit < l.size(); ++lit) { QString opt = l.at(lit).trimmed().toQString(); if(opt.startsWith("-")) { if (opt.startsWith(libArg)) { QMakeLocalFileName l(opt.mid(libArg.length())); if(!libdirs.contains(l)) libdirs.insert(libidx++, l); } else if(opt.startsWith("-l")) { QString lib = opt.right(opt.length() - 2); QString prl_ext = project->first(ProKey("QMAKE_" + lib.toUpper() + "_SUFFIX")).toQString(); for(int dep_i = 0; dep_i < libdirs.size(); ++dep_i) { const QMakeLocalFileName &lfn = libdirs[dep_i]; if(!project->isActiveConfig("compile_libtool")) { //give them the .libs.. QString la = lfn.local() + Option::dir_sep + project->values("QMAKE_PREFIX_SHLIB").first() + lib + Option::libtool_ext; if(exists(la) && QFile::exists(lfn.local() + Option::dir_sep + ".libs")) { QString dot_libs = lfn.real() + Option::dir_sep + ".libs"; l.append("-L" + dot_libs); libdirs.insert(libidx++, QMakeLocalFileName(dot_libs)); } } QString prl = lfn.local() + Option::dir_sep + project->values("QMAKE_PREFIX_SHLIB").first() + lib + prl_ext; if(processPrlFile(prl)) { if(prl.startsWith(lfn.local())) prl.replace(0, lfn.local().length(), lfn.real()); opt = linkLib(prl, lib); break; } } } else if (target_mode == TARG_MAC_MODE && opt.startsWith("-F")) { QMakeLocalFileName f(opt.right(opt.length()-2)); if(!frameworkdirs.contains(f)) frameworkdirs.insert(fwidx++, f); } else if (target_mode == TARG_MAC_MODE && opt.startsWith("-framework")) { if(opt.length() > 11) opt = opt.mid(11); else opt = l.at(++lit).toQString(); opt = opt.trimmed(); foreach (const QMakeLocalFileName &dir, frameworkdirs) { QString prl = dir.local() + "/" + opt + ".framework/" + opt + Option::prl_ext; if(processPrlFile(prl)) break; } } } else if(!opt.isNull()) { QString lib = opt; processPrlFile(lib); #if 0 if(ret) opt = linkLib(lib, ""); #endif if(!opt.isEmpty()) for (int k = 0; k < l.size(); ++k) l[k] = l.at(k).toQString().replace(lib, opt); } ProStringList &prl_libs = project->values("QMAKE_CURRENT_PRL_LIBS"); if(!prl_libs.isEmpty()) { for(int prl = 0; prl < prl_libs.size(); ++prl) l.insert(lit+prl+1, escapeFilePath(prl_libs.at(prl).toQString())); prl_libs.clear(); } }
QT_BEGIN_NAMESPACE void UnixMakefileGenerator::init() { if(init_flag) return; init_flag = true; if(project->isEmpty("QMAKE_EXTENSION_SHLIB")) { if(project->isEmpty("QMAKE_CYGWIN_SHLIB")) { project->values("QMAKE_EXTENSION_SHLIB").append("so"); } else { project->values("QMAKE_EXTENSION_SHLIB").append("dll"); } } if (project->isEmpty("QMAKE_PREFIX_SHLIB")) // Prevent crash when using the empty variable. project->values("QMAKE_PREFIX_SHLIB").append(""); if(!project->isEmpty("QMAKE_FAILED_REQUIREMENTS")) /* no point */ return; ProStringList &configs = project->values("CONFIG"); if(project->isEmpty("ICON") && !project->isEmpty("RC_FILE")) project->values("ICON") = project->values("RC_FILE"); if(project->isEmpty("QMAKE_EXTENSION_PLUGIN")) project->values("QMAKE_EXTENSION_PLUGIN").append(project->first("QMAKE_EXTENSION_SHLIB")); if(project->isEmpty("QMAKE_COPY_FILE")) project->values("QMAKE_COPY_FILE").append("$(COPY)"); if(project->isEmpty("QMAKE_STREAM_EDITOR")) project->values("QMAKE_STREAM_EDITOR").append("sed"); if(project->isEmpty("QMAKE_COPY_DIR")) project->values("QMAKE_COPY_DIR").append("$(COPY) -R"); if(project->isEmpty("QMAKE_INSTALL_FILE")) project->values("QMAKE_INSTALL_FILE").append("$(COPY_FILE)"); if(project->isEmpty("QMAKE_INSTALL_DIR")) project->values("QMAKE_INSTALL_DIR").append("$(COPY_DIR)"); if(project->isEmpty("QMAKE_INSTALL_PROGRAM")) project->values("QMAKE_INSTALL_PROGRAM").append("$(COPY_FILE)"); if(project->isEmpty("QMAKE_LIBTOOL")) project->values("QMAKE_LIBTOOL").append("libtool --silent"); if(project->isEmpty("QMAKE_SYMBOLIC_LINK")) project->values("QMAKE_SYMBOLIC_LINK").append("ln -f -s"); /* this should probably not be here, but I'm using it to wrap the .t files */ if(project->first("TEMPLATE") == "app") project->values("QMAKE_APP_FLAG").append("1"); else if(project->first("TEMPLATE") == "lib") project->values("QMAKE_LIB_FLAG").append("1"); else if(project->first("TEMPLATE") == "subdirs") { MakefileGenerator::init(); if(project->isEmpty("MAKEFILE")) project->values("MAKEFILE").append("Makefile"); return; /* subdirs is done */ } if (!project->isEmpty("TARGET")) project->values("TARGET") = escapeFilePaths(project->values("TARGET")); project->values("QMAKE_ORIG_TARGET") = project->values("TARGET"); project->values("QMAKE_ORIG_DESTDIR") = project->values("DESTDIR"); project->values("QMAKE_LIBS") += escapeFilePaths(project->values("LIBS")); project->values("QMAKE_LIBS_PRIVATE") += escapeFilePaths(project->values("LIBS_PRIVATE")); if((!project->isEmpty("QMAKE_LIB_FLAG") && !project->isActiveConfig("staticlib")) || (project->isActiveConfig("qt") && project->isActiveConfig("plugin"))) { if(configs.indexOf("dll") == -1) configs.append("dll"); } else if(!project->isEmpty("QMAKE_APP_FLAG") || project->isActiveConfig("dll")) { configs.removeAll("staticlib"); } if(!project->isEmpty("QMAKE_INCREMENTAL")) project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_INCREMENTAL"); else if(!project->isEmpty("QMAKE_LFLAGS_PREBIND") && !project->values("QMAKE_LIB_FLAG").isEmpty() && project->isActiveConfig("dll")) project->values("QMAKE_LFLAGS") += project->values("QMAKE_LFLAGS_PREBIND"); if(!project->isEmpty("QMAKE_INCDIR")) project->values("INCLUDEPATH") += project->values("QMAKE_INCDIR"); project->values("QMAKE_L_FLAG") << (project->isActiveConfig("rvct_linker") ? "--userlibpath " : project->isActiveConfig("armcc_linker") ? "-L--userlibpath=" : project->isActiveConfig("ti_linker") ? "--search_path=" : "-L"); ProStringList ldadd; if(!project->isEmpty("QMAKE_LIBDIR")) { const ProStringList &libdirs = project->values("QMAKE_LIBDIR"); for(int i = 0; i < libdirs.size(); ++i) { if(!project->isEmpty("QMAKE_LFLAGS_RPATH") && project->isActiveConfig("rpath_libdirs")) project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + libdirs[i]; project->values("QMAKE_LIBDIR_FLAGS") += "-L" + escapeFilePath(libdirs[i]); } } ldadd += project->values("QMAKE_LIBDIR_FLAGS"); if (project->isActiveConfig("mac")) { if (!project->isEmpty("QMAKE_FRAMEWORKPATH")) { const ProStringList &fwdirs = project->values("QMAKE_FRAMEWORKPATH"); for (int i = 0; i < fwdirs.size(); ++i) project->values("QMAKE_FRAMEWORKPATH_FLAGS") += "-F" + escapeFilePath(fwdirs[i]); } ldadd += project->values("QMAKE_FRAMEWORKPATH_FLAGS"); } ProStringList &qmklibs = project->values("QMAKE_LIBS"); qmklibs = ldadd + qmklibs; if(!project->isEmpty("QMAKE_RPATHDIR")) { const ProStringList &rpathdirs = project->values("QMAKE_RPATHDIR"); for(int i = 0; i < rpathdirs.size(); ++i) { if(!project->isEmpty("QMAKE_LFLAGS_RPATH")) project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATH") + escapeFilePath(QFileInfo(rpathdirs[i].toQString()).absoluteFilePath()); } } if (!project->isEmpty("QMAKE_RPATHLINKDIR")) { const ProStringList &rpathdirs = project->values("QMAKE_RPATHLINKDIR"); for (int i = 0; i < rpathdirs.size(); ++i) { if (!project->isEmpty("QMAKE_LFLAGS_RPATHLINK")) project->values("QMAKE_LFLAGS") += var("QMAKE_LFLAGS_RPATHLINK") + escapeFilePath(QFileInfo(rpathdirs[i].toQString()).absoluteFilePath()); } } if(project->isActiveConfig("GNUmake") && !project->isEmpty("QMAKE_CFLAGS_DEPS")) include_deps = true; //do not generate deps if(project->isActiveConfig("compile_libtool")) Option::obj_ext = ".lo"; //override the .o MakefileGenerator::init(); QString comps[] = { "C", "CXX", "OBJC", "OBJCXX", QString() }; for(int i = 0; !comps[i].isNull(); i++) { QString compile_flag = var("QMAKE_COMPILE_FLAG"); if(compile_flag.isEmpty()) compile_flag = "-c"; if(doPrecompiledHeaders() && !project->isEmpty("PRECOMPILED_HEADER")) { QString pchFlags = var(ProKey("QMAKE_" + comps[i] + "FLAGS_USE_PRECOMPILE")); QString pchBaseName; if(!project->isEmpty("PRECOMPILED_DIR")) { pchBaseName = Option::fixPathToTargetOS(project->first("PRECOMPILED_DIR").toQString()); if(!pchBaseName.endsWith(Option::dir_sep)) pchBaseName += Option::dir_sep; } pchBaseName += project->first("QMAKE_ORIG_TARGET").toQString(); // replace place holders pchFlags = pchFlags.replace("${QMAKE_PCH_INPUT}", fileFixify(project->first("PRECOMPILED_HEADER").toQString())); pchFlags = pchFlags.replace("${QMAKE_PCH_OUTPUT_BASE}", pchBaseName); if (project->isActiveConfig("icc_pch_style")) { // icc style pchFlags = pchFlags.replace("${QMAKE_PCH_OUTPUT}", pchBaseName + project->first("QMAKE_PCH_OUTPUT_EXT")); } else { // gcc style (including clang_pch_style) QString headerSuffix; if (project->isActiveConfig("clang_pch_style")) headerSuffix = project->first("QMAKE_PCH_OUTPUT_EXT").toQString(); else pchBaseName += project->first("QMAKE_PCH_OUTPUT_EXT").toQString(); pchBaseName += Option::dir_sep; QString pchOutputFile; if(comps[i] == "C") { pchOutputFile = "c"; } else if(comps[i] == "CXX") { pchOutputFile = "c++"; } else if(project->isActiveConfig("objective_c")) { if(comps[i] == "OBJC") pchOutputFile = "objective-c"; else if(comps[i] == "OBJCXX") pchOutputFile = "objective-c++"; } if(!pchOutputFile.isEmpty()) { pchFlags = pchFlags.replace("${QMAKE_PCH_OUTPUT}", pchBaseName + pchOutputFile + headerSuffix); } } if (!pchFlags.isEmpty()) compile_flag += " " + pchFlags; } QString cflags; if(comps[i] == "OBJC" || comps[i] == "OBJCXX") cflags += " $(CFLAGS)"; else cflags += " $(" + comps[i] + "FLAGS)"; compile_flag += cflags + " $(INCPATH)"; QString compiler = comps[i]; if (compiler == "C") compiler = "CC"; const ProKey runComp("QMAKE_RUN_" + compiler); if(project->isEmpty(runComp)) project->values(runComp).append("$(" + compiler + ") " + compile_flag + " " + var("QMAKE_CC_O_FLAG") + "$obj $src"); const ProKey runCompImp("QMAKE_RUN_" + compiler + "_IMP"); if(project->isEmpty(runCompImp)) project->values(runCompImp).append("$(" + compiler + ") " + compile_flag + " " + var("QMAKE_CC_O_FLAG") + "\"$@\" \"$<\""); } if (project->isActiveConfig("mac") && !project->isEmpty("TARGET") && !project->isActiveConfig("compile_libtool") && ((project->isActiveConfig("build_pass") || project->isEmpty("BUILDS")))) { ProString bundle; if(project->isActiveConfig("bundle") && !project->isEmpty("QMAKE_BUNDLE_EXTENSION")) { bundle = unescapeFilePath(project->first("TARGET")); if(!project->isEmpty("QMAKE_BUNDLE_NAME")) bundle = unescapeFilePath(project->first("QMAKE_BUNDLE_NAME")); if(!bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); } else if(project->first("TEMPLATE") == "app" && project->isActiveConfig("app_bundle")) { bundle = unescapeFilePath(project->first("TARGET")); if(!project->isEmpty("QMAKE_APPLICATION_BUNDLE_NAME")) bundle = unescapeFilePath(project->first("QMAKE_APPLICATION_BUNDLE_NAME")); if(!bundle.endsWith(".app")) bundle += ".app"; if(project->isEmpty("QMAKE_BUNDLE_LOCATION")) project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS"); project->values("QMAKE_PKGINFO").append(project->first("DESTDIR") + bundle + "/Contents/PkgInfo"); project->values("QMAKE_BUNDLE_RESOURCE_FILE").append(project->first("DESTDIR") + bundle + "/Contents/Resources/empty.lproj"); } else if(project->first("TEMPLATE") == "lib" && !project->isActiveConfig("staticlib") && ((!project->isActiveConfig("plugin") && project->isActiveConfig("lib_bundle")) || (project->isActiveConfig("plugin") && project->isActiveConfig("plugin_bundle")))) { bundle = unescapeFilePath(project->first("TARGET")); if(project->isActiveConfig("plugin")) { if(!project->isEmpty("QMAKE_PLUGIN_BUNDLE_NAME")) bundle = unescapeFilePath(project->first("QMAKE_PLUGIN_BUNDLE_NAME")); if(!project->isEmpty("QMAKE_BUNDLE_EXTENSION") && !bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); else if(!bundle.endsWith(".plugin")) bundle += ".plugin"; if(project->isEmpty("QMAKE_BUNDLE_LOCATION")) project->values("QMAKE_BUNDLE_LOCATION").append("Contents/MacOS"); } else { if(!project->isEmpty("QMAKE_FRAMEWORK_BUNDLE_NAME")) bundle = unescapeFilePath(project->first("QMAKE_FRAMEWORK_BUNDLE_NAME")); if(!project->isEmpty("QMAKE_BUNDLE_EXTENSION") && !bundle.endsWith(project->first("QMAKE_BUNDLE_EXTENSION"))) bundle += project->first("QMAKE_BUNDLE_EXTENSION"); else if(!bundle.endsWith(".framework")) bundle += ".framework"; } } if(!bundle.isEmpty()) { project->values("QMAKE_BUNDLE") = ProStringList(bundle); project->values("ALL_DEPS") += project->first("QMAKE_PKGINFO"); project->values("ALL_DEPS") += project->first("QMAKE_BUNDLE_RESOURCE_FILE"); } else { project->values("QMAKE_BUNDLE").clear(); project->values("QMAKE_BUNDLE_LOCATION").clear(); } } else { //no bundling here project->values("QMAKE_BUNDLE").clear(); project->values("QMAKE_BUNDLE_LOCATION").clear(); } if(!project->isEmpty("QMAKE_INTERNAL_INCLUDED_FILES")) project->values("DISTFILES") += project->values("QMAKE_INTERNAL_INCLUDED_FILES"); project->values("DISTFILES") += project->projectFile(); init2(); project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_LIBS"; if(!project->isEmpty("QMAKE_MAX_FILES_PER_AR")) { bool ok; int max_files = project->first("QMAKE_MAX_FILES_PER_AR").toInt(&ok); ProStringList ar_sublibs, objs = project->values("OBJECTS"); if(ok && max_files > 5 && max_files < (int)objs.count()) { QString lib; for(int i = 0, obj_cnt = 0, lib_cnt = 0; i != objs.size(); ++i) { if((++obj_cnt) >= max_files) { if(lib_cnt) { lib.sprintf("lib%s-tmp%d.a", project->first("QMAKE_ORIG_TARGET").toLatin1().constData(), lib_cnt); ar_sublibs << lib; obj_cnt = 0; } lib_cnt++; } } } if(!ar_sublibs.isEmpty()) { project->values("QMAKE_AR_SUBLIBS") = ar_sublibs; project->values("QMAKE_INTERNAL_PRL_LIBS") << "QMAKE_AR_SUBLIBS"; } } if(project->isActiveConfig("compile_libtool")) { static const char * const libtoolify[] = { "QMAKE_RUN_CC", "QMAKE_RUN_CC_IMP", "QMAKE_RUN_CXX", "QMAKE_RUN_CXX_IMP", "QMAKE_LINK_THREAD", "QMAKE_LINK", "QMAKE_AR_CMD", "QMAKE_LINK_SHLIB_CMD", 0 }; for (int i = 0; libtoolify[i]; i++) { ProStringList &l = project->values(libtoolify[i]); if(!l.isEmpty()) { QString libtool_flags, comp_flags; if (!strncmp(libtoolify[i], "QMAKE_LINK", 10) || !strcmp(libtoolify[i], "QMAKE_AR_CMD")) { libtool_flags += " --mode=link"; if(project->isActiveConfig("staticlib")) { libtool_flags += " -static"; } else { if(!project->isEmpty("QMAKE_LIB_FLAG")) { int maj = project->first("VER_MAJ").toInt(); int min = project->first("VER_MIN").toInt(); int pat = project->first("VER_PAT").toInt(); comp_flags += " -version-info " + QString::number(10*maj + min) + ":" + QString::number(pat) + ":0"; if (strcmp(libtoolify[i], "QMAKE_AR_CMD")) { QString rpath = Option::output_dir; if(!project->isEmpty("DESTDIR")) { rpath = project->first("DESTDIR").toQString(); if(QDir::isRelativePath(rpath)) rpath.prepend(Option::output_dir + Option::dir_sep); } comp_flags += " -rpath " + Option::fixPathToTargetOS(rpath, false); } } } if(project->isActiveConfig("plugin")) libtool_flags += " -module"; } else { libtool_flags += " --mode=compile"; } l.first().prepend("$(LIBTOOL)" + libtool_flags + " "); if(!comp_flags.isEmpty()) l.first() += comp_flags; } } } }
bool UnixMakefileGenerator::findLibraries() { ProString libArg = project->first("QMAKE_L_FLAG"); if (libArg == "-L") libArg.clear(); QList<QMakeLocalFileName> libdirs; int libidx = 0; foreach (const ProString &dlib, project->values("QMAKE_DEFAULT_LIBDIRS")) libdirs.append(QMakeLocalFileName(dlib.toQString())); static const char * const lflags[] = { "QMAKE_LIBS", "QMAKE_LIBS_PRIVATE", 0 }; for (int i = 0; lflags[i]; i++) { ProStringList &l = project->values(lflags[i]); for (ProStringList::Iterator it = l.begin(); it != l.end(); ) { QString stub, dir, extn, opt = (*it).trimmed().toQString(); if(opt.startsWith("-")) { if(opt.startsWith("-L")) { QString lib = opt.mid(2); QMakeLocalFileName f(lib); int idx = libdirs.indexOf(f); if (idx >= 0 && idx < libidx) { it = l.erase(it); continue; } libdirs.insert(libidx++, f); if (!libArg.isEmpty()) *it = libArg + lib; } else if(opt.startsWith("-l")) { if (project->isActiveConfig("rvct_linker") || project->isActiveConfig("armcc_linker")) { (*it) = "lib" + opt.mid(2) + ".so"; } else if (project->isActiveConfig("ti_linker")) { (*it) = opt.mid(2); } else { stub = opt.mid(2); } } else if (target_mode == TARG_MAC_MODE && opt.startsWith("-framework")) { if (opt.length() == 10) ++it; // Skip } } else { extn = dir = ""; stub = opt; int slsh = opt.lastIndexOf(Option::dir_sep); if(slsh != -1) { dir = opt.left(slsh); stub = opt.mid(slsh+1); } QRegExp stub_reg("^.*lib(" + stub + "[^./=]*)\\.(.*)$"); if(stub_reg.exactMatch(stub)) { stub = stub_reg.cap(1); extn = stub_reg.cap(2); } } if(!stub.isEmpty()) { stub += project->first(ProKey("QMAKE_" + stub.toUpper() + "_SUFFIX")).toQString(); bool found = false; ProStringList extens; if(!extn.isNull()) extens << extn; else extens << project->values("QMAKE_EXTENSION_SHLIB").first() << "a"; for (ProStringList::Iterator extit = extens.begin(); extit != extens.end(); ++extit) { if(dir.isNull()) { for(QList<QMakeLocalFileName>::Iterator dep_it = libdirs.begin(); dep_it != libdirs.end(); ++dep_it) { QString pathToLib = ((*dep_it).local() + Option::dir_sep + project->values("QMAKE_PREFIX_SHLIB").first() + stub + "." + (*extit)); if(exists(pathToLib)) { (*it) = "-l" + stub; found = true; break; } } } else { QString lib = dir + project->values("QMAKE_PREFIX_SHLIB").first() + stub + "." + (*extit); if (exists(lib)) { (*it) = lib; found = true; break; } } } if(!found && project->isActiveConfig("compile_libtool")) { for(int dep_i = 0; dep_i < libdirs.size(); ++dep_i) { if(exists(libdirs[dep_i].local() + Option::dir_sep + project->values("QMAKE_PREFIX_SHLIB").first() + stub + Option::libtool_ext)) { (*it) = libdirs[dep_i].real() + Option::dir_sep + project->values("QMAKE_PREFIX_SHLIB").first() + stub + Option::libtool_ext; found = true; break; } } } } ++it; } } return false; }