Analysis: why I think PR #586 is not good

[pzhlkj6612]

Summary

This is an analysis of why PR #586 not only did not solve all the problems, but also introduced new problems, but our test did not fail at that time.

I didn't figure out why the commands in the Makefile can be successfully executed through "mingw32-make.exe" before. Although it passed the test, I thought it didn't look good, so I said "unconditionally adding quotes may break the program", and didn't provide any proof. After analysis, I know that adding quotes unconditionally in qmake code like #586 will not break anything, because doing so has no actual effect. Moreover, there are indeed some problems that are hid by those passed tests, so we should think more about it.

At the same time, I also provide a patch to fix the problem introduced in #586 , although it is useless since we are no longer specifying the full path to the installed CQtDeployer. Here is the patch:

useless patch

From 1a47ab7bcc237aeefbc82014e134e16c8ec2dbcb Mon Sep 17 00:00:00 2001
From: Mozi <29089388+pzhlkj6612@users.noreply.github.com>
Date: Mon, 24 May 2021 20:20:22 +0800
Subject: [PATCH] Ensure CQtDeployer's path is treated as one string

We need to make sure the "DEPLOYER" variable holds a legal path. That
  is, if there are spaces in the path, the string should be enclosed in
  quotes.
In qmake, functions "shell_quote()" and "system_quote()" will add quotes
  to strings that have already been enclosed in quotes, so we should
  check and remove the quotes in advance (especially on Windows).
Since these commands will be run by "make" instead of the "system"
  function, I think it makes more sense to use "shell_quote()".
  Actually, both of these functions can be used here.
In addition, enclosing the "$$()" expansion syntax in quotes has no
  effect. Doing so will not add any quotes.
---
 QIFData/InstallerBase.pri        | 7 ++++++-
 QIFData/installerCQtDeployer.pri | 2 +-
 test.pri                         | 9 +++++++--
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/QIFData/InstallerBase.pri b/QIFData/InstallerBase.pri
index 9ab3b6f..0a328a2 100644
--- a/QIFData/InstallerBase.pri
+++ b/QIFData/InstallerBase.pri
@@ -4,7 +4,7 @@ QT_DIR= $$[QT_HOST_BINS]
 win32:QMAKE_BIN= $$QT_DIR/qmake.exe
 win32:LUPDATE = $$QT_DIR/lupdate.exe
 win32:LRELEASE = $$QT_DIR/lrelease.exe
