Qual é a melhor maneira de invocar um comando de 32 bits com Shell.Run no VBScript, de modo que ele seja bem-sucedido nos sistemas operacionais Windows de 32 bits e 64 bits?
Em 64 bits, o aplicativo é encerrado porque não é um processo de 64 bits. Embora eu possa usar c: \ windows \ syswow64 \ cscript.exe myscript.vbs, isso não é portátil para o Windows 32 bits.
Não consigo reproduzir o problema que você está descrevendo no meu sistema. Se eu escrever um VBScript para invocar a versão de 32 bits do Bloco de Notas em% windir% \ syswow64 usando Shell.Run, ele funcionará bem apesar do fato de o host de script ser de 64 bits e o Bloco de Notas ser de 32 bits.
Set oShell = WScript.CreateObject("WScript.Shell")
oShell.Run "%windir%\syswow64\notepad.exe"
Qual comando de 32 bits você está tentando chamar que está falhando?
Eu percebo que essa pergunta é antiga, mas estou postando uma resposta para ela de qualquer maneira, porque tenho algum conhecimento específico e relevante sobre isso e é útil para futuros Googlers (como eu me deparei com isso).
A Microsoft fornece versões de 32 e 64 bits do host de scripts do Windows ( cscript.exe e wscript.exe ) em um sistema de 64 bits, com o padrão sendo a versão nativa da plataforma quando um script é executado. Isso é uma boa notícia porque significa que você pode lidar com as diferenças de plataforma sem ter que se preocupar com o comportamento externo do WSH em um ambiente emulado de 32 bits em uma máquina de 64 bits. Se você quiser confiar nesse comportamento, poderá invocar manualmente cscript ou wscript do diretório \SysWOW64 , mas geralmente é preferível usar a versão nativa e lidar com as diferenças de plataforma em seu próprio código.
Eu sempre começo cada VBScript que escrevo com o seguinte:
Option Explicit 'I always use this to avoid spelling errors in var names; Just my personal preference
Dim objShell :Set objShell = CreateObject("WScript.Shell")
Dim objFS :Set objFS = CreateObject("Scripting.FileSystemObject")
'Determine OS platform
Dim strPlatform :strPlatform = objShell.ExpandEnvironmentStrings("%PROCESSOR_ARCHITECTURE%")
If strPlatform = "AMD64" Then strPlatform = "x64"
'Set 32-bit and 64-bit filesystem paths
Dim strProgramFilesX64 'Will always be "\Program Files", regardless of platform
Dim strProgramFilesX86 'Will be "\Program Files (x86)" on 64-bit, otherwise "\Program Files" on 32-bit
Dim strSystem32X64 'Will always be "\Windows\System32", regardless of platform
Dim strSystem32X86 'Will be "\Windows\SysWOW64" on 64-bit, otherwise "\Windows\System32" on 32-bit
strProgramFilesX64 = objShell.ExpandEnvironmentStrings("%ProgramFiles%")
strSystem32X64 = objShell.ExpandEnvironmentStrings("%SystemRoot%") & "\System32"
If strPlatform = "x64" Then
strProgramFilesX86 = objShell.ExpandEnvironmentStrings("%ProgramFiles(x86)%")
strSystem32X86 = objShell.ExpandEnvironmentStrings("%SystemRoot%") & "\SysWOW64"
Else
strProgramFilesX86 = strProgramFilesX64
strSystem32X86 = strSystem32X64
End If
Observe que o código acima usa variáveis de ambiente do shell para definir a plataforma e os caminhos de 64 bits primeiro. Isso ocorre porque essas variáveis são comuns a todas as versões do Windows, mas as específicas do x86 são definidas apenas em sistemas de 64 bits (o que é reverso na minha opinião).
Usar esse código no início de seus scripts faz com que sejam totalmente portáveis entre as plataformas. Você pode controlar o comportamento de seu próprio código usando as variáveis strProgramFilesX86/64 e strSystem32X86/64 e elas sempre serão mapeadas para os locais corretos, independentemente da plataforma em que o script está sendo executado.
Por exemplo, se você estiver usando objShell.Run() para lançar algo que você sabe que é um software de 32 bits, você sempre poderá usar objShell.Run(strProgramFilesX86 & "\MyApp\App.exe") e ele será executado corretamente a partir de Program Files (x86) em sistemas de 64 bits. \Program Files em sistemas de 32 bits.
Você também pode usar a variável strPlatform se precisar que algo diferente aconteça em uma plataforma versus a outra. Por exemplo, quando estou fazendo instalações de software e tenho uma versão de 32 bits e uma de 64 bits do software. Eu renomeio a versão de 32 bits para ter um -x86 no final do nome do arquivo e, da mesma forma, -x64 com a versão de 64 bits. Dessa forma, posso chamar o instalador com uma única linha de código sem me importar com a plataforma, assim:
objShell.Run "setup-" & strPlatform & ".exe"
Isso será avaliado como setup-x64.exe em um sistema de 64 bits e setup-x86.exe em um sistema de 32 bits.
Contanto que você se atenha a essas variáveis, não precisa se preocupar em manter duas versões diferentes de seus scripts ou em qual plataforma o computador de destino está executando.