/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the tools applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*

  config.cpp

*/

#include "archiveextractor.h"

#include "config.h"

#include "uncompressor.h"

#include <stdlib.h>

QT_BEGIN_NAMESPACE

/*

  An entry on the MetaStack.

 */

class MetaStackEntry

{

public:

    void open();

    void close();

    QStringList accum;

    QStringList next;

};

/*

 */

void MetaStackEntry::open()

{

    next.append(QString());

}

/*

 */

void MetaStackEntry::close()

{

    accum += next;

    next.clear();

}

/*

  ###

*/

class MetaStack : private QStack<MetaStackEntry>

{

public:

    MetaStack();

    void process(QChar ch, const Location& location);

    QStringList getExpanded(const Location& location);

};

MetaStack::MetaStack()

{

    push(MetaStackEntry());

    top().open();

}

void MetaStack::process(QChar ch, const Location& location)

{

    if (ch == QLatin1Char('{')) {

        push(MetaStackEntry());

        top().open();

    }

    else if (ch == QLatin1Char('}')) {

        if (count() == 1)

            location.fatal(tr("Unexpected '}'"));

        top().close();

        QStringList suffixes = pop().accum;

        QStringList prefixes = top().next;

        top().next.clear();

        QStringList::ConstIterator pre = prefixes.begin();

        while (pre != prefixes.end()) {

                QStringList::ConstIterator suf = suffixes.begin();

            while (suf != suffixes.end()) {

            top().next << (*pre + *suf);

            ++suf;

            }

            ++pre;

        }

    }

    else if (ch == QLatin1Char(',') && count() > 1) {

        top().close();

        top().open();

    }

    else {

        QStringList::Iterator pre = top().next.begin();

        while (pre != top().next.end()) {

            *pre += ch;

            ++pre;

        }

    }

}

QStringList MetaStack::getExpanded(const Location& location)

{

    if (count() > 1)

        location.fatal(tr("Missing '}'"));

    top().close();

    return top().accum;

}

QT_STATIC_CONST_IMPL QString Config::dot = QLatin1String(".");

QMap<QString, QString> Config::uncompressedFiles;

QMap<QString, QString> Config::extractedDirs;

int Config::numInstances;

/*!

  \class Config

  \brief The Config class contains the configuration variables

  for controlling how qdoc produces documentation.

  Its load() function, reads, parses, and processes a qdocconf file.

 */

/*!

  The constructor sets the \a programName and initializes all

  internal state variables to empty values.

 */

Config::Config(const QString& programName)

    : prog(programName)

{

    loc = Location::null;

    lastLoc = Location::null;

    locMap.clear();

    stringValueMap.clear();

    stringListValueMap.clear();

    numInstances++;

}

/*!

  The destructor deletes all the temporary files and

  directories it built.

 */

Config::~Config()

{

    if (--numInstances == 0) {

	QMap<QString, QString>::ConstIterator f = uncompressedFiles.begin();

	while (f != uncompressedFiles.end()) {

	    QDir().remove(*f);

	    ++f;

	}

	uncompressedFiles.clear();

	QMap<QString, QString>::ConstIterator d = extractedDirs.begin();

	while (d != extractedDirs.end()) {

	    removeDirContents(*d);

	    QDir dir(*d);

	    QString name = dir.dirName();

	    dir.cdUp();

	    dir.rmdir(name);

	    ++d;

	}

	extractedDirs.clear();

    }

}

/*!

  Loads and parses the qdoc configuration file \a fileName.

  This function calls the other load() function, which does

  the loading, parsing, and processing of the configuration

  file.

  Intializes the location variables returned by location()

  and lastLocation().

 */

void Config::load(const QString& fileName)

{

    load(Location::null, fileName);

    if (loc.isEmpty()) {

	loc = Location(fileName);

    }

    else {

	loc.setEtc(true);

    }

    lastLoc = Location::null;

}

/*!

  Joins all the strings in \a values into a single string with the

  individual \a values separated by ' '. Then it inserts the result

  into the string list map with \a var as the key.

  It also inserts the \a values string list into a separate map,

  also with \a var as the key.

 */

void Config::setStringList(const QString& var, const QStringList& values)

{

    stringValueMap[var] = values.join(QLatin1String(" "));

    stringListValueMap[var] = values;

}