-win32:DEPLOYER="$$(cqtdeployer)"
+win32:DEPLOYER=$$(cqtdeployer)
 
 
 contains(QMAKE_HOST.os, Linux):{
@@ -18,6 +18,11 @@ android {
     DEPLOYER = $$QT_DIR/androiddeployqt
 }
 
+contains(DEPLOYER, '^".+"$') {
+    # Trim the enclosed quotes.
+    DEPLOYER = $$str_member($$DEPLOYER, 1, -2)
+}
+
 message( PWD :$$PWD)
 
 message( Configuration variables :)
diff --git a/QIFData/installerCQtDeployer.pri b/QIFData/installerCQtDeployer.pri
index af41139..c7badad 100644
--- a/QIFData/installerCQtDeployer.pri
+++ b/QIFData/installerCQtDeployer.pri
@@ -17,7 +17,7 @@ win32:OUT_BIN= -binOut bin
 BASE_DEPLOY_FLAGS = clear -qmake $$QMAKE_BIN -libDir $$PWD/../ -recursiveDepth 4 -ignoreEnv $$DEPLOY_TARGET
 BASE_DEPLOY_FLAGS_CQT = $$BASE_DEPLOY_FLAGS -targetDir $$DATA_DIR $$OUT_LIB $$OUT_BIN
 
-deploy_dep.commands += $$DEPLOYER -bin $$DEPLOY_TARGET $$BASE_DEPLOY_FLAGS_CQT
+deploy_dep.commands += $$shell_quote($$DEPLOYER) -bin $$DEPLOY_TARGET $$BASE_DEPLOY_FLAGS_CQT
 
 win32:CONFIG_FILE = $$PWD/config/configWin.xml
 unix:CONFIG_FILE = $$PWD/config/configLinux.xml
diff --git a/test.pri b/test.pri
index 3a088db..b7ee551 100644
--- a/test.pri
+++ b/test.pri
@@ -8,10 +8,15 @@ contains(QMAKE_HOST.os, Linux):{
 }
 
 DEPLOYER=cqtdeployer
-win32:DEPLOYER="$$(cqtdeployer)"
+win32:DEPLOYER=$$(cqtdeployer)
+
+contains(DEPLOYER, '^".+"$') {
+    # Trim the enclosed quotes.
+    DEPLOYER = $$str_member($$DEPLOYER, 1, -2)
+}
 
 test.commands =
-deployTest.commands = $$DEPLOYER -bin $$exec clear -qmake $$QMAKE_BIN -targetDir $$PWD/deployTests -libDir $$PWD -recursiveDepth 4
+deployTest.commands = $$shell_quote($$DEPLOYER) -bin $$exec clear -qmake $$QMAKE_BIN -targetDir $$PWD/deployTests -libDir $$PWD -recursiveDepth 4
 
 !contains(DEFINES, WITHOUT_TESTS) {
     test.depends = deployTest

Analysis

Here are some analyses that are not directly related to the code in our program, which will help us to understand the behavior of our code.

qmake

We could know the following rules of qmake through experiments (yes, I tried to read the source code of qmake before, but... it's toooooo complicated):

1. In a project file, variables are used to hold lists of strings (doc and source code). For example, the assignment statement foo = bar means that the value of the "foo" variable is a single-element list, and its first and only element is the string literal "bar". And the statement foo = bar baz means that there are two elements in the "foo" variable.
2. Anything enclosed in quotes represents a string containing its value, or the string form of its value, and no quotes are added at the beginning and end of the value. In particular:
   1. A pair of quotes ( '' or "" ) represents neither an empty string nor an empty string enclosed in quotes, but an ignorable empty statement (i.e., it's nothing). In function calls, the statements func(,) , func('',) , func(, "") and func("", '') have the same meaning, which is calling the function func with two empty parameters.
   2. Using quotes to enclose a string literal ( ' ' , " " , 'foo' or "bar" ) or a function that returns a string ( '$$absolute_path(foo, C:\bar)' or "$$clean_path(/foo/bar/..)" ) will not change the value of that string (or the returned string).
   3. Using a space as the separator, you can concatenate all items of a variable or the returned list from a function by enclosing it with quotes ( joined = '$$var' or joined = "$$files(C:/Program Files/Windows M*)" ) or calling the $$quote() function ( joined = $$quote($$var) or joined = $$quote($$files(C:/Program Files/Windows M*)) ). If the RHS variable only contains one string, the value of that string will be directly copied to the LHS variable without any changes. You can "expand" an arbitrary variable in this way. In addition, you can also directly print out the "expanded" list via message($$var) .
3. To add quotes into a string or make a string contains quotes, we need to escape them with a backslash ( \' or \" ), enclose it in another type of quotes ( "'" or '"' ), or use the builtin functions ( shell_quote() or system_quote() ).
4. We can construct a longer string by concatenating multiple variables (similar to the "String literal concatenation" feature in Python but without space delimiters). For example:
   1. Concatenate string literals: 'foo'bar"baz" , '"'foo"'" or \""'\''"'"\"\'"'"\"foo\''\""'"\"'"'"\' (hey, don't play with quotes and backslashes).
   2. Concatenate "expanded" lists: $$cat(/etc/hosts, lines)$$cat(/etc/networks, lines)$$cat(/etc/shells, lines) .
   3. Concatenate string literals with "expanded" lists: foo$$escape_expand(bar\\n\\tbaz) , $$find(CONFIG, re)'foo' or $$upper(cm)$$lower(AKE, iS, "")$$lower(tHE, '')$$upper(best) .
5. The $$() expansion syntax and the $$getenv() replace function will return the value of the specific environment variable as a string without any changes. That is, regardless of whether the value contains spaces, it will not add quotes at the beginning and end. Don't forget that the returned value is a complete string, so the spaces in it will not divide its content into multiple parts like we assign a list to a qmake variable. For example, the foo = C:\Program Files (x86) statement will produce a variable named "foo" which contains three elements C:\Program , Files and (x86) , while the bar = $$getenv(ProgramFiles(x86)) statement will produce a variable named "bar" which contains only one element C:\Program Files (x86) .

Practice is the sole criterion of truth, so let's read and run the following code:

too long qmake code

# To avoid the "message(message) requires one argument." error message,
#   we should not directly use the "message()" function to print out the
#   content of a variable, but try to use the "for()" loop to iterate
#   its contents.


### 1. String lists

foo = bar
for(item, foo): message($$item)
# output: bar

foo = bar baz
for(item, foo): message($$item)
# bar
# baz


### 2. Anything enclosed in quotes
###   2.1. A pair of quotes

var =
for(item, var): message($$item)
# no output
var = ''
for(item, var): message($$item)
# no output
var = ""
for(item, var): message($$item)
# no output

var = '' ''
for(item, var): message($$item)
# no output
var = '' foo
for(item, var): message($$item)
# foo
var = foo ""
for(item, var): message($$item)
# foo

var = "" foo ''
for(item, var): message($$item)
# foo
var = foo '' bar
for(item, var): message($$item)
# foo
# bar

defineTest(func) {
	message(ARGC = $$ARGC)
	message(size(ARGV) = $$size(ARGV))
}
func(,)
# ARGC = 2
# size(ARGV) = 0
func('',)
# ARGC = 2
# size(ARGV) = 0
func(, "")
# ARGC = 2
# size(ARGV) = 0
func("", '')
# ARGC = 2
# size(ARGV) = 0

###   2.2. Enclose something in quotes

var = ' '
for(item, var): message($$item)
# (empty line)
var = " "
for(item, var): message($$item)
# (empty line)
var = 'foo'
for(item, var): message($$item)
# foo
var = "bar"
for(item, var): message($$item)
# bar

var = 'foo' "bar" '' " "
for(item, var): message($$item)
# foo
# bar
# 
var = "" '$$absolute_path(foo, C:\bar)' ' ' baz
for(item, var): message($$item)
# C:/bar/foo
# 
# baz
var = "" 'foo' "$$clean_path(/bar/baz/..)" ''
for(item, var): message($$item)
# foo
# /bar

###   2.3. Concatenate all items of a list

unjoined = 	foo	 bar 	      	  \
 			baz
for(item, unjoined): message($$item)
# foo
# bar
# baz
joined = '$$unjoined'
for(item, joined): message($$item)
# foo bar baz
joined = $$quote($$unjoined)
for(item, joined): message($$item)
# foo bar baz
message($$unjoined)
# foo bar baz

unjoined = $$files(C:/Program Files/Windows M*)
for(item, unjoined): message($$item)
# C:/Program Files/Windows Mail
# C:/Program Files/Windows Media Player
# C:/Program Files/Windows Multimedia Platform
joined = "$$unjoined"
for(item, joined): message($$item)
# C:/Program Files/Windows Mail C:/Program Files/Windows Media Player C:/Program Files/Windows Multimedia Platform
joined = $$quote($$unjoined)
for(item, joined): message($$item)
# C:/Program Files/Windows Mail C:/Program Files/Windows Media Player C:/Program Files/Windows Multimedia Platform
message($$unjoined)
# C:/Program Files/Windows Mail C:/Program Files/Windows Media Player C:/Program Files/Windows Multimedia Platform

unjoined = foo
for(item, unjoined): message($$item)
# foo
joined = "$$unjoined"
for(item, joined): message($$item)
# foo
joined = $$quote($$unjoined)
for(item, joined): message($$item)
# foo
message($$unjoined)
# foo

unjoined = $$files(/usr/lo?al)
for(item, unjoined): message($$item)
# /usr/local
joined = "$$unjoined"
for(item, joined): message($$item)
# /usr/local
joined = $$quote($$unjoined)
for(item, joined): message($$item)
# /usr/local
message($$unjoined)
# /usr/local


### 3. Add quotes

var = \'
for(item, var): message($$item)
# '
var = \"
for(item, var): message($$item)
# "

var = '\''
for(item, var): message($$item)
# '
var = "\""
for(item, var): message($$item)
# "

var = "\'"
for(item, var): message($$item)
# '
var = '\"'
for(item, var): message($$item)
# "

var = "'"
for(item, var): message($$item)
# '
var = '"'
for(item, var): message($$item)
# "

foo = bar baz
var = $$shell_quote($$foo)
for(item, var): message($$item)
# "bar baz"
var = $$system_quote($$foo)
for(item, var): message($$item)
# "bar baz"
var = '"$$foo"'
for(item, var): message($$item)
# "bar baz"


### 4. String literal concatenation
###   4.1. Concatenate string literals

var = 'foo'bar"baz"
for(item, var): message($$item)
# foobarbaz

var = '"'foo"'"
for(item, var): message($$item)
# "foo'

var = \""'\''"'"\"\'"'"\"foo\''\""'"\"'"'"\'
for(item, var): message($$item)
# "'''""'""foo''"""''

###   4.2. Concatenate "expanded" lists

var = $$cat(/etc/hosts, lines)$$cat(/etc/networks, lines)$$cat(/etc/shells, lines)
for(item, var): message($$item)
# 127.0.0.1  localhost
# 127.0.1.1  <hostname>
# # The following lines are desirable for IPv6 capable hosts
# ::1     ip6-localhost ip6-loopback
# fe00::0 ip6-localnet
# ff00::0 ip6-mcastprefix
# ff02::1 ip6-allnodes
# ff02::2 ip6-allrouters# symbolic names for networks, see networks(5) for more information
# link-local 169.254.0.0# /etc/shells: valid login shells
# /bin/sh
# /bin/bash
# /bin/rbash
# /bin/dash

###   4.3. Concatenate string literals with "expanded" lists

var = foo$$escape_expand(bar\\n\\tbaz)
for(item, var): message($$item)
# foobar
# (continuous new line)        baz

var = $$find(CONFIG, re)'foo'
for(item, var): message($$item)
# release
# debug_and_release
# debug_and_release_target
# precompile_header
# shared
# shared
# releasefoo

qmake = $$upper(cm)$$lower(AKE, iS, "")$$lower(tHE, '')$$upper(best)
for(item, qmake): message($$item)
# CMake
# is
# the
# BEST


### 5. $$() and $$getenv()

foo = C:\Program Files (x86)
for(item, foo): message($$item)
# C:\Program
# Files
# (x86)
foo = C:\Program Files
for(item, foo): message($$item)
# C:\Program
# Files

bar = $$getenv(ProgramFiles(x86))
for(item, bar): message($$item)
# C:\Program Files (x86)
bar = $$getenv(ProgramFiles)
for(item, bar): message($$item)
# C:\Program Files
bar = $$(ProgramFiles)
for(item, bar): message($$item)
# C:\Program Files

I think the syntax of qmake is a bit casual... maybe CMake can save us, I guess.

qmake and Make

We have the following qmake code:

PROGRAM_PATH = "C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat"  # Don't misunderstand the quotes.
PROGRAM_ARG  = version

the_target.commands = $$PROGRAM_PATH $$PROGRAM_ARG
QMAKE_EXTRA_TARGETS *= the_target

It will generate the following Makefile rule:

the_target:
	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version

Let's copy the command into CMD and execute it:

> C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version
'C:\Program' is not recognized as an internal or external command,
operable program or batch file.

This is the expected behavior. We do need quotes when a path contains spaces. However, if we build this target with "mingw32-make.exe", CQtDeployer will be launched!

> mingw32-make.exe the_target
C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version
Info: Print info ...
...

Uh, why does it work?

Make and Windows API

Before reading the source code of "mingw32-make.exe", we could use Process Monitor to see what operations "mingw32-make.exe" did before launching CQtDeployer:

Events from Process Monitor (simplified)

Operation	Path	Result	Detail
...	...	...	...
CreateFile	C:\Program.exe	NAME NOT FOUND	...
CreateFile	C:\Program.exe	NAME NOT FOUND	...
CreateFile	C:\Program.cmd	NAME NOT FOUND	...
CreateFile	C:\Program.cmd	NAME NOT FOUND	...
CreateFile	C:\Program.bat	NAME NOT FOUND	...
CreateFile	C:\Program.bat	NAME NOT FOUND	...
CreateFile	C:\Program	NAME NOT FOUND	...
CreateFile	C:\Program	NAME NOT FOUND	...
CreateFile	C:\Program.com	NAME NOT FOUND	...
CreateFile	C:\Program.com	NAME NOT FOUND	...
CreateFile	C:\Program	NAME NOT FOUND	...
CreateFile	C:\Program.exe	NAME NOT FOUND	...
CreateFile	C:\Program Files	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Program Files	SUCCESS	...
CloseFile	C:\Program Files	SUCCESS
CreateFile	C:\Program Files	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Program Files	SUCCESS	...
CloseFile	C:\Program Files	SUCCESS
CreateFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS	...
CloseFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS
CreateFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS	...
CloseFile	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat	SUCCESS
...	...	...	...
CreateFile	C:\Windows\System32\cmd.exe	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Windows\System32\cmd.exe	SUCCESS	...
CloseFile	C:\Windows\System32\cmd.exe	SUCCESS
CreateFile	C:\Windows\System32\cmd.exe	SUCCESS	..., OpenResult: Opened
QueryBasicInformationFile	C:\Windows\System32\cmd.exe	SUCCESS	...
CloseFile	C:\Windows\System32\cmd.exe	SUCCESS
...	...	...	...
Process Create	C:\WINDOWS\system32\cmd.exe	SUCCESS	PID: ..., Command line: C:\WINDOWS\system32\cmd.exe /c ""C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat" version"
...	...	...	...

According to the source code of "mingw32-make.exe", I divided these events into two parts and only kept the "Path" column.

The first part, calling SearchPath (source code):

Path
---
C:\Program.exe
C:\Program.exe
C:\Program.cmd
C:\Program.cmd
C:\Program.bat
C:\Program.bat
C:\Program
C:\Program
C:\Program.com
C:\Program.com

The other part, calling CreateProcess (source code):

Path
---
C:\Program
C:\Program.exe
C:\Program Files
C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat

SearchPath

• SearchPathA
• SearchPathW

I've created a simple program to emulate (I think it's not a "simulation") the process of file search (source code).

CPP code (SearchPath)

#include <iostream>
#include <windows.h>
#include <tchar.h>

#ifdef UNICODE
#define _tcout std::wcout
#else
#define _tcout std::cout
#endif

int _tmain(int argc, _TCHAR **argv)
{
    // The default PATH.
    _TCHAR *lpPath = _T(
        "C:\\Windows\\system32;"
        "C:\\Windows;"
        "C:\\Windows\\System32\\Wbem;"
        "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;"
        "C:\\Windows\\System32\\OpenSSH\\;"
        "C:\\Users\\user\\AppData\\Local\\Microsoft\\WindowsApps;");
    _TCHAR lpBuffer[MAX_PATH];
    _TCHAR *lpFileNames[] = {
        _T("C:\\Program.exe"),
        _T("C:\\Program.cmd"),
        _T("C:\\Program.bat"),
        _T("C:\\Program"),
        _T("C:\\Program.com"),
        NULL};

    for (_TCHAR **lpFileName = lpFileNames; *lpFileName; lpFileName++)
    {
        if (0 == SearchPath(
                     /* lpPath        */ lpPath,
                     /* lpFileName    */ *lpFileName,
                     /* lpExtension   */ NULL,
                     /* nBufferLength */ MAX_PATH,
                     /* lpBuffer      */ lpBuffer,
                     /* lpFilePart    */ NULL))
            _tcout << _T("SearchPath(") << lpPath << _T(", ") << *lpFileName << _T(", NULL,...)")
                   << _T(" failed, code: ") << GetLastError() << std::endl;

        if (0 == SearchPath(
                     /* lpPath        */ NULL,
                     /* lpFileName    */ *lpFileName,
                     /* lpExtension   */ NULL,
                     /* nBufferLength */ MAX_PATH,
                     /* lpBuffer      */ lpBuffer,
                     /* lpFilePart    */ NULL))
            _tcout << _T("SearchPath(NULL, ") << *lpFileName << _T(", NULL,...)")
                   << _T(" failed, code: ") << GetLastError() << std::endl;
    }

    return 0;
}

Since the *lpFileName variable holds an absolute path, the parameter lpPath will not have any effect on the search process.

As long as the five files "C:\Program.exe", "C:\Program.cmd", "C:\Program.bat", "C:\Program" and "C:\Program.com" do not exist, all ten calls to SearchPath will fail, and we could get the same events in Process Monitor.

Why C:\\Program* ?

The command C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version in Makefile is divided into several parts by spaces. The first part is C:\Program , which is regarded as a program that needs to be found and executed (aka argv[0] ).

CreateProcess

• CreateProcessA
• CreateProcessW

After enabling outputting the debug information of "jobs", we could take a look at the process of "mingw32-make.exe" for process creation, and know the two important parameters of the CreateProcess function:

> mingw32-make.exe the_target --debug=jobs
C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version
CreateProcess(NULL,C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat version,...)
...
Info: Print info ...
...

As you can see, the second parameter is the full command from our Makefile.

I've also created a simple program to emulate the process of process creation (source code).

CPP code (CreateProcess)

#include <iostream>
#include <windows.h>
#include <tchar.h>

#ifdef UNICODE
#define _tcout std::wcout
#else
#define _tcout std::cout
#endif

int _tmain(int argc, _TCHAR **argv)
{
    _TCHAR *commandline = _T("C:\\Program Files (x86)\\CQtDeployer\\1.x\\cqtdeployer.bat version");
    STARTUPINFO startInfo;
    memset(&startInfo, '\0', sizeof(startInfo));
    GetStartupInfo(&startInfo);
    PROCESS_INFORMATION procInfo;

    if (FALSE == CreateProcess(
                     /* lpApplicationName    */ NULL,
                     /* lpCommandLine        */ commandline,
                     /* lpProcessAttributes  */ NULL,
                     /* lpThreadAttributes   */ 0,
                     /* bInheritHandles      */ TRUE,
                     /* dwCreationFlags      */ 0,
                     /* lpEnvironment        */ NULL,
                     /* lpCurrentDirectory   */ 0,
                     /* lpStartupInfo        */ &startInfo,
                     /* lpProcessInformation */ &procInfo))
        _tcout << _T("CreateProcess(NULL, ") << commandline << _T(",...)")
               << _T(" failed, code: ") << GetLastError() << std::endl;

    return 0;
}

As long as the two files "C:\Program" and "C:\Program.exe" do not exist, CQtDeployer will be called. This behavior is already documented, but I still think it looks like magic.

Another reference

• unicode - What is the difference between _tmain() and main() in C++? - Stack Overflow
• TEXT vs. _TEXT vs. _T, and UNICODE vs. _UNICODE | The Old New Thing

Further exploring

You may remember that "CMD.EXE" can be launched by typing "cmd" in CMD, PowerShell or the "Run" dialog of Windows Explorer without specifying its extension. Do you know how it is achieved?

Go back to CQtDeployer

After reading my lengthy analysis, we can start analyzing CQtDeployer.

Before the fixes

Both "/test.pri" and "/QIFData/InstallerBase.pri" have the same qmake instructions, they will get the value of the environment variable cqtdeployer in the same way:

win32:DEPLOYER=$$(cqtdeployer)

CQtDeployer/test.pri

Line 11 in 7fda866

win32:DEPLOYER=$$(cqtdeployer)

CQtDeployer/QIFData/InstallerBase.pri

Line 7 in 7fda866

win32:DEPLOYER=$$(cqtdeployer)

And we have the following qmake instructions:

In "/test.pri":

deployTest.commands = $$DEPLOYER -bin $$exec clear -qmake $$QMAKE_BIN -targetDir $$PWD/deployTests -libDir $$PWD -recursiveDepth 4

CQtDeployer/test.pri

Line 14 in 7fda866

deployTest.commands = $$DEPLOYER -bin $$exec clear -qmake $$QMAKE_BIN -targetDir $$PWD/deployTests -libDir $$PWD -recursiveDepth 4

In "/QIFData/installerCQtDeployer.pri":

deploy_dep.commands += $$DEPLOYER -bin $$DEPLOY_TARGET $$BASE_DEPLOY_FLAGS_CQT

CQtDeployer/QIFData/installerCQtDeployer.pri

Line 20 in 7fda866

deploy_dep.commands += $$DEPLOYER -bin $$DEPLOY_TARGET $$BASE_DEPLOY_FLAGS_CQT

In our system, there is an environment varialbe named cqtdeployer and its value is "C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat" . The above instructions will generate the following Makefile rules to call the installed CQtDeployer:

deploy_dep:
	"C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat" -bin ...

deployTest:
	"C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat" -bin ...

It works fine. However, we know that those quotes in the value of the environment variable will cause trouble in PowerShell ( #581 ), so we should remove them.

After the "arbitrary" fixes...

diff of #586

diff --git a/QIFData/InstallerBase.pri b/QIFData/InstallerBase.pri
index 68d0216c..9ab3b6f0 100644
--- a/QIFData/InstallerBase.pri
+++ b/QIFData/InstallerBase.pri
@@ -4,7 +4,7 @@ QT_DIR= $$[QT_HOST_BINS]
 win32:QMAKE_BIN= $$QT_DIR/qmake.exe
 win32:LUPDATE = $$QT_DIR/lupdate.exe
 win32:LRELEASE = $$QT_DIR/lrelease.exe
-win32:DEPLOYER=$$(cqtdeployer)
+win32:DEPLOYER="$$(cqtdeployer)"
 
 
 contains(QMAKE_HOST.os, Linux):{
diff --git a/QIFData/packages/cqtdeployer.1_5/meta/installscript.js b/QIFData/packages/cqtdeployer.1_5/meta/installscript.js
index cebf05ed..a3d72d15 100644
--- a/QIFData/packages/cqtdeployer.1_5/meta/installscript.js
+++ b/QIFData/packages/cqtdeployer.1_5/meta/installscript.js
@@ -92,14 +92,14 @@ function systemIntegration() {
         component.addOperation('EnvironmentVariable',
                                [
                                    "cqtdeployer",
-                                   "\"" + targetDir + "\\" + VERSION + "\\cqtdeployer.bat\""
+                                   targetDir + "\\" + VERSION + "\\cqtdeployer.bat"
                                ]
                               )
 
         component.addOperation('EnvironmentVariable',
                                [
                                    "cqtDir",
-                                   "\"" + targetDir + "\\" + VERSION + "\\\""
+                                   targetDir + "\\" + VERSION + "\\"
                                ]
                               )
 
diff --git a/test.pri b/test.pri
index f7b7895f..3a088db7 100644
--- a/test.pri
+++ b/test.pri
@@ -8,7 +8,7 @@ contains(QMAKE_HOST.os, Linux):{
 }
 
 DEPLOYER=cqtdeployer
-win32:DEPLOYER=$$(cqtdeployer)
+win32:DEPLOYER="$$(cqtdeployer)"
 
 test.commands =
 deployTest.commands = $$DEPLOYER -bin $$exec clear -qmake $$QMAKE_BIN -targetDir $$PWD/deployTests -libDir $$PWD -recursiveDepth 4

7fda866...9dd5da5

The changes in the file "/QIFData/packages/cqtdeployer.1_5/meta/installscript.js" is fine, but enclosing the $$(cqtdeployer) statement in quotes in the files "/test.pri" and "/QIFData/InstallerBase.pri" has no real effect.

Now the value of the environment variable is C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat , the qmake instructions will generate the following rules:

deploy_dep:
	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat -bin ...

deployTest:
	C:\Program Files (x86)\CQtDeployer\1.x\cqtdeployer.bat -bin ...

Note that the paths to the bat file are not enclosed in quotes.

If we "build" these two targets, "mingw32-make.exe" will not complain anything since CQtDeployer will be found and launched successfully. Yes, it works, but in my opinion, the changed code does not seem to be a best practice, and may confuse people who read the code in the future.

Afterword

I want to share my knowledge and discoveries with the world, so I wrote this analysis. Any discussion is welcomed.

Thank you for reading.

[EndrII]

The cqtdeployer tool will move to cmake build system. So I think it is no actuality article

[pzhlkj6612]

Good news! I think CMake is a better choice.

[EndrII]

Yes, cmake support is done .. So you can try new cqtdeployer 1.6