Various fixes

- Actions update handlers were wonkey. Now moved most logic to the action activate handler
- Updated docs

Author: 0xeb

README.md

@@ -14,51 +14,53 @@ To execute a script, just press `ENTER` or double-click it. After running a scri
 
 An active script will then be monitored for changes. If you modify the script in your favorite text editor and save it, then QScripts will execute the script for you automatically in IDA.
 
-To deactivate a script, just press `Ctrl-D` or right-click and choose `Deactivate script monitor` from the QScripts window. When an active script becomes inactive, it will be shown in *italics*.
+To deactivate the script monitor, just press `Ctrl-D` or right-click and choose `Deactivate script monitor` from the QScripts window. When an active script becomes inactive, it will be shown in *italics*.
 
 There are few options that can be configured in QScripts. Just press `Ctrl+E` or right-click and select `Options`:
 
 * Clear message window before execution: clear the message log before re-running the script. Very handy if you to have a fresh output log each time.
 * Show file name when execution: display the name of the file that is automatically executed
-* Execute the unload script function: A special function, if defined, called `__quick_unload_script` will be invoked before reloading the script. This gives your script a chance to do some cleanup (for example to unregister some hotkeys)
+* Execute the unload script function: A special function, if defined in the global scope (usually by your active script), called `__quick_unload_script` will be invoked before reloading the script. This gives your script a chance to do some cleanup (for example to unregister some hotkeys)
 * Script monitor interval: controls the refresh rate of the script change monitor. Ideally 500ms is a good amount of time to pick up script changes.
-* Allow QScripts execution to be undo-able: The executed script's side effects can be reverted with IDA's Undo
+* Allow QScripts execution to be undo-able: The executed script's side effects can be reverted with IDA's Undo.
 
 ## Executing a script without activating it
 
