diff options
Diffstat (limited to 'experimental/tqtinterface/qt4/qmake/generators/makefile.cpp')
| -rw-r--r-- | experimental/tqtinterface/qt4/qmake/generators/makefile.cpp | 2503 |
1 files changed, 2503 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/qmake/generators/makefile.cpp b/experimental/tqtinterface/qt4/qmake/generators/makefile.cpp new file mode 100644 index 000000000..5036889ed --- /dev/null +++ b/experimental/tqtinterface/qt4/qmake/generators/makefile.cpp @@ -0,0 +1,2503 @@ +/**************************************************************************** +** +** Implementation of MakefileGenerator class. +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of qmake. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "makefile.h" +#include "option.h" +#include "meta.h" +#include <tqdir.h> +#include <tqfile.h> +#include <tqtextstream.h> +#include <tqregexp.h> +#include <tqdict.h> +#if defined(TQ_OS_UNIX) +#include <unistd.h> +#else +#include <io.h> +#endif +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> + +// Well, Windows doesn't have this, so here's the macro +#ifndef S_ISDIR +#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) +#endif +#define TQMAKE_EOL(x) (x == '\r' || x == '\n') + +TQString mkdir_p_asstring(const TQString &dir) +{ + TQString ret = "@$(CHK_DIR_EXISTS) \"" + dir + "\" "; + if(Option::target_mode == Option::TARG_WIN_MODE) + ret += "$(MKDIR)"; + else + ret += "|| $(MKDIR)"; + ret += " \"" + dir + "\""; + return ret; +} + +static bool createDir(const TQString& fullPath) +{ + if(TQFile::exists(fullPath)) + return FALSE; + TQDir dirTmp; + bool ret = TRUE; + TQString pathComponent, tmpPath; + TQStringList hierarchy = TQStringList::split(TQString(Option::dir_sep), fullPath, TRUE); + for(TQStringList::Iterator it = hierarchy.begin(); it != hierarchy.end(); ++it) { + pathComponent = *it + TQDir::separator(); + tmpPath += pathComponent; + if(!dirTmp.mkdir(tmpPath)) { + ret = FALSE; +// break; + } + } + return ret; +} + + +MakefileGenerator::MakefileGenerator(TQMakeProject *p) : init_opath_already(FALSE), + init_already(FALSE), tqmoc_aware(FALSE), + no_io(FALSE), project(p) +{ +} + +static char *gimme_buffer(off_t s) +{ + static char *big_buffer = NULL; + static int big_buffer_size = 0; + if(!big_buffer || big_buffer_size < s) + big_buffer = (char *)realloc(big_buffer, s); + return big_buffer; +} + +bool +MakefileGenerator::generateMocList(const TQString &fn_target) +{ + if(!tqfindMocDestination(fn_target).isEmpty()) + return TRUE; + + TQString fn_local = Option::fixPathToLocalOS(fileFixify(fn_target, TQDir::currentDirPath(), Option::output_dir)); + + int file = open(fn_local.latin1(), O_RDONLY); + if(file == -1) + return FALSE; + + struct stat fst; + if(fstat(file, &fst) || S_ISDIR(fst.st_mode)) + return FALSE; //shouldn't happen + char *big_buffer = gimme_buffer(fst.st_size); + + int total_size_read; + for(int have_read = total_size_read = 0; + (have_read = read(file, big_buffer + total_size_read, + fst.st_size - total_size_read)); + total_size_read += have_read); + close(file); + + bool ignore_qobject = FALSE; + int line_count = 1; + /* qmake ignore TQ_OBJECT */ +#define COMP_LEN 9 //strlen("TQ_OBJECT") +#define OBJ_LEN 9 //strlen("TQ_OBJECT") +#define DIS_LEN 11 //strlen("TQ_DISPATCH") + int x; + for(x = 0; x < (total_size_read-COMP_LEN); x++) { + if(*(big_buffer + x) == '/') { + x++; + if(total_size_read >= x) { + if(*(big_buffer + x) == '/') { //c++ style comment + for( ;x < total_size_read && !TQMAKE_EOL(*(big_buffer + x)); x++); + line_count++; + } else if(*(big_buffer + x) == '*') { //c style comment + for( ;x < total_size_read; x++) { + if(*(big_buffer + x) == 't' || *(big_buffer + x) == 'q') { //ignore + if(total_size_read >= (x + 20)) { + if(!strncmp(big_buffer + x + 1, "make ignore TQ_OBJECT", 20)) { + debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore TQ_OBJECT\"", + fn_target.latin1(), line_count); + x += 20; + ignore_qobject = TRUE; + } + } + } else if(*(big_buffer + x) == '*') { + if(total_size_read >= (x+1) && *(big_buffer + (x+1)) == '/') { + x += 2; + break; + } + } else if(TQMAKE_EOL(*(big_buffer + x))) { + line_count++; + } + } + } + } + } +#define SYMBOL_CHAR(x) ((x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z') || \ + (x <= '0' && x >= '9') || x == '_') + + bool interesting = *(big_buffer+x) == 'T' && (!strncmp(big_buffer+x, "TQ_OBJECT", OBJ_LEN) || + !strncmp(big_buffer+x, "TQ_DISPATCH", DIS_LEN)); + if(interesting) { + int len = 0; + if(!strncmp(big_buffer+x, "TQ_OBJECT", OBJ_LEN)) { + if(ignore_qobject) { + debug_msg(2, "Mocgen: %s:%d Ignoring TQ_OBJECT", fn_target.latin1(), line_count); + interesting = FALSE; + } + len=OBJ_LEN; + } else if(!strncmp(big_buffer+x, "TQ_DISPATCH", DIS_LEN)) { + len=DIS_LEN; + } + if(SYMBOL_CHAR(*(big_buffer+x+len))) + interesting = FALSE; + if(interesting) { + *(big_buffer+x+len) = '\0'; + debug_msg(2, "Mocgen: %s:%d Found TQMOC symbol %s", fn_target.latin1(), + line_count, big_buffer+x); + + int ext_pos = fn_target.tqfindRev('.'); + int ext_len = fn_target.length() - ext_pos; + int dir_pos = fn_target.tqfindRev(Option::dir_sep, ext_pos); + TQString tqmocFile; + if(!project->isEmpty("TQMOC_DIR")) + tqmocFile = project->first("TQMOC_DIR"); + else if(dir_pos != -1) + tqmocFile = fn_target.left(dir_pos+1); + + bool cpp_ext = FALSE; + for(TQStringList::Iterator cppit = Option::cpp_ext.begin(); + cppit != Option::cpp_ext.end(); ++cppit) { + if((cpp_ext = (fn_target.right(ext_len) == (*cppit)))) + break; + } + if(cpp_ext) { + tqmocFile += Option::cpp_tqmoc_mod + fn_target.mid(dir_pos+1, ext_pos - dir_pos-1) + Option::cpp_tqmoc_ext; + project->variables()["_SRCTQMOC"].append(tqmocFile); + } else if(project->variables()["HEADERS"].tqfindIndex(fn_target) != -1) { + for(TQStringList::Iterator hit = Option::h_ext.begin(); + hit != Option::h_ext.end(); ++hit) { + if((fn_target.right(ext_len) == (*hit))) { + tqmocFile += Option::h_tqmoc_mod + fn_target.mid(dir_pos+1, ext_pos - dir_pos-1) + + Option::h_tqmoc_ext; + logicWarn(tqmocFile, "SOURCES"); + project->variables()["_HDRTQMOC"].append(tqmocFile); + break; + } + } + } + + if(!tqmocFile.isEmpty()) { + tqmocFile = Option::fixPathToTargetOS(tqmocFile); + tqmocablesToTQMOC[cleanFilePath(fn_target)] = tqmocFile; + tqmocablesFromTQMOC[cleanFilePath(tqmocFile)] = fn_target; + } + break; + } + } + + while(x < total_size_read && SYMBOL_CHAR(*(big_buffer+x))) + x++; + if(TQMAKE_EOL(*(big_buffer+x))) + line_count++; + } +#undef OBJ_LEN +#undef DIS_LEN + return TRUE; +} + +bool +MakefileGenerator::generateDependencies(TQPtrList<MakefileDependDir> &dirs, const TQString &f, bool recurse) +{ + if(processedDependencies(f)) + return TRUE; + setProcessedDependencies(f, TRUE); + + TQStringList &fndeps = tqfindDependencies(f); + TQString fn = fileFixify(f, TQDir::currentDirPath(), Option::output_dir); + fn = Option::fixPathToLocalOS(fn, FALSE); + TQString fix_env_fn = Option::fixPathToLocalOS(fn); + int file = open(fix_env_fn.latin1(), O_RDONLY); + if(file == -1) + return FALSE; + struct stat fst; + if(fstat(file, &fst) || S_ISDIR(fst.st_mode)) + return FALSE; //shouldn't happen + + TQString fndir, fix_env_fndir; + int dl = fn.tqfindRev(Option::dir_sep); + if(dl != -1) + fndir = fn.left(dl+1); + dl = fix_env_fn.tqfindRev(Option::dir_sep); + if(dl != -1) + fix_env_fndir = fix_env_fn.left(dl + 1); + + int line_count = 1; + char *big_buffer = gimme_buffer(fst.st_size); + + int total_size_read; + for(int have_read = total_size_read = 0; + (have_read = read(file, big_buffer + total_size_read, + fst.st_size - total_size_read)); + total_size_read += have_read); + close(file); + + bool ui_file = fn.endsWith(Option::ui_ext); + for(int x = 0; x < total_size_read; x++) { + TQStringList *outdeps=&fndeps; + TQString inc; + if(!ui_file) { + if(*(big_buffer + x) == '/') { + x++; + if(total_size_read >= x) { + if(*(big_buffer + x) == '/') { //c++ style comment + for( ; x < total_size_read && !TQMAKE_EOL(*(big_buffer + x)); x++); + } else if(*(big_buffer + x) == '*') { //c style comment + for( ; x < total_size_read; x++) { + if(*(big_buffer + x) == '*') { + if(total_size_read >= (x+1) && *(big_buffer + (x+1)) == '/') { + x += 2; + break; + } + } else if(TQMAKE_EOL(*(big_buffer + x))) { + line_count++; + } + } + } + } + } + while(x < total_size_read && //Skip spaces + (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t')) + x++; + if(*(big_buffer + x) == '#') { + x++; + while(x < total_size_read && //Skip spaces after hash + (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t')) + x++; + if(total_size_read >= x + 8 && !strncmp(big_buffer + x, "include", 7) && + (*(big_buffer + x + 7) == ' ' || *(big_buffer + x + 7) == '\t' || + *(big_buffer + x + 7) == '<' || *(big_buffer + x + 7) == '"')) { + for(x+=7; //skip spaces after keyword + x < total_size_read && (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t'); + x++); + char term = *(big_buffer + x); + if(term == '"'); + else if(term == '<') + term = '>'; + else + continue; //wtf? + x++; + + int inc_len; + for(inc_len = 0; *(big_buffer + x + inc_len) != term && + !TQMAKE_EOL(*(big_buffer + x + inc_len)); inc_len++); + *(big_buffer + x + inc_len) = '\0'; + inc = big_buffer + x; + } else if(total_size_read >= x + 14 && !strncmp(big_buffer + x, "qmake_warning ", 14)) { + for(x+=14; //skip spaces after keyword + x < total_size_read && (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t'); + x++); + char term = 0; + if(*(big_buffer + x) == '"') + term = '"'; + if(*(big_buffer + x) == '\'') + term = '\''; + if(term) + x++; + + int msg_len; + for(msg_len = 0; (term && *(big_buffer + x + msg_len) != term) && + !TQMAKE_EOL(*(big_buffer + x + msg_len)); msg_len++); + const char saved_term = *(big_buffer + x + msg_len); + *(big_buffer + x + msg_len) = '\0'; + TQString msg = big_buffer + x; + debug_msg(0, "%s:%d qmake_warning -- %s", fix_env_fn.latin1(), + line_count, msg.latin1()); + *(big_buffer + x + msg_len) = saved_term; //put it back + } + } + } else if(ui_file) { + // skip whitespaces + while(x < total_size_read && + (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t')) + x++; + if(*(big_buffer + x) == '<') { + x++; + if(total_size_read >= x + 12 && !strncmp(big_buffer + x, "includehint", 11) && + (*(big_buffer + x + 11) == ' ' || *(big_buffer + x + 11) == '>')) { + for(x += 11; *(big_buffer + x) != '>'; x++); + int inc_len = 0; + for(x += 1 ; *(big_buffer + x + inc_len) != '<'; inc_len++); + *(big_buffer + x + inc_len) = '\0'; + inc = big_buffer + x; + } else if(total_size_read >= x + 13 && !strncmp(big_buffer + x, "customwidget", 12) && + (*(big_buffer + x + 12) == ' ' || *(big_buffer + x + 12) == '>')) { + for(x += 13; *(big_buffer + x) != '>'; x++); //skip up to > + while(x < total_size_read) { + for(x++; *(big_buffer + x) != '<'; x++); //skip up to < + x++; + if(total_size_read >= x + 7 && !strncmp(big_buffer+x, "header", 6) && + (*(big_buffer + x + 6) == ' ' || *(big_buffer + x + 6) == '>')) { + for(x += 7; *(big_buffer + x) != '>'; x++); //skip up to > + int inc_len = 0; + for(x += 1 ; *(big_buffer + x + inc_len) != '<'; inc_len++); + *(big_buffer + x + inc_len) = '\0'; + inc = big_buffer + x; + break; + } else if(total_size_read >= x + 14 && !strncmp(big_buffer+x, "/customwidget", 13) && + (*(big_buffer + x + 13) == ' ' || *(big_buffer + x + 13) == '>')) { + x += 14; + break; + } + } + } else if(total_size_read >= x + 8 && !strncmp(big_buffer + x, "include", 7) && + (*(big_buffer + x + 7) == ' ' || *(big_buffer + x + 7) == '>')) { + for(x += 8; *(big_buffer + x) != '>'; x++) { + if(total_size_read >= x + 9 && *(big_buffer + x) == 'i' && + !strncmp(big_buffer + x, "impldecl", 8)) { + for(x += 8; *(big_buffer + x) != '='; x++); + if(*(big_buffer + x) != '=') + continue; + for(x++; *(big_buffer+x) == '\t' || *(big_buffer+x) == ' '; x++); + char quote = 0; + if(*(big_buffer+x) == '\'' || *(big_buffer+x) == '"') { + quote = *(big_buffer + x); + x++; + } + int val_len; + for(val_len = 0; TRUE; val_len++) { + if(quote) { + if(*(big_buffer+x+val_len) == quote) + break; + } else if(*(big_buffer + x + val_len) == '>' || + *(big_buffer + x + val_len) == ' ') { + break; + } + } + char saved = *(big_buffer + x + val_len); + *(big_buffer + x + val_len) = '\0'; + TQString where = big_buffer + x; + *(big_buffer + x + val_len) = saved; + if(where == "in implementation") { + TQString cpp = fn.left(fn.length() - Option::ui_ext.length()) + + Option::cpp_ext.first(); + outdeps = &tqfindDependencies(cpp); + } + } + } + int inc_len = 0; + for(x += 1 ; *(big_buffer + x + inc_len) != '<'; inc_len++); + *(big_buffer + x + inc_len) = '\0'; + inc = big_buffer + x; + } + } + } + + if(!inc.isEmpty()) { + bool from_source_dir = TRUE; + debug_msg(5, "%s:%d Found dependency to %s", fix_env_fn.latin1(), + line_count, inc.latin1()); + if(!project->isEmpty("SKIP_DEPENDS")) { + bool found = FALSE; + TQStringList &nodeplist = project->values("SKIP_DEPENDS"); + for(TQStringList::Iterator it = nodeplist.begin(); + it != nodeplist.end(); ++it) { + TQRegExp regx((*it)); + if(regx.search(inc) != -1) { + found = TRUE; + break; + } + } + if(found) + continue; + } + TQString fqn; + if(project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH") && + !stat(TQString(fix_env_fndir + inc), &fst) && !S_ISDIR(fst.st_mode)) { + fqn = fndir + inc; + goto handle_fqn; + } else if(project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH") && + !stat(inc, &fst) && !S_ISDIR(fst.st_mode)) { + fqn = inc; + goto handle_fqn; + } else { + if((Option::target_mode == Option::TARG_MAC9_MODE && inc.tqfind(':')) || + (Option::target_mode == Option::TARG_WIN_MODE && inc[1] != ':') || + ((Option::target_mode == Option::TARG_UNIX_MODE || + Option::target_mode == Option::TARG_TQNX6_MODE || + Option::target_mode == Option::TARG_MACX_MODE) && + inc[0] != '/')) { + for(MakefileDependDir *mdd = dirs.first(); mdd; mdd = dirs.next() ) { + if(!stat(TQString(mdd->local_dir + TQDir::separator() + inc), &fst) && + !S_ISDIR(fst.st_mode)) { + fqn = mdd->real_dir + TQDir::separator() + inc; + goto handle_fqn; + } + } + } + } + if(fqn.isEmpty() && Option::mkfile::do_dep_heuristics) { + //these are some hacky heuristics it will try to do on an include + //however these can be turned off at runtime, I'm not sure how + //reliable these will be, most likely when problems arise turn it off + //and see if they go away.. + if(depHeuristics.tqcontains(inc)) { + fqn = depHeuristics[inc]; + from_source_dir = FALSE; + } else if(Option::mkfile::do_dep_heuristics) { //some heuristics.. + //is it a file from a .ui? + TQString inc_file = inc.section(Option::dir_sep, -1); + int extn = inc_file.tqfindRev('.'); + if(extn != -1 && + (inc_file.right(inc_file.length()-extn) == Option::cpp_ext.first() || + inc_file.right(inc_file.length()-extn) == Option::h_ext.first())) { + TQString uip = inc_file.left(extn) + Option::ui_ext; + TQStringList uil = project->variables()["FORMS"]; + for(TQStringList::Iterator it = uil.begin(); it != uil.end(); ++it) { + if((*it).section(Option::dir_sep, -1) == uip) { + if(!project->isEmpty("UI_DIR")) + fqn = project->first("UI_DIR"); + else if(!project->isEmpty("UI_HEADERS_DIR")) + fqn = project->first("UI_HEADERS_DIR"); + else + fqn = (*it).section(Option::dir_sep, 0, -2); + if(!fqn.isEmpty() && !fqn.endsWith(Option::dir_sep)) + fqn += Option::dir_sep; + fqn += inc_file; + from_source_dir = FALSE; //uics go in the output_dir (so don't fix them) + fqn = fileFixify(fqn, TQDir::currentDirPath(), Option::output_dir); + goto cache_fqn; + } + } + } + if(project->isActiveConfig("lex_included")) { //is this the lex file? + TQString rhs = Option::lex_mod + Option::cpp_ext.first(); + if(inc.endsWith(rhs)) { + TQString lhs = inc.left(inc.length() - rhs.length()) + Option::lex_ext; + TQStringList ll = project->variables()["LEXSOURCES"]; + for(TQStringList::Iterator it = ll.begin(); it != ll.end(); ++it) { + TQString s = (*it), d; + int slsh = s.tqfindRev(Option::dir_sep); + if(slsh != -1) { + d = s.left(slsh + 1); + s = s.right(s.length() - slsh - 1); + } + if(!project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH")) + d = project->first("TQMAKE_ABSOLUTE_SOURCE_PATH"); + if(s == lhs) { + fqn = d + inc; + from_source_dir = FALSE; //uics go in the output_dir (so don't fix them) + fqn = fileFixify(fqn, TQDir::currentDirPath(), Option::output_dir); + goto cache_fqn; + } + } + } + } + { //is it from a .y? + TQString rhs = Option::yacc_mod + Option::h_ext.first(); + if(inc.endsWith(rhs)) { + TQString lhs = inc.left(inc.length() - rhs.length()) + Option::yacc_ext; + TQStringList yl = project->variables()["YACCSOURCES"]; + for(TQStringList::Iterator it = yl.begin(); it != yl.end(); ++it) { + TQString s = (*it), d; + int slsh = s.tqfindRev(Option::dir_sep); + if(slsh != -1) { + d = s.left(slsh + 1); + s = s.right(s.length() - slsh - 1); + } + if(!project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH")) + d = project->first("TQMAKE_ABSOLUTE_SOURCE_PATH"); + if(s == lhs) { + fqn = d + inc; + from_source_dir = FALSE; //uics go in the output_dir (so don't fix them) + fqn = fileFixify(fqn, TQDir::currentDirPath(), Option::output_dir); + goto cache_fqn; + } + } + } + } + if( tqmocAware() && //is it a tqmoc file? + ( inc.endsWith(Option::cpp_ext.first()) || inc.endsWith(Option::cpp_tqmoc_ext) ) + || ( (Option::cpp_ext.first() != Option::h_tqmoc_ext) && inc.endsWith(Option::h_tqmoc_ext) )) { + TQString tqmocs[] = { TQString("_HDRTQMOC"), TQString("_SRCTQMOC"), TQString::null }; + for(int tqmoc = 0; !tqmocs[tqmoc].isNull(); tqmoc++) { + TQStringList &l = project->variables()[tqmocs[tqmoc]]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString file = Option::fixPathToTargetOS((*it)); + if(file.section(Option::dir_sep, -(inc.tqcontains('/')+1)) == inc) { + fqn = (*it); + if(tqmocs[tqmoc] == "_HDRTQMOC") { + //Since it is include, no need to link it in as well + project->variables()["_SRCTQMOC"].append((*it)); + l.remove(it); + } else if(!tqfindMocSource(fqn).endsWith(fileFixify(fn))) { + /* Not really a very good test, but this will at least avoid + confusion if it really does happen (since tmake/qmake + previously didn't even allow this the test is mostly accurate) */ + warn_msg(WarnLogic, + "Found potential multiple TQMOC include %s (%s) in '%s'", + inc.latin1(), fqn.latin1(), fix_env_fn.latin1()); + } + from_source_dir = FALSE; //tqmocs go in the output_dir (so don't fix them) + goto cache_fqn; + } + } + } + } + fqn = tqfindDependency(inc); //all else fails.. + cache_fqn: + if(from_source_dir) { + fqn = fileFixify(fqn); + from_source_dir = FALSE; + } + depHeuristics.insert(inc, fqn); + } + } + handle_fqn: + if(fqn.isEmpty()) //I give up + continue; + fqn = Option::fixPathToTargetOS(fqn, FALSE); + if(from_source_dir) + fqn = fileFixify(fqn); + debug_msg(4, "Resolved dependency of %s to %s", inc.latin1(), fqn.latin1()); + if(outdeps && outdeps->tqfindIndex(fqn) == -1) + outdeps->append(fqn); + } + //read past new line now.. + for( ; x < total_size_read && !TQMAKE_EOL(*(big_buffer + x)); x++); + line_count++; + } + + if(recurse) { + for(TQStringList::Iterator fnit = fndeps.begin(); fnit != fndeps.end(); ++fnit) { + generateDependencies(dirs, (*fnit), recurse); + TQStringList &deplist = tqfindDependencies((*fnit)); + for(TQStringList::Iterator it = deplist.begin(); it != deplist.end(); ++it) + if(fndeps.tqfindIndex((*it)) == -1 && (*it) != fn) + fndeps.append((*it)); + } + } + debug_msg(2, "Dependencies: %s -> %s", fn.latin1(), fndeps.join(" :: ").latin1()); + return TRUE; +} + +void +MakefileGenerator::initOutPaths() +{ + if(init_opath_already) + return; + init_opath_already = TRUE; + TQMap<TQString, TQStringList> &v = project->variables(); + if(!v.tqcontains("TQMAKE_ABSOLUTE_SOURCE_PATH")) { + if(Option::mkfile::do_cache && !Option::mkfile::cachefile.isEmpty() && + v.tqcontains("TQMAKE_ABSOLUTE_SOURCE_ROOT")) { + TQString root = v["TQMAKE_ABSOLUTE_SOURCE_ROOT"].first(); + root = Option::fixPathToTargetOS( root ); + if(!root.isEmpty()) { + TQFileInfo fi(Option::mkfile::cachefile); + if(!fi.convertToAbs()) { + TQString cache_r = fi.dirPath(), pwd = Option::output_dir; + if ( pwd.startsWith(cache_r) && !pwd.startsWith(root) ) { + pwd = Option::fixPathToTargetOS(root + pwd.mid(cache_r.length())); + if(TQFile::exists(pwd)) + v.insert("TQMAKE_ABSOLUTE_SOURCE_PATH", pwd); + } + } + } + } + } + if(!v["TQMAKE_ABSOLUTE_SOURCE_PATH"].isEmpty()) { + TQString &asp = v["TQMAKE_ABSOLUTE_SOURCE_PATH"].first(); + asp = Option::fixPathToTargetOS( asp ); + if(asp.isEmpty() || asp == Option::output_dir) //if they're the same, why bother? + v["TQMAKE_ABSOLUTE_SOURCE_PATH"].clear(); + } + TQString currentDir = TQDir::currentDirPath(); + TQString dirs[] = { TQString("OBJECTS_DIR"), TQString("TQMOC_DIR"), TQString("UI_HEADERS_DIR"), + TQString("UI_SOURCES_DIR"), TQString("UI_DIR"), TQString("DESTDIR"), + TQString("SUBLIBS_DIR"), TQString("DLLDESTDIR"), TQString::null }; + for(int x = 0; dirs[x] != TQString::null; x++) { + if ( !v[dirs[x]].isEmpty() ) { + TQString orig_path = v[dirs[x]].first(); +#ifdef TQ_WS_WIN + // We don't want to add a separator for DLLDESTDIR on Windows + if (!(dirs[x] == "DLLDESTDIR")) +#endif + { + TQString &path = v[dirs[x]].first(); + path = fileFixify(path, Option::output_dir, Option::output_dir); + if(path.right(Option::dir_sep.length()) != Option::dir_sep) + path += Option::dir_sep; + } + if(noIO()) + continue; + + TQString path = project->first(dirs[x]); //not to be changed any further + path = Option::fixPathToTargetOS(fileFixify(path, TQDir::currentDirPath(), Option::output_dir)); + debug_msg(3, "Fixed output_dir %s (%s) into %s (%s)", dirs[x].latin1(), orig_path.latin1(), + v[dirs[x]].join("::").latin1(), path.latin1()); + + TQDir d; + if(path.startsWith(Option::dir_sep)) { + d.cd(Option::dir_sep); + path = path.right(path.length() - 1); + } +#ifdef TQ_WS_WIN + bool driveExists = TRUE; + if ( !TQDir::isRelativePath( path ) ) { + if ( TQFile::exists( path.left( 3 ) ) ) { + d.cd( path.left( 3 ) ); + path = path.right( path.length() - 3 ); + } else { + warn_msg(WarnLogic, "%s: Cannot access drive '%s' (%s)", dirs[x].latin1(), + path.left( 3 ).latin1(), path.latin1() ); + driveExists = FALSE; + } + } + if ( driveExists ) { +#endif + TQStringList subs = TQStringList::split(Option::dir_sep, path); + for(TQStringList::Iterator subit = subs.begin(); subit != subs.end(); ++subit) { + if(!d.cd(*subit)) { + d.mkdir((*subit)); + if ( d.exists( (*subit) ) ) + d.cd((*subit)); + else { + warn_msg(WarnLogic, "%s: Cannot access directory '%s' (%s)", dirs[x].latin1(), + (*subit).latin1(), path.latin1() ); + break; + } + } + } +#ifdef TQ_WS_WIN + } +#endif + } + } + if ( !v["DESTDIR"].isEmpty() ) { + TQDir d(v["DESTDIR"].first()); + if(Option::fixPathToLocalOS(d.absPath()) == Option::fixPathToLocalOS(Option::output_dir)) + v.remove("DESTDIR"); + } + TQDir::current().cd( currentDir ); +} + +void +MakefileGenerator::init() +{ + initOutPaths(); + if(init_already) + return; + init_already = TRUE; + + TQMap<TQString, TQStringList> &v = project->variables(); + TQString paths[] = { TQString("SOURCES"), TQString("FORMS"), TQString("YACCSOURCES"), TQString("INCLUDEPATH"), + TQString("HEADERS"), TQString("HEADERS_ORIG"), TQString("LEXSOURCES"), + TQString("TQMAKE_INTERNAL_INCLUDED_FILES"), + TQString("PRECOMPILED_HEADER"), TQString::null }; + for(int y = 0; paths[y] != TQString::null; y++) { + TQStringList &l = v[paths[y]]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + if ((*it).isEmpty()) + continue; + if(TQFile::exists((*it))) + (*it) = fileFixify((*it)); + } + } + + /* get deps and tqmocables */ + TQDict<void> cache_found_files; + TQString cache_file(".qmake.internal.cache"); + if(!project->isEmpty("TQMAKE_INTERNAL_CACHE_FILE")) + cache_file = Option::fixPathToLocalOS(project->first("TQMAKE_INTERNAL_CACHE_FILE")); + if(cache_file.tqfind(TQDir::separator()) == -1) //guess they know what they are doing.. + cache_file.prepend(Option::output_dir + TQDir::separator()); + if((Option::qmake_mode == Option::TQMAKE_GENERATE_PROJECT || + Option::mkfile::do_deps || Option::mkfile::do_tqmocs) && !noIO()) { + TQPtrList<MakefileDependDir> deplist; + deplist.setAutoDelete(TRUE); + if((Option::qmake_mode == Option::TQMAKE_GENERATE_PROJECT || Option::mkfile::do_deps) && + doDepends()) { + TQStringList incDirs = v["DEPENDPATH"] + v["TQMAKE_ABSOLUTE_SOURCE_PATH"]; + if(project->isActiveConfig("depend_includepath")) + incDirs += v["INCLUDEPATH"]; + for(TQStringList::Iterator it = incDirs.begin(); it != incDirs.end(); ++it) { + TQString r = (*it), l = Option::fixPathToLocalOS((*it)); + deplist.append(new MakefileDependDir(r.tqreplace("\"",""), + l.tqreplace("\"",""))); + } + debug_msg(1, "Dependency Directories: %s", incDirs.join(" :: ").latin1()); + if(Option::output.name() != "-" && project->isActiveConfig("qmake_cache")) { + TQFile cachef(cache_file); + if(cachef.open(IO_ReadOnly | IO_Translate)) { + TQFileInfo cachefi(cache_file); + debug_msg(2, "Trying internal cache information: %s", cache_file.latin1()); + TQTextStream cachet( TQT_TQIODEVICE(&cachef) ); + TQString line, file; + enum { CacheInfo, CacheDepend, CacheMoc } state = CacheInfo; + while (!cachet.eof()) { + line = cachet.readLine().stripWhiteSpace(); + int sep = line.tqfind('='); + if(line == "[depend]") { + state = CacheDepend; + } else if(line == "[tqmocable]") { + state = CacheMoc; + } else if(line == "[check]") { + state = CacheInfo; + } else if(!line.isEmpty() && sep != -1) { + file = TQT_TQSTRING(line.left(sep)).stripWhiteSpace(); + line = TQT_TQSTRING(line.right(line.length() - sep - 1)).stripWhiteSpace(); + if(state == CacheInfo) { + if(file == "TQMAKE_CACHE_VERSION") { + if(line != qmake_version()) + break; + } else { + const TQStringList &l = project->variables()[file]; + if(!l.isEmpty() && !line.isEmpty() && l.join(" ") != line) + break; + } + } else if(state == CacheDepend) { + bool found = (bool)cache_found_files[file]; + TQStringList files = TQStringList::split(" ", line); + if(!found) { + TQFileInfo fi(fileFixify(file, TQDir::currentDirPath(), Option::output_dir)); + if(fi.exists() && fi.lastModified() < cachefi.lastModified()) { + cache_found_files.insert(file, (void *)1); + found = TRUE; + } + } + if(found) { + for(TQStringList::Iterator dep_it = files.begin(); + dep_it != files.end(); ++dep_it) { + if(!cache_found_files[(*dep_it)]) { + TQFileInfo fi(fileFixify((*dep_it), TQDir::currentDirPath(), Option::output_dir)); + if(fi.exists() && + fi.lastModified() < cachefi.lastModified()) { + cache_found_files.insert((*dep_it), (void *)1); + } else { + found = FALSE; + break; + } + } + } + if(found) { + debug_msg(2, "Dependencies (cached): %s -> %s", file.latin1(), + files.join(" :: ").latin1()); + tqfindDependencies(file) = files; + setProcessedDependencies(file, TRUE); + } + } + } else { + void *found = cache_found_files[file]; + if(found != (void *)2) { + if(found) { + cache_found_files.tqreplace(file, (void *)2); + } else { + TQFileInfo fi(fileFixify(file, TQDir::currentDirPath(), Option::output_dir)); + if(fi.exists() && fi.lastModified() < cachefi.lastModified()) { + cache_found_files.insert(file, (void *)2); + found = (void*)1; + } + } + } + if(found && line != "*qmake_ignore*") { + int ext_len = file.length() - file.tqfindRev('.'); + bool cpp_ext = FALSE; + for(TQStringList::Iterator cppit = Option::cpp_ext.begin(); + cppit != Option::cpp_ext.end(); ++cppit) { + if((cpp_ext = (file.right(ext_len) == (*cppit)))) + break; + } + if(cpp_ext) { + project->variables()["_SRCTQMOC"].append(line); + } else if(project->variables()["HEADERS"].tqfindIndex(file) != -1) { + for(TQStringList::Iterator hit = Option::h_ext.begin(); + hit != Option::h_ext.end(); ++hit) { + if((file.right(ext_len) == (*hit))) { + project->variables()["_HDRTQMOC"].append(line); + break; + } + } + } + debug_msg(2, "Mocgen (cached): %s -> %s", file.latin1(), + line.latin1()); + tqmocablesToTQMOC[file] = line; + tqmocablesFromTQMOC[line] = file; + } + } + } + } + cachef.close(); + } + } + } + if(!noIO()) { + TQString sources[] = { TQString("OBJECTS"), TQString("LEXSOURCES"), TQString("YACCSOURCES"), + TQString("HEADERS"), TQString("SOURCES"), TQString("FORMS"), + TQString("PRECOMPILED_HEADER"), TQString::null }; + depHeuristics.clear(); + bool write_cache = FALSE, read_cache = TQFile::exists(cache_file); + int x; + for(x = 0; sources[x] != TQString::null; x++) { + TQStringList vpath, &l = v[sources[x]]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + if(!(*val_it).isEmpty()) { + TQString file = fileFixify((*val_it), TQDir::currentDirPath(), Option::output_dir); + if(!TQFile::exists(file)) { + bool found = FALSE; + if(TQDir::isRelativePath((*val_it))) { + if(vpath.isEmpty()) + vpath = v["VPATH_" + sources[x]] + v["VPATH"] + + v["TQMAKE_ABSOLUTE_SOURCE_PATH"] + v["DEPENDPATH"]; + + for(TQStringList::Iterator vpath_it = vpath.begin(); + vpath_it != vpath.end(); ++vpath_it) { + TQString real_dir = Option::fixPathToLocalOS((*vpath_it)); + if(TQFile::exists(real_dir + TQDir::separator() + (*val_it))) { + TQString dir = (*vpath_it); + if(dir.right(Option::dir_sep.length()) != Option::dir_sep) + dir += Option::dir_sep; + (*val_it) = fileFixify(dir + (*val_it)); + found = TRUE; + debug_msg(1, "Found file through vpath %s -> %s", + file.latin1(), (*val_it).latin1()); + break; + } + } + } + if(!found) { + TQString dir, regex = (*val_it), real_dir; + if(regex.tqfindRev(Option::dir_sep) != -1) { + dir = regex.left(regex.tqfindRev(Option::dir_sep) + 1); + real_dir = fileFixify(Option::fixPathToLocalOS(dir), + TQDir::currentDirPath(), Option::output_dir); + regex = regex.right(regex.length() - dir.length()); + } + if(real_dir.isEmpty() || TQFile::exists(real_dir)) { + TQDir d(real_dir, regex); + if(!d.count()) { + debug_msg(1, "%s:%d Failure to tqfind %s in vpath (%s)", + __FILE__, __LINE__, + (*val_it).latin1(), vpath.join("::").latin1()); + warn_msg(WarnLogic, "Failure to tqfind: %s", (*val_it).latin1()); + continue; + } else { + for(int i = 0; i < (int)d.count(); i++) { + TQString file = fileFixify(dir + d[i]); + if(i == (int)d.count() - 1) + (*val_it) = file; + else + l.insert(val_it, file); + } + } + } else { + debug_msg(1, "%s:%d Cannot match %s%c%s, as %s does not exist.", + __FILE__, __LINE__, + real_dir.latin1(), TQDir::separator(), regex.latin1(), + real_dir.latin1()); + warn_msg(WarnLogic, "Failure to tqfind: %s", (*val_it).latin1()); + } + } + } + } + } + } + for(x = 0; sources[x] != TQString::null; x++) { + TQStringList &l = v[sources[x]]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + bool found_cache_tqmoc = FALSE, found_cache_dep = FALSE; + if(read_cache && Option::output.name() != "-" && + project->isActiveConfig("qmake_cache")) { + if(processedDependencies((*val_it))) + found_cache_dep = TRUE; + if(cache_found_files[(*val_it)] == (void *)2) + found_cache_tqmoc = TRUE; + if(!found_cache_tqmoc || !found_cache_dep) + write_cache = TRUE; + } + /* Do tqmoc before dependency checking since some includes can come from + tqmoc_*.cpp files */ + if(found_cache_tqmoc) { + TQString fixed_file(fileFixify((*val_it), TQDir::currentDirPath(), Option::output_dir)); + TQString tqmoc = tqfindMocDestination(fixed_file); + if(!tqmoc.isEmpty()) { + for(TQStringList::Iterator cppit = Option::cpp_ext.begin(); + cppit != Option::cpp_ext.end(); ++cppit) { + if(fixed_file.endsWith((*cppit))) { + TQStringList &deps = tqfindDependencies(fixed_file); + if(!deps.tqcontains(tqmoc)) + deps.append(tqmoc); + break; + } + } + } + } else if(tqmocAware() && (sources[x] == "SOURCES" || sources[x] == "HEADERS") && + (Option::qmake_mode == Option::TQMAKE_GENERATE_PROJECT || + Option::mkfile::do_tqmocs)) { + generateMocList((*val_it)); + } + if(!found_cache_dep && sources[x] != "OBJECTS") { + debug_msg(5, "Looking for dependencies for %s", (*val_it).latin1()); + generateDependencies(deplist, (*val_it), doDepends()); + } + } + } + if(project->isActiveConfig("qmake_cache") && (write_cache || !read_cache)) { + TQFile cachef(cache_file); + if(cachef.open(IO_WriteOnly | IO_Translate)) { + debug_msg(2, "Writing internal cache information: %s", cache_file.latin1()); + TQTextStream cachet( TQT_TQIODEVICE(&cachef) ); + cachet << "[check]" << "\n" + << "TQMAKE_CACHE_VERSION = " << qmake_version() << "\n" + << "TQMAKE_ABSOLUTE_SOURCE_PATH = " << var("TQMAKE_ABSOLUTE_SOURCE_PATH") << "\n" + << "TQMOC_DIR = " << var("TQMOC_DIR") << "\n" + << "UI_DIR = " << var("UI_DIR") << "\n" + << "UI_HEADERS_DIR = " << var("UI_HEADERS_DIR") << "\n" + << "UI_SOURCES_DIR = " << var("UI_SOURCES_DIR") << "\n"; + cachet << "[depend]" << endl; + for(TQMap<TQString, TQStringList>::Iterator it = depends.begin(); + it != depends.end(); ++it) + cachet << dependencyKey(it.key()) << " = " << it.data().join(" ") << endl; + cachet << "[tqmocable]" << endl; + TQString mc, tqmoc_sources[] = { TQString("HEADERS"), TQString("SOURCES"), TQString::null }; + for(int x = 0; tqmoc_sources[x] != TQString::null; x++) { + TQStringList &l = v[tqmoc_sources[x]]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + TQString f = fileFixify((*val_it)); + if(!f.isEmpty()) { + mc = tqmocablesToTQMOC[f]; + if(mc.isEmpty()) + mc = "*qmake_ignore*"; + cachet << f << " = " << mc << endl; + } + } + } + cachef.close(); + } + } + } + } + v["OBJECTS"] = createObjectList("SOURCES") + v["OBJECTS"]; // init variables + + //lex files + { + TQStringList &impls = v["LEXIMPLS"]; + TQStringList &l = v["LEXSOURCES"]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString dir; + TQFileInfo fi((*it)); + if(fi.dirPath() != ".") + dir = fi.dirPath() + Option::dir_sep; + dir = fileFixify(dir, TQDir::currentDirPath(), Option::output_dir); + if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep) + dir += Option::dir_sep; + TQString impl = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first(); + logicWarn(impl, "SOURCES"); + logicWarn(impl, "SOURCES"); + impls.append(impl); + if( ! project->isActiveConfig("lex_included")) { + v["SOURCES"].append(impl); + // attribute deps of lex file to impl file + TQStringList &lexdeps = tqfindDependencies((*it)); + TQStringList &impldeps = tqfindDependencies(impl); + for(TQStringList::ConstIterator d = lexdeps.begin(); d != lexdeps.end(); ++d) { + if(!impldeps.tqcontains(*d)) + impldeps.append(*d); + } + lexdeps.clear(); + } + } + if( ! project->isActiveConfig("lex_included")) + v["OBJECTS"] += (v["LEXOBJECTS"] = createObjectList("LEXIMPLS")); + } + //yacc files + { + TQStringList &decls = v["YACCCDECLS"], &impls = v["YACCIMPLS"]; + TQStringList &l = v["YACCSOURCES"]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString dir; + TQFileInfo fi((*it)); + if(fi.dirPath() != ".") + dir = fi.dirPath() + Option::dir_sep; + dir = fileFixify(dir, TQDir::currentDirPath(), Option::output_dir); + if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep) + dir += Option::dir_sep; + TQString impl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::cpp_ext.first(); + logicWarn(impl, "SOURCES"); + TQString decl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::h_ext.first(); + logicWarn(decl, "HEADERS"); + + decls.append(decl); + impls.append(impl); + v["SOURCES"].append(impl); + TQStringList &impldeps = tqfindDependencies(impl); + impldeps.append(decl); + // attribute deps of yacc file to impl file + TQStringList &yaccdeps = tqfindDependencies((*it)); + for(TQStringList::ConstIterator d = yaccdeps.begin(); d != yaccdeps.end(); ++d) { + if(!impldeps.tqcontains(*d)) + impldeps.append(*d); + } + if( project->isActiveConfig("lex_included")) { + // is there a matching lex file ? Transfer its dependencies. + TQString lexsrc = fi.baseName(TRUE) + Option::lex_ext; + if(fi.dirPath() != ".") + lexsrc.prepend(fi.dirPath() + Option::dir_sep); + if(v["LEXSOURCES"].tqfindIndex(lexsrc) != -1) { + TQString trg = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first(); + impldeps.append(trg); + impldeps += tqfindDependencies(lexsrc); + depends[lexsrc].clear(); + } + } + yaccdeps.clear(); + } + v["OBJECTS"] += (v["YACCOBJECTS"] = createObjectList("YACCIMPLS")); + } + + //UI files + { + TQStringList &includepath = project->variables()["INCLUDEPATH"]; + if(!project->isEmpty("UI_DIR")) + includepath.append(project->first("UI_DIR")); + else if(!project->isEmpty("UI_HEADERS_DIR")) + includepath.append(project->first("UI_HEADERS_DIR")); + TQStringList &decls = v["UICDECLS"], &impls = v["UICIMPLS"]; + TQStringList &l = v["FORMS"]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString impl, decl; + TQFileInfo fi(Option::fixPathToLocalOS((*it))); + if ( !project->isEmpty("UI_DIR") ) { + impl = decl = project->first("UI_DIR"); + TQString d = fi.dirPath(); + if( d == ".") + d = TQDir::currentDirPath(); + d = fileFixify(d, TQDir::currentDirPath(), Option::output_dir); + if(!includepath.tqcontains(d)) + includepath.append(d); + } else { + if(decl.isEmpty() && !project->isEmpty("UI_HEADERS_DIR")) + decl = project->first("UI_HEADERS_DIR"); + if(!decl.isEmpty() || (project->isEmpty("UI_HEADERS_DIR") && + !project->isEmpty("UI_SOURCES_DIR")) ) { + TQString d = fi.dirPath(); + if( d == ".") + d = TQDir::currentDirPath(); + d = fileFixify(d, TQDir::currentDirPath(), Option::output_dir); + if(!includepath.tqcontains(d)) + includepath.append(d); + } + if(impl.isEmpty() && !project->isEmpty("UI_SOURCES_DIR")) + impl = project->first("UI_SOURCES_DIR"); + if(fi.dirPath() != ".") { + if(impl.isEmpty()) + impl = fi.dirPath() + Option::dir_sep; + if(decl.isEmpty()) + decl = fi.dirPath() + Option::dir_sep; + } + } + impl = fileFixify(impl, TQDir::currentDirPath(), Option::output_dir); + if(!impl.isEmpty() && !impl.endsWith(Option::dir_sep)) + impl += Option::dir_sep; + impl += fi.baseName(TRUE) + Option::cpp_ext.first(); + if(Option::output_dir != TQDir::currentDirPath() && + project->isEmpty("UI_DIR") && project->isEmpty("UI_HEADERS_DIR")) { + TQString decl_fixed = fileFixify(decl, TQDir::currentDirPath(), Option::output_dir); + if(!includepath.tqcontains(decl_fixed)) + includepath.append(decl_fixed); + if(!includepath.tqcontains(decl)) + project->variables()["INCLUDEPATH"].append(decl); + } + decl = fileFixify(decl, TQDir::currentDirPath(), Option::output_dir); + if(!decl.isEmpty() && !decl.endsWith(Option::dir_sep)) + decl += Option::dir_sep; + decl += fi.baseName(TRUE) + Option::h_ext.first(); + logicWarn(impl, "SOURCES"); + logicWarn(decl, "HEADERS"); + decls.append(decl); + impls.append(impl); + tqfindDependencies(impl).append(decl); + + TQString tqmocable = Option::h_tqmoc_mod + fi.baseName(TRUE) + Option::h_tqmoc_ext; + if(!v["TQMOC_DIR"].isEmpty()) + tqmocable.prepend(v["TQMOC_DIR"].first()); + else if(fi.dirPath() != ".") + tqmocable.prepend(fi.dirPath() + Option::dir_sep); + logicWarn(tqmocable, "SOURCES"); + tqmocablesToTQMOC[cleanFilePath(decl)] = tqmocable; + tqmocablesFromTQMOC[cleanFilePath(tqmocable)] = decl; + v["_UITQMOC"].append(tqmocable); + } + v["OBJECTS"] += (v["UICOBJECTS"] = createObjectList("UICDECLS")); + } + + //Translation files + if(!project->isEmpty("TRANSLATIONS")) { + TQStringList &trf = project->variables()["TRANSLATIONS"]; + for(TQStringList::Iterator it = trf.begin(); it != trf.end(); ++it) { + (*it) = Option::fixPathToLocalOS((*it)); + } + } + + //Image files + if(!project->isEmpty("IMAGES")) { + if(project->isEmpty("TQMAKE_IMAGE_COLLECTION")) + v["TQMAKE_IMAGE_COLLECTION"].append("qmake_image_collection" + Option::cpp_ext.first()); + TQString imgfile = project->first("TQMAKE_IMAGE_COLLECTION"); + Option::fixPathToTargetOS(imgfile); + if(!project->isEmpty("UI_DIR") || !project->isEmpty("UI_SOURCES_DIR")) { + if(imgfile.tqfind(Option::dir_sep) != -1) + imgfile = imgfile.right(imgfile.tqfindRev(Option::dir_sep) + 1); + imgfile.prepend( (project->isEmpty("UI_DIR") ? project->first("UI_SOURCES_DIR") : + project->first("UI_DIR")) ); + v["TQMAKE_IMAGE_COLLECTION"] = TQStringList(imgfile); + } + logicWarn(imgfile, "SOURCES"); + if(!noIO()) { + TQStringList &l = v["IMAGES"]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + if(!TQFile::exists((*it))) { + warn_msg(WarnLogic, "Failure to open: %s", (*it).latin1()); + continue; + } + tqfindDependencies(imgfile).append(fileFixify((*it))); + } + } + v["OBJECTS"] += (v["IMAGEOBJECTS"] = createObjectList("TQMAKE_IMAGE_COLLECTION")); + } + if(Option::output_dir != TQDir::currentDirPath()) + project->variables()["INCLUDEPATH"].append(fileFixify(Option::output_dir, Option::output_dir, + Option::output_dir)); + + //tqmoc files + if ( tqmocAware() ) { + if(!project->isEmpty("TQMOC_DIR")) + project->variables()["INCLUDEPATH"].append(project->first("TQMOC_DIR")); + if ( Option::h_tqmoc_ext == Option::cpp_ext.first() ) + v["OBJTQMOC"] = createObjectList("_HDRTQMOC") + createObjectList("_UITQMOC"); + + TQStringList &l = v["SRCTQMOC"]; + l = v["_HDRTQMOC"] + v["_UITQMOC"] + v["_SRCTQMOC"]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + if(!(*val_it).isEmpty()) + (*val_it) = Option::fixPathToTargetOS((*val_it), FALSE); + } + } + + TQString fixpaths[] = { TQString("PRE_TARGETDEPS"), TQString("POST_TARGETDEPS"), TQString::null }; + for(int path = 0; !fixpaths[path].isNull(); path++) { + TQStringList &l = v[fixpaths[path]]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + if(!(*val_it).isEmpty()) + (*val_it) = Option::fixPathToTargetOS((*val_it), FALSE); + } + } + + // Make sure the INCLUDEPATH doesn't contain any empty(/null) entries + TQStringList &ipl = project->variables()["INCLUDEPATH"]; + for(TQStringList::Iterator ipl_it = ipl.begin(); ipl_it != ipl.end();) { + if ((*ipl_it).isEmpty()) + ipl_it = ipl.remove(ipl_it); + else + ++ipl_it; + } +} + +bool +MakefileGenerator::processPrlFile(TQString &file) +{ + bool ret = FALSE, try_tqreplace_file=FALSE; + TQString meta_file, orig_file = file; + if(TQMakeMetaInfo::libExists(file)) { + try_tqreplace_file = TRUE; + meta_file = file; + file = ""; + } else { + TQString tmp = file; + int ext = tmp.tqfindRev('.'); + if(ext != -1) + tmp = tmp.left(ext); + meta_file = tmp; + } + meta_file = fileFixify(meta_file); + if(!TQMakeMetaInfo::libExists(fileFixify(meta_file, TQDir::currentDirPath(), Option::output_dir)) && + project->isActiveConfig("qt")) { + TQString stem = meta_file, dir, extn; + int slsh = stem.tqfindRev('/'), hadlib = 0; + if(slsh != -1) { + dir = stem.left(slsh + 1); + stem = stem.right(stem.length() - slsh - 1); + } + if(stem.startsWith("lib")) { + hadlib = 1; + stem = stem.right(stem.length() - 3); + } + int dot = stem.tqfind('.'); + if(dot != -1) { + extn = stem.right(stem.length() - dot); + stem = stem.left(dot); + } + if(stem == "qt" || stem == "qte" || stem == "qte-mt" || stem == "qt-mt") { + if(stem.endsWith("-mt")) + stem = stem.left(stem.length() - 3); //lose the -mt + else + stem += "-mt"; //try the thread case + meta_file = dir; + if(hadlib) + meta_file += "lib"; + meta_file += stem + extn; + try_tqreplace_file = TRUE; + } + } + TQString real_meta_file = Option::fixPathToLocalOS(meta_file); + if(project->variables()["TQMAKE_PRL_INTERNAL_FILES"].tqfindIndex(TQMakeMetaInfo::tqfindLib(meta_file)) != -1) { + ret = TRUE; + } else if(!meta_file.isEmpty()) { + TQString f = fileFixify(real_meta_file, TQDir::currentDirPath(), Option::output_dir); + if(TQMakeMetaInfo::libExists(f)) { + TQMakeMetaInfo libinfo; + debug_msg(1, "Processing PRL file: %s", real_meta_file.latin1()); + if(!libinfo.readLib(f)) { + fprintf(stderr, "Error processing meta file: %s\n", real_meta_file.latin1()); + } else if(project->isActiveConfig("no_read_prl_" + libinfo.type().lower())) { + debug_msg(2, "Ignored meta file %s [%s]", real_meta_file.latin1(), libinfo.type().latin1()); + } else { + ret = TRUE; + TQMap<TQString, TQStringList> &vars = libinfo.variables(); + for( TQMap<TQString, TQStringList>::Iterator it = vars.begin(); it != vars.end(); ++it) + processPrlVariable(it.key(), it.data()); + if(try_tqreplace_file && !libinfo.isEmpty("TQMAKE_PRL_TARGET")) { + TQString dir; + int slsh = real_meta_file.tqfindRev(Option::dir_sep); + if(slsh != -1) + dir = real_meta_file.left(slsh+1); + file = libinfo.first("TQMAKE_PRL_TARGET"); + if(TQDir::isRelativePath(file)) + file.prepend(dir); + } + } + } + if(ret) { + TQString mf = TQMakeMetaInfo::tqfindLib(meta_file); + project->variables()["TQMAKE_PRL_INTERNAL_FILES"].append(mf); + project->variables()["TQMAKE_INTERNAL_INCLUDED_FILES"].append(mf); + } + } + if(try_tqreplace_file && file.isEmpty()) { +#if 0 + warn_msg(WarnLogic, "Found prl [%s] file with no target [%s]!", meta_file.latin1(), + orig_file.latin1()); +#endif + file = orig_file; + } + return ret; +} + +void +MakefileGenerator::processPrlVariable(const TQString &var, const TQStringList &l) +{ + if(var == "TQMAKE_PRL_LIBS") { + TQString where = "TQMAKE_LIBS"; + if(!project->isEmpty("TQMAKE_INTERNAL_PRL_LIBS")) + where = project->first("TQMAKE_INTERNAL_PRL_LIBS"); + TQStringList &out = project->variables()[where]; + for(TQStringList::ConstIterator it = l.begin(); it != l.end(); ++it) { + if( out.tqfindIndex((*it)) == -1) + out.append((*it)); + } + } else if(var == "TQMAKE_PRL_DEFINES") { + TQStringList &out = project->variables()["DEFINES"]; + for(TQStringList::ConstIterator it = l.begin(); it != l.end(); ++it) { + if(out.tqfindIndex((*it)) == -1 && + project->variables()["PRL_EXPORT_DEFINES"].tqfindIndex((*it)) == -1) + out.append((*it)); + } + } +} + +void +MakefileGenerator::processPrlFiles() +{ + TQDict<void> processed; + for(bool ret = FALSE; TRUE; ret = FALSE) { + //read in any prl files included.. + TQStringList l_out; + TQString where = "TQMAKE_LIBS"; + if(!project->isEmpty("TQMAKE_INTERNAL_PRL_LIBS")) + where = project->first("TQMAKE_INTERNAL_PRL_LIBS"); + TQStringList &l = project->variables()[where]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString file = (*it); + if(!processed[file] && processPrlFile(file)) { + processed.insert(file, (void*)1); + ret = TRUE; + } + if(!file.isEmpty()) + l_out.append(file); + } + if(ret) + l = l_out; + else + break; + } +} + +void +MakefileGenerator::writePrlFile(TQTextStream &t) +{ + TQString target = project->first("TARGET"); + int slsh = target.tqfindRev(Option::dir_sep); + if(slsh != -1) + target = target.right(target.length() - slsh - 1); + TQString bdir = Option::output_dir; + if(bdir.isEmpty()) + bdir = TQDir::currentDirPath(); + t << "TQMAKE_PRL_BUILD_DIR = " << bdir << endl; + + if(!project->projectFile().isEmpty() && project->projectFile() != "-") + t << "TQMAKE_PRO_INPUT = " << project->projectFile().section('/', -1) << endl; + + if(!project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH")) + t << "TQMAKE_PRL_SOURCE_DIR = " << project->first("TQMAKE_ABSOLUTE_SOURCE_PATH") << endl; + t << "TQMAKE_PRL_TARGET = " << target << endl; + if(!project->isEmpty("PRL_EXPORT_DEFINES")) + t << "TQMAKE_PRL_DEFINES = " << project->variables()["PRL_EXPORT_DEFINES"].join(" ") << endl; + if(!project->isEmpty("PRL_EXPORT_CFLAGS")) + t << "TQMAKE_PRL_CFLAGS = " << project->variables()["PRL_EXPORT_CFLAGS"].join(" ") << endl; + if(!project->isEmpty("PRL_EXPORT_CXXFLAGS")) + t << "TQMAKE_PRL_CXXFLAGS = " << project->variables()["PRL_EXPORT_CXXFLAGS"].join(" ") << endl; + if(!project->isEmpty("CONFIG")) + t << "TQMAKE_PRL_CONFIG = " << project->variables()["CONFIG"].join(" ") << endl; + if(!project->isEmpty("VERSION")) + t << "TQMAKE_PRL_VERSION = " << project->first("VERSION") << endl; + if(project->isActiveConfig("staticlib") || project->isActiveConfig("explicitlib")) { + TQStringList libs; + if(!project->isEmpty("TQMAKE_INTERNAL_PRL_LIBS")) + libs = project->variables()["TQMAKE_INTERNAL_PRL_LIBS"]; + else + libs << "TQMAKE_LIBS"; //obvious one + t << "TQMAKE_PRL_LIBS = "; + for(TQStringList::Iterator it = libs.begin(); it != libs.end(); ++it) + t << project->variables()[(*it)].join(" ") << " "; + t << endl; + } +} + +bool +MakefileGenerator::write() +{ + usePlatformDir(); + init(); + tqfindLibraries(); + if((Option::qmake_mode == Option::TQMAKE_GENERATE_MAKEFILE || //write prl + Option::qmake_mode == Option::TQMAKE_GENERATE_PRL) && + project->variables()["TQMAKE_FAILED_RETQUIREMENTS"].isEmpty() && + project->isActiveConfig("create_prl") && project->first("TEMPLATE") == "lib" && + !project->isActiveConfig("plugin")) { + TQString prl = var("TARGET"); + int slsh = prl.tqfindRev(Option::dir_sep); + if(slsh != -1) + prl = prl.right(prl.length() - slsh); + int dot = prl.tqfind('.'); + if(dot != -1) + prl = prl.left(dot); + prl += Option::prl_ext; + if(!project->isEmpty("DESTDIR")) + prl.prepend(var("DESTDIR")); + TQString local_prl = Option::fixPathToLocalOS(fileFixify(prl, TQDir::currentDirPath(), Option::output_dir)); + TQFile ft(local_prl); + if(ft.open(IO_WriteOnly)) { + project->variables()["ALL_DEPS"].append(prl); + project->variables()["TQMAKE_INTERNAL_PRL_FILE"].append(prl); + TQTextStream t( TQT_TQIODEVICE(&ft) ); + writePrlFile(t); + ft.close(); + } + } + if(Option::qmake_mode == Option::TQMAKE_GENERATE_MAKEFILE && + project->isActiveConfig("link_prl")) //load up prl's' + processPrlFiles(); + + if(Option::qmake_mode == Option::TQMAKE_GENERATE_MAKEFILE || //write prl file + Option::qmake_mode == Option::TQMAKE_GENERATE_PROJECT) { + TQTextStream t( TQT_TQIODEVICE(&Option::output) ); + writeMakefile(t); + } + return TRUE; +} + +// Manipulate directories, so it's possible to build +// several cross-platform targets concurrently +void +MakefileGenerator::usePlatformDir() +{ + TQString pltDir(project->first("TQMAKE_PLATFORM_DIR")); + if(pltDir.isEmpty()) + return; + char sep = TQDir::separator(); + TQString slashPltDir = sep + pltDir; + + TQString filePath = project->first("DESTDIR"); + project->variables()["DESTDIR"] = TQT_TQSTRING(filePath + + (filePath.isEmpty() ? pltDir : slashPltDir)); + + filePath = project->first("DLLDESTDIR"); + project->variables()["DLLDESTDIR"] = TQT_TQSTRING(filePath + + (filePath.isEmpty() ? pltDir : slashPltDir)); + + filePath = project->first("OBJECTS_DIR"); + project->variables()["OBJECTS_DIR"] = TQT_TQSTRING(filePath + + (filePath.isEmpty() ? pltDir : slashPltDir)); + + filePath = project->first("TQMAKE_LIBDIR_QT"); + project->variables()["TQMAKE_LIBDIR_QT"] = TQT_TQSTRING(filePath + + (filePath.isEmpty() ? pltDir : slashPltDir)); + + filePath = project->first("TQMAKE_LIBS_QT"); + int fpi = filePath.tqfindRev(sep); + if (fpi == -1) + project->variables()["TQMAKE_LIBS_QT"].prepend(pltDir + sep); + else + project->variables()["TQMAKE_LIBS_QT"] = TQT_TQSTRING(filePath.left(fpi) + + slashPltDir + + filePath.mid(fpi)); + + filePath = project->first("TQMAKE_LIBS_TQT_THREAD"); + fpi = filePath.tqfindRev(sep); + if (fpi == -1) + project->variables()["TQMAKE_LIBS_TQT_THREAD"].prepend(pltDir + sep); + else + project->variables()["TQMAKE_LIBS_TQT_THREAD"] = TQT_TQSTRING(filePath.left(fpi) + + slashPltDir + + filePath.mid(fpi)); + + filePath = project->first("TQMAKE_LIBS_TQT_ENTRY"); + fpi = filePath.tqfindRev(sep); + if (fpi == -1) + project->variables()["TQMAKE_LIBS_TQT_ENTRY"].prepend(pltDir + sep); + else + project->variables()["TQMAKE_LIBS_TQT_ENTRY"] = TQT_TQSTRING(filePath.left(fpi) + + slashPltDir + + filePath.mid(fpi)); +} + +void +MakefileGenerator::writeObj(TQTextStream &t, const TQString &obj, const TQString &src) +{ + TQStringList &objl = project->variables()[obj]; + TQStringList &srcl = project->variables()[src]; + + TQStringList::Iterator oit = objl.begin(); + TQStringList::Iterator sit = srcl.begin(); + TQString stringSrc("$src"); + TQString stringObj("$obj"); + for( ;sit != srcl.end() && oit != objl.end(); oit++, sit++) { + if((*sit).isEmpty()) + continue; + + if(!doDepends()) { + TQString sdep, odep = (*sit) + " "; + TQStringList deps = tqfindDependencies((*sit)); + for(TQStringList::Iterator dit = deps.begin(); dit != deps.end(); dit++) { + if((*dit).endsWith(Option::cpp_tqmoc_ext)) + odep += (*dit) + " "; + else + sdep += (*dit) + " "; + } + t << (*sit) << ": " << sdep << endl + << (*oit) << ": " << odep ; + } else { + t << (*oit) << ": " << (*sit) << " " << tqfindDependencies((*sit)).join(" \\\n\t\t"); + } + + TQString comp, cimp; + for(TQStringList::Iterator cppit = Option::cpp_ext.begin(); cppit != Option::cpp_ext.end(); ++cppit) { + if((*sit).endsWith((*cppit))) { + comp = "TQMAKE_RUN_CXX"; + cimp = "TQMAKE_RUN_CXX_IMP"; + break; + } + } + if(comp.isEmpty()) { + comp = "TQMAKE_RUN_CC"; + cimp = "TQMAKE_RUN_CC_IMP"; + } + bool use_implicit_rule = !project->isEmpty(cimp); + if(use_implicit_rule) { + if(!project->isEmpty("OBJECTS_DIR")) { + use_implicit_rule = FALSE; + } else { + int dot = (*sit).tqfindRev('.'); + if(dot == -1 || ((*sit).left(dot) + Option::obj_ext != (*oit))) + use_implicit_rule = FALSE; + } + } + if (!use_implicit_rule && !project->isEmpty(comp)) { + TQString p = var(comp), srcf(*sit); + p.tqreplace(stringSrc, srcf); + p.tqreplace(stringObj, (*oit)); + t << "\n\t" << p; + } + t << endl << endl; + } +} + + +void +MakefileGenerator::writeUicSrc(TQTextStream &t, const TQString &ui) +{ + TQStringList &uil = project->variables()[ui]; + for(TQStringList::Iterator it = uil.begin(); it != uil.end(); it++) { + TQString decl, impl; + { + TQString tmp = (*it), impl_dir, decl_dir; + decl = tmp.tqreplace(TQRegExp("\\" + Option::ui_ext + "$"), Option::h_ext.first()); + int dlen = decl.tqfindRev(Option::dir_sep) + 1; + tmp = (*it); + impl = tmp.tqreplace(TQRegExp("\\" + Option::ui_ext + "$"), Option::cpp_ext.first()); + int ilen = decl.tqfindRev(Option::dir_sep) + 1; + if(!project->isEmpty("UI_DIR")) { + impl_dir = project->first("UI_DIR"); + decl = project->first("UI_DIR") + decl.right(decl.length() - dlen); + impl = project->first("UI_DIR") + impl.right(impl.length() - ilen); + } else { + if(!project->isEmpty("UI_HEADERS_DIR")) { + decl_dir = project->first("UI_HEADERS_DIR"); + decl = project->first("UI_HEADERS_DIR") + decl.right(decl.length() - dlen); + } + if(!project->isEmpty("UI_SOURCES_DIR")) { + impl_dir = project->first("UI_SOURCES_DIR"); + impl = project->first("UI_SOURCES_DIR") + impl.right(impl.length() - ilen); + } + } + impl = fileFixify(impl, TQDir::currentDirPath(), Option::output_dir); + decl = fileFixify(decl, TQDir::currentDirPath(), Option::output_dir); + if(decl_dir.isEmpty()) + decl_dir = decl.section(Option::dir_sep,0,-2); + if(impl_dir.isEmpty()) + impl_dir = impl.section(Option::dir_sep,0,-2); + if (TQDir::isRelativePath(impl_dir)) + impl_dir.prepend(Option::output_dir + Option::dir_sep); + if (TQDir::isRelativePath(decl_dir)) + decl_dir.prepend(Option::output_dir + Option::dir_sep); + createDir(impl_dir); + createDir(decl_dir); + } + TQStringList deps = tqfindDependencies((*it)); + deps.remove(decl); //avoid circular dependencies.. + t << decl << ": " << (*it) << " "; + t << deps.join(" \\\n\t\t") << "\n\t" + << "$(UIC) " << (*it) << " -o " << decl << endl << endl; + + TQString mildDecl = decl; + int k = mildDecl.tqfindRev(Option::dir_sep); + if ( k != -1 ) + mildDecl = mildDecl.mid( k + 1 ); + t << impl << ": " << decl << " " << (*it) << " "; + if(TQFile::exists((*it) + Option::h_ext.first())) + t << (*it) << Option::h_ext.first() << " "; + t << deps.join(" \\\n\t\t") << "\n\t" + << "$(UIC) " << (*it) << " -i " << mildDecl << " -o " << impl << endl << endl; + } +} + + +void +MakefileGenerator::writeMocObj(TQTextStream &t, const TQString &obj, const TQString &src) +{ + TQStringList &objl = project->variables()[obj], + &srcl = project->variables()[src]; + TQStringList::Iterator oit = objl.begin(), sit = srcl.begin(); + TQString stringSrc("$src"), stringObj("$obj"); + for( ;sit != srcl.end() && oit != objl.end(); oit++, sit++) { + TQString hdr = tqfindMocSource((*sit)); + t << (*oit) << ": " + << (*sit) << " " << tqfindDependencies((*sit)).join(" \\\n\t\t") << " " + << hdr << " " << tqfindDependencies(hdr).join(" \\\n\t\t"); + bool use_implicit_rule = !project->isEmpty("TQMAKE_RUN_CXX_IMP"); + if(use_implicit_rule) { + if(!project->isEmpty("OBJECTS_DIR") || !project->isEmpty("TQMOC_DIR")) { + use_implicit_rule = FALSE; + } else { + int dot = (*sit).tqfindRev('.'); + if(dot == -1 || ((*sit).left(dot) + Option::obj_ext != (*oit))) + use_implicit_rule = FALSE; + } + } + if (!use_implicit_rule && !project->isEmpty("TQMAKE_RUN_CXX")) { + TQString p = var("TQMAKE_RUN_CXX"), srcf(*sit); + p.tqreplace(stringSrc, srcf); + p.tqreplace(stringObj, (*oit)); + t << "\n\t" << p; + } + t << endl << endl; + } +} + + +void +MakefileGenerator::writeMocSrc(TQTextStream &t, const TQString &src) +{ + TQStringList &l = project->variables()[src]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString m = Option::fixPathToTargetOS(tqfindMocDestination(*it)); + if ( !m.isEmpty()) { + TQString deps; + if(!project->isActiveConfig("no_tqmocdepend")) + deps += "$(TQMOC) "; + deps += (*it); + t << m << ": " << deps << "\n\t" + << "$(TQMOC)"; + t << " " << (*it) << " -o " << m << endl << endl; + } + } +} + +void +MakefileGenerator::writeYaccSrc(TQTextStream &t, const TQString &src) +{ + TQStringList &l = project->variables()[src]; + if(project->isActiveConfig("yacc_no_name_mangle") && l.count() > 1) + warn_msg(WarnLogic, "yacc_no_name_mangle specified, but multiple parsers expected." + "This can lead to link problems.\n"); + TQString default_out_h = "y.tab.h", default_out_c = "y.tab.c"; + if(!project->isEmpty("TQMAKE_YACC_HEADER")) + default_out_h = project->first("TQMAKE_YACC_HEADER"); + if(!project->isEmpty("TQMAKE_YACC_SOURCE")) + default_out_c = project->first("TQMAKE_YACC_SOURCE"); + TQString stringBase("$base"); + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQFileInfo fi((*it)); + TQString dir; + if(fi.dirPath() != ".") + dir = fi.dirPath() + Option::dir_sep; + dir = fileFixify(dir, TQDir::currentDirPath(), Option::output_dir); + if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep) + dir += Option::dir_sep; + + TQString impl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::cpp_ext.first(); + TQString decl = dir + fi.baseName(TRUE) + Option::yacc_mod + Option::h_ext.first(); + + TQString yaccflags = "$(YACCFLAGS)", mangle = "y"; + if(!project->isActiveConfig("yacc_no_name_mangle")) { + mangle = fi.baseName(TRUE); + if(!project->isEmpty("TQMAKE_YACCFLAGS_MANGLE")) + yaccflags += " " + var("TQMAKE_YACCFLAGS_MANGLE").tqreplace(stringBase, mangle); + else + yaccflags += " -p " + mangle; + } + TQString out_h = default_out_h, out_c = default_out_c; + if(!mangle.isEmpty()) { + out_h.tqreplace(stringBase, mangle); + out_c.tqreplace(stringBase, mangle); + } + + t << impl << ": " << (*it) << "\n\t" + << "$(YACC) " << yaccflags << " " << (*it) << "\n\t" + << "-$(DEL_FILE) " << impl << " " << decl << "\n\t" + << "-$(MOVE) " << out_h << " " << decl << "\n\t" + << "-$(MOVE) " << out_c << " " << impl << endl << endl; + t << decl << ": " << impl << endl << endl; + } +} + +void +MakefileGenerator::writeLexSrc(TQTextStream &t, const TQString &src) +{ + TQStringList &l = project->variables()[src]; + if(project->isActiveConfig("yacc_no_name_mangle") && l.count() > 1) + warn_msg(WarnLogic, "yacc_no_name_mangle specified, but multiple parsers expected.\n" + "This can lead to link problems.\n"); + TQString default_out_c = "lex.$base.c"; + if(!project->isEmpty("TQMAKE_LEX_SOURCE")) + default_out_c = project->first("TQMAKE_LEX_SOURCE"); + TQString stringBase("$base"); + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQFileInfo fi((*it)); + TQString dir; + if(fi.dirPath() != ".") + dir = fi.dirPath() + Option::dir_sep; + dir = fileFixify(dir, TQDir::currentDirPath(), Option::output_dir); + if(!dir.isEmpty() && dir.right(Option::dir_sep.length()) != Option::dir_sep) + dir += Option::dir_sep; + TQString impl = dir + fi.baseName(TRUE) + Option::lex_mod + Option::cpp_ext.first(); + + TQString lexflags = "$(LEXFLAGS)", stub="yy"; + if(!project->isActiveConfig("yacc_no_name_mangle")) { + stub = fi.baseName(TRUE); + lexflags += " -P" + stub; + } + TQString out_c = default_out_c; + if(!stub.isEmpty()) + out_c.tqreplace(stringBase, stub); + + t << impl << ": " << (*it) << " " << tqfindDependencies((*it)).join(" \\\n\t\t") << "\n\t" + << ( "$(LEX) " + lexflags + " " ) << (*it) << "\n\t" + << "-$(DEL_FILE) " << impl << " " << "\n\t" + << "-$(MOVE) " << out_c << " " << impl << endl << endl; + } +} + +void +MakefileGenerator::writeImageObj(TQTextStream &t, const TQString &obj) +{ + TQStringList &objl = project->variables()[obj]; + TQString stringSrc("$src"); + TQString stringObj("$obj"); + + TQString uidir; + for(TQStringList::Iterator oit = objl.begin(); oit != objl.end(); oit++) { + TQString src(project->first("TQMAKE_IMAGE_COLLECTION")); + t << (*oit) << ": " << src; + bool use_implicit_rule = !project->isEmpty("TQMAKE_RUN_CXX_IMP"); + if(use_implicit_rule) { + if(!project->isEmpty("OBJECTS_DIR") || !project->isEmpty("UI_DIR") || !project->isEmpty("UI_SOURCES_DIR")) { + use_implicit_rule = FALSE; + } else { + int dot = src.tqfindRev('.'); + if(dot == -1 || (src.left(dot) + Option::obj_ext != (*oit))) + use_implicit_rule = FALSE; + } + } + if(!use_implicit_rule && !project->isEmpty("TQMAKE_RUN_CXX")) { + TQString p = var("TQMAKE_RUN_CXX"), srcf(src); + p.tqreplace(stringSrc, srcf); + p.tqreplace(stringObj, (*oit)); + t << "\n\t" << p; + } + t << endl << endl; + } +} + + +void +MakefileGenerator::writeImageSrc(TQTextStream &t, const TQString &src) +{ + TQStringList &l = project->variables()[src]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString gen = project->first("MAKEFILE_GENERATOR"); + if ( gen == "MSVC" ) { + t << (*it) << ": " << tqfindDependencies((*it)).join(" \\\n\t\t") << "\n\t" + << "$(UIC) -o " << (*it) << " -embed " << project->first("TQMAKE_ORIG_TARGET") + << " -f <<\n" << tqfindDependencies((*it)).join(" ") << "\n<<" << endl << endl; + } else if ( gen == "BMAKE" ) { + t << (*it) << ": " << tqfindDependencies((*it)).join(" \\\n\t\t") << "\n\t" + << "$(UIC) " << " -embed " << project->first("TQMAKE_ORIG_TARGET") + << " -f &&|\n" << tqfindDependencies((*it)).join(" ") << "\n| -o " << (*it) << endl << endl; + } else { + t << (*it) << ": " << tqfindDependencies((*it)).join(" \\\n\t\t") << "\n\t" + << "$(UIC) " << " -embed " << project->first("TQMAKE_ORIG_TARGET") + << " " << tqfindDependencies((*it)).join(" ") << " -o " << (*it) << endl << endl; + } + } +} + + +void +MakefileGenerator::writeInstalls(TQTextStream &t, const TQString &installs) +{ + TQString all_installs, all_uninstalls; + TQStringList &l = project->variables()[installs]; + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQString pvar = (*it) + ".path"; + if(project->variables()[(*it) + ".CONFIG"].tqfindIndex("no_path") == -1 && + project->variables()[pvar].isEmpty()) { + warn_msg(WarnLogic, "%s is not defined: install target not created\n", pvar.latin1()); + continue; + } + + bool do_default = TRUE; + const TQString root = "$(INSTALL_ROOT)"; + TQString target, dst= fileFixify(project->variables()[pvar].first()); + if(dst.right(1) != Option::dir_sep) + dst += Option::dir_sep; + TQStringList tmp, uninst = project->variables()[(*it) + ".uninstall"]; + //other + tmp = project->variables()[(*it) + ".extra"]; + if(tmp.isEmpty()) + tmp = project->variables()[(*it) + ".commands"]; //to allow compatible name + if(!tmp.isEmpty()) { + do_default = FALSE; + if(!target.isEmpty()) + target += "\n\t"; + target += tmp.join(" "); + } + //masks + tmp = project->variables()[(*it) + ".files"]; + if(!tmp.isEmpty()) { + if(!target.isEmpty()) + target += "\n"; + do_default = FALSE; + for(TQStringList::Iterator wild_it = tmp.begin(); wild_it != tmp.end(); ++wild_it) { + TQString wild = Option::fixPathToLocalOS((*wild_it), FALSE), wild_var = fileFixify(wild); + TQString dirstr = TQDir::currentDirPath(), filestr = wild; + int slsh = filestr.tqfindRev(Option::dir_sep); + if(slsh != -1) { + dirstr = filestr.left(slsh+1); + filestr = filestr.right(filestr.length() - slsh - 1); + } + if(dirstr.right(Option::dir_sep.length()) != Option::dir_sep) + dirstr += Option::dir_sep; + if(TQFile::exists(wild)) { //real file + TQString file = wild; + TQFileInfo fi(wild); + if(!target.isEmpty()) + target += "\t"; + TQString cmd = TQString(fi.isDir() ? "-$(INSTALL_DIR)" : "-$(INSTALL_FILE)") + " \"" + + Option::fixPathToTargetOS(fileFixify(wild, TQString::null, + TQString::null, FALSE, FALSE), FALSE) + + "\" \"" + root + dst + "\"\n"; + target += cmd; + if(!project->isActiveConfig("debug") && + !fi.isDir() && fi.isExecutable() && !project->isEmpty("TQMAKE_STRIP")) + target += TQString("\t-") + var("TQMAKE_STRIP") + " \"" + + root + fileFixify(dst + filestr, TQString::null, TQString::null, FALSE, FALSE) + + "\"\n"; + if(!uninst.isEmpty()) + uninst.append("\n\t"); + uninst.append( +#ifdef TQ_WS_WIN + TQString("-$(DEL_FILE)") +#else + TQString("-$(DEL_FILE) -r") +#endif + + " \"" + root + fileFixify(dst + filestr, TQString::null, TQString::null, FALSE, FALSE) + "\""); + continue; + } + fixEnvVariables(dirstr); + TQDir dir(dirstr, filestr); //wild + for(uint x = 0; x < dir.count(); x++) { + TQString file = dir[x]; + if(file == "." || file == "..") //blah + continue; + if(!uninst.isEmpty()) + uninst.append("\n\t"); + uninst.append( +#ifdef TQ_WS_WIN + TQString("-$(DEL_FILE)") +#else + TQString("-$(DEL_FILE) -r") +#endif + + " \"" + root + fileFixify(dst + file, TQString::null, TQString::null, FALSE, FALSE) + + "\""); + TQFileInfo fi(Option::fixPathToTargetOS(fileFixify(dirstr + file), TRUE)); + if(!target.isEmpty()) + target += "\t"; + TQString cmd = TQString(fi.isDir() ? "-$(INSTALL_DIR)" : "-$(INSTALL_FILE)") + " \"" + + Option::fixPathToTargetOS(fileFixify(dirstr + file, TQString::null, + TQString::null, FALSE, FALSE), FALSE) + + "\" \"" + root + dst + "\"\n"; + target += cmd; + if(!project->isActiveConfig("debug") && + !fi.isDir() && fi.isExecutable() && !project->isEmpty("TQMAKE_STRIP")) + target += TQString("\t-") + var("TQMAKE_STRIP") + " \"" + + root + fileFixify(dst + file, TQString::null, TQString::null, FALSE, FALSE) + + "\"\n"; + } + } + } + //default? + if(do_default) { + target = defaultInstall((*it)); + uninst = project->variables()[(*it) + ".uninstall"]; + } + + if(!target.isEmpty()) { + t << "install_" << (*it) << ": all "; + const TQStringList &deps = project->variables()[(*it) + ".depends"]; + if(!deps.isEmpty()) { + for(TQStringList::ConstIterator dep_it = deps.begin(); dep_it != deps.end(); ++dep_it) { + TQString targ = var((*dep_it) + ".target"); + if(targ.isEmpty()) + targ = (*dep_it); + t << targ; + } + } + t << "\n\t"; + const TQStringList &dirs = project->variables()[pvar]; + for(TQStringList::ConstIterator pit = dirs.begin(); pit != dirs.end(); ++pit) { + TQString tmp_dst = fileFixify((*pit)); +#ifndef TQ_WS_WIN + if(tmp_dst.right(1) != Option::dir_sep) + tmp_dst += Option::dir_sep; +#endif + t << mkdir_p_asstring(root+tmp_dst) << "\n\t"; + } + t << target << endl << endl; + if(!uninst.isEmpty()) { + t << "uninstall_" << (*it) << ": " << "\n\t" + << uninst.join("") << "\n\t" + << "-$(DEL_DIR) \"" << ( root + dst ) << "\"" << endl << endl; + } + t << endl; + + if(project->variables()[(*it) + ".CONFIG"].tqfindIndex("no_default_install") == -1) { + all_installs += TQString("install_") + (*it) + " "; + if(!uninst.isEmpty()) + all_uninstalls += "uninstall_" + (*it) + " "; + } + } else { + debug_msg(1, "no definition for install %s: install target not created",(*it).latin1()); + } + } + t << "install: " << all_installs << " " << var("INSTALLDEPS") << "\n\n"; + t << "uninstall: " << all_uninstalls << " " << var("UNINSTALLDEPS") << "\n\n"; +} + +TQString +MakefileGenerator::var(const TQString &var) +{ + return val(project->variables()[var]); +} + +TQString +MakefileGenerator::val(const TQStringList &varList) +{ + return valGlue(varList, "", " ", ""); +} + +TQString +MakefileGenerator::varGlue(const TQString &var, const TQString &before, const TQString &glue, const TQString &after) +{ + return valGlue(project->variables()[var], before, glue, after); +} + +TQString +MakefileGenerator::valGlue(const TQStringList &varList, const TQString &before, const TQString &glue, const TQString &after) +{ + TQString ret; + for(TQStringList::ConstIterator it = varList.begin(); it != varList.end(); ++it) { + if(!(*it).isEmpty()) { + if(!ret.isEmpty()) + ret += glue; + ret += (*it); + } + } + return ret.isEmpty() ? TQString("") : before + ret + after; +} + + +TQString +MakefileGenerator::varList(const TQString &var) +{ + return valList(project->variables()[var]); +} + +TQString +MakefileGenerator::valList(const TQStringList &varList) +{ + return valGlue(varList, "", " \\\n\t\t", ""); +} + + +TQStringList +MakefileGenerator::createObjectList(const TQString &var) +{ + TQStringList &l = project->variables()[var], ret; + TQString objdir, dir; + if(!project->variables()["OBJECTS_DIR"].isEmpty()) + objdir = project->first("OBJECTS_DIR"); + for(TQStringList::Iterator it = l.begin(); it != l.end(); ++it) { + TQFileInfo fi(Option::fixPathToLocalOS((*it))); + if(objdir.isEmpty() && project->isActiveConfig("object_with_source")) { + TQString fName = Option::fixPathToTargetOS((*it), FALSE); + int dl = fName.tqfindRev(Option::dir_sep); + if(dl != -1) + dir = fName.left(dl + 1); + } else { + dir = objdir; + } + ret.append(dir + fi.baseName(TRUE) + Option::obj_ext); + } + return ret; +} + +bool +MakefileGenerator::writeMakefile(TQTextStream &t) +{ + t << "####### Compile" << endl << endl; + writeObj(t, "OBJECTS", "SOURCES"); + writeUicSrc(t, "FORMS"); + writeObj(t, "UICOBJECTS", "UICIMPLS"); + writeMocObj(t, "OBJTQMOC", "SRCTQMOC" ); + writeMocSrc(t, "HEADERS"); + writeMocSrc(t, "SOURCES"); + writeMocSrc(t, "UICDECLS"); + writeYaccSrc(t, "YACCSOURCES"); + writeLexSrc(t, "LEXSOURCES"); + writeImageObj(t, "IMAGEOBJECTS"); + writeImageSrc(t, "TQMAKE_IMAGE_COLLECTION"); + + t << "####### Install" << endl << endl; + writeInstalls(t, "INSTALLS"); + return TRUE; +} + +TQString MakefileGenerator::buildArgs() +{ + static TQString ret; + if(ret.isEmpty()) { + //special variables + if(!project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH")) + ret += " TQMAKE_ABSOLUTE_SOURCE_PATH=\"" + project->first("TQMAKE_ABSOLUTE_SOURCE_PATH") + "\""; + + //warnings + else if(Option::warn_level == WarnNone) + ret += " -Wnone"; + else if(Option::warn_level == WarnAll) + ret += " -Wall"; + else if(Option::warn_level & WarnParser) + ret += " -Wparser"; + //other options + if(!Option::user_template.isEmpty()) + ret += " -t " + Option::user_template; + if(!Option::mkfile::do_cache) + ret += " -nocache"; + if(!Option::mkfile::do_deps) + ret += " -nodepend"; + if(!Option::mkfile::do_tqmocs) + ret += " -notqmoc"; + if(!Option::mkfile::do_dep_heuristics) + ret += " -nodependheuristics"; + if(!Option::mkfile::qmakespec_commandline.isEmpty()) + ret += " -spec " + Option::mkfile::qmakespec_commandline; + + //arguments + for(TQStringList::Iterator it = Option::before_user_vars.begin(); + it != Option::before_user_vars.end(); ++it) { + if((*it).left(tqstrlen("TQMAKE_ABSOLUTE_SOURCE_PATH")) != "TQMAKE_ABSOLUTE_SOURCE_PATH") + ret += " \"" + (*it) + "\""; + } + if(Option::after_user_vars.count()) { + ret += " -after "; + for(TQStringList::Iterator it = Option::after_user_vars.begin(); + it != Option::after_user_vars.end(); ++it) { + if((*it).left(tqstrlen("TQMAKE_ABSOLUTE_SOURCE_PATH")) != "TQMAKE_ABSOLUTE_SOURCE_PATH") + ret += " \"" + (*it) + "\""; + } + } + } + return ret; +} + +//could get stored argv, but then it would have more options than are +//probably necesary this will try to guess the bare minimum.. +TQString MakefileGenerator::build_args() +{ + static TQString ret; + if(ret.isEmpty()) { + ret = "$(TQMAKE)"; + + // general options and arguments + ret += buildArgs(); + + //output + TQString ofile = Option::fixPathToTargetOS(fileFixify(Option::output.name())); + if (!ofile.isEmpty() && ofile != project->first("TQMAKE_MAKEFILE")) + ret += " -o " + ofile; + + //inputs + TQStringList files = fileFixify(Option::mkfile::project_files); + ret += " " + files.join(" "); + } + return ret; +} + +bool +MakefileGenerator::writeHeader(TQTextStream &t) +{ + time_t foo = time(NULL); + t << "#############################################################################" << endl; + t << "# Makefile for building: " << var("TARGET") << endl; + t << "# Generated by qmake (" << qmake_version() << ") (TQt " << TQT_VERSION_STR << ") on: " << ctime(&foo); + t << "# Project: " << fileFixify(project->projectFile()) << endl; + t << "# Template: " << var("TEMPLATE") << endl; + t << "# Command: " << build_args() << endl; + t << "#############################################################################" << endl; + t << endl; + return TRUE; +} + + +//makes my life easier.. +bool +MakefileGenerator::writeMakeQmake(TQTextStream &t) +{ + TQString ofile = Option::fixPathToTargetOS(fileFixify(Option::output.name())); + if(project->isEmpty("TQMAKE_FAILED_RETQUIREMENTS") && !project->isActiveConfig("no_autoqmake") && + !project->isEmpty("TQMAKE_INTERNAL_PRL_FILE")) { + TQStringList files = fileFixify(Option::mkfile::project_files); + t << project->first("TQMAKE_INTERNAL_PRL_FILE") << ": " << "\n\t" + << "@$(TQMAKE) -prl " << buildArgs() << " " << files.join(" ") << endl; + } + + TQString pfile = project->projectFile(); + if(pfile != "(stdin)") { + TQString qmake = build_args(); + if(!ofile.isEmpty() && !project->isActiveConfig("no_autoqmake")) { + t << ofile << ": " << fileFixify(pfile) << " "; + if(Option::mkfile::do_cache) + t << fileFixify(Option::mkfile::cachefile) << " "; + if(!specdir().isEmpty()) { + if (TQFile::exists(Option::fixPathToLocalOS(specdir()+TQDir::separator()+"qmake.conf"))) + t << specdir() << Option::dir_sep << "qmake.conf" << " "; + else if (TQFile::exists(Option::fixPathToLocalOS(specdir()+TQDir::separator()+"tmake.conf"))) + t << specdir() << Option::dir_sep << "tmake.conf" << " "; + } + t << project->variables()["TQMAKE_INTERNAL_INCLUDED_FILES"].join(" \\\n\t\t") << "\n\t" + << qmake <<endl; + } + if(project->first("TQMAKE_ORIG_TARGET") != "qmake") { + t << "qmake: " << + project->variables()["TQMAKE_INTERNAL_TQMAKE_DEPS"].join(" \\\n\t\t") << "\n\t" + << "@" << qmake << endl << endl; + } + } + return TRUE; +} + +TQStringList +MakefileGenerator::fileFixify(const TQStringList& files, const TQString &out_dir, const TQString &in_dir, + bool force_fix, bool canon) const +{ + if(files.isEmpty()) + return files; + TQStringList ret; + for(TQStringList::ConstIterator it = files.begin(); it != files.end(); ++it) { + if(!(*it).isEmpty()) + ret << fileFixify((*it), out_dir, in_dir, force_fix, canon); + } + return ret; +} + +TQString +MakefileGenerator::fileFixify(const TQString& file0, const TQString &out_d, + const TQString &in_d, bool force_fix, bool canon) const +{ + if(file0.isEmpty()) + return file0; + TQString key = file0; + if(TQDir::isRelativePath(file0)) + key.prepend(TQDir::currentDirPath() + "--"); + if(!in_d.isEmpty() || !out_d.isEmpty() || force_fix || !canon) + key.prepend(in_d + "--" + out_d + "--" + TQString::number((int)force_fix) + "--" + + TQString::number((int)canon) + "-"); + if(fileFixed.tqcontains(key)) + return fileFixed[key]; + + TQString file = file0; + int depth = 4; + if(Option::qmake_mode == Option::TQMAKE_GENERATE_MAKEFILE || + Option::qmake_mode == Option::TQMAKE_GENERATE_PRL) { + if(project && !project->isEmpty("TQMAKE_PROJECT_DEPTH")) + depth = project->first("TQMAKE_PROJECT_DEPTH").toInt(); + else if(Option::mkfile::cachefile_depth != -1) + depth = Option::mkfile::cachefile_depth; + } + + TQChar quote; + if((file.startsWith("'") || file.startsWith("\"")) && file.startsWith(file.right(1))) { + quote = file.at(0); + file = file.mid(1, file.length() - 2); + } + TQString orig_file = file; + if(!force_fix && project->isActiveConfig("no_fixpath")) { + if(!project->isEmpty("TQMAKE_ABSOLUTE_SOURCE_PATH")) { //absoluteify it + TQString qfile = Option::fixPathToLocalOS(file, TRUE, canon); + if(TQDir::isRelativePath(file)) { //already absolute + TQFileInfo fi(qfile); + if(!fi.convertToAbs()) //strange + file = fi.filePath(); + } + } + } else { //fix it.. + TQString qfile(Option::fixPathToLocalOS(file, TRUE, canon)), in_dir(in_d), out_dir(out_d); + { + if(out_dir.isNull() || TQDir::isRelativePath(out_dir)) + out_dir.prepend(Option::output_dir + TQDir::separator()); + if(out_dir == ".") + out_dir = TQDir::currentDirPath(); + if(in_dir.isEmpty() || TQDir::isRelativePath(in_dir)) + in_dir.prepend(TQDir::currentDirPath() + TQDir::separator()); + if(in_dir == ".") + in_dir = TQDir::currentDirPath(); + + if(!TQDir::isRelativePath(in_dir) || !TQDir::isRelativePath(out_dir)) { + TQFileInfo in_fi(in_dir); + if(!in_fi.convertToAbs()) + in_dir = in_fi.filePath(); + TQFileInfo out_fi(out_dir); + if(!out_fi.convertToAbs()) + out_dir = out_fi.filePath(); + } + TQString in_canonical_dir = TQDir(in_dir).canonicalPath(), + out_canonical_dir = TQDir(out_dir).canonicalPath(); + if(!in_canonical_dir.isEmpty()) + in_dir = in_canonical_dir; + if(!out_canonical_dir.isEmpty()) + out_dir = out_canonical_dir; + } + if(out_dir != in_dir || !TQDir::isRelativePath(qfile)) { + if(TQDir::isRelativePath(qfile)) { + if(file.left(Option::dir_sep.length()) != Option::dir_sep && + in_dir.right(Option::dir_sep.length()) != Option::dir_sep) + file.prepend(Option::dir_sep); + file.prepend(in_dir); + } + file = Option::fixPathToTargetOS(file, FALSE, canon); + if(canon && TQFile::exists(file) && file == Option::fixPathToTargetOS(file, TRUE, canon)) { + TQString real_file = TQDir(file).canonicalPath(); + if(!real_file.isEmpty()) + file = Option::fixPathToTargetOS(real_file, false, canon); + } + TQString match_dir = Option::fixPathToTargetOS(out_dir, FALSE, canon); + if(file == match_dir) { + file = ""; + } else if(file.startsWith(match_dir) && + file.mid(match_dir.length(), Option::dir_sep.length()) == Option::dir_sep) { + file = file.right(file.length() - (match_dir.length() + 1)); + } else { + for(int i = 1; i <= depth; i++) { + int sl = match_dir.tqfindRev(Option::dir_sep); + if(sl == -1) + break; + match_dir = match_dir.left(sl); + if(match_dir.isEmpty()) + break; + if(file.startsWith(match_dir) && + file.mid(match_dir.length(), Option::dir_sep.length()) == Option::dir_sep) { + //concat + int remlen = file.length() - (match_dir.length() + 1); + if (remlen < 0) + remlen = 0; + file = file.right(remlen); + //prepend + for(int o = 0; o < i; o++) + file.prepend(".." + Option::dir_sep); + } + } + } + } + } + file = Option::fixPathToTargetOS(file, FALSE, canon); + if(file.isEmpty()) + file = "."; + if(!quote.isNull()) + file = quote + file + quote; + debug_msg(3, "Fixed %s :: to :: %s (%d) [%s::%s]", orig_file.latin1(), file.latin1(), depth, + in_d.latin1(), out_d.latin1()); + ((MakefileGenerator*)this)->fileFixed.insert(key, file); + return file; +} + +TQString +MakefileGenerator::cleanFilePath(const TQString &file) const +{ + return fileFixify(Option::fixPathToTargetOS(file)); +} + +void MakefileGenerator::logicWarn(const TQString &f, const TQString &w) +{ + if(!(Option::warn_level & WarnLogic)) + return; + TQString file = f; + int slsh = f.tqfindRev(Option::dir_sep); + if(slsh != -1) + file = file.right(file.length() - slsh - 1); + TQStringList &l = project->variables()[w]; + for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) { + TQString file2((*val_it)); + slsh = file2.tqfindRev(Option::dir_sep); + if(slsh != -1) + file2 = file2.right(file2.length() - slsh - 1); + if(file2 == file) { + warn_msg(WarnLogic, "Found potential symbol conflict of %s (%s) in %s", + file.latin1(), (*val_it).latin1(), w.latin1()); + break; + } + } +} + +TQString +MakefileGenerator::dependencyKey(const TQString &file) const +{ + TQString key = file; + Option::fixPathToTargetOS(key); + if(key.tqfind(Option::dir_sep)) + key = key.right(key.length() - key.tqfindRev(Option::dir_sep) - 1); + return key; +} + +void +MakefileGenerator::setProcessedDependencies(const TQString &file, bool b) +{ + depProcessed[dependencyKey(file)] = b; +} + +bool +MakefileGenerator::processedDependencies(const TQString &file) +{ + TQString key = dependencyKey(file); + if(!depProcessed.tqcontains(key)) + return FALSE; + return depProcessed[key]; +} + +TQStringList +&MakefileGenerator::tqfindDependencies(const TQString &file) +{ + return depends[dependencyKey(file)]; +} + + +TQString +MakefileGenerator::specdir() +{ + if(!spec.isEmpty()) + return spec; + spec = Option::mkfile::qmakespec; +#if 0 + if(const char *d = getenv("TQTDIR")) { + TQString qdir = Option::fixPathToTargetOS(TQString(d)); + if(qdir.endsWith(TQString(TQChar(TQDir::separator())))) + qdir.truncate(qdir.length()-1); + //fix path + TQFileInfo fi(spec); + TQString absSpec(fi.absFilePath()); + absSpec = Option::fixPathToTargetOS(absSpec); + //tqreplace what you can + if(absSpec.startsWith(qdir)) { + absSpec.tqreplace(0, qdir.length(), "$(TQTDIR)"); + spec = absSpec; + } + } +#else + spec = Option::fixPathToTargetOS(spec); +#endif + return spec; +} + +bool +MakefileGenerator::openOutput(TQFile &file) const +{ + { + TQString outdir; + if(!file.name().isEmpty()) { + if(TQDir::isRelativePath(file.name())) + file.setName(Option::output_dir + file.name()); //pwd when qmake was run + TQFileInfo fi(file); + if(fi.isDir()) + outdir = file.name() + TQDir::separator(); + } + if(!outdir.isEmpty() || file.name().isEmpty()) { + TQString fname = "Makefile"; + if(!project->isEmpty("MAKEFILE")) + fname = project->first("MAKEFILE"); + file.setName(outdir + fname); + } + } + if(TQDir::isRelativePath(file.name())) + file.setName(Option::output_dir + file.name()); //pwd when qmake was run + if(project->isEmpty("TQMAKE_MAKEFILE")) + project->variables()["TQMAKE_MAKEFILE"].append(file.name()); + int slsh = file.name().tqfindRev(Option::dir_sep); + if(slsh != -1) + createDir(file.name().left(slsh)); + if(file.open(IO_WriteOnly | IO_Translate)) { + TQFileInfo fi(Option::output); + TQString od = Option::fixPathToTargetOS((fi.isSymLink() ? fi.readLink() : fi.dirPath()) ); + if(TQDir::isRelativePath(od)) + od.prepend(Option::output_dir); + Option::output_dir = od; + return TRUE; + } + return FALSE; +} + + + +//Factory thing +#include "unixmake.h" +#include "msvc_nmake.h" +#include "borland_bmake.h" +#include "mingw_make.h" +#include "msvc_dsp.h" +#include "msvc_vcproj.h" +#include "metrowerks_xml.h" +#include "pbuilder_pbx.h" +#include "projectgenerator.h" + +MakefileGenerator * +MakefileGenerator::create(TQMakeProject *proj) +{ + if(Option::qmake_mode == Option::TQMAKE_GENERATE_PROJECT) + return new ProjectGenerator(proj); + + MakefileGenerator *mkfile = NULL; + TQString gen = proj->first("MAKEFILE_GENERATOR"); + if(gen.isEmpty()) { + fprintf(stderr, "No generator specified in config file: %s\n", + proj->projectFile().latin1()); + } else if(gen == "UNIX") { + mkfile = new UnixMakefileGenerator(proj); + } else if(gen == "MSVC") { + // Visual Studio =< v6.0 + if(proj->first("TEMPLATE").tqfind(TQRegExp("^vc.*")) != -1) + mkfile = new DspMakefileGenerator(proj); + else + mkfile = new NmakeMakefileGenerator(proj); + } else if(gen == "MSVC.NET") { + // Visual Studio >= v7.0 + if(proj->first("TEMPLATE").tqfind(TQRegExp("^vc.*")) != -1) + mkfile = new VcprojGenerator(proj); + else + mkfile = new NmakeMakefileGenerator(proj); + } else if(gen == "BMAKE") { + mkfile = new BorlandMakefileGenerator(proj); + } else if(gen == "MINGW") { + mkfile = new MingwMakefileGenerator(proj); + } else if(gen == "METROWERKS") { + mkfile = new MetrowerksMakefileGenerator(proj); + } else if(gen == "PROJECTBUILDER") { + mkfile = new ProjectBuilderMakefileGenerator(proj); + } else { + fprintf(stderr, "Unknown generator specified: %s\n", gen.latin1()); + } + return mkfile; +} |