/*!

  Looks up the configuarion variable \a var in the string

  map and returns the boolean value.

 */

bool Config::getBool(const QString& var) const

{

    return QVariant(getString(var)).toBool();

}

/*!

  Looks up the configuration variable \a var in the string list

  map. Iterates through the string list found, interpreting each

  string in the list as an integer and adding it to a total sum.

  Returns the sum.

 */

int Config::getInt(const QString& var) const

{

    QStringList strs = getStringList(var);

    QStringList::ConstIterator s = strs.begin();

    int sum = 0;

    while (s != strs.end()) {

	sum += (*s).toInt();

	++s;

    }

    return sum;

}

/*!

  First, this function looks up the configuration variable \a var

  in the location map and, if found, sets the internal variable

  \c{lastLoc} to the Location that \a var maps to.

  Then it looks up the configuration variable \a var in the string

  map, and returns the string that \a var maps to.

 */

QString Config::getString(const QString& var) const

{

    if (!locMap[var].isEmpty())

	(Location&) lastLoc = locMap[var];

    return stringValueMap[var];

}

/*!

  Looks up the configuration variable \a var in the string

  list map, converts the string list it maps to into a set

  of strings, and returns the set.

 */

QSet<QString> Config::getStringSet(const QString& var) const

{

    return QSet<QString>::fromList(getStringList(var));

}

/*!

  First, this function looks up the configuration variable \a var

  in the location map and, if found, sets the internal variable

  \c{lastLoc} the Location that \a var maps to.

  Then it looks up the configuration variable \a var in the string

  list map, and returns the string list that \a var maps to.

 */

QStringList Config::getStringList(const QString& var) const

{

    if (!locMap[var].isEmpty())

	(Location&) lastLoc = locMap[var];

    return stringListValueMap[var];

}

/*!

  Calls getRegExpList() with the control variable \a var and

  iterates through the resulting list of regular expressions,

  concatening them with some extras characters to form a single

  QRegExp, which is returned/

  \sa getRegExpList()

 */

QRegExp Config::getRegExp(const QString& var) const

{

    QString pattern;

    QList<QRegExp> subRegExps = getRegExpList(var);

    QList<QRegExp>::ConstIterator s = subRegExps.begin();

    while (s != subRegExps.end()) {

        if (!(*s).isValid())

            return *s;

        if (!pattern.isEmpty())

            pattern += QLatin1Char('|');

        pattern += QLatin1String("(?:") + (*s).pattern() + QLatin1Char(')');

        ++s;

    }

    if (pattern.isEmpty())

        pattern = QLatin1String("$x"); // cannot match

    return QRegExp(pattern);

}

/*!

  Looks up the configuration variable \a var in the string list

  map, converts the string list to a list of regular expressions,

  and returns it.

 */

QList<QRegExp> Config::getRegExpList(const QString& var) const

{

    QStringList strs = getStringList(var);

    QStringList::ConstIterator s = strs.begin();

    QList<QRegExp> regExps;

    while (s != strs.end()) {

	regExps += QRegExp(*s);

	++s;

    }

    return regExps;

}

/*!

  This function is slower than it could be.

 */

QSet<QString> Config::subVars(const QString& var) const

{

    QSet<QString> result;

    QString varDot = var + QLatin1Char('.');

    QMap<QString, QString>::ConstIterator v = stringValueMap.begin();

    while (v != stringValueMap.end()) {

        if (v.key().startsWith(varDot)) {

            QString subVar = v.key().mid(varDot.length());

            int dot = subVar.indexOf(QLatin1Char('.'));

            if (dot != -1)

                subVar.truncate(dot);

            result.insert(subVar);

        }

        ++v;

    }

    return result;

}

/*!

  Builds and returns a list of file pathnames for the file

  type specified by \a filesVar (e.g. "headers" or "sources").

  The files are found in the directories specified by

  \a dirsVar, and they are filtered by \a defaultNameFilter

  if a better filter can't be constructed from \a filesVar.

  The directories in \a excludedDirs are avoided.

 */

QStringList Config::getAllFiles(const QString &filesVar,

                                const QString &dirsVar,

				const QString &defaultNameFilter,

                                const QSet<QString> &excludedDirs)

