1 files changed, 71 insertions, 30 deletions

diff --git a/qmake/option.cpp b/qmake/option.cpp
index 8b7e5e8..e6928fa 100644
--- a/qmake/option.cpp
+++ b/qmake/option.cpp
@@ -1,22 +1,20 @@
 /****************************************************************************
-** $Id$
+** 
 **
-** Definition of ________ class.
+** Implementation of Option class.
 **
-** Created : 970521
+** Copyright (C) 1992-2003 Trolltech AS.  All rights reserved.
 **
-** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
-**
-** This file is part of the network module of the Qt GUI Toolkit.
+** This file is part of qmake.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition licenses may use this
 ** file in accordance with the Qt Commercial License Agreement provided
@@ -35,33 +33,37 @@
 **
 **********************************************************************/
 
 #include "option.h"
 #include <qdir.h>
 #include <qregexp.h>
 #include <stdlib.h>
 #include <stdarg.h>
 
 //convenience
 QString Option::prf_ext;
 QString Option::prl_ext;
+QString Option::libtool_ext;
+QString Option::pkgcfg_ext;
 QString Option::ui_ext;
 QStringList Option::h_ext;
-QString Option::moc_ext;
+QString Option::cpp_moc_ext;
+QString Option::h_moc_ext;
 QStringList Option::cpp_ext;
 QString Option::obj_ext;
 QString Option::lex_ext;
 QString Option::yacc_ext;
 QString Option::dir_sep;
-QString Option::moc_mod;
+QString Option::h_moc_mod;
+QString Option::cpp_moc_mod;
 QString Option::yacc_mod;
 QString Option::lex_mod;
 
 //mode
 Option::QMAKE_MODE Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;
 
 //all modes
 int Option::warn_level = WarnLogic;
 int Option::debug_level = 0;
 QFile Option::output;
 QString Option::output_dir;
 QStringList Option::before_user_vars;
@@ -71,48 +73,53 @@ QString Option::user_template_prefix;
 #if defined(Q_OS_WIN32)
 Option::TARG_MODE Option::target_mode = Option::TARG_WIN_MODE;
 #elif defined(Q_OS_MAC9)
 Option::TARG_MODE Option::target_mode = Option::TARG_MAC9_MODE;
 #elif defined(Q_OS_MACX)
 Option::TARG_MODE Option::target_mode = Option::TARG_MACX_MODE;
 #elif defined(Q_OS_QNX6)
 Option::TARG_MODE Option::target_mode = Option::TARG_QNX6_MODE;
 #else
 Option::TARG_MODE Option::target_mode = Option::TARG_UNIX_MODE;
 #endif
 
+//QMAKE_*_PROPERTY stuff
+QStringList Option::prop::properties;
+
 //QMAKE_GENERATE_PROJECT stuff
 bool Option::projfile::do_pwd = TRUE;
 bool Option::projfile::do_recursive = TRUE;
 QStringList Option::projfile::project_dirs;
 
 //QMAKE_GENERATE_MAKEFILE stuff
 QString Option::mkfile::qmakespec;
 int Option::mkfile::cachefile_depth = -1;
 bool Option::mkfile::do_deps = TRUE;
 bool Option::mkfile::do_mocs = TRUE;
 bool Option::mkfile::do_dep_heuristics = TRUE;
 bool Option::mkfile::do_preprocess = FALSE;
 bool Option::mkfile::do_cache = TRUE;
 QString Option::mkfile::cachefile;
 QStringList Option::mkfile::project_files;
 QString Option::mkfile::qmakespec_commandline;
 
 static Option::QMAKE_MODE default_mode(QString progname)
 {
     int s = progname.findRev(Option::dir_sep);
     if(s != -1)
         progname = progname.right(progname.length() - (s + 1));
     if(progname == "qmakegen")
         return Option::QMAKE_GENERATE_PROJECT;
+    else if(progname == "qt-config")
+        return Option::QMAKE_QUERY_PROPERTY;
     return Option::QMAKE_GENERATE_MAKEFILE;
 }
 
 QString project_builtin_regx();
 bool usage(const char *a0)
 {
     fprintf(stdout, "Usage: %s [mode] [options] [files]\n"
             "\n"
             "   QMake has two modes, one mode for generating project files based on\n"
             "some heuristics, and the other for generating makefiles. Normally you\n"
             "shouldn't need to specify a mode, as makefile generation is the default\n"
             "mode for qmake, but you may use this to test qmake on an existing project\n"
@@ -152,41 +159,50 @@ bool usage(const char *a0)
             "\t-spec spec     Use spec as QMAKESPEC       [makefile mode only]\n"
             "\t-nocache       Don't use a cache file      [makefile mode only]\n"
             "\t-nodepend      Don't generate dependencies [makefile mode only]\n"
             "\t-nomoc         Don't generate moc targets  [makefile mode only]\n"
             "\t-nopwd         Don't look for files in pwd [ project mode only]\n"
             "\t-norecursive   Don't do a recursive search [ project mode only]\n"
             ,a0, 
             default_mode(a0) == Option::QMAKE_GENERATE_PROJECT  ? " (default)" : "", project_builtin_regx().latin1(),
             default_mode(a0) == Option::QMAKE_GENERATE_MAKEFILE ? " (default)" : "");
     return FALSE;
 }
 
