En esta página

Lenguaje qmake

Muchos archivos de proyecto de qmake se limitan a describir los archivos fuente y de cabecera utilizados por el proyecto, mediante una lista de definiciones de tipo « name = value » y « name += value ». qmake también ofrece otros operadores, funciones y ámbitos que pueden utilizarse para procesar la información proporcionada en las declaraciones de variables. Estas funciones avanzadas permiten generar Makefiles para múltiples plataformas a partir de un único archivo de proyecto.

Operadores

En muchos archivos de proyecto, los operadores de asignación (=) y de anexión (+=) pueden utilizarse para incluir toda la información sobre un proyecto. El patrón típico de uso consiste en asignar una lista de valores a una variable y añadir más valores en función del resultado de diversas comprobaciones. Dado que qmake define ciertas variables con valores por defecto, a veces es necesario utilizar el operador de eliminación (-=) para filtrar los valores que no son necesarios. En las secciones siguientes se describe cómo utilizar los operadores para manipular el contenido de las variables.

Asignación de valores

El operador « = » asigna un valor a una variable:

TARGET = myapp

La línea anterior establece la variable TARGET en myapp. Esto sobrescribirá cualquier valor establecido previamente para TARGET con myapp.

Añadir valores

El operador += añade un nuevo valor a la lista de valores de una variable:

DEFINES += USE_MY_STUFF

La línea anterior añade « USE_MY_STUFF » a la lista de definiciones del preprocesador que se incluirán en el Makefile generado.

Eliminación de valores

El operador -= elimina un valor de la lista de valores de una variable:

DEFINES -= USE_MY_STUFF

La línea anterior elimina « USE_MY_STUFF » de la lista de definiciones del preprocesador que se incluirán en el Makefile generado.

Añadir valores únicos

El operador ` *= ` añade un valor a la lista de valores de una variable, pero solo si aún no está presente. Esto evita que los valores se incluyan varias veces en una variable. Por ejemplo:

DEFINES *= USE_MY_STUFF

En la línea anterior, « USE_MY_STUFF » solo se añadirá a la lista de definiciones del preprocesador si aún no está definido. Ten en cuenta que la función «unique()» también se puede utilizar para garantizar que una variable solo contenga una instancia de cada valor.

Sustitución de valores

El operador ` ~= ` sustituye cualquier valor que coincida con una expresión regular por el valor especificado:

DEFINES ~= s/QT_[DT].+/QT

En la línea anterior, cualquier valor de la lista que comience por QT_D o QT_T se sustituye por QT.

Expansión de variables

El operador $$ se utiliza para extraer el contenido de una variable y puede emplearse para pasar valores entre variables o proporcionarlos a funciones:

EVERYTHING = $$SOURCES $$HEADERS
message("The project contains the following files:")
message($$EVERYTHING)

Las variables se pueden utilizar para almacenar el contenido de las variables de entorno. Estas se pueden evaluar en el momento en que se ejecuta qmake, o incluirse en el Makefile generado para su evaluación cuando se compila el proyecto.

Para obtener el contenido de un valor de entorno cuando se ejecuta qmake, utiliza el operador « $$(...) »:

DESTDIR = $$(PWD)
message(The project will be installed in $$DESTDIR)

En la asignación anterior, el valor de la variable de entorno ` PWD ` se lee cuando se procesa el archivo del proyecto.

Para obtener el contenido de un valor de entorno en el momento en que se procesa el Makefile generado, utilice el operador « $(...) »:

DESTDIR = $$(PWD)
message(The project will be installed in $$DESTDIR)

DESTDIR = $(PWD)
message(The project will be installed in the value of PWD)
message(when the Makefile is processed.)

En la asignación anterior, el valor de PWD se lee inmediatamente al procesar el archivo de proyecto, pero en el Makefile generado se asigna $(PWD) a DESTDIR. Esto hace que el proceso de compilación sea más flexible, siempre y cuando la variable de entorno esté configurada correctamente en el momento de procesar el Makefile.

Acceso a las propiedades de qmake

El operador especial $$[...] se puede utilizar para acceder a las propiedades de qmake:

message(Qt version: $$[QT_VERSION])
message(Qt is installed in $$[QT_INSTALL_PREFIX])
message(Qt resources can be found in the following locations:)
message(Documentation: $$[QT_INSTALL_DOCS])
message(Header files: $$[QT_INSTALL_HEADERS])
message(Libraries: $$[QT_INSTALL_LIBS])
message(Binary files (executables): $$[QT_INSTALL_BINS])
message(Plugins: $$[QT_INSTALL_PLUGINS])
message(Data files: $$[QT_INSTALL_DATA])
message(Translation files: $$[QT_INSTALL_TRANSLATIONS])
message(Settings: $$[QT_INSTALL_CONFIGURATION])
message(Examples: $$[QT_INSTALL_EXAMPLES])