-It is possible to execute a script from QScripts without having to activate it. Just press `Shift-ENTER` on a script and it will be executed.
+It is possible to execute a script from QScripts without having to activate it. Just press `Shift-Enter` on a script and it will be executed (disregarding if there's an active script or not).
 
-## Working with dependencies
+## Managing Dependencies in QScripts
 
-It is possible to instruct QScripts to re-execute the active script if any of its dependent scripts are also modified. To use the automatic dependency system, please create a file named exactly like your active script but with the additional `.deps.qscripts` extension. In that file you put your dependent scripts path.
+QScripts offers a feature that allows automatic re-execution of the active script when any of its dependent scripts, undergo modifications.
 
-When using Python, it would be helpful if we can also [reload](https://docs.python.org/3/library/importlib.html#importlib.reload) the changed dependent script from the active script automatically. To do that, simply add the directive line `/reload` along with the desired reload syntax. For example, here's a complete `.deps.qscripts` file with a `reload` directive (for Python 2.x):
+### Setting Up Automatic Dependencies
 
-```
-/reload reload($basename$)
-t2.py
-// This is a comment
-t3.py
-```
+To leverage this automatic dependency tracking feature, create a file named identically to your active script, appending `.deps.qscripts` to its name. This file should contain paths to dependent scripts, along with any necessary reload directives.
 
-And for Python 3.x:
+Optionally, you can place the `.deps.qscripts` file within a `.qscripts` subfolder, located alongside your active script.
 
-```
-/reload import importlib;importlib.reload($basename$);
+### Integrating Python Scripts
+
+For projects involving Python, QScripts can automatically [reload](https://docs.python.org/3/library/importlib.html#importlib.reload) any changed dependent Python scripts. Include a `/reload` directive in your `.deps.qscripts` file, followed by the appropriate Python reload syntax.
+
+#### Example `.deps.qscripts` file for `t1.py`:
+
+```plaintext
+/reload import importlib; import $basename$; importlib.reload($basename$);
 t2.py
 # This is a comment
 t3.py
 ```
 
-So what happens now if we have an active file `t1.py` with the dependency file above?
+The `t1.py.deps.qscripts` configuration enables the following behavior:
 
-1. Any time `t1.py` changes, it will be automatically re-executed in IDA.
-2. If the dependency index file `t1.py.deps.qscripts` is changed, then your new dependencies will be reloaded and the active script will be executed again.
-3. If any dependency script file has changed, then the active script will re-execute. If you had a `reload` directive set up, then the modified dependency files will also be reloaded.
+1. **Script Auto-Execution**: Changes to `t1.py` trigger its automatic re-execution within the IDA environment.
+2. **Dependency Reload**: Modifications to the dependency index file (`t1.py.deps.qscripts`) lead to the reloading of specified dependencies, followed by the re-execution of the active script.
+3. **Dependency Script Changes**: Any alteration in a dependency script file causes the active script to re-execute. If a reload directive is present, the modified dependency files are also reloaded. In our cases, if either or both of `t2.py` and `t3.py` are modified, `t1.py` is re-executed and the modified dependencies are reloaded as well.
 
-Please note that if each dependent script file has its own dependency index file, then QScripts will recursively make all the linked dependencies as part of the active script dependencies. In this case, the directives (such as `reload`) are ignored.
+**Note**: If a dependent script possesses its own `.deps.qscripts` file, QScripts recursively integrates all linked dependencies into the active script's dependencies. However, specific directives (e.g., `reload`) within these recursive dependencies are disregarded.
 
 See also:
+
 * [Simple dependency example](test_scripts/dependency-test/README.md)
 * [Package dependency example](test_scripts/pkg-dependency/README.md)
 

qscripts.cpp

@@ -41,6 +41,7 @@ struct qscripts_chooser_t: public plugmod_t, public chooser_t
     int opt_with_undo        = 0;
 
     active_script_info_t selected_script;
+    script_info_t* action_active_script = nullptr;
 
     struct expand_ctx_t
     {
@@ -329,26 +330,30 @@ struct qscripts_chooser_t: public plugmod_t, public chooser_t
 
             if (!elang->eval_snippet(reload_cmd.c_str(), &err))
             {
-				err.sprnt("failed to execute the reload directive for '%s' with command: %s!\n", 
-                    script_file,
-                    reload_cmd.c_str());
+                err.sprnt(
+                    "QScripts failed to reload script file: '%s'\n"
+                    "Reload command used: %s", script_file, reload_cmd.c_str());
                 break;
             }
             return true;
         } while (false);
 
         if (!silent)
-            msg("QScripts failed to reload script file: '%s'\nReload command used: %s", script_file, err.c_str());
+			msg("%s", err.c_str());
 
         return false;
     }
 
     bool execute_script(script_info_t *script_info, bool with_undo)
     {
         if (with_undo)
-            return process_ui_action(ACTION_EXECUTE_SCRIPT_WITH_UNDO_ID);
-        else
-            return execute_script_sync(script_info);
+        {
+            action_active_script = script_info;
+            auto r = process_ui_action(ACTION_EXECUTE_SCRIPT_WITH_UNDO_ID);
+            action_active_script = nullptr;
+            return r;
+        }
+        return execute_script_sync(script_info);
     }
 
     // Executes a script file
@@ -824,14 +829,14 @@ struct qscripts_chooser_t: public plugmod_t, public chooser_t
             "Deactivate script monitor",
             "Ctrl+D",
             FO_ACTION_UPDATE([this],
-                if (!this->is_correct_widget(ctx))
-                    return AST_DISABLE_FOR_WIDGET;
-                else
-                    return this->is_monitor_active() ? AST_ENABLE : AST_DISABLE;
+                return this->is_correct_widget(ctx) ? AST_ENABLE_FOR_WIDGET : AST_DISABLE_FOR_WIDGET;
             ),
             FO_ACTION_ACTIVATE([this]) {
-                this->clear_selected_script();
-                refresh_chooser(QSCRIPTS_TITLE);
+                if (this->is_monitor_active())
+                {
+                    this->clear_selected_script();
+                    refresh_chooser(QSCRIPTS_TITLE);
+                }
                 return 1;
             },
             nullptr,
@@ -843,10 +848,7 @@ struct qscripts_chooser_t: public plugmod_t, public chooser_t
             "Execute selected script",
             "Shift+Enter",
             FO_ACTION_UPDATE([this],
-                if (!this->is_correct_widget(ctx))
-                    return AST_DISABLE_FOR_WIDGET;
-                else
-                    return ctx->chooser_selection.empty() ? AST_DISABLE : AST_ENABLE;
+                return this->is_correct_widget(ctx) ? AST_ENABLE_FOR_WIDGET : AST_DISABLE_FOR_WIDGET;
             ),
             FO_ACTION_ACTIVATE([this]) {
                 if (!ctx->chooser_selection.empty())
@@ -862,10 +864,12 @@ struct qscripts_chooser_t: public plugmod_t, public chooser_t
             "QScripts monitor: execute last active script",
             "Alt-Shift-X",
             FO_ACTION_UPDATE([this],
-                return this->has_selected_script() ? AST_ENABLE : AST_DISABLE;
+                return AST_ENABLE_ALWAYS;
             ),
             FO_ACTION_ACTIVATE([this]) {
-                if (this->has_selected_script())
+                if (action_active_script != nullptr)
+                    this->execute_script_sync(action_active_script);
+                else if (this->has_selected_script())
                     this->execute_script_sync(&selected_script);
                 return 1;
             },

test_scripts/dependency-test/README.md

@@ -2,7 +2,7 @@ This is a dependency test folder.
 
 The script `t1.py` has its dependency index file which describes the reload directive and one dependency on `t2.py`:
 ```
-/reload import importlib;importlib.reload($basename$)
+/reload import importlib;import $basename$;importlib.reload($basename$)
 t2.py
 ```
 

test_scripts/pkg-dependency/README.md

@@ -6,7 +6,7 @@ For this purpose, we can either explicitly specify the package's full path or re
 # Define package base folder
 /pkgbase $env:idapyx$
 # Automatically reload the package's modules when they change
-/reload import importlib; from $pkgparentmodname$ import $basename$ as __qscripts_autoreload__; importlib.reload(__qscripts_autoreload__)
+/reload import importlib;from $pkgparentmodname$ import $basename$ as __qscripts_autoreload__; importlib.reload(__qscripts_autoreload__)
 # Specify the paths to the package modules that need to be reloaded if they change
 $pkgbase$/idapyx/bin/pe/rtfuncs.py
 $pkgbase$/idapyx/bin/pe/types.py