-bool
+enum {
+    QMAKE_CMDLINE_SUCCESS,
+    QMAKE_CMDLINE_SHOW_USAGE,
+    QMAKE_CMDLINE_BAIL
+};
+int
 Option::internalParseCommandLine(int argc, char **argv, int skip)
 {
     bool before = TRUE;
     for(int x = skip; x < argc; x++) {
         if(*argv[x] == '-' && strlen(argv[x]) > 1) { /* options */
             QString opt = argv[x] + 1;
 
             //first param is a mode, or we default
             if(x == 1) {
                 bool specified = TRUE;
                 if(opt == "project") {
                     Option::qmake_mode = Option::QMAKE_GENERATE_PROJECT;
                 } else if(opt == "prl") {
                     Option::mkfile::do_deps = FALSE;
                     Option::mkfile::do_mocs = FALSE;
                     Option::qmake_mode = Option::QMAKE_GENERATE_PRL;
+                } else if(opt == "set") {
+                    Option::qmake_mode = Option::QMAKE_SET_PROPERTY;
+                } else if(opt == "query") {
+                    Option::qmake_mode = Option::QMAKE_QUERY_PROPERTY;
                 } else if(opt == "makefile") {
                     Option::qmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
                 } else {
                     specified = FALSE;
                 }
                 if(specified)
                     continue;
             }
             //all modes
             if(opt == "o" || opt == "output") {
                 Option::output.setName(argv[++x]);
             } else if(opt == "after") {
@@ -199,27 +215,27 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
                 Option::target_mode = TARG_MAC9_MODE;
             } else if(opt == "macx") {
                 Option::target_mode = TARG_MACX_MODE;
             } else if(opt == "unix") {
                 Option::target_mode = TARG_UNIX_MODE;
             } else if(opt == "win32") {
                 Option::target_mode = TARG_WIN_MODE;
             } else if(opt == "d") {
                 Option::debug_level++;
             } else if(opt == "version" || opt == "v" || opt == "-version") {
                 fprintf(stderr, "Qmake version: %s (Qt %s)\n", qmake_version(), QT_VERSION_STR);
                 fprintf(stderr, "Qmake is free software from Trolltech AS.\n");
-                return FALSE;
+                return QMAKE_CMDLINE_BAIL;
             } else if(opt == "h" || opt == "help") {
-                return FALSE;
+                return QMAKE_CMDLINE_SHOW_USAGE;
             } else if(opt == "Wall") {
                 Option::warn_level |= WarnAll;
             } else if(opt == "Wparser") {
                 Option::warn_level |= WarnParser;
             } else if(opt == "Wlogic") {
                 Option::warn_level |= WarnLogic;
             } else if(opt == "Wnone") {
                 Option::warn_level = WarnNone;
             } else {
                 if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
                    Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
                     if(opt == "nodepend") {
@@ -230,73 +246,87 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
                         Option::mkfile::do_cache = FALSE;
                     } else if(opt == "nodependheuristics") {
                         Option::mkfile::do_dep_heuristics = FALSE;
                     } else if(opt == "E") {
                         Option::mkfile::do_preprocess = TRUE;
                     } else if(opt == "cache") {
                         Option::mkfile::cachefile = argv[++x];
                     } else if(opt == "platform" || opt == "spec") {
                         Option::mkfile::qmakespec = argv[++x];
                         Option::mkfile::qmakespec_commandline = argv[x];
                     } else {
                         fprintf(stderr, "***Unknown option -%s\n", opt.latin1());
-                        return usage(argv[0]);
+                        return QMAKE_CMDLINE_SHOW_USAGE;
                     }
                 } else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
                     if(opt == "nopwd") {
                         Option::projfile::do_pwd = FALSE;
                     } else if(opt == "r") {
                         Option::projfile::do_recursive = TRUE;
                     } else if(opt == "norecursive") {
                         Option::projfile::do_recursive = FALSE;
                     } else {
                         fprintf(stderr, "***Unknown option -%s\n", opt.latin1());
-                        return FALSE;
+                        return QMAKE_CMDLINE_SHOW_USAGE;
                     }
                 }
             }
         } else {
             QString arg = argv[x];
             if(arg.find('=') != -1) {
                 if(before)
                     Option::before_user_vars.append(arg);
                 else
                     Option::after_user_vars.append(arg);
             } else {
-                QFileInfo fi(arg);
-                if(!fi.convertToAbs()) //strange
-                    arg = fi.filePath();
-                if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
-                   Option::qmake_mode == Option::QMAKE_GENERATE_PRL)
-                    Option::mkfile::project_files.append(arg);
-                else
-                    Option::projfile::project_dirs.append(arg);
+                bool handled = TRUE;
+                if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY ||
+                    Option::qmake_mode == Option::QMAKE_SET_PROPERTY) {
+                    Option::prop::properties.append(arg);
+                } else {
+                    QFileInfo fi(arg);
+                    if(!fi.convertToAbs()) //strange
+                        arg = fi.filePath();
+                    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
+                       Option::qmake_mode == Option::QMAKE_GENERATE_PRL)
+                        Option::mkfile::project_files.append(arg);
+                    else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
+                        Option::projfile::project_dirs.append(arg);
+                    else 
+                        handled = FALSE;
+                }
+                if(!handled)
+                    return QMAKE_CMDLINE_SHOW_USAGE;
             }
         }
     }
