opencos-eda 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

opencos/commands/deps_help.py

@@ -10,32 +10,37 @@ it is generally run as simply
 uses no tools and will print a help text regarding DEPS markup files to stdout.
 '''
 
+# pylint: disable=line-too-long
 
 import os
 
 from opencos.eda_base import Command
 from opencos import util
+from opencos.util import Colors
 
 
-BASIC_DEPS_HELP = '''
+BASIC_DEPS_HELP = f'''
+{Colors.yellow}
+Note: you can run with one of: {Colors.cyan}--verbose, --help, --debug{Colors.yellow} to show full
+schema supported, or {Colors.cyan}--no-color{Colors.yellow} to avoid printing this text with colors.
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
-  What is a DEPS.yml file and why does `eda` use this?
-  - DEPS.yml is a fancy filelist.
+  What is a {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} file and why does `eda` use this?
+  - {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} is a fancy filelist.
   - Used to organize a project into "targets", a tool can run on a "target".
   - Allows for more than just source files attached to a "target".
     -- incdirs, defines, and args can be applied to a "target".
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
   Hello World example:
 
-  The following example is a DEPS.yml file example for a SystemVerilog simulation of
-  hello_world_tb.sv. DEPS.yml is, in short, a fancy filelist. We use them in the `eda`
+  The following example is a {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} file example for a SystemVerilog simulation of
+  hello_world_tb.sv. {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} is, in short, a fancy filelist. We use them in the `eda`
   app to organize projects.
 
---- DEPS.yml: ---
+--- {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 hello-world:           # <-- this is a named target that will be run
 
@@ -64,20 +69,20 @@ endmodule : hello_world_tb
 
 
   hello-world:
-    The target name in the DEPS.yml we named is hello-world. That is a valid target
+    The target name in the {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} we named is hello-world. That is a valid target
     that `eda` can use. Such as:
 
        eda sim --tool=verilator hello-world
 
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
    Beyond Hello World example:
 
    The following example is a DEPS.yml file for a more complex module simulation.
    It has two files in ./DEPS.yml and ./lib/DEPS.yml.
 
---- ./DEPS.yml: ---
+--- {Colors.byellow}./DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 my_fifo:                         # <-- this is a design
   incdirs: . lib                 # <-- 'incdirs' define the paths searched to find `include files
@@ -102,7 +107,7 @@ my_fifo_stress_test:             # <-- this is another TEST
   deps:
     - my_fifo_test               # aside from the define, this is same as "my_fifo_test"
 
---- lib/DEPS.yml: ---
+--- {Colors.byellow}lib/DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 lib_pkg:                         # <-- this is a package required by bin_to_gray below
   deps:
@@ -115,15 +120,15 @@ bin_to_gray:                     # <-- this is the target that was required by .
                                  # to be read before the code that uses them
     - bin_to_gray.sv             # an SV module pulled in directly
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 '''
 
 
-FULL_DEPS_HELP = '''
+FULL_DEPS_HELP = f'''
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
-   Full DEPS.yml schema:
+   Full {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} schema:
 
 ```
 DEFAULTS: # <table> defaults applied to ALL targets in this file, local targets ** override ** the defaults.
@@ -140,6 +145,14 @@ target-spec:
     SOME_DEFINE: value
     SOME_DEFINE_NO_VALUE:   # we just leave this blank, or use nil (yaml's None)
 
+  plusargs: # <table>
+    variable0: value
+    variable1:              # blank for no value, or use nil (yaml's None)
+
+  parameters: # <table>
+    SomeParameter: value
+    SOME_OTHER_PARAMETER: value
+
   incdirs: # <array>
     - some/relative/path
 
@@ -150,20 +163,22 @@ target-spec:
     - some_file.sv               # <string> aka, a file
     - sv@some_file.txt           # <string> aka, ext@file where we'd like a file not ending in .sv to be
                                  # treated as a .sv file for tools.
-                                 # Supported for sv@, v@, vhdl@, cpp@
+                                 # Supported for sv@, v@, vhdl@, cpp@, sdc@, f@, py@, makefile@
     - commands:                  # <table> with key 'commands' for a <array>:  support for built-in commands
                                  # Note this cannot be confused for other targets or files.
       - shell: # <string>
-        var-subst-args: # <bool> default false. If true, substitute vars in commands, such as {fpga}
-                        # substituted from eda arg --fpga=SomeFpga, such that {fpga} becomes SomeFpga
+        var-subst-args: # <bool> default false. If true, substitute vars in commands, such as {{fpga}}
+                        # substituted from eda arg --fpga=SomeFpga, such that {{fpga}} becomes SomeFpga
         var-subst-os-env:  #<bool> default false. If true, substitute vars in commands using os.environ vars,
-                           # such as {FPGA} could get substituted by env value for $FPGA
-        tee: # <string> optional filename, otherwise shell commands write to {target-spec}__shell_0.log
+                           # such as {{FPGA}} could get substituted by env value for $FPGA
+        tee: # <string> optional filename, otherwise shell commands write to {{target-spec}}__shell_0.log
         run-from-work-dir: #<bool> default true. If false, runs from the directory of this DEPS file.
         filepath-subst-target-dir: #<bool> default true. If false, disables shell file path
 	                               substituion on this target's directory (this DEPS file dir).
         dirpath-subst-target-dir: #<bool> default false. If true, enables shell directory path
 	                              substituion on this target's directory (this DEPS file dir).
+        run-after-tool: # <bool> default false. Set to true to run after any EDA tools, or
+	                any command handlers have completed.
       - shell: echo "Hello World!"
       - work-dir-add-sources: # <array or | space separated string>, this is how to add generated files
                               # to compile order list.
@@ -196,6 +211,8 @@ target-spec:
     args: # <array or | space separated string>
     deps: # <array or | space separated string> # Note: not implemented yet
     defines: ## <table>
+    plusargs: ## <table>
+    parameters: ## <table>
     incdirs: ## <array>
 
   tags: # <table> this is the currently support tags features in a target.
@@ -215,6 +232,8 @@ target-spec:
                                           # tool in 'with-tools'.
       deps: <array or | space separated string, applied with tag>
       defines: <table, applied with tag>
+      plusargs: <table, applied with tag>
+      parameters: <table, applied with tag>
       incdirs: <array, applied with tag>
       replace-config-tools: <table>  # spec matching eda_config_defaults.yml::tools.<tool> (replace merge strategy)
       additive-config-tools: <table> # spec matching eda_config_defaults.yml::tools.<tool> (additive merge strategy)

opencos/commands/sim.py

@@ -300,7 +300,6 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         tool = self.args.get('tool', None)
         # Certain args are allow-listed here
         deps_file_args = []
-        print(f'SUPER DREW DEBUG: {self.get_command_line_args()=}')
         for a in self.get_command_line_args():
             if any(a.startswith(x) for x in [
                     '--compile-args',

opencos/deps/deps_file.py

@@ -16,7 +16,7 @@ from opencos.util import debug, error
 from opencos.utils.markup_helpers import yaml_safe_load, toml_load_only_root_line_numbers, \
     markup_writer, markup_dumper
 from opencos.utils.str_helpers import fnmatch_or_re, dep_str2list, pretty_list_columns_manual, \
-    is_valid_target_name, VALID_TARGET_INFO_STR
+    is_valid_target_name, VALID_TARGET_INFO_STR, get_shorter_path_str_rel_vs_abs
 from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils.status_constants import EDA_DEPS_FILE_NOT_FOUND, EDA_DEPS_TARGET_NOT_FOUND
 
@@ -270,9 +270,12 @@ class DepsFile:
         return f'line={self.line_numbers.get(target_node, "")}'
 
     def gen_caller_info(self, target: str) -> str:
-        '''Given a full target name (path/to/my_target) return caller_info str for debug'''
+        '''Given a full target name (path/to/my_target) return caller_info str for debug
+
+        Use abspath if the str is shorter, for the path information part.
+        '''
         return '::'.join([
-            self.rel_deps_file,
+            get_shorter_path_str_rel_vs_abs(rel_path=self.rel_deps_file),
             target,
             self.get_approx_line_number_str(target)
         ])
@@ -298,90 +301,90 @@ class DepsFile:
         some caller_info(str). This is more useful for YAML or TOML markup where we have
         caller_info.
         '''
-        if target_node not in self.data:
-            found_target = False
 
-            if target_node.startswith('-'):
-                # likely an unparsed arg that made it this far.
-                util.warning(f"Ignoring unparsed argument '{target_node}'")
-                return False
+        if target_node in self.data:
+            debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
+            return True
 
-            # For error printing, prefer relative paths:
-            if self.target_path:
-                t_path = os.path.relpath(self.target_path) + os.path.sep
-            else:
-                t_path = ''
-            t_node = target_node
-            t_full = os.path.join(t_path, t_node)
+        if target_node.startswith('-'):
+            # likely an unparsed arg that made it this far.
+            util.warning(f"Ignoring unparsed argument '{target_node}'")
+            return False
 
-            if not is_valid_target_name(target_node):
-                util.warning(
-                    f"In file {self.rel_deps_file}, {target_node} {VALID_TARGET_INFO_STR}"
-                )
+        # For error printing, prefer relative paths, unless the abspath is shorter:
+        if self.target_path:
+            t_path = os.path.relpath(self.target_path) + os.path.sep
+            t_path = get_shorter_path_str_rel_vs_abs(rel_path=t_path)
+        else:
+            t_path = ''
+        t_node = target_node
+        t_full = os.path.join(t_path, t_node)
 
-            if not caller_info:
-                # If we don't have caller_info, likely came from command line (or DEPS JSON data):
-                if '.' in target_node:
-                    # Likely a filename (target_node does not include path)
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full} (file?):',
-                        f'File={t_node} not found in directory={t_path}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                elif not self.rel_deps_file:
-                    # target, but there's no DEPS file
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full}:',
-                        f'but path {t_path} has no DEPS markup file (DEPS.yml)',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                else:
-                    self.warning_show_available_targets()
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full}:',
-                        f'was not found in deps_file={self.rel_deps_file}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_TARGET_NOT_FOUND
-                    )
+        if not is_valid_target_name(target_node):
+            util.warning(
+                f"In file {self.rel_deps_file}, {target_node} {VALID_TARGET_INFO_STR}"
+            )
 
+        if not caller_info:
+            # If we don't have caller_info, likely came from command line (or DEPS JSON data):
+            if '.' in target_node:
+                # Likely a filename (target_node does not include path)
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full} (file?):',
+                    f'File={t_node} not found in directory={t_path}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            elif not self.rel_deps_file:
+                # target, but there's no DEPS file
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full}:',
+                    f'but path {t_path} has no DEPS markup file (DEPS.yml)',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
             else:
-                # If we have caller_info, then this was a recursive call from another
-                # DEPS file. It should already have the useful error messaging:
-
-                if '.' in target_node:
-                    # Likely a filename (target_node does not include path)
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full} (file?):',
-                        f'called from {caller_info},',
-                        f'File={t_node} not found in directory={t_path}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                elif not self.rel_deps_file:
-                    # target, but there's no DEPS file
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full}:',
-                        f'called from {caller_info},',
-                        f'but {t_path} has no DEPS markup file (DEPS.yml)',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                else:
-                    self.warning_show_available_targets()
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full}:',
-                        f'called from {caller_info},',
-                        f'Target not found in deps_file={self.rel_deps_file}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_TARGET_NOT_FOUND
-                    )
+                self.warning_show_available_targets()
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full}:',
+                    f'was not found in deps_file={self.rel_deps_file}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_TARGET_NOT_FOUND
+                )
+
         else:
-            debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
-            found_target = True
+            # If we have caller_info, then this was a recursive call from another
+            # DEPS file. It should already have the useful error messaging:
+
+            if '.' in target_node:
+                # Likely a filename (target_node does not include path)
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full} (file?):',
+                    f'called from {caller_info},',
+                    f'File={t_node} not found in directory={t_path}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            elif not self.rel_deps_file:
+                # target, but there's no DEPS file
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full}:',
+                    f'called from {caller_info},',
+                    f'but {t_path} has no DEPS markup file (DEPS.yml)',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            else:
+                self.warning_show_available_targets()
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full}:',
+                    f'called from {caller_info},',
+                    f'Target not found in deps_file={self.rel_deps_file}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_TARGET_NOT_FOUND
+                )
 
-        return found_target
+        return False
 
 
     def get_entry(self, target_node) -> dict:

opencos/eda.py

@@ -204,9 +204,12 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         has_all_exe = True
         has_all_in_exe_path = True
+        exe_path = None
         for exe in exe_list:
             assert exe != '', f'{name=} {value=} value missing "exe" {exe=}'
             p = shutil.which(exe)
+            if not exe_path:
+                exe_path = p # set on first required exe
             if not p:
                 has_all_exe = False
                 util.debug(f"... No, missing exe {exe}")
@@ -217,10 +220,11 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         has_vsim_helper = True
         if value.get('requires_vsim_helper', False):
-            # This tool name must be in opencos.utils.vsim_helper.TOOL_IS[name].
+            # This tool name must be in opencos.utils.vsim_helper.TOOL_PATH[name].
             # Special case for vsim being used by a lot of tools.
             vsim_helper.init() # only runs checks once internally
-            has_vsim_helper = vsim_helper.TOOL_IS.get(name, False)
+            exe_path = vsim_helper.TOOL_PATH[name]
+            has_vsim_helper = bool(exe_path)
 
         has_vscode_helper = True
         needs_vscode_extensions = value.get('requires_vscode_extension', None)
@@ -254,18 +258,24 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         if all((has_all_py, has_all_env, has_all_exe, has_all_in_exe_path,
                 has_vsim_helper, has_vscode_helper)):
-            exe = exe_list[0]
-            p = shutil.which(exe)
-            config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list
+            if exe_path:
+                p = exe_path
+            else:
+                p = shutil.which(exe_list[0])
+            config['auto_tools_found'][name] = p # populate key-value pairs w/ first exe in list
             if not quiet:
                 util.info(f"Detected {name} ({p})")
-            tool_setup(tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config)
+            tool_setup(
+                tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config
+            )
 
     return config
 
 
-def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool = False,
-               warnings: bool = True):
+def tool_setup(
+        tool: str, config: dict, quiet: bool = False, auto_setup: bool = False,
+        warnings: bool = True
+):
     ''' Adds items to config["tools_loaded"] (set) and updates config['command_handler'].
 
     config is potentially updated for entry ['command_handler'][command] with a Tool class.
@@ -410,7 +420,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
 
     deferred_tokens = unparsed
     if not command:
-        util.error("Didn't get a command!")
+        util.error("'eda' didn't get a command, or command is invalid (run with --help to see",
+                   "valid commands)!")
         return 2
 
     sco = config['command_handler'][command](config=config) # sub command object
@@ -430,7 +441,12 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
        command not in config.get('command_determines_tool', []) and \
        command not in config.get('command_tool_is_optional', []):
         use_tool = which_tool(command, config)
-        util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        if use_tool:
+            util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        else:
+            # Not all commands have a hard requirement on tool (such as 'multi') because we
+            # haven't examined sub-commands yet.
+            util.info(f'--tool not specified, will attempt to determine tool(s) for {command=}.')
         setattr(sco, 'auto_tool_applied', True)
 
     rc = check_command_handler_cls(command_obj=sco, command=command, parsed_args=parsed)
@@ -483,12 +499,60 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
         if not isinstance(sco, cls):
             # If someone set --tool verilator for command=synth, then our 'sco' will have defaulted
             # to CommandSynth with no tool attached. If we don't have a tool set, error and return.
-            util.warning(f"{command=} is using handling class '{type(sco)}' (but missing",
-                         f"requirement {cls}, likely because we aren't using a derived class",
-                         "for a specific tool)")
-            parsed_tool = getattr(parsed_args, 'tool', '??')
-            return util.error(f"EDA {command=} for tool '{parsed_tool}' is not",
-                              f"supported (this tool '{parsed_tool}' cannot run {command=})")
+            parsed_tool =  getattr(parsed_args, 'tool', '')
+            auto_tool_entry = command_obj.config.get(
+                'auto_tools_order', [{}])[0].get(parsed_tool, {})
+            if parsed_tool and not auto_tool_entry:
+                util.warning(
+                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
+                    f"but missing requirement {cls}, likely because the tool was not loaded",
+                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                )
+                return util.error(
+                    f"EDA {command=} for tool '{parsed_tool}' cannot be run because tool",
+                    f"'{parsed_tool}' is not known to `eda`. It does not exist in the config:",
+                    "see informational message for --config-yml, and check that file's",
+                    "auto_tools_order."
+                )
+            if parsed_tool:
+                util.warning(
+                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
+                    f"but missing requirement {cls}, likely because the tool was not loaded",
+                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                )
+                for k,v in auto_tool_entry.items():
+                    if k == 'exe' or k.startswith('requires_cmd'):
+                        util.warning(
+                            f"tool '{parsed_tool}' has requirements that may not have been met --",
+                            f"{k}: {v}"
+                        )
+                    if k == 'requires_vsim_helper':
+                        if found_tool := vsim_helper.found():
+                            util.warning(
+                                f"tool '{parsed_tool}' was not found, vsim appears to be for tool",
+                                f"'{found_tool}'"
+                            )
+
+                return util.error(
+                    f"EDA {command=} for tool '{parsed_tool}' is not supported (tool",
+                    f"'{parsed_tool}' cannot run {command=}). It is likely that tool",
+                    f"'{parsed_tool}' is not in PATH, or was unable to be loaded due to missing",
+                    "requirements, or missing information when checking the exe version."
+                )
+
+            # No parsed_tool.
+            util.warning(
+                f"{command=} for default tool (--tool not set) is using handling class",
+                f"'{type(sco)}', but missing requirement {cls}, likely because the tool was not",
+                "loaded (not in PATH) or mis-configured (such as missing a Tool based class)"
+            )
+            return util.error(
+                f"EDA {command=} for default tool (--tool not set) is not supported (default",
+                f"tool cannot run {command=}). It appears that no suitable default tool to run",
+                f"{command=} was automatically found, was not in PATH, or was unable to be loaded",
+                "due to missing requirements, or missing information when checking the exe version."
+            )
+
     return 0
 
 
@@ -559,9 +623,36 @@ def main(*args):
     util.global_log.stop()
     return main_ret
 
+def main_show_autocomplete_instructions() -> None:
+    ''' Executable script entry point - eda_show_autocomplete
+
+    from pyproject.toml::project.scripts. Shows instructions on how to enable bash autocomplete
+    '''
+    source_filepath = opencos.__file__.replace(
+        '__init__.py', 'eda_deps_bash_completion.bash'
+    )
+    if os.path.exists(source_filepath):
+        print(
+            f"{Colors.yellow}To enable bash autocompletion with"
+            f" {Colors.bold}eda{Colors.normal}{Colors.yellow} script (uv not equired):"
+        )
+        print(f"{Colors.normal}")
+        print(f"    source {source_filepath}")
+        print("")
+        print(f"{Colors.yellow}Feel free to inspect this script prior to sourcing.")
+        print(f"{Colors.normal}")
+        sys.exit(0)
+    else:
+        util.error(f"It appears the following file(s) doe not exist: {source_filepath}")
+        sys.exit(1)
+
 
 def main_cli() -> None:
-    ''' Returns None, will exit with return code. Entry point for package script or __main__.'''
+    ''' Executable script entry point - eda
+
+    from pyproject.tom::project.scripts, or from __main__.
+    Returns None, will exit with return code.
+    '''
     signal.signal(signal.SIGINT, signal_handler)
     util.global_exit_allowed = True
     # Strip eda or eda.py from sys.argv, we know who we are if called from __main__:

opencos/eda_base.py

@@ -45,6 +45,9 @@ def print_base_help() -> None:
 def print_eda_usage_line(no_targets: bool = False, command_name='COMMAND') -> None:
     '''Prints line for eda [options] COMMAND [options] FILES|TARGETS,...'''
     print(f'{safe_emoji("🔦 ")}Usage:')
+    print(f'    {Colors.bold}{Colors.yellow}eda_targets PATTERN')
+    print(f'    {Colors.bold}{Colors.yellow}eda_show_autocomplete{Colors.normal}')
+    print()
     if no_targets:
         print(
             (f'    {Colors.bold}{Colors.yellow}eda {Colors.cyan}[options]'
@@ -208,11 +211,12 @@ class Tool:
     def set_exe(self, config: dict) -> None:
         '''Sets self._EXE based on config'''
         if self._TOOL and self._TOOL in config.get('auto_tools_order', [{}])[0]:
-            exe = config.get('auto_tools_order', [{}])[0][self._TOOL].get('exe', '')
-            if exe and isinstance(exe, list):
-                exe = exe[0] # pick first
+            # config['auto_tools_found'] has the first exe full path:
+            exe = config.get('auto_tools_found', {}).get(self._TOOL)
             if exe and exe != self._EXE:
-                util.info(f'Override for {self._TOOL} using exe {exe}')
+                # Note that shutil.which() on the exe leaf may not match, this does NOT
+                # modify os.environ['PATH'].
+                util.debug(f'{self._TOOL} using exe: {exe}')
                 self._EXE = exe
 
     def get_tool_name(self) -> str:

opencos/eda_config.py

@@ -390,11 +390,18 @@ def tool_try_add_to_path( # pylint: disable=too-many-branches
         util.error(f'--tool setting for {tool}: {user_exe} is not an executable')
         return name
 
-    user_exe = shutil.which(exe)
+    user_exe = shutil.which(user_exe)
 
     if update_config:
         if isinstance(config_exe, list):
             config['auto_tools_order'][0][name]['exe'][0] = user_exe
+            for index,value in enumerate(config_exe[1:]):
+                # update all entries, if we can, if the value is also in 'path'
+                # from our set --tool=Name=path/exe
+                new_value = os.path.join(path, os.path.split(value)[1])
+                if os.path.exists(new_value) and shutil.which(new_value) and \
+                   os.access(new_value, os.X_OK):
+                    config['auto_tools_order'][0][name]['exe'][index] = new_value
         else:
             config['auto_tools_order'][0][name]['exe'] = user_exe
         util.debug(f'For {tool=}, auto_tools_order config updated')

opencos/eda_config_defaults.yml

@@ -510,7 +510,7 @@ auto_tools_order:
         lec:   opencos.tools.slang_yosys.CommandLecYosys
 
     questa:
-      exe: qrun
+      exe: vsim
       requires_vsim_helper: True
       handlers:
         lint: opencos.tools.questa.CommandLintQuesta
@@ -528,13 +528,14 @@ auto_tools_order:
         elab: opencos.tools.riviera.CommandElabRiviera
         sim:  opencos.tools.riviera.CommandSimRiviera
 
-    modelsim_ase:
+    questa_fe:
       exe: vsim
       requires_vsim_helper: True
       handlers:
-        lint: opencos.tools.modelsim_ase.CommandLintModelsimAse
-        elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
-        sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
+        lint: opencos.tools.questa_fe.CommandLintQuestaFe
+        elab: opencos.tools.questa_fe.CommandElabQuestaFe
+        sim: opencos.tools.questa_fe.CommandSimQuestaFe
+        flist: opencos.tools.questa_fe.CommandFListQuestaFe
 
     questa_fse:  # free student edition, works similar to modelsim_ase
       exe: vsim
@@ -545,6 +546,14 @@ auto_tools_order:
         sim:  opencos.tools.questa_fse.CommandSimQuestaFse
         flist: opencos.tools.questa_fse.CommandFListQuestaFse
 
+    modelsim_ase:
+      exe: vsim
+      requires_vsim_helper: True
+      handlers:
+        lint: opencos.tools.modelsim_ase.CommandLintModelsimAse
+        elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
+        sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
+
     iverilog:
       exe: iverilog
       handlers: