Doc: edit the qmake manual

Restructure to make it easier to find information.
Fix Qdoc commands and linking. Edit for grammar
and style.
Remove descriptions of obsolete variables.

Task-number: QTBUG-29167
Change-Id: Id44e7f36bbf21fb98df034210f49025b320be361
Reviewed-by: Sze Howe Koh <szehowe.koh@gmail.com>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>

3 files changed, 1379 insertions, 1854 deletions

diff --git a/doc/src/development/qmake-manual.qdoc b/doc/src/development/qmake-manual.qdoc
index eee96da0..7926f5b0 100644
--- a/doc/src/development/qmake-manual.qdoc
+++ b/doc/src/development/qmake-manual.qdoc
@@ -29,69 +29,45 @@
     \page qmake-manual.html
     \title qmake Manual
     \startpage {index.html}{Qt Reference Documentation}
-    \nextpage qmake Tutorial
+    \nextpage Overview
 
     \ingroup qttools
     \keyword qmake
 
-    \l{qmake}{\c qmake} is a tool that helps simplify the build process for
-    development projects across different platforms.  \l{qmake}{\c qmake}
-    automates the generation of Makefiles so that only a few lines of
-    information are needed to create each Makefile. \l{qmake}{\c qmake} can be
-    used for any software project, whether it is written in Qt or not.
+    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.
 
-    \l{qmake}{\c qmake} generates a Makefile based on the information in a
+    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.
-    \l{qmake}{\c qmake} contains additional features to support development
+
+    qmake contains additional features to support development
     with Qt, automatically including build rules for \l{moc.html}{moc}
     and \l{uic.html}{uic}.
-    \l{qmake}{\c qmake} can also generate projects for Microsoft Visual studio
-    without requiring the developer to change the project file.
-
-    \section1 Getting Started
 
