/****************************************************************************
** $Id:  qt/option.cpp   3.0.0-beta6   edited Sep 11 13:50 $
**
** Definition of ________ class.
**
** Created : 970521
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the network module of the Qt GUI Toolkit.
**
** 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
** with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "option.h"
#include <qdir.h>
#include <qregexp.h>
#include <stdlib.h>
#include <stdarg.h>

//convenience
QString Option::prl_ext;
QString Option::ui_ext;
QString Option::h_ext;
QString Option::moc_ext;
QString 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::yacc_mod;
QString Option::lex_mod;
QString Option::cc_ext;
QString Option::cxx_ext;

//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::user_vars;
QString Option::user_template;
#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;
#else
Option::TARG_MODE Option::target_mode = Option::TARG_UNIX_MODE;
#endif

//QMAKE_GENERATE_PROJECT stuff
bool Option::projfile::do_pwd = 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_dep_heuristics = TRUE;
bool Option::mkfile::do_preprocess = FALSE;
bool Option::mkfile::do_cache = TRUE;
QString Option::mkfile::cachefile;
QStringList Option::mkfile::project_files;


bool usage(const char *a0)
{
    fprintf(stderr, "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"
	    "\n"
	    "Mode:\n"
	    "\t-project       Put qmake into project file generation mode\n"
	    "\t               In this mode qmake interprets files as files to\n"
	    "\t               be built,\n"
	    "\t               defaults to *.cpp; *.l; *.y; *.ui\n"
	    "\t-makefile      Put qmake into makefile generation mode (assumed)\n"
	    "\t               In this mode qmake interprets files project files to\n"
	    "\t               be built, if skipped qmake will try to find a project\n"
	    "\t               file in your current working directory\n"
	    "\n"
	    "Warnings Options:\n"
	    "\t-Wnone         Turn off all warnings\n"
	    "\t-Wall          Turn on all warnings\n"
	    "\t-Wparser       Turn on parser warnings\n"
	    "\t-Wlogic        Turn on logic warnings\n"
	    "\n"
	    "Options:\n"
	    "\t-o file        Write output to file\n"
	    "\t-unix          Run in unix mode\n"
	    "\t-win32         Run in win32 mode\n"
	    "\t-d             Increase debug level\n"
	    "\t-t templ       Overrides TEMPLATE as templ\n"
	    "\t-help          This help\n"
	    "\t-v             Version information\n"
	    "\t-cache file    Use file as cache           [makefile mode only]\n"
	    "\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-nopwd         Don't look for files in pwd [ project mode only]\n"
	    ,a0);
    return FALSE;
}
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;
    return Option::QMAKE_GENERATE_MAKEFILE;
}


bool
Option::parseCommandLine(int argc, char **argv)
{
    for(int x = 1; 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 == "makefile") {
		    Option::qmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
		} else {
		    specified = FALSE;
		    Option::qmake_mode = default_mode(argv[0]);
		}
		if(specified)
		    continue;
	    }
	    //all modes
	    if(opt == "o" || opt == "output") {
		Option::output.setName(argv[++x]);
	    } else if(opt == "t" || opt == "template") {
		Option::user_template = argv[++x];
	    } else if(opt == "mac9") {
		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\n", QMAKE_VERSION);
		fprintf(stderr, "Qmake is free software from Trolltech AS.\n");
		return FALSE;
	    } else if(opt == "h" || opt == "help") {
		return usage(argv[0]);
	    } 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) {
		    if(opt == "nodepend") {
			Option::mkfile::do_deps = FALSE;
		    } else if(opt == "nocache") {
			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 == "spec") {
			Option::mkfile::qmakespec = argv[++x];
		    } else {
			fprintf(stderr, "***Unknown option -%s\n", opt.latin1());
			return usage(argv[0]);
		    }
		} else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
		    if(opt == "nopwd") {
			Option::projfile::do_pwd = FALSE;
		    } else {
			fprintf(stderr, "***Unknown option -%s\n", opt.latin1());
			return usage(argv[0]);
		    }
		}
	    }
	}
	else {
	    if(x == 1)
		Option::qmake_mode = default_mode(argv[0]);

	    QString arg = argv[x];
	    if(arg.find('=') != -1) {
		Option::user_vars.append(arg);
	    } else {
		if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE)
		    Option::mkfile::project_files.append(arg);
		else
		    Option::projfile::project_dirs.append(arg);
	    }
	}
    }

    if(Option::qmake_mode == Option::QMAKE_GENERATE_NOTHING)
	Option::qmake_mode = default_mode(argv[0]);

    //last chance for defaults
    if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE) {
	if(Option::mkfile::cachefile.isNull() || Option::mkfile::cachefile.isEmpty()) {
	    if(Option::mkfile::do_cache) {
		QString dir = QDir::convertSeparators(QDir::currentDirPath());
		while(!QFile::exists((Option::mkfile::cachefile = dir +
				      QDir::separator() + ".qmake.cache"))) {
		    dir = dir.left(dir.findRev(QDir::separator()));
		    if(dir.isEmpty() || dir.find(QDir::separator()) == -1) {
			Option::mkfile::cachefile = "";
			break;
		    }
		    if(Option::mkfile::cachefile_depth == -1)
			Option::mkfile::cachefile_depth = 1;
		    else
			Option::mkfile::cachefile_depth++;
		}
	    }
	}

	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.count()) {
	    QString proj = QDir::currentDirPath();
	    proj = proj.right(proj.length() - (proj.findRev('/') + 1)) + ".pro";
	    if(QFile::exists(proj)) {
		Option::qmake_mode = default_mode(argv[0]);
		Option::mkfile::project_files.append(proj);
	    } else {
		return usage(argv[0]);
	    }
	}
    }

    //defaults for globals
    Option::moc_mod = "moc_";
    Option::lex_mod = "_lex";
    Option::yacc_mod = "_yacc";
    Option::prl_ext = ".prl";
    Option::ui_ext = ".ui";
    Option::h_ext = ".h";
    Option::moc_ext = ".moc";
    Option::cpp_ext = ".cpp";
    Option::cc_ext = ".cc";
    Option::cxx_ext = ".cxx";
    Option::lex_ext = ".l";
    Option::yacc_ext = ".y";
    if(Option::target_mode == Option::TARG_WIN_MODE) {
	Option::dir_sep = "\\";
	Option::obj_ext =  ".obj";
    } else {
	if(Option::target_mode == Option::TARG_MAC9_MODE)
	    Option::dir_sep = ":";
	else
	    Option::dir_sep = "/";
	Option::obj_ext = ".o";
    }
    return TRUE;
}

bool Option::postProcessProject(QMakeProject *project)
{
    if(!project->isEmpty("QMAKE_EXT_PRL"))
	Option::prl_ext = project->first("QMAKE_EXT_PRL");
    if(!project->isEmpty("QMAKE_EXT_UI"))
	Option::ui_ext = project->first("QMAKE_EXT_UI");
    if(!project->isEmpty("QMAKE_EXT_H"))
	Option::h_ext = project->first("QMAKE_EXT_H");
    if(!project->isEmpty("QMAKE_EXT_MOC"))
	Option::moc_ext = project->first("QMAKE_EXT_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_CPP"))
	Option::cpp_ext = project->first("QMAKE_EXT_CPP");
    if(!project->isEmpty("QMAKE_EXT_CC"))
	Option::cc_ext = project->first("QMAKE_EXT_CC");
    if(!project->isEmpty("QMAKE_EXT_CXX"))
	Option::cxx_ext = project->first("QMAKE_EXT_CXX");
    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_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, rep_len;
    QRegExp reg_var("\\$\\(.*\\)");
    while((rep = reg_var.match(x, 0, &rep_len)) != -1)
	x.replace(rep, rep_len, QString(getenv(x.mid(rep + 2, rep_len - 3).latin1())));
}
static QString fixPath(QString x)
{
#if 0
    QFileInfo fi(x);
    if(fi.isDir()) {
	QDir dir(x);
	x = dir.canonicalPath();
    } else {
	QString dir = fi.dir().canonicalPath();
	if(!dir.isEmpty() && dir.right(1) != Option::dir_sep)
	    dir += Option::dir_sep;
	x = dir + fi.fileName();
    }
#endif
    return QDir::cleanDirPath(x);
}


QString
Option::fixPathToTargetOS(const QString& in, bool fix_env)
{
    QString tmp(in);
    if(fix_env)
	fixEnvVariables(tmp);
    tmp = fixPath(tmp);
    QString rep;
    if(Option::target_mode == TARG_UNIX_MODE || Option::target_mode == TARG_MACX_MODE)
	rep = "[\\\\]";
    else if(Option::target_mode == TARG_MAC9_MODE)
	rep = "[/\\\\]";
    else if(Option::target_mode == TARG_WIN_MODE)
	rep = "[/]";
    return tmp.replace(QRegExp(rep), Option::dir_sep);
}

QString
Option::fixPathToLocalOS(const QString& in, bool fix_env)
{
    QString tmp(in);
    if(fix_env)
	fixEnvVariables(tmp);
    tmp = fixPath(tmp);
#if defined(Q_OS_WIN32)
    return tmp.replace(QRegExp("/"), "\\");
#else
    return tmp.replace(QRegExp("\\\\"), "/");
#endif
}

void debug_msg(int level, const char *fmt, ...)
{
    if(Option::debug_level < level)
	return;
    fprintf(stdout, "DEBUG %d: ", level);
    {
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stdout, fmt, ap);
	va_end(ap);
    }
    fprintf(stdout, "\n");
}

void warn_msg(QMakeWarn type, const char *fmt, ...)
{
    if(!(Option::warn_level & type))
	return;
    fprintf(stdout, "WARNING: ");
    {
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stdout, fmt, ap);
	va_end(ap);
    }
    fprintf(stdout, "\n");
}