-    return TRUE;
+    return QMAKE_CMDLINE_SUCCESS;
 }
 
 
 bool
 Option::parseCommandLine(int argc, char **argv)
 {
-    Option::moc_mod = "moc_";
+    Option::cpp_moc_mod = "";
+    Option::h_moc_mod = "moc_";
     Option::lex_mod = "_lex";
     Option::yacc_mod = "_yacc";
     Option::prl_ext = ".prl";
+    Option::libtool_ext = ".la";
+    Option::pkgcfg_ext = ".pc";
     Option::prf_ext = ".prf";
     Option::ui_ext = ".ui";
     Option::h_ext << ".h" << ".hpp" << ".hh" << ".H" << ".hxx";
-    Option::moc_ext = ".moc";
+    Option::cpp_moc_ext = ".moc";
+    Option::h_moc_ext = ".cpp";
     Option::cpp_ext << ".cpp" << ".cc" << ".cxx" << ".C";
     Option::lex_ext = ".l";
     Option::yacc_ext = ".y";
 
     if(Option::qmake_mode == Option::QMAKE_GENERATE_NOTHING)
         Option::qmake_mode = default_mode(argv[0]);
     if(const char *envflags = getenv("QMAKEFLAGS")) {
         int env_argc = 0, env_size = 0, currlen=0;
         char quote = 0, **env_argv = NULL;
         for(int i = 0; envflags[i]; i++) {
             if(!quote && (envflags[i] == '\'' || envflags[i] == '"')) {
                 quote = envflags[i];
@@ -325,26 +355,29 @@ Option::parseCommandLine(int argc, char **argv)
         if(env_argv[env_argc]) {
             env_argv[env_argc][currlen] = '\0';
             currlen = 0;
             env_argc++;
         }
         internalParseCommandLine(env_argc, env_argv);
         for(int i2 = 0; i2 < env_size; i2++) {
             if(env_argv[i2])
                 free(env_argv[i2]);
         }
         free(env_argv);
     }
-    if(!internalParseCommandLine(argc, argv, 1))
-        return usage(argv[0]);
+    {
+        int ret = internalParseCommandLine(argc, argv, 1);
+        if(ret != QMAKE_CMDLINE_SUCCESS) 
+            return ret == QMAKE_CMDLINE_SHOW_USAGE ? usage(argv[0]) : FALSE;
+    }
 
     //last chance for defaults
     if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
         Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
         if(Option::mkfile::qmakespec.isNull() || Option::mkfile::qmakespec.isEmpty())
             Option::mkfile::qmakespec = getenv("QMAKESPEC");
 
         //try REALLY hard to do it for them, lazy..
         if(Option::mkfile::project_files.isEmpty()) {
             QString pwd = QDir::currentDirPath(), 
                    proj = pwd + "/" + pwd.right(pwd.length() - (pwd.findRev('/') + 1)) + ".pro";
             if(QFile::exists(proj)) {
@@ -372,40 +405,48 @@ Option::parseCommandLine(int argc, char **argv)
     return TRUE;
 }
 
 bool Option::postProcessProject(QMakeProject *project)
 {
     Option::cpp_ext = project->variables()["QMAKE_EXT_CPP"];
     if(cpp_ext.isEmpty())
         cpp_ext << ".cpp"; //something must be there
     Option::h_ext = project->variables()["QMAKE_EXT_H"];
     if(h_ext.isEmpty())
         h_ext << ".h";
 
+    if(!project->isEmpty("QMAKE_EXT_PKGCONFIG"))
+        Option::pkgcfg_ext = project->first("QMAKE_EXT_PKGCONFIG");
+    if(!project->isEmpty("QMAKE_EXT_LIBTOOL"))
+        Option::libtool_ext = project->first("QMAKE_EXT_LIBTOOL");
     if(!project->isEmpty("QMAKE_EXT_PRL"))
         Option::prl_ext = project->first("QMAKE_EXT_PRL");
     if(!project->isEmpty("QMAKE_EXT_PRF"))
         Option::prf_ext = project->first("QMAKE_EXT_PRF");
     if(!project->isEmpty("QMAKE_EXT_UI"))
         Option::ui_ext = project->first("QMAKE_EXT_UI");
-    if(!project->isEmpty("QMAKE_EXT_MOC"))
-        Option::moc_ext = project->first("QMAKE_EXT_MOC");
+    if(!project->isEmpty("QMAKE_EXT_CPP_MOC"))
+        Option::cpp_moc_ext = project->first("QMAKE_EXT_CPP_MOC");
+    if(!project->isEmpty("QMAKE_EXT_H_MOC"))
+        Option::h_moc_ext = project->first("QMAKE_EXT_H_MOC");
     if(!project->isEmpty("QMAKE_EXT_LEX"))
         Option::lex_ext = project->first("QMAKE_EXT_LEX");
     if(!project->isEmpty("QMAKE_EXT_YACC"))
         Option::yacc_ext = project->first("QMAKE_EXT_YACC");
     if(!project->isEmpty("QMAKE_EXT_OBJ"))
         Option::obj_ext = project->first("QMAKE_EXT_OBJ");
-    if(!project->isEmpty("QMAKE_MOD_MOC"))
-        Option::moc_mod = project->first("QMAKE_MOD_MOC");
+    if(!project->isEmpty("QMAKE_H_MOD_MOC"))
+        Option::h_moc_mod = project->first("QMAKE_H_MOD_MOC");
+    if(!project->isEmpty("QMAKE_CPP_MOD_MOC"))
+        Option::cpp_moc_mod = project->first("QMAKE_CPP_MOD_MOC");
     if(!project->isEmpty("QMAKE_MOD_LEX"))
         Option::lex_mod = project->first("QMAKE_MOD_LEX");
     if(!project->isEmpty("QMAKE_MOD_YACC"))
         Option::yacc_mod = project->first("QMAKE_MOD_YACC");
     if(!project->isEmpty("QMAKE_DIR_SEP"))
         Option::dir_sep = project->first("QMAKE_DIR_SEP");
     return TRUE;
 }
 
 void fixEnvVariables(QString &x)
 {
     int rep;