Short answer: You can't fully recover the original, human-readable Setup.rul script from a compiled InstallShield 2012 EXE, but there are practical workarounds to reverse-engineer key logic and resources you need to build your new installer. Let's break down your options:

1. Extract Non-Script Resources First #

Even if you can't get the original script, you can pull out critical assets from the EXE to speed up rebuilding your new installer:

• Use InstallShield itself: Open InstallShield, go to File > Open > Installer Package, select your old EXE. This lets you extract things like dialog layouts, file/folder structures, registry entries, and component configurations. These are all visual or declarative elements you can directly reuse in your new project.
• Use a general extraction tool like Universal Extractor to unpack the EXE's contents. You'll get access to embedded CAB files, the underlying MSI (if it's a Basic MSI project), or compiled InstallScript bytecode files. While the bytecode isn't readable Setup.rul, it's the foundation for the next step.

2. Try Decompiling InstallScript Bytecode #

InstallShield compiles Setup.rul into proprietary bytecode that's embedded in the EXE. There are specialized decompiler tools designed to convert this bytecode back into a pseudo-Setup.rul format. Keep in mind:

• The decompiled code won't match the original. Variable names will be generic (like var1, var2), comments will be gone, and complex logic might be scrambled. You'll need to spend time tracing through the code to map it to the original installer's behavior.
• Support for InstallShield 2012 might be hit-or-miss with these tools. Some older decompilers work better with specific versions, so you may need to test a couple options.
• If the EXE is packed or encrypted (some enterprise installers use this), decompilation will likely fail entirely.

3. Reverse-Engineer Behavior Instead of Code #

If decompilation doesn't give you usable results, focus on replicating what the installer does rather than how it's coded:

• Use Process Monitor to track every file write, registry change, and system call during the old installer's run. This gives you a precise log of all the installer's actions, which you can replicate in your new project's custom actions or declarative settings.
• Use InstallShield's built-in Monitor Installation tool (under the Tools menu). Run this tool, launch your old installer, and it will capture all the installation steps and generate a new InstallShield project skeleton with those actions pre-configured. This is often faster than decompiling for straightforward installers.
• Manually document the old installer's flow: Walk through each dialog, note component options, custom prompts, post-install actions, and error handling. Then build these elements from scratch in your new InstallShield project.

Key Limitations to Keep in Mind #

• Full recovery of the original Setup.rul is impossible. Compilation discards too much human-readable context (comments, meaningful variable names, original code structure).
• Decompiled code will require significant cleanup to be usable, especially for complex installers with custom logic.
• Encrypted or packed installers will block most extraction/decompilation attempts.

At the end of the day, if you just need to replicate specific features of the old installer, combining resource extraction with behavior replication will get you much further than chasing the original Setup.rul file.

内容的提问来源于stack exchange，提问作者SRP