-    The \l{qmake Tutorial} and guide to \l{qmake Common Projects} provide overviews
-    that aim to help new users get started with \l{qmake}{\c qmake}.
-
-    \list
-    \li \l{qmake Tutorial}
-      \tableofcontents{1 qmake Tutorial}
-    \endlist
-
-    \list
-    \li \l{qmake Common Projects}
-      \tableofcontents{1 qmake Common Projects}
-    \endlist
-
-    The guide to \l{Third Party Libraries} shows you how to use simple third party libraries
-    in your Qt project using qmake.
-    \list
-    \li \l{Third Party Libraries}
-      \tableofcontents{1 Third Party Libraries}
-    \endlist
+    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{Using qmake}
-      \tableofcontents{1 Using qmake}
-    \li \l{qmake Project Files}
-      \tableofcontents{1 qmake Project Files}
-    \li \l{Running qmake}
-      \tableofcontents{1 Running qmake}
-    \li \l{qmake Platform Notes}
-      \tableofcontents{1 qmake Platform Notes}
-    \li \l{qmake Advanced Usage}
-      \tableofcontents{1 qmake Advanced Usage}
-    \li \l{Using Precompiled Headers}
-      \tableofcontents{1 Using Precompiled Headers}
-    \li \l{Configuring qmake's Environment}
-      \tableofcontents{1 Configuring qmake's Environment}
-    \li \l{qmake Reference}
+        \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{qmake Variable Reference}
+            \li \l{Variables}
             \li \l{Replace Functions}
             \list
                 \li \l{Built-in Replace Functions}
@@ -106,30 +82,25 @@
 */
 
 /*!
-    \page qmake-using.html
-    \title Using qmake
+    \page qmake-overview.html
+    \title Overview
     \contentspage {qmake Manual}{Contents}
     \previouspage qmake Manual
-    \nextpage qmake Project Files
+    \nextpage Getting Started
 
-    \l{qmake Manual#qmake}{\c qmake} provides a project-oriented system for
-    managing the buildprocess for applications, libraries, and other components.
-    This approach gives developers control over the source files used, and
+    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. \l{qmake Manual#qmake}{\c qmake} expands
+    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.
 
-    In this document, we provide a basic introduction to project files,
-    describe some of the main features of \l{qmake Manual#qmake}{\c qmake},
-    and show how to use \l{qmake Manual#qmake}{\c qmake} on the command line.
-
     \section1 Describing a Project
 
-    Projects are described by the contents of project (\c .pro) files.
-    The information within these is used by \l{qmake Manual#qmake}{\c qmake}
-    to generate a Makefile containing all the commands that are needed to
-    build each 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
@@ -139,114 +110,133 @@
     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.
+    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.
 
-    Complete examples of project files can be found in the
-    \l{qmake Tutorial}.
-    An introduction to project files can be found in the
-    \l{qmake Project Files} chapter, and a more detailed description is
-    available in the \l{qmake Reference}.
+    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 \l{qmake Manual#qmake}{\c qmake}
-    in the top level directory of your project. By default,
-    \l{qmake Manual#qmake}{\c qmake} generates a Makefile that you then use
-    to build the project, and you can then run your platform's \c make tool
-    to build the 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
 
-    \l{qmake Manual#qmake}{\c qmake} can also be used to generate project files.
-    A full description of \c{qmake}'s command line options can be found in the
-    \l{Running qmake} chapter of this manual.
+    The guide to \l{Third Party Libraries} shows you how to use simple third
+    party libraries in your Qt project.
 
-    \section1 Using Precompiled Headers
+    \section1 Precompiling Headers
 
     In large projects, it is possible to take advantage of precompiled
-    header files to speed up the build process. This feature is described
-    in detail in the \l{Using Precompiled Headers} chapter.
+    header files to speed up the build process. For more information, see
+    \l{Using Precompiled Headers}.
 */
 
 /*!
     \page qmake-project-files.html
-    \title qmake Project Files
+    \title Creating Project Files
     \contentspage {qmake Manual}{Contents}
-    \previouspage Using qmake
-    \nextpage Running qmake
+    \previouspage Getting Started
+    \nextpage Building Common Project Types
 
-    Project files contain all the information required by
-    \l{qmake Manual#qmake}{\c qmake} to build your application, library,
-    or plugin. The resources used by your project are generally specified
-    using a series of declarations, but support for simple programming
-    constructs allow you to describe different build processes for different
+    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 \l{qmake Manual#qmake}{\c qmake} can be
+    The project file format used by qmake can be
     used to support both simple and fairly complex build systems.
-    Simple project files will use a straightforward declarative style,
+    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 the control flow
+    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 \l{qmake Manual#qmake}{\c qmake}
+    simplest projects, these variables inform qmake
     about the configuration options to use, or supply filenames and paths to
     use in the build process.
 
-    \l{qmake Manual#qmake}{\c qmake} looks for certain variables in each
+    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 list of values in the
-    \c HEADERS and \c SOURCES variables are used to tell
-    \l{qmake Manual#qmake}{\c qmake} about header and source files in the
-    same directory as the project file.
+    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 lines show how lists of values are assigned to variables:
+    The following snippet illustrates how lists of values are assigned to
+    variables:
 
     \snippet doc/src/snippets/qmake/variables.pro 0
 
-    Note that the first assignment only includes values that are specified on
-    the same line as the \c SOURCES variable. The second assignment splits
-    the items across lines by using the \c \\ character.
-
     The list of values in a variable is extended in the following way:
 
     \snippet doc/src/snippets/qmake/variables.pro 1
 
-    The \c CONFIG variable is another special variable that
-    \l{qmake Manual#qmake}{\c qmake} uses when generating a Makefile.
-    It is discussed in the section on
-    \l{#GeneralConfiguration}{general configuration} later in this chapter.
-    In the above line, \c console is added to the list of existing values
+    \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 the variables that \l{qmake Manual#qmake}{\c qmake}
-    recognizes, and describes what they should contain.
+    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 CONFIG    \li General project configuration options.
-    \row \li DESTDIR   \li The directory in which the executable or binary file will
+    \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 FORMS     \li A list of UI files to be processed by \c uic.
-    \row \li HEADERS   \li A list of filenames of header (.h) files used when
+    \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 QT        \li Qt-specific configuration options.
-    \row \li RESOURCES \li A list of resource (.rc) files to be included in the
+    \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 SOURCES   \li A list of source code files to be used when building
+    \row \li \l{SOURCES}  \li A list of source code files to be used when building
                       the project.
-    \row \li TEMPLATE  \li The template to use for the project. This determines
+    \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
@@ -257,22 +247,20 @@
     \snippet doc/src/snippets/qmake/dereferencing.pro 0
 
     The \c $$ operator is used extensively with built-in functions that operate
-    on strings and lists of values. These are described in the chapter on
-    \l{qmake Advanced Usage}.
+    on strings and lists of values. For more information, see
+    \l{qmake Language}.
 
     \section3 Whitespace
 
-    Normally, variables are used to contain whitespace-separated lists
-    of values. However, it is sometimes necessary to specify values containing
-    spaces. These must be quoted by using double quotes:
+    Usually, whitespace separates values in variable assignments. To specify
+    values that contain spaces, you must enclose the values in double quotes:
 
     \snippet doc/src/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{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} and
-    \l{qmake Variable Reference#LIBS}{LIBS} variables for the Windows platform:
+    \l{INCLUDEPATH} and \l{LIBS} variables for the Windows platform:
 
     \snippet doc/src/snippets/qmake/spaces.pro quoting include paths with spaces
 
@@ -284,16 +272,14 @@
     \snippet doc/src/snippets/qmake/comments.pro 0
 
     To include the \c # character in variable assignments, it is necessary
-    to use the contents of the built-in \c LITERAL_HASH variable. See the
-    \l{qmake Variable Reference#LITERAL_HASH}{variable reference} for more
-    information.
+    to use the contents of the built-in \l{LITERAL_HASH} variable.
 
     \section2 Built-in Functions and Control Flow
 
-    \l{qmake Manual#qmake}{\c qmake} provides a number of built-in functions
-    to allow the contents of variables to be processed.
-    The most commonly used function in simple
-    project files is the \c include function which takes a filename as an
+    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
@@ -302,114 +288,77 @@
     \snippet doc/src/snippets/qmake/include.pro 0
 
     Support for conditional structures is made available via
-    \l{qmake Advanced Usage#scopes}{scopes} that behave like \c if
-    statements in programming languages:
+    \l{Scopes}{scopes} that behave like \c if statements in programming languages:
 
     \snippet doc/src/snippets/qmake/scopes.pro 0
 
     The assignments inside the braces are only made if the condition is
-    true. In this case, the special \c win32 variable must be set; this
-    happens automatically on Windows, but this can also be specified on
-    other platforms by running \l{qmake Manual#qmake}{\c qmake}
-    with the \c{-win32} command line
-    option (see \l{Running qmake} for more information). The opening
-    brace must stand on the same line as the condition.
-
-    Simple loops are constructed by iterating over lists of values using
-    the built-in \c for function. The following code adds directories
-    to the \l{qmake Variable Reference#SUBDIRS}{SUBDIRS} variable, but
-    only if they exist:
-
-    \snippet doc/src/snippets/qmake/functions.pro 0
+    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 \c find, \c unique, and
-    \c count. These functions, and many others are provided to manipulate
-    strings and paths, support user input, and call external tools. A list
-    of the functions available can be found in the
-    \l{qmake Advanced Usage} chapter of this manual.
+    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 \c TEMPLATE variable is used to define the type of project that will
+    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,
-    \l{qmake Manual#qmake}{\c qmake} assumes that an application should be
+    qmake assumes that an application should be
     built, and will generate an appropriate Makefile (or equivalent file)
     for the purpose.
 
-    The types of project available are listed in the following table with
-    information about the files that \l{qmake Manual#qmake}{\c qmake}
-    will generate for each of them:
+    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 Description of \l{qmake Manual#qmake}{\c qmake} output
-    \row    \li app (default) \li Creates a Makefile to build an application.
-    \row    \li lib           \li Creates a Makefile to build a library.
-    \row    \li subdirs       \li Creates a Makefile containing rules for the
-    subdirectories specified using the \l{qmake Variable Reference#SUBDIRS}{SUBDIRS}
+    \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 Creates a Visual Studio Project file to build
+    \row    \li vcapp         \li Visual Studio Project file to build
                              an application.
-    \row    \li vclib         \li Creates a Visual Studio Project file to build a library.
-    \row    \li vcsubdirs     \li Creates a Visual Studio Solution file to build projects in sub-directories.
+    \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 the \l{qmake Tutorial} for advice on writing project files for
+    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, \l{qmake Manual#qmake}{\c qmake}
+    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 \l{qmake Variable Reference#SUBDIRS}{SUBDIRS} variable is used to
+    The \c SUBDIRS variable is used to
     contain a list of all the subdirectories to be processed.
 
     \target GeneralConfiguration
     \section1 General Configuration
 
-    The \l{qmake Variable Reference#CONFIG}{CONFIG variable} specifies the
-    options and features that the compiler should use and the libraries that
-    should be linked against. Anything can be added to the \c CONFIG variable,
-    but the options covered below are recognized by
-    \l{qmake Manual#qmake}{\c qmake} internally.
-
-    The following options control the compiler flags that are used to build the
-    project:
-
-    \table
-    \header \li Option   \li Description
-    \row    \li release  \li The project is to be built in release mode.
-            This is ignored if \c debug is also specified.
-    \row    \li debug    \li The project is to be built in debug mode.
-    \row    \li debug_and_release \li The project is built in \e both debug and
-            release modes.
-    \row    \li debug_and_release_target \li The project is built in \e both debug
-    and release modes. TARGET is built into \e both the 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 warn_on  \li The compiler should output as many warnings as possible.
-            This is ignored if \c warn_off is specified.
-    \row    \li warn_off \li The compiler should output as few warnings as possible.
-    \row    \li copy_dir_files \li Enables the install rule to also copy directories, not just files.
-    \endtable
+    The \l{CONFIG} variable specifies the options and features that the project
+    should be configured with.
 
-    The \c debug_and_release option is special in that it enables \e both debug and
-    release versions of a project to be built. In such a case, the Makefile that
-    \l{qmake Manual#qmake}{\c qmake} generates includes a rule that builds both versions,
-    and this can be invoked in the following way:
+    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 doc/src/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, and installation targets will be
-    created for both debug and release builds.
+    the default when building the project.
 
-    Note that each of the options specified in the \c CONFIG variable can also be
+    \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.
@@ -420,50 +369,49 @@
     \snippet doc/src/snippets/qmake/configscopes.pro 5
 
     This enables different configurations to be defined for \c release and
-    \c debug builds, and is described in more detail in the
-    \l{qmake Advanced Usage#Scopes}{Scopes} section of the
-    \l{qmake Advanced Usage}{Advanced Usage} chapter of this manual.
+    \c debug builds. For more information, see \l{Scopes}{Using Scopes}.
 
-    The following options define the type of project to be built. Note that some
-    of these options only take effect when used on the relevant platform. On other
-    platforms, they have no effect.
+    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
 
-    When using \l{qmake Variable Reference#TEMPLATE}{application or library project
-    templates}, more specialized configuration options can be used to fine tune the
-    build process. These are explained in details in the
-    \l{qmake-common-projects.html}{Common Projects} chapter of this manual.
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 1
 
-    The value \c qt is added by default, but you can remove it to use qmake for
-    a non-Qt project.
-
-    \note You must use "+=", not "=", or \l{qmake Manual#qmake}{\c qmake}
+    \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 \c CONFIG variable contains the \c qt value, qmake's support for Qt
+    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 \c QT
-    variable which can be used to declare the required extension modules.
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 2
 
-    Note that \c QT includes the \c core and \c gui modules by default, so the
+    \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:
@@ -477,68 +425,45 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 4
 
-    The table below shows the options that can be used with the \c QT variable
-    and the features that are associated with each of them:
-
-    \table
-    \header \li Option                     \li Features
-    \row    \li core (included by default) \li QtCore module
-    \row    \li gui  (included by default) \li QtGui module
-    \row    \li network                    \li QtNetwork module
-    \row    \li opengl                     \li QtOpenGL module
-    \row    \li sql                        \li QtSql module
-    \row    \li svg                        \li QtSvg module
-    \row    \li webkitwidgets              \li QtWebkit module
-    \row    \li widgets                    \li QtWidgets module
-    \row    \li xml                        \li QtXml module
-    \row    \li xmlpatterns                \li QtXmlPatterns module
-    \endtable
-
-    Note that adding the \c opengl option to the \c QT variable automatically
-    causes the equivalent option to be added to the \c CONFIG variable.
-    Therefore, for Qt applications, it is not necessary to add the \c opengl
-    option to both \c CONFIG and \c{QT}.
+    For a list of Qt modules that you can add to the \c QT variable, see
+    \l{Variables#QT}{QT}.
 
     \section1 Configuration Features
 
-    \l{qmake Manual#qmake}{\c qmake} can be set up with extra configuration
+    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, \l{qmake Manual#qmake}{\c qmake} can configure the build
+    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_2fpkgconfig}{pkg-config},
+    \l{http://www.freedesktop.org/wiki/Software/pkg-config}{pkg-config},
     such as the D-Bus and ogg libraries, with the following lines:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 5
 
-    More information about features can be found in the
-    \l{qmake Advanced Usage#Adding New Configuration Features}
-    {Adding New Configuration Features} section of the \l{qmake Advanced Usage}
-    chapter.
+    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 \l{qmake Manual#qmake}{\c qmake} searches for libraries
+    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{qmake Variable Reference#LIBS}{LIBS} variable. The paths to the libraries
-    themselves can be given, or the familiar Unix-style notation for specifying
-    libraries and paths can be used if preferred.
+    \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 doc/src/snippets/code/doc_src_qmake-manual.pro 6
 
     The paths containing header files can also be specified in a similar way
-    using the \l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} variable.
+    using the \l{INCLUDEPATH} variable.
 
-    For example, it is possible to add several paths to be searched for header
-    files:
+    For example, to add several paths to be searched for header files:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 7
 */
@@ -547,109 +472,82 @@
     \page qmake-running.html
     \title Running qmake
     \contentspage {qmake Manual}{Contents}
-    \previouspage qmake Project Files
-    \nextpage qmake Platform Notes
+    \previouspage Building Common Project Types
+    \nextpage Platform Notes
 
-    The behavior of \l{qmake Manual#qmake}{\c qmake} can be customized when it
+    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.
 
-    \tableofcontents
-
-    \target Commands
-    \section1 Command-Line Options
-
-    \section2 Syntax
+    \section1 Command Syntax
 
-    The syntax used to run \l{qmake Manual#qmake}{\c qmake} takes the
-    following simple form:
+    The syntax used to run qmake takes the following simple form:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 8
 
-    \l{qmake Manual#qmake}{\c qmake} supports two different modes of operation:
-    In the default mode,\l{qmake Manual#qmake}{\c qmake} will use the
-    description in a project file to generate a Makefile, but it is also
-    possible to use \l{qmake Manual#qmake}{\c qmake} to generate project files.
+    \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
-        \l{qmake Manual#qmake}{\c qmake} output will be a Makefile.
+        qmake output will be a Makefile.
     \li \c -project \BR
-        \l{qmake Manual#qmake}{\c qmake} output will be a project file. \BR
-    \b{Note:} It is likely that the created file will need to be edited; for example,
+        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
 
-    The following \c options are used to specify both general and mode-specific
+    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; options that influence the
+    \l{#MakefileMode}{Makefile Mode Options} section, whereas options that influence the
     creation of project files are described in the
-    \l{#ProjectMode}{Project File Options} section.
+    \l{#ProjectMode}{Project Mode Options} section.
+
+    \section1 Files
 
     The \c files argument represents a list of one or more project files, separated
     by spaces.
 
-    \section2 Options
+    \section1 General Options
 
     A wide range of options can be specified on the command line to
-    \l{qmake Manual#qmake}{\c qmake} in order to customize the build process,
+    qmake in order to customize the build process,
     and to override default settings for your platform. The following basic
-    options provide usage information, specify where
-    \l{qmake Manual#qmake}{\c qmake} writes the output file, and control the
+    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
-        \l{qmake Manual#qmake}{\c qmake} will go over these features and give some
-        useful help.
-    \li \c -o file \BR
-        \l{qmake Manual#qmake}{\c qmake} output will be directed to \e file. If
-        this option is not specified, \l{qmake Manual#qmake}{\c qmake} will try
+        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
-        \l{qmake Manual#qmake}{\c qmake} will output debugging information.
-    \endlist
-
-    For projects that need to be built differently on each target platform,
-    with many subdirectories, you can run \l{qmake Manual#qmake}{\c qmake} with
-    each of the following options to set the corresponding platform-specific
-    variable in each project file:
-
-    \list
-    \li \c -unix \BR
-        \l{qmake Manual#qmake}{\c qmake} will run in unix mode. In this mode,
-        Unix file naming and path conventions will be used, additionally
-        testing for \c unix (as a scope) will succeed. This is the default
-        mode on all Unices.
-    \li \c -macx \BR
-        \l{qmake Manual#qmake}{\c qmake} will run in Mac OS X mode. In this
-        mode, Unix file naming and path conventions will be used, additionally
-        testing for \c macx (as a scope) will succeed. This is the default mode
-        on Mac OS X.
-    \li \c -win32 \BR
-        \l{qmake Manual#qmake}{\c qmake} will run in win32 mode. In this mode,
-        Windows file naming and path conventions will be used, additionally
-        testing for \c win32 (as a scope) will succeed. This is the default
-        mode on Windows.
+        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 \c TEMPLATE
-    variable in the project file. We can override or modify this by using the
+    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
-        \l{qmake Manual#qmake}{\c qmake} will override any set \c TEMPLATE
-        variables with tmpl, but only \e after the .pro file has been processed.
-    \li \c -tp prefix \BR
-        \l{qmake Manual#qmake}{\c qmake} will add the prefix to the \c TEMPLATE
-        variable.
+    \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
@@ -657,57 +555,54 @@
 
     \list
     \li \c -Wall \BR
-        \l{qmake Manual#qmake}{\c qmake} will report all known warnings.
+        qmake will report all known warnings.
     \li \c -Wnone \BR
-        No warning information will be generated by \
-        l{qmake Manual#qmake}{\c qmake}.
+        No warning information will be generated by qmake.
     \li \c -Wparser \BR
-        \l{qmake Manual#qmake}{\c qmake} will only generate parser warnings.
+        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
-        \l{qmake Manual#qmake}{\c qmake} will warn of common pitfalls and
+        qmake will warn of common pitfalls and
         potential problems in your project file. For example,
-        \l{qmake Manual#qmake}{\c qmake} will report whether a file is placed
-        into a list of files multiple times, or if a file cannot be found.
+        qmake will report multiple occurrences of files in lists and missing
+        files.
     \endlist
 
     \target MakefileMode
-    \section2 Makefile Mode Options
+    \section1 Makefile Mode Options
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 9
 
-    In Makefile mode, \l{qmake Manual#qmake}{\c qmake} will generate a Makefile
+    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
-        \l{qmake Manual#qmake}{\c qmake} will process assignments given on the
+        qmake will process assignments given on the
         command line after the specified files.
     \li \c -nocache \BR
-        \l{qmake Manual#qmake}{\c qmake} will ignore the .qmake.cache file.
+        qmake will ignore the \c{.qmake.cache} file.
     \li \c -nodepend \BR
-        \l{qmake Manual#qmake}{\c qmake} will not generate any dependency
+        qmake will not generate any dependency
         information.
-    \li \c -cache file \BR
-        \l{qmake Manual#qmake}{\c qmake} will use \e file as the cache file,
+    \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
-        \l{qmake Manual#qmake}{\c qmake} will use \e spec as a path to
-        platform and compiler information, and the value of \c QMAKESPEC will
-        be ignored.
+    \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 \l{qmake Manual#qmake}{\c qmake} assignments on the
-    command line; they will be processed before all of the files specified.
-    For example:
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 10
 
-    This will generate a Makefile, from test.pro with Unix pathnames.  However
-    many of the specified options aren't necessary as they are the default.
-    Therefore, the line can be simplified on Unix to:
+    However, some of the specified options can be omitted as they are default
+    values:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 11
 
@@ -717,28 +612,27 @@
     option will be postponed until after the specified files are parsed.
 
     \target ProjectMode
-    \section2 Project Mode Options
+    \section1 Project Mode Options
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 12
 
-    In project mode, \l{qmake Manual#qmake}{\c qmake} will generate a project
+    In project mode, qmake will generate a project
     file. Additionally, you may supply the following options in this mode:
 
     \list
     \li \c -r \BR
-       \l{qmake Manual#qmake}{\c qmake} will look through supplied directories
-       recursively
+       qmake will look through supplied directories recursively.
     \li \c -nopwd \BR
-       \l{qmake Manual#qmake}{\c qmake} will not look in your current working
-       directory for source code and only use the specified \c files
+       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 \c DEPENDPATH
+    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 \c FORMS, and C++ files are added to \c SOURCES.
+    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.
@@ -746,19 +640,16 @@
 
 /*!
     \page qmake-platform-notes.html
-    \title qmake Platform Notes
+    \title Platform Notes
     \contentspage {qmake Manual}{Contents}
     \previouspage Running qmake
-    \nextpage qmake Advanced Usage
+    \nextpage qmake Language
 
-    Many cross-platform projects can be handled by the \c{qmake}'s basic
-    configuration features. On some platforms, it is sometimes useful, or even
+    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.
-    \l{qmake Manual#qmake}{\c qmake} knows about many of these features, and
-    these can be accessed via specific variables that only have an effect on
-    the platforms where they are relevant.
-
-    \tableofcontents
+    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
 
@@ -767,37 +658,33 @@
 
     \section2 Source and Binary Packages
 
-    The version of \l{qmake Manual#qmake}{\c qmake} supplied in source 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
-    \l{qmake Manual#qmake}{\c qmake} with the \c -spec option (see
-    \l{Running qmake} for more information). This makes it possible, for
-    example, to use \l{qmake Manual#qmake}{\c qmake} from a binary package to
-    create a Makefile in a project directory with the following command line
-    invocation:
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 13
 
     \section2 Using Frameworks
 
-    \l{qmake Manual#qmake}{\c qmake} is able to automatically generate build
+    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 Variable Reference#QMAKE_LFLAGS}{QMAKE_LFLAGS} variable, as shown
-    in the following example:
+    \l{QMAKE_LFLAGS} variable, as shown in the following example:
 
     \snippet doc/src/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{qmake Variable Reference#LIBS}{LIBS}
-    variable:
+    the name of the framework to the \l{LIBS} variable:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 15
 
@@ -807,79 +694,72 @@
     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{qmake Variable Reference#TEMPLATE}{\c lib template} and add the
-    \c lib_bundle option to the
-    \l{qmake Variable Reference#CONFIG}{CONFIG} variable:
+    \l{TEMPLATE}{\c lib template} and add the \c lib_bundle option to the
+    \l{CONFIG} variable:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 16
 
     The data associated with the library is specified using the
-    \l{qmake Variable Reference#QMAKE_BUNDLE_DATA}{QMAKE_BUNDLE_DATA}
+    \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 doc/src/snippets/code/doc_src_qmake-manual.pro 17
 
-    Here, the \c FRAMEWORK_HEADERS variable is a user-defined variable that
-    is used to define the headers required to use a particular framework.
-    Appending it to the \c QMAKE_BUNDLE_DATA variable ensures that the
-    information about these headers are added to the collection of
+    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's name and version are specified by
-    \l{qmake Variable Reference#QMAKE_FRAMEWORK_BUNDLE_NAME}
-    {QMAKE_FRAMEWORK_BUNDLE_NAME}
-    and \l{qmake Variable Reference#QMAKE_FRAMEWORK_VERSION}
-    {QMAKE_FRAMEWORK_VERSION} variables. By default, the values used for
-    these are obtained from the \l{qmake Variable Reference#TARGET}{TARGET}
-    and \l{qmake Variable Reference#VERSION}{VERSION} variables.
+    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 \c{qmake}'s support for Xcode
+    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 \l{qmake Manual#qmake}{\c qmake} to generate an Xcode project
-    from an existing \l{qmake Manual#qmake}{\c qmake} project files. For
-    example:
+    by running qmake to generate an Xcode project from an existing qmake project
+    file. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 19
 
-    Note that, if a project is later moved on the disk,
-    \l{qmake Manual#qmake}{\c qmake} must be run again to process the project
-    file and create a new Xcode project file.
+    \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 On supporting two build targets simultaneously
+    \section2 Supporting Two Build Targets Simultaneously
 
-    Implementing this is currently not feasible, because the XCode
+    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
+    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 "Frameworks & Libraries" phase in the
-    XCode build system.
+    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 "Active Build Configuration" is stored
-    in a .pbxuser file, which is generated by xcode on first load, not
+    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.
+    applications developed using Visual Studio 2005, or later.
 
     \section2 Creating Visual Studio Project Files
 
@@ -889,12 +769,11 @@
     and do not need to worry about how project dependencies are managed.
 
     However, some developers may need to import an existing
-    \l{qmake Manual#qmake}{\c qmake} project into Visual Studio.
-    \l{qmake Manual#qmake}{\c qmake} is able to take a project file and create
+    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
-    \l{qmake Manual#qmake}{\c qmake}
-    \l{qmake Variable Reference#TEMPLATE}{project template} to either \c vcapp
+    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:
@@ -907,27 +786,26 @@
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 21
 
     Each time you update the project file, you need to run
-    \l{qmake Manual#qmake}{\c qmake} to generate an updated Visual Studio
+    qmake to generate an updated Visual Studio
     project.
 
-    \note If you are using the Visual Studio Add-in, you can import \c .pro
-    files via the \gui{Qt->Import from .pro file} menu item.
+    \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 2005 Manifest Files
+    \section2 Visual Studio Manifest Files
 
-    When deploying Qt applications built using Visual Studio 2005, it is
-    necessary to ensure that the manifest file, created when the application
-    was linked, is handled correctly. This is handled automatically for
+    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{qmake Variable Reference#CONFIG}
-    {CONFIG} variable:
+    the following assignment to the \l{CONFIG} variable:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 22
 
     Also, the manifest embedding for DLLs can be removed with the following
-    assignment to the \l{qmake Variable Reference#CONFIG}{CONFIG} variable:
+    assignment to the \c CONFIG variable:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 23
 
@@ -938,19 +816,18 @@
 
 /*!
     \page qmake-reference.html
-    \title qmake Reference
+    \title Reference
     \contentspage {qmake Manual}{Contents}
-    \previouspage Configuring qmake's Environment
-    \nextpage qmake Variable Reference
+    \previouspage Configuring qmake
+    \nextpage Variables
 
-    This reference is a detailed index of all the variables and function that
-    are available for use in \l{qmake Manual#qmake}{\c qmake} project files.
+    The reference sections describe in detail the variables and functions that
+    are available for use in qmake project files.
 
     \section1 Variable Reference
 
-    The \l{qmake Variable Reference} describes the variables that are
-    recognized by \l{qmake Manual#qmake}{\c qmake}when configuring the build
-    process for projects.
+    \l{Variables} describes the variables that are recognized by qmake when
+    configuring the build process for projects.
 
     \section1 Function Reference
 
@@ -966,62 +843,18 @@
         \li \l{Replace Functions}
         \li \l{Test Functions}
     \endlist
-
-    \target FrequentlyUsedVariables
-    \section1 Frequently Used Variables
-
-    The following variables are frequently used in project files to describe
-    common aspects of the build process. These are fully described in the
-    \l{qmake-variable-reference.html}{Variable Reference}.
-
-    \list
-    \li \l{qmake Variable Reference#CONFIG}{CONFIG}
-    \li \l{qmake Variable Reference#DEF_FILE}{DEF_FILE}
-    \li \l{qmake Variable Reference#DEFINES}{DEFINES}
-    \li \l{qmake Variable Reference#DESTDIR}{DESTDIR}
-    \li \l{qmake Variable Reference#DISTFILES}{DISTFILES}
-    \li \l{qmake Variable Reference#DLLDESTDIR}{DLLDESTDIR}
-    \li \l{qmake Variable Reference#FORMS}{FORMS}
-    \li \l{qmake Variable Reference#GUID}{GUID}
-    \li \l{qmake Variable Reference#HEADERS}{HEADERS}
-    \li \l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH}
-    \li \l{qmake Variable Reference#LEXSOURCES}{LEXSOURCES}
-    \li \l{qmake Variable Reference#LIBS}{LIBS}
-    \li \l{qmake Variable Reference#MOC_DIR}{MOC_DIR}
-    \li \l{qmake Variable Reference#OBJECTS_DIR}{OBJECTS_DIR}
-    \li \l{qmake Variable Reference#QT}{QT}
-    \li \l{qmake Variable Reference#RCC_DIR}{RCC_DIR}
-    \li \l{qmake Variable Reference#REQUIRES}{REQUIRES}
-    \li \l{qmake Variable Reference#RESOURCES}{RESOURCES}
-    \li \l{qmake Variable Reference#SOURCES}{SOURCES}
-    \li \l{qmake Variable Reference#SUBDIRS}{SUBDIRS}
-    \li \l{qmake Variable Reference#TARGET}{TARGET}
-    \li \l{qmake Variable Reference#TEMPLATE}{TEMPLATE}
-    \li \l{qmake Variable Reference#TRANSLATIONS}{TRANSLATIONS}
-    \li \l{qmake Variable Reference#UI_DIR}{UI_DIR}
-    \li \l{qmake Variable Reference#UI_HEADERS_DIR}{UI_HEADERS_DIR}
-    \li \l{qmake Variable Reference#UI_SOURCES_DIR}{UI_SOURCES_DIR}
-    \li \l{qmake Variable Reference#VERSION}{VERSION}
-    \li \l{qmake Variable Reference#YACCSOURCES}{YACCSOURCES}
-    \endlist
-
-    \section1 Environment Variables and Configuration
-
-    The \l{Configuring qmake's Environment} chapter of this manual
-    describes the environment variables that \l{qmake Manual#qmake}{\c qmake}
-    uses when configuring the build process.
 */
 
 /*!
     \page qmake-variable-reference.html
-    \title qmake Variable Reference
+    \title Variables
     \contentspage {qmake Manual}{Contents}
-    \previouspage qmake Reference
+    \previouspage Reference
     \nextpage Replace Functions
 
-    \c{qmake}'s fundamental behavior is influenced by variable declarations that
+    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
+    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.
 
@@ -1034,29 +867,33 @@
     \target CONFIG
     \section1 CONFIG
 
-    The \c CONFIG variable specifies project configuration and
-    compiler options.  The values will be recognized internally by
-    \l{qmake Manual#qmake}{\c qmake} and have special meaning.  They are as follows.
+    Specifies project configuration and compiler options. The values are
+    recognized internally by qmake and have special meaning.
 
-    These \c CONFIG values control compilation flags:
+    The following \c CONFIG values control compilation flags:
 
-    \table 95%
+    \table
     \header \li Option   \li Description
     \row    \li release  \li The project is to be built in release mode.
-            This is ignored if \c debug is also specified.
+            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 built in \e both debug and
-            release modes. This can have some unexpected side effects (see
-            below for more information).
+    \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.
-            This is ignored if \c warn_off is specified.
+            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.
@@ -1070,59 +907,50 @@
             default is used.
     \row    \li thread \li Thread support is enabled. This is enabled when CONFIG
             includes \c qt, which is the default.
-    \omit
-    \row    \li qt_debug \li Specifies that the project should be built against
-            debug versions of the Qt libraries specified using the
-            \l{#QT}{QT} variable.
-    \row    \li qt_release \li Specifies that the project should be built against
-            release versions of the Qt libraries specified using the
-            \l{#QT}{QT} variable.
-    \endomit
     \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
-    \l{qmake Manual#qmake}{\c qmake} generates includes a rule that builds both
+    qmake generates includes a rule that builds both
     versions, and this can be invoked in the following way:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 24
 
-    When linking a library, \l{qmake Manual#qmake}{\c qmake} relies on the
+    When linking a library, qmake relies on the
     underlying platform to know what other libraries this library links
-    against. However, if linking statically, \l{qmake Manual#qmake}{\c qmake}
+    against. However, if linking statically, qmake
     will not get this information unless we use the following \c CONFIG
     options:
 
-     \table 95%
+     \table
      \header \li Option   \li Description
      \row    \li create_prl  \li This option enables
-        \l{qmake Manual#qmake}{\c qmake} to track these dependencies. When this
-        option is enabled, \l{qmake Manual#qmake}{\c qmake} will create a file
-        ending in \c .prl which will save meta-information about the library
+        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 is enabled,
-        \l{qmake Manual#qmake}{\c qmake} will process all libraries linked to
-        by the application and find their meta-information(see
+     \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
 
-    Please note that \c create_prl is required when \e {building} a
+    \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}, adding the
-    \c build_all option to the \c CONFIG variable makes this rule the default
-    when building the project, and installation targets will be created for
-    both debug and release builds.
+    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{qmake Advanced Usage#Scopes}{scopes} that test for each value will be
+    \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 mode, and you can test for this to perform
+    will be set for each of these modes, and you can test for this to perform
     build-specific tasks. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 25
@@ -1131,22 +959,22 @@
     \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/library type:
+    The following options define the application or library type:
 
-    \table 95%
+    \table
     \header \li Option \li Description
-    \row \li qt \li The target is a Qt application/library and requires the Qt
+    \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.
+        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{qmake Common Projects#building-a-testcase}{A check target} will be added
+        \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.
@@ -1157,16 +985,15 @@
     \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,3} The target is a shared object/DLL. The proper
+    \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, so, dylib) will be created.
-    \row \li dll \li
-    \row \li dylib \li
+        (.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 \li
+    \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
@@ -1177,7 +1004,7 @@
 
     These options define specific features on Windows only:
 
-    \table 95%
+    \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
@@ -1192,12 +1019,12 @@
          C++, depending on whether this feature is enabled or disabled by default.
     \endtable
 
-    See \l{qmake Platform Notes#Visual Studio 2005 Manifest Files}{qmake Platform Notes}
-    for more information on the options for embedding manifest files.
+    See \l{Platform Notes#Visual Studio Manifest Files}{Platform Notes}
+    for more information about the options for embedding manifest files.
 
-    These options only have an effect on Mac OS X:
+    The following options take an effect only on Mac OS X:
 
-    \table 95%
+    \table
     \header \li Option \li Description
     \row \li ppc \li Builds a PowerPC binary.
     \row \li x86 \li Builds an i386 compatible binary.
@@ -1208,9 +1035,9 @@
     The build process for bundles is also influenced by
     the contents of the \l{#QMAKE_BUNDLE_DATA}{QMAKE_BUNDLE_DATA} variable.
 
-    These options have an effect on Linux/Unix platforms:
+    The following options take an effect only on Linux/Unix platforms:
 
-    \table 95%
+    \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
@@ -1227,7 +1054,7 @@
     \target DEFINES
     \section1 DEFINES
 
-    \l{qmake Manual#qmake}{\c qmake} adds the values of this variable as
+    qmake adds the values of this variable as
     compiler C preprocessor macros (-D option).
 
     For example:
@@ -1237,21 +1064,20 @@
     \target DEF_FILE
     \section1 DEF_FILE
 
-    \e {This is only used on Windows when using the \c app template}.
+    \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
 
-    This variable contains the list of all directories to look in to
-    resolve dependencies. This will be used when crawling through
-    \c included files.
+    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
 
-    \e {This is only used on Windows CE platform.}
+    \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
@@ -1260,13 +1086,11 @@
     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:
+    For example, the following definition uploads all PNG images in \c path to
+    the directory where the build target is deployed:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 28
 
-    This will upload all PNG images in \c path to the same directory your
-    build target will be deployed to.
-
     The default deployment target path for Windows CE is
     \c{%CSIDL_PROGRAM_FILES%\target}, which usually gets expanded to
     \c{\Program Files\target}.
@@ -1285,23 +1109,21 @@
     \target DEPLOYMENT_PLUGIN
     \section1 DEPLOYMENT_PLUGIN
 
-    \e {This is only used on Windows CE platform.}
+    \note This variable is used only on the Windows CE platform.
 
-    This variable specifies the Qt plugins that will be deployed. All plugins
+    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 In Windows CE, No plugins will be deployed automatically.
+    \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:
+    For example, the following definition uploads the jpeg imageformat plugin to
+    the plugins directory on the Windows CE device:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 142
 
-    This will upload the jpeg imageformat plugin to the plugins directory
-    on the Windows CE device.
-
     \target DESTDIR
     \section1 DESTDIR
 
@@ -1311,35 +1133,27 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 30
 
-    \target DESTDIR_TARGET
-    \section1 DESTDIR_TARGET
-
-    This variable is set internally by \l{qmake Manual#qmake}{\c qmake}, which
-    is basically the \c DESTDIR variable with the \c TARGET variable appened at
-    the end. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \target DLLDESTDIR
-    \section1 DLLDESTDIR
-
-    Specifies where to copy the \l{#TARGET}{target} dll.
-
     \target DISTFILES
     \section1 DISTFILES
 
-    This variable contains a list of files to be included in the dist
+    Specifies a list of files to be included in the dist
     target. This feature is supported by UnixMake specs only.
 
     For example:
 
     \snippet doc/src/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
 
-    This variable specifies the UI files (see \l{Qt Designer Manual}) to be
-    processed through \c uic
+    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.
 
@@ -1362,12 +1176,9 @@
 
     Defines the header files for the project.
 
-    \l{qmake Manual#qmake}{\c qmake} will generate dependency information (unless
-    \c -nodepend is specified on the \l{Running qmake#Commands}{command line})
-    for the specified headers. \l{qmake Manual#qmake}{\c qmake} will also
-    automatically detect if \c moc is required by the classes in these headers,
-    and add the appropriate dependencies and files to the project for generating
-    and linking the moc files.
+    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:
 
@@ -1385,7 +1196,7 @@
     \target INCLUDEPATH
     \section1 INCLUDEPATH
 
-    This variable specifies the #include directories which should be
+    Specifies the #include directories which should be
     searched when compiling the project.
 
     For example:
@@ -1393,15 +1204,14 @@
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 35
 
     To specify a path containing spaces, quote the path using the technique
-    mentioned in the \l{qmake Project Files#Whitespace}{qmake Project Files}
-    document.
+    described in \l{Whitespace}.
 
     \snippet doc/src/snippets/qmake/spaces.pro quoting include paths with spaces
 
     \target INSTALLS
     \section1 INSTALLS
 
-    This variable contains a list of resources that will be installed when
+    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.
@@ -1412,31 +1222,26 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 36
 
-    Note that \l{qmake Manual#qmake}{\c qmake} will skip files that are
-    executable. If you need to install executable files, you can unset the
-    files' executable flags.
-
-    Note that \c qmake will skip files that are executable. If you need to install
-    executable files, you can unset the files' executable flags.
+    For more information, see \l{Installing Files}.
 
     \target LEXIMPLS
     \section1 LEXIMPLS
 
-    This variable contains a list of lex implementation files.  The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable contains the names of intermediate lex object
+    Specifies the names of intermediate Lex object
     files.The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} and rarely needs to be modified.
+    qmake and rarely needs to be modified.
 
     \target LEXSOURCES
     \section1 LEXSOURCES
 
-    This variable contains a list of lex source files.  All
+    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.
 
@@ -1447,33 +1252,24 @@
     \target LIBS
     \section1 LIBS
 
-    This variable contains a list of libraries to be linked into the project.
-    You can use the Unix \c -l (library) and -L (library path) flags and qmake
-    will do the correct thing with these libraries on Windows
-    (namely this means passing the full path of the library to
-    the linker). The only limitation to this is the library must exist, for
-    qmake to find which directory a \c -l lib lives in.
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 38
 
     To specify a path containing spaces, quote the path using the technique
-    mentioned in the \l{qmake Project Files#Whitespace}{qmake Project Files}
-    document.
+    described in \l{Whitespace}.
 
     \snippet doc/src/snippets/qmake/spaces.pro quoting library paths with spaces
 
-    \b{Note:} On Windows, specifying libraries with the \c{-l} option,
-    as in the above example, will cause the library with the highest version
-    number to be used; for example, \c{libmath2.lib} could potentially be used
-    instead of \c{libmathlib}. To avoid this ambiguity, we recommend that you
-    explicitly specify the library to be used by including the \c{.lib}
-    file name suffix.
-
     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 \c CONFIG variable:
+    \c no_lflags_merge option to the \l{CONFIG} variable:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 39
 
@@ -1494,24 +1290,22 @@
     \target MAKEFILE
     \section1 MAKEFILE
 
-    This variable specifies the name of the Makefile which
-    \l{qmake Manual#qmake}{\c qmake} should use when outputting the dependency
-    information for building a project.  The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+    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
 
-    This variable contains the name of the Makefile generator to use
+    Specifies the name of the Makefile generator to use
     when generating a Makefile.  The value of this variable is typically
-    handled internally by \l{qmake Manual#qmake}{\c qmake} and rarely needs to
+    handled internally by qmake and rarely needs to
     be modified.
 
     \target MOC_DIR
     \section1 MOC_DIR
 
-    This variable specifies the directory where all intermediate moc
+    Specifies the directory where all intermediate moc
     files should be placed.
 
     For example:
@@ -1521,149 +1315,101 @@
     \target OBJECTS
     \section1 OBJECTS
 
-    This variable is generated from the \link #SOURCES SOURCES
-    \endlink variable.  The extension of each source file will have been
-    replaced by .o (Unix) or .obj (Win32).  The value of this variable is
-    typically handled by \l {qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+    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
 
-    This variable specifies the directory where all intermediate
+    Specifies the directory where all intermediate
     objects should be placed.
 
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 41
 
-    \target OBJMOC
-    \section1 OBJMOC
-
-    This variable is set by \l{qmake Manual#qmake}{\c qmake} if files can be
-    found that contain the Q_OBJECT macro. \c OBJMOC contains the name of all
-    intermediate moc object files. The value of this variable is typically
-    handled by \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf}
-    and rarely needs to be modified.
-
     \target POST_TARGETDEPS
     \section1 POST_TARGETDEPS
 
-    All libraries that the \l{#TARGET}{target} depends on can be
-    listed in this variable. Some backends, such as the generators for Visual
-    Studio and Xcode project files, do not support this. Generally, this is
-    supported
-    internally by these build tools, this is useful for explicitly listing
-    dependant static libraries.
+    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 will go after all builtin (and \link #PRE_TARGETDEPS
+    This list is placed after all builtin (and \link #PRE_TARGETDEPS
     $$PRE_TARGETDEPS \endlink) dependencies.
 
     \target PRE_TARGETDEPS
     \section1 PRE_TARGETDEPS
 
-    All libraries that the \l{#TARGET}{target} depends on can be
-    listed in this variable. Some backends, such as the generators for Visual
-    Studio and Xcode project files, do not support this. Generally this is
-    supported
-    internally by these build tools, this is useful for explicitly listing
-    dependant static libraries.
+    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 will go before all builtin dependencies.
+    This list is placed before all builtin dependencies.
 
     \target PRECOMPILED_HEADER
     \section1 PRECOMPILED_HEADER
 
-    This variable indicates the header file for creating a precompiled
+    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).
 
-    On other platforms, this variable has different meaning, as noted
-    below.
-
-    This variable contains a list of header files that require some
-    sort of pre-compilation step (such as with moc). The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \target PWD
     \section1 PWD
 
-    The \c PWD variable specifies the full path leading to the directory
+    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 IN_PWD is an alias for PWD.
-
-    \note Function calls have no effect on the value of PWD. PWD will refer to
-    the path of the calling file.
+    \note Do not attempt to overwrite the value of this variable.
 
     \target OUT_PWD
     \section1 OUT_PWD
 
-    This variable contains the full path leading to the directory where
-    \l{qmake Manual#qmake}{\c qmake} places the generated Makefile.
+    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
 
-    This variable contains the name of the \l{qmake Manual#qmake}{\c qmake}
-    program itself and is placed in generated Makefiles.  The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable contains the name of the \l{qmake Manual#qmake}{\c qmake}
-    configuration to use when generating Makefiles.  The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} and rarely needs
-    to be modified.
-
-    Use the \c{QMAKESPEC} environment variable to override the
-    \l{qmake Manual#qmake}{\c qmake} configuration. Note that, due to the way
-    \l{qmake Manual#qmake}{\c qmake} reads project files, setting the
-    \c{QMAKESPEC} environment variable from within a project file will have no
-    effect.
+    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.
 
-    \target QMAKE_APP_FLAG
-    \section1 QMAKE_APP_FLAG
-
-    This variable is empty unless the \c app
-    \l{#TEMPLATE}{TEMPLATE} is specified.  The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified. Use the
-    following instead:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 42
-
-    \target QMAKE_APP_OR_DLL
-    \section1 QMAKE_APP_OR_DLL
-
-    This variable is empty unless the \c app or \c dll \l{#TEMPLATE}{TEMPLATE}
-    is specified.  The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    \note Do not attempt to overwrite the value of this variable.
 
     \target QMAKE_AR_CMD
     \section1 QMAKE_AR_CMD
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains the command for invoking the program which creates,
-    modifies and extracts archives. The value of this variable is typically
-    handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+    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
 
-    This variable is used to hold the data that will be installed with a library
+    \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
@@ -1678,14 +1424,14 @@
     Library bundles are created when the \c lib_bundle option is added to the
     \l{#CONFIG}{CONFIG} variable.
 
-    See \l{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
+    See \l{Platform Notes#Creating Frameworks}{Platform Notes} for
     more information about creating library bundles.
 
-    \e{This is used on Mac OS X only.}
-
     \section1 QMAKE_BUNDLE_EXTENSION
 
-    This variable defines the extension to be used for library bundles.
+    \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.
 
@@ -1694,11 +1440,9 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 44
 
-    \e{This is used on Mac OS X only.}
-
     \section1 QMAKE_CC
 
-    This variable specifies the C compiler that will be used when building
+    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.
@@ -1706,71 +1450,67 @@
     \target QMAKE_CFLAGS_DEBUG
     \section1 QMAKE_CFLAGS_DEBUG
 
-    This variable contains the flags for the C compiler in debug mode. The
-    value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    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
 
-    This variable contains the compiler flags for creating a non-debuggable
-    application.  The value of this variable is typically
-    handled by \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf}
+    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
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains the compiler flags for creating a shared
+    Specifies the compiler flags for creating a shared
     library. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target QMAKE_CFLAGS_THREAD
     \section1 QMAKE_CFLAGS_THREAD
 
-    This variable contains the compiler flags for creating a multi-threaded
+    Specifies the compiler flags for creating a multi-threaded
     application. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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 not empty if the warn_off
-    \l{#CONFIG}{CONFIG} option is specified.  The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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 not empty if the warn_on \l{#CONFIG}{CONFIG} option is
-    specified. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    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
 
-    This variable contains any files which are not generated files (such as moc and uic
-    generated files) and object files that should be removed when using "make 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
 
-    This variable specifies the C++ compiler that will be used when building
+    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
 
-    This variable contains the C++ compiler flags that are used when building
+    Specifies the C++ compiler flags for building
     a project. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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.
@@ -1778,155 +1518,151 @@
     \target QMAKE_CXXFLAGS_DEBUG
     \section1 QMAKE_CXXFLAGS_DEBUG
 
-    This variable contains the C++ compiler flags for creating a debuggable
-    application. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    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
 
-    This variable contains the C++ compiler flags for creating an application.
+    Specifies the C++ compiler flags for release builds.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
 
     \target QMAKE_CXXFLAGS_SHLIB
     \section1 QMAKE_CXXFLAGS_SHLIB
 
-    This variable contains the C++ compiler flags for creating a shared library.
+    Specifies the C++ compiler flags for creating a shared library.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target QMAKE_CXXFLAGS_THREAD
     \section1 QMAKE_CXXFLAGS_THREAD
 
-    This variable contains the C++ compiler flags for creating a multi-threaded
-    application.  The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake}or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    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
 
-    This variable contains the C++ compiler flags for suppressing compiler
+    Specifies the C++ compiler flags for suppressing compiler
     warnings. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target QMAKE_CXXFLAGS_WARN_ON
     \section1 QMAKE_CXXFLAGS_WARN_ON
 
-    This variable contains C++ compiler flags for generating compiler warnings.
+    Specifies C++ compiler flags for generating compiler warnings.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target QMAKE_DISTCLEAN
     \section1 QMAKE_DISTCLEAN
 
-    This variable removes extra files upon the invocation of \c{make distclean}.
+    Specifies a list of files to be removed by \c{make distclean}.
 
     \target QMAKE_EXTENSION_SHLIB
     \section1 QMAKE_EXTENSION_SHLIB
 
-    This variable contains the extention for shared libraries.  The value of
-    this variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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 that platform-specific variables that change the extension will override
+    \note Platform-specific variables that change the extension override
     the contents of this variable.
 
     \section1 QMAKE_EXT_MOC
 
-    This variable changes the extention used on included moc files.
+    Contains the extension used on included moc files.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
 
     \section1 QMAKE_EXT_UI
 
-    This variable changes the extention used on /e Designer UI files.
+    Contains the extension used on \QD UI files.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
 
     \section1 QMAKE_EXT_PRL
 
-    This variable changes the extention used on created PRL files.
+    Contains the extension used on created PRL files.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
-             \l{Configuring qmake's Environment#libdepend}{Library Dependencies}.
+    See also \l{Configuring qmake#Extensions}{File Extensions},
+             \l{LibDepend}{Library Dependencies}.
 
     \section1 QMAKE_EXT_LEX
 
-    This variable changes the extention used on files given to lex.
+    Contains the extension used on files given to Lex.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
+    See also \l{Configuring qmake#Extensions}{File Extensions},
              \l{#LEXSOURCES}{LEXSOURCES}.
 
     \section1 QMAKE_EXT_YACC
-    This variable changes the extention used on files given to yacc.
+    Contains the extension used on files given to Yacc.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions},
+    See also \l{Configuring qmake#Extensions}{File Extensions},
              \l{#YACCSOURCES}{YACCSOURCES}.
 
     \section1 QMAKE_EXT_OBJ
 
-    This variable changes the extention used on generated object files.
+    Contains the extension used on generated object files.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
 
     \section1 QMAKE_EXT_CPP
 
-    This variable changes the interpretation of all suffixes in this
-    list of values as files of type C++ source code.
+    Contains suffixes for files that should be interpreted as C++ source code.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
 
     \section1 QMAKE_EXT_H
 
-    This variable changes the interpretation of all suffixes in this
-    list of values as files of type C header files.
+    Contains suffixes for files which should be interpreted as C header files.
 
-    See also \l{Configuring qmake's Environment#Extensions}{File Extensions}.
+    See also \l{Configuring qmake#Extensions}{File Extensions}.
 
         \section1 QMAKE_EXTRA_COMPILERS
 
-        This variable contains the extra compilers/preprocessors that have been added
+    Specifies a list of additional compilers or preprocessors.
 
-        See also \l{Configuring qmake's Environment#Customizing}{Customizing Makefile Output}
+    See also \l{Adding Compilers}.
 
         \section1 QMAKE_EXTRA_TARGETS
 
-        This variable contains the extra targets that have been added
+    Specifies a list of additional qmake targets.
 
-        See also \l{Configuring qmake's Environment#Customizing}{Customizing Makefile Output}
+    See also \l{Adding Custom Targets}.
 
     \target QMAKE_FAILED_REQUIREMENTS
     \section1 QMAKE_FAILED_REQUIREMENTS
 
-    This variable contains the list of requirements that were failed to be met
-    when \l{qmake Manual#qmake}{\c qmake} was used. For example, the sql module
-    is needed and wasn't compiled into Qt. The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+    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{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
+    See \l{Creating Frameworks} for
     more information about creating frameworks and library bundles.
 
-    \e{This is used on Mac OS X only.}
-
     \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.
@@ -1934,35 +1670,31 @@
     By default, this variable contains the same value as the \l{#VERSION}{VERSION}
     variable.
 
-    See \l{qmake Platform Notes#Creating Frameworks}{qmake Platform Notes} for
-    more information about creating frameworks.
-
-    \e{This is used on Mac OS X only.}
+    See \l{Creating Frameworks} for more information about creating frameworks.
 
     \target QMAKE_INCDIR
     \section1 QMAKE_INCDIR
 
-    This variable contains the location of all known header files to be added
-    to INCLUDEPATH when building an application.  The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable contains the location of EGL header files to be added to
-    INCLUDEPATH when building an application with OpenGL/ES or OpenVG support.
+    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
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target QMAKE_INCDIR_OPENGL
     \section1 QMAKE_INCDIR_OPENGL
 
-    This variable contains the location of OpenGL header files to be added
-    to INCLUDEPATH when building an application with OpenGL support. The
+    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
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     If the OpenGL implementation uses EGL (most OpenGL/ES systems),
@@ -1970,12 +1702,12 @@
 
     \section1 QMAKE_INCDIR_OPENGL_ES1, QMAKE_INCDIR_OPENGL_ES2
 
-    These variables contain the location of OpenGL headers files to be added
-    to INCLUDEPATH when building an application with OpenGL ES 1
+    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 \
-    l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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),
@@ -1984,47 +1716,31 @@
     \target QMAKE_INCDIR_OPENVG
     \section1 QMAKE_INCDIR_OPENVG
 
-    This variable contains the location of OpenVG header files to be added
-    to INCLUDEPATH when building an application with OpenVG support. The
+    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
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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_QT
-    \section1 QMAKE_INCDIR_QT
-
-    This variable contains the location of all known header file paths to be
-    added to INCLUDEPATH when building a Qt application. The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
-    \target QMAKE_INCDIR_THREAD
-    \section1 QMAKE_INCDIR_THREAD
-
-    This variable contains the location of all known header file paths to be
-    added to INCLUDEPATH when building a multi-threaded application. The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
-    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \target QMAKE_INCDIR_X11
     \section1 QMAKE_INCDIR_X11
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains the location of X11 header file paths to be added
-    to INCLUDEPATH when building a X11 application. The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    \e {This is used on Mac OS X platforms only.}
+    \note This variable is used on Mac OS X platforms only.
 
-    This variable contains the name of the property list file, \c{.plist}, you
+    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@,
@@ -2035,7 +1751,7 @@
 
     \section1 QMAKE_LFLAGS
 
-    This variable contains a general set of flags that are passed to
+    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.
@@ -2043,110 +1759,110 @@
     \target QMAKE_LFLAGS_CONSOLE
     \section1 QMAKE_LFLAGS_CONSOLE
 
-    \e {This is used on Windows only.}
+    \note This variable is used on Windows only.
 
-    This variable contains link flags when building console programs. The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
+    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
 
-    This variable contains link flags when building debuggable applications.
-    The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    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
 
-    This variable contains link flags when building plugins. The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    Library paths in this definition are added to the executable at link
-    time so that the added paths will be preferentially searched at runtime.
+    Specifies the linker flags needed to use the values from \l{QMAKE_RPATHDIR}.
 
-    \section1 QMAKE_LFLAGS_QT_DLL
+    The value of this variable is typically handled by
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
 
-    This variable contains link flags when building programs that use the Qt
-    library built as a dll. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c 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
 
-    This variable contains link flags when building applications for release.
+    Specifies the linker flags for release builds.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
 
-    \section1 QMAKE_LFLAGS_SHAPP
+    \section1 QMAKE_LFLAGS_APP
 
-    This variable contains link flags when building applications which are
-    using the \c app template.  The value of this variable is typically
-    handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable contains link flags when building shared libraries
+    Specifies the linker flags used for building shared libraries.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_LFLAGS_SONAME
 
-    This variable specifies the link flags to set the name of shared objects,
-    such as .so or .dll.  The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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
 
-    This variable contains link flags when building multi-threaded projects.
+    Specifies the linker flags for building multi-threaded projects.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_LFLAGS_WINDOWS
 
-    \e {This is used on Windows only.}
+    \note This variable is used on Windows only.
 
-    This variable contains link flags when building Windows GUI projects (i.e.
+    Specifies the linker flags for building Windows GUI projects (that is,
     non-console applications). The value of this variable is typically handled
-    by \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    by qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_LIBDIR
 
-    This variable contains the location of all known library directories. The
-    value of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
+    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
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains the location of all library directory with -L
+    Specifies the location of all library directories with -L
     prefixed. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_LIBDIR_EGL
 
-    This variable contains the location of the EGL library directory, when 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 \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf}
+    handled by qmake or \l{#QMAKESPEC}{qmake.conf}
     and rarely needs to be modified.
 
     \section1 QMAKE_LIBDIR_OPENGL
 
-    This variable contains the location of the OpenGL library directory. The
+    Specifies the location of the OpenGL library directory. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     If the OpenGL implementation uses EGL (most OpenGL/ES systems),
@@ -2154,63 +1870,51 @@
 
     \section1 QMAKE_LIBDIR_OPENVG
 
-    This variable contains the location of the OpenVG library directory. The
+    Specifies the location of the OpenVG library directory. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    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_QT
-
-    This variable contains the location of the Qt library directory. The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
-    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \section1 QMAKE_LIBDIR_X11
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains the location of the X11 library directory. The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
+    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
 
-    This variable contains all project libraries. The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable contains all EGL libraries when building Qt with OpenGL/ES
+    Specifies all EGL libraries when building Qt with OpenGL/ES
     or OpenVG.  The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.  The usual value is \c{-lEGL}.
 
     \section1 QMAKE_LIBS_OPENGL
 
-    This variable contains all OpenGL libraries.  The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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_QT
-
-    This variable contains all OpenGL Qt libraries.The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \section1 QMAKE_LIBS_OPENGL_ES1, QMAKE_LIBS_OPENGL_ES2
 
-    These variables contain all the OpenGL libraries for OpenGL ES 1
+    These variables specify all the OpenGL libraries for OpenGL ES 1
     and OpenGL ES 2.
 
     The value of these variables is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     If the OpenGL implementation uses EGL (most OpenGL/ES systems),
@@ -2218,8 +1922,8 @@
 
     \section1 QMAKE_LIBS_OPENVG
 
-    This variable contains all OpenVG libraries.  The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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}.
 
@@ -2230,127 +1934,72 @@
     If the OpenVG implementation uses EGL, then QMAKE_LIBS_EGL may also
     need to be set.
 
-    \section1 QMAKE_LIBS_QT
-
-    This variable contains all Qt libraries.The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
-    \section1 QMAKE_LIBS_QT_DLL
-
-    \e {This is used on Windows only.}
-
-    This variable contains all Qt libraries when Qt is built as a dll. The
-    value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \section1 QMAKE_LIBS_QT_OPENGL
-
-    This variable contains all the libraries needed to link against if OpenGL
-    support is turned on. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \section1 QMAKE_LIBS_QT_THREAD
-
-    This variable contains all the libraries needed to link against if thread
-    support is turned on.  The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \section1 QMAKE_LIBS_RT
-
-    \e {This is used with Borland compilers only.}
-
-    This variable contains the runtime library needed to link against when
-    building an application.  The value of this variable is typically handled
-    by \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and
-    rarely needs to be modified.
-
-    \section1 QMAKE_LIBS_RTMT
-
-    \e {This is used with Borland compilers only.}
-
-    This variable contains the runtime library needed to link against when
-    building a multi-threaded application.  The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \section1 QMAKE_LIBS_THREAD
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains all libraries that need to be linked against when
-    building a multi-threaded application.  The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
-    \section1 QMAKE_LIBS_WINDOWS
-
-    \e {This is used on Windows only.}
-
-    This variable contains all windows libraries. The value of this variable
-    is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    This variable contains all X11 libraries.The value of this variable is
-    typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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 \l{qmake Manual#qmake}{\c qmake}
+    of this variable is typically handled by qmake
     or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
 
     \section1 QMAKE_LINK_SHLIB_CMD
 
-    This variable contains the command to execute when creating a shared
+    Specifies the command to execute when creating a shared
     library. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_LN_SHLIB
 
-    This variable contains the command to execute when creating a link
-    to a shared library. The
-    value of this variable is typically handled by \c qmake or
+    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
 
-    This variable contains the command to execute after linking the TARGET
+    Specifies the command to execute after linking the \l{TARGET}
     together. This variable is normally empty and therefore nothing is
-    executed, additionally some backends will not support this - mostly only
-    Makefile backends.
+    executed.
+
+    \note This variable takes no effect on Xcode projects.
 
     \section1 QMAKE_PRE_LINK
 
-    This variable contains the command to execute before linking the TARGET
+    Specifies the command to execute before linking the \l{TARGET}
     together. This variable is normally empty and therefore nothing is
-    executed, additionally some backends will not support this - mostly only
-    Makefile backends.
+    executed.
+
+    \note This variable takes no effect on Xcode projects.
 
     \section1 QMAKE_PROJECT_NAME
 
-    \e {This is used for Visual Studio project files only.}
+    \note This variable is used for Visual Studio project files only.
 
-    This variable determines the name of the project when generating project
+    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 \l {qmake Manual#qmake}{ \c qmake} and
-    rarely needs to be modified.
+    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 has an effect when building on Mac OS X. On that
+
+    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
@@ -2359,29 +2008,15 @@
 
     \section1 QMAKE_MAKEFILE
 
-    This variable contains the name of the Makefile to create. The value of
-    this variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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_MOC_SRC
-
-    This variable contains the names of all moc source files to generate and
-    include in the project. The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
     \section1 QMAKE_QMAKE
 
-    This variable contains the location of qmake if it is not in the path. The
-    value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \section1 QMAKE_QT_DLL
+    Contains the abosolute path of the qmake executable.
 
-    This variable is not empty if Qt was built as a dll.  The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
+    \note Do not attempt to overwrite the value of this variable.
 
     \section1 QMAKE_RESOURCE_FLAGS
 
@@ -2393,143 +2028,152 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 45
 
-    \section1 QMAKE_RPATH
-
-    \e {This is used on Unix platforms only.}
-
-    Is equivalent to \l QMAKE_LFLAGS_RPATH.
-
     \section1 QMAKE_RPATHDIR
 
-    \e {This is used on Unix platforms only.}
+    \note This variable is used on Unix platforms only.
 
-    A list of library directory paths, these paths are added to the
+    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
 
-    This variable specifies the individual rule needed to build an object. The
+    Specifies the individual rule needed to build an object. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_RUN_CC_IMP
 
-    This variable specifies the individual rule needed to build an object. The
+    Specifies the individual rule needed to build an object. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_RUN_CXX
 
-    This variable specifies the individual rule needed to build an object. The
+    Specifies the individual rule needed to build an object. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_RUN_CXX_IMP
 
-    This variable specifies the individual rule needed to build an object. The
+    Specifies the individual rule needed to build an object. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 QMAKE_TARGET
 
-    This variable contains the name of the project target.  The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
+    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 QMAKE_UIC
-
-    This variable contains the location of uic if it is not in the path. The
-    value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    It can be used to specify arguments to uic as well, such as additional plugin
-    paths.  For example:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 46
-
     \section1 QT
 
-    The values stored in the \c QT variable control which of the Qt modules are
-    used by your project.
+    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 features that are associated with each of them:
+    and the Qt modules that are associated with each of them:
 
     \table
     \header \li Option                     \li Features
-    \row    \li core (included by default) \li QtCore module
-    \row    \li gui  (included by default) \li QtGui module
-    \row    \li network                    \li QtNetwork module
-    \row    \li opengl                     \li QtOpenGL module
-    \row    \li sql                        \li QtSql module
-    \row    \li svg                        \li QtSvg module
-    \row    \li xml                        \li QtXml module
-    \row    \li webkit                     \li WebKit integration
+    \row    \li axcontainer                \li \l{Using ActiveX controls and COM in Qt}
+                                               {QAxContainer} module, which is
+                                               part of the ActiveQt framework
+    \row    \li axserver                   \li \l{Building ActiveX servers in Qt}
+                                               {QAxServer} module, which is
+                                               part of the ActiveQt framework
+    \row    \li concurrent                 \li \l{Qt Concurrent} module
+    \row    \li core (included by default) \li \l{Qt Core} module
+    \row    \li dbus                       \li \l{Qt D-Bus} module
+    \row    \li declarative                \li \l{Qt Quick 1 Reference Documentation}
+                                               {Qt Declarative}
+    \row    \li designer                   \li \l{Qt Designer} module
+    \row    \li designercomponents         \li \l{Qt Designer Components} module
+    \row    \li gui  (included by default) \li \l{Qt GUI} module
+    \row    \li help                       \li \l{Qt Help} module
+    \row    \li multimedia                 \li \l{Qt Multimedia} module
+    \row    \li multimediawidgets          \li \l{Qt Multimedia Widgets} module
+    \row    \li network                    \li \l{Qt Network} module
+    \row    \li opengl                     \li \l{Qt OpenGL} module
+    \row    \li printsupport               \li \l{Qt Print Support} module
+    \row    \li qml                        \li \l{Qt QML} module
+    \row    \li qmltest                    \li \l{Qt QML Test} module
+    \row    \li qtx11extras                \li \l{Qt X11 Extras} module
+    \row    \li quick                      \li \l{Qt Quick} module
+    \row    \li script                     \li \l{Qt Script} module
+    \row    \li scripttools                \li \l{Qt Script Tools} module
+    \row    \li sensors                    \li \l{Qt Sensors} module
+    \row    \li serialport                 \li \l{Qt Serial Port} module
+    \row    \li sql                        \li \l{Qt SQL} module
+    \row    \li svg                        \li \l{Qt SVG} module
+    \row    \li testlib                    \li \l{Qt Test} module
+    \row    \li uitools                    \li \l{Qt UI Tools} module
+    \row    \li webkit                     \li \l{Qt WebKit} module
+    \row    \li webkitwidgets              \li \l{Qt WebKit Widgets} module
+    \row    \li widgets                    \li \l{Qt Widgets} module
+    \row    \li xml                        \li \l{Qt XML} module
+    \row    \li xmlpatterns                \li \l{Qt XML Patterns} module
     \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 QtGui module, you need to
-    exclude the \c gui value with the "-=" operator; the following line will
+    If you want to build a project \e without the 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 doc/src/snippets/code/doc_src_qmake-manual.pro 47
 
-    Note that adding the \c opengl option to the \c QT variable automatically
-    causes the equivalent option to be added to the \c CONFIG variable.
-    Therefore, for Qt applications, it is not necessary to add the \c opengl
-    option to both \c CONFIG and \c{QT}.
-
     \section1 QTPLUGIN
 
-    This variable contains a list of names of static plugins that are to be
-    compiled with an application so that they are available as built-in
+    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
+    \target QT_VERSION_variable
     \section1 QT_VERSION
 
-    This variable contains the current version of Qt.
+    Contains the current version of Qt.
 
     \target QT_MAJOR_VERSION
     \section1 QT_MAJOR_VERSION
 
-    This variable contains the current major version of Qt.
+    Contains the current major version of Qt.
 
     \target QT_MINOR_VERSION
     \section1 QT_MINOR_VERSION
 
-    This variable contains the current minor version of Qt.
+    Contains the current minor version of Qt.
 
     \target QT_PATCH_VERSION
     \section1 QT_PATCH_VERSION
 
-    This variable contains the current patch version of Qt.
+    Contains the current patch version of Qt.
 
     \section1 RC_FILE
 
-    This variable contains the name of the resource file for the application.
+    Specifies the name of the resource file for the application.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 RC_INCLUDEPATH
 
-    This variable contains include paths that are passed to the Windows
-    Resource Compiler.
+    Specifies include paths that are passed to the Windows Resource Compiler.
 
     \target RCC_DIR
     \section1 RCC_DIR
 
-    This variable specifies the directory where all intermediate
-    resource files should be placed.
+    Specifies the directory for Qt Resource Compiler output files.
 
     For example:
 
@@ -2538,31 +2182,30 @@
     \target REQUIRES
     \section1 REQUIRES
 
-    This is a special variable processed by \l{qmake Manual#qmake}{\c qmake}.
-    If the contents of this variable do not appear in CONFIG by the time this
-    variable is assigned, then a minimal Makefile will be generated that
-    states what dependencies (the values assigned to REQUIRES) are
-    missing.
+    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.
 
-    This is mainly used in Qt's build system for building the examples.
+    \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
 
-    This variable contains the name of the resource collection file (qrc)
-    for the application. Further information about the resource collection
-    file can be found at \l{The Qt Resource System}.
+    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
 
-    This variable contains the name of the resource file for the application.
+    Specifies the name of the compiled Windows resource file for the target.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target SIGNATURE_FILE
     \section1 SIGNATURE_FILE
 
-    \e {This is only used on Windows CE.}
+    \note This variable is only used on Windows CE.
 
     Specifies which signature file should be used to sign the project target.
 
@@ -2572,27 +2215,19 @@
     \target SOURCES
     \section1 SOURCES
 
-    This variable contains the name of all source files in the project.
+    Specifies the names of all source files in the project.
 
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 49
 
-    See also \l{#HEADERS}{HEADERS}
-
-    \section1 SRCMOC
-
-    This variable is set by \l{qmake Manual#qmake}{\c qmake} if files can be
-    found that contain the Q_OBJECT macro. \c SRCMOC contains the name of all
-    the generated moc files. The value of this variable is typically handled
-    by \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and
-    rarely needs to be modified.
+    See also \l{#HEADERS}{HEADERS}.
 
     \target SUBDIRS
     \section1 SUBDIRS
 
     This variable, when used with the \l{#TEMPLATE}{\c subdirs template}
-    contains the names of all subdirectories or project files that contain
+    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.
 
@@ -2601,7 +2236,7 @@
     \snippet doc/src/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 \l{qmake Manual#qmake}{\c qmake}
+    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.
 
@@ -2636,56 +2271,55 @@
     \target TARGET
     \section1 TARGET
 
-    This specifies the name of the target file.
+    Specifies the name of the target file. Contains the base name of the project
+    file by default.
 
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 52
 
     The project file above would produce an executable named \c myapp on
-    unix and 'myapp.exe' on windows.
+    unix and \c{myapp.exe} on Windows.
 
     \section1 TARGET_EXT
 
-    This variable specifies the target's extension. The value of this variable
-    is typically handled by \l {qmake Manual#qmake}{\c qmake} or
+    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
 
-    This variable specifies the target's extension with a major version number.
+    Specifies the extension of \c TARGET with a major version number.
     The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \section1 TARGET_x.y.z
 
-    This variable specifies the target's extension with version number. The
+    Specifies the extension of \c TARGET with version number. The
     value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
+    qmake or \l{#QMAKESPEC}{qmake.conf} and rarely
     needs to be modified.
 
     \target TEMPLATE
     \section1 TEMPLATE
 
-    This variable contains the name of the template to use when
-    generating the project.  The allowed values are:
+    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{qmake Common Projects#Application}{qmake Common Projects} for more information.)
-    \row    \li lib    \li Creates a Makefile for building libraries. (See
-            \l{qmake Common Projects#Library}{qmake Common Projects} for more information.)
+    \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 \e {Windows only} Creates an application project for Visual Studio.
-            (See \l{qmake Platform Notes#Creating Visual Studio Project Files}{qmake Platform Notes}
-            for more information.)
-    \row    \li vclib  \li \e {Windows only} Creates a library project for Visual Studio.
-            (See \l{qmake Platform Notes#Creating Visual Studio Project Files}{qmake Platform Notes}
-            for more information.)
+    \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:
@@ -2700,63 +2334,27 @@
 
     \section1 TRANSLATIONS
 
-    This variable contains a list of translation (.ts) files that contain
+    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.
 
-    \section1 UICIMPLS
-
-    This variable contains a list of the generated implementation files by UIC.
-    The value of this variable is typically handled by
-    \l{qmake Manual#qmake}{\c qmake} or \l{#QMAKESPEC}{qmake.conf} and rarely
-    needs to be modified.
-
-    \section1 UICOBJECTS
-
-    This variable is generated from the UICIMPLS variable. The extension of
-    each file will have been replaced by .o (Unix) or .obj (Win32). The value
-    of this variable is typically handled by \l{qmake Manual#qmake}{\c qmake}
-    or \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \target UI_DIR
     \section1 UI_DIR
 
-    This variable specifies the directory where all intermediate files from uic
-    should be placed. This variable overrides both UI_SOURCES_DIR and
-    UI_HEADERS_DIR.
+    Specifies the directory where all intermediate files from uic
+    should be placed.
 
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 54
 
-    \target UI_HEADERS_DIR
-    \section1 UI_HEADERS_DIR
-
-    This variable specifies the directory where all declaration files (as
-    generated by uic) should be placed.
-
-    For example:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 55
-
-    \target UI_SOURCES_DIR
-    \section1 UI_SOURCES_DIR
-
-    This variable specifies the directory where all implementation files (as generated
-    by uic) should be placed.
-
-    For example:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 56
-
     \target VERSION
     \section1 VERSION
 
-    This variable contains the version number of the application or library if
-    either the \c app \l{#TEMPLATE}{TEMPLATE} or the \c lib \l{#TEMPLATE}{TEMPLATE}
-    is specified.
+    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:
 
@@ -2764,45 +2362,31 @@
 
     \section1 VER_MAJ
 
-    This variable contains the major version number of the library, if the
+    Specifies the major version number of the library if the
     \c lib \l{#TEMPLATE}{template} is specified.
 
     \section1 VER_MIN
 
-    This variable contains the minor version number of the library, if the
+    Specifies the minor version number of the library if the
     \c lib \l{#TEMPLATE}{template} is specified.
 
     \section1 VER_PAT
 
-    This variable contains the patch version number of the library, if the
+    Specifies the patch version number of the library if the
     \c lib \l{#TEMPLATE}{template} is specified.
 
     \section1 VPATH
 
-    This variable tells \l{qmake Manual#qmake}{\c qmake} where to search for
-    files it cannot open. With this you may tell
-    \l{qmake Manual#qmake}{\c qmake} where it may look for things like SOURCES,
-    and if it finds an entry in SOURCES that cannot be opened it will look
+    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}.
 
-    \section1 YACCIMPLS
-
-    This variable contains a list of yacc source files. The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
-    \section1 YACCOBJECTS
-
-    This variable contains a list of yacc object files. The value of this
-    variable is typically handled by \l{qmake Manual#qmake}{\c qmake} or
-    \l{#QMAKESPEC}{qmake.conf} and rarely needs to be modified.
-
     \target YACCSOURCES
     \section1 YACCSOURCES
 
-    This variable contains a list of yacc source files to be included
+    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.
 
@@ -2812,29 +2396,32 @@
 
     \section1 _PRO_FILE_
 
-    This variable contains the path to the project file in use.
+    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 doc/src/snippets/qmake/project_location.pro project file
 
+    \note Do not attempt to overwrite the value of this variable.
+
     \section1 _PRO_FILE_PWD_
 
-    This variable contains the path to the directory containing the project
-    file in use.
+    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 doc/src/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 qmake Variable Reference
+    \previouspage Variables
     \nextpage Test Functions
 
     qmake provides functions for processing the contents of variables
@@ -2867,7 +2454,9 @@
 
     \section2 basename(variablename)
 
-    Returns the basename of the file specified. For example:
+    Returns the basename of the file specified in \c variablename.
+
+    For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 59
 
@@ -2909,7 +2498,7 @@
 
     \section2 escape_expand(arg1 [, arg2 ..., argn])
 
-    This function accepts an arbitrary number of arguments. It expands the
+    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.
 
@@ -2918,15 +2507,16 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 173
 
+    \target findfunction
     \section2 find(variablename, substr)
 
-    Places all the values in \e variablename that match \e substr. \e
-    substr may be a regular expression, and will be matched accordingly.
+    Returns all the values in \c variablename that match the regular expression
+    \c substr.
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 64
 
     MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MY_VAR3 will
-    contains 'three two three'.
+    contain 'three two three'.
 
     \section2 first(variablename)
 
@@ -2971,11 +2561,11 @@
 
     \section2 join(variablename, glue, before, after)
 
-    Joins the value of \e variablename with \c glue. If this value is
-    non-empty it prefixes the value with \e before and suffix it with \e
-    after. \e variablename is the only required field, the others default
-    to empty strings. If you need to encode spaces in \e glue, \e before, or \e
-    after you must quote them.
+    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)
 
@@ -2989,7 +2579,7 @@
 
     \section2 list(arg1 [, arg2 ..., argn])
 
-    This function takes an arbitrary number of arguments. It creates a uniquely
+    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
@@ -3008,20 +2598,20 @@
 
     \section2 member(variablename, position)
 
-    Returns the value at the given \e position in the list of items in
-    \e variablename.
+    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. \e variablename is the only required field. If not specified,
+    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 \e question, and returns a value read from stdin.
+    Displays the specified \c question, and returns a value read from stdin.
 
     \section2 quote(string)
 
-    Converts a whole \e string into a single entity and returns the result.
+    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)
@@ -3053,7 +2643,7 @@
     \section2 sprintf(string, arguments...)
 
     Replaces %1-%9 with the arguments passed in the comma-separated list
-    of function \e arguments and returns the processed string.
+    of function \c arguments and returns the processed string.
 
     \section2 resolve_depends(variablename, prefix)
 
@@ -3140,8 +2730,8 @@
     \target unique
     \section2 unique(variablename)
 
-    This will return a list of values in variable that are unique (that is
-    with repetitive entries removed). For example:
+    Returns the list of values in \c variablename with duplicate entries removed.
+    For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 73
 
@@ -3180,10 +2770,10 @@
     \section2 CONFIG(config)
 
     This function can be used to test for variables placed into the
-    \c CONFIG variable. This is the same as regular old style (tmake) scopes,
-    but has the added advantage a second parameter can be passed to test for
+    \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 (i.e. the last one set will be considered the active config for
+    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:
 
@@ -3196,7 +2786,7 @@
 
     \section2 contains(variablename, value)
 
-    Succeeds if the variable \e variablename contains the value \e 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.
 
@@ -3205,18 +2795,19 @@
     \snippet doc/src/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 \c SOURCES and \c HEADERS
+    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 \e variablename contains a list with the
-    specified \e number of value; otherwise fails.
+    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:
+    only processed if the variable contains the correct number of values.
+    For example:
 
     \snippet doc/src/snippets/qmake/functions.pro 2
 
@@ -3247,9 +2838,9 @@
 
     \section2 error(string)
 
-    This function never returns a value. \l{qmake Manual#qmake}{\c qmake}
-    displays the given \e string to the user, and exits. This function
-    should only be used for unrecoverable errors.
+    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:
 
@@ -3258,19 +2849,19 @@
     \section2 eval(string)
 
     Evaluates the contents of the string using
-    \l{qmake Manual#qmake}{\c qmake}'s syntax rules and returns true.
+    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 doc/src/snippets/qmake/functions.pro 4
 
-    Note that quotation marks can be used to delimit the string, and that
+    \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 \e filename exists.
+    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.
@@ -3278,7 +2869,7 @@
     For example:
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 63
 
-    Note that "/" can be used as a directory separator, regardless of the
+    \note "/" should be used as a directory separator, regardless of the
     platform in use.
 
     \section2 export(variablename)
@@ -3291,16 +2882,13 @@
     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)
 
-    This special test function will cause a loop to be started that
-    iterates over all values in \e list, setting \e iterate to each
-    value in turn. As a convenience, if \e list is 1..10 then iterate will
+    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.
 
-    The use of an else scope afer a condition line with a for() loop is
-    disallowed.
-
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 65
@@ -3327,8 +2915,7 @@
 
     \section2 if(condition)
 
-    This test function evaluates \c condition. It is used to group boolean
-    expressions.
+    Evaluates \c condition. It is used to group boolean expressions.
 
     For example:
 
@@ -3336,22 +2923,21 @@
 
     \section2 include(filename)
 
-    Includes the contents of the file specified by \e filename into the
+    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 \e filename is included; otherwise it fails. The included
+    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:
+    the condition for a scope. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 66
 
     \section2 infile(filename, var, val)
 
-    Succeeds if the file \e filename (when parsed by
-    \l{qmake Manual#qmake}{\c qmake} itself) contains the variable \e var with
-    a value of \e val; otherwise fails. If you do not specify a third argument
-    (\e val), the function will only test whether \e var has been declared in
+    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
@@ -3360,7 +2946,7 @@
 
     \section2 isEmpty(variablename)
 
-    Succeeds if the variable \e variablename is empty; otherwise fails.
+    Succeeds if the variable \c variablename is empty; otherwise fails.
     This is the equivalent of \c{count( variablename, 0 )}.
 
     For example:
@@ -3382,7 +2968,7 @@
 
     \section2 load(feature)
 
-    This function loads the feature file (\c .prf) specified by \c feature,
+    Loads the feature file (\c .prf) specified by \c feature,
     unless the feature has already been loaded.
 
     \section2 log(message)
@@ -3394,19 +2980,19 @@
 
     \section2 message(string)
 
-    This function simply writes a message to the console. Unlike the
-    \c error() function, this function allows processing to continue.
+    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 doc/src/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.
+    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{qmake Advanced Usage}{in conjunction with a scope} to filter out
-    messages during builds; for example:
+    \l{Scopes}{in conjunction with a scope} to filter out
+    messages during builds. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 69
 
@@ -3418,18 +3004,16 @@
     \section2 requires(condition)
 
     Evaluates \c condition. If the condition is false, qmake skips this
-    project (and its SUBDIRS) when building.
+    project (and its \l{SUBDIRS}) when building.
 
-    \note You can also use the REQUIRES variable for this purpose. However, we
+    \note You can also use the \l{REQUIRES} variable for this purpose. However, we
     recommend using this function, instead.
 
-    See also \l{REQUIRES}.
-
     \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:
+    You can check the return value of this function using a scope.
 
     For example:
 
@@ -3437,6 +3021,7 @@
 
     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
@@ -3452,8 +3037,7 @@
 
     \section2 warning(string)
 
-    This function will always succeed, and will display the given
-    \c string to the user. message() is a synonym for warning().
+    Always succeeds, and displays \c string as a warning message to the user.
 
     \section2 write_file(filename, [variablename, [mode]])
 
@@ -3484,71 +3068,79 @@
     \page qmake-environment-reference.html
     \contentspage {qmake Manual}{Contents}
     \previouspage Using Precompiled Headers
-    \nextpage qmake Reference
+    \nextpage Reference
 
-    \title Configuring qmake's Environment
+    \title Configuring qmake
 
-    \tableofcontents
-
-    \target Properties
     \section1 Properties
 
-    \l{qmake Manual#qmake}{\c qmake} has a system of persistent information,
-    this allows you to \c set a variable in qmake once, and each time qmake is
-    invoked this value can be queried. Use the following to set a property in
-    qmake:
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 74
 
-    The appropriate variable and value should be substituted for
-    \c VARIABLE and \c VALUE.
+    The appropriate property and value should be substituted for
+    \c PROPERTY and \c VALUE.
 
-    To retrieve this information back from qmake you can do:
+    You can retrieve this information back from qmake as follows:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 75
 
-    \note \c{qmake -query} will only list variables that you have
-    previously set with \c{qmake -set VARIABLE VALUE}.
+    \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). As
-    \c VARIABLE is versioned as well, you can set one value in an older
-    version of \l{qmake Manual#qmake}{\c qmake}, and newer versions will
-    retrieve this value. However, if you set \c VARIABLE for a newer version
-    of \l{qmake Manual#qmake}{\c qmake}, the older version will not use this
-    value. You can however query a specific version of a variable if you
-    prefix that version of \l{qmake Manual#qmake}{\c qmake} to \c VARIABLE,
-    as in the following example:
+    will be stored in different places for different platforms).
+
+    The following list summarizes the \c built-in properties:
 
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 76
+    \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
 
-    \l{qmake Manual#qmake}{\c qmake} also has the notion of \c builtin
-    properties, for example you can query the installation of Qt for this
-    version of \l{qmake Manual#qmake}{\c qmake} with the
+    For example, you can query the installation of Qt for this version of qmake with the
     \c QT_INSTALL_PREFIX property:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 77
 
-    These built-in properties cannot have a version prefixed to them as they
-    are not versioned, and each version of \l{qmake Manual#qmake}{\c qmake}
-    will have its own built-in set of these values. The list below outlines
-    the built-in properties:
-
-    \list
-    \li \c QT_INSTALL_PREFIX - Where the version of Qt this qmake is built for resides
-    \li \c QT_INSTALL_DATA - Where data for this version of Qt resides
-    \li \c QMAKE_VERSION - The current version of qmake
-    \endlist
-
-    Finally, these values can be queried in a project file with a special
-    notation such as:
+    You can query the values of properties in a project file as follows:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 78
 
     \target QMAKESPEC
     \section1 QMAKESPEC
 
-    \l{qmake Manual#qmake}{\c qmake} requires a platform and compiler
+    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.
@@ -3557,162 +3149,58 @@
 
     \list
     \li A complete path to a directory containing a \c{qmake.conf} file.
-       In this case \l{qmake Manual#qmake}{\c qmake} will open the
+       In this case qmake will open the
        \c{qmake.conf} file from within that directory. If the file does not
-       exist, \l{qmake Manual#qmake}{\c qmake} will exit with an error.
+       exist, qmake will exit with an error.
     \li The name of a platform-compiler combination. In this case,
-       \l{qmake Manual#qmake}{\c qmake} will search in the directory specified
+       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
 
-    \b{Note:} The \c QMAKESPEC path will automatically be added to the
-    \l{qmake Variable Reference#INCLUDEPATH}{INCLUDEPATH} system variable.
-
-    \target INSTALLS
-    \section1 INSTALLS
-
-    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,
-    \l{qmake Manual#qmake}{\c qmake}has the concept of an install set, an
-    object which contains instructions about the way part of a project is to
-    be installed. For example, a collection of documentation files can be
-    described in the following way:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 79
-
-    The \c path member informs \l{qmake Manual#qmake}{\c 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 coped 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 doc/src/snippets/code/doc_src_qmake-manual.pro 80
-
-    \l{qmake Manual#qmake}{\c qmake} will ensure that the specified files are
-    copied to the installation directory. If you require greater control over
-    this process, you can also provide a definition for the \c extra member of
-    the object. For example, the following line tells
-    \l{qmake Manual#qmake}{\c qmake} to execute a series of commands for this
-    install set:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 81
-
-    The \c unix scope
-    (see \l{qmake Advanced Usage#Scopes and Conditions}{Scopes and Conditions})
-    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, \l{qmake Manual#qmake}{\c qmake}
-    will decide what needs to be copied for you. Currently, the only supported
-    built-in install set is \c target:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 82
-
-    In the above lines, \l{qmake Manual#qmake}{\c qmake} knows what needs to
-    be copied, and will handle the installation process automatically.
+    \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 \l{qmake Manual#qmake}{\c qmake} reads to
+    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. If \c -nocache is not specified when
-    \l{qmake Manual#qmake}{\c qmake} is run, it will try to find a file called
-    \c{.qmake.cache} in parent directories of the current directory. If it
+    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 it finds a \c{.qmake.cache} file then it will process this file first before
+    If qmake  finds a \c{.qmake.cache} file then it will process this file first before
     it processes the project file.
 
-    \target LibDepend
-    \section1 Library Dependencies
-
-    Often when linking against a library, \l{qmake Manual#qmake}{\c 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 sufficent. 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. To help with this situation,
-    \l{qmake Manual#qmake}{\c qmake} attempts to follow a library's
-    dependencies where appropriate, but this behavior must be explicitly
-    enabled by following two steps.
-
-    The first step is to enable dependency tracking in the library itself.
-    To do this you must tell \l{qmake Manual#qmake}{\c qmake} to save
-    information about the library:
-
-    \snippet doc/src/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, \l{qmake Manual#qmake}{\c 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. You are free to view this file
-    and, if it is deleted, \l{qmake Manual#qmake}{\c qmake} will know to
-    recreate it when necessary, either when the project file is later read, or
-    if a dependent library (described below) has changed. When installing this
-    library, by specifying it as a target in an \c INSTALLS declaration,
-    \l{qmake Manual#qmake}{\c 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 doc/src/snippets/code/doc_src_qmake-manual.pro 84
-
-    When this is enabled, \l{qmake Manual#qmake}{\c qmake} will process all
-    libraries linked to by the application and find their meta-information.
-    \l{qmake Manual#qmake}{\c qmake} will use this to determine the relevant
-    linking information, specifically adding values to the application project
-    file's list of \c DEFINES as well as \c LIBS. Once
-    \l{qmake Manual#qmake}{\c 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 internals of the .prl file are left closed so they can easily
-    change later. They are not designed to be changed by hand, should only
-    be created by \{qmake Manual#qmake}{\c qmake}, and should not be
-    transferred between operating systems as they may contain
-    platform-dependent information.
-
     \target Extensions
     \section1 File Extensions
 
-    Under normal circumstances \l{qmake Manual#qmake}{\c qmake} will try to
+    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 \l{qmake Manual#qmake}{\c 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
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 85
 
     The following variables can be used to redefine common file extensions recognized
-    by \l{qmake Manual#qmake}{\c qmake}:
+    by qmake:
 
     \list
-    \li QMAKE_EXT_MOC - This modifies the extension placed on included moc files.
-    \li QMAKE_EXT_UI - This modifies the extension used for designer UI files (usually
-                      in \c FORMS).
-    \li QMAKE_EXT_PRL - This modifies the extension placed on
+    \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 QMAKE_EXT_LEX - This changes the suffix used in files (usually in \c LEXSOURCES).
-    \li QMAKE_EXT_YACC - This changes the suffix used in files (usually in \c YACCSOURCES).
-    \li QMAKE_EXT_OBJ - This changes the suffix used on generated object 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
@@ -3720,246 +3208,50 @@
     accept a list of values:
 
     \list
-    \li QMAKE_EXT_CPP - Causes \l{qmake Manual#qmake}{\c qmake} to interpret
+    \li \l{QMAKE_EXT_CPP} causes qmake to interpret
         all files with these suffixes as C++ source files.
-    \li QMAKE_EXT_H - Causes \l qmake Manual#{qmake}{\c qmake} to interpret
+    \li \l{QMAKE_EXT_H} causes qmake to interpret
         all files with these suffixes as C and C++ header files.
     \endlist
-
-    \target Customizing
-    \section1 Customizing Makefile Output
-
-    \l{qmake Manual#qmake}{\c 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 \l{qmake Manual#qmake}{\c qmake}
-    backends.
-
-    Customization of the Makefile output is performed through an object-style
-    API as found in other places in \l{qmake Manual#qmake}{\c qmake}. Objects
-    are defined automatically by specifying their members; for example:
-
-    \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 86
-
-    The definitions above define a \l{qmake Manual#qmake}{\c qmake} target
-    called \c mytarget, containing a Makefile target called \c{.buildfile}
-    which in turn is generated with the \c touch command. 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 instruct \l{qmake Manual#qmake}{\c qmake} that this
-    object is a target to be built:
-
-    \snippet doc/src/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{qmake Variable Reference#TARGET}{qmake build target}. To do this, you
-    simply need to include your Makefile target in the list of
-    \l{qmake Variable Reference#PRE_TARGETDEPS}{PRE_TARGETDEPS}.
-
-    The following tables are an overview of the options available to you with
-    the QMAKE_EXTRA_TARGETS variable.
-
-    \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.  See the CONFIG table for details.
-    \row
-        \li depends
-        \li The existing build targets that the custom build target depends on.
-    \row
-        \li recurse
-        \li Specifies which sub-targets should used when creating the rules in the Makefile to call in
-           the sub-target specific Makefile.  This is only used when \c recursive is set in the CONFIG.
-    \row
-        \li recurse_target
-        \li Specifies the target that should be built via the sub-target Makefile for the rule in the Makefile.
-           This adds something like $(MAKE) -f Makefile.[subtarget] [recurse_target].  This is only used when
-           \c recursive is set in the CONFIG.
-    \row
-        \li target
-        \li The file being created by the custom build target.
-    \endtable
-
-    List of members specific to the CONFIG option:
-
-    \table
-    \header
-        \li Member
-        \li Description
-    \row
-        \li recursive
-        \li Indicates that rules should be created in the Makefile and thus call
-           the relevant target inside the sub-target specific Makefile.  This defaults to creating
-           an entry for each of the sub-targets.
-    \endtable
-
-    For convenience, there is also a method of customizing projects
-    for new compilers or preprocessors:
-
-    \snippet doc/src/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 commands 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, \l{qmake Manual#qmake}{\c qmake} will execute
-    \c depend_command to generate dependency information, and place this
-    information in the project as well.
-
-    These commands can easily be placed into a cache file, allowing subsequent
-    project files to add arguments to \c NEW_HEADERS.
-
-    The following tables are an overview of the options available to you with the QMAKE_EXTRA_COMPILERS
-    variable.
-
-    \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) then 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 contains 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 variable_out
-        \li The variable that the files created from the output should be added to.
-    \endtable
-
-    List of members specific to the CONFIG option:
-
-    \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) then 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 contains 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 refered 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
-
-    List of members specific to the CONFIG option:
-
-    \table
-    \header
-        \li Member
-        \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 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
-
 */
 
 /*!
-    \page qmake-advanced-usage.html
-    \title qmake Advanced Usage
+    \page qmake-language.html
+    \title qmake Language
     \contentspage {qmake Manual}{Contents}
-    \previouspage qmake Platform Notes
-    \nextpage Using Precompiled Headers
+    \previouspage Platform Notes
+    \nextpage Advanced Usage
 
-    Many \l{qmake Manual#qmake}{\c qmake} project files simply describe the
+    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.
-    \l{qmake Manual#qmake}{\c qmake} also provides other operators, functions,
+    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.
 
-    \tableofcontents
-
     \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
-    \l{qmake Manual#qmake}{\c qmake} defines certain variables using default
+    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 operators can be
-    used to manipulate the contents of variables.
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 89
 
-    The above line sets the \c TARGET variable to \c myapp. This will overwrite any
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 90
@@ -3967,6 +3259,8 @@
     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 doc/src/snippets/code/doc_src_qmake-manual.pro 91
@@ -3974,6 +3268,8 @@
     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:
@@ -3981,11 +3277,12 @@
     \snippet doc/src/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 variables only contains one
+    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:
 
@@ -3994,18 +3291,59 @@
     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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 Syntax
+    \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:
@@ -4013,32 +3351,30 @@
     \snippet doc/src/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; see below
-    for examples.
+    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:
+    contained within a pair of braces. For example:
 
     \snippet doc/src/snippets/qmake/scopes.pro 0
 
     The above code will add the \c paintwidget_win.cpp file to the sources listed
-    in the generated Makefile if \l{qmake Manual#qmake}{\c qmake} is used on a
-    Windows platform. If \l{qmake Manual#qmake}{\c qmake} is used on a
-    platform other than Windows, the define will be ignored.
+    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, suppose we want to process
-    something on all platforms \e except for Windows. We can achieve this by
-    negating the scope like this:
+    original condition is false. For example, to process something when building
+    for all platforms \e except Windows, negate the scope like this:
 
     \snippet doc/src/snippets/qmake/scopes.pro 1
 
-    Scopes can be nested to combine more than one condition. For instance, if
-    you want to include a particular file for a certain platform only if
-    debugging is enabled then you write the following:
+    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 doc/src/snippets/qmake/scopes.pro 2
 
@@ -4049,12 +3385,12 @@
     \snippet doc/src/snippets/qmake/scopes.pro 3
 
     You may also use the \c : operator to perform single line conditional
-    assignments; for example:
+    assignments. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 95
 
-    The above line adds \c USE_MY_STUFF to the \c DEFINES variable only on the
-    Windows platform.
+    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.
 
@@ -4073,9 +3409,8 @@
 
     \section2 Configuration and Scopes
 
-    The values stored in the
-    \l{qmake-project-files.html#GeneralConfiguration}{\c CONFIG variable} are
-    treated specially by \l{qmake Manual#qmake}{\c qmake}. Each of the possible
+    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:
 
@@ -4115,18 +3450,19 @@
     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
-    \l{qmake Manual#qmake}{\c qmake} uses when generating Makefiles, such as
-    \c DEFINES, \c SOURCES, and \c HEADERS. It is possible for you to create
-    variables for your own use; \l{qmake Manual#qmake}{\c qmake} creates new
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 97
 
-    There are no restricitions on what you do to your own variables, as \c
+    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.
 
@@ -4147,76 +3483,38 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 100
 
-    Variables can be used to store the contents of environment variables.
-    These can be evaluated at the time that \l{qmake Manual#qmake}{\c qmake}
-    is run, or included in the generated Makefile for evaluation when the
-    project is built.
+    \target UsingReplaceFunctions
+    \section1 Replace Functions
 
-    To obtain the contents of an environment value when
-    \l{qmake Manual#qmake}{\c qmake}is run, use the \c $$(...) operator:
-
-    \snippet doc/src/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 doc/src/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.
-
-    The special \c $$[...] operator can be used to access various
-    configuration options that were set when Qt was built:
-
-    \snippet doc/src/snippets/qmake/qtconfiguration.pro 0
-
-    The variables accessible with this operator are typically used to
-    enable third party plugins and components to be integrated with 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 doc/src/snippets/code/doc_src_qmake-manual.pro 101
-
-    \target VariableProcessingFunctions
-    \section1 Variable Processing Functions
-
-    \l{qmake Manual#qmake}{\c qmake} provides a selection of built-in
+    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. In order to assign a result to a variable,
-    it is necessary to use the \c $$ operator with this type of function in
-    the same way used to assign contents of one variable to another:
+    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 doc/src/snippets/qmake/functions.pro 1
 
     This type of function should be used on the right-hand side of
-    assignments (i.e, as an operand).
+    assignments (that is, as an operand).
 
-    It is possible to define your own functions for processing the
-    contents of variables. These functions can be defined in the following
-    way:
+    You can define your own functions for processing the contents of variables
+    as follows:
 
     \snippet doc/src/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{qmake-function-reference.html}{eval()} built-in function,
-    and compiles a list of files:
+    \l{eval(string)}{eval()} built-in function, and compiles a list of files:
 
     \snippet doc/src/snippets/qmake/replacefunction.pro 0
 
-    \target ConditionalFunctions
-    \section1 Conditional Functions
+    \target UsingTestFunctions
+    \section1 Test Functions
 
-    \l{qmake Manual#qmake}{\c qmake} provides built-in functions that can be
+    qmake provides built-in functions that can be
     used as conditions when writing scopes. These functions do not return a
-    value, but instead indicate "success" or "failure":
+    value, but instead indicate \e success or \e failure:
 
     \snippet doc/src/snippets/qmake/functions.pro 3
 
@@ -4228,21 +3526,33 @@
     exists and returns true if they all exist, or false if not:
 
     \snippet doc/src/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
 
-    \l{qmake Manual#qmake}{\c qmake} lets you create your own \e features that
+    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 \c CONFIG variable. Features are collections 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 \l{qmake Manual#qmake}{\c qmake} checks
+    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;
-       this contains a colon-separated list of directories.
-    \li In a directory listed in the \c QMAKEFEATURES property variable; this
+    \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
@@ -4250,15 +3560,16 @@
     \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 (a colon-separated list
-       of directories). (\c{$QMAKEPATH/mkspecs/<features>})
+       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
-       \c QMAKESPEC environment variable. (\c{$QMAKESPEC/<features>})
+       \l{QMAKESPEC} environment variable. For example: \c{$QMAKESPEC/<features>}.
     \li In a features directory residing in the \c data_install/mkspecs directory.
-       (\c{data_install/mkspecs/<features>})
+       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.
-       (\c{$QMAKESPEC/../<features>})
+       For example: \c{$QMAKESPEC/../<features>}.
     \endlist
 
     The following features directories are searched for features files:
@@ -4274,7 +3585,7 @@
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 103
 
     With this addition to the \c CONFIG variable,
-    \l{qmake Manual#qmake}{\c qmake} will search the locations listed above for
+    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:
 
@@ -4297,27 +3608,278 @@
 
     \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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 doc/src/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 qmake Advanced Usage
-    \nextpage Configuring qmake's Environment
+    \previouspage Advanced Usage
+    \nextpage Configuring qmake
 
     \target Introduction
 
-    Precompiled headers are a performance feature supported by some
+    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.
 
-    \l{qmake Manual#qmake}{\c qmake} supports the use of precompiled headers
-    (PCH) on some platforms and build environments, including:
+    qmake supports the use of precompiled headers
+    on some platforms and build environments, including:
     \list
     \li Windows
         \list
@@ -4338,38 +3900,33 @@
     \target ADD_PCH
     \section1 Adding Precompiled Headers to Your Project
 
-    \target PCH_CONTENTS
-    \section2 Contents of the Precompiled Header File
-
     The precompiled header must contain code which is \e stable
-    and \e static throughout your project. A typical PCH might look
-    like this:
-
-    \section3 Example: \c stable.h
+    and \e static throughout your project. A typical precompiled header might
+    look like this:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.cpp 104
 
-    Note that a precompiled header file needs to separate C includes from
+    \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 PCH, you only need to define the
-    \c PRECOMPILED_HEADER variable in your project file:
+    To make your project use precompiled headers, you only need to define the
+    \l{PRECOMPILED_HEADER} variable in your project file:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 105
 
-    \l{qmake Manual#qmake}{\c qmake} will handle the rest, to ensure the
+    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
-    \l{qmake Manual#qmake}{\c qmake} will do this if the configuration
-    supports PCH.
+    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 PCH.
+    conditional blocks in your project file to add settings when using
+    precompiled headers.
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 106
@@ -4383,8 +3940,8 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 107
 
-    To avoid potential conflicts like these, it is good practice to ensure
-    that header files that will be precompiled are given distinctive names.
+    To avoid potential conflicts like these, give distinctive names to header
+    files that will be precompiled.
 
     \target EXAMPLE_PROJECT
     \section1 Example Project
@@ -4517,14 +4074,13 @@
 
 /*!
     \page qmake-tutorial.html
-    \title qmake Tutorial
+    \title Getting Started
     \contentspage {qmake Manual}{Contents}
-    \previouspage qmake Manual
-    \nextpage qmake Common Projects
+    \previouspage Overview
+    \nextpage Creating Project Files
 
-    This tutorial teaches you how to use \l{qmake Manual#qmake}{\c qmake}. We
-    recommend that you read the \l{qmake Manual#qmake}{\c qmake} user guide
-    after completing this tutorial.
+    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
 
@@ -4542,11 +4098,11 @@
     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 \l{qmake Manual#qmake}{\c qmake} about the source and
+    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{qmake Variable Reference#SOURCES}{SOURCES} variable.
+    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:
 
@@ -4564,16 +4120,15 @@
 
     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{qmake Variable Reference#HEADERS}{HEADERS}.
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 111
 
-    The target name is set automatically; it is the same as the project
-    file, but with the suffix appropriate to the platform. For example, if
+    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:
@@ -4584,34 +4139,34 @@
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 113
 
-    You can now use \l{qmake Manual#qmake}{\c qmake} to generate a Makefile
-    for your application. On the command line, in your project's directory,
+    You can now use qmake to generate a Makefile
+    for your application. On the command line, in your project directory,
     type the following:
 
     \snippet doc/src/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, \l{qmake Manual#qmake}{\c qmake} can also
-    generate Visual Studio project files, for example:
+    For Visual Studio users, qmake can also generate Visual Studio project
+    files. For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 115
 
     \section1 Making an Application Debuggable
 
-    The release version of an application doesn't contain any debugging
-    symbols or other debugging information. During development it is useful
+    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
-    \c CONFIG variable in the project file.
+    \l{CONFIG} variable in the project file.
 
     For example:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 116
 
-    Use \l{qmake Manual#qmake}{\c qmake} as before to generate a Makefile and
-    you will be able to obtain useful information about your application when
-    running it in a debugging environment.
+    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
 
@@ -4619,61 +4174,59 @@
     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 can't just add these to the \c SOURCES
-    variable since this will put both files in the Makefile. So, what we
+    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 \l{qmake Manual#qmake}{\c qmake} is run on.
+    which platform we are building for.
 
-    A simple scope that will add in the platform-dependent file for
+    A simple scope that adds the platform-dependent file for
     Windows looks like this:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 117
 
-    So if \l{qmake Manual#qmake}{\c qmake} is run on Windows, it will add
-    \c hellowin.cpp to the list of source files. If
-    \l{qmake Manual#qmake}{\c qmake} is run on any other platform, it
-    will simply ignore it. Now all that is left to be done is to create a
-    scope for the Unix-specific file.
+    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 now look
+    When you have done that, your project file should look
     something like this:
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 118
 
-    Use \l{qmake Manual#qmake}{\c qmake} as before to generate a Makefile.
+    Use qmake as before to generate a Makefile.
 
-    \section1 Stopping qmake If a File Doesn't Exist
+    \section1 Stopping qmake If a File Does Not Exist
 
-    You may not want to create a Makefile if a certain file doesn't exist.
-    We can check if a file exists by using the exists() function.  We can
-    stop \l{qmake Manual#qmake}{\c qmake} from processing by using the error()
-    function. This works in the same way as scopes do. Simply replace the
-    scope condition with the function. A check for a \c main.cpp file looks
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 119
 
-    The \c{!} symbol is used to negate the test; i.e. \c{exists( main.cpp )}
+    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 doesn't exist.
+    file does not exist.
 
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 120
 
-    Use \l{qmake Manual#qmake}{\c qmake} as before to generate a makefile.
+    Use qmake as before to generate a makefile.
     If you rename \c main.cpp temporarily, you will see the message and
-    \l{qmake Manual#qmake}{\c qmake} will stop processing.
+    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 qDebug() when you run your application on the command line.
-    Unless you build your application with the appropriate console setting,
-    you won't see the output. We can easily put \c console on the \c CONFIG
-    line so that on Windows the makefile will have this setting. However,
-    let's say that we only want to add the \c CONFIG line if we are running
+    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; just create one scope, then create
-    the other inside it. Put the settings to be processed inside the last
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 121
@@ -4684,21 +4237,21 @@
     \snippet doc/src/snippets/code/doc_src_qmake-manual.pro 122
 
     That's it! You have now completed the tutorial for
-    \l{qmake Manual#qmake}{\c qmake}, and are ready to write project files for
+    qmake, and are ready to write project files for
     your development projects.
 */
 
 /*!
     \page qmake-common-projects.html
-    \title qmake Common Projects
+    \title Building Common Project Types
     \contentspage {qmake Manual}{Contents}
-    \previouspage qmake Tutorial
-    \nextpage Using qmake
+    \previouspage Creating Project Files
+    \nextpage Running qmake
 
-    This chapter describes how to set up \l{qmake Manual#qmake}{\c qmake}
-    project files for three common project types that are based on Qt.
-    Although all kinds of projects use many of the same variables, each of
-    them use project-specific variables to customize output files.
+    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
@@ -4707,12 +4260,10 @@
     \target Application
     \section1 Building an Application
 
-    \section2 The app Template
-
-    The \c app template tells \l{qmake Manual#qmake}{\c qmake} to generate a
+    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
-    \c CONFIG variable definition:
+    \l{CONFIG} variable definition:
 
     \table
     \header \li Option  \li Description
@@ -4722,55 +4273,60 @@
     \row    \li testcase \li The application is \l{Building a Testcase}{an automated test}.
     \endtable
 
-    When using this template the following \l{qmake Manual#qmake}{\c qmake}
+    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 HEADERS - A list of all the header files for the application.
-    \li SOURCES - A list of all the source files for the application.
-    \li FORMS - A list of all the UI files (created using \c{Qt Designer})
-    for the application.
-    \li LEXSOURCES - A list of all the lex source files for the application.
-    \li YACCSOURCES - A list of all the yacc source files for the application.
-    \li TARGET - Name of the executable for the application. This defaults
+    \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 DESTDIR - The directory in which the target executable is placed.
-    \li DEFINES - A list of any additional pre-processor defines needed for the application.
-    \li INCLUDEPATH - A list of any additional include paths needed for the application.
-    \li DEPENDPATH - The dependency search path for the application.
-    \li VPATH - The search path to find supplied files.
-    \li DEF_FILE - Windows only: A .def file to be linked against for the application.
-    \li RC_FILE - Windows only: A resource file for the application.
-    \li RES_FILE - Windows only: A resource file to be linked against for the application.
+    \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
-    instance, if you do not have any extra INCLUDEPATHs then you do not need
-    to specify any, \l{qmake Manual#qmake}{\c qmake} will add in the default
-    ones needed. For instance, an example project file might look like this:
+    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 doc/src/snippets/code/doc_src_qmake-manual.pro 123
 
-    For items that are single valued, e.g. the template or the destination
+    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 item's
-    value with the new value, for example if we wrote \c{DEFINES=USE_MY_STUFF},
-    all other definitions would be deleted.
+    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.
 
-    \section2 Building a Testcase
+    \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, \l{qmake Manual#qmake}{\c qmake} will insert a \c check
+    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{qmake Variable Reference#SUBDIRS}{SUBDIRS} projects. This means it is
+    \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.
 
@@ -4790,11 +4346,11 @@
         \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 \e{-o filename,format} option supported by
+            from the test (such as the \c{-o filename,format} option supported by
             \l{QTestLib}).
     \endtable
 
-    Note that these must be set while invoking the \c make tool, and not set in the
+    \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:
 
@@ -4819,59 +4375,57 @@
 
     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 primary requirement is only that the test program exit with a zero exit code
+    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
 
-    \section2 The lib Template
-
-    The \c lib template tells \l{qmake Manual#qmake}{\c qmake} to generate a
-    Makefile that will build a library.  When using this template, in addition
-    to the system variables mentioned above for the \c app template the
-    \c VERSION variable is supported. You should use these in your .pro file
-    to specify information about the 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
-    \c CONFIG variable to determine the type of library that is built:
+    \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; this also enables the dll option.
+    \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.
+    \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,
+    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 \l{qmake Manual#qmake}{\c qmake} to generate a
+    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 \c VERSION variable is used to specify information about the plugin.
+    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.
+    \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 project's \c CONFIG
+    settings can be enabled by adding \c designer to the \l{Variables#QT}{QT}
     variable. For example:
 
     \code
@@ -4883,13 +4437,13 @@
     \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 \c CONFIG variable can hold both \c debug and \c 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 your project's \c CONFIG definition:
+    \c debug_and_release option to the \c CONFIG variable:
 
     \snippet doc/src/snippets/qmake/debug_and_release.pro 0
     \snippet doc/src/snippets/qmake/debug_and_release.pro 1
@@ -4898,7 +4452,7 @@
     ensure that the resulting targets have different names. Providing different
     names for targets ensures that one will not overwrite the other.
 
-    When \l{qmake Manual#qmake}{\c qmake} processes the project file, it will
+    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:
 
@@ -4922,7 +4476,7 @@
 
     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 to the one used on Unix platforms:
+    different convention on Windows from the one used on Unix platforms:
 
     \omit
     Note: This was originally used in the customwidgetplugin.pro file, but is
@@ -4932,7 +4486,7 @@
 
     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
+    added to the scope to do the same for release mode. Left as it is, the
     target name remains unmodified.
 */
 
diff --git a/doc/src/snippets/code/doc_src_qmake-manual.pro b/doc/src/snippets/code/doc_src_qmake-manual.pro
index 0f95d767..0ee47858 100644
--- a/doc/src/snippets/code/doc_src_qmake-manual.pro
+++ b/doc/src/snippets/code/doc_src_qmake-manual.pro
@@ -90,7 +90,7 @@ qmake -makefile [options] files
 
 
 #! [10]
-qmake -makefile -unix -o Makefile "CONFIG+=test" test.pro
+qmake -makefile -o Makefile "CONFIG+=test" test.pro
 #! [10]
 
 
@@ -271,13 +271,6 @@ win32:OBJECTS_DIR = c:/myproject/tmp
 #! [41]
 
 
-#! [42]
-app {
-    # Conditional code for 'app' template here
-}
-#! [42]
-
-
 #! [43]
 FRAMEWORK_HEADERS.version = Versions
 FRAMEWORK_HEADERS.files = path/to/header_one.h path/to/header_two.h
@@ -296,11 +289,6 @@ QMAKE_RESOURCE_FLAGS += -threshold 0 -compress 9
 #! [45]
 
 
-#! [46]
-QMAKE_UIC = uic -L /path/to/plugin
-#! [46]
-
-
 #! [47]
 QT -= gui # Only the core module is used.
 #! [47]
@@ -350,18 +338,6 @@ win32:UI_DIR = c:/myproject/ui
 #! [54]
 
 
-#! [55]
-unix:UI_HEADERS_DIR = ../myproject/ui/include
-win32:UI_HEADERS_DIR = c:/myproject/ui/include
-#! [55]
-
-
-#! [56]
-unix:UI_SOURCES_DIR = ../myproject/ui/src
-win32:UI_SOURCES_DIR = c:/myproject/ui/src
-#! [56]
-
-
 #! [57]
 VERSION = 1.2.3
 #! [57]
@@ -472,21 +448,16 @@ ARGS = $$unique(ARGS) #1 2 3 5
 
 
 #! [74]
-qmake -set VARIABLE VALUE
+qmake -set PROPERTY VALUE
 #! [74]
 
 
 #! [75]
-qmake -query VARIABLE
-qmake -query #queries all current VARIABLE/VALUE pairs..
+qmake -query PROPERTY
+qmake -query #queries all current PROPERTY/VALUE pairs
 #! [75]
 
 
-#! [76]
-qmake -query "1.06a/VARIABLE"
-#! [76]
-
-
 #! [77]
 qmake -query "QT_INSTALL_PREFIX"
 #! [77]
diff --git a/doc/src/snippets/qmake/scopes.pro b/doc/src/snippets/qmake/scopes.pro
index 4e59afba..63b9b3aa 100644
--- a/doc/src/snippets/qmake/scopes.pro
+++ b/doc/src/snippets/qmake/scopes.pro
@@ -23,14 +23,14 @@ unix {
 
 #! [2]
 macx {
-    debug {
+    CONFIG(debug, debug|release) {
         HEADERS += debugging.h
     }
 }
 #! [2]
 
 #! [3]
-macx:debug {
+macx:CONFIG(debug, debug|release) {
     HEADERS += debugging.h
 }
 #! [3]