Hello,

I am trying to execute a bat file that takes in a few arguments. From
Windows command line, this works as intended:

>"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8

The tcl code looks like this:

set batFile {C:/Program Files/test.bat}
set runFile {C:/Program Files/runFile.txt}
set N 8
set command [concat \"$batFile\" \"$runFile\" $N]
exec {*}$command

Unless I'm missing something, this same process works fine for exe
files. With the batch file, it appears to fail due to the spaces in the
batch filepath. Any suggestions? I see online some suggestions to use
auto_execok but I can't really figure out how to apply it in this scenario.

Thanks,

Jacob

On 2/20/2024 2:49 PM, Jacob wrote:
>
> set batFile {C:/Program Files/test.bat}
> set runFile {C:/Program Files/runFile.txt}
> set N 8
> set command [concat \"$batFile\" \"$runFile\" $N]
> exec {*}$command
>

Concat flattens the arguments you provide, and when the exec gets it, it
looks for the first item as command name, which would be C:/Program.

You want to try this instead:

set command [list \"$batFile\" \"$runFile\" $N]

On 2/20/2024 12:17 PM, saitology9 wrote:
> On 2/20/2024 2:49 PM, Jacob wrote:
>>
>> set batFile {C:/Program Files/test.bat}
>> set runFile {C:/Program Files/runFile.txt}
>> set N 8
>> set command [concat \"$batFile\" \"$runFile\" $N]
>> exec {*}$command
>>
>
> Concat flattens the arguments you provide, and when the exec gets it, it
> looks for the first item as command name, which would be C:/Program.
>
> You want to try this instead:
>
> set command [list \"$batFile\" \"$runFile\" $N]

Thanks for your suggestion. I actually have tried that as well, and get
the following error:

couldn't execute ""C:/Program Files/test.bat"": No error

Jacob <JacobLambeth@clevelandgolf.com> wrote:
> On 2/20/2024 12:17 PM, saitology9 wrote:
>> On 2/20/2024 2:49 PM, Jacob wrote:
>>>
>>> set batFile {C:/Program Files/test.bat}
>>> set runFile {C:/Program Files/runFile.txt}
>>> set N 8
>>> set command [concat \"$batFile\" \"$runFile\" $N]
>>> exec {*}$command
>>>
>>
>> Concat flattens the arguments you provide, and when the exec gets it, it
>> looks for the first item as command name, which would be C:/Program.
>>
>> You want to try this instead:
>>
>> set command [list \"$batFile\" \"$runFile\" $N]
>
> Thanks for your suggestion. I actually have tried that as well, and get
> the following error:
>
> couldn't execute ""C:/Program Files/test.bat"": No error
>

The quotes are unnecessary. Remove them.

set command [list $batFile $runFile $N]

On 2/20/2024 1:33 PM, Anonymous wrote:
> Jacob <JacobLambeth@clevelandgolf.com> wrote:
>> On 2/20/2024 12:17 PM, saitology9 wrote:
>>> On 2/20/2024 2:49 PM, Jacob wrote:
>>>>
>>>> set batFile {C:/Program Files/test.bat}
>>>> set runFile {C:/Program Files/runFile.txt}
>>>> set N 8
>>>> set command [concat \"$batFile\" \"$runFile\" $N]
>>>> exec {*}$command
>>>>
>>>
>>> Concat flattens the arguments you provide, and when the exec gets it, it
>>> looks for the first item as command name, which would be C:/Program.
>>>
>>> You want to try this instead:
>>>
>>> set command [list \"$batFile\" \"$runFile\" $N]
>>
>> Thanks for your suggestion. I actually have tried that as well, and get
>> the following error:
>>
>> couldn't execute ""C:/Program Files/test.bat"": No error
>>
>
> The quotes are unnecessary. Remove them.
>
> set command [list $batFile $runFile $N]
>
>
>

The problem appears to be when you have spaces in the path to the first parameter (the file to run/execute).

I can get it to work, but only by doing a

cd [file dirname $batFile]

and then only using the filename portion of batFile on the command line.

I believe this is likely a problem with [exec] as I recall a prior discussion on this a few years back.

On 2/20/2024 3:55 PM, et99 wrote:
> On 2/20/2024 1:33 PM, Anonymous wrote:
>> Jacob <JacobLambeth@clevelandgolf.com> wrote:
>>> On 2/20/2024 12:17 PM, saitology9 wrote:
>>>> On 2/20/2024 2:49 PM, Jacob wrote:
>>>>>
>>>>> set batFile {C:/Program Files/test.bat}
>>>>> set runFile {C:/Program Files/runFile.txt}
>>>>> set N 8
>>>>> set command [concat \"$batFile\" \"$runFile\" $N]
>>>>> exec {*}$command
>>>>>
>>>>
>>>> Concat flattens the arguments you provide, and when the exec gets it, it
>>>> looks for the first item as command name, which would be C:/Program.
>>>>
>>>> You want to try this instead:
>>>>
>>>> set command [list \"$batFile\" \"$runFile\" $N]
>>>
>>> Thanks for your suggestion. I actually have tried that as well, and get
>>> the following error:
>>>
>>> couldn't execute ""C:/Program Files/test.bat"": No error
>>>
>>
>> The quotes are unnecessary. Remove them.
>>
>> set command [list $batFile $runFile $N]
>>
>>
>>
>
> The problem appears to be when you have spaces in the path to the first parameter (the file to run/execute).
>
> I can get it to work, but only by doing a
>
> cd [file dirname $batFile]
>
> and then only using the filename portion of batFile on the command line.
>
> I believe this is likely a problem with [exec] as I recall a prior discussion on this a few years back.
>
>
>

Oh, forgot to show how I did the exec, so...

set command [list [file tail $batFile ] $runFile $N]
cd [file dirname $batFile]
exec cmd.exe /c {*}$command

Jacob <JacobLambeth@clevelandgolf.com> wrote:
> Hello,
>
> I am trying to execute a bat file that takes in a few arguments. From
> Windows command line, this works as intended:
>
>>"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>
> The tcl code looks like this:
>
> set batFile {C:/Program Files/test.bat}
> set runFile {C:/Program Files/runFile.txt}
> set N 8
> set command [concat \"$batFile\" \"$runFile\" $N]
> exec {*}$command
>
>
> Unless I'm missing something, this same process works fine for exe
> files. With the batch file, it appears to fail due to the spaces in the
> batch filepath. Any suggestions? I see online some suggestions to use
> auto_execok but I can't really figure out how to apply it in this scenario.
>
> Thanks,
>
> Jacob

et99 showed the way to "run" a bat file on windows.

The reason you are having trouble is that windows has no notion of
"script" files like Unix/Linux systems do (i.e., there is nothing
equivalent to the #!/path/to/interpreter feature of Unix/Linux in
windows)

So you either have to launch the proper interpreter, passing it the bat
file as a parameter (as et99 showed) or you have to use auto_execok to
obtain the right "invocation" to run the batch file (and auto_execok
should give back something similar to what et99 showed).

On Unix/Linux systems script files are first class "executables" just
the same as an ELF binary executable for the host CPU. Under windows,
script files (and bat files) are truly second class citizens, at best.

On 2/20/2024 6:44 PM, Rich wrote:
> Jacob <JacobLambeth@clevelandgolf.com> wrote:
>> Hello,
>>
>> I am trying to execute a bat file that takes in a few arguments. From
>> Windows command line, this works as intended:
>>
>>> "C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>>
>> The tcl code looks like this:
>>
>> set batFile {C:/Program Files/test.bat}
>> set runFile {C:/Program Files/runFile.txt}
>> set N 8
>> set command [concat \"$batFile\" \"$runFile\" $N]
>> exec {*}$command
>>
>>
>> Unless I'm missing something, this same process works fine for exe
>> files. With the batch file, it appears to fail due to the spaces in the
>> batch filepath. Any suggestions? I see online some suggestions to use
>> auto_execok but I can't really figure out how to apply it in this scenario.
>>
>> Thanks,
>>
>> Jacob
>
> et99 showed the way to "run" a bat file on windows.
>
> The reason you are having trouble is that windows has no notion of
> "script" files like Unix/Linux systems do (i.e., there is nothing
> equivalent to the #!/path/to/interpreter feature of Unix/Linux in
> windows)
>
> So you either have to launch the proper interpreter, passing it the bat
> file as a parameter (as et99 showed) or you have to use auto_execok to
> obtain the right "invocation" to run the batch file (and auto_execok
> should give back something similar to what et99 showed).
>
> On Unix/Linux systems script files are first class "executables" just
> the same as an ELF binary executable for the host CPU. Under windows,
> script files (and bat files) are truly second class citizens, at best.

A (lucky) google hit showed how it can actually be done w/o using the [cd], like this:

exec {*}[auto_execok start] {} /D [file dirname $batFile] [file tail $batFile] $runFile $N

To see what this expands to, I also dup'd this line changing exec to foo, with:
proc foo args {puts |$args|}
and get this result:

|C:/Windows/System32/cmd.exe /c start {} /D {C:/Users/et/Desktop/New folder} test.bat {C:/Users/et/Desktop/New folder/New Text Document.txt} 8|

The really strange thing is what this eventually results in (as reported in windows process explorer):

C:\WINDOWS\system32\cmd.exe /c ""C:\Users\et\Desktop\New folder\test.bat" "C:/Users/et/Desktop/New folder/New Text Document.txt" 8"

When it runs, it's set to the directory following the /D And yes, that is actually a pair of d-quotes around the whole shebang. I can't tell what part of that [exec] played, other than it's likely that it changed the forward / to \.

Ahhh the mysteries of windows :)

On 2/20/2024 10:03 PM, et99 wrote:
> exec {*}[auto_execok start] {} /D [file dirname $batFile] [file tail
> $batFile] $runFile $N

Thank you for your responses. This method does in fact work. It is
definitely more complicated than I would like. I explored solutions in
Python (subprocess.Popen) and Matlab (system) and they are much cleaner.
Perhaps they just have the same stuff already being done behind the scenes.

Am 21.02.2024 um 16:02 schrieb Jacob:
> On 2/20/2024 10:03 PM, et99 wrote:
>> exec {*}[auto_execok start] {} /D [file dirname $batFile] [file tail
>> $batFile] $runFile $N
>
> Thank you for your responses. This method does in fact work. It is
> definitely more complicated than I would like. I explored solutions in
> Python (subprocess.Popen) and Matlab (system) and they are much cleaner.
> Perhaps they just have the same stuff already being done behind the scenes.

IMHO, the following should do the job:

exec {*}[auto_execok start] "" [file nativename $batFile] [file
nativename $runFile] $N

Remark the empty pair of quotes as first argument of the start.exe
command. This is to avoid, that the batfile name is taken as window title.

Try "help start" in a dos box.

Remark also, that there are a couple of bugs here and 8.6.14 will again
change the behaviour.

Take care,
Harald

* Jacob <JacobLambeth@clevelandgolf.com>
| I am trying to execute a bat file that takes in a few arguments. From
| Windows command line, this works as intended:
>
| >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>
| The tcl code looks like this:
>
| set batFile {C:/Program Files/test.bat}
| set runFile {C:/Program Files/runFile.txt}
| set N 8
| set command [concat \"$batFile\" \"$runFile\" $N]
| exec {*}$command
>
>
| Unless I'm missing something, this same process works fine for exe
| files. With the batch file, it appears to fail due to the spaces in
| the batch filepath. Any suggestions?

IMHO you should just use [list] instead of [concat] to construct the
command and exec the .bat command directly, not via auto_execok, which
only introduces more quoting issues.

This works for me:

set batFile {C:/Program Files/test.bat}
set runFile {C:/Program Files/runFile.txt}
set N 8
set command [list $batFile $runFile $N]
exec {*}$command

TCL on Windows can 'exec' .bat files just fine (cf. TCL source code).

HTH
R'

On 2/21/2024 8:58 AM, Ralf Fassel wrote:
> * Jacob <JacobLambeth@clevelandgolf.com>
> | I am trying to execute a bat file that takes in a few arguments. From
> | Windows command line, this works as intended:
>>
> | >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>>
> | The tcl code looks like this:
>>
> | set batFile {C:/Program Files/test.bat}
> | set runFile {C:/Program Files/runFile.txt}
> | set N 8
> | set command [concat \"$batFile\" \"$runFile\" $N]
> | exec {*}$command
>>
>>
> | Unless I'm missing something, this same process works fine for exe
> | files. With the batch file, it appears to fail due to the spaces in
> | the batch filepath. Any suggestions?
>
> IMHO you should just use [list] instead of [concat] to construct the
> command and exec the .bat command directly, not via auto_execok, which
> only introduces more quoting issues.
>
> This works for me:
>
> set batFile {C:/Program Files/test.bat}
> set runFile {C:/Program Files/runFile.txt}
> set N 8
> set command [list $batFile $runFile $N]
> exec {*}$command
>
> TCL on Windows can 'exec' .bat files just fine (cf. TCL source code).
>
> HTH
> R'

Ralf,

This was actually the very first thing I tried. After troubleshooting a
bit more, it appears to fail when there is a space in $runFile.

-Jacob

On 2/21/2024 8:17 AM, Harald Oehlmann wrote:
> Am 21.02.2024 um 16:02 schrieb Jacob:
>> On 2/20/2024 10:03 PM, et99 wrote:
>>> exec {*}[auto_execok start] {} /D [file dirname $batFile] [file tail
>>> $batFile] $runFile $N
>>
>> Thank you for your responses. This method does in fact work. It is
>> definitely more complicated than I would like. I explored solutions in
>> Python (subprocess.Popen) and Matlab (system) and they are much
>> cleaner. Perhaps they just have the same stuff already being done
>> behind the scenes.
>
> IMHO, the following should do the job:
>
> exec {*}[auto_execok start] "" [file nativename $batFile] [file
> nativename $runFile] $N
>
> Remark the empty pair of quotes as first argument of the start.exe
> command. This is to avoid, that the batfile name is taken as window title.
>
> Try "help start" in a dos box.
>
> Remark also, that there are a couple of bugs here and 8.6.14 will again
> change the behaviour.
>
> Take care,
> Harald
>
>

Harald,

Thanks for the suggestion. It does not work for me. It opens up the
command prompt, but appears to fail due to the spaces in the filepath.

-Jacob

Am 20.02.24 um 20:49 schrieb Jacob:
> Hello,
>
> I am trying to execute a bat file that takes in a few arguments. From
> Windows command line, this works as intended:
>
> >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>
> The tcl code looks like this:
>
> set batFile {C:/Program Files/test.bat}
> set runFile {C:/Program Files/runFile.txt}
> set N 8
> set command [concat \"$batFile\" \"$runFile\" $N]
> exec {*}$command
>
>
> Unless I'm missing something, this same process works fine for exe
> files. With the batch file, it appears to fail due to the spaces in the
> batch filepath. Any suggestions? I see online some suggestions to use
> auto_execok but I can't really figure out how to apply it in this scenario.
>
> Thanks,
>
> Jacob

#! /usr/bin/env tclsh
set batFile "C:/Program Files/test.bat"
set runFile "C:/Program Files/runFile.txt"
set N 8
exec cmd /c start /min "" $batFile $runFile $N

On 2/21/2024 10:39 AM, Jacob wrote:
> On 2/21/2024 8:58 AM, Ralf Fassel wrote:
>> * Jacob <JacobLambeth@clevelandgolf.com>
>> | I am trying to execute a bat file that takes in a few arguments. From
>> | Windows command line, this works as intended:
>>>
>> | >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>>>
>> | The tcl code looks like this:
>>>
>> | set batFile {C:/Program Files/test.bat}
>> | set runFile {C:/Program Files/runFile.txt}
>> | set N 8
>> | set command [concat \"$batFile\" \"$runFile\" $N]
>> | exec {*}$command
>>>
>>>
>> | Unless I'm missing something, this same process works fine for exe
>> | files. With the batch file, it appears to fail due to the spaces in
>> | the batch filepath. Any suggestions?
>>
>> IMHO you should just use [list] instead of [concat] to construct the
>> command and exec the .bat command directly, not via auto_execok, which
>> only introduces more quoting issues.
>>
>> This works for me:
>>
>>     set batFile {C:/Program Files/test.bat}
>>     set runFile {C:/Program Files/runFile.txt}
>>     set N 8
>>     set command [list $batFile $runFile $N]
>>     exec {*}$command
>>
>> TCL on Windows can 'exec' .bat files just fine (cf. TCL source code).
>>
>> HTH
>> R'
>
> Ralf,
>
> This was actually the very first thing I tried. After troubleshooting a bit more, it appears to fail when there is a space in $runFile.
>
> -Jacob

Jacob:

Are you certain its the space in runFile? When I try with a batFile that has no spaces in the path, it works even if runFile has spaces. When batFile has the spaces is when all the previously suggested solutions failed for me.

I tried with several versions of tcl, including an 8.6.9 tclkit, 8.6.13 magicsplat, and 9.0b1 all 3 give the same error, which is not coming from tcl source code, but is the same exact text as this from a cmd window (and has the back slashes regardless of how I sent them to exec):

C:\>cmd.exe /c C:\Program Files\test.bat
'C:\Program' is not recognized as an internal or external command,
operable program or batch file.

which is because there's no quotes around the file name. So, somewhere in the translation, [exec] has stripped them before sending them in. That is why it works if there are no spaces in the path.

Also, all that auto_execok does is look at the first parameter, which is "start" and generates:

% auto_execok start
C:/Windows/System32/cmd.exe /c start

where (from looking at it's code) it uses:

% set env(COMSPEC)
C:\WINDOWS\system32\cmd.exe
% file attributes $env(COMSPEC) -shortname
C:/Windows/System32/cmd.exe

On 2/21/2024 11:37 AM, greg wrote:
> Am 20.02.24 um 20:49 schrieb Jacob:
>> Hello,
>>
>> I am trying to execute a bat file that takes in a few arguments. From Windows command line, this works as intended:
>>
>>  >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>>
>> The tcl code looks like this:
>>
>> set batFile {C:/Program Files/test.bat}
>> set runFile {C:/Program Files/runFile.txt}
>> set N 8
>> set command [concat \"$batFile\" \"$runFile\" $N]
>> exec {*}$command
>>
>>
>> Unless I'm missing something, this same process works fine for exe files. With the batch file, it appears to fail due to the spaces in the batch filepath. Any suggestions? I see online some suggestions to use auto_execok but I can't really figure out how to apply it in this scenario.
>>
>> Thanks,
>>
>> Jacob
>
> #! /usr/bin/env tclsh
> set batFile "C:/Program Files/test.bat"
> set runFile "C:/Program Files/runFile.txt"
> set N 8
> exec cmd /c start /min "" $batFile $runFile $N

Greg:

This doesn't work for me. It just hangs w/o running my batch file. I have to manually kill the processes (cmd and conhost). The command line that is ultimately generated will error out if typed into a cmd window.

The solution, as found here:

https://stackoverflow.com/questions/6376113/how-do-i-use-spaces-in-the-command-prompt

describes what I saw when I used the /D parameter, i.e. quotes around quotes. It does not seem to scan like tcl would, rather it must simply be looking at the first and last char for a " and then strips the pair, as in,

[string range <string> 1 end-1 ]

And then it process what's left as the command to run plus it's args.

On 2/21/2024 11:48 AM, et99 wrote:
> On 2/21/2024 10:39 AM, Jacob wrote:
>> On 2/21/2024 8:58 AM, Ralf Fassel wrote:
>>> * Jacob <JacobLambeth@clevelandgolf.com>
>>> | I am trying to execute a bat file that takes in a few arguments. From
>>> | Windows command line, this works as intended:
>>>>
>>> | >"C:\Program Files\test.bat" "C:\Program Files\runFile.txt" 8
>>>>
>>> | The tcl code looks like this:
>>>>
>>> | set batFile {C:/Program Files/test.bat}
>>> | set runFile {C:/Program Files/runFile.txt}
>>> | set N 8
>>> | set command [concat \"$batFile\" \"$runFile\" $N]
>>> | exec {*}$command
>>>>
>>>>
>>> | Unless I'm missing something, this same process works fine for exe
>>> | files. With the batch file, it appears to fail due to the spaces in
>>> | the batch filepath. Any suggestions?
>>>
>>> IMHO you should just use [list] instead of [concat] to construct the
>>> command and exec the .bat command directly, not via auto_execok, which
>>> only introduces more quoting issues.
>>>
>>> This works for me:
>>>
>>>     set batFile {C:/Program Files/test.bat}
>>>     set runFile {C:/Program Files/runFile.txt}
>>>     set N 8
>>>     set command [list $batFile $runFile $N]
>>>     exec {*}$command
>>>
>>> TCL on Windows can 'exec' .bat files just fine (cf. TCL source code).
>>>
>>> HTH
>>> R'
>>
>> Ralf,
>>
>> This was actually the very first thing I tried. After troubleshooting
>> a bit more, it appears to fail when there is a space in $runFile.
>>
>> -Jacob
>
> Jacob:
>
> Are you certain its the space in runFile? When I try with a batFile that
> has no spaces in the path, it works even if runFile has spaces. When
> batFile has the spaces is when all the previously suggested solutions
> failed for me.
>
> I tried with several versions of tcl, including an 8.6.9 tclkit, 8.6.13
> magicsplat, and 9.0b1 all 3 give the same error, which is not coming
> from tcl source code, but is the same exact text as this from a cmd
> window (and has the back slashes regardless of how I sent them to exec):
>
> C:\>cmd.exe /c C:\Program Files\test.bat
> 'C:\Program' is not recognized as an internal or external command,
> operable program or batch file.
>
> which is because there's no quotes around the file name. So, somewhere
> in the translation, [exec] has stripped them before sending them in.
> That is why it works if there are no spaces in the path.
>
> Also, all that auto_execok does is look at the first parameter, which is
> "start" and generates:
>
>
> % auto_execok start
> C:/Windows/System32/cmd.exe /c start
>
> where (from looking at it's code) it uses:
>
> % set env(COMSPEC)
> C:\WINDOWS\system32\cmd.exe
> % file attributes $env(COMSPEC) -shortname
> C:/Windows/System32/cmd.exe
>
>

Yes, it is quite weird. It will work if batFile OR runFile contain no
spaces. If both have a space, it fails!

On 2/21/2024 4:24 PM, Jacob wrote:
> Yes, it is quite weird. It will work if batFile OR runFile contain no spaces. If both have a space, it fails!

I agree, weird.

BTW, you might find this useful, here's my little windows arg tester .bat file I used for this exercise.

It's a template for a droplet that I use often. You can run it via command line or drop icons on the batch file icon itself. I use the technique for such things as, clipboard copy a file's full path, linux-like touch, and several checksums. It does assume wish is known to windows, else you need the full path.

::if 0 {
start wish "%~f0" %*
@echo off
for %%x in (%cmdcmdline%) do if /i "%%~x"=="/c" set DOUBLECLICKED=1
IF defined DOUBLECLICKED (
exit
) ELSE (
cmd /k
)
:: }
wm wi .
console show
console eval {wm geom . 146x13+128+128; wm protocol . WM_DELETE_WINDOW exit }
if {$argc > 0} {
puts "argc = |$argc| "
foreach arg $argv {
set type "-"
if { [file isdirectory $arg] } {
set type "D"
} elseif { [file readable $arg] } {
set type "F"
}
puts "arg [incr n] = $type |$arg| "
}
} else {
puts stderr "No arguments found"
}

* Jacob <JacobLambeth@clevelandgolf.com>
| On 2/21/2024 8:58 AM, Ralf Fassel wrote:
| > IMHO you should just use [list] instead of [concat] to construct the
| > command and exec the .bat command directly, not via auto_execok, which
| > only introduces more quoting issues.
| > This works for me:
| > set batFile {C:/Program Files/test.bat}
| > set runFile {C:/Program Files/runFile.txt}
| > set N 8
| > set command [list $batFile $runFile $N]
| > exec {*}$command
| > TCL on Windows can 'exec' .bat files just fine (cf. TCL source
| > code).
>
| Ralf,
>
| This was actually the very first thing I tried. After troubleshooting
| a bit more, it appears to fail when there is a space in $runFile.

Can you
- tell what 'fail' means in this context:
- TCL fails to execute the batch
- the batch fails to recognize the parameters
- other?

- show the contents of C:/Program Files/test.bat

- show the transcript of the session you tried?

Here's mine:

$ cd C:/Users/ralf/AppData/Local/Temp/foo bar

$ cat xxx.bat
@echo off
REM xxx.bat
echo this is xxx.bat
echo arguments /%1/ /%2/ /%3/

$ tclsh
% pwd
C:/Users/ralf/AppData/Local/Temp/foo bar
% set cmd [list [file join [pwd] xxx.bat] arg1 "arg2 with space" arg3]
{C:/Users/ralf/AppData/Local/Temp/foo bar/xxx.bat} arg1 {arg2 with space} arg3
% exec {*}$cmd
this is xxx.bat
arguments /arg1/ /"arg2 with space"/ /arg3/

HTH
R'

On 2/22/2024 2:20 AM, Ralf Fassel wrote:
> * Jacob <JacobLambeth@clevelandgolf.com>
> | On 2/21/2024 8:58 AM, Ralf Fassel wrote:
> | > IMHO you should just use [list] instead of [concat] to construct the
> | > command and exec the .bat command directly, not via auto_execok, which
> | > only introduces more quoting issues.
> | > This works for me:
> | > set batFile {C:/Program Files/test.bat}
> | > set runFile {C:/Program Files/runFile.txt}
> | > set N 8
> | > set command [list $batFile $runFile $N]
> | > exec {*}$command
> | > TCL on Windows can 'exec' .bat files just fine (cf. TCL source
> | > code).
>>
> | Ralf,
>>
> | This was actually the very first thing I tried. After troubleshooting
> | a bit more, it appears to fail when there is a space in $runFile.
>
> Can you
> - tell what 'fail' means in this context:
> - TCL fails to execute the batch
> - the batch fails to recognize the parameters
> - other?
>
> - show the contents of C:/Program Files/test.bat
>
> - show the transcript of the session you tried?
>
> Here's mine:
>
> $ cd C:/Users/ralf/AppData/Local/Temp/foo bar
>
> $ cat xxx.bat
> @echo off
> REM xxx.bat
> echo this is xxx.bat
> echo arguments /%1/ /%2/ /%3/
>
> $ tclsh
> % pwd
> C:/Users/ralf/AppData/Local/Temp/foo bar
> % set cmd [list [file join [pwd] xxx.bat] arg1 "arg2 with space" arg3]
> {C:/Users/ralf/AppData/Local/Temp/foo bar/xxx.bat} arg1 {arg2 with space} arg3
> % exec {*}$cmd
> this is xxx.bat
> arguments /arg1/ /"arg2 with space"/ /arg3/
>
> HTH
> R'

Ralf,

Sure, here is my bat file (test.bat):

@echo off
(for %%a in (%*) do (
echo %%a
))

I have placed the file in 2 locations:
"C:\batTest\bat test\test.bat"
"C:\batTest\test.bat"

I am running Tcl 8.6.13 via Magic Splat in tkcon shell.

(bin) 54 % #Test1:
set batFile {C:\batTest\bat test\test.bat}
set arg1 {argNoSpaces}
set arg2 8
set command [list $batFile $arg1 $arg2]
exec {*}$command

Output:
argNoSpaces
8

(bin) 59 % #Test2:
set batFile {C:\batTest\test.bat}
set arg1 {argNoSpaces}
set arg2 8
set command [list $batFile $arg1 $arg2]
exec {*}$command

Output:
argNoSpaces
8

(bin) 64 % #Test3:
set batFile {C:\batTest\test.bat}
set arg1 {arg with spaces}
set arg2 8
set command [list $batFile $arg1 $arg2]
exec {*}$command

Output:
"arg with spaces"
8

#Test4:
set batFile {C:\batTest\bat test\test.bat}
set arg1 {arg with spaces}
set arg2 8
set command [list $batFile $arg1 $arg2]
exec {*}$command

Output:
'C:\batTest\bat' is not recognized as an internal or external command,
operable program or batch file.

(bin) 89 % #Test5:
set batFile {C:\batTest\bat test\test.bat}
set arg1 {argNoSpace}
set arg2 {arg with spaces}
set command [list $batFile $arg1 $arg2]
exec {*}$command

Output:
'C:\batTest\bat' is not recognized as an internal or external command,
operable program or batch file.

* Jacob <JacobLambeth@clevelandgolf.com>
| Sure, here is my bat file (test.bat):
>
| @echo off
| (for %%a in (%*) do (
| echo %%a
| ))
>
--<snip-snip>--

Your test 1-3 show what I would expect.

| #Test4:
| set batFile {C:\batTest\bat test\test.bat}
| set arg1 {arg with spaces}
| set arg2 8
| set command [list $batFile $arg1 $arg2]
| exec {*}$command
>
| Output:
| 'C:\batTest\bat' is not recognized as an internal or external command,
| operable program or batch file.

Interesting. I get:

% set batFile {C:\batTest\bat test\test.bat}
C:\batTest\bat test\test.bat
% set arg1 {arg with spaces}
arg with spaces
% set arg2 8
8
% set command [list $batFile $arg1 $arg2]
{C:\batTest\bat test\test.bat} {arg with spaces} 8
% exec {*}$command
this is test.bat
"arg with spaces"
8
%

I.e. I get the expected result.

I had modified the test.bat with an additional first line
echo this is test.bat
to show whether I did get there at all, but it makes no difference if I
take that out again (I still get the expectzed result). I wonder
whether the message you see comes from the script (= Windows) or from TCL
(= tkcon trying to exec something).

If you add a first line to the test.bat script, do you get there, or
does tkcon bail out before it can execute the test.bat?

@echo off
echo this is test.bat
(for %%a in (%*) do (
echo %%a
))

| I am running Tcl 8.6.13 via Magic Splat in tkcon shell.

I'm running a self-compiled 8.6.13...

R'

On 2/22/2024 8:16 AM, Ralf Fassel wrote:
> * Jacob <JacobLambeth@clevelandgolf.com>
> | Sure, here is my bat file (test.bat):
>>
> | @echo off
> | (for %%a in (%*) do (
> | echo %%a
> | ))
>>
> --<snip-snip>--
>
> Your test 1-3 show what I would expect.
>
>
> | #Test4:
> | set batFile {C:\batTest\bat test\test.bat}
> | set arg1 {arg with spaces}
> | set arg2 8
> | set command [list $batFile $arg1 $arg2]
> | exec {*}$command
>>
> | Output:
> | 'C:\batTest\bat' is not recognized as an internal or external command,
> | operable program or batch file.
>
> Interesting. I get:
>
> % set batFile {C:\batTest\bat test\test.bat}
> C:\batTest\bat test\test.bat
> % set arg1 {arg with spaces}
> arg with spaces
> % set arg2 8
> 8
> % set command [list $batFile $arg1 $arg2]
> {C:\batTest\bat test\test.bat} {arg with spaces} 8
> % exec {*}$command
> this is test.bat
> "arg with spaces"
> 8
> %
>
> I.e. I get the expected result.
>
> I had modified the test.bat with an additional first line
> echo this is test.bat
> to show whether I did get there at all, but it makes no difference if I
> take that out again (I still get the expectzed result). I wonder
> whether the message you see comes from the script (= Windows) or from TCL
> (= tkcon trying to exec something).
>
> If you add a first line to the test.bat script, do you get there, or
> does tkcon bail out before it can execute the test.bat?
>
> @echo off
> echo this is test.bat
> (for %%a in (%*) do (
> echo %%a
> ))
>
>
> | I am running Tcl 8.6.13 via Magic Splat in tkcon shell.
>
> I'm running a self-compiled 8.6.13...
>
> R'

Thanks Ralf. Changing the first line of the bat file makes no difference
for me. I have identified a few more instances where Test4 works and
doesn't:

tcl 8.6.13 tkcon: fails
tcl 8.6.13 tclsh: works
tcl 8.6.13 wish: fails
tcl 8.5.9 tkcon: works
tcl 8.5.9 tclsh: works
tcl 8.5.9 wish: works

-Jacob

On 2/22/2024 9:30 AM, Jacob wrote:
>
> Ralf,
>
> Sure, here is my bat file (test.bat):
>
> @echo off
> (for %%a in (%*) do (
> echo %%a
> ))
>
> I have placed the file in 2 locations:
> "C:\batTest\bat test\test.bat"
> "C:\batTest\test.bat"
>

Exec behavior may vary a bit depending on the platform, like using the
right quotation to mark individual arguments to the command itself, but
nevertheless this is interesting.

With a wish shell or from tkcon, there seems to be no way to properly
escape an argument containing spaces, to the command being invoked,
without breaking the exec command.

However, from a plain tclsh, everything works fine. You can escape
arguments with spaces by enclosing them in double-quotes, which Windows
accepts fine.

# i added a line to the bat file
% exec $bat
done...

% exec $bat 1 2 3
1 2
3 done...

% exec $bat 1 2 3 "Hello there"
1 2
3 "Hello there"
done...

* Jacob <JacobLambeth@clevelandgolf.com>
| Thanks Ralf. Changing the first line of the bat file makes no
| difference for me. I have identified a few more instances where Test4
| works and
| doesn't:
>
| tcl 8.6.13 tkcon: fails
| tcl 8.6.13 tclsh: works
| tcl 8.6.13 wish: fails
| tcl 8.5.9 tkcon: works
| tcl 8.5.9 tclsh: works
| tcl 8.5.9 wish: works

Ah, I always tried it via tclsh. My self-compiled wish 8.6.13 also
succeeds, whereas the wish 8.6.12 which comes with MSYS2 also fails.

Weird... maybe open a ticket on https://core.tcl-lang.org ?

R'

On 2/22/2024 9:43 AM, saitology9 wrote:
> On 2/22/2024 9:30 AM, Jacob wrote:
> >
> > Ralf,
> >
> > Sure, here is my bat file (test.bat):
> >
> > @echo off
> > (for %%a in (%*) do (
> >      echo %%a
> > ))
> >
> > I have placed the file in 2 locations:
> > "C:\batTest\bat test\test.bat"
> > "C:\batTest\test.bat"
> >
>
> Exec behavior may vary a bit depending on the platform, like using the right quotation to mark individual arguments to the command itself, but nevertheless this is interesting.
>
>
> With a wish shell or from tkcon, there seems to be no way to properly escape an argument containing spaces, to the command being invoked, without breaking the exec command.
>
>
> However, from a plain tclsh, everything works fine.  You can escape arguments with spaces by enclosing them in double-quotes, which Windows accepts fine.
>
>
> # i added a line to the bat file
> % exec $bat
> done...
>
> % exec $bat 1 2 3
> 1
> 2
> 3
> done...
>
> % exec $bat 1 2 3 "Hello there"
> 1
> 2
> 3
> "Hello there"
> done...
>
>
>
>

I think some of these different results might also depend on the value of tcl_interactive.

When it's set to 1, I can type (into a wish console):

% start wish "C:/Users/et/Desktop/New folder/testargs.bat" one two "thr ee"

and this works. But with exec it fails:

% exec "C:/Users/et/Desktop/New folder/testargs.bat" one two "thr ee"
'C:\Users\et\Desktop\New' is not recognized as an internal or external command,
operable program or batch file.

but if "thr ee" is "three" it again works.

I searched the tcl source and that message is nowhere to be found, I'm pretty certain it comes from windows, perhaps from some kind of error code to text windows call.

I think a ticket is in order.