[2] | 1 | /****************************************************************************
|
---|
| 2 | **
|
---|
[651] | 3 | ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
|
---|
[561] | 4 | ** All rights reserved.
|
---|
| 5 | ** Contact: Nokia Corporation ([email protected])
|
---|
[2] | 6 | **
|
---|
| 7 | ** This file is part of the qmake application of the Qt Toolkit.
|
---|
| 8 | **
|
---|
| 9 | ** $QT_BEGIN_LICENSE:LGPL$
|
---|
| 10 | ** Commercial Usage
|
---|
| 11 | ** Licensees holding valid Qt Commercial licenses may use this file in
|
---|
| 12 | ** accordance with the Qt Commercial License Agreement provided with the
|
---|
| 13 | ** Software or, alternatively, in accordance with the terms contained in
|
---|
| 14 | ** a written agreement between you and Nokia.
|
---|
| 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 | **
|
---|
[561] | 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.
|
---|
[2] | 27 | **
|
---|
| 28 | ** GNU General Public License Usage
|
---|
| 29 | ** Alternatively, this file may be used under the terms of the GNU
|
---|
| 30 | ** General Public License version 3.0 as published by the Free Software
|
---|
| 31 | ** Foundation and appearing in the file LICENSE.GPL included in the
|
---|
| 32 | ** packaging of this file. Please review the following information to
|
---|
| 33 | ** ensure the GNU General Public License version 3.0 requirements will be
|
---|
| 34 | ** met: http://www.gnu.org/copyleft/gpl.html.
|
---|
| 35 | **
|
---|
[561] | 36 | ** If you have questions regarding the use of this file, please contact
|
---|
| 37 | ** Nokia at [email protected].
|
---|
[2] | 38 | ** $QT_END_LICENSE$
|
---|
| 39 | **
|
---|
| 40 | ****************************************************************************/
|
---|
| 41 |
|
---|
| 42 | #include "option.h"
|
---|
| 43 | #include "cachekeys.h"
|
---|
| 44 | #include <qdir.h>
|
---|
| 45 | #include <qregexp.h>
|
---|
| 46 | #include <qhash.h>
|
---|
| 47 | #include <qdebug.h>
|
---|
| 48 | #include <qsettings.h>
|
---|
| 49 | #include <stdlib.h>
|
---|
| 50 | #include <stdarg.h>
|
---|
| 51 |
|
---|
| 52 | QT_BEGIN_NAMESPACE
|
---|
| 53 |
|
---|
| 54 | //convenience
|
---|
| 55 | const char *Option::application_argv0 = 0;
|
---|
| 56 | QString Option::prf_ext;
|
---|
| 57 | QString Option::js_ext;
|
---|
| 58 | QString Option::prl_ext;
|
---|
| 59 | QString Option::libtool_ext;
|
---|
| 60 | QString Option::pkgcfg_ext;
|
---|
| 61 | QString Option::ui_ext;
|
---|
| 62 | QStringList Option::h_ext;
|
---|
| 63 | QString Option::cpp_moc_ext;
|
---|
| 64 | QString Option::h_moc_ext;
|
---|
| 65 | QStringList Option::cpp_ext;
|
---|
| 66 | QStringList Option::c_ext;
|
---|
| 67 | QString Option::obj_ext;
|
---|
| 68 | QString Option::lex_ext;
|
---|
| 69 | QString Option::yacc_ext;
|
---|
| 70 | QString Option::pro_ext;
|
---|
[561] | 71 | QString Option::mmp_ext;
|
---|
[2] | 72 | QString Option::dir_sep;
|
---|
| 73 | QString Option::dirlist_sep;
|
---|
| 74 | QString Option::h_moc_mod;
|
---|
| 75 | QString Option::cpp_moc_mod;
|
---|
| 76 | QString Option::yacc_mod;
|
---|
| 77 | QString Option::lex_mod;
|
---|
| 78 | QString Option::sysenv_mod;
|
---|
| 79 | QString Option::res_ext;
|
---|
| 80 | char Option::field_sep;
|
---|
| 81 |
|
---|
| 82 | //mode
|
---|
| 83 | Option::QMAKE_MODE Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;
|
---|
| 84 |
|
---|
| 85 | //all modes
|
---|
| 86 | QString Option::qmake_abslocation;
|
---|
| 87 | int Option::warn_level = WarnLogic;
|
---|
| 88 | int Option::debug_level = 0;
|
---|
| 89 | QFile Option::output;
|
---|
| 90 | QString Option::output_dir;
|
---|
| 91 | bool Option::recursive = false;
|
---|
| 92 | QStringList Option::before_user_vars;
|
---|
| 93 | QStringList Option::after_user_vars;
|
---|
| 94 | QStringList Option::user_configs;
|
---|
| 95 | QStringList Option::after_user_configs;
|
---|
| 96 | QString Option::user_template;
|
---|
| 97 | QString Option::user_template_prefix;
|
---|
| 98 | QStringList Option::shellPath;
|
---|
| 99 | #if defined(Q_OS_WIN32)
|
---|
| 100 | Option::TARG_MODE Option::target_mode = Option::TARG_WIN_MODE;
|
---|
[27] | 101 | #elif defined(Q_OS_OS2)
|
---|
| 102 | Option::TARG_MODE Option::target_mode = Option::TARG_OS2_MODE;
|
---|
[2] | 103 | #elif defined(Q_OS_MAC)
|
---|
| 104 | Option::TARG_MODE Option::target_mode = Option::TARG_MACX_MODE;
|
---|
| 105 | #else
|
---|
| 106 | Option::TARG_MODE Option::target_mode = Option::TARG_UNIX_MODE;
|
---|
| 107 | #endif
|
---|
| 108 |
|
---|
| 109 | //QMAKE_*_PROPERTY stuff
|
---|
| 110 | QStringList Option::prop::properties;
|
---|
| 111 |
|
---|
| 112 | //QMAKE_GENERATE_PROJECT stuff
|
---|
| 113 | bool Option::projfile::do_pwd = true;
|
---|
| 114 | QStringList Option::projfile::project_dirs;
|
---|
| 115 |
|
---|
| 116 | //QMAKE_GENERATE_MAKEFILE stuff
|
---|
| 117 | QString Option::mkfile::qmakespec;
|
---|
| 118 | int Option::mkfile::cachefile_depth = -1;
|
---|
| 119 | bool Option::mkfile::do_deps = true;
|
---|
| 120 | bool Option::mkfile::do_mocs = true;
|
---|
| 121 | bool Option::mkfile::do_dep_heuristics = true;
|
---|
| 122 | bool Option::mkfile::do_preprocess = false;
|
---|
| 123 | bool Option::mkfile::do_stub_makefile = false;
|
---|
| 124 | bool Option::mkfile::do_cache = true;
|
---|
| 125 | QString Option::mkfile::cachefile;
|
---|
| 126 | QStringList Option::mkfile::project_files;
|
---|
| 127 | QString Option::mkfile::qmakespec_commandline;
|
---|
| 128 |
|
---|
| 129 | static Option::QMAKE_MODE default_mode(QString progname)
|
---|
| 130 | {
|
---|
| 131 | int s = progname.lastIndexOf(Option::dir_sep);
|
---|
| 132 | if(s != -1)
|
---|
| 133 | progname = progname.right(progname.length() - (s + 1));
|
---|
| 134 | if(progname == "qmakegen")
|
---|
| 135 | return Option::QMAKE_GENERATE_PROJECT;
|
---|
| 136 | else if(progname == "qt-config")
|
---|
| 137 | return Option::QMAKE_QUERY_PROPERTY;
|
---|
| 138 | return Option::QMAKE_GENERATE_MAKEFILE;
|
---|
| 139 | }
|
---|
| 140 |
|
---|
| 141 | QString project_builtin_regx();
|
---|
| 142 | bool usage(const char *a0)
|
---|
| 143 | {
|
---|
| 144 | fprintf(stdout, "Usage: %s [mode] [options] [files]\n"
|
---|
| 145 | "\n"
|
---|
| 146 | "QMake has two modes, one mode for generating project files based on\n"
|
---|
| 147 | "some heuristics, and the other for generating makefiles. Normally you\n"
|
---|
| 148 | "shouldn't need to specify a mode, as makefile generation is the default\n"
|
---|
| 149 | "mode for qmake, but you may use this to test qmake on an existing project\n"
|
---|
| 150 | "\n"
|
---|
| 151 | "Mode:\n"
|
---|
| 152 | " -project Put qmake into project file generation mode%s\n"
|
---|
| 153 | " In this mode qmake interprets files as files to\n"
|
---|
| 154 | " be built,\n"
|
---|
| 155 | " defaults to %s\n"
|
---|
[561] | 156 | " Note: The created .pro file probably will \n"
|
---|
| 157 | " need to be edited. For example add the QT variable to \n"
|
---|
| 158 | " specify what modules are required.\n"
|
---|
[2] | 159 | " -makefile Put qmake into makefile generation mode%s\n"
|
---|
| 160 | " In this mode qmake interprets files as project files to\n"
|
---|
| 161 | " be processed, if skipped qmake will try to find a project\n"
|
---|
| 162 | " file in your current working directory\n"
|
---|
| 163 | "\n"
|
---|
| 164 | "Warnings Options:\n"
|
---|
| 165 | " -Wnone Turn off all warnings\n"
|
---|
| 166 | " -Wall Turn on all warnings\n"
|
---|
| 167 | " -Wparser Turn on parser warnings\n"
|
---|
| 168 | " -Wlogic Turn on logic warnings\n"
|
---|
| 169 | "\n"
|
---|
| 170 | "Options:\n"
|
---|
| 171 | " * You can place any variable assignment in options and it will be *\n"
|
---|
| 172 | " * processed as if it was in [files]. These assignments will be parsed *\n"
|
---|
| 173 | " * before [files]. *\n"
|
---|
| 174 | " -o file Write output to file\n"
|
---|
| 175 | " -unix Run in unix mode\n"
|
---|
| 176 | " -win32 Run in win32 mode\n"
|
---|
[27] | 177 | " -os2 Run in OS/2 mode\n"
|
---|
[2] | 178 | " -macx Run in Mac OS X mode\n"
|
---|
| 179 | " -d Increase debug level\n"
|
---|
| 180 | " -t templ Overrides TEMPLATE as templ\n"
|
---|
| 181 | " -tp prefix Overrides TEMPLATE so that prefix is prefixed into the value\n"
|
---|
| 182 | " -help This help\n"
|
---|
| 183 | " -v Version information\n"
|
---|
| 184 | " -after All variable assignments after this will be\n"
|
---|
| 185 | " parsed after [files]\n"
|
---|
| 186 | " -norecursive Don't do a recursive search\n"
|
---|
| 187 | " -recursive Do a recursive search\n"
|
---|
| 188 | " -set <prop> <value> Set persistent property\n"
|
---|
| 189 | " -query <prop> Query persistent property. Show all if <prop> is empty.\n"
|
---|
| 190 | " -cache file Use file as cache [makefile mode only]\n"
|
---|
| 191 | " -spec spec Use spec as QMAKESPEC [makefile mode only]\n"
|
---|
| 192 | " -nocache Don't use a cache file [makefile mode only]\n"
|
---|
| 193 | " -nodepend Don't generate dependencies [makefile mode only]\n"
|
---|
| 194 | " -nomoc Don't generate moc targets [makefile mode only]\n"
|
---|
| 195 | " -nopwd Don't look for files in pwd [project mode only]\n"
|
---|
| 196 | ,a0,
|
---|
| 197 | default_mode(a0) == Option::QMAKE_GENERATE_PROJECT ? " (default)" : "", project_builtin_regx().toLatin1().constData(),
|
---|
| 198 | default_mode(a0) == Option::QMAKE_GENERATE_MAKEFILE ? " (default)" : ""
|
---|
| 199 | );
|
---|
| 200 | return false;
|
---|
| 201 | }
|
---|
| 202 |
|
---|
| 203 | int
|
---|
| 204 | Option::parseCommandLine(int argc, char **argv, int skip)
|
---|
| 205 | {
|
---|
| 206 | bool before = true;
|
---|
| 207 | for(int x = skip; x < argc; x++) {
|
---|
| 208 | if(*argv[x] == '-' && strlen(argv[x]) > 1) { /* options */
|
---|
| 209 | QString opt = argv[x] + 1;
|
---|
| 210 |
|
---|
| 211 | //first param is a mode, or we default
|
---|
| 212 | if(x == 1) {
|
---|
| 213 | bool specified = true;
|
---|
| 214 | if(opt == "project") {
|
---|
| 215 | Option::recursive = true;
|
---|
| 216 | Option::qmake_mode = Option::QMAKE_GENERATE_PROJECT;
|
---|
| 217 | } else if(opt == "prl") {
|
---|
| 218 | Option::mkfile::do_deps = false;
|
---|
| 219 | Option::mkfile::do_mocs = false;
|
---|
| 220 | Option::qmake_mode = Option::QMAKE_GENERATE_PRL;
|
---|
| 221 | } else if(opt == "set") {
|
---|
| 222 | Option::qmake_mode = Option::QMAKE_SET_PROPERTY;
|
---|
| 223 | } else if(opt == "query") {
|
---|
| 224 | Option::qmake_mode = Option::QMAKE_QUERY_PROPERTY;
|
---|
| 225 | } else if(opt == "makefile") {
|
---|
| 226 | Option::qmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
|
---|
| 227 | } else {
|
---|
| 228 | specified = false;
|
---|
| 229 | }
|
---|
| 230 | if(specified)
|
---|
| 231 | continue;
|
---|
| 232 | }
|
---|
| 233 | //all modes
|
---|
| 234 | if(opt == "o" || opt == "output") {
|
---|
| 235 | Option::output.setFileName(argv[++x]);
|
---|
| 236 | } else if(opt == "after") {
|
---|
| 237 | before = false;
|
---|
| 238 | } else if(opt == "t" || opt == "template") {
|
---|
| 239 | Option::user_template = argv[++x];
|
---|
| 240 | } else if(opt == "tp" || opt == "template_prefix") {
|
---|
| 241 | Option::user_template_prefix = argv[++x];
|
---|
| 242 | } else if(opt == "mac9") {
|
---|
| 243 | Option::target_mode = TARG_MAC9_MODE;
|
---|
| 244 | } else if(opt == "macx") {
|
---|
| 245 | Option::target_mode = TARG_MACX_MODE;
|
---|
| 246 | } else if(opt == "unix") {
|
---|
| 247 | Option::target_mode = TARG_UNIX_MODE;
|
---|
| 248 | } else if(opt == "win32") {
|
---|
| 249 | Option::target_mode = TARG_WIN_MODE;
|
---|
[27] | 250 | } else if(opt == "os2") {
|
---|
| 251 | Option::target_mode = TARG_OS2_MODE;
|
---|
[2] | 252 | } else if(opt == "d") {
|
---|
| 253 | Option::debug_level++;
|
---|
| 254 | } else if(opt == "version" || opt == "v" || opt == "-version") {
|
---|
| 255 | fprintf(stdout,
|
---|
| 256 | "QMake version %s\n"
|
---|
| 257 | "Using Qt version %s in %s\n",
|
---|
| 258 | qmake_version(), QT_VERSION_STR,
|
---|
| 259 | QLibraryInfo::location(QLibraryInfo::LibrariesPath).toLatin1().constData());
|
---|
| 260 | #ifdef QMAKE_OPENSOURCE_VERSION
|
---|
| 261 | fprintf(stdout, "QMake is Open Source software from Nokia Corporation and/or its subsidiary(-ies).\n");
|
---|
| 262 | #endif
|
---|
| 263 | return Option::QMAKE_CMDLINE_BAIL;
|
---|
| 264 | } else if(opt == "h" || opt == "help") {
|
---|
| 265 | return Option::QMAKE_CMDLINE_SHOW_USAGE;
|
---|
| 266 | } else if(opt == "Wall") {
|
---|
| 267 | Option::warn_level |= WarnAll;
|
---|
| 268 | } else if(opt == "Wparser") {
|
---|
| 269 | Option::warn_level |= WarnParser;
|
---|
| 270 | } else if(opt == "Wlogic") {
|
---|
| 271 | Option::warn_level |= WarnLogic;
|
---|
| 272 | } else if(opt == "Wnone") {
|
---|
| 273 | Option::warn_level = WarnNone;
|
---|
| 274 | } else if(opt == "r" || opt == "recursive") {
|
---|
| 275 | Option::recursive = true;
|
---|
| 276 | } else if(opt == "norecursive") {
|
---|
| 277 | Option::recursive = false;
|
---|
| 278 | } else if(opt == "config") {
|
---|
| 279 | Option::user_configs += argv[++x];
|
---|
| 280 | } else {
|
---|
| 281 | if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
|
---|
| 282 | Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
|
---|
| 283 | if(opt == "nodepend" || opt == "nodepends") {
|
---|
| 284 | Option::mkfile::do_deps = false;
|
---|
| 285 | } else if(opt == "nomoc") {
|
---|
| 286 | Option::mkfile::do_mocs = false;
|
---|
| 287 | } else if(opt == "nocache") {
|
---|
| 288 | Option::mkfile::do_cache = false;
|
---|
| 289 | } else if(opt == "createstub") {
|
---|
| 290 | Option::mkfile::do_stub_makefile = true;
|
---|
| 291 | } else if(opt == "nodependheuristics") {
|
---|
| 292 | Option::mkfile::do_dep_heuristics = false;
|
---|
| 293 | } else if(opt == "E") {
|
---|
| 294 | Option::mkfile::do_preprocess = true;
|
---|
| 295 | } else if(opt == "cache") {
|
---|
| 296 | Option::mkfile::cachefile = argv[++x];
|
---|
| 297 | } else if(opt == "platform" || opt == "spec") {
|
---|
| 298 | Option::mkfile::qmakespec = argv[++x];
|
---|
| 299 | Option::mkfile::qmakespec_commandline = argv[x];
|
---|
| 300 | } else {
|
---|
| 301 | fprintf(stderr, "***Unknown option -%s\n", opt.toLatin1().constData());
|
---|
| 302 | return Option::QMAKE_CMDLINE_SHOW_USAGE | Option::QMAKE_CMDLINE_ERROR;
|
---|
| 303 | }
|
---|
| 304 | } else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
|
---|
| 305 | if(opt == "nopwd") {
|
---|
| 306 | Option::projfile::do_pwd = false;
|
---|
| 307 | } else {
|
---|
| 308 | fprintf(stderr, "***Unknown option -%s\n", opt.toLatin1().constData());
|
---|
| 309 | return Option::QMAKE_CMDLINE_SHOW_USAGE | Option::QMAKE_CMDLINE_ERROR;
|
---|
| 310 | }
|
---|
| 311 | }
|
---|
| 312 | }
|
---|
| 313 | } else {
|
---|
| 314 | QString arg = argv[x];
|
---|
| 315 | if(arg.indexOf('=') != -1) {
|
---|
| 316 | if(before)
|
---|
| 317 | Option::before_user_vars.append(arg);
|
---|
| 318 | else
|
---|
| 319 | Option::after_user_vars.append(arg);
|
---|
| 320 | } else {
|
---|
| 321 | bool handled = true;
|
---|
| 322 | if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY ||
|
---|
| 323 | Option::qmake_mode == Option::QMAKE_SET_PROPERTY) {
|
---|
| 324 | Option::prop::properties.append(arg);
|
---|
| 325 | } else {
|
---|
| 326 | QFileInfo fi(arg);
|
---|
| 327 | if(!fi.makeAbsolute()) //strange
|
---|
| 328 | arg = fi.filePath();
|
---|
| 329 | if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
|
---|
| 330 | Option::qmake_mode == Option::QMAKE_GENERATE_PRL)
|
---|
| 331 | Option::mkfile::project_files.append(arg);
|
---|
| 332 | else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
|
---|
| 333 | Option::projfile::project_dirs.append(arg);
|
---|
| 334 | else
|
---|
| 335 | handled = false;
|
---|
| 336 | }
|
---|
| 337 | if(!handled) {
|
---|
| 338 | return Option::QMAKE_CMDLINE_SHOW_USAGE | Option::QMAKE_CMDLINE_ERROR;
|
---|
| 339 | }
|
---|
| 340 | }
|
---|
| 341 | }
|
---|
| 342 | }
|
---|
| 343 |
|
---|
| 344 | return Option::QMAKE_CMDLINE_SUCCESS;
|
---|
| 345 | }
|
---|
| 346 |
|
---|
[29] | 347 | #if defined(Q_OS_WIN)
|
---|
[2] | 348 | static QStringList detectShellPath()
|
---|
| 349 | {
|
---|
| 350 | QStringList paths;
|
---|
| 351 | QString path = qgetenv("PATH");
|
---|
| 352 | QStringList pathlist = path.toLower().split(";");
|
---|
| 353 | for (int i = 0; i < pathlist.count(); i++) {
|
---|
| 354 | QString maybeSh = pathlist.at(i) + "/sh.exe";
|
---|
| 355 | if (QFile::exists(maybeSh)) {
|
---|
| 356 | paths.append(maybeSh);
|
---|
| 357 | }
|
---|
| 358 | }
|
---|
| 359 | return paths;
|
---|
| 360 | }
|
---|
[29] | 361 | #elif defined(Q_OS_OS2)
|
---|
| 362 | static QStringList detectShellPath()
|
---|
| 363 | {
|
---|
| 364 | /* @todo check if sh is actually the active shell of the process; relying on
|
---|
| 365 | * the presence of sh.exe in PATH as done for Windows above is obviously not
|
---|
| 366 | * enough */
|
---|
| 367 | return QStringList();
|
---|
| 368 | }
|
---|
[2] | 369 | #endif
|
---|
| 370 |
|
---|
| 371 | int
|
---|
| 372 | Option::init(int argc, char **argv)
|
---|
| 373 | {
|
---|
| 374 | Option::application_argv0 = 0;
|
---|
| 375 | Option::cpp_moc_mod = "";
|
---|
| 376 | Option::h_moc_mod = "moc_";
|
---|
| 377 | Option::lex_mod = "_lex";
|
---|
| 378 | Option::yacc_mod = "_yacc";
|
---|
| 379 | Option::prl_ext = ".prl";
|
---|
| 380 | Option::libtool_ext = ".la";
|
---|
| 381 | Option::pkgcfg_ext = ".pc";
|
---|
| 382 | Option::prf_ext = ".prf";
|
---|
| 383 | Option::js_ext = ".js";
|
---|
| 384 | Option::ui_ext = ".ui";
|
---|
| 385 | Option::h_ext << ".h" << ".hpp" << ".hh" << ".hxx";
|
---|
| 386 | Option::c_ext << ".c";
|
---|
[29] | 387 | #if !defined(Q_OS_WIN) && !defined(Q_OS_OS2)
|
---|
[2] | 388 | Option::h_ext << ".H";
|
---|
| 389 | #endif
|
---|
| 390 | Option::cpp_moc_ext = ".moc";
|
---|
| 391 | Option::h_moc_ext = ".cpp";
|
---|
| 392 | Option::cpp_ext << ".cpp" << ".cc" << ".cxx";
|
---|
[29] | 393 | #if !defined(Q_OS_WIN) && !defined(Q_OS_OS2)
|
---|
[2] | 394 | Option::cpp_ext << ".C";
|
---|
| 395 | #endif
|
---|
| 396 | Option::lex_ext = ".l";
|
---|
| 397 | Option::yacc_ext = ".y";
|
---|
| 398 | Option::pro_ext = ".pro";
|
---|
[561] | 399 | Option::mmp_ext = ".mmp";
|
---|
[29] | 400 | #if defined(Q_OS_WIN) || defined(Q_OS_OS2)
|
---|
[2] | 401 | Option::dirlist_sep = ";";
|
---|
| 402 | Option::shellPath = detectShellPath();
|
---|
| 403 | #else
|
---|
| 404 | Option::dirlist_sep = ":";
|
---|
| 405 | #endif
|
---|
| 406 | Option::sysenv_mod = "QMAKE_ENV_";
|
---|
| 407 | Option::field_sep = ' ';
|
---|
| 408 |
|
---|
| 409 | if(argc && argv) {
|
---|
| 410 | Option::application_argv0 = argv[0];
|
---|
| 411 | QString argv0 = argv[0];
|
---|
| 412 | if(Option::qmake_mode == Option::QMAKE_GENERATE_NOTHING)
|
---|
| 413 | Option::qmake_mode = default_mode(argv0);
|
---|
| 414 | if(!argv0.isEmpty() && !QFileInfo(argv0).isRelative()) {
|
---|
| 415 | Option::qmake_abslocation = argv0;
|
---|
| 416 | } else if (argv0.contains(QLatin1Char('/'))
|
---|
[29] | 417 | #if defined(Q_OS_WIN) || defined(Q_OS_OS2)
|
---|
[2] | 418 | || argv0.contains(QLatin1Char('\\'))
|
---|
| 419 | #endif
|
---|
| 420 | ) { //relative PWD
|
---|
| 421 | Option::qmake_abslocation = QDir::current().absoluteFilePath(argv0);
|
---|
| 422 | } else { //in the PATH
|
---|
| 423 | QByteArray pEnv = qgetenv("PATH");
|
---|
| 424 | QDir currentDir = QDir::current();
|
---|
[29] | 425 | #if defined(Q_OS_WIN) || defined(Q_OS_OS2)
|
---|
[2] | 426 | QStringList paths = QString::fromLocal8Bit(pEnv).split(QLatin1String(";"));
|
---|
| 427 | #else
|
---|
| 428 | QStringList paths = QString::fromLocal8Bit(pEnv).split(QLatin1String(":"));
|
---|
| 429 | #endif
|
---|
| 430 | for (QStringList::const_iterator p = paths.constBegin(); p != paths.constEnd(); ++p) {
|
---|
| 431 | if ((*p).isEmpty())
|
---|
| 432 | continue;
|
---|
| 433 | QString candidate = currentDir.absoluteFilePath(*p + QLatin1Char('/') + argv0);
|
---|
[29] | 434 | #if defined(Q_OS_WIN) || defined(Q_OS_OS2)
|
---|
[2] | 435 | candidate += ".exe";
|
---|
| 436 | #endif
|
---|
| 437 | if (QFile::exists(candidate)) {
|
---|
| 438 | Option::qmake_abslocation = candidate;
|
---|
| 439 | break;
|
---|
| 440 | }
|
---|
| 441 | }
|
---|
| 442 | }
|
---|
| 443 | if(!Option::qmake_abslocation.isNull())
|
---|
| 444 | Option::qmake_abslocation = QDir::cleanPath(Option::qmake_abslocation);
|
---|
| 445 | } else {
|
---|
| 446 | Option::qmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
|
---|
| 447 | }
|
---|
| 448 |
|
---|
| 449 | const QByteArray envflags = qgetenv("QMAKEFLAGS");
|
---|
| 450 | if (!envflags.isNull()) {
|
---|
| 451 | int env_argc = 0, env_size = 0, currlen=0;
|
---|
| 452 | char quote = 0, **env_argv = NULL;
|
---|
| 453 | for (int i = 0; i < envflags.size(); ++i) {
|
---|
| 454 | if (!quote && (envflags.at(i) == '\'' || envflags.at(i) == '"')) {
|
---|
| 455 | quote = envflags.at(i);
|
---|
| 456 | } else if (envflags.at(i) == quote) {
|
---|
| 457 | quote = 0;
|
---|
| 458 | } else if (!quote && envflags.at(i) == ' ') {
|
---|
| 459 | if (currlen && env_argv && env_argv[env_argc]) {
|
---|
| 460 | env_argv[env_argc][currlen] = '\0';
|
---|
| 461 | currlen = 0;
|
---|
| 462 | env_argc++;
|
---|
| 463 | }
|
---|
| 464 | } else {
|
---|
| 465 | if(!env_argv || env_argc > env_size) {
|
---|
| 466 | env_argv = (char **)realloc(env_argv, sizeof(char *)*(env_size+=10));
|
---|
| 467 | for(int i2 = env_argc; i2 < env_size; i2++)
|
---|
| 468 | env_argv[i2] = NULL;
|
---|
| 469 | }
|
---|
| 470 | if(!env_argv[env_argc]) {
|
---|
| 471 | currlen = 0;
|
---|
| 472 | env_argv[env_argc] = (char*)malloc(255);
|
---|
| 473 | }
|
---|
| 474 | if(currlen < 255)
|
---|
| 475 | env_argv[env_argc][currlen++] = envflags.at(i);
|
---|
| 476 | }
|
---|
| 477 | }
|
---|
| 478 | if(env_argv) {
|
---|
| 479 | if(env_argv[env_argc]) {
|
---|
| 480 | env_argv[env_argc][currlen] = '\0';
|
---|
| 481 | currlen = 0;
|
---|
| 482 | env_argc++;
|
---|
| 483 | }
|
---|
| 484 | parseCommandLine(env_argc, env_argv);
|
---|
| 485 | for(int i2 = 0; i2 < env_size; i2++) {
|
---|
| 486 | if(env_argv[i2])
|
---|
| 487 | free(env_argv[i2]);
|
---|
| 488 | }
|
---|
| 489 | free(env_argv);
|
---|
| 490 | }
|
---|
| 491 | }
|
---|
| 492 | if(argc && argv) {
|
---|
| 493 | int ret = parseCommandLine(argc, argv, 1);
|
---|
| 494 | if(ret != Option::QMAKE_CMDLINE_SUCCESS) {
|
---|
| 495 | if ((ret & Option::QMAKE_CMDLINE_SHOW_USAGE) != 0)
|
---|
| 496 | usage(argv[0]);
|
---|
| 497 | return ret;
|
---|
| 498 | //return ret == QMAKE_CMDLINE_SHOW_USAGE ? usage(argv[0]) : false;
|
---|
| 499 | }
|
---|
| 500 | }
|
---|
| 501 |
|
---|
| 502 | //last chance for defaults
|
---|
| 503 | if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
|
---|
| 504 | Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
|
---|
| 505 | if(Option::mkfile::qmakespec.isNull() || Option::mkfile::qmakespec.isEmpty())
|
---|
| 506 | Option::mkfile::qmakespec = QString::fromLocal8Bit(qgetenv("QMAKESPEC").constData());
|
---|
| 507 |
|
---|
| 508 | //try REALLY hard to do it for them, lazy..
|
---|
| 509 | if(Option::mkfile::project_files.isEmpty()) {
|
---|
| 510 | QString pwd = qmake_getpwd(),
|
---|
| 511 | proj = pwd + "/" + pwd.right(pwd.length() - (pwd.lastIndexOf('/') + 1)) + Option::pro_ext;
|
---|
| 512 | if(QFile::exists(proj)) {
|
---|
| 513 | Option::mkfile::project_files.append(proj);
|
---|
| 514 | } else { //last try..
|
---|
| 515 | QStringList profiles = QDir(pwd).entryList(QStringList("*" + Option::pro_ext));
|
---|
| 516 | if(profiles.count() == 1)
|
---|
| 517 | Option::mkfile::project_files.append(pwd + "/" + profiles[0]);
|
---|
| 518 | }
|
---|
| 519 | #ifndef QT_BUILD_QMAKE_LIBRARY
|
---|
| 520 | if(Option::mkfile::project_files.isEmpty()) {
|
---|
| 521 | usage(argv[0]);
|
---|
| 522 | return Option::QMAKE_CMDLINE_ERROR;
|
---|
| 523 | }
|
---|
| 524 | #endif
|
---|
| 525 | }
|
---|
| 526 | }
|
---|
| 527 |
|
---|
| 528 | //defaults for globals
|
---|
[27] | 529 | if(Option::target_mode == Option::TARG_WIN_MODE ||
|
---|
| 530 | Option::target_mode == Option::TARG_OS2_MODE) {
|
---|
[2] | 531 | Option::dir_sep = "\\";
|
---|
| 532 | Option::obj_ext = ".obj";
|
---|
| 533 | Option::res_ext = ".res";
|
---|
| 534 | } else {
|
---|
| 535 | if(Option::target_mode == Option::TARG_MAC9_MODE)
|
---|
| 536 | Option::dir_sep = ":";
|
---|
| 537 | else
|
---|
| 538 | Option::dir_sep = "/";
|
---|
| 539 | Option::obj_ext = ".o";
|
---|
| 540 | }
|
---|
| 541 | Option::qmake_abslocation = Option::fixPathToTargetOS(Option::qmake_abslocation);
|
---|
| 542 | return QMAKE_CMDLINE_SUCCESS;
|
---|
| 543 | }
|
---|
| 544 |
|
---|
| 545 | bool Option::postProcessProject(QMakeProject *project)
|
---|
| 546 | {
|
---|
| 547 | Option::cpp_ext = project->variables()["QMAKE_EXT_CPP"];
|
---|
| 548 | if(cpp_ext.isEmpty())
|
---|
| 549 | cpp_ext << ".cpp"; //something must be there
|
---|
| 550 | Option::h_ext = project->variables()["QMAKE_EXT_H"];
|
---|
| 551 | if(h_ext.isEmpty())
|
---|
| 552 | h_ext << ".h";
|
---|
| 553 | Option::c_ext = project->variables()["QMAKE_EXT_C"];
|
---|
| 554 | if(c_ext.isEmpty())
|
---|
| 555 | c_ext << ".c"; //something must be there
|
---|
| 556 |
|
---|
| 557 | if(!project->isEmpty("QMAKE_EXT_RES"))
|
---|
| 558 | Option::res_ext = project->first("QMAKE_EXT_RES");
|
---|
| 559 | if(!project->isEmpty("QMAKE_EXT_PKGCONFIG"))
|
---|
| 560 | Option::pkgcfg_ext = project->first("QMAKE_EXT_PKGCONFIG");
|
---|
| 561 | if(!project->isEmpty("QMAKE_EXT_LIBTOOL"))
|
---|
| 562 | Option::libtool_ext = project->first("QMAKE_EXT_LIBTOOL");
|
---|
| 563 | if(!project->isEmpty("QMAKE_EXT_PRL"))
|
---|
| 564 | Option::prl_ext = project->first("QMAKE_EXT_PRL");
|
---|
| 565 | if(!project->isEmpty("QMAKE_EXT_PRF"))
|
---|
| 566 | Option::prf_ext = project->first("QMAKE_EXT_PRF");
|
---|
| 567 | if(!project->isEmpty("QMAKE_EXT_JS"))
|
---|
| 568 | Option::prf_ext = project->first("QMAKE_EXT_JS");
|
---|
| 569 | if(!project->isEmpty("QMAKE_EXT_UI"))
|
---|
| 570 | Option::ui_ext = project->first("QMAKE_EXT_UI");
|
---|
| 571 | if(!project->isEmpty("QMAKE_EXT_CPP_MOC"))
|
---|
| 572 | Option::cpp_moc_ext = project->first("QMAKE_EXT_CPP_MOC");
|
---|
| 573 | if(!project->isEmpty("QMAKE_EXT_H_MOC"))
|
---|
| 574 | Option::h_moc_ext = project->first("QMAKE_EXT_H_MOC");
|
---|
| 575 | if(!project->isEmpty("QMAKE_EXT_LEX"))
|
---|
| 576 | Option::lex_ext = project->first("QMAKE_EXT_LEX");
|
---|
| 577 | if(!project->isEmpty("QMAKE_EXT_YACC"))
|
---|
| 578 | Option::yacc_ext = project->first("QMAKE_EXT_YACC");
|
---|
| 579 | if(!project->isEmpty("QMAKE_EXT_OBJ"))
|
---|
| 580 | Option::obj_ext = project->first("QMAKE_EXT_OBJ");
|
---|
| 581 | if(!project->isEmpty("QMAKE_H_MOD_MOC"))
|
---|
| 582 | Option::h_moc_mod = project->first("QMAKE_H_MOD_MOC");
|
---|
| 583 | if(!project->isEmpty("QMAKE_CPP_MOD_MOC"))
|
---|
| 584 | Option::cpp_moc_mod = project->first("QMAKE_CPP_MOD_MOC");
|
---|
| 585 | if(!project->isEmpty("QMAKE_MOD_LEX"))
|
---|
| 586 | Option::lex_mod = project->first("QMAKE_MOD_LEX");
|
---|
| 587 | if(!project->isEmpty("QMAKE_MOD_YACC"))
|
---|
| 588 | Option::yacc_mod = project->first("QMAKE_MOD_YACC");
|
---|
| 589 | if(!project->isEmpty("QMAKE_DIR_SEP"))
|
---|
| 590 | Option::dir_sep = project->first("QMAKE_DIR_SEP");
|
---|
| 591 | if(!project->isEmpty("QMAKE_DIRLIST_SEP"))
|
---|
| 592 | Option::dirlist_sep = project->first("QMAKE_DIRLIST_SEP");
|
---|
| 593 | if(!project->isEmpty("QMAKE_MOD_SYSTEM_ENV"))
|
---|
| 594 | Option::sysenv_mod = project->first("QMAKE_MOD_SYSTEM_ENV");
|
---|
| 595 | return true;
|
---|
| 596 | }
|
---|
| 597 |
|
---|
| 598 | QString
|
---|
| 599 | Option::fixString(QString string, uchar flags)
|
---|
| 600 | {
|
---|
| 601 | const QString orig_string = string;
|
---|
| 602 | static QHash<FixStringCacheKey, QString> *cache = 0;
|
---|
| 603 | if(!cache) {
|
---|
| 604 | cache = new QHash<FixStringCacheKey, QString>;
|
---|
| 605 | qmakeAddCacheClear(qmakeDeleteCacheClear_QHashFixStringCacheKeyQString, (void**)&cache);
|
---|
| 606 | }
|
---|
| 607 | FixStringCacheKey cacheKey(string, flags);
|
---|
| 608 | if(cache->contains(cacheKey)) {
|
---|
| 609 | const QString ret = cache->value(cacheKey);
|
---|
| 610 | //qDebug() << "Fix (cached) " << orig_string << "->" << ret;
|
---|
| 611 | return ret;
|
---|
| 612 | }
|
---|
| 613 |
|
---|
| 614 | //fix the environment variables
|
---|
| 615 | if(flags & Option::FixEnvVars) {
|
---|
| 616 | int rep;
|
---|
| 617 | QRegExp reg_var("\\$\\(.*\\)");
|
---|
| 618 | reg_var.setMinimal(true);
|
---|
| 619 | while((rep = reg_var.indexIn(string)) != -1)
|
---|
| 620 | string.replace(rep, reg_var.matchedLength(),
|
---|
| 621 | QString::fromLocal8Bit(qgetenv(string.mid(rep + 2, reg_var.matchedLength() - 3).toLatin1().constData()).constData()));
|
---|
| 622 | }
|
---|
| 623 |
|
---|
| 624 | //canonicalize it (and treat as a path)
|
---|
| 625 | if(flags & Option::FixPathCanonicalize) {
|
---|
| 626 | #if 0
|
---|
| 627 | string = QFileInfo(string).canonicalFilePath();
|
---|
| 628 | #endif
|
---|
| 629 | string = QDir::cleanPath(string);
|
---|
| 630 | }
|
---|
| 631 |
|
---|
| 632 | if(string.length() > 2 && string[0].isLetter() && string[1] == QLatin1Char(':'))
|
---|
| 633 | string[0] = string[0].toLower();
|
---|
| 634 |
|
---|
| 635 | //fix separators
|
---|
| 636 | Q_ASSERT(!((flags & Option::FixPathToLocalSeparators) && (flags & Option::FixPathToTargetSeparators)));
|
---|
| 637 | if(flags & Option::FixPathToLocalSeparators) {
|
---|
[29] | 638 | #if defined(Q_OS_WIN) || defined(Q_OS_OS2)
|
---|
[2] | 639 | string = string.replace('/', '\\');
|
---|
| 640 | #else
|
---|
| 641 | string = string.replace('\\', '/');
|
---|
| 642 | #endif
|
---|
| 643 | } else if(flags & Option::FixPathToTargetSeparators) {
|
---|
| 644 | string = string.replace('/', Option::dir_sep).replace('\\', Option::dir_sep);
|
---|
| 645 | }
|
---|
| 646 |
|
---|
[769] | 647 | if ((string.startsWith("\"") && string.endsWith("\"")) ||
|
---|
| 648 | (string.startsWith("\'") && string.endsWith("\'")))
|
---|
[2] | 649 | string = string.mid(1, string.length()-2);
|
---|
| 650 |
|
---|
| 651 | //cache
|
---|
| 652 | //qDebug() << "Fix" << orig_string << "->" << string;
|
---|
| 653 | cache->insert(cacheKey, string);
|
---|
| 654 | return string;
|
---|
| 655 | }
|
---|
| 656 |
|
---|
| 657 | const char *qmake_version()
|
---|
| 658 | {
|
---|
| 659 | static char *ret = NULL;
|
---|
| 660 | if(ret)
|
---|
| 661 | return ret;
|
---|
| 662 | ret = (char *)malloc(15);
|
---|
| 663 | qmakeAddCacheClear(qmakeFreeCacheClear, (void**)&ret);
|
---|
| 664 | #if defined(_MSC_VER) && _MSC_VER >= 1400
|
---|
| 665 | sprintf_s(ret, 15, "%d.%02d%c", QMAKE_VERSION_MAJOR, QMAKE_VERSION_MINOR, 'a' + QMAKE_VERSION_PATCH);
|
---|
| 666 | #else
|
---|
| 667 | sprintf(ret, "%d.%02d%c", QMAKE_VERSION_MAJOR, QMAKE_VERSION_MINOR, 'a' + QMAKE_VERSION_PATCH);
|
---|
| 668 | #endif
|
---|
| 669 | return ret;
|
---|
| 670 | }
|
---|
| 671 |
|
---|
| 672 | void debug_msg_internal(int level, const char *fmt, ...)
|
---|
| 673 | {
|
---|
| 674 | if(Option::debug_level < level)
|
---|
| 675 | return;
|
---|
| 676 | fprintf(stderr, "DEBUG %d: ", level);
|
---|
| 677 | {
|
---|
| 678 | va_list ap;
|
---|
| 679 | va_start(ap, fmt);
|
---|
| 680 | vfprintf(stderr, fmt, ap);
|
---|
| 681 | va_end(ap);
|
---|
| 682 | }
|
---|
| 683 | fprintf(stderr, "\n");
|
---|
| 684 | }
|
---|
| 685 |
|
---|
| 686 | void warn_msg(QMakeWarn type, const char *fmt, ...)
|
---|
| 687 | {
|
---|
| 688 | if(!(Option::warn_level & type))
|
---|
| 689 | return;
|
---|
| 690 | fprintf(stderr, "WARNING: ");
|
---|
| 691 | {
|
---|
| 692 | va_list ap;
|
---|
| 693 | va_start(ap, fmt);
|
---|
| 694 | vfprintf(stderr, fmt, ap);
|
---|
| 695 | va_end(ap);
|
---|
| 696 | }
|
---|
| 697 | fprintf(stderr, "\n");
|
---|
| 698 | }
|
---|
| 699 |
|
---|
| 700 | class QMakeCacheClearItem {
|
---|
| 701 | private:
|
---|
| 702 | qmakeCacheClearFunc func;
|
---|
| 703 | void **data;
|
---|
| 704 | public:
|
---|
| 705 | QMakeCacheClearItem(qmakeCacheClearFunc f, void **d) : func(f), data(d) { }
|
---|
| 706 | ~QMakeCacheClearItem() {
|
---|
| 707 | (*func)(*data);
|
---|
| 708 | *data = 0;
|
---|
| 709 | }
|
---|
| 710 | };
|
---|
| 711 | static QList<QMakeCacheClearItem*> cache_items;
|
---|
| 712 |
|
---|
| 713 | void
|
---|
| 714 | qmakeClearCaches()
|
---|
| 715 | {
|
---|
| 716 | qDeleteAll(cache_items);
|
---|
| 717 | cache_items.clear();
|
---|
| 718 | }
|
---|
| 719 |
|
---|
| 720 | void
|
---|
| 721 | qmakeAddCacheClear(qmakeCacheClearFunc func, void **data)
|
---|
| 722 | {
|
---|
| 723 | cache_items.append(new QMakeCacheClearItem(func, data));
|
---|
| 724 | }
|
---|
| 725 |
|
---|
| 726 | #ifdef Q_OS_WIN
|
---|
| 727 | # include <windows.h>
|
---|
| 728 |
|
---|
| 729 | QT_USE_NAMESPACE
|
---|
| 730 | #endif
|
---|
| 731 |
|
---|
[29] | 732 | #ifdef Q_OS_OS2
|
---|
| 733 | # include <qt_os2.h>
|
---|
| 734 |
|
---|
| 735 | QT_USE_NAMESPACE
|
---|
| 736 | #endif
|
---|
| 737 |
|
---|
[2] | 738 | QString qmake_libraryInfoFile()
|
---|
| 739 | {
|
---|
| 740 | QString ret;
|
---|
[29] | 741 | #if defined(Q_OS_WIN)
|
---|
[561] | 742 | wchar_t module_name[MAX_PATH];
|
---|
| 743 | GetModuleFileName(0, module_name, MAX_PATH);
|
---|
| 744 | QFileInfo filePath = QString::fromWCharArray(module_name);
|
---|
[2] | 745 | ret = filePath.filePath();
|
---|
[29] | 746 | #elif defined(Q_OS_OS2)
|
---|
| 747 | QFileInfo filePath;
|
---|
| 748 | static char appFileName[CCHMAXPATH] = "\0";
|
---|
| 749 | if (!appFileName[0]) {
|
---|
| 750 | PPIB ppib;
|
---|
| 751 | DosGetInfoBlocks(NULL, &ppib);
|
---|
| 752 | DosQueryModuleName(ppib->pib_hmte, sizeof(appFileName), appFileName);
|
---|
| 753 | }
|
---|
[548] | 754 | ret = QFileInfo(QString::fromLocal8Bit(appFileName)).absolutePath() +
|
---|
| 755 | QLatin1String("/qt.conf");
|
---|
| 756 | if (!QFile::exists(ret)) {
|
---|
| 757 | // search in the system-wide location
|
---|
| 758 | ret = QString::fromLocal8Bit(qgetenv("ETC"));
|
---|
| 759 | if (ret.isEmpty())
|
---|
| 760 | ret = QDir::rootPath();
|
---|
| 761 | ret = ret + QLatin1String("/qtsys.conf");
|
---|
| 762 | }
|
---|
| 763 | return QDir::cleanPath(ret);
|
---|
[2] | 764 | #else
|
---|
| 765 | QString argv0 = QFile::decodeName(QByteArray(Option::application_argv0));
|
---|
| 766 | QString absPath;
|
---|
| 767 |
|
---|
| 768 | if (!argv0.isEmpty() && argv0.at(0) == QLatin1Char('/')) {
|
---|
| 769 | /*
|
---|
| 770 | If argv0 starts with a slash, it is already an absolute
|
---|
| 771 | file path.
|
---|
| 772 | */
|
---|
| 773 | absPath = argv0;
|
---|
| 774 | } else if (argv0.contains(QLatin1Char('/'))) {
|
---|
| 775 | /*
|
---|
| 776 | If argv0 contains one or more slashes, it is a file path
|
---|
| 777 | relative to the current directory.
|
---|
| 778 | */
|
---|
| 779 | absPath = QDir::current().absoluteFilePath(argv0);
|
---|
| 780 | } else {
|
---|
| 781 | /*
|
---|
| 782 | Otherwise, the file path has to be determined using the
|
---|
| 783 | PATH environment variable.
|
---|
| 784 | */
|
---|
| 785 | QByteArray pEnv = qgetenv("PATH");
|
---|
| 786 | QDir currentDir = QDir::current();
|
---|
| 787 | QStringList paths = QString::fromLocal8Bit(pEnv.constData()).split(QLatin1String(":"));
|
---|
| 788 | for (QStringList::const_iterator p = paths.constBegin(); p != paths.constEnd(); ++p) {
|
---|
| 789 | if ((*p).isEmpty())
|
---|
| 790 | continue;
|
---|
| 791 | QString candidate = currentDir.absoluteFilePath(*p + QLatin1Char('/') + argv0);
|
---|
| 792 | QFileInfo candidate_fi(candidate);
|
---|
| 793 | if (candidate_fi.exists() && !candidate_fi.isDir()) {
|
---|
| 794 | absPath = candidate;
|
---|
| 795 | break;
|
---|
| 796 | }
|
---|
| 797 | }
|
---|
| 798 | }
|
---|
| 799 |
|
---|
| 800 | absPath = QDir::cleanPath(absPath);
|
---|
| 801 |
|
---|
| 802 | QFileInfo fi(absPath);
|
---|
| 803 | ret = fi.exists() ? fi.canonicalFilePath() : QString();
|
---|
| 804 | #endif
|
---|
[548] | 805 | #if !defined(Q_OS_OS2)
|
---|
[2] | 806 | if(!ret.isEmpty())
|
---|
| 807 | ret = QDir(QFileInfo(ret).absolutePath()).filePath("qt.conf");
|
---|
| 808 | return ret;
|
---|
[548] | 809 | #endif
|
---|
[2] | 810 | }
|
---|
| 811 |
|
---|
| 812 | QT_END_NAMESPACE
|
---|