{

    QStringList result = getStringList(filesVar);

    QStringList dirs = getStringList(dirsVar);

    QString nameFilter = getString(filesVar + dot +

        QLatin1String(CONFIG_FILEEXTENSIONS));

    if (nameFilter.isEmpty())

        nameFilter = defaultNameFilter;

    QStringList::ConstIterator d = dirs.begin();

    while (d != dirs.end()) {

	result += getFilesHere(*d, nameFilter, excludedDirs);

	++d;

    }

    return result;

}

/*!

  \a fileName is the path of the file to find.

  \a files and \a dirs are the lists where we must find the

  components of \a fileName.

  \a location is used for obtaining the file and line numbers

  for report qdoc errors.

 */

QString Config::findFile(const Location& location,

                         const QStringList& files,

                         const QStringList& dirs,

                         const QString& fileName,

                         QString& userFriendlyFilePath)

{

    if (fileName.isEmpty() || fileName.startsWith(QLatin1Char('/'))) {

        userFriendlyFilePath = fileName;

        return fileName;

    }

    QFileInfo fileInfo;

    QStringList components = fileName.split(QLatin1Char('?'));

    QString firstComponent = components.first();

    QStringList::ConstIterator f = files.begin();

    while (f != files.end()) {

	if (*f == firstComponent ||

            (*f).endsWith(QLatin1Char('/') + firstComponent)) {

	    fileInfo.setFile(*f);

	    if (!fileInfo.exists())

		location.fatal(tr("File '%1' does not exist").arg(*f));

	    break;

	}

	++f;

    }

    if (fileInfo.fileName().isEmpty()) {

	QStringList::ConstIterator d = dirs.begin();

	while (d != dirs.end()) {

	    fileInfo.setFile(QDir(*d), firstComponent);

	    if (fileInfo.exists()) {

		break;

            }

	    ++d;

	}

    }

    userFriendlyFilePath = QString();

    if (!fileInfo.exists())

	    return QString();

    QStringList::ConstIterator c = components.begin();

    for (;;) {

	bool isArchive = (c != components.end() - 1);

	ArchiveExtractor *extractor = 0;

	QString userFriendly = *c;

	if (isArchive) {

	    extractor = ArchiveExtractor::extractorForFileName(userFriendly);

        }

	if (extractor == 0) {

	    Uncompressor *uncompressor =

		    Uncompressor::uncompressorForFileName(userFriendly);

	    if (uncompressor != 0) {

		QString fileNameWithCorrectExtension =

			uncompressor->uncompressedFilePath(

				fileInfo.filePath());

		QString uncompressed = uncompressedFiles[fileInfo.filePath()];

		if (uncompressed.isEmpty()) {

		    uncompressed =

                        QTemporaryFile(fileInfo.filePath()).fileName();

		    uncompressor->uncompressFile(location,

                                                 fileInfo.filePath(),

                                                 uncompressed);

		    uncompressedFiles[fileInfo.filePath()] = uncompressed;

		}

		fileInfo.setFile(uncompressed);

		if (isArchive) {

		    extractor = ArchiveExtractor::extractorForFileName(

					fileNameWithCorrectExtension);

		}

                else {

		    userFriendly = fileNameWithCorrectExtension;

		}

	    }

	}

	userFriendlyFilePath += userFriendly;

	if (isArchive) {

	    if (extractor == 0)

		location.fatal(tr("Unknown archive type '%1'")

				.arg(userFriendlyFilePath));

	    QString extracted = extractedDirs[fileInfo.filePath()];

	    if (extracted.isEmpty()) {

		extracted = QTemporaryFile(fileInfo.filePath()).fileName();

		if (!QDir().mkdir(extracted))

		    location.fatal(tr("Cannot create temporary directory '%1'")

				    .arg(extracted));

		extractor->extractArchive(location, fileInfo.filePath(),

					   extracted);

		extractedDirs[fileInfo.filePath()] = extracted;

	    }

	    ++c;

	    fileInfo.setFile(QDir(extracted), *c);

	}

        else {

	    break;

	}

	userFriendlyFilePath += "?";

    }

    return fileInfo.filePath();

}

/*!

 */

QString Config::findFile(const Location& location,

                         const QStringList& files,

                         const QStringList& dirs,

                         const QString& fileBase,

                         const QStringList& fileExtensions,

                         QString& userFriendlyFilePath)