QMake - comment copier un fichier sur la sortie

Vous pouvez utiliser un qmake fonction de réutilisabilité:

# Copies the given files to the destination directory
defineTest(copyToDestdir) {
    files = $$1

    for(FILE, files) {
        DDIR = $$DESTDIR

        # Replace slashes in paths with backslashes for Windows
        win32:FILE ~= s,/,\\,g
        win32:DDIR ~= s,/,\\,g

        QMAKE_POST_LINK += $$QMAKE_COPY $$quote($$FILE) $$quote($$DDIR) $$escape_expand(\\n\\t)
    }

    export(QMAKE_POST_LINK)
}

de l'utiliser ensuite comme suit:

copyToDestdir($$OTHER_FILES) # a variable containing multiple paths
copyToDestdir(run.sh) # a single filename
copyToDestdir(run.sh README) # multiple files

Qt 5.6 ajouté cela comme une fonctionnalité non documentée:

CONFIG += file_copies

Inventer un nom pour décrire les fichiers que vous souhaitez copier:

COPIES += myDocumentation

Liste les fichiers que vous souhaitez copier, dans son .files membre:

myDocumentation.files = $$files(text/docs/*.txt)

Spécifier le chemin d'accès de destination dans le .path membre:

myDocumentation.path = $$OUT_PWD/documentation

Éventuellement spécifier un chemin d'accès de base à être coupé à partir de la source chemins:

myDocumentation.base = $$PWD/text/docs

Il fonctionne en fait en faisant les mêmes choses que de nombreuses autres réponses ici. Voir file_copies.prf pour les détails sanglants.

L'interface est très similaire à celle pour INSTALLE.

Créer un fichier copy_files.prf dans un des chemins qui utilise qmake pour config caractéristiques. Le fichier devrait ressembler à ceci:

QMAKE_EXTRA_COMPILERS += copy_files
copy_files.name = COPY
copy_files.input = COPY_FILES
copy_files.CONFIG = no_link

copy_files.output_function = fileCopyDestination
defineReplace(fileCopyDestination) {
    return($$shadowed($$1))
}

win32:isEmpty(MINGW_IN_SHELL) {
    # Windows shell
    copy_files.commands = copy /y ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
    TOUCH = copy /y nul
}
else {
    # Unix shell
    copy_files.commands = mkdir -p `dirname ${QMAKE_FILE_OUT}` && cp ${QMAKE_FILE_IN} ${QMAKE_FILE_OUT}
    TOUCH = touch
}

QMAKE_EXTRA_TARGETS += copy_files_cookie
copy_files_cookie.target = copy_files.cookie
copy_files_cookie.depends = compiler_copy_files_make_all

win32:!mingw {
    # NMake/MSBuild
    copy_files_cookie.commands = $$TOUCH $** && $$TOUCH $@
}
else {
    # GNU Make
    copy_files_cookie.commands = $$TOUCH $<  && $$TOUCH $@
}

PRE_TARGETDEPS += $${copy_files_cookie.target}

Comment il fonctionne

La première partie définit un extra compilateur qui va lire l'entrée des noms de fichier de la COPY_FILES variable. La partie suivante définit la fonction qui sera utilisé pour synthétiser un nom de fichier de sortie correspondant à chaque entrée. Ensuite, nous définissons les commandes utilisées pour invoquer cette "compilateur", selon le type de shell, nous sommes dans.

Ensuite, nous définissons un extra makefile cible copy_files.cookie, qui dépend de la cible compiler_copy_files_make_all. Ce dernier est le nom de la cible qui qmake génère pour le compilateur que nous avons défini dans la première étape. Cela signifie que lorsque le copy_files.cookie cible est construit, il invoquera l'extra compilateur pour copier les fichiers.

Nous spécifier une commande à exécuter par cette cible, qui touch les fichiers copy_files.cookie et compiler_copy_files_make_all. En touchant ces fichiers, nous nous assurons que make ne va pas essayer de copier les fichiers à nouveau à moins que les horodatages sont plus récents que le touché de fichiers. Enfin, nous ajoutons copy_files.cookie à la liste des dépendances de la make all cible.

Comment l'utiliser

Dans votre .pro fichier, ajouter copy_files à la CONFIG variable:

CONFIG += copy_files

Puis ajoutez les fichiers à la COPY_FILES variable:

COPY_FILES += docs/*.txt

Tout d'abord, définissons ci-dessous (qui est de XD cadre) quelque part, comme à l'intérieur de functions.prf fichier:

# --------------------------------------
# This file defines few useful functions
# --------------------------------------

#copyDir(source, destination)
# using "shell_path()" to correct path depending on platform
# escaping quotes and backslashes for file paths
defineTest(copyDir) {
    #append copy command
    !isEmpty(xd_copydir.commands): xd_copydir.commands += && \$$escape_expand(\n\t)
    xd_copydir.commands += ( $(COPY_DIR) \"$$shell_path($$1)\" \"$$shell_path($$2)\" || echo \"copy failed\" )
    #the qmake generated MakeFile contains "first" and we depend that on "xd_copydir"
    first.depends *= xd_copydir
    QMAKE_EXTRA_TARGETS *= first xd_copydir

    export(first.depends)
    export(xd_copydir.commands)
    export(QMAKE_EXTRA_TARGETS)
}

#copy(source, destination) (i.e. the name "copyFile" was reserved)
defineTest(copyFile) {
    #append copy command
    !isEmpty(xd_copyfile.commands): xd_copyfile.commands += && \$$escape_expand(\n\t)
    xd_copyfile.commands += ( $(COPY_FILE) \"$$shell_path($$1)\" \"$$shell_path($$2)\" || echo \"copy failed\" )
    #the qmake generated MakeFile contains "first" and we depend that on "xd_copyfile"
    first.depends *= xd_copyfile
    QMAKE_EXTRA_TARGETS *= first xd_copyfile

    export(first.depends)
    export(xd_copyfile.commands)
    export(QMAKE_EXTRA_TARGETS)
}

et à utiliser dans votre projet comme:

include($$PWD/functions.prf) #optional

copyFile($$PWD/myfile1.txt, $$DESTDIR/myfile1.txt)
copyFile($$PWD/README.txt, $$DESTDIR/README.txt)
copyFile($$PWD/LICENSE, $$DESTDIR/LICENSE)
copyDir($$PWD/redist, $$DESTDIR/redist) #copy "redist" folder to "$$DESTDIR"

Noter que tous les fichiers sont copiés avant l'opération du lien qui est fait (ce qui peut être utile).

xd_functions.prf script complet

Mais lorsque vous besoin de quelque chose comme copyFileLater(source, destination), de copier seulement les fichiers une fois le build est fait alors envisager l'utilisation de code ci-dessous (qui est de XD cadre Apache 2.0 licence):

# --------------------------------------
# This file defines few useful functions
# --------------------------------------
xd_command_count = 0
#xd_prebuild(prefix, command)
defineTest(xd_prebuild) {
#generate target name with number
xd_command_count = $$num_add($$xd_command_count, 1)
name = $$1$$xd_command_count
#append command
eval( $${name}.commands += ( \$\$2 ) );
#the qmake generated "MakeFile" should contain "first"
#   and we depend that on new command
!contains( first.depends, $$name ) {
!isEmpty(first.depends): first.depends += \\$$escape_expand(\\n)
first.depends += $$name
}
QMAKE_EXTRA_TARGETS *= first $$name
export(xd_command_count)
export($${name}.commands)
export(first.depends)
export(QMAKE_EXTRA_TARGETS)
#eval( warning(xd_push_command: $${name}.commands += \$\${$${name}.commands}) )
}
#xd_postbuild(command)
defineTest(xd_postbuild) {
!isEmpty(QMAKE_POST_LINK): QMAKE_POST_LINK = $$QMAKE_POST_LINK$$escape_expand(\\n\\t)
QMAKE_POST_LINK = $${QMAKE_POST_LINK}$$quote(-$$1)
export(QMAKE_POST_LINK)
}
#xd_escape(path)
#   resolves path like built-in functions (i.e. counts input relative to $$PWD)
defineReplace(xd_escape) {
1 = $$absolute_path($$1)
#using "shell_path()" to correct path depending on platform
#   escaping quotes and backslashes for file paths
1 = $$shell_path($$1)
return($$quote($$1))
}
#copyFile(source, destination)
#   this will both copy and rename "source" to "destination", However like "copy_file()":
#       if "destination" is path to existing directory or ends with slash (i.e. "/" or "\\"),
#       will just copy to existing "destination" directory without any rename
#
#   note: this is executed before build, but after qmake did exit
#       so use "copy_file(...)" instead if the output file is required in qmake script
#       like for example if "write_file(...)" is called on the output...
defineTest(copyFile) {
#note that "$(COPY_FILE)" is generated by qmake from "$$QMAKE_COPY_FILE"
xd_prebuild(xd_copyfile, $(COPY_FILE) $$xd_escape($$1) $$xd_escape($$2) || echo copyFile-failed)
}
#copyFileLater(source, destination = $(DESTDIR))
#   note: this is executed after build is done, hence the name copy-later
defineTest(copyFileLater) {
destDir = $$2
isEmpty(destDir): destDir = $(DESTDIR)
#append copy command
xd_postbuild($(COPY_FILE) $$xd_escape($$1) $$xd_escape($$destDir) || echo copyFileLater-failed)
#!build_pass:warning(copyFile: $$1 to: $$destDir)
}
#copyDir(source, destination)
defineTest(copyDir) {
xd_prebuild(xd_copydir, $(COPY_DIR) $$xd_escape($$1) $$xd_escape($$2) || echo copyDir-failed)
}
#copyDirLater(source, destination = $(DESTDIR))
#   note: this is executed after build is done, hence the name copy-later
defineTest(copyDirLater) {
destDir = $$2
isEmpty(destDir): destDir = $(DESTDIR)
#append copy command
xd_postbuild($(COPY_DIR) $$xd_escape($$1) $$xd_escape($$destDir) || echo copyDirLater-failed)
#!build_pass:warning(copyFile: $$1 to: $$destDir)
}
#makeDir(destination)
defineTest(makeDir) {
xd_prebuild(xd_makedir, $(MKDIR) $$xd_escape($$1) || echo makeDir-failed: \"$$1\")
}
defineTest(makeDirLater) {
xd_postbuild( $(MKDIR) $$xd_escape($$1) || echo makeDirLater-failed )
#!build_pass:warning(makeDirLater: $$1)
}
defineTest(deleteFile) {
xd_prebuild(xd_delfile, $(DEL_FILE) $$xd_escape($$1) || echo deleteFile-failed)
}
defineTest(deleteFileLater) {
xd_postbuild( $(DEL_FILE) $$xd_escape($$1) || echo deleteFileLater-failed )
#!build_pass:warning(deleteFileLater: $$1)
}
defineTest(deleteDir) {
xd_prebuild(xd_delfile, $(DEL_DIR) $$xd_escape($$1) || echo deleteDir-failed)
}
defineTest(deleteDirLater) {
xd_postbuild( $(DEL_DIR) $$xd_escape($$1) || echo deleteDirLater-failed )
#!build_pass:warning(deleteFileLater: $$1)
}
#qmakeLater(qmake-script-file-path-to-run)
#   note that inside the script runned by this method
#   $$OUT_PWD will be same as original $$OUT_PWD of qmakeLater(...) caller project
#   since there is the "Makefile" that executes our custom qmake
defineTest(qmakeRun) {
xd_postbuild( $(QMAKE) $$xd_escape($$1) -r -spec \"$$shell_path($$QMAKESPEC)\" )
#!build_pass:warning(qmakeLater: $$1)
}
defineTest(qmakeLater) {
xd_postbuild( $(QMAKE) $$xd_escape($$1) -r -spec \"$$shell_path($$QMAKESPEC)\" )
#!build_pass:warning(qmakeLater: $$1)
}