Para obtener más información, consulta «Configuración de qmake».

Las propiedades a las que se puede acceder con este operador se utilizan normalmente para permitir la integración en Qt de complementos y componentes de terceros. Por ejemplo, se puede instalar un complemento « Qt Widgets Designer » junto con los complementos integrados de « Qt Widgets Designer » si se incluye la siguiente declaración en su archivo de proyecto:

target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target

Ámbitos

Los ámbitos son similares a las sentencias « if » de los lenguajes de programación procedimentales. Si se cumple una determinada condición, se procesan las declaraciones contenidas dentro del ámbito.

Sintaxis de los ámbitos

Los ámbitos consisten en una condición seguida de una llave de apertura en la misma línea, una secuencia de comandos y definiciones, y una llave de cierre en una nueva línea:

<condition> {
    <command or definition>
    ...
}

La llave de apertura debe escribirse en la misma línea que la condición. Los ámbitos pueden concatenarse para incluir más de una condición, tal y como se describe en las secciones siguientes.

Ámbitos y condiciones

Un ámbito se escribe como una condición seguida de una serie de declaraciones contenidas entre un par de llaves. Por ejemplo:

win32 {
    SOURCES += paintwidget_win.cpp
}

El código anterior añadirá el archivo paintwidget_win.cpp a las fuentes enumeradas en el Makefile generado al compilar para una plataforma Windows. Al compilar para otras plataformas, la definición se ignorará.

Las condiciones utilizadas en un ámbito determinado también pueden negarse para proporcionar un conjunto alternativo de declaraciones que se procesarán únicamente si la condición original es falsa. Por ejemplo, para procesar algo al compilar para todas las plataformas excepto Windows, niega el ámbito de la siguiente manera:

!win32 {
    SOURCES -= paintwidget_win.cpp
}

Los ámbitos se pueden anidar para combinar más de una condición. Por ejemplo, para incluir un archivo concreto para una plataforma determinada solo si la depuración está habilitada, escribe lo siguiente:

macx {
    CONFIG(debug, debug|release) {
        HEADERS += debugging.h
    }
}

Para evitar tener que escribir muchos ámbitos anidados, puedes anidar ámbitos utilizando el operador « : ». Los ámbitos anidados del ejemplo anterior se pueden reescribir de la siguiente manera:

macx:CONFIG(debug, debug|release) {
    HEADERS += debugging.h
}

También puedes utilizar el operador « : » para realizar asignaciones condicionales en una sola línea. Por ejemplo:

win32:DEFINES += USE_MY_STUFF

La línea anterior añade « USE_MY_STUFF » a la variable DEFINES solo cuando se compila para la plataforma Windows. En general, el operador « : » se comporta como un operador lógico «AND», uniendo varias condiciones y exigiendo que todas ellas sean verdaderas.

También existe el operador ` | `, que actúa como un operador lógico «OR», uniendo varias condiciones y exigiendo que solo una de ellas sea verdadera.

win32|macx {
    HEADERS += debugging.h
}

Si necesitas combinar ambos operadores, puedes utilizar la función « if » para especificar la precedencia de los operadores.

if(win32|macos):CONFIG(debug, debug|release) {
    # Do something on Windows and macOS,
    # but only for the debug configuration.
}
win32|if(macos:CONFIG(debug, debug|release)) {
    # Do something on Windows (regardless of debug or release)
    # and on macOS (only for debug).
}

La condición admite el carácter comodín para coincidir con una familia de valores « CONFIG » o nombres «mkspec».

win32-* {
    # Matches every mkspec starting with "win32-"
    SOURCES += win32_specific.cpp
}

Nota: Históricamente , comprobar el nombre de mkspec con comodines como se ha indicado anteriormente era la forma que tenía qmake de verificar la plataforma. Hoy en día, recomendamos utilizar valores definidos por el mkspec en la variable ` QMAKE_PLATFORM `.

También puedes proporcionar declaraciones alternativas a las que se encuentran dentro de un ámbito utilizando un ámbito « else ». Cada ámbito « else » se procesa si las condiciones de los ámbitos anteriores son falsas. Esto te permite escribir comprobaciones complejas cuando se combina con otros ámbitos (separados por el operador « : », como se ha mostrado anteriormente). Por ejemplo:

win32:xml {
    message(Building for Windows)
    SOURCES += xmlhandler_win.cpp
} else:xml {
    SOURCES += xmlhandler.cpp
} else {
    message("Unknown configuration")
}

Configuración y ámbitos

qmake trata de forma especial los valores almacenados en la variable CONFIG. Cada uno de los valores posibles puede utilizarse como condición para un ámbito. Por ejemplo, la lista de valores que contiene CONFIG puede ampliarse con el valor opengl:

CONFIG += opengl

Como resultado de esta operación, se procesarán todos los ámbitos que comprueben si cumple « opengl ». Podemos utilizar esta característica para asignar al ejecutable final un nombre adecuado:

opengl {
    TARGET = application-gl
} else {
    TARGET = application
}

Esta característica facilita cambiar la configuración de un proyecto sin perder todos los ajustes personalizados que puedan ser necesarios para una configuración específica. En el código anterior, se procesan las declaraciones del primer ámbito, y el ejecutable final se llamará application-gl. Sin embargo, si no se especifica opengl, se procesarán en su lugar las declaraciones del segundo ámbito, y el ejecutable final se llamará application.

Dado que es posible introducir tus propios valores en la línea « CONFIG », esto te ofrece una forma cómoda de personalizar los archivos de proyecto y ajustar con precisión los Makefiles generados.

Valores del ámbito de la plataforma

Además de los valores « win32 », « macx » y « unix » utilizados en muchas condiciones de ámbito, se pueden comprobar con los ámbitos otros valores integrados específicos de la plataforma y del compilador. Estos se basan en las especificaciones de plataforma proporcionadas en el directorio « mkspecs » de Qt. Por ejemplo, las siguientes líneas de un archivo de proyecto muestran la especificación actual en uso y comprueban la especificación « linux-g++ »:

message($$QMAKESPEC)

linux-g++ {
    message(Linux)
}

Se puede comprobar cualquier otra combinación de plataforma y compilador, siempre que exista una especificación correspondiente en el directorio mkspecs.

Variables

Muchas de las variables utilizadas en los archivos de proyecto son variables especiales que qmake utiliza al generar Makefiles, como DEFINES, SOURCES y HEADERS. Además, puedes crear variables para tu propio uso. qmake crea nuevas variables con un nombre determinado cuando encuentra una asignación a ese nombre. Por ejemplo:

MY_VARIABLE = value

No hay restricciones sobre lo que se pueda hacer con las variables propias, ya que qmake las ignorará a menos que necesite evaluarlas al procesar un ámbito.

También puedes asignar el valor de una variable actual a otra variable anteponiendo $$ al nombre de la variable. Por ejemplo:

MY_DEFINES = $$DEFINES

Ahora la variable MY_DEFINES contiene lo que hay en la variable DEFINES en este punto del archivo de proyecto. Esto también equivale a:

MY_DEFINES = $${DEFINES}

La segunda notación te permite añadir el contenido de la variable a otro valor sin separar ambos con un espacio. Por ejemplo, lo siguiente garantizará que al ejecutable final se le asigne un nombre que incluya la plantilla de proyecto que se está utilizando:

TARGET = myproject_$${TEMPLATE}

Funciones de sustitución

qmake proporciona una selección de funciones integradas que permiten procesar el contenido de las variables. Estas funciones procesan los argumentos que se les proporcionan y devuelven un valor, o una lista de valores, como resultado. Para asignar un resultado a una variable, utiliza el operador $$ con este tipo de función, tal y como lo harías para asignar el contenido de una variable a otra:

HEADERS = model.h
HEADERS += $$OTHER_HEADERS
HEADERS = $$unique(HEADERS)

Este tipo de función debe utilizarse en el lado derecho de las asignaciones (es decir, como operando).

Puedes definir tus propias funciones para procesar el contenido de las variables de la siguiente manera:

defineReplace(functionName){
    #function code
}

La siguiente función de ejemplo toma un nombre de variable como único argumento, extrae una lista de valores de la variable mediante la función integrada `eval() ` y compila una lista de archivos:

defineReplace(headersAndSources) {
    variable = $$1
    names = $$eval($$variable)
    headers =
    sources =

    for(name, names) {
        header = $${name}.h
        exists($$header) {
            headers += $$header
        }
        source = $${name}.cpp
        exists($$source) {
            sources += $$source
        }
    }
    return($$headers $$sources)
}

Funciones de prueba

qmake proporciona funciones integradas que pueden utilizarse como condiciones al escribir ámbitos. Estas funciones no devuelven un valor, sino que indican si la operación se ha realizado con éxito o ha fallado:

count(options, 2) {
    message(Both release and debug specified.)
}

Este tipo de función solo debe utilizarse en expresiones condicionales.

Es posible definir tus propias funciones para establecer condiciones en los ámbitos. El siguiente ejemplo comprueba si existen todos los archivos de una lista y devuelve «true» si todos existen, o «false» en caso contrario:

defineTest(allFiles) {
    files = $$ARGS

    for(file, files) {
        !exists($$file) {
            return(false)
        }
    }
    return(true)
}

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.