move qmake docs into qtbase

as of qttools/18a5e89623815f5355b4173a2e93609eb10289d1

Change-Id: I75cb55e0c404449a4e0d963e09185287a3f6343e
Reviewed-by: Martin Smith <martin.smith@digia.com>
Reviewed-by: Leena Miettinen <riitta-leena.miettinen@digia.com>

36 files changed, 6151 insertions, 0 deletions

diff --git a/qmake/doc/qmake.qdocconf b/qmake/doc/qmake.qdocconf
new file mode 100644
index 0000000000..67e6e95650
--- /dev/null
+++ b/qmake/doc/qmake.qdocconf
@@ -0,0 +1,26 @@
+include($QT_INSTALL_DOCS/global/qt-module-defaults.qdocconf)
+
+project                 = QMake
+description             = QMake Manual
+url                     = http://qt-project.org/doc/qt-$QT_VER/qmake
+
+qhp.projects            = qmake
+
+qhp.qmake.file                = qmake.qhp
+qhp.qmake.namespace           = org.qt-project.qmake.$QT_VERSION_TAG
+qhp.qmake.virtualFolder       = qmake
+qhp.qmake.indexTitle          = QMake Manual
+qhp.qmake.filterAttributes    = qt $QT_VERSION tools qmake
+qhp.qmake.customFilters.qmake.name = qmake Manual
+qhp.qmake.customFilters.qmake.filterAttributes = qt tools qmake
+qhp.qmake.subprojects         = manual
+qhp.qmake.subprojects.manual.title = Manual
+qhp.qmake.subprojects.manual.indexTitle = qmake Manual
+qhp.qmake.subprojects.manual.selectors = fake:page
+
+language                = Cpp
+
+sources                 = src/qmake-manual.qdoc
+
+imagedirs               = src/images
+exampledirs             = src
diff --git a/qmake/doc/src/images/qmake-precompile-ui.png b/qmake/doc/src/images/qmake-precompile-ui.png
new file mode 100644
index 0000000000..8c7b936fee
--- /dev/null
+++ b/qmake/doc/src/images/qmake-precompile-ui.png
diff --git a/qmake/doc/src/qmake-manual.qdoc b/qmake/doc/src/qmake-manual.qdoc
new file mode 100644
index 0000000000..5552f6344e
--- /dev/null
+++ b/qmake/doc/src/qmake-manual.qdoc
@@ -0,0 +1,4491 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \page qmake-manual.html
+    \title qmake Manual
+    \startpage {index.html}{Qt Reference Documentation}
+    \nextpage Overview
+
+    \ingroup qttools
+    \keyword qmake
+
+    The qmake tool helps simplify the build process for development projects
+    across different platforms. It automates the generation of Makefiles so that
+    only a few lines of information are needed to create each Makefile.
+    You can use qmake for any software project, whether it is written with Qt or
+    not.
+
+    qmake generates a Makefile based on the information in a
+    project file. Project files are created by the developer, and are usually
+    simple, but more sophisticated project files can be created for complex
+    projects.
+
+    qmake contains additional features to support development
+    with Qt, automatically including build rules for \l{moc.html}{moc}
+    and \l{uic.html}{uic}.
+
+    qmake can also generate projects for Microsoft Visual studio
+    without requiring the developer to change the project file.
+
+    \section1 Table of Contents
+
+    \list
+        \li \l{Overview}
+        \li \l{Getting Started}
+        \li \l{Creating Project Files}
+        \li \l{Building Common Project Types}
+        \li \l{Running qmake}
+        \li \l{Platform Notes}
+        \li \l{qmake Language}
+        \li \l{Advanced Usage}
+        \li \l{Using Precompiled Headers}
+        \li \l{Configuring qmake}
+        \li \l{Reference}
+        \list
+            \li \l{Variables}
+            \li \l{Replace Functions}
+            \list
+                \li \l{Built-in Replace Functions}
+           \endlist
+           \li \l{Test Functions}
+            \list
+                \li \l{Built-in Test Functions}
+                \li \l{Test Function Library}
+            \endlist
+        \endlist
+    \endlist
+*/
+
+/*!
+    \page qmake-overview.html
+    \title Overview
+    \contentspage {qmake Manual}{Contents}
+    \previouspage qmake Manual
+    \nextpage Getting Started
+
+    The qmake tool provides you with a project-oriented system for managing the
+    build process for applications, libraries, and other components.
+    This approach gives you control over the source files used, and
+    allows each of the steps in the process to be described concisely,
+    typically within a single file. qmake expands
+    the information in each project file to a Makefile that executes the necessary
+    commands for compiling and linking.
+
+    \section1 Describing a Project
+
+    Projects are described by the contents of project (\c .pro) files. qmake
+    uses the information within the files to generate Makefiles that contain
+    all the commands that are needed to build each project.
+    Project files typically contain a list of source and header files,
+    general configuration information, and any application-specific details,
+    such as a list of extra libraries to link against, or a list of extra
+    include paths to use.
+
+    Project files can contain a number of different elements, including
+    comments, variable declarations, built-in functions, and some simple
+    control structures. In most simple projects, it is only necessary
+    to declare the source and header files that are used to build the
+    project with some basic configuration options. For more information about
+    how to create a simple project file, see \l{Getting Started}.
+
+    You can create more sophisticated project files for complex projects. For an
+    overview of project files, see \l{Creating Project Files}. For detailed
+    information about the variables and functions that you can use in project
+    files, see \l{Reference}.
+
+    You can use application or library project templates to specify specialized
+    configuration options to fine tune the build process. For more information,
+    see \l{Building Common Project Types}.
+
+    You can use the \l{external: Qt Creator Manual}{Qt Creator} new project
+    wizard to create the project file. You choose the project template, and Qt
+    Creator creates a project file with default values that enable you to build
+    and run the project. You can modify the project file to suit your purposes.
+
+    You can also use qmake to generate project files. For a full description of
+    qmake command line options, see \l{Running qmake}.
+
+    The basic configuration features of qmake can handle most cross-platform
+    projects. However, it might be useful, or even necessary, to use some
+    platform-specific variables. For more information, see \l{Platform Notes}.
+
+    \section1 Building a Project
+
+    For simple projects, you only need to run qmake in the top level directory
+    of your project to generate a Makefile. You can then run your platform's
+    \c make tool to build the project according to the Makefile.
+
+    For more information about the environment variables that qmake uses when
+    configuring the build process, see \l{Configuring qmake}.
+
+    \section1 Using Third Party Libraries
+
+    The guide to \l{Third Party Libraries} shows you how to use simple third
+    party libraries in your Qt project.
+
+    \section1 Precompiling Headers
+
+    In large projects, it is possible to take advantage of precompiled
+    header files to speed up the build process. For more information, see
+    \l{Using Precompiled Headers}.
+*/
+
+/*!
+    \page qmake-project-files.html
+    \title Creating Project Files
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Getting Started
+    \nextpage Building Common Project Types
+
+    Project files contain all the information required by qmake to build your
+    application, library, or plugin. Generally, you use a series of declarations
+    to specify the resources in the project, but support for simple programming
+    constructs enables you to describe different build processes for different
+    platforms and environments.
+
+    \section1 Project File Elements
+
+    The project file format used by qmake can be
+    used to support both simple and fairly complex build systems.
+    Simple project files use a straightforward declarative style,
+    defining standard variables to indicate the source and header files
+    that are used in the project. Complex projects may use control flow
+    structures to fine-tune the build process.
+
+    The following sections describe the different types of elements used
+    in project files.
+
+    \target ProjectFileElementsVariables
+    \section2 Variables
+
+    In a project file, variables are used to hold lists of strings. In the
+    simplest projects, these variables inform qmake
+    about the configuration options to use, or supply filenames and paths to
+    use in the build process.
+
+    qmake looks for certain variables in each
+    project file, and it uses the contents of these to determine what it
+    should write to a Makefile. For example, the lists of values in the
+    \l{HEADERS} and \l{SOURCES} variables are used to tell qmake about header
+    and source files in the same directory as the project file.
+
+    Variables can also be used internally to store temporary lists of values,
+    and existing lists of values can be overwritten or extended with new
+    values.
+
+    The following snippet illustrates how lists of values are assigned to
+    variables:
+
+    \snippet snippets/qmake/variables.pro 0
+
+    The list of values in a variable is extended in the following way:
+
+    \snippet snippets/qmake/variables.pro 1
+
+    \note The first assignment only includes values that are specified on
+    the same line as the \c HEADERS variable. The second assignment splits
+    the values in the \c SOURCES variable across lines by using a backslash
+    (\\).
+
+    The \l{CONFIG} variable is another special variable that qmake uses when
+    generating a Makefile. It is discussed in \l{General Configuration}.
+    In the snippet above, \c console is added to the list of existing values
+    contained in \c CONFIG.
+
+    The following table lists some frequently used variables and describes their
+    contents. For a full list of variables and their descriptions,
+    see \l{Variables}.
+
+    \table
+    \header \li Variable \li Contents
+    \row \li \l{CONFIG}  \li General project configuration options.
+    \row \li \l{DESTDIR} \li The directory in which the executable or binary file will
+                      be placed.
+    \row \li \l{FORMS}   \li A list of UI files to be processed by the
+                         \l{uic}{user interface compiler (uic)}.
+    \row \li \l{HEADERS} \li A list of filenames of header (.h) files used when
+                      building the project.
+    \row \li \l{Variables#QT}{QT} \li A list of Qt modules used in the project.
+    \row \li \l{RESOURCES} \li A list of resource (.qrc) files to be included in the
+                      final project. See the \l{The Qt Resource System} for
+                      more information about these files.
+    \row \li \l{SOURCES}  \li A list of source code files to be used when building
+                      the project.
+    \row \li \l{TEMPLATE} \li The template to use for the project. This determines
+                      whether the output of the build process will be an
+                      application, a library, or a plugin.
+    \endtable
+
+    The contents of a variable can be read by prepending the variable name with
+    \c $$. This can be used to assign the contents of one variable to another:
+
+    \snippet snippets/qmake/dereferencing.pro 0
+
+    The \c $$ operator is used extensively with built-in functions that operate
+    on strings and lists of values. For more information, see
+    \l{qmake Language}.
+
+    \section3 Whitespace
+
+    Usually, whitespace separates values in variable assignments. To specify
+    values that contain spaces, you must enclose the values in double quotes:
+
+    \snippet snippets/qmake/quoting.pro 0
+
+    The quoted text is treated as a single item in the list of values held by
+    the variable. A similar approach is used to deal with paths that contain
+    spaces, particularly when defining the
+    \l{INCLUDEPATH} and \l{LIBS} variables for the Windows platform:
+
+    \snippet snippets/qmake/spaces.pro quoting include paths with spaces
+
+    \section2 Comments
+
+    You can add comments to project files. Comments begin with the \c
+    # character and continue to the end of the same line. For example:
+
+    \snippet snippets/qmake/comments.pro 0
+
+    To include the \c # character in variable assignments, it is necessary
+    to use the contents of the built-in \l{LITERAL_HASH} variable.
+
+    \section2 Built-in Functions and Control Flow
+
+    qmake provides a number of built-in functions to enable the contents of
+    variables to be processed. The most commonly used function in simple
+    project files is the \l{include(filename)}{include()} function which takes a
+    filename as an
+    argument. The contents of the given file are included in the project
+    file at the place where the \c include function is used.
+    The \c include function is most commonly used to include other project
+    files:
+
+    \snippet snippets/qmake/include.pro 0
+
+    Support for conditional structures is made available via
+    \l{Scopes}{scopes} that behave like \c if statements in programming languages:
+
+    \snippet snippets/qmake/scopes.pro 0
+
+    The assignments inside the braces are only made if the condition is
+    true. In this case, the \c win32 \l{CONFIG} option must be set. This
+    happens automatically on Windows. The opening brace must stand on the same
+    line as the condition.
+
+    More complex operations on variables that would usually require loops
+    are provided by built-in functions such as \l{findfunction}{find()},
+    \l{unique}{unique()}, and \l{countfunction}{count()}. These functions, and
+    many others are provided to manipulate
+    strings and paths, support user input, and call external tools. For more
+    information about using the functions, see \l{qmake Language}. For lists
+    of all functions and their descriptions, see \l{Replace Functions} and
+    \l{Test Functions}.
+
+    \section1 Project Templates
+
+    The \l{TEMPLATE} variable is used to define the type of project that will
+    be built. If this is not declared in the project file,
+    qmake assumes that an application should be
+    built, and will generate an appropriate Makefile (or equivalent file)
+    for the purpose.
+
+    The following table summarizes the types of projects available and describes
+    the files that qmake will generate for each of them:
+
+    \table
+    \header \li Template      \li qmake Output
+    \row    \li app (default) \li Makefile to build an application.
+    \row    \li lib           \li Makefile to build a library.
+    \row    \li subdirs       \li Makefile containing rules for the
+    subdirectories specified using the \l{SUBDIRS}
+    variable. Each subdirectory must contain its own project file.
+    \row    \li vcapp         \li Visual Studio Project file to build
+                             an application.
+    \row    \li vclib         \li Visual Studio Project file to build a library.
+    \row    \li vcsubdirs     \li Visual Studio Solution file to build
+                              projects in sub-directories.
+    \endtable
+
+    See \l{Building Common Project Types} for advice on writing project files for
+    projects that use the \c app and \c lib templates.
+
+    When the \c subdirs template is used, qmake
+    generates a Makefile to examine each specified subdirectory,
+    process any project file it finds there, and run the platform's
+    \c make tool on the newly-created Makefile.
+    The \c SUBDIRS variable is used to
+    contain a list of all the subdirectories to be processed.
+
+    \target GeneralConfiguration
+    \section1 General Configuration
+
+    The \l{CONFIG} variable specifies the options and features that the project
+    should be configured with.
+
+    The project can be built in \e release mode or \e debug mode, or both.
+    If debug and release are both specified, the last one takes effect. If you
+    specify the \c debug_and_release option to build both the debug and release
+    versions of a project, the Makefile that qmake generates includes a rule
+    that builds both versions. This can be invoked in the following way:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 0
+
+    Adding the \c build_all option to the \c CONFIG variable makes this rule
+    the default when building the project.
+
+    \note Each of the options specified in the \c CONFIG variable can also be
+    used as a scope condition.
+    You can test for the presence of certain configuration options by using the
+    built-in \l{CONFIG(config)}{CONFIG()} function.
+    For example, the following lines show the function as the condition in a scope
+    to test whether only the \c opengl option is in use:
+
+    \snippet snippets/qmake/configscopes.pro 4
+    \snippet snippets/qmake/configscopes.pro 5
+
+    This enables different configurations to be defined for \c release and
+    \c debug builds. For more information, see \l{Scopes}{Using Scopes}.
+
+    The following options define the type of project to be built.
+
+    \note Some of these options only take effect when used on the relevant
+    platform.
+
+    \table
+    \header \li Option \li Description
+    \row    \li qt     \li The project is a Qt application and should link against the Qt
+                      library. You can use the \c QT variable to control any additional
+                      Qt modules that are required by your application.
+                      This value is added by default, but you can remove it to
+                      use qmake for a non-Qt project.
+    \row    \li x11    \li The project is an X11 application or library.
+                       This value is not needed if the target uses Qt.
+    \endtable
+
+    The \l{TEMPLATE}{application and library project templates} provide you with
+    more specialized configuration options to fine tune the build process. The
+    options are explained in detail in \l{Building Common Project Types}.
+
+    For example, if your application uses the Qt library and you want to
+    build it in \c debug mode, your project file will contain the following line:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 1
+
+    \note You must use "+=", not "=", or qmake
+    will not be able to use Qt's configuration to determine the settings
+    needed for your project.
+
+    \section1 Declaring Qt Libraries
+
+    If the \l{CONFIG} variable contains the \c qt value, qmake's support for Qt
+    applications is enabled. This makes it possible to fine-tune which of the
+    Qt modules are used by your application. This is achieved with the
+    \l{Variables#QT}{QT} variable which can be used to declare the required
+    extension modules.
+    For example, we can enable the XML and network modules in the following way:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 2
+
+    \note \c QT includes the \c core and \c gui modules by default, so the
+    above declaration \e adds the network and XML modules to this default list.
+    The following assignment \e omits the default modules, and will lead to
+    errors when the application's source code is being compiled:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 3
+
+    If you want to build a project \e without the \c gui module, you need to
+    exclude it with the "-=" operator. By default, \c QT contains both
+    \c core and \c gui, so the following line will result in a minimal
+    Qt project being built:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 4
+
+    For a list of Qt modules that you can add to the \c QT variable, see
+    \l{Variables#QT}{QT}.
+
+    \section1 Configuration Features
+
+    qmake can be set up with extra configuration
+    features that are specified in feature (.prf) files. These extra features
+    often provide support for custom tools that are used during the build
+    process. To add a feature to the build process, append the feature name
+    (the stem of the feature filename) to the \c CONFIG variable.
+
+    For example, qmake can configure the build
+    process to take advantage of external libraries that are supported by
+    \l{http://www.freedesktop.org/wiki/Software/pkg-config}{pkg-config},
+    such as the D-Bus and ogg libraries, with the following lines:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 5
+
+    For more information about adding features, see
+    \l{Adding New Configuration Features}.
+
+    \section1 Declaring Other Libraries
+
+    If you are using other libraries in your project in addition to those
+    supplied with Qt, you need to specify them in your project file.
+
+    The paths that qmake searches for libraries
+    and the specific libraries to link against can be added to the list of values in the
+    \l{LIBS} variable. You can specify the paths to the libraries or use the
+    Unix-style notation for specifying libraries and paths.
+
+    For example, the following lines show how a library can be specified:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 6
+
+    The paths containing header files can also be specified in a similar way
+    using the \l{INCLUDEPATH} variable.
+
+    For example, to add several paths to be searched for header files:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 7
+*/
+
+/*!
+    \page qmake-running.html
+    \title Running qmake
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Building Common Project Types
+    \nextpage Platform Notes
+
+    The behavior of qmake can be customized when it
+    is run by specifying various options on the command line. These allow the
+    build process to be fine-tuned, provide useful diagnostic
+    information, and can be used to specify the target platform for
+    your project.
+
+    \section1 Command Syntax
+
+    The syntax used to run qmake takes the following simple form:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 8
+
+    \section1 Operating Modes
+
+    qmake supports two different modes of operation. In the default mode, qmake
+    uses the information in a project file to generate a Makefile, but it is also
+    possible to use qmake to generate project files.
+    If you want to explicitly set the mode, you must specify it before all
+    other options. The \c mode can be either of the following two values:
+
+    \list
+    \li \c -makefile \BR
+        qmake output will be a Makefile.
+    \li \c -project \BR
+        qmake output will be a project file. \BR
+    \note It is likely that the created file will need to be edited. For example,
+    adding the \c QT variable to suit what modules are required for the project.
+    \endlist
+
+    You can use the \c options to specify both general and mode-specific
+    settings. Options that only apply to the Makefile mode are described in the
+    \l{#MakefileMode}{Makefile Mode Options} section, whereas options that influence the
+    creation of project files are described in the
+    \l{#ProjectMode}{Project Mode Options} section.
+
+    \section1 Files
+
+    The \c files argument represents a list of one or more project files, separated
+    by spaces.
+
+    \section1 General Options
+
+    A wide range of options can be specified on the command line to
+    qmake in order to customize the build process,
+    and to override default settings for your platform. The following basic
+    options provide help on using qmake, specify where qmake writes the output
+    file, and control the
+    level of debugging information that will be written to the console:
+
+    \list
+    \li \c -help \BR
+        qmake will go over these features and give some useful help.
+    \li \c {-o file} \BR
+        qmake output will be directed to \c file. If
+        this option is not specified, qmake will try
+        to use a suitable file name for its output, depending on the mode it is
+        running in.\BR
+        If '-' is specified, output is directed to stdout.
+    \li \c -d \BR
+        qmake will output debugging information. Adding \c -d more than once
+        increases verbosity.
+    \endlist
+
+    The template used for the project is usually specified by the \l{TEMPLATE}
+    variable in the project file. You can override or modify this by using the
+    following options:
+
+    \list
+    \li \c {-t tmpl} \BR
+        qmake will override any set \c TEMPLATE variables with \c tmpl, but only
+        \e after the .pro file has been processed.
+    \li \c {-tp prefix} \BR
+        qmake will add \c prefix to the \c TEMPLATE variable.
+    \endlist
+
+    The level of warning information can be fine-tuned to help you find problems in
+    your project file:
+
+    \list
+    \li \c -Wall \BR
+        qmake will report all known warnings.
+    \li \c -Wnone \BR
+        No warning information will be generated by qmake.
+    \li \c -Wparser \BR
+        qmake will only generate parser warnings.
+        This will alert you to common pitfalls and potential problems in the
+        parsing of your project files.
+    \li \c -Wlogic \BR
+        qmake will warn of common pitfalls and
+        potential problems in your project file. For example,
+        qmake will report multiple occurrences of files in lists and missing
+        files.
+    \endlist
+
+    \target MakefileMode
+    \section1 Makefile Mode Options
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 9
+
+    In Makefile mode, qmake will generate a Makefile
+    that is used to build the project. Additionally, the following options may
+    be used in this mode to influence the way the project file is generated:
+
+    \list
+    \li \c -after \BR
+        qmake will process assignments given on the
+        command line after the specified files.
+    \li \c -nocache \BR
+        qmake will ignore the \c{.qmake.cache} file.
+    \li \c -nodepend \BR
+        qmake will not generate any dependency
+        information.
+    \li \c {-cache file} \BR
+        qmake will use \c file as the cache file,
+        ignoring any other .qmake.cache files found.
+    \li \c {-spec spec} \BR
+        qmake will use \c spec as a path to platform and compiler information,
+        and ignore the value of \l{QMAKESPEC}.
+    \endlist
+
+    You may also pass qmake assignments on the command line. They are processed
+    before all of the files specified. For example, the following command
+    generates a Makefile from test.pro:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 10
+
+    However, some of the specified options can be omitted as they are default
+    values:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 11
+
+    If you are certain you want your variables processed after the
+    files specified, then you may pass the \c -after option. When this
+    is specified, all assignments on the command line after the \c -after
+    option will be postponed until after the specified files are parsed.
+
+    \target ProjectMode
+    \section1 Project Mode Options
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 12
+
+    In project mode, qmake will generate a project
+    file. Additionally, you may supply the following options in this mode:
+
+    \list
+    \li \c -r \BR
+       qmake will look through supplied directories recursively.
+    \li \c -nopwd \BR
+       qmake will not look in your current working directory for source code.
+       It will only use the specified \c files.
+    \endlist
+
+    In this mode, the \c files argument can be a list of files or directories.
+    If a directory is specified, it will be included in the \l{DEPENDPATH}
+    variable, and relevant code from there will be included in the generated
+    project file. If a file is given, it will be appended to the correct
+    variable, depending on its extension. For example, UI files are added
+    to \l{FORMS}, and C++ files are added to \l{SOURCES}.
+
+    You may also pass assignments on the command line in this mode. When doing
+    so, these assignments will be placed last in the generated project file.
+*/
+
+/*!
+    \page qmake-platform-notes.html
+    \title Platform Notes
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Running qmake
+    \nextpage qmake Language
+
+    Many cross-platform projects can be handled by the basic qmake configuration
+    features. However, on some platforms, it is sometimes useful, or even
+    necessary, to take advantage of platform-specific features.
+    qmake knows about many of these features, which can be accessed via specific
+    variables that only take effect on the platforms where they are relevant.
+
+    \section1 Mac OS X
+
+    Features specific to this platform include support for creating universal
+    binaries, frameworks and bundles.
+
+    \section2 Source and Binary Packages
+
+    The version of qmake supplied in source packages
+    is configured slightly differently to that supplied in binary packages in
+    that it uses a different feature specification. Where the source package
+    typically uses the \c macx-g++ specification, the binary package is
+    typically configured to use the \c macx-xcode specification.
+
+    Users of each package can override this configuration by invoking
+    qmake with the \c -spec option (see \l{Running qmake} for more information).
+    For example, to use qmake from a binary package to create a Makefile in a
+    project directory, invoke the following command:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 13
+
+    \section2 Using Frameworks
+
+    qmake is able to automatically generate build
+    rules for linking against frameworks in the standard framework directory on
+    Mac OS X, located at \c{/Library/Frameworks/}.
+
+    Directories other than the standard framework directory need to be specified
+    to the build system, and this is achieved by appending linker options to the
+    \l{QMAKE_LFLAGS} variable, as shown in the following example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 14
+
+    The framework itself is linked in by appending the \c{-framework} options and
+    the name of the framework to the \l{LIBS} variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 15
+
+    \section2 Creating Frameworks
+
+    Any given library project can be configured so that the resulting library
+    file is placed in a
+    \l{http://developer.apple.com/documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WhatAreFrameworks.html}
+    {framework}, ready for deployment. To do this, set up the project to use the
+    \l{TEMPLATE}{\c lib template} and add the \c lib_bundle option to the
+    \l{CONFIG} variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 16
+
+    The data associated with the library is specified using the
+    \l{QMAKE_BUNDLE_DATA}
+    variable. This holds items that will be installed with a library
+    bundle, and is often used to specify a collection of header files,
+    as in the following example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 17
+
+    You use the \c FRAMEWORK_HEADERS variable to specify the headers required by
+    a particular framework.
+    Appending it to the \c QMAKE_BUNDLE_DATA variable ensures that
+    information about these headers is added to the collection of
+    resources that will be installed with the library bundle. Also, the
+    framework name and version are specified by the \l {QMAKE_FRAMEWORK_BUNDLE_NAME}
+    and \l{QMAKE_FRAMEWORK_VERSION} variables. By default, the values used for
+    these variables are obtained from the \l{TARGET} and \l{VERSION} variables.
+
+    See \l{Deploying an Application on Mac OS X} for more information about
+    deploying applications and libraries.
+
+    \section2 Creating and Moving Xcode Projects
+
+    Developers on Mac OS X can take advantage of the qmake support for Xcode
+    project files, as described in
+    \l{Qt is Mac OS X Native#Development Tools}{Qt is Mac OS X Native},
+    by running qmake to generate an Xcode project from an existing qmake project
+    file. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 19
+
+    \note If a project is later moved on the disk, qmake must be run again to
+    process the project file and create a new Xcode project file.
+
+    \section2 Supporting Two Build Targets Simultaneously
+
+    Implementing this is currently not feasible, because the Xcode
+    concept of Active Build Configurations is conceptually different
+    from the qmake idea of build targets.
+
+    The Xcode Active Build Configurations settings are for modifying
+    Xcode configurations, compiler flags and similar build
+    options. Unlike Visual Studio, Xcode does not allow for the
+    selection of specific library files based on whether debug or
+    release build configurations are selected. The qmake debug and
+    release settings control which library files are linked to the
+    executable.
+
+    It is currently not possible to set files in Xcode configuration
+    settings from the qmake generated Xcode project file. The way the
+    libraries are linked in the \e {Frameworks & Libraries} phase in the
+    Xcode build system.
+
+    Furthermore, the selected \e {Active Build Configuration} is stored
+    in a .pbxuser file, which is generated by Xcode on first load, not
+    created by qmake.
+
+    \section1 Windows
+
+    Features specific to this platform include support for creating Visual
+    Studio project files and handling manifest files when deploying Qt
+    applications developed using Visual Studio 2005, or later.
+
+    \section2 Creating Visual Studio Project Files
+
+    Developers using Visual Studio to write Qt applications can use the
+    Visual Studio integration facilities provided with the
+    \l{Qt Commercial License}
+    and do not need to worry about how project dependencies are managed.
+
+    However, some developers may need to import an existing
+    qmake project into Visual Studio.
+    qmake is able to take a project file and create
+    a Visual Studio project that contains all the necessary information
+    required by the development environment. This is achieved by setting the
+    qmake \l{TEMPLATE}{project template} to either \c vcapp
+    (for application projects) or \c vclib (for library projects).
+
+    This can also be set using a command line option, for example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 20
+
+    It is possible to recursively generate \c{.vcproj} files in subdirectories
+    and a \c{.sln} file in the main directory, by typing:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 21
+
+    Each time you update the project file, you need to run
+    qmake to generate an updated Visual Studio
+    project.
+
+    \note If you are using the Visual Studio Add-in, select \gui Qt >
+    \gui{Import from .pro file} to import \c .pro files.
+
+    \section2 Visual Studio Manifest Files
+
+    When deploying Qt applications built using Visual Studio 2005, or later,
+    make sure that the manifest file that was created when the application
+    was linked is handled correctly. This is handled automatically for
+    projects that generate DLLs.
+
+    Removing manifest embedding for application executables can be done with
+    the following assignment to the \l{CONFIG} variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 22
+
+    Also, the manifest embedding for DLLs can be removed with the following
+    assignment to the \c CONFIG variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 23
+
+    This is discussed in more detail in the
+    \l{Deploying an Application on Windows#Manifest files}
+    {deployment guide for Windows}.
+*/
+
+/*!
+    \page qmake-reference.html
+    \title Reference
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Configuring qmake
+    \nextpage Variables
+
+    The reference sections describe in detail the variables and functions that
+    are available for use in qmake project files.
+
+    \section1 Variable Reference
+
+    \l{Variables} describes the variables that are recognized by qmake when
+    configuring the build process for projects.
+
+    \section1 Function Reference
+
+    There are two types of qmake functions: replace functions and test
+    functions. Replace functions return a value list, while test functions
+    return a boolean result. The functions are implemented in two places:
+    fundamental functionality is offered as built-in functions. More complex
+    functions are implemented in a library of feature files (.prf).
+
+    The functions are divided into categories according to their type:
+
+    \list
+        \li \l{Replace Functions}
+        \li \l{Test Functions}
+    \endlist
+*/
+
+/*!
+    \page qmake-variable-reference.html
+    \title Variables
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Reference
+    \nextpage Replace Functions
+
+    The fundamental behavior of qmake is influenced by variable declarations that
+    define the build process of each project. Some of these declare resources,
+    such as headers and source files, that are common to each platform. Others
+    are used to customize the behavior of compilers and linkers on specific
+    platforms.
+
+    Platform-specific variables follow the naming pattern of the
+    variables which they extend or modify, but include the name of the relevant
+    platform in their name. For example, \c QMAKE_LIBS can be used to specify a list
+    of libraries that a project needs to link against, and \c QMAKE_LIBS_X11 can be
+    used to extend or override this list.
+
+    \target CONFIG
+    \section1 CONFIG
+
+    Specifies project configuration and compiler options. The values are
+    recognized internally by qmake and have special meaning.
+
+    The following \c CONFIG values control compilation flags:
+
+    \table
+    \header \li Option   \li Description
+    \row    \li release  \li The project is to be built in release mode.
+            If \c debug is also specified, the last one takes effect.
+    \row    \li debug    \li The project is to be built in debug mode.
+    \row    \li debug_and_release \li The project is prepared to be built in
+            \e both debug and release modes.
+    \row    \li debug_and_release_target \li This option is set by default. If
+            \c debug_and_release is also set, the debug and release builds
+            end up in separate debug and release directories.
+    \row    \li build_all \li If \c debug_and_release is specified, the project is
+            built in both debug and release modes by default.
+    \row    \li autogen_precompile_source \li Automatically generates a \c .cpp
+            file that includes the precompiled header file specified in the .pro
+            file.
+    \row    \li ordered  \li When using the \c subdirs template, this option
+            specifies that the directories listed should be processed in the
+            order in which they are given.
+    \row    \li precompile_header \li Enables support for the use of
+            \l{Using Precompiled Headers}{precompiled headers} in projects.
+    \row    \li warn_on  \li The compiler should output as many warnings as possible.
+            If \c warn_off is also specified, the last one takes effect.
+    \row    \li warn_off \li The compiler should output as few warnings as possible.
+    \row    \li exceptions \li Exception support is enabled. Set by default.
+    \row    \li exceptions_off \li Exception support is disabled.
+    \row    \li rtti \li RTTI support is enabled. By default, the compiler
+            default is used.
+    \row    \li rtti_off \li RTTI support is disabled. By default, the compiler
+            default is used.
+    \row    \li stl \li STL support is enabled. By default, the compiler
+            default is used.
+    \row    \li stl_off \li STL support is disabled. By default, the compiler
+            default is used.
+    \row    \li thread \li Thread support is enabled. This is enabled when CONFIG
+            includes \c qt, which is the default.
+    \endtable
+
+    Since the \c debug option overrides the \c release option when both are
+    defined in the \c CONFIG variable, it is necessary to use the
+    \c debug_and_release option if you want to allow both debug and release
+    versions of a project to be built. In such a case, the Makefile that
+    qmake generates includes a rule that builds both
+    versions, and this can be invoked in the following way:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 24
+
+    When linking a library, qmake relies on the
+    underlying platform to know what other libraries this library links
+    against. However, if linking statically, qmake
+    will not get this information unless we use the following \c CONFIG
+    options:
+
+     \table
+     \header \li Option   \li Description
+     \row    \li create_prl  \li This option enables
+        qmake to track these dependencies. When this
+        option is enabled, qmake will create a file
+        with the extension \c .prl which will save meta-information about the library
+        (see \l{LibDepend}{Library Dependencies} for more info).
+     \row    \li link_prl    \li When this option is enabled,
+        qmake will process all libraries linked to
+        by the application and find their meta-information (see
+        \l{LibDepend}{Library Dependencies} for more info).
+     \endtable
+
+    \note The \c create_prl option is required when \e {building} a
+    static library, while \c link_prl is required when \e {using} a
+    static library.
+
+    On Windows (or if Qt is configured with \c{-debug-and-release}), add the
+    \c build_all option to the \c CONFIG variable to build all build
+    configurations by default.
+
+    Additionally, adding \c debug_and_release to the \c CONFIG variable will
+    cause both \c debug and \c release to be defined in the contents of
+    \c CONFIG. When the project file is processed, the
+    \l{Scopes}{scopes} that test for each value will be
+    processed for \e both debug and release modes. The \c{build_pass} variable
+    will be set for each of these modes, and you can test for this to perform
+    build-specific tasks. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 25
+
+    As a result, it may be useful to define mode-specific variables, such as
+    \l{#QMAKE_LFLAGS_RELEASE}{QMAKE_LFLAGS_RELEASE}, instead of general
+    variables, such as \l{#QMAKE_LFLAGS}{QMAKE_LFLAGS}, where possible.
+
+    The following options define the application or library type:
+
+    \table
+    \header \li Option \li Description
+    \row \li qt \li The target is a Qt application or library and requires the Qt
+         library and header files. The proper include and library paths for the
+         Qt library will automatically be added to the project. This is defined
+         by default, and can be fine-tuned with the \c{\l{#qt}{QT}} variable.
+    \row \li thread \li The target is a multi-threaded application or library.  The
+        proper defines and compiler flags will automatically be added to
+        the project. This value is set by default.
+    \row \li x11 \li The target is a X11 application or library. The proper
+        include paths and libraries will automatically be added to the
+        project.
+    \row \li testcase \li The target is an automated test.
+        \l{Building Common Project Types#building-a-testcase}{A check target} will be added
+        to the generated Makefile to run the test. Only relevant when generating
+        Makefiles.
+    \row \li insignificant_test \li The exit code of the automated test will be ignored.
+        Only relevant if \c testcase is also set.
+    \row \li windows \li The target is a Win32 window application (app only). The
+        proper include paths, compiler flags and libraries will
+        automatically be added to the project.
+    \row \li console \li The target is a Win32 console application (app only). The
+        proper include paths, compiler flags and libraries will
+        automatically be added to the project.
+    \row \li shared \li{1,2} The target is a shared object/DLL. The proper
+        include paths, compiler flags and libraries will automatically be
+        added to the project. Note that \c dll can also be used on all platforms;
+        a shared library file with the appropriate suffix for the target platform
+        (.dll or .so) will be created.
+    \row \li dll
+    \row \li static \li{1,2} The target is a static library (lib only).  The proper
+        compiler flags will automatically be added to the project.
+    \row \li staticlib
+    \row \li plugin \li The target is a plugin (lib only). This enables dll as well.
+    \row \li designer \li The target is a plugin for \QD.
+    \row \li no_lflags_merge \li Ensures that the list of libraries stored in the
+         \c LIBS variable is not reduced to a list of unique values before it is used.
+    \row \li resources \li Configures qmake to run rcc on the content of \c RESOURCES
+         if defined.
+    \endtable
+
+    These options define specific features on Windows only:
+
+    \table
+    \header \li Option \li Description
+    \row \li flat \li When using the vcapp template this will put all the source
+         files into the source group and the header files into the header group
+         regardless of what directory they reside in.  Turning this
+         option off will group the files within the source/header group depending
+         on the directory they reside. This is turned on by default.
+    \row \li embed_manifest_dll \li Embeds a manifest file in the DLL created
+         as part of a library project.
+    \row \li embed_manifest_exe \li Embeds a manifest file in the DLL created
+         as part of an application project.
+    \row \li incremental \li Used to enable or disable incremental linking in Visual
+         C++, depending on whether this feature is enabled or disabled by default.
+    \endtable
+
+    See \l{Platform Notes#Visual Studio Manifest Files}{Platform Notes}
+    for more information about the options for embedding manifest files.
+
+    The following options take an effect only on Mac OS X:
+
+    \table
+    \header \li Option \li Description
+    \row \li ppc \li Builds a PowerPC binary.
+    \row \li x86 \li Builds an i386 compatible binary.
+    \row \li app_bundle \li Puts the executable into a bundle (this is the default).
+    \row \li lib_bundle \li Puts the library into a library bundle.
+    \endtable
+
+    The build process for bundles is also influenced by
+    the contents of the \l{#QMAKE_BUNDLE_DATA}{QMAKE_BUNDLE_DATA} variable.
+
+    The following options take an effect only on Linux/Unix platforms:
+
+    \table
+    \header \li Option \li Description
+    \row \li largefile \li Includes support for large files.
+    \row \li separate_debug_info \li Puts debugging information for libraries in
+    separate files.
+    \endtable
+
+    The \c CONFIG variable will also be checked when resolving scopes. You may
+    assign anything to this variable.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 26
+
+    \target DEFINES
+    \section1 DEFINES
+
+    qmake adds the values of this variable as
+    compiler C preprocessor macros (-D option).
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 27
+
+    \target DEF_FILE
+    \section1 DEF_FILE
+
+    \note This variable is used only on Windows when using the \c app template.
+
+    Specifies a \c .def file to be included in the project.
+
+    \target DEPENDPATH
+    \section1 DEPENDPATH
+
+    Specifies a list of all directories to look in to resolve dependencies. This
+    variable is used when crawling through \c included files.
+
+    \target DEPLOYMENT
+    \section1 DEPLOYMENT
+
+    \note This variable is used only on the Windows CE platform.
+
+    Specifies which additional files will be deployed. Deployment means the
+    transfer of files from the development system to the target device or
+    emulator.
+
+    Files can be deployed by either creating a Visual Studio project or using
+    the \l {Using Qt Test remotely on Windows CE}{cetest} executable.
+
+    For example, the following definition uploads all PNG images in \c path to
+    the directory where the build target is deployed:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 28
+
+    The default deployment target path for Windows CE is
+    \c{%CSIDL_PROGRAM_FILES%\target}, which usually gets expanded to
+    \c{\Program Files\target}.
+
+    It is also possible to specify multiple \c sources to be deployed on
+    target \c paths. In addition, different variables can be used for
+    deployment to different directories.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 29
+
+    \note In Windows CE all linked Qt libraries will be deployed to the path
+    specified by \c{myFiles.path}.
+
+    \target DEPLOYMENT_PLUGIN
+    \section1 DEPLOYMENT_PLUGIN
+
+    \note This variable is used only on the Windows CE platform.
+
+    Specifies the Qt plugins that will be deployed. All plugins
+    available in Qt can be explicitly deployed to the device. See
+    \l{Static Plugins}{Static Plugins} for a complete list.
+
+    \note No plugins will be deployed automatically to Windows CE devices.
+    If the application depends on plugins, these plugins have to be specified
+    manually.
+
+    For example, the following definition uploads the jpeg imageformat plugin to
+    the plugins directory on the Windows CE device:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 142
+
+    \target DESTDIR
+    \section1 DESTDIR
+
+    Specifies where to put the \l{#TARGET}{target} file.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 30
+
+    \target DISTFILES
+    \section1 DISTFILES
+
+    Specifies a list of files to be included in the dist
+    target. This feature is supported by UnixMake specs only.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 31
+
+    \target DLLDESTDIR
+    \section1 DLLDESTDIR
+
+    \note This variable applies only to Windows targets.
+
+    Specifies where to copy the \l{#TARGET}{target} dll.
+
+    \target FORMS
+    \section1 FORMS
+
+    Specifies the UI files (see \l{Qt Designer Manual}) to be processed by \c uic
+    before compiling.  All dependencies, headers and source files required
+    to build these UI files will automatically be added to the project.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 32
+
+    \target GUID
+    \section1 GUID
+
+    Specifies the GUID that is set inside a \c{.vcproj} file. The GUID is
+    usually randomly determined. However, should you require a fixed GUID,
+    it can be set using this variable.
+
+    This variable is specific to \c{.vcproj} files only; it is ignored
+    otherwise.
+
+    \target HEADERS
+    \section1 HEADERS
+
+    Defines the header files for the project.
+
+    qmake automatically detects whether \l{moc} is required by the classes in
+    the headers, and adds the appropriate dependencies and files to the project
+    for generating and linking the moc files.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 34
+
+    See also \l{#SOURCES}{SOURCES}.
+
+    \target ICON
+    \section1 ICON
+
+    This variable is used only on Mac OS to set the application icon.
+    Please see \l{Setting the Application Icon}{the application icon documentation}
+    for more information.
+
+    \target INCLUDEPATH
+    \section1 INCLUDEPATH
+
+    Specifies the #include directories which should be
+    searched when compiling the project.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 35
+
+    To specify a path containing spaces, quote the path using the technique
+    described in \l{Whitespace}.
+
+    \snippet snippets/qmake/spaces.pro quoting include paths with spaces
+
+    \target INSTALLS
+    \section1 INSTALLS
+
+    Specifies a list of resources that will be installed when
+    \c{make install} or a similar installation procedure is executed. Each
+    item in the list is typically defined with attributes that provide
+    information about where it will be installed.
+
+    For example, the following \c{target.path} definition describes where the
+    build target will be installed, and the \c INSTALLS assignment adds the
+    build target to the list of existing resources to be installed:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 36
+
+    For more information, see \l{Installing Files}.
+
+    \target LEXIMPLS
+    \section1 LEXIMPLS
+
+    Specifies a list of Lex implementation files.  The value
+    of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target LEXOBJECTS
+    \section1 LEXOBJECTS
+
+    Specifies the names of intermediate Lex object
+    files.The value of this variable is typically handled by
+    qmake and rarely needs to be modified.
+
+    \target LEXSOURCES
+    \section1 LEXSOURCES
+
+    Specifies a list of Lex source files.  All
+    dependencies, headers and source files will automatically be added to
+    the project for building these lex files.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 37
+
+    \target LIBS
+    \section1 LIBS
+
+    Specifies a list of libraries to be linked into the project.
+    If you use the Unix \c -l (library) and -L (library path) flags, qmake
+    handles the libraries correctly on Windows (that is, passes the full path of
+    the library to the linker). The library must exist for
+    qmake to find the directory where a \c -l lib is located.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 38
+
+    To specify a path containing spaces, quote the path using the technique
+    described in \l{Whitespace}.
+
+    \snippet snippets/qmake/spaces.pro quoting library paths with spaces
+
+    By default, the list of libraries stored in \c LIBS is reduced to a list of
+    unique names before it is used. To change this behavior, add the
+    \c no_lflags_merge option to the \l{CONFIG} variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 39
+
+    \target LITERAL_HASH
+    \section1 LITERAL_HASH
+
+    This variable is used whenever a literal hash character (\c{#}) is needed in
+    a variable declaration, perhaps as part of a file name or in a string passed
+    to some external application.
+
+    For example:
+
+    \snippet snippets/qmake/comments.pro 1
+
+    By using \c LITERAL_HASH in this way, the \c # character can be used
+    to construct a URL for the \c message() function to print to the console.
+
+    \target MAKEFILE
+    \section1 MAKEFILE
+
+    Specifies the name of the generated Makefile. The value of this variable is
+    typically handled by qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to
+    be modified.
+
+    \target MAKEFILE_GENERATOR
+    \section1 MAKEFILE_GENERATOR
+
+    Specifies the name of the Makefile generator to use
+    when generating a Makefile.  The value of this variable is typically
+    handled internally by qmake and rarely needs to
+    be modified.
+
+    \target MOC_DIR
+    \section1 MOC_DIR
+
+    Specifies the directory where all intermediate moc
+    files should be placed.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 40
+
+    \target OBJECTS
+    \section1 OBJECTS
+
+    This variable is automatically populated from the \l{SOURCES} variable.
+    The extension of each source file is replaced by .o (Unix) or .obj (Win32).
+    You can add objects to the list.
+
+    \target OBJECTS_DIR
+    \section1 OBJECTS_DIR
+
+    Specifies the directory where all intermediate
+    objects should be placed.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 41
+
+    \target POST_TARGETDEPS
+    \section1 POST_TARGETDEPS
+
+    Lists the libraries that the \l{#TARGET}{target} depends on. Some backends,
+    such as the generators for Visual Studio and Xcode project files, do not
+    support this variable. Generally, this variable is supported internally by
+    these build tools, and it is useful for explicitly listing dependent static
+    libraries.
+
+    This list is placed after all builtin (and \link #PRE_TARGETDEPS
+    $$PRE_TARGETDEPS \endlink) dependencies.
+
+    \target PRE_TARGETDEPS
+    \section1 PRE_TARGETDEPS
+
+    Lists libraries that the \l{#TARGET}{target} depends on. Some backends,
+    such as the generators for Visual Studio and Xcode project files, do not
+    support this variable. Generally, this variable is supported internally by
+    these build tools, and it is useful for explicitly listing dependent static
+    libraries.
+
+    This list is placed before all builtin dependencies.
+
+    \target PRECOMPILED_HEADER
+    \section1 PRECOMPILED_HEADER
+
+    Indicates the header file for creating a precompiled
+    header file, to increase the compilation speed of a project.
+    Precompiled headers are currently only supported on some platforms
+    (Windows - all MSVC project types, Mac OS X - Xcode, Makefile,
+    Unix - gcc 3.3 and up).
+
+    \target PWD
+    \section1 PWD
+
+    Specifies the full path leading to the directory
+    containing the current file being parsed. This can be useful
+    to refer to files within the source tree when writing project files to
+    support shadow builds.
+
+    See also \l{#_PRO_FILE_PWD_}{_PRO_FILE_PWD_}.
+
+    \note Do not attempt to overwrite the value of this variable.
+
+    \target OUT_PWD
+    \section1 OUT_PWD
+
+    Specifies the full path leading to the directory where qmake places the
+    generated Makefile.
+
+    \note Do not attempt to overwrite the value of this variable.
+
+    \target QMAKE_systemvariable
+    \section1 QMAKE
+
+    Specifies the name of the qmake program itself and is placed in generated
+    Makefiles. The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKESPEC_systemvariable
+    \section1 QMAKESPEC
+
+    A system variable that contains the full path of the qmake configuration that is used
+    when generating Makefiles. The value of this variable is automatically computed.
+
+    \note Do not attempt to overwrite the value of this variable.
+
+    \target QMAKE_AR_CMD
+    \section1 QMAKE_AR_CMD
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the command to execute when creating a shared library. The value of this variable
+    is typically handled by qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_BUNDLE_DATA
+    \section1 QMAKE_BUNDLE_DATA
+
+    \note This variable is used on Mac OS X only.
+
+    Specifies the data that will be installed with a library
+    bundle, and is often used to specify a collection of header files.
+
+    For example, the following lines add \c path/to/header_one.h
+    and \c path/to/header_two.h to a group containing information about the
+    headers supplied with the framework:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 43
+
+    The last line adds the information about the headers to the collection of
+    resources that will be installed with the library bundle.
+
+    Library bundles are created when the \c lib_bundle option is added to the
+    \l{#CONFIG}{CONFIG} variable.
+
+    See \l{Platform Notes#Creating Frameworks}{Platform Notes} for
+    more information about creating library bundles.
+
+    \section1 QMAKE_BUNDLE_EXTENSION
+
+    \note This variable is used on Mac OS X only.
+
+    Specifies the extension to be used for library bundles.
+    This allows frameworks to be created with custom extensions instead of the
+    standard \c{.framework} directory name extension.
+
+    For example, the following definition will result in a framework with the
+    \c{.myframework} extension:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 44
+
+    \section1 QMAKE_CC
+
+    Specifies the C compiler that will be used when building
+    projects containing C source code. Only the file name of the compiler
+    executable needs to be specified as long as it is on a path contained
+    in the \c PATH variable when the Makefile is processed.
+
+    \target QMAKE_CFLAGS_DEBUG
+    \section1 QMAKE_CFLAGS_DEBUG
+
+    Specifies the C compiler flags for debug builds.
+    The value of this variable is typically handled by qmake or \l{#QMAKESPEC}{qmake.conf} and
+    rarely needs to be modified.
+
+    \target QMAKE_CFLAGS_RELEASE
+    \section1 QMAKE_CFLAGS_RELEASE
+
+    Specifies the C compiler flags for release builds.
+    The value of this variable is typically handled by qmake or \l{#QMAKESPEC}{qmake.conf}
+    and rarely needs to be modified.
+
+    \target QMAKE_CFLAGS_SHLIB
+    \section1 QMAKE_CFLAGS_SHLIB
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the compiler flags for creating a shared
+    library. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_CFLAGS_THREAD
+    \section1 QMAKE_CFLAGS_THREAD
+
+    Specifies the compiler flags for creating a multi-threaded
+    application. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_CFLAGS_WARN_OFF
+    \section1 QMAKE_CFLAGS_WARN_OFF
+
+    This variable is used only when the \c {warn_off} \l{#CONFIG}{CONFIG} option
+    is set. The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_CFLAGS_WARN_ON
+    \section1 QMAKE_CFLAGS_WARN_ON
+
+    This variable is used only when the \c {warn_on} \l{#CONFIG}{CONFIG} option
+    is set. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_CLEAN
+    \section1 QMAKE_CLEAN
+
+    Specifies a list of generated files (by \l{moc} and \l{uic}, for example) and
+    object files to be removed by \c {make clean}.
+
+    \section1 QMAKE_CXX
+
+    Specifies the C++ compiler that will be used when building
+    projects containing C++ source code. Only the file name of the compiler
+    executable needs to be specified as long as it is on a path contained
+    in the \c PATH variable when the Makefile is processed.
+
+    \section1 QMAKE_CXXFLAGS
+
+    Specifies the C++ compiler flags for building
+    a project. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified. The flags specific to debug and release modes can be
+    adjusted by modifying the \c QMAKE_CXXFLAGS_DEBUG and
+    \c QMAKE_CXXFLAGS_RELEASE variables, respectively.
+
+    \target QMAKE_CXXFLAGS_DEBUG
+    \section1 QMAKE_CXXFLAGS_DEBUG
+
+    Specifies the C++ compiler flags for debug builds.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_CXXFLAGS_RELEASE
+    \section1 QMAKE_CXXFLAGS_RELEASE
+
+    Specifies the C++ compiler flags for release builds.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_CXXFLAGS_SHLIB
+    \section1 QMAKE_CXXFLAGS_SHLIB
+
+    Specifies the C++ compiler flags for creating a shared library.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_CXXFLAGS_THREAD
+    \section1 QMAKE_CXXFLAGS_THREAD
+
+    Specifies the C++ compiler flags for creating a multi-threaded application.
+    The value of this variable is typically handled by qmake or \l{#QMAKESPEC}
+    {qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_CXXFLAGS_WARN_OFF
+    \section1 QMAKE_CXXFLAGS_WARN_OFF
+
+    Specifies the C++ compiler flags for suppressing compiler
+    warnings. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_CXXFLAGS_WARN_ON
+    \section1 QMAKE_CXXFLAGS_WARN_ON
+
+    Specifies C++ compiler flags for generating compiler warnings.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_DISTCLEAN
+    \section1 QMAKE_DISTCLEAN
+
+    Specifies a list of files to be removed by \c{make distclean}.
+
+    \target QMAKE_EXTENSION_SHLIB
+    \section1 QMAKE_EXTENSION_SHLIB
+
+    Contains the extension for shared libraries.  The value of
+    this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \note Platform-specific variables that change the extension override
+    the contents of this variable.
+
+    \section1 QMAKE_EXT_MOC
+
+    Contains the extension used on included moc files.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
+
+    \section1 QMAKE_EXT_UI
+
+    Contains the extension used on \QD UI files.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
+
+    \section1 QMAKE_EXT_PRL
+
+    Contains the extension used on created PRL files.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions},
+             \l{LibDepend}{Library Dependencies}.
+
+    \section1 QMAKE_EXT_LEX
+
+    Contains the extension used on files given to Lex.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions},
+             \l{#LEXSOURCES}{LEXSOURCES}.
+
+    \section1 QMAKE_EXT_YACC
+    Contains the extension used on files given to Yacc.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions},
+             \l{#YACCSOURCES}{YACCSOURCES}.
+
+    \section1 QMAKE_EXT_OBJ
+
+    Contains the extension used on generated object files.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
+
+    \section1 QMAKE_EXT_CPP
+
+    Contains suffixes for files that should be interpreted as C++ source code.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
+
+    \section1 QMAKE_EXT_H
+
+    Contains suffixes for files which should be interpreted as C header files.
+
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
+
+        \section1 QMAKE_EXTRA_COMPILERS
+
+    Specifies a list of additional compilers or preprocessors.
+
+    See also \l{Adding Compilers}.
+
+        \section1 QMAKE_EXTRA_TARGETS
+
+    Specifies a list of additional qmake targets.
+
+    See also \l{Adding Custom Targets}.
+
+    \target QMAKE_FAILED_REQUIREMENTS
+    \section1 QMAKE_FAILED_REQUIREMENTS
+
+    Contains the list of failed requirements.
+    The value of this variable is set by qmake and cannot be modified.
+
+    See also \l{requires(condition)}{requires()} and \l{REQUIRES}.
+
+    \section1 QMAKE_FRAMEWORK_BUNDLE_NAME
+
+    \note This variable is used on Mac OS X only.
+
+    In a framework project, this variable contains the name to be used for the
+    framework that is built.
+
+    By default, this variable contains the same value as the \l{#TARGET}{TARGET}
+    variable.
+
+    See \l{Creating Frameworks} for
+    more information about creating frameworks and library bundles.
+
+    \target QMAKE_FRAMEWORK_VERSION
+    \section1 QMAKE_FRAMEWORK_VERSION
+
+    \note This variable is used on Mac OS X only.
+
+    For projects where the build target is a Mac OS X framework, this variable
+    is used to specify the version number that will be applied to the framework
+    that is built.
+
+    By default, this variable contains the same value as the \l{#VERSION}{VERSION}
+    variable.
+
+    See \l{Creating Frameworks} for more information about creating frameworks.
+
+    \target QMAKE_INCDIR
+    \section1 QMAKE_INCDIR
+
+    Specifies the list of system header paths that are appended to \l{INCLUDEPATH}.
+    The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_INCDIR_EGL
+    \section1 QMAKE_INCDIR_EGL
+
+    Specifies the location of EGL header files to be added to
+    \l{INCLUDEPATH} when building a target with OpenGL/ES or OpenVG support.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target QMAKE_INCDIR_OPENGL
+    \section1 QMAKE_INCDIR_OPENGL
+
+    Specifies the location of OpenGL header files to be added
+    to \l{INCLUDEPATH} when building a target with OpenGL support. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenGL implementation uses EGL (most OpenGL/ES systems),
+    then QMAKE_INCDIR_EGL may also need to be set.
+
+    \section1 QMAKE_INCDIR_OPENGL_ES1, QMAKE_INCDIR_OPENGL_ES2
+
+    These variables specify the location of OpenGL headers files to be added
+    to \l{INCLUDEPATH} when building a target with OpenGL ES 1
+    or OpenGL ES 2 support respectively.
+
+    The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenGL implementation uses EGL (most OpenGL/ES systems),
+    then QMAKE_INCDIR_EGL may also need to be set.
+
+    \target QMAKE_INCDIR_OPENVG
+    \section1 QMAKE_INCDIR_OPENVG
+
+    Specifies the location of OpenVG header files to be added
+    to \l{INCLUDEPATH} when building a target with OpenVG support. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenVG implementation uses EGL then QMAKE_INCDIR_EGL may also
+    need to be set.
+
+    \target QMAKE_INCDIR_X11
+    \section1 QMAKE_INCDIR_X11
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the location of X11 header file paths to be added
+    to \l{INCLUDEPATH} when building a X11 target. The value of this variable
+    is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \target QMAKE_INFO_PLIST
+    \section1 QMAKE_INFO_PLIST
+
+    \note This variable is used on Mac OS X platforms only.
+
+    Specifies the name of the property list file, \c{.plist}, you
+    would like to include in your Mac OS X application bundle.
+
+    In the \c{.plist} file, you can define some variables, e.g., @EXECUTABLE@,
+    which qmake will replace with the actual executable name. Other variables
+    include @ICON@, @TYPEINFO@, @LIBRARY@, and @SHORT_VERSION@.
+
+    \note Most of the time, the default \c{Info.plist} is good enough.
+
+    \section1 QMAKE_LFLAGS
+
+    Specifies a general set of flags that are passed to
+    the linker. If you need to change the flags used for a particular
+    platform or type of project, use one of the specialized variables
+    for that purpose instead of this variable.
+
+    \target QMAKE_LFLAGS_CONSOLE
+    \section1 QMAKE_LFLAGS_CONSOLE
+
+    \note This variable is used on Windows only.
+
+    Specifies the linker flags for building console programs. The value
+    of this variable is typically handled by qmake
+    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_DEBUG
+
+    Specifies the linker flags for debug builds.
+    The value of this variable is typically handled by qmake or \l{#QMAKESPEC}{qmake.conf}
+    and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_PLUGIN
+
+    Specifies the linker flags for building plugins. The value of this
+    variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_RPATH
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the linker flags needed to use the values from \l{QMAKE_RPATHDIR}.
+
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_RPATHLINK
+
+    Specifies the linker flags needed to use the values from
+    \l{QMAKE_RPATHLINKDIR}.
+
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_RELEASE
+
+    Specifies the linker flags for release builds.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_APP
+
+    Specifies the linker flags for building applications.
+    The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LFLAGS_SHLIB
+
+    Specifies the linker flags used for building shared libraries.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LFLAGS_SONAME
+
+    Specifies the linker flags for setting the name of shared objects,
+    such as .so or .dll. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LFLAGS_THREAD
+
+    Specifies the linker flags for building multi-threaded projects.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LFLAGS_WINDOWS
+
+    \note This variable is used on Windows only.
+
+    Specifies the linker flags for building Windows GUI projects (that is,
+    non-console applications). The value of this variable is typically handled
+    by qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LIBDIR
+
+    Specifies a list of system library paths.
+    The value of this variable is typically handled by qmake
+    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LIBDIR_FLAGS
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the location of all library directories with -L
+    prefixed. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LIBDIR_EGL
+
+    Specifies the location of the EGL library directory, when EGL
+    is used with OpenGL/ES or OpenVG. The value of this variable is typically
+    handled by qmake or \l{#QMAKESPEC}{qmake.conf}
+    and rarely needs to be modified.
+
+    \section1 QMAKE_LIBDIR_OPENGL
+
+    Specifies the location of the OpenGL library directory. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenGL implementation uses EGL (most OpenGL/ES systems),
+    then QMAKE_LIBDIR_EGL may also need to be set.
+
+    \section1 QMAKE_LIBDIR_OPENVG
+
+    Specifies the location of the OpenVG library directory. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenVG implementation uses EGL, then QMAKE_LIBDIR_EGL
+    may also need to be set.
+
+    \section1 QMAKE_LIBDIR_X11
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies the location of the X11 library directory. The value
+    of this variable is typically handled by qmake
+    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LIBS
+
+    Specifies all project libraries. The value of this variable
+    is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LIBS_EGL
+
+    Specifies all EGL libraries when building Qt with OpenGL/ES
+    or OpenVG.  The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.  The usual value is \c{-lEGL}.
+
+    \section1 QMAKE_LIBS_OPENGL
+
+    Specifies all OpenGL libraries.  The value of this variable
+    is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    If the OpenGL implementation uses EGL (most OpenGL/ES systems),
+    then QMAKE_LIBS_EGL may also need to be set.
+
+    \section1 QMAKE_LIBS_OPENGL_ES1, QMAKE_LIBS_OPENGL_ES2
+
+    These variables specify all the OpenGL libraries for OpenGL ES 1
+    and OpenGL ES 2.
+
+    The value of these variables is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    If the OpenGL implementation uses EGL (most OpenGL/ES systems),
+    then QMAKE_LIBS_EGL may also need to be set.
+
+    \section1 QMAKE_LIBS_OPENVG
+
+    Specifies all OpenVG libraries.  The value of this variable
+    is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.  The usual
+    value is \c{-lOpenVG}.
+
+    Some OpenVG engines are implemented on top of OpenGL.  This will
+    be detected at configure time and QMAKE_LIBS_OPENGL will be implicitly
+    added to QMAKE_LIBS_OPENVG wherever the OpenVG libraries are linked.
+
+    If the OpenVG implementation uses EGL, then QMAKE_LIBS_EGL may also
+    need to be set.
+
+    \section1 QMAKE_LIBS_THREAD
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies all libraries that need to be linked against when
+    building a multi-threaded target. The value of this variable is
+    typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LIBS_X11
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies all X11 libraries. The value of this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LIB_FLAG
+
+    This variable is not empty if the \c lib template is specified. The value
+    of this variable is typically handled by qmake
+    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_LINK_SHLIB_CMD
+
+    Specifies the command to execute when creating a shared
+    library. The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_LN_SHLIB
+
+    Specifies the command to execute when creating a link to a shared library. The
+    value of this variable is typically handled by qmake or
+     \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_POST_LINK
+
+    Specifies the command to execute after linking the \l{TARGET}
+    together. This variable is normally empty and therefore nothing is
+    executed.
+
+    \note This variable takes no effect on Xcode projects.
+
+    \section1 QMAKE_PRE_LINK
+
+    Specifies the command to execute before linking the \l{TARGET}
+    together. This variable is normally empty and therefore nothing is
+    executed.
+
+    \note This variable takes no effect on Xcode projects.
+
+    \section1 QMAKE_PROJECT_NAME
+
+    \note This variable is used for Visual Studio project files only.
+
+    Determines the name of the project when generating project
+    files for IDEs. The default value is the target name. The value of this
+    variable is typically handled by qmake and rarely needs to be modified.
+
+    \section1 QMAKE_MAC_SDK
+
+    This variable is used on Mac OS X when building universal binaries.
+
+    \section1 QMAKE_MACOSX_DEPLOYMENT_TARGET
+
+    This variable only takes effect when building on Mac OS X. On that
+    platform, the variable will be forwarded to the MACOSX_DEPLOYMENT_TARGET
+    environment variable, which is interpreted by the compiler or linker.
+    For more information, see the
+    \l{Deploying an Application on Mac OS X#Mac OS X Version Dependencies}{Deploying
+    an Application on Mac OS X} document.
+
+    \section1 QMAKE_MAKEFILE
+
+    Specifies the name of the Makefile to create. The value of
+    this variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QMAKE_QMAKE
+
+    Contains the abosolute path of the qmake executable.
+
+    \note Do not attempt to overwrite the value of this variable.
+
+    \section1 QMAKE_RESOURCE_FLAGS
+
+    This variable is used to customize the list of options passed to the
+    \l{rcc}{Resource Compiler} in each of the build rules where it is used.
+    For example, the following line ensures that the \c{-threshold} and
+    \c{-compress} options are used with particular values each time that
+    \c rcc is invoked:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 45
+
+    \section1 QMAKE_RPATHDIR
+
+    \note This variable is used on Unix platforms only.
+
+    Specifies a list of library paths that are added to the
+    executable at link time so that the paths will be preferentially
+    searched at runtime.
+
+    \section1 QMAKE_RPATHLINKDIR
+
+    Specifies a list of library paths for the static linker to search for implicit
+    dependencies of shared libraries. For more information, see the manual page
+    for \c ld(1).
+
+    \section1 QMAKE_RUN_CC
+
+    Specifies the individual rule needed to build an object. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_RUN_CC_IMP
+
+    Specifies the individual rule needed to build an object. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_RUN_CXX
+
+    Specifies the individual rule needed to build an object. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_RUN_CXX_IMP
+
+    Specifies the individual rule needed to build an object. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 QMAKE_TARGET
+
+    Specifies the name of the project target.  The value of this
+    variable is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 QT
+
+    Specifies the Qt modules that are used by your project.
+
+    The table below shows the options that can be used with the \c QT variable
+    and the Qt modules that are associated with each of them:
+
+    \table
+    \header \li Option                     \li Module Enabled
+    \row    \li axcontainer                \li \l{Using ActiveX controls and COM in Qt}
+                                               {QAxContainer}, which is
+                                               part of the \l{Active Qt} framework
+    \row    \li axserver                   \li \l{Building ActiveX servers in Qt}
+                                               {QAxServer}, which is
+                                               part of the \l{Active Qt} framework
+    \row    \li concurrent                 \li \l{Qt Concurrent}
+    \row    \li core (included by default) \li \l{Qt Core}
+    \row    \li dbus                       \li \l{Qt D-Bus}
+    \row    \li declarative                \li \l{Qt Quick 1} (deprecated)
+    \row    \li designer                   \li \l{Qt Designer}
+    \row    \li designercomponents         \li \l{Qt Designer Components}
+    \row    \li gui  (included by default) \li \l{Qt GUI}
+    \row    \li help                       \li \l{Qt Help}
+    \row    \li multimedia                 \li \l{Qt Multimedia}
+    \row    \li multimediawidgets          \li \l{Qt Multimedia Widgets}
+    \row    \li network                    \li \l{Qt Network}
+    \row    \li opengl                     \li \l{Qt OpenGL} (deprecated)
+    \row    \li printsupport               \li \l{Qt Print Support}
+    \row    \li qml                        \li \l{Qt QML}
+    \row    \li qmltest                    \li \l{Qt QML Test}
+    \row    \li x11extras                  \li \l{Qt X11 Extras}
+    \row    \li quick                      \li \l{Qt Quick}
+    \row    \li script                     \li \l{Qt Script} (deprecated)
+    \row    \li scripttools                \li \l{Qt Script Tools} (deprecated)
+    \row    \li sensors                    \li \l{Qt Sensors}
+    \row    \li serialport                 \li \l{Qt Serial Port}
+    \row    \li sql                        \li \l{Qt SQL}
+    \row    \li svg                        \li \l{Qt SVG}
+    \row    \li testlib                    \li \l{Qt Test}
+    \row    \li uitools                    \li \l{Qt UI Tools}
+    \row    \li webkit                     \li \l{Qt WebKit}
+    \row    \li webkitwidgets              \li \l{Qt WebKit Widgets}
+    \row    \li widgets                    \li \l{Qt Widgets}
+    \row    \li xml                        \li \l{Qt XML} (deprecated)
+    \row    \li xmlpatterns                \li \l{Qt XML Patterns}
+    \endtable
+
+    By default, \c QT contains both \c core and \c gui, ensuring that standard
+    GUI applications can be built without further configuration.
+
+    If you want to build a project \e without the \l{Qt GUI} module, you need to
+    exclude the \c gui value with the "-=" operator. The following line will
+    result in a minimal Qt project being built:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 47
+
+    \section1 QTPLUGIN
+
+    Specifies a list of names of static Qt plugins that are to be
+    linked with an application so that they are available as built-in
+    resources.
+
+    \target QT_VERSION_variable
+    \section1 QT_VERSION
+
+    Contains the current version of Qt.
+
+    \target QT_MAJOR_VERSION
+    \section1 QT_MAJOR_VERSION
+
+    Contains the current major version of Qt.
+
+    \target QT_MINOR_VERSION
+    \section1 QT_MINOR_VERSION
+
+    Contains the current minor version of Qt.
+
+    \target QT_PATCH_VERSION
+    \section1 QT_PATCH_VERSION
+
+    Contains the current patch version of Qt.
+
+    \section1 RC_FILE
+
+    Specifies the name of the resource file for the application.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 RC_INCLUDEPATH
+
+    Specifies include paths that are passed to the Windows Resource Compiler.
+
+    \target RCC_DIR
+    \section1 RCC_DIR
+
+    Specifies the directory for Qt Resource Compiler output files.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 48
+
+    \target REQUIRES
+    \section1 REQUIRES
+
+    Specifies a list of values that are evaluated as conditions. If any of the conditions is false,
+    qmake skips this project (and its \l{SUBDIRS}) when building.
+
+    \note We recommend using the \l{requires(condition)}{requires()} function
+    instead if you want to skip projects or subprojects when building.
+
+    \target RESOURCES
+    \section1 RESOURCES
+
+    Specifies the name of the resource collection files (qrc)
+    for the target. For more information about the resource collection
+    file, see \l{The Qt Resource System}.
+
+    \section1 RES_FILE
+
+    Specifies the name of the compiled Windows resource file for the target.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target SIGNATURE_FILE
+    \section1 SIGNATURE_FILE
+
+    \note This variable is only used on Windows CE.
+
+    Specifies which signature file should be used to sign the project target.
+
+    \note This variable will overwrite the setting you have specified in configure,
+    with the \c -signature option.
+
+    \target SOURCES
+    \section1 SOURCES
+
+    Specifies the names of all source files in the project.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 49
+
+    See also \l{#HEADERS}{HEADERS}.
+
+    \target SUBDIRS
+    \section1 SUBDIRS
+
+    This variable, when used with the \l{#TEMPLATE}{\c subdirs template}
+    Specifies the names of all subdirectories or project files that contain
+    parts of the project that need be built. Each subdirectory specified
+    using this variable must contain its own project file.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 50
+
+    It is essential that the project file in each subdirectory has the same
+    name as the subdirectory itself, so that qmake
+    can find it. For example, if the subdirectory is called \c myapp then the
+    project file in that directory should be called \c myapp.pro.
+
+    If you need to ensure that the subdirectories are built in the order in
+    which they are specified, update the \l{#CONFIG}{CONFIG} variable to
+    include the \c ordered option:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 51
+
+    It is possible to modify this default behavior of \c SUBDIRS by giving
+    additional modifiers to \c SUBDIRS elements. Supported modifiers are:
+
+    \table
+    \header \li Modifier \li Effect
+    \row \li .subdir     \li Use the specified subdirectory instead of \c SUBDIRS value.
+    \row \li .file       \li Specify the subproject \c pro file explicitly. Cannot be
+                        used in conjunction with \c .subdir modifier.
+    \row \li .depends    \li This subproject depends on specified subproject.
+                        Available only on platforms that use makefiles.
+    \row \li .makefile   \li The makefile of subproject.
+                        Available only on platforms that use makefiles.
+    \row \li .target     \li Base string used for makefile targets related to this
+                        subproject.
+                        Available only on platforms that use makefiles.
+    \endtable
+
+    For example, define two subdirectories, both of which reside in a different directory
+    than the \c SUBDIRS value, and one of the subdirectories must be built before the other:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 149
+
+    \target TARGET
+    \section1 TARGET
+
+    Specifies the name of the target file. Contains the base name of the project
+    file by default.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 52
+
+    The project file above would produce an executable named \c myapp on
+    unix and \c{myapp.exe} on Windows.
+
+    \section1 TARGET_EXT
+
+    Specifies the extension of \c TARGET. The value of this variable
+    is typically handled by qmake or
+    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+
+    \section1 TARGET_x
+
+    Specifies the extension of \c TARGET with a major version number.
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \section1 TARGET_x.y.z
+
+    Specifies the extension of \c TARGET with version number. The
+    value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
+    needs to be modified.
+
+    \target TEMPLATE
+    \section1 TEMPLATE
+
+    Specifies the name of the template to use when generating the project. The
+    allowed values are:
+
+    \table
+    \header \li Option \li Description
+    \row    \li app    \li Creates a Makefile for building applications
+            (the default). See \l{Building an Application} for more information.
+    \row    \li lib    \li Creates a Makefile for building libraries. See
+            \l{Building a Library} for more information.
+    \row    \li subdirs \li Creates a Makefile for building targets in subdirectories.
+            The subdirectories are specified using the \l{#SUBDIRS}{SUBDIRS}
+            variable.
+    \row    \li vcapp  \li Windows only. Creates an application project for
+            Visual Studio. See \l{Creating Visual Studio Project Files} for more
+            information.
+    \row    \li vclib  \li Windows only. Creates a library project for Visual Studio.
+    \endtable
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 53
+
+    The template can be overridden by specifying a new template type with the
+    \c -t command line option. This overrides the template type \e after the .pro
+    file has been processed. With .pro files that use the template type to
+    determine how the project is built, it is necessary to declare TEMPLATE on
+    the command line rather than use the \c -t option.
+
+    \section1 TRANSLATIONS
+
+    Specifies a list of translation (.ts) files that contain
+    translations of the user interface text into non-native languages.
+
+    See the \l{Qt Linguist Manual} for more information about
+    internationalization (i18n) and localization (l10n) with Qt.
+
+    \target UI_DIR
+    \section1 UI_DIR
+
+    Specifies the directory where all intermediate files from uic
+    should be placed.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 54
+
+    \target VERSION
+    \section1 VERSION
+
+    Specifies the version number of the application if the \c app \l{#TEMPLATE}{template} is
+    specified or the version number of the library if the \c lib template is specified.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 57
+
+    \section1 VER_MAJ
+
+    Specifies the major version number of the library if the
+    \c lib \l{#TEMPLATE}{template} is specified.
+
+    \section1 VER_MIN
+
+    Specifies the minor version number of the library if the
+    \c lib \l{#TEMPLATE}{template} is specified.
+
+    \section1 VER_PAT
+
+    Specifies the patch version number of the library if the
+    \c lib \l{#TEMPLATE}{template} is specified.
+
+    \section1 VPATH
+
+    Tells qmake where to search for files it cannot open. For example, if qmake
+    looks for \c SOURCES and finds an entry that it cannot open, it looks
+    through the entire VPATH list to see if it can find the file on its own.
+
+    See also \l{#DEPENDPATH}{DEPENDPATH}.
+
+    \target YACCSOURCES
+    \section1 YACCSOURCES
+
+    Specifies a list of Yacc source files to be included
+    in the project. All dependencies, headers and source files will
+    automatically be included in the project.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 58
+
+    \section1 _PRO_FILE_
+
+    Contains the path to the project file in use.
+
+    For example, the following line causes the location of the project
+    file to be written to the console:
+
+    \snippet snippets/qmake/project_location.pro project file
+
+    \note Do not attempt to overwrite the value of this variable.
+
+    \section1 _PRO_FILE_PWD_
+
+    Contains the path to the directory containing the project file in use.
+
+    For example, the following line causes the location of the directory
+    containing the project file to be written to the console:
+
+    \snippet snippets/qmake/project_location.pro project file directory
+
+    \note Do not attempt to overwrite the value of this variable.
+*/
+
+/*!
+    \page qmake-function-reference.html
+    \title Replace Functions
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Variables
+    \nextpage Test Functions
+
+    qmake provides functions for processing the contents of variables
+    during the configuration process. These functions are called
+    \e {replace functions}. Typically, they return values that you can
+    assign to other variables. You can obtain these values by prefixing a
+    function with the \c $$ operator. Replace functions can be divided into
+    built-in functions and function libraries.
+
+    See also \l{Test Functions}.
+
+    \section1 Built-in Replace Functions
+
+    Basic replace functions are implemented as built-in functions.
+
+    \section2 absolute_path(path[, base])
+
+    Returns the absolute path of \c path.
+
+    If \c base is not specified, uses the current directory as the base
+    directory.
+
+    For example, the following call returns the string
+    \c {"/home/johndoe/myproject/readme.txt"}:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 159
+
+    See also \l{clean_path(path)}{clean_path()},
+    \l{relative_path(filePath[, base])}{relative_path()}.
+
+    \section2 basename(variablename)
+
+    Returns the basename of the file specified in \c variablename.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 59
+
+    \section2 cat(filename[, mode])
+
+    Returns the contents of \c filename. You can specify the following options
+    for \c mode:
+
+    \list
+        \li \c blob returns the entire contents of the file as one value
+        \li \c lines returns each line as a separate value (without line
+            endings)
+        \li \c true (default value) and \c false return file contents as
+            separate values, split according to qmake value list splitting rules
+            (as in variable assignments). If \c mode is \c false, values that
+            contain only a newline character are inserted into the list to
+            indicate where line breaks were in the file.
+    \endlist
+
+    \section2 clean_path(path)
+
+    Returns \c path with directory separators normalized (converted to "/") and
+    redundant ones removed, and "."s and ".."s resolved (as far as possible).
+    This function is a wrapper around QDir::cleanPath.
+
+    See also \l{absolute_path(path[, base])}{absolute_path()},
+    \l{relative_path(filePath[, base])}{relative_path()},
+    \l{shell_path(path)}{shell_path()}, \l{system_path(path)}{system_path()}.
+
+    \section2 dirname(file)
+
+    Returns the directory name part of the specified file. For example:
+
+    \snippet snippets/qmake/dirname.pro 0
+
+    \section2 enumerate_vars
+
+    Returns a list of all defined variable names.
+
+    \section2 escape_expand(arg1 [, arg2 ..., argn])
+
+    Accepts an arbitrary number of arguments. It expands the
+    escape sequences \c {\n}, \c {\r}, \c {\t} for each argument and returns
+    the arguments as a list.
+
+    \note If you specify the string to expand literally, you need to escape the
+    backslashes, as illustrated by the following code snippet:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 173
+
+    \target findfunction
+    \section2 find(variablename, substr)
+
+    Returns all the values in \c variablename that match the regular expression
+    \c substr.
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 64
+
+    MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MY_VAR3 will
+    contain 'three two three'.
+
+    \section2 first(variablename)
+
+    Returns the first value of \c variablename.
+
+    For example, the following call returns \c firstname:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 161
+
+    See also \l{last(variablename)}{last()}.
+
+    \section2 format_number(number[, options...])
+
+    Returns \c number in the format specified by \c options. You can specify the
+    following options:
+
+    \list
+        \li \c ibase=n sets the base of the input to \c n
+        \li \c obase=n sets the base of the output to \c n
+        \li \c width=n sets the minimum width of the output to \c n. If the
+            output is shorter than \c width, it is padded with spaces
+        \li \c zeropad pads the output with zeroes instead of spaces
+        \li \c padsign prepends a space to positive values in the output
+        \li \c alwayssign prepends a plus sign to positive values in the output
+        \li \c leftalign places the padding to the right of the value in the
+            output
+    \endlist
+
+    Floating-point numbers are currently not supported.
+
+    For example, the following call converts the hexadecimal number \c BAD to
+    \c 002989:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 163
+
+    \section2 fromfile(filename, variablename)
+
+    Evaluates \c filename as a qmake project file and returns the value assigned
+    to \c variablename.
+
+    See also \l{infile(filename, var, val)}{infile()}.
+
+    \section2 join(variablename, glue, before, after)
+
+    Joins the value of \c variablename with \c glue. If this value is
+    not empty, this function prefixes the value with \c before and suffixes it
+    with \c after. \c variablename is the only required field, the others default
+    to empty strings. If you need to encode spaces in \c glue, \c before, or \c
+    after, you must quote them.
+
+    \section2 last(variablename)
+
+    Returns the last value of \c variablename.
+
+    For example, the following call returns \c phone:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 162
+
+    See also \l{first(variablename)}{first()}.
+
+    \section2 list(arg1 [, arg2 ..., argn])
+
+    Takes an arbitrary number of arguments. It creates a uniquely
+    named variable that contains a list of the arguments, and returns the name
+    of that variable. You can use the variable to write a loop as illustrated by
+    the following code snippet
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 170
+
+    instead of:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 171
+
+    \section2 lower(arg1 [, arg2 ..., argn])
+
+    Takes an arbitrary number of arguments and converts them to lower case.
+
+    See also \l{upper(arg1 [, arg2 ..., argn])}{upper()}.
+
+    \section2 member(variablename, position)
+
+    Returns the value at the given \c position in the list of items in
+    \c variablename.
+    If an item cannot be found at the position specified, an empty string is
+    returned. \c variablename is the only required field. If not specified,
+    \c position defaults to 0, causing the first value in the list to be
+    returned.
+
+    \section2 prompt(question)
+
+    Displays the specified \c question, and returns a value read from stdin.
+
+    \section2 quote(string)
+
+    Converts a whole \c string into a single entity and returns the result.
+    This is just a fancy way of enclosing the string into double quotes.
+
+    \section2 re_escape(string)
+
+    Returns the \c string with every special regular expression character
+    escaped with a backslash. This function is a wrapper around QRegExp::escape.
+
+    \section2 relative_path(filePath[, base])
+
+    Returns the path to \c filePath relative to \c base. If \c base is not
+    specified, it is the current project directory. This function is a wrapper
+    around QDir::relativeFilePath.
+
+    See also \l{absolute_path(path[, base])}{absolute_path()},
+    \l{clean_path(path)}{clean_path()}.
+
+    \section2 replace(string, old_string, new_string)
+
+    Replaces each instance of \c old_string with \c new_string in the
+    contents of the variable supplied as \c string. For example, the
+    code
+
+    \snippet snippets/qmake/replace.pro 0
+
+    prints the message:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 70
+
+    \section2 sprintf(string, arguments...)
+
+    Replaces %1-%9 with the arguments passed in the comma-separated list
+    of function \c arguments and returns the processed string.
+
+    \section2 resolve_depends(variablename, prefix)
+
+    This is an internal function that you will typically not need.
+
+    \section2 reverse(variablename)
+
+    Returns the values of \c variablename in reverse order.
+
+    \section2 section(variablename, separator, begin, end)
+
+    Returns a section of the value of \c variablename. This function is a
+    wrapper around QString::section.
+
+    For example, the following call outputs \c surname:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 167
+
+    \section2 shadowed(path)
+
+    Maps the path from the project source directory to the build directory.
+    This function returns \c path for in-source builds. It returns an empty
+    string if \c path points outside of the source tree.
+
+    \section2 shell_path(path)
+
+    Converts all directory separators within \c path to separators that are
+    compatible with the shell that is used while building the project (that is,
+    the shell that is invoked by the make tool). For example, slashes are
+    converted to backslashes when the Windows shell is used.
+
+    See also \l{system_path(path)}{system_path()}.
+
+    \section2 shell_quote(arg)
+
+    Quotes \c arg for the shell that is used while building the project.
+
+    See also \l{system_quote(arg)}{system_quote()}.
+
+    \section2 size(variablename)
+
+    Returns the number of values of \c variablename.
+
+    \section2 sort_depends(variablename, prefix)
+
+    This is an internal function that you will typically not need.
+
+    \section2 split(variablename, separator)
+
+    Splits the value of \c variablename into separate values, and returns them
+    as a list. This function is a wrapper around QString::split.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 168
+
+    \section2 system(command[, mode])
+
+    You can use this variant of the \c system function to obtain stdout from the
+    command and assign it to a variable.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 72
+
+    See also the test variant of \l{system(command)}{system()}.
+
+    \section2 system_path(path)
+
+    Converts all directory separators within \c path to separators that are
+    compatible with the shell that is used by the \c{system()} functions to
+    invoke commands. For example, slashes are converted to backslashes for the
+    Windows shell.
+
+    See also \l{shell_path(path)}{shell_path()}.
+
+    \section2 system_quote(arg)
+
+    Quotes \c arg for the for the shell that is used by the \c{system()}
+    functions.
+
+    See also \l{shell_quote(arg)}{shell_quote()}.
+
+    \target unique
+    \section2 unique(variablename)
+
+    Returns the list of values in \c variablename with duplicate entries removed.
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 73
+
+    \section2 upper(arg1 [, arg2 ..., argn])
+
+    Takes an arbitrary number of arguments and converts them to upper case.
+
+    See also \l{lower(arg1 [, arg2 ..., argn])}{lower()}.
+
+    \section2 val_escape(variablename)
+
+    Escapes the values of \c variablename in a way that enables parsing them as
+    qmake code.
+*/
+
+/*!
+    \page qmake-test-function-reference.html
+    \title Test Functions
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Replace Functions
+
+    Test functions return a boolean value that you can test for in the
+    conditional parts of scopes. Test functions can be divided into
+    built-in functions and function libraries.
+
+    See also \l{Replace Functions}.
+
+    \section1 Built-in Test Functions
+
+    Basic test functions are implemented as built-in functions.
+
+    \section2 cache(variablename, [set|add|sub] [transient] [super], [source variablename])
+
+    This is an internal function that you will typically not need.
+
+    \section2 CONFIG(config)
+
+    This function can be used to test for variables placed into the
+    \l{CONFIG} variable. This is the same as scopes,
+    but has the added advantage that a second parameter can be passed to test for
+    the active config. As the order of values is important in \c CONFIG
+    variables (that is, the last one set will be considered the active config for
+    mutually exclusive values) a second parameter can be used to specify a set
+    of values to consider. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 60
+
+    Because release is considered the active setting (for feature parsing)
+    it will be the CONFIG used to generate the build file. In the common
+    case a second parameter is not needed, but for specific mutual
+    exclusive tests it is invaluable.
+
+    \section2 contains(variablename, value)
+
+    Succeeds if the variable \c variablename contains the value \c value;
+    otherwise fails. You can check the return value of this function using
+    a scope.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 61
+
+    The contents of the scope are only processed if the \c drivers
+    variable contains the value \c network. If this is the case, the
+    appropriate files are added to the \l{SOURCES} and \l{HEADERS}
+    variables.
+
+    \target countfunction
+    \section2 count(variablename, number)
+
+    Succeeds if the variable \c variablename contains a list with the
+    specified \c number of values; otherwise fails.
+
+    This function is used to ensure that declarations inside a scope are
+    only processed if the variable contains the correct number of values.
+    For example:
+
+    \snippet snippets/qmake/functions.pro 2
+
+    \section2 debug(level, message)
+
+    Checks whether qmake runs at the specified debug level. If yes, it returns
+    true and prints a debug message.
+
+    \section2 defined(name[, type])
+
+    Tests whether the function or variable \c name is defined. If \c type is
+    omitted, checks all functions. To check only variables or particular type of
+    functions, specify \c type. It can have the following values:
+
+    \list
+        \li \c test only checks test functions
+        \li \c replace only checks replace functions
+        \li \c var only checks variables
+    \endlist
+
+    \section2 equals(variablename, value)
+
+    Tests whether \c variablename equals the string \c value.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 160
+
+    \section2 error(string)
+
+    This function never returns a value. qmake displays \c string as an error
+    message to the user and exits. This function should only be used for
+    unrecoverable errors.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 62
+
+    \section2 eval(string)
+
+    Evaluates the contents of the string using
+    qmake syntax rules and returns true.
+    Definitions and assignments can be used in the string to modify the
+    values of existing variables or create new definitions.
+
+    For example:
+    \snippet snippets/qmake/functions.pro 4
+
+    \note Quotation marks can be used to delimit the string, and
+    the return value can be discarded if it is not needed.
+
+    \section2 exists(filename)
+
+    Tests whether a file with the given \c filename exists.
+    If the file exists, the function succeeds; otherwise it fails.
+    If a regular expression is specified for the filename, this function
+    succeeds if any file matches the regular expression specified.
+
+    For example:
+    \snippet snippets/code/doc_src_qmake-manual.pro 63
+
+    \note "/" should be used as a directory separator, regardless of the
+    platform in use.
+
+    \section2 export(variablename)
+
+    Exports the current value of \c variablename from the local context of a
+    function to the global context.
+
+    \section2 files(pattern[, recursive=false])
+
+    Expands the specified wildcard pattern and returns a list of filenames.
+    If \c recursive is true, this function descends into subdirectories.
+
+    \target forfunction
+    \section2 for(iterate, list)
+
+    Starts a loop that iterates over all values in \c list, setting \c iterate to each
+    value in turn. As a convenience, if \c list is 1..10 then iterate will
+    iterate over the values 1 through 10.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 65
+
+    \section2 greaterThan(variablename, value)
+
+    Tests that the value of \c variablename is greater than \c value. First,
+    this function attempts a numerical comparison. If at least one of the
+    operands fails to convert, this function does a string comparison.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 164
+
+    It is impossible to compare two numbers as strings directly. As a
+    workaround, construct temporary values with a non-numeric prefix and compare
+    these.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 172
+
+    See also \l{lessThan(variablename, value)}{lessThan()}.
+
+    \section2 if(condition)
+
+    Evaluates \c condition. It is used to group boolean expressions.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 166
+
+    \section2 include(filename)
+
+    Includes the contents of the file specified by \c filename into the
+    current project at the point where it is included. This function
+    succeeds if \c filename is included; otherwise it fails. The included
+    file is processed immediately.
+
+    You can check whether the file was included by using this function as
+    the condition for a scope. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 66
+
+    \section2 infile(filename, var, val)
+
+    Succeeds if the file \c filename (when parsed by qmake itself) contains the
+    variable \c var with a value of \c val; otherwise fails. If you do not
+    specify \c val, the function tests whether \c var has been assigned in
+    the file.
+
+    \section2 isActiveConfig
+
+    This is an alias for the \c CONFIG function.
+
+    \section2 isEmpty(variablename)
+
+    Succeeds if the variable \c variablename is empty; otherwise fails.
+    This is the equivalent of \c{count( variablename, 0 )}.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 67
+
+    \section2 isEqual
+
+    This is an alias for the \c equals function.
+
+    \section2 lessThan(variablename, value)
+
+    Tests that the value of \c variablename is less than \c value. Works as
+    \l{greaterThan(variablename, value)}{greaterThan()}.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 165
+
+    \section2 load(feature)
+
+    Loads the feature file (\c .prf) specified by \c feature,
+    unless the feature has already been loaded.
+
+    \section2 log(message)
+
+    Prints a message on the console. Unlike the \c message function, neither
+    prepends text nor appends a line break.
+
+    See also \l{message(string)}{message()}.
+
+    \section2 message(string)
+
+    Always succeeds, and displays \c string as a general message to the user.
+    Unlike the \c error() function, this function allows processing to continue.
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 68
+
+    The above line causes "This is a message" to be written to the console.
+    The use of quotation marks is optional, but recommended.
+
+    \note By default, messages are written out for each Makefile generated by
+    qmake for a given project. If you want to ensure that messages only appear
+    once for each project, test the \c build_pass variable
+    \l{Scopes}{in conjunction with a scope} to filter out
+    messages during builds. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 69
+
+    \section2 mkpath(dirPath)
+
+    Creates the directory path \c dirPath. This function is a wrapper around the
+    QDir::makepath function.
+
+    \section2 requires(condition)
+
+    Evaluates \c condition. If the condition is false, qmake skips this
+    project (and its \l{SUBDIRS}) when building.
+
+    \note You can also use the \l{REQUIRES} variable for this purpose. However, we
+    recommend using this function, instead.
+
+    \section2 system(command)
+
+    Executes the given \c command in a secondary shell. Succeeds
+    if the command returns with a zero exit status; otherwise fails.
+    You can check the return value of this function using a scope.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 71
+
+    See also the replace variant of \l{system(command[, mode])}{system()}.
+
+    \target touchfunction
+    \section2 touch(filename, reference_filename)
+
+    Updates the time stamp of \c filename to match the time stamp of
+    \c reference_filename.
+
+    \section2 unset(variablename)
+
+    Removes \c variablename from the current context.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 169
+
+    \section2 warning(string)
+
+    Always succeeds, and displays \c string as a warning message to the user.
+
+    \section2 write_file(filename, [variablename, [mode]])
+
+    Writes the values of \c variablename to a file with the name \c filename,
+    each value on a separate line. If \c variablename is not specified, creates
+    an empty file. If \c mode is \c append and the file already exists, appends
+    to it instead of replacing it.
+
+    \section1 Test Function Library
+
+    Complex test functions are implemented in a library of .prf files.
+
+    \section2 packagesExist(packages)
+
+    Uses the PKGCONFIG mechanism to determine whether or not the given packages
+    exist at the time of project parsing.
+
+    This can be useful to optionally enable or disable features. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 157
+
+    And then, in the code:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 158
+*/
+
+/*!
+    \page qmake-environment-reference.html
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Using Precompiled Headers
+    \nextpage Reference
+
+    \title Configuring qmake
+
+    \section1 Properties
+
+    qmake has a system for persistent configuration, which allows you to set a
+    property in qmake once, and query it each time qmake is invoked. You can set
+    a property in qmake as follows:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 74
+
+    The appropriate property and value should be substituted for
+    \c PROPERTY and \c VALUE.
+
+    You can retrieve this information back from qmake as follows:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 75
+
+    \note \c{qmake -query} lists built-in properties in addition to the
+    properties that you set with \c{qmake -set PROPERTY VALUE}.
+
+    This information will be saved into a QSettings object (meaning it
+    will be stored in different places for different platforms).
+
+    The following list summarizes the \c built-in properties:
+
+    \list
+        \li QMAKE_SPEC - the shortname of the host \c mkspec that is resolved
+            and stored in the \l{QMAKESPEC} variable during a host build
+        \li QMAKE_VERSION - the current version of qmake
+        \li QMAKE_XSPEC - the shortname of the target \c mkspec that is resolved
+            and stored in the \l{QMAKESPEC} variable during a target build
+        \li QT_HOST_BINS - location of host executables
+        \li QT_HOST_DATA - location of data for host executables used by qmake
+        \li QT_HOST_PREFIX - default prefix for all host paths
+        \li QT_INSTALL_ARCHDATA - location of general architecture-dependent Qt
+            data
+        \li QT_INSTALL_BINS - location of Qt binaries (tools and applications)
+        \li QT_INSTALL_CONFIGURATION - location for Qt settings. Not applicable
+            on Windows
+        \li QT_INSTALL_DATA - location of general architecture-independent Qt
+            data
+        \li QT_INSTALL_DOCS - location of documentation
+        \li QT_INSTALL_EXAMPLES - location of examples
+        \li QT_INSTALL_HEADERS - location for all header files
+        \li QT_INSTALL_IMPORTS - location of QML 1.x extensions
+        \li QT_INSTALL_LIBEXECS - location of executables required by libraries at runtime
+        \li QT_INSTALL_LIBS - location of libraries
+        \li QT_INSTALL_PLUGINS - location of Qt plugins
+        \li QT_INSTALL_PREFIX - default prefix for all paths
+        \li QT_INSTALL_QML - location of QML 2.x extensions
+        \li QT_INSTALL_TESTS - location of Qt test cases
+        \li QT_INSTALL_TRANSLATIONS - location of translation information for
+            Qt strings
+        \li QT_SYSROOT - the sysroot used by the target build environment
+        \li QT_VERSION - the Qt version. We recommend that you query Qt module specific
+            version numbers by using $$QT.<module>.version variables instead.
+    \endlist
+
+    For example, you can query the installation of Qt for this version of qmake with the
+    \c QT_INSTALL_PREFIX property:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 77
+
+    You can query the values of properties in a project file as follows:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 78
+
+    \target QMAKESPEC
+    \section1 QMAKESPEC
+
+    qmake requires a platform and compiler
+    description file which contains many default values used to generate
+    appropriate Makefiles. The standard Qt distribution comes with many of
+    these files, located in the \c mkspecs subdirectory of the Qt installation.
+
+    The \c QMAKESPEC environment variable can contain any of the following:
+
+    \list
+    \li A complete path to a directory containing a \c{qmake.conf} file.
+       In this case qmake will open the
+       \c{qmake.conf} file from within that directory. If the file does not
+       exist, qmake will exit with an error.
+    \li The name of a platform-compiler combination. In this case,
+       qmake will search in the directory specified
+       by the \c mkspecs subdirectory of the data path specified when Qt was
+       compiled (see QLibraryInfo::DataPath).
+    \endlist
+
+    \note The \c QMAKESPEC path will automatically be added to the
+    \l{INCLUDEPATH} system variable.
+
+    \target cache
+    \section1 Cache File
+
+    The cache file is a special file qmake reads to
+    find settings not specified in the \c qmake.conf file, project files, or
+    at the command line. When qmake is run, it looks for a file called
+    \c{.qmake.cache} in parent directories of the current directory, unless you
+    specify \c -nocache. If qmake
+    fails to find this file, it will silently ignore this step of processing.
+
+    If qmake  finds a \c{.qmake.cache} file then it will process this file first before
+    it processes the project file.
+
+    \target Extensions
+    \section1 File Extensions
+
+    Under normal circumstances qmake will try to
+    use appropriate file extensions for your platform. However, it is
+    sometimes necessary to override the default choices for each platform and
+    explicitly define file extensions for qmake to
+    use. This is achieved by redefining certain built-in variables. For
+    example, the extension used for \l moc files can be redefined with the
+    following assignment in a project file:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 85
+
+    The following variables can be used to redefine common file extensions recognized
+    by qmake:
+
+    \list
+    \li \l{QMAKE_EXT_MOC} modifies the extension placed on included moc files.
+    \li \l{QMAKE_EXT_UI} modifies the extension used for \QD UI files
+        (usually in \l{FORMS}).
+    \li \l{QMAKE_EXT_PRL} modifies the extension placed on
+                       \l{#LibDepend}{library dependency files}.
+    \li \l{QMAKE_EXT_LEX} changes the suffix used in Lex files (usually in
+        \l{LEXSOURCES}).
+    \li \l{QMAKE_EXT_YACC} changes the suffix used in Yacc files (usually in
+        \l{YACCSOURCES}).
+    \li \l{QMAKE_EXT_OBJ} changes the suffix used on generated object files.
+    \endlist
+
+    All of the above accept just the first value, so you must assign to it just one
+    value that will be used throughout your project file. There are two variables that
+    accept a list of values:
+
+    \list
+    \li \l{QMAKE_EXT_CPP} causes qmake to interpret
+        all files with these suffixes as C++ source files.
+    \li \l{QMAKE_EXT_H} causes qmake to interpret
+        all files with these suffixes as C and C++ header files.
+    \endlist
+*/
+
+/*!
+    \page qmake-language.html
+    \title qmake Language
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Platform Notes
+    \nextpage Advanced Usage
+
+    Many qmake project files simply describe the
+    sources and header files used by the project, using a list of
+    \c{name = value} and \c{name += value} definitions.
+    qmake also provides other operators, functions,
+    and scopes that can be used to process the information supplied in
+    variable declarations. These advanced features allow Makefiles to be
+    generated for multiple platforms from a single project file.
+
+    \section1 Operators
+
+    In many project files, the assignment (\c{=}) and append (\c{+=}) operators can
+    be used to include all the information about a project. The typical pattern of
+    use is to assign a list of values to a variable, and append more values
+    depending on the result of various tests. Since
+    qmake defines certain variables using default
+    values, it is sometimes necessary to use the removal (\c{-=}) operator to
+    filter out values that are not required. The following sections describe how
+    to use operators to manipulate the contents of variables.
+
+    \section2 Assigning Values
+
+    The \c = operator assigns a value to a variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 89
+
+    The above line sets the \l{TARGET} variable to \c myapp. This will overwrite any
+    values previously set for \c TARGET with \c myapp.
+
+    \section2 Appending Values
+
+    The \c += operator appends a new value to the list of values in a variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 90
+
+    The above line appends \c USE_MY_STUFF to the list of pre-processor defines to be put
+    in the generated Makefile.
+
+    \section2 Removing Values
+
+    The \c -= operator removes a value from the list of values in a variable:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 91
+
+    The above line removes \c USE_MY_STUFF from the list of pre-processor defines to be
+    put in the generated Makefile.
+
+    \section2 Adding Unique Values
+
+    The \c *= operator adds a value to the list of values in a variable, but only
+    if it is not already present. This prevents values from being included many
+    times in a variable. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 92
+
+    In the above line, \c USE_MY_STUFF will only be added to the list of pre-processor
+    defines if it is not already defined. Note that the \l{unique}{unique()}
+    function can also be used to ensure that a variable only contains one
+    instance of each value.
+
+    \section2 Replacing Values
+
+    The \c ~= operator replaces any values that match a regular expression with
+    the specified value:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 93
+
+    In the above line, any values in the list that start with \c QT_D or \c QT_T are
+    replaced with \c QT.
+
+    \section2 Variable Expansion
+
+    The \c $$ operator is used to extract the contents of a variable, and can be
+    used to pass values between variables or supply them to functions:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 94
+
+    Variables can be used to store the contents of environment variables.
+    These can be evaluated at the time when qmake
+    is run, or included in the generated Makefile for evaluation when the
+    project is built.
+
+    To obtain the contents of an environment value when
+    qmake is run, use the \c $$(...) operator:
+
+    \snippet snippets/qmake/environment.pro 0
+
+    In the above assignment, the value of the \c PWD environment variable
+    is read when the project file is processed.
+
+    To obtain the contents of an environment value at the time when the
+    generated Makefile is processed, use the \c $(...) operator:
+
+    \snippet snippets/qmake/environment.pro 1
+
+    In the above assignment, the value of \c PWD is read immediately
+    when the project file is processed, but \c $(PWD) is assigned to
+    \c DESTDIR in the generated Makefile. This makes the build process
+    more flexible as long as the environment variable is set correctly
+    when the Makefile is processed.
+
+    \section2 Accessing qmake Properties
+
+    The special \c $$[...] operator can be used to access qmake properties:
+
+    \snippet snippets/qmake/qtconfiguration.pro 0
+
+    For more information, see \l{Configuring qmake}.
+
+    The properties accessible with this operator are typically used to
+    enable third party plugins and components to be integrated in Qt.
+    For example, a \QD plugin can be installed alongside \QD's built-in
+    plugins if the following declaration is made in its project file:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 101
+
+    \target Scopes
+    \section1 Scopes
+
+    Scopes are similar to \c if statements in procedural programming languages.
+    If a certain condition is true, the declarations inside the scope are processed.
+
+    \section2 Scope Syntax
+
+    Scopes consist of a condition followed by an opening brace on the same line,
+    a sequence of commands and definitions, and a closing brace on a new line:
+
+    \snippet snippets/qmake/scopes.pro syntax
+
+    The opening brace \e{must be written on the same line as the condition}.
+    Scopes may be concatenated to include more than one condition, as described
+    in the following sections.
+
+    \section2 Scopes and Conditions
+
+    A scope is written as a condition followed by a series of declarations
+    contained within a pair of braces. For example:
+
+    \snippet snippets/qmake/scopes.pro 0
+
+    The above code will add the \c paintwidget_win.cpp file to the sources listed
+    in the generated Makefile when building for a Windows platform. When
+    building for other platforms, the define will be ignored.
+
+    The conditions used in a given scope can also be negated to provide an
+    alternative set of declarations that will be processed only if the
+    original condition is false. For example, to process something when building
+    for all platforms \e except Windows, negate the scope like this:
+
+    \snippet snippets/qmake/scopes.pro 1
+
+    Scopes can be nested to combine more than one condition. For instance, to
+    include a particular file for a certain platform only if
+    debugging is enabled, write the following:
+
+    \snippet snippets/qmake/scopes.pro 2
+
+    To save writing many nested scopes, you can nest scopes using the \c :
+    operator. The nested scopes in the above example can be rewritten in
+    the following way:
+
+    \snippet snippets/qmake/scopes.pro 3
+
+    You may also use the \c : operator to perform single line conditional
+    assignments. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 95
+
+    The above line adds \c USE_MY_STUFF to the \l{DEFINES} variable only when
+    building for the Windows platform.
+    Generally, the \c : operator behaves like a logical AND operator, joining
+    together a number of conditions, and requiring all of them to be true.
+
+    There is also the \c | operator to act like a logical OR operator, joining
+    together a number of conditions, and requiring only one of them to be true.
+
+    \snippet snippets/qmake/scopes.pro 4
+
+    You can also provide alternative declarations to those within a scope by
+    using an \c else scope. Each \c else scope is processed if the conditions
+    for the preceding scopes are false.
+    This allows you to write complex tests when combined with other scopes
+    (separated by the \c : operator as above). For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 96
+
+    \section2 Configuration and Scopes
+
+    The values stored in the \l{CONFIG} variable are
+    treated specially by qmake. Each of the possible
+    values can be used as the condition for a scope. For example, the list of
+    values held by \c CONFIG can be extended with the \c opengl value:
+
+    \snippet snippets/qmake/configscopes.pro 0
+
+    As a result of this operation, any scopes that test for \c opengl will
+    be processed. We can use this feature to give the final executable an
+    appropriate name:
+
+    \snippet snippets/qmake/configscopes.pro 1
+    \snippet snippets/qmake/configscopes.pro 2
+    \snippet snippets/qmake/configscopes.pro 3
+
+    This feature makes it easy to change the configuration for a project
+    without losing all the custom settings that might be needed for a specific
+    configuration. In the above code, the declarations in the first scope are
+    processed, and the final executable will be called \c application-gl.
+    However, if \c opengl is not specified, the declarations in the second
+    scope are processed instead, and the final executable will be called
+    \c application.
+
+    Since it is possible to put your own values on the \c CONFIG
+    line, this provides you with a convenient way to customize project files
+    and fine-tune the generated Makefiles.
+
+    \section2 Platform Scope Values
+
+    In addition to the \c win32, \c macx, and \c unix values used in many
+    scope conditions, various other built-in platform and compiler-specific
+    values can be tested with scopes. These are based on platform
+    specifications provided in Qt's \c mkspecs directory. For example, the
+    following lines from a project file show the current specification in
+    use and test for the \c linux-g++ specification:
+
+    \snippet snippets/qmake/specifications.pro 0
+
+    You can test for any other platform-compiler combination as long as a
+    specification exists for it in the \c mkspecs directory.
+
+    \target UsingVariables
+    \section1 Variables
+
+    Many of the variables used in project files are special variables that
+    qmake uses when generating Makefiles, such as \l{DEFINES}, \l{SOURCES}, and
+    \l{HEADERS}. In addition, you can create variables for your own use. qmake
+    creates new
+    variables with a given name when it encounters an assignment to that name.
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 97
+
+    There are no restricitions on what you do to your own variables, as
+    qmake will ignore them unless it needs to evaluate them when processing
+    a scope.
+
+    You can also assign the value of a current variable to another
+    variable by prefixing $$ to the variable name. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 98
+
+    Now the MY_DEFINES variable contains what is in the DEFINES variable at
+    this point in the project file.  This is also equivalent to:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 99
+
+    The second notation allows you to append the contents of the variable to
+    another value without separating the two with a space. For example, the
+    following will ensure that the final executable will be given a name
+    that includes the project template being used:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 100
+
+    \target UsingReplaceFunctions
+    \section1 Replace Functions
+
+    qmake provides a selection of built-in
+    functions to allow the contents of variables to be processed. These
+    functions process the arguments supplied to them and return a value, or
+    list of values, as a result. To assign a result to a variable, use the \c $$
+    operator with this type of function as you would to assign contents of one
+    variable to another:
+
+    \snippet snippets/qmake/functions.pro 1
+
+    This type of function should be used on the right-hand side of
+    assignments (that is, as an operand).
+
+    You can define your own functions for processing the contents of variables
+    as follows:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 102
+
+    The following example function takes a variable name as its only
+    argument, extracts a list of values from the variable with the
+    \l{eval(string)}{eval()} built-in function, and compiles a list of files:
+
+    \snippet snippets/qmake/replacefunction.pro 0
+
+    \target UsingTestFunctions
+    \section1 Test Functions
+
+    qmake provides built-in functions that can be
+    used as conditions when writing scopes. These functions do not return a
+    value, but instead indicate \e success or \e failure:
+
+    \snippet snippets/qmake/functions.pro 3
+
+    This type of function should be used in conditional expressions
+    only.
+
+    It is possible to define your own functions to provide conditions
+    for scopes. The following example tests whether each file in a list
+    exists and returns true if they all exist, or false if not:
+
+    \snippet snippets/qmake/testfunction.pro 0
+*/
+
+/*!
+    \page qmake-advanced-usage.html
+    \title Advanced Usage
+    \contentspage {qmake Manual}{Contents}
+    \previouspage qmake Language
+    \nextpage Using Precompiled Headers
+
+    \section1 Adding New Configuration Features
+
+    qmake lets you create your own \c features that
+    can be included in project files by adding their names to the list of
+    values specified by the \l{CONFIG} variable. Features are collections of
+    custom functions and definitions in \c{.prf} files that can reside in one
+    of many standard directories. The locations of these directories are
+    defined in a number of places, and qmake checks
+    each of them in the following order when it looks for \c{.prf} files:
+
+    \omit
+        TODO: Fix the list, as it is incomplete and partly incorrect.
+    \endomit
+
+    \list 1
+    \li In a directory listed in the \c QMAKEFEATURES environment variable that
+        contains a colon-separated list of directories.
+    \li In a directory listed in the \c QMAKEFEATURES property variable that
+       contains a colon-spearated list of directories.
+    \omit
+    \li In a features directory beneath the project's root directory (where
+       the \c{.qmake.cache} file is generated).
+    \endomit
+    \li In a features directory residing within a \c mkspecs directory.
+       \c mkspecs directories can be located beneath any of the directories
+       listed in the \c QMAKEPATH environment variable that contains a
+        colon-separated list of directories. For example:
+        \c{$QMAKEPATH/mkspecs/<features>}.
+    \li In a features directory residing beneath the directory provided by the
+       \l{QMAKESPEC} environment variable. For example: \c{$QMAKESPEC/<features>}.
+    \li In a features directory residing in the \c data_install/mkspecs directory.
+       For example: \c{data_install/mkspecs/<features>}.
+    \li In a features directory that exists as a sibling of the directory
+       specified by the \c QMAKESPEC environment variable.
+       For example: \c{$QMAKESPEC/../<features>}.
+    \endlist
+
+    The following features directories are searched for features files:
+
+    \list 1
+    \li \c{features/unix}, \c{features/win32}, or \c{features/macx}, depending on
+       the platform in use
+    \li \c features/
+    \endlist
+
+    For example, consider the following assignment in a project file:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 103
+
+    With this addition to the \c CONFIG variable,
+    qmake will search the locations listed above for
+    the \c myfeatures.prf file after it has finished parsing your project file.
+    On Unix systems, it will look for the following file:
+
+    \list 1
+    \li \c $QMAKEFEATURES/myfeatures.prf (for each directory listed in the
+       \c QMAKEFEATURES environment variable)
+    \li \c $$QMAKEFEATURES/myfeatures.prf (for each directory listed in the
+       \c QMAKEFEATURES property variable)
+    \li \c myfeatures.prf (in the project's root directory)
+    \li \c $QMAKEPATH/mkspecs/features/unix/myfeatures.prf and
+       \c $QMAKEPATH/mkspecs/features/myfeatures.prf (for each directory
+       listed in the \c QMAKEPATH environment variable)
+    \li \c $QMAKESPEC/features/unix/myfeatures.prf and
+       \c $QMAKESPEC/features/myfeatures.prf
+    \li \c data_install/mkspecs/features/unix/myfeatures.prf and
+       \c data_install/mkspecs/features/myfeatures.prf
+    \li \c $QMAKESPEC/../features/unix/myfeatures.prf and
+       \c $QMAKESPEC/../features/myfeatures.prf
+    \endlist
+
+    \note The \c{.prf} files must have names in lower case.
+
+    \section1 Installing Files
+
+    It is common on Unix to also use the build tool to install applications
+    and libraries; for example, by invoking \c{make install}. For this reason,
+    qmake has the concept of an \c {install set}, an
+    object which contains instructions about the way a part of a project is to
+    be installed. For example, a collection of documentation files can be
+    described in the following way:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 79
+
+    The \c path member informs qmake that the files
+    should be installed in \c /usr/local/program/doc (the path member), and the
+    \c files member specifies the files that should be copied to the
+    installation directory. In this case, everything in the \c docs directory
+    will be copied to \c /usr/local/program/doc.
+
+    Once an install set has been fully described, you can append it to the
+    install list with a line like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 80
+
+    qmake will ensure that the specified files are
+    copied to the installation directory. If you require more control over
+    this process, you can also provide a definition for the \c extra member of
+    the object. For example, the following line tells
+    qmake to execute a series of commands for this
+    install set:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 81
+
+    The \c unix \l{Scopes and Conditions}{scope}
+    ensures that these particular commands are only executed on Unix platforms.
+    Appropriate commands for other platforms can be defined using other scope
+    rules.
+
+    Commands specified in the \c extra member are executed before the instructions
+    in the other members of the object are performed.
+
+    If you append a built-in install set to the \c INSTALLS variable and do
+    not specify \c files or \c extra members, qmake
+    will decide what needs to be copied for you. Currently, the \c target and \c dlltarget
+    install sets are supported. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 82
+
+    In the above lines, qmake knows what needs to
+    be copied, and will handle the installation process automatically.
+
+    \section1 Adding Custom Targets
+
+    qmake tries to do everything expected of a
+    cross-platform build tool. This is often less than ideal when you really
+    need to run special platform-dependent commands. This can be achieved with
+    specific instructions to the different qmake backends.
+
+    Customization of the Makefile output is performed through an object-style
+    API as found in other places in qmake. Objects are defined automatically by
+    specifying their \e members. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 86
+
+    The definitions above define a qmake target called \c mytarget, containing a
+    Makefile target called \c{.buildfile} which in turn is generated with the
+    \l{touchfunction}{touch()} function. Finally, the
+    \c{.depends} member specifies that \c mytarget depends on \c mytarget2,
+    another target that is defined afterwards. \c mytarget2 is a dummy target.
+    It is only defined to echo some text to the console.
+
+    The final step is to use the \c QMAKE_EXTRA_TARGETS variable to instruct
+    qmake that this object is a target to be built:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 87
+
+    This is all you need to do to actually build custom targets. Of course,
+    you may want to tie one of these targets to the
+    \l{TARGET}{qmake build target}. To do this, you
+    simply need to include your Makefile target in the list of
+    \l{PRE_TARGETDEPS}.
+
+    Custom target specifications support the following members:
+
+    \table
+    \header
+        \li Member
+        \li Description
+    \row
+        \li commands
+        \li The commands for generating the custom build target.
+    \row
+        \li CONFIG
+        \li Specific configuration options for the custom build target. Can be
+            set to \c recursive to indicate that rules should be created in the
+            Makefile to call the relevant target inside the sub-target specific
+            Makefile. This member defaults to creating an entry for each of the
+            sub-targets.
+    \row
+        \li depends
+        \li The existing build targets that the custom build target depends on.
+    \row
+        \li recurse
+        \li Specifies which sub-targets should be used when creating the rules
+            in the Makefile to call in the sub-target specific Makefile. This
+            member is used only when \c recursive is set in \c CONFIG. Typical
+            values are "Debug" and "Release".
+    \row
+        \li recurse_target
+        \li Specifies the target that should be built via the sub-target
+            Makefile for the rule in the Makefile. This member adds something
+            like \c {$(MAKE) -f Makefile.[subtarget] [recurse_target]}. This
+            member is used only when \c recursive is set in \c CONFIG.
+    \row
+        \li target
+        \li The name of the custom build target.
+    \endtable
+
+    \section1 Adding Compilers
+
+    It is possible to customize qmake to support new compilers and
+    preprocessors:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 88
+
+    With the above definitions, you can use a drop-in replacement for moc if one
+    is available. The command is executed on all arguments given to the
+    \c NEW_HEADERS variable (from the \c input member), and the result is written
+    to the file defined by the \c output member. This file is added to the
+    other source files in the project. Additionally, qmake will execute
+    \c depend_command to generate dependency information, and place this
+    information in the project as well.
+
+    Custom compiler specifications support the following members:
+
+    \table
+    \header
+        \li Member
+        \li Description
+    \row
+        \li commands
+        \li The commands used for for generating the output from the input.
+    \row
+        \li CONFIG
+        \li Specific configuration options for the custom compiler. See the
+            CONFIG table for details.
+    \row
+        \li depend_command
+        \li Specifies a command used to generate the list of dependencies for
+            the output.
+    \row
+        \li dependency_type
+        \li Specifies the type of file the output is. If it is a known type
+            (such as TYPE_C, TYPE_UI, TYPE_QRC), it is handled as one of those
+            type of files.
+    \row
+        \li depends
+        \li Specifies the dependencies of the output file.
+    \row
+        \li input
+        \li The variable that specifies the files that should be processed with
+            the custom compiler.
+    \row
+        \li name
+        \li A description of what the custom compiler is doing.  This is only
+            used in some backends.
+    \row
+        \li output
+        \li The filename that is created from the custom compiler.
+    \row
+        \li output_function
+        \li Specifies a custom qmake function that is used to specify the
+            filename to be created.
+    \row
+        \li variables
+        \li Indicates that the variables specified here are replaced with
+            $(QMAKE_COMP_VARNAME) when referred to in the pro file as
+            $(VARNAME).
+    \row
+        \li variable_out
+        \li The variable that the files created from the output should be added
+            to.
+    \endtable
+
+    The CONFIG member supports the following options:
+
+    \table
+    \header
+        \li Option
+        \li Description
+    \row
+        \li combine
+        \li Indicates that all of the input files are combined into a single
+            output file.
+    \row
+        \li target_predeps
+        \li Indicates that the output should be added to the list of
+            \l{PRE_TARGETDEPS}.
+    \row
+        \li explicit_dependencies
+        \li The dependencies for the output only get generated from the depends
+            member and from nowhere else.
+    \row
+        \li no_link
+        \li Indicates that the output should not be added to the list of objects
+            to be linked in.
+    \endtable
+
+    \target LibDepend
+    \section1 Library Dependencies
+
+    Often when linking against a library, qmake
+    relies on the underlying platform to know what other libraries this
+    library links against, and lets the platform pull them in. In many cases,
+    however, this is not sufficient. For example, when statically linking a
+    library, no other libraries are linked to, and therefore no dependencies
+    to those libraries are created. However, an application that later links
+    against this library will need to know where to find the symbols that
+    the static library will require. qmake attempts to keep track of the
+    dependencies of a library, where appropriate, if you explicitly enable
+    tracking.
+
+    The first step is to enable dependency tracking in the library itself.
+    To do this you must tell qmake to save information about the library:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 83
+
+    This is only relevant to the \c lib template, and will be ignored for all
+    others. When this option is enabled, qmake will create a file ending in .prl
+    which will save some meta-information about the library. This metafile is
+    just like an ordinary project file, but only contains internal variable
+    declarations. When installing this library, by specifying it as a target in
+    an \l{INSTALLS} declaration, qmake will automatically copy the .prl file to
+    the installation path.
+
+    The second step in this process is to enable reading of this meta
+    information in the applications that use the static library:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 84
+
+    When this is enabled, qmake will process all
+    libraries linked to by the application and find their meta-information.
+    qmake will use this to determine the relevant
+    linking information, specifically adding values to the application project
+    file's list of \l{DEFINES} as well as \l{LIBS}. Once
+    qmake has processed this file, it will then
+    look through the newly introduced libraries in the \c LIBS variable, and
+    find their dependent .prl files, continuing until all libraries have been
+    resolved. At this point, the Makefile is created as usual, and the
+    libraries are linked explicitly against the application.
+
+    The .prl files should be created by qmake only, and should not be
+    transferred between operating systems, as they may contain
+    platform-dependent information.
+*/
+
+/*!
+    \page qmake-precompiledheaders.html
+    \title Using Precompiled Headers
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Advanced Usage
+    \nextpage Configuring qmake
+
+    \target Introduction
+
+    Precompiled headers (PCH) are a performance feature supported by some
+    compilers to compile a stable body of code, and store the compiled
+    state of the code in a binary file. During subsequent compilations,
+    the compiler will load the stored state, and continue compiling the
+    specified file. Each subsequent compilation is faster because the
+    stable code does not need to be recompiled.
+
+    qmake supports the use of precompiled headers
+    on some platforms and build environments, including:
+    \list
+    \li Windows
+        \list
+        \li nmake
+        \li Visual Studio projects (VS 2008 and later)
+        \endlist
+    \li Mac OS X
+        \list
+        \li Makefile
+        \li Xcode
+        \endlist
+    \li Unix
+        \list
+        \li GCC 3.4 and above
+        \endlist
+    \endlist
+
+    \target ADD_PCH
+    \section1 Adding Precompiled Headers to Your Project
+
+    The precompiled header must contain code which is \e stable
+    and \e static throughout your project. A typical precompiled header might
+    look like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.cpp 104
+
+    \note A precompiled header file needs to separate C includes from
+    C++ includes, since the precompiled header file for C files may not
+    contain C++ code.
+
+    \target PROJECT_OPTIONS
+    \section2 Project Options
+
+    To make your project use precompiled headers, you only need to define the
+    \l{PRECOMPILED_HEADER} variable in your project file:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 105
+
+    qmake will handle the rest, to ensure the
+    creation and use of the precompiled header file. You do not need to
+    include the precompiled header file in \c HEADERS, as
+    qmake will do this if the configuration supports precompiled headers.
+
+    All platforms that support precompiled headers have the configuration
+    option \c precompile_header set. Using this option, you may trigger
+    conditional blocks in your project file to add settings when using
+    precompiled headers.
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 106
+
+    \section1 Notes on Possible Issues
+
+    On some platforms, the file name suffix for precompiled header files is
+    the same as that for other object files. For example, the following
+    declarations may cause two different object files with the same name to
+    be generated:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 107
+
+    To avoid potential conflicts like these, give distinctive names to header
+    files that will be precompiled.
+
+    \target EXAMPLE_PROJECT
+    \section1 Example Project
+
+    You can find the following source code in the
+    \c{examples/qmake/precompile} directory in the Qt distribution:
+
+    \section2 \c mydialog.ui
+
+    The following image displays the mydialog.ui file in Qt Creator Design mode.
+    You can view the code in the Edit mode.
+
+    \image qmake-precompile-ui.png
+
+    \section2 \c stable.h
+
+    \snippet snippets/qmake/precompile-stable.h 0
+
+    \omit
+    ##Keeping the snippet in qtdoc is a workaround, because it contains code
+    that would tell qdoc to start a new page. Remove it and put the
+    following snippet back after modularizing the docs.
+    \snippet examples/qmake/precompile/stable.h 0
+    \endomit
+
+    \section2 \c myobject.h
+
+    \code
+    #include <QObject>
+
+    class MyObject : public QObject
+    {
+    public:
+        MyObject();
+        ~MyObject();
+    };
+    \endcode
+
+    \omit
+    ##Remove the code and put the snippets back after modularizing the docs.
+    \snippet examples/qmake/precompile/myobject.h 0
+    \endomit
+
+    \section2 \c myobject.cpp
+
+    \code
+    #include <iostream>
+    #include <QDebug>
+    #include <QObject>
+    #include "myobject.h"
+
+    MyObject::MyObject()
+        : QObject()
+    {
+        std::cout << "MyObject::MyObject()\n";
+    }
+    \endcode
+
+    \omit
+    \snippet examples/qmake/precompile/myobject.cpp 0
+    \endomit
+
+    \section2 \c util.cpp
+
+    \code
+    void util_function_does_nothing()
+    {
+        // Nothing here...
+        int x = 0;
+        ++x;
+    }
+    \endcode
+
+    \omit
+    \snippet examples/qmake/precompile/util.cpp 0
+    \endomit
+
+    \section2 \c main.cpp
+
+    \code
+    #include <QApplication>
+    #include <QPushButton>
+    #include <QLabel>
+    #include "myobject.h"
+    #include "mydialog.h"
+
+    int main(int argc, char **argv)
+    {
+        QApplication app(argc, argv);
+
+        MyObject obj;
+        MyDialog dialog;
+
+        dialog.connect(dialog.aButton, SIGNAL(clicked()), SLOT(close()));
+        dialog.show();
+
+        return app.exec();
+    }
+    \endcode
+
+    \omit
+    \snippet examples/qmake/precompile/main.cpp 0
+    \endomit
+
+    \section2 \c precompile.pro
+
+    \code
+    TEMPLATE  = app
+    LANGUAGE  = C++
+    CONFIG   += console precompile_header
+    CONFIG   -= app_bundle
+
+    # Use Precompiled headers (PCH)
+    PRECOMPILED_HEADER  = stable.h
+
+    HEADERS   = stable.h \
+                mydialog.h \
+                myobject.h
+    SOURCES   = main.cpp \
+                mydialog.cpp \
+                myobject.cpp \
+                util.cpp
+    FORMS     = mydialog.ui
+    \endcode
+
+    \omit
+    \snippet examples/qmake/precompile/precompile.pro 0
+    \endomit
+*/
+
+/*!
+    \page qmake-tutorial.html
+    \title Getting Started
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Overview
+    \nextpage Creating Project Files
+
+    This tutorial teaches you the basics of qmake. The other topics in this
+    manual contain more detailed information about using qmake.
+
+    \section1 Starting off Simple
+
+    Let's assume that you have just finished a basic implementation of
+    your application, and you have created the following files:
+
+    \list
+    \li hello.cpp
+    \li hello.h
+    \li main.cpp
+    \endlist
+
+    You will find these files in the \c{examples/qmake/tutorial} directory
+    of the Qt distribution. The only other thing you know about the setup of
+    the application is that it's written in Qt.  First, using your favorite
+    plain text editor, create a file called \c hello.pro in
+    \c{examples/qmake/tutorial}. The first thing you need to do is add the
+    lines that tell qmake about the source and
+    header files that are part of your development project.
+
+    We'll add the source files to the project file first.  To do this you
+    need to use the \l{SOURCES} variable.
+    Just start a new line with \c {SOURCES +=} and put hello.cpp after it.
+    You should have something like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 108
+
+    We repeat this for each source file in the project, until we end up
+    with the following:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 109
+
+    If you prefer to use a Make-like syntax, with all the files listed in
+    one go you can use the newline escaping like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 110
+
+    Now that the source files are listed in the project file, the header
+    files must be added. These are added in exactly the same way as source
+    files, except that the variable name we use is \l{HEADERS}.
+
+    Once you have done this, your project file should look something like
+    this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 111
+
+    The target name is set automatically. It is the same as the project
+    filename, but with the suffix appropriate for the platform. For example, if
+    the project file is called \c hello.pro, the target will be \c hello.exe
+    on Windows and \c hello on Unix. If you want to use a different name
+    you can set it in the project file:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 112
+
+    The finished project file should look like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 113
+
+    You can now use qmake to generate a Makefile
+    for your application. On the command line, in your project directory,
+    type the following:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 114
+
+    Then type \c make or \c nmake depending on the compiler you use.
+
+    For Visual Studio users, qmake can also generate Visual Studio project
+    files. For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 115
+
+    \section1 Making an Application Debuggable
+
+    The release version of an application does not contain any debugging
+    symbols or other debugging information. During development, it is useful
+    to produce a debugging version of the application that has the
+    relevant information. This is easily achieved by adding \c debug to the
+    \l{CONFIG} variable in the project file.
+
+    For example:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 116
+
+    Use qmake as before to generate a Makefile. You will now obtain useful
+    information about your application when running it in a debugging
+    environment.
+
+    \section1 Adding Platform-Specific Source Files
+
+    After a few hours of coding, you might have made a start on the
+    platform-specific part of your application, and decided to keep the
+    platform-dependent code separate.  So you now have two new files to
+    include into your project file: \c hellowin.cpp and \c
+    hellounix.cpp.  We cannot just add these to the \c SOURCES
+    variable since that would place both files in the Makefile. So, what we
+    need to do here is to use a scope which will be processed depending on
+    which platform we are building for.
+
+    A simple scope that adds the platform-dependent file for
+    Windows looks like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 117
+
+    When building for Windows, qmake adds \c hellowin.cpp to the list of source
+    files. When building for any other platform, qmake simply ignores it. Now
+    all that is left to be done is to create a scope for the Unix-specific file.
+
+    When you have done that, your project file should look
+    something like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 118
+
+    Use qmake as before to generate a Makefile.
+
+    \section1 Stopping qmake If a File Does Not Exist
+
+    You may not want to create a Makefile if a certain file does not exist.
+    We can check if a file exists by using the \l{exists(filename)}{exists()}
+    function. We can stop qmake from processing by using the \l{error(string)}
+    {error()} function. This works in the same way as scopes do. Simply replace
+    the scope condition with the function. A check for a file called main.cpp looks
+    like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 119
+
+    The \c{!} symbol is used to negate the test. That is, \c{exists( main.cpp )}
+    is true if the file exists, and \c{!exists( main.cpp )} is true if the
+    file does not exist.
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 120
+
+    Use qmake as before to generate a makefile.
+    If you rename \c main.cpp temporarily, you will see the message and
+    qmake will stop processing.
+
+    \section1 Checking for More than One Condition
+
+    Suppose you use Windows and you want to be able to see statement
+    output with \c {qDebug()} when you run your application on the command line.
+    To see the output, you must build your application with the appropriate
+    console setting. We can easily put \c console on the \c CONFIG
+    line to include this setting in the Makefile on Windows. However,
+    let's say that we only want to add the \c CONFIG line when we are running
+    on Windows \e and when \c debug is already on the \c CONFIG line.
+    This requires using two nested scopes. First create one scope, then create
+    the other inside it. Put the settings to be processed inside the second
+    scope, like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 121
+
+    Nested scopes can be joined together using colons, so the final
+    project file looks like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 122
+
+    That's it! You have now completed the tutorial for
+    qmake, and are ready to write project files for
+    your development projects.
+*/
+
+/*!
+    \page qmake-common-projects.html
+    \title Building Common Project Types
+    \contentspage {qmake Manual}{Contents}
+    \previouspage Creating Project Files
+    \nextpage Running qmake
+
+    This chapter describes how to set up qmake project files for three common
+    project types that are based on Qt: application, library, and plugin.
+    Although all project types use many of the same variables, each of
+    them uses project-specific variables to customize output files.
+
+    Platform-specific variables are not described here. For more information,
+    see  \l{Deploying an Application on Windows} and
+    \l{Developing Qt Applications for Mac OS X}.
+
+    \target Application
+    \section1 Building an Application
+
+    The \c app template tells qmake to generate a
+    Makefile that will build an application. With this template, the type of
+    application can be specified by adding one of the following options to the
+    \l{CONFIG} variable definition:
+
+    \table
+    \header \li Option  \li Description
+    \row    \li windows \li The application is a Windows GUI application.
+    \row    \li console \li \c app template only: the application is a Windows console
+                       application.
+    \row    \li testcase \li The application is \l{Building a Testcase}{an automated test}.
+    \endtable
+
+    When using this template, the following qmake
+    system variables are recognized. You should use these in your .pro file to
+    specify information about your application.
+
+    \list
+    \li \l{HEADERS} - A list of header files for the application.
+    \li \l{SOURCES} - A list of C++ source files for the application.
+    \li \l{FORMS} - A list of UI files for the application (created using
+        Qt Designer).
+    \li \l{LEXSOURCES} - A list of Lex source files for the application.
+    \li \l{YACCSOURCES} - A list of Yacc source files for the
+        application.
+    \li \l{TARGET} - Name of the executable for the application. This defaults
+    to the name of the project file. (The extension, if any, is added
+    automatically).
+    \li \l{DESTDIR} - The directory in which the target executable is placed.
+    \li \l{DEFINES} - A list of any additional pre-processor defines needed for
+        the application.
+    \li \l{INCLUDEPATH} - A list of any additional include paths needed for the
+        application.
+    \li \l{DEPENDPATH} - The dependency search path for the application.
+    \li \l{VPATH} - The search path to find supplied files.
+    \li \l{DEF_FILE} - Windows only: A .def file to be linked against for the
+        application.
+    \li \l{RC_FILE} - Windows only: A resource file for the application.
+    \li \l{RES_FILE} - Windows only: A resource file to be linked against for
+        the application.
+    \endlist
+
+    You only need to use the system variables that you have values for. For
+    example, if you do not have any extra INCLUDEPATHs then you do not need
+    to specify any. qmake will add the necessary default values.
+    An example project file might look like this:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 123
+
+    For items that are single valued, such as the template or the destination
+    directory, we use "="; but for multi-valued items we use "+=" to \e
+    add to the existing items of that type. Using "=" replaces the variable
+    value with the new value. For example, if we write \c{DEFINES=USE_MY_STUFF},
+    all other definitions are deleted.
+
+    \section1 Building a Testcase
+
+    A testcase project is an \c app project intended to be run as an automated
+    test. Any \c app may be marked as a testcase by adding the value \c testcase
+    to the \c CONFIG variable.
+
+    For testcase projects, qmake will insert a \c check
+    target into the generated Makefile. This target will run the application.
+    The test is considered to pass if it terminates with an exit code equal to zero.
+
+    The \c check target automatically recurses through
+    \l{SUBDIRS} projects. This means it is
+    possible to issue a \c{make check} command from within a SUBDIRS project
+    to run an entire test suite.
+
+    The execution of the \c check target may be customized by certain Makefile
+    variables. These variables are:
+
+    \table
+    \header
+        \li Variable
+        \li Description
+    \row
+        \li TESTRUNNER
+        \li A command or shell fragment prepended to each test command. An example
+            use-case is a "timeout" script which will terminate a test if it does not
+            complete within a specified time.
+    \row
+        \li TESTARGS
+        \li Additional arguments appended to each test command. For example, it may
+            be useful to pass additional arguments to set the output file and format
+            from the test (such as the \c{-o filename,format} option supported by
+            \l{QTestLib}).
+    \endtable
+
+    \note The variables must be set while invoking the \c make tool, not in the
+    .pro file. Most \c make tools support the setting of Makefile variables directly
+    on the command-line:
+
+    \code
+        # Run tests through test-wrapper and use xunitxml output format.
+        # In this example, test-wrapper is a fictional wrapper script which terminates
+        # a test if it does not complete within the amount of seconds set by "--timeout".
+        # The "-o result.xml,xunitxml" options are interpreted by QTestLib.
+        make check TESTRUNNER="test-wrapper --timeout 120" TESTARGS="-o result.xml,xunitxml"
+    \endcode
+
+    Testcase projects may be further customized with the following \c CONFIG options:
+
+    \table
+    \header
+        \li Option
+        \li Description
+    \row
+        \li insignificant_test
+        \li The exit code of the test will be ignored during \c{make check}.
+    \endtable
+
+    Testcases will often be written with \l{QTest} or \l{TestCase}, but
+    that is not a requirement to make use of \c{CONFIG+=testcase} and \c{make check}.
+    The only primary requirement is that the test program exit with a zero exit code
+    on success, and a non-zero exit code on failure.
+
+    \target Library
+    \section1 Building a Library
+
+    The \c lib template tells qmake to generate a Makefile that will build a
+    library.  When using this template, the \l{VERSION} variable is supported,
+    in addition to the system variables that the \c app template supports. Use
+    the variables in your .pro file to specify information about the library.
+
+    When using the \c lib template, the following options can be added to the
+    \l{CONFIG} variable to determine the type of library that is built:
+
+    \table
+    \header \li Option    \li Description
+    \row    \li dll       \li The library is a shared library (dll).
+    \row    \li staticlib \li The library is a static library.
+    \row    \li plugin    \li The library is a plugin.
+    \endtable
+
+    The following option can also be defined to provide additional information about
+    the library.
+
+    \list
+    \li VERSION - The version number of the target library. For example, 2.3.1.
+    \endlist
+
+    The target file name for the library is platform-dependent. For example, on
+    X11 and Mac OS X, the library name will be prefixed by \c lib. On Windows,
+    no prefix is added to the file name.
+
+    \target Plugin
+    \section1 Building a Plugin
+
+    Plugins are built using the \c lib template, as described in the previous
+    section. This tells qmake to generate a
+    Makefile for the project that will build a plugin in a suitable form for
+    each platform, usually in the form of a library. As with ordinary
+    libraries, the \l{VERSION} variable is used to specify information about the
+    plugin.
+
+    \list
+    \li VERSION - The version number of the target library. For example, 2.3.1.
+    \endlist
+
+    \section2 Building a Qt Designer Plugin
+
+    \QD plugins are built using a specific set of configuration settings that
+    depend on the way Qt was configured for your system. For convenience, these
+    settings can be enabled by adding \c designer to the \l{Variables#QT}{QT}
+    variable. For example:
+
+    \code
+    QT          += widgets designer
+    \endcode
+
+    See the \l{Qt Designer Examples} for more examples of plugin-based projects.
+
+    \section1 Building and Installing in Debug and Release Modes
+
+    Sometimes, it is necessary to build a project in both debug and release
+    modes. Although the \l{CONFIG} variable can hold both \c debug and \c release
+    options, the \c debug option overrides the \c release option.
+
+    \section2 Building in Both Modes
+
+    To enable a project to be built in both modes, you must add the
+    \c debug_and_release option to the \c CONFIG variable:
+
+    \snippet snippets/qmake/debug_and_release.pro 0
+    \snippet snippets/qmake/debug_and_release.pro 1
+
+    The scope in the above snippet modifies the build target in each mode to
+    ensure that the resulting targets have different names. Providing different
+    names for targets ensures that one will not overwrite the other.
+
+    When qmake processes the project file, it will
+    generate a Makefile rule to allow the project to be built in both modes.
+    This can be invoked in the following way:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 124
+
+    The \c build_all option can be added to the \c CONFIG variable in the
+    project file to ensure that the project is built in both modes by default:
+
+    \snippet snippets/qmake/debug_and_release.pro 2
+
+    This allows the Makefile to be processed using the default rule:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 125
+
+    \section2 Installing in Both Modes
+
+    The \c build_all option also ensures that both versions of the target
+    will be installed when the installation rule is invoked:
+
+    \snippet snippets/code/doc_src_qmake-manual.pro 126
+
+    It is possible to customize the names of the build targets depending on
+    the target platform. For example, a library or plugin may be named using a
+    different convention on Windows from the one used on Unix platforms:
+
+    \omit
+    Note: This was originally used in the customwidgetplugin.pro file, but is
+    no longer needed there.
+    \endomit
+    \snippet snippets/code/doc_src_qmake-manual.pro 127
+
+    The default behavior in the above snippet is to modify the name used for
+    the build target when building in debug mode. An \c else clause could be
+    added to the scope to do the same for release mode. Left as it is, the
+    target name remains unmodified.
+*/
+
diff --git a/qmake/doc/src/snippets/code/doc_src_qmake-manual.cpp b/qmake/doc/src/snippets/code/doc_src_qmake-manual.cpp
new file mode 100644
index 0000000000..bd63e600cd
--- /dev/null
+++ b/qmake/doc/src/snippets/code/doc_src_qmake-manual.cpp
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//! [104]
+// Add C includes here
+
+#if defined __cplusplus
+// Add C++ includes here
+#include <stdlib>
+#include <iostream>
+#include <vector>
+#include <QApplication> // Qt includes
+#include <QPushButton>
+#include <QLabel>
+#include "thirdparty/include/libmain.h"
+#include "my_stable_class.h"
+...
+#endif
+//! [104]
+
+
diff --git a/qmake/doc/src/snippets/code/doc_src_qmake-manual.pro b/qmake/doc/src/snippets/code/doc_src_qmake-manual.pro
new file mode 100644
index 0000000000..0ee4785887
--- /dev/null
+++ b/qmake/doc/src/snippets/code/doc_src_qmake-manual.pro
@@ -0,0 +1,917 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#! [0]
+make all
+#! [0]
+
+
+#! [1]
+CONFIG += qt debug
+#! [1]
+
+
+#! [2]
+QT += network xml
+#! [2]
+
+
+#! [3]
+QT = network xml # This will omit the core and gui modules.
+#! [3]
+
+
+#! [4]
+QT -= gui # Only the core module is used.
+#! [4]
+
+
+#! [5]
+CONFIG += link_pkgconfig
+PKGCONFIG += ogg dbus-1
+#! [5]
+
+
+#! [6]
+LIBS += -L/usr/local/lib -lmath
+#! [6]
+
+
+#! [7]
+INCLUDEPATH = c:/msdev/include d:/stl/include
+#! [7]
+
+
+#! [8]
+qmake [mode] [options] files
+#! [8]
+
+
+#! [9]
+qmake -makefile [options] files
+#! [9]
+
+
+#! [10]
+qmake -makefile -o Makefile "CONFIG+=test" test.pro
+#! [10]
+
+
+#! [11]
+qmake "CONFIG+=test" test.pro
+#! [11]
+
+
+#! [12]
+qmake -project [options] files
+#! [12]
+
+
+#! [13]
+qmake -spec macx-g++
+#! [13]
+
+
+#! [14]
+QMAKE_LFLAGS += -F/path/to/framework/directory/
+#! [14]
+
+
+#! [15]
+LIBS += -framework TheFramework
+#! [15]
+
+
+#! [16]
+TEMPLATE = lib
+CONFIG += lib_bundle
+#! [16]
+
+
+#! [17]
+FRAMEWORK_HEADERS.version = Versions
+FRAMEWORK_HEADERS.files = path/to/header_one.h path/to/header_two.h
+FRAMEWORK_HEADERS.path = Headers
+QMAKE_BUNDLE_DATA += FRAMEWORK_HEADERS
+#! [17]
+
+
+#! [19]
+qmake -spec macx-xcode project.pro
+#! [19]
+
+
+#! [20]
+qmake -tp vc
+#! [20]
+
+
+#! [21]
+qmake -tp vc -r
+#! [21]
+
+
+#! [22]
+CONFIG -= embed_manifest_exe
+#! [22]
+
+
+#! [23]
+CONFIG -= embed_manifest_dll
+#! [23]
+
+
+#! [24]
+make all
+#! [24]
+
+
+#! [25]
+build_pass:CONFIG(debug, debug|release) {
+    unix: TARGET = $$join(TARGET,,,_debug)
+    else: TARGET = $$join(TARGET,,,d)
+}
+#! [25]
+
+
+#! [26]
+CONFIG += console newstuff
+...
+newstuff {
+    SOURCES += new.cpp
+    HEADERS += new.h
+}
+#! [26]
+
+
+#! [27]
+DEFINES += USE_MY_STUFF
+#! [27]
+
+
+#! [28]
+myFiles.files = path\*.png
+DEPLOYMENT += myFiles
+#! [28]
+
+
+#! [29]
+myFiles.files = path\file1.ext1 path2\file2.ext1 path3\*
+myFiles.path = \some\path\on\device
+someother.files = C:\additional\files\*
+someother.path = \myFiles\path2
+DEPLOYMENT += myFiles someother
+#! [29]
+
+
+#! [30]
+DESTDIR = ../../lib
+#! [30]
+
+
+#! [31]
+DISTFILES += ../program.txt
+#! [31]
+
+
+#! [32]
+FORMS = mydialog.ui \
+    mywidget.ui \
+        myconfig.ui
+#! [32]
+
+
+#! [33]
+FORMS3 = my_uic3_dialog.ui \
+     my_uic3_widget.ui \
+         my_uic3_config.ui
+#! [33]
+
+
+#! [34]
+HEADERS = myclass.h \
+          login.h \
+          mainwindow.h
+#! [34]
+
+
+#! [35]
+INCLUDEPATH = c:/msdev/include d:/stl/include
+#! [35]
+
+
+#! [36]
+target.path += $$[QT_INSTALL_PLUGINS]/imageformats
+INSTALLS += target
+#! [36]
+
+
+#! [37]
+LEXSOURCES = lexer.l
+#! [37]
+
+
+#! [38]
+unix:LIBS += -L/usr/local/lib -lmath
+win32:LIBS += c:/mylibs/math.lib
+#! [38]
+
+
+#! [39]
+CONFIG += no_lflags_merge
+#! [39]
+
+
+#! [40]
+unix:MOC_DIR = ../myproject/tmp
+win32:MOC_DIR = c:/myproject/tmp
+#! [40]
+
+
+#! [41]
+unix:OBJECTS_DIR = ../myproject/tmp
+win32:OBJECTS_DIR = c:/myproject/tmp
+#! [41]
+
+
+#! [43]
+FRAMEWORK_HEADERS.version = Versions
+FRAMEWORK_HEADERS.files = path/to/header_one.h path/to/header_two.h
+FRAMEWORK_HEADERS.path = Headers
+QMAKE_BUNDLE_DATA += FRAMEWORK_HEADERS
+#! [43]
+
+
+#! [44]
+QMAKE_BUNDLE_EXTENSION = .myframework
+#! [44]
+
+
+#! [45]
+QMAKE_RESOURCE_FLAGS += -threshold 0 -compress 9
+#! [45]
+
+
+#! [47]
+QT -= gui # Only the core module is used.
+#! [47]
+
+
+#! [48]
+unix:RCC_DIR = ../myproject/resources
+win32:RCC_DIR = c:/myproject/resources
+#! [48]
+
+
+#! [49]
+SOURCES = myclass.cpp \
+      login.cpp \
+      mainwindow.cpp
+#! [49]
+
+
+#! [50]
+SUBDIRS = kernel \
+          tools
+#! [50]
+
+
+#! [51]
+CONFIG += ordered
+#! [51]
+
+
+#! [52]
+TEMPLATE = app
+TARGET = myapp
+SOURCES = main.cpp
+#! [52]
+
+
+#! [53]
+TEMPLATE = lib
+SOURCES = main.cpp
+TARGET = mylib
+#! [53]
+
+
+#! [54]
+unix:UI_DIR = ../myproject/ui
+win32:UI_DIR = c:/myproject/ui
+#! [54]
+
+
+#! [57]
+VERSION = 1.2.3
+#! [57]
+
+
+#! [58]
+YACCSOURCES = moc.y
+#! [58]
+
+
+#! [59]
+FILE = /etc/passwd
+FILENAME = $$basename(FILE) #passwd
+#! [59]
+
+
+#! [60]
+CONFIG = debug
+CONFIG += release
+CONFIG(release, debug|release):message(Release build!) #will print
+CONFIG(debug, debug|release):message(Debug build!) #no print
+#! [60]
+
+
+#! [61]
+contains( drivers, network ) {
+    # drivers contains 'network'
+    message( "Configuring for network build..." )
+    HEADERS += network.h
+    SOURCES += network.cpp
+}
+#! [61]
+
+
+#! [62]
+error(An error has occurred in the configuration process.)
+#! [62]
+
+
+#! [63]
+exists( $(QTDIR)/lib/libqt-mt* ) {
+      message( "Configuring for multi-threaded Qt..." )
+      CONFIG += thread
+}
+#! [63]
+
+
+#! [64]
+MY_VAR = one two three four
+MY_VAR2 = $$join(MY_VAR, " -L", -L) -Lfive
+MY_VAR3 = $$member(MY_VAR, 2) $$find(MY_VAR, t.*)
+#! [64]
+
+
+#! [65]
+LIST = 1 2 3
+for(a, LIST):exists(file.$${a}):message(I see a file.$${a}!)
+#! [65]
+
+
+#! [66]
+include( shared.pri )
+OPTIONS = standard custom
+!include( options.pri ) {
+    message( "No custom build options specified" )
+OPTIONS -= custom
+}
+#! [66]
+
+
+#! [67]
+isEmpty( CONFIG ) {
+CONFIG += warn_on debug
+}
+#! [67]
+
+
+#! [68]
+message( "This is a message" )
+#! [68]
+
+
+#! [69]
+!build_pass:message( "This is a message" )
+#! [69]
+
+
+#! [70]
+This is a test.
+#! [70]
+
+
+#! [71]
+system(ls /bin):HAS_BIN=FALSE
+#! [71]
+
+
+#! [72]
+UNAME = $$system(uname -s)
+contains( UNAME, [lL]inux ):message( This looks like Linux ($$UNAME) to me )
+#! [72]
+
+
+#! [73]
+ARGS = 1 2 3 2 5 1
+ARGS = $$unique(ARGS) #1 2 3 5
+#! [73]
+
+
+#! [74]
+qmake -set PROPERTY VALUE
+#! [74]
+
+
+#! [75]
+qmake -query PROPERTY
+qmake -query #queries all current PROPERTY/VALUE pairs
+#! [75]
+
+
+#! [77]
+qmake -query "QT_INSTALL_PREFIX"
+#! [77]
+
+
+#! [78]
+QMAKE_VERS = $$[QMAKE_VERSION]
+#! [78]
+
+
+#! [79]
+documentation.path = /usr/local/program/doc
+documentation.files = docs/*
+#! [79]
+
+
+#! [80]
+INSTALLS += documentation
+#! [80]
+
+
+#! [81]
+unix:documentation.extra = create_docs; mv master.doc toc.doc
+#! [81]
+
+
+#! [82]
+target.path = /usr/local/myprogram
+INSTALLS += target
+#! [82]
+
+
+#! [83]
+CONFIG += create_prl
+#! [83]
+
+
+#! [84]
+CONFIG += link_prl
+#! [84]
+
+
+#! [85]
+QMAKE_EXT_MOC = .mymoc
+#! [85]
+
+
+#! [86]
+mytarget.target = .buildfile
+mytarget.commands = touch $$mytarget.target
+mytarget.depends = mytarget2
+
+mytarget2.commands = @echo Building $$mytarget.target
+#! [86]
+
+
+#! [87]
+QMAKE_EXTRA_TARGETS += mytarget mytarget2
+#! [87]
+
+
+#! [88]
+new_moc.output  = moc_${QMAKE_FILE_BASE}.cpp
+new_moc.commands = moc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
+new_moc.depend_command = g++ -E -M ${QMAKE_FILE_NAME} | sed "s,^.*: ,,"
+new_moc.input = NEW_HEADERS
+QMAKE_EXTRA_COMPILERS += new_moc
+#! [88]
+
+
+#! [89]
+TARGET = myapp
+#! [89]
+
+
+#! [90]
+DEFINES += USE_MY_STUFF
+#! [90]
+
+
+#! [91]
+DEFINES -= USE_MY_STUFF
+#! [91]
+
+
+#! [92]
+DEFINES *= USE_MY_STUFF
+#! [92]
+
+
+#! [93]
+DEFINES ~= s/QT_[DT].+/QT
+#! [93]
+
+
+#! [94]
+EVERYTHING = $$SOURCES $$HEADERS
+message("The project contains the following files:")
+message($$EVERYTHING)
+#! [94]
+
+
+#! [95]
+win32:DEFINES += USE_MY_STUFF
+#! [95]
+
+
+#! [96]
+win32:xml {
+    message(Building for Windows)
+    SOURCES += xmlhandler_win.cpp
+} else:xml {
+    SOURCES += xmlhandler.cpp
+} else {
+    message("Unknown configuration")
+}
+#! [96]
+
+
+#! [97]
+MY_VARIABLE = value
+#! [97]
+
+
+#! [98]
+MY_DEFINES = $$DEFINES
+#! [98]
+
+
+#! [99]
+MY_DEFINES = $${DEFINES}
+#! [99]
+
+
+#! [100]
+TARGET = myproject_$${TEMPLATE}
+#! [100]
+
+
+#! [101]
+target.path = $$[QT_INSTALL_PLUGINS]/designer
+INSTALLS += target
+#! [101]
+
+
+#! [102]
+defineReplace(functionName){
+    #function code
+}
+#! [102]
+
+
+#! [103]
+CONFIG += myfeatures
+#! [103]
+
+
+#! [105]
+PRECOMPILED_HEADER = stable.h
+#! [105]
+
+
+#! [106]
+precompile_header:!isEmpty(PRECOMPILED_HEADER) {
+DEFINES += USING_PCH
+}
+#! [106]
+
+
+#! [107]
+PRECOMPILED_HEADER = window.h
+SOURCES            = window.cpp
+#! [107]
+
+
+#! [108]
+SOURCES += hello.cpp
+#! [108]
+
+
+#! [109]
+SOURCES += hello.cpp
+SOURCES += main.cpp
+#! [109]
+
+
+#! [110]
+SOURCES = hello.cpp \
+          main.cpp
+#! [110]
+
+
+#! [111]
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+#! [111]
+
+
+#! [112]
+TARGET = helloworld
+#! [112]
+
+
+#! [113]
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+#! [113]
+
+
+#! [114]
+qmake -o Makefile hello.pro
+#! [114]
+
+
+#! [115]
+qmake -tp vc hello.pro
+#! [115]
+
+
+#! [116]
+CONFIG += debug
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+#! [116]
+
+
+#! [117]
+win32 {
+    SOURCES += hellowin.cpp
+}
+#! [117]
+
+
+#! [118]
+CONFIG += debug
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+win32 {
+    SOURCES += hellowin.cpp
+}
+unix {
+    SOURCES += hellounix.cpp
+}
+#! [118]
+
+
+#! [119]
+!exists( main.cpp ) {
+    error( "No main.cpp file found" )
+}
+#! [119]
+
+
+#! [120]
+CONFIG += debug
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+win32 {
+    SOURCES += hellowin.cpp
+}
+unix {
+    SOURCES += hellounix.cpp
+}
+!exists( main.cpp ) {
+    error( "No main.cpp file found" )
+}
+#! [120]
+
+
+#! [121]
+win32 {
+    debug {
+        CONFIG += console
+    }
+}
+#! [121]
+
+
+#! [122]
+CONFIG += debug
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+win32 {
+    SOURCES += hellowin.cpp
+}
+unix {
+    SOURCES += hellounix.cpp
+}
+!exists( main.cpp ) {
+    error( "No main.cpp file found" )
+}
+win32:debug {
+    CONFIG += console
+}
+#! [122]
+
+
+#! [123]
+TEMPLATE = app
+DESTDIR  = c:/helloapp
+HEADERS += hello.h
+SOURCES += hello.cpp
+SOURCES += main.cpp
+DEFINES += USE_MY_STUFF
+CONFIG  += release
+#! [123]
+
+
+#! [124]
+make all
+#! [124]
+
+
+#! [125]
+make
+#! [125]
+
+
+#! [126]
+make install
+#! [126]
+
+
+#! [127]
+CONFIG(debug, debug|release) {
+    mac: TARGET = $$join(TARGET,,,_debug)
+    win32: TARGET = $$join(TARGET,,d)
+}
+#! [127]
+
+#! [142]
+DEPLOYMENT_PLUGIN += qjpeg
+#! [142]
+
+#! [149]
+SUBDIRS += my_executable my_library
+my_executable.subdir = app
+my_executable.depends = my_library
+my_library.subdir = lib
+#! [149]
+
+#! [157]
+packagesExist(sqlite3 QtNetwork QtDeclarative) {
+    DEFINES += USE_FANCY_UI
+}
+#! [157]
+
+#! [158]
+#ifdef USE_FANCY_UI
+    // Use the fancy UI, as we have extra packages available
+#endif
+#! [158]
+
+#! [159]
+message($$absolute_path("readme.txt", "/home/johndoe/myproject"))
+#! [159]
+
+
+#! [160]
+TARGET = helloworld
+equals(TARGET, "helloworld") {
+    message("The target assignment was successful.")
+}
+#! [160]
+
+
+#! [161]
+CONTACT = firstname middlename surname phone
+message($$first(CONTACT))
+#! [161]
+
+
+#! [162]
+CONTACT = firstname middlename surname phone
+message($$last(CONTACT))
+#! [162]
+
+
+#! [163]
+message($$format_number(BAD, ibase=16 width=6 zeropad))
+#! [163]
+
+
+#! [164]
+ANSWER = 42
+greaterThan(ANSWER, 1) {
+    message("The answer might be correct.")
+}
+#! [164]
+
+
+#! [165]
+ANSWER = 42
+lessThan(ANSWER, 1) {
+    message("The answer might be wrong.")
+}
+#! [165]
+
+
+#! [166]
+if(linux-g++*|macx-g++*):CONFIG(debug, debug|release) {
+    message("We are on Linux or Mac OS, and we are in debug mode.")
+}
+#! [166]
+
+
+#! [167]
+CONTACT = firstname:middlename:surname:phone
+message($$section(CONTACT, :, 2, 2))
+#! [167]
+
+
+#! [168]
+CONTACT = firstname:middlename:surname:phone
+message($$split(CONTACT, :))
+#! [168]
+
+#! [169]
+NARF = zort
+unset(NARF)
+!defined(NARF, var) {
+    message("NARF is not defined.")
+}
+#! [169]
+
+
+#! [170]
+for(var, $$list(foo bar baz)) {
+    ...
+}
+#! [170]
+
+
+#! [171]
+values = foo bar baz
+for(var, values) {
+    ...
+}
+#! [171]
+
+
+#! [172]
+VALUE = 123
+TMP_VALUE = x$$VALUE
+greaterThan(TMP_VALUE, x456): message("Condition may be true.")
+#! [172]
+
+
+#! [173]
+message("First line$$escape_expand(\\n)Second line")
+#! [173]
diff --git a/qmake/doc/src/snippets/qmake/comments.pro b/qmake/doc/src/snippets/qmake/comments.pro
new file mode 100644
index 0000000000..957052c81d
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/comments.pro
@@ -0,0 +1,10 @@
+#! [0]
+# Comments usually start at the beginning of a line, but they
+# can also follow other content on the same line.
+#! [0]
+
+#! [1]
+# To include a literal hash character, use the $$LITERAL_HASH variable:
+urlPieces = http://qt-project.org/doc/qt-5.0/qtgui/qtextdocument.html pageCount
+message($$join(urlPieces, $$LITERAL_HASH))
+#! [1]
diff --git a/qmake/doc/src/snippets/qmake/configscopes.pro b/qmake/doc/src/snippets/qmake/configscopes.pro
new file mode 100644
index 0000000000..6ab7f7c428
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/configscopes.pro
@@ -0,0 +1,23 @@
+SOURCES = main.cpp
+#! [0]
+CONFIG += opengl
+#! [0]
+
+#! [1]
+opengl {
+    TARGET = application-gl
+} else {
+#! [1] #! [2]
+    TARGET = application
+#! [2] #! [3]
+}
+#! [3]
+
+#! [4]
+CONFIG(opengl) {
+    message(Building with OpenGL support.)
+} else {
+#! [4] #! [5]
+    message(OpenGL support is not available.)
+}
+#! [5]
diff --git a/qmake/doc/src/snippets/qmake/debug_and_release.pro b/qmake/doc/src/snippets/qmake/debug_and_release.pro
new file mode 100644
index 0000000000..92e8dbf76a
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/debug_and_release.pro
@@ -0,0 +1,14 @@
+#! [0]
+CONFIG += debug_and_release
+
+CONFIG(debug, debug|release) {
+    TARGET = debug_binary
+} else {
+#! [0] #! [1]
+    TARGET = release_binary
+}
+#! [1]
+
+#! [2]
+CONFIG += build_all
+#! [2]
diff --git a/qmake/doc/src/snippets/qmake/delegate.h b/qmake/doc/src/snippets/qmake/delegate.h
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/delegate.h
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/dereferencing.pro b/qmake/doc/src/snippets/qmake/dereferencing.pro
new file mode 100644
index 0000000000..ff0c97995c
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/dereferencing.pro
@@ -0,0 +1,5 @@
+#! [0]
+TEMP_SOURCES = $$SOURCES
+#! [0]
+# Do something with the SOURCES variable then restore its old value.
+SOURCES = $$TEMP_SOURCES
diff --git a/qmake/doc/src/snippets/qmake/destdir.pro b/qmake/doc/src/snippets/qmake/destdir.pro
new file mode 100644
index 0000000000..b2f943904a
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/destdir.pro
@@ -0,0 +1,2 @@
+SOURCES = main.cpp
+DESTDIR = output
diff --git a/qmake/doc/src/snippets/qmake/dirname.pro b/qmake/doc/src/snippets/qmake/dirname.pro
new file mode 100644
index 0000000000..59e1f20b3f
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/dirname.pro
@@ -0,0 +1,6 @@
+#! [0]
+FILE = /etc/X11R6/XF86Config
+DIRNAME = $$dirname(FILE) #/etc/X11R6
+#! [0]
+message($$FILE)
+message($$DIRNAME)
diff --git a/qmake/doc/src/snippets/qmake/environment.pro b/qmake/doc/src/snippets/qmake/environment.pro
new file mode 100644
index 0000000000..808bdeba47
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/environment.pro
@@ -0,0 +1,9 @@
+#! [0] #! [1]
+DESTDIR = $$(PWD)
+message(The project will be installed in $$DESTDIR)
+#! [0]
+
+DESTDIR = $(PWD)
+message(The project will be installed in the value of PWD)
+message(when the Makefile is processed.)
+#! [1]
diff --git a/qmake/doc/src/snippets/qmake/functions.pro b/qmake/doc/src/snippets/qmake/functions.pro
new file mode 100644
index 0000000000..2766120719
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/functions.pro
@@ -0,0 +1,34 @@
+#! [0]
+EXTRAS = handlers tests docs
+for(dir, EXTRAS) {
+    exists($$dir) {
+        SUBDIRS += $$dir
+    }
+}
+#! [0]
+
+SOURCES = paintwidget_mac.cpp paintwidget_unix.cpp paintwidget_win.cpp
+macx {
+    SOURCES = $$find(SOURCES, "_mac")
+}
+
+#! [1]
+HEADERS = model.h
+HEADERS += $$OTHER_HEADERS
+HEADERS = $$unique(HEADERS)
+#! [1]
+
+CONFIG += debug
+#! [2]
+options = $$find(CONFIG, "debug") $$find(CONFIG, "release")
+#! [3]
+count(options, 2) {
+    message(Both release and debug specified.)
+}
+#! [2] #! [3]
+
+#! [4]
+eval(TARGET = myapp) {
+    message($$TARGET)
+}
+#! [4]
diff --git a/qmake/doc/src/snippets/qmake/include.pro b/qmake/doc/src/snippets/qmake/include.pro
new file mode 100644
index 0000000000..37e7156957
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/include.pro
@@ -0,0 +1,3 @@
+#! [0]
+include(other.pro)
+#! [0]
diff --git a/qmake/doc/src/snippets/qmake/main.cpp b/qmake/doc/src/snippets/qmake/main.cpp
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/main.cpp
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/model.cpp b/qmake/doc/src/snippets/qmake/model.cpp
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/model.cpp
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/model.h b/qmake/doc/src/snippets/qmake/model.h
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/model.h
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/other.pro b/qmake/doc/src/snippets/qmake/other.pro
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/other.pro
diff --git a/qmake/doc/src/snippets/qmake/paintwidget_mac.cpp b/qmake/doc/src/snippets/qmake/paintwidget_mac.cpp
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/paintwidget_mac.cpp
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/paintwidget_unix.cpp b/qmake/doc/src/snippets/qmake/paintwidget_unix.cpp
new file mode 100644
index 0000000000..c39fc2cbf6
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/paintwidget_unix.cpp
@@ -0,0 +1,44 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    return 0;
+}
diff --git a/qmake/doc/src/snippets/qmake/paintwidget_win.cpp b/qmake/doc/src/snippets/qmake/paintwidget_win.cpp
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/paintwidget_win.cpp
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/doc/src/snippets/qmake/precompile-stable.h b/qmake/doc/src/snippets/qmake/precompile-stable.h
new file mode 100644
index 0000000000..eef8cef728
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/precompile-stable.h
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//! [0]
+/* Add C includes here */
+
+#if defined __cplusplus
+/* Add C++ includes here */
+
+# include <iostream>
+# include <QApplication>
+# include <QPushButton>
+# include <QLabel>
+#endif
+//! [0]
diff --git a/qmake/doc/src/snippets/qmake/project_location.pro b/qmake/doc/src/snippets/qmake/project_location.pro
new file mode 100644
index 0000000000..09d9b3d9d0
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/project_location.pro
@@ -0,0 +1,6 @@
+#! [project file]
+message($$_PRO_FILE_)
+#! [project file]
+#! [project file directory]
+message($$_PRO_FILE_PWD_)
+#! [project file directory]
diff --git a/qmake/doc/src/snippets/qmake/qtconfiguration.pro b/qmake/doc/src/snippets/qmake/qtconfiguration.pro
new file mode 100644
index 0000000000..55e13be352
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/qtconfiguration.pro
@@ -0,0 +1,18 @@
+# Show information about the Qt installation.
+#! [0]
+message(Qt version: $$[QT_VERSION])
+message(Qt is installed in $$[QT_INSTALL_PREFIX])
+message(Qt resources can be found in the following locations:)
+message(Documentation: $$[QT_INSTALL_DOCS])
+message(Header files: $$[QT_INSTALL_HEADERS])
+message(Libraries: $$[QT_INSTALL_LIBS])
+message(Binary files (executables): $$[QT_INSTALL_BINS])
+message(Plugins: $$[QT_INSTALL_PLUGINS])
+message(Data files: $$[QT_INSTALL_DATA])
+message(Translation files: $$[QT_INSTALL_TRANSLATIONS])
+message(Settings: $$[QT_INSTALL_SETTINGS])
+message(Examples: $$[QT_INSTALL_EXAMPLES])
+#! [0]
+
+# Show configuration information.
+message(CONFIG = $$CONFIG)
diff --git a/qmake/doc/src/snippets/qmake/quoting.pro b/qmake/doc/src/snippets/qmake/quoting.pro
new file mode 100644
index 0000000000..62efb2042e
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/quoting.pro
@@ -0,0 +1,8 @@
+#! [0]
+DEST = "Program Files"
+#! [0]
+count(DEST, 1) {
+    message(Only one item found in DEST.)
+} else {
+    message(More than one item found in DEST.)
+}
diff --git a/qmake/doc/src/snippets/qmake/replace.pro b/qmake/doc/src/snippets/qmake/replace.pro
new file mode 100644
index 0000000000..504e01a018
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/replace.pro
@@ -0,0 +1,4 @@
+#! [0]
+MESSAGE = This is a tent.
+message($$replace(MESSAGE, tent, test))
+#! [0]
diff --git a/qmake/doc/src/snippets/qmake/replacefunction.pro b/qmake/doc/src/snippets/qmake/replacefunction.pro
new file mode 100644
index 0000000000..98013ba42d
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/replacefunction.pro
@@ -0,0 +1,46 @@
+#! [0]
+defineReplace(headersAndSources) {
+    variable = $$1
+    names = $$eval($$variable)
+    headers =
+    sources =
+
+    for(name, names) {
+        header = $${name}.h
+        exists($$header) {
+            headers += $$header
+        }
+        source = $${name}.cpp
+        exists($$source) {
+            sources += $$source
+        }
+    }
+    return($$headers $$sources)
+}
+#! [0]
+
+defineReplace(matchingFiles) {
+    names = $$ARGS
+    files =
+
+    for(name, names) {
+        header = $${name}.h
+        source = $${name}.cpp
+        exists($$header):exists($$source) {
+            files += $$header
+            files += $$source
+        }
+    }
+    return($$files)
+}
+
+names = delegate model view main
+message(Finding all headers and sources from the following list of names:)
+message($$names)
+allFiles = $$headersAndSources(names)
+message(Found: $$allFiles)
+
+message(Finding only matching headers and sources from the following list of names:)
+message($$names)
+matching = $$matchingFiles($$names)
+message(Found: $$matching)
diff --git a/qmake/doc/src/snippets/qmake/scopes.pro b/qmake/doc/src/snippets/qmake/scopes.pro
new file mode 100644
index 0000000000..63b9b3aa55
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/scopes.pro
@@ -0,0 +1,42 @@
+#! [syntax]
+<condition> {
+    <command or definition>
+    ...
+}
+#! [syntax]
+
+#! [0]
+win32 {
+    SOURCES += paintwidget_win.cpp
+}
+#! [0]
+
+#! [1]
+!win32 {
+    SOURCES -= paintwidget_win.cpp
+}
+#! [1]
+
+unix {
+    SOURCES += paintwidget_unix.cpp
+}
+
+#! [2]
+macx {
+    CONFIG(debug, debug|release) {
+        HEADERS += debugging.h
+    }
+}
+#! [2]
+
+#! [3]
+macx:CONFIG(debug, debug|release) {
+    HEADERS += debugging.h
+}
+#! [3]
+
+#! [4]
+win32|macx {
+    HEADERS += debugging.h
+}
+#! [4]
diff --git a/qmake/doc/src/snippets/qmake/shared_or_static.pro b/qmake/doc/src/snippets/qmake/shared_or_static.pro
new file mode 100644
index 0000000000..31c25ea44b
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/shared_or_static.pro
@@ -0,0 +1,8 @@
+TEMPLIBS = $$[QT_INSTALL_LIBS] libQtGui.prl
+include($$join(TEMPLIBS, "/"))
+
+contains(QMAKE_PRL_CONFIG, shared) {
+    message(Shared Qt)
+} else {
+    message(Static Qt)
+}
diff --git a/qmake/doc/src/snippets/qmake/spaces.pro b/qmake/doc/src/snippets/qmake/spaces.pro
new file mode 100644
index 0000000000..614d4c553d
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/spaces.pro
@@ -0,0 +1,9 @@
+#! [quoting library paths with spaces]
+win32:LIBS += "C:/mylibs/extra libs/extra.lib"
+unix:LIBS += "-L/home/user/extra libs" -lextra
+#! [quoting library paths with spaces]
+
+#! [quoting include paths with spaces]
+win32:INCLUDEPATH += "C:/mylibs/extra headers"
+unix:INCLUDEPATH += "/home/user/extra headers"
+#! [quoting include paths with spaces]
diff --git a/qmake/doc/src/snippets/qmake/specifications.pro b/qmake/doc/src/snippets/qmake/specifications.pro
new file mode 100644
index 0000000000..f9a0d0a1cb
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/specifications.pro
@@ -0,0 +1,7 @@
+#! [0]
+message($$QMAKESPEC)
+
+linux-g++ {
+    message(Linux)
+}
+#! [0]
diff --git a/qmake/doc/src/snippets/qmake/testfunction.pro b/qmake/doc/src/snippets/qmake/testfunction.pro
new file mode 100644
index 0000000000..785ffed6be
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/testfunction.pro
@@ -0,0 +1,20 @@
+#! [0]
+defineTest(allFiles) {
+    files = $$ARGS
+
+    for(file, files) {
+        !exists($$file) {
+            return(false)
+        }
+    }
+    return(true)
+}
+#! [0]
+
+files = delegate.h model.h view.h
+
+allFiles($$files) {
+    message(All files are present: $$files)
+} else {
+    message(Not all files are present: $$files)
+}
diff --git a/qmake/doc/src/snippets/qmake/variables.pro b/qmake/doc/src/snippets/qmake/variables.pro
new file mode 100644
index 0000000000..c1439ba68b
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/variables.pro
@@ -0,0 +1,7 @@
+#! [0]
+HEADERS = mainwindow.h paintwidget.h
+#! [0] #! [1]
+SOURCES = main.cpp mainwindow.cpp \
+          paintwidget.cpp
+CONFIG += console
+#! [1]
diff --git a/qmake/doc/src/snippets/qmake/view.h b/qmake/doc/src/snippets/qmake/view.h
new file mode 100644
index 0000000000..92c7eb6a48
--- /dev/null
+++ b/qmake/doc/src/snippets/qmake/view.h
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
diff --git a/qmake/qmake-docs.pro b/qmake/qmake-docs.pro
new file mode 100644
index 0000000000..3123f7c5d8
--- /dev/null
+++ b/qmake/qmake-docs.pro
@@ -0,0 +1,2 @@
+TEMPLATE = aux
+QMAKE_DOCS = $$PWD/doc/qmake.qdocconf