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

opencos/commands/deps_help.py

@@ -13,11 +13,70 @@ uses no tools and will print a help text regarding DEPS markup files to stdout.
 # pylint: disable=line-too-long
 
 import os
+import re
 
 from opencos.eda_base import Command
 from opencos import util
 from opencos.util import Colors
 
+def get_deps_md_file() -> str:
+    '''Tries to get docs/DEPS.md from our pypackage dist'''
+    opencos_dir, _ = os.path.split(util.__file__)
+
+    # Try to get it from site-packages dir, which should have docs/ alongside
+    # commands/ and tools/
+    filename = os.path.join(opencos_dir, 'docs', 'DEPS.md')
+    if os.path.isfile(filename):
+        return filename
+
+    # If you're running directly from the git checkout dir, you won't be getting
+    # this dist, so it's not in opencos/docs, it will simply be in ./docs
+    filename = os.path.join(opencos_dir, '..', 'docs', 'DEPS.md')
+    if os.path.isfile(filename):
+        return filename
+    return ''
+
+def get_deps_md_contents() -> str:
+    '''Tries to get the docs/DEPS.md file and returns the str contents
+
+    This also performs some limited colorization of markdown and YAML
+    (assuming util was not disabled with --no-color)
+    '''
+    filename = get_deps_md_file()
+    if not filename:
+        return ''
+
+    def make_byellow(match):
+        '''Used by re.sub to wrap the match with bold yellow and return to normal yellow'''
+        return f'{Colors.byellow}{match.group(0)}{Colors.normal}{Colors.yellow}'
+
+    lines = []
+    with open(filename, encoding='utf-8') as f:
+        for line in f.readlines():
+
+            if line.startswith('# '):
+                # colors for markdown headings
+                line = f'{Colors.bgreen}{line}{Colors.normal}{Colors.yellow}'
+            elif line.startswith('## '):
+                # colors for markdown headings
+                line = f'{Colors.bcyan}{line}{Colors.normal}{Colors.yellow}'
+
+            elif '#' in line:
+                # colors for comments
+                line = line.replace('#', f'{Colors.normal}{Colors.cyan}#') + Colors.yellow
+
+            # colors for starting a line with:
+            #  key: value
+            #  - key : value
+            # try to make "key:"  or "- key:" as bold:
+            line = re.sub(
+                r'^( *\-? ?[^ ]+):', make_byellow, line
+            )
+
+            lines.append(line)
+
+    return ''.join(lines)
+
 
 BASIC_DEPS_HELP = f'''
 {Colors.yellow}
@@ -128,119 +187,8 @@ FULL_DEPS_HELP = f'''
 
 {Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
-   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.
-
-METADATA: # <table> unstructured data, any UPPERCASE first level key is not considered a target.
-
-target-spec:
-
-  args: # <array or | separated str>
-    - --waves
-    - --sim_plusargs="+info=500"
-
-  defines: # <table>
-    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
-
-  top: # <string>
-
-  deps: # <array or | space separated string>
-    - some_relative_target       # <string> aka, a target
-    - 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@, 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-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
-        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.
-      - peakrdl:              # <string>     ## peakrdl command to generate CSRs
-
-  reqs: # <array or | space separated string>
-    - some_file.mem           # <string> aka, a non-source file required for this target.
-                              # This file is checked for existence prior to invoking the tool involved, for example,
-                              # in a simulation this would be done prior to a compile step.
-
-  multi:
-    ignore-this-target:  # <array of tables> eda commands to be ignored in `eda multi <command>` for this target only
-                         # this is checked in the matching multi targets list, and is not inherited through dependencies.
-      - commands: synth  # space separated strings
-        tools: vivado    # space separated strings
-
-      - commands: sim # omit tools, ignores 'sim' commands for all tools, for this target only, when this target
-                      # is in the target list called by `eda multi`.
-
-      - tools: vivado # omit commands, ignores all commands if tool is vivado, for this target only, when this target
-                      # is in the target list called by `eda multi`.
-
-    args: # <array> additional args added to all multi commands of this target.
-          # Note that all args are POSIX with dashes, --sim-plusargs=value, etc.
-
-  <eda-command>: # key is one of sim, flist, build, synth, etc.
-                 # can be used instead of 'tags' to support different args or deps.
-    disable-tools: # Note: not implemented yet.
-    only-tools:    # Note: not implemented yet.
-    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.
-    <tag-name>: # <string> key for table, can be anything, name is not used.
-      with-tools: <array or | space separated string>
-                  # If using one of these tools, apply these values.
-                  # entries can be in the form: vivado, or vivado:2024.1
-      with-commands: <array or | space separated string>
-                  # apply if this was the `eda` command, such as: sim
-      with-args: # <table> (optional) arg key/value pairs to match for this tag.
-                 # this would be an alternative to running eda with --tags=value
-                 # The existence of an argument with correct value would enable a tag.
-                 # And example would be:
-                 #   with-args:
-                 #     waves: true
-      args: <array or | space separated string> # args to be applied if this target is used, with a matching
-                                          # 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)
-
-
-```
-'''
+''' + get_deps_md_contents()
+
 
 
 class CommandDepsHelp:
@@ -275,4 +223,6 @@ class CommandDepsHelp:
         '''
         Command.help(self, tokens=tokens, no_targets=True)
         print()
+        print(BASIC_DEPS_HELP)
+        print()
         print(FULL_DEPS_HELP)

opencos/commands/export.py

@@ -58,9 +58,14 @@ class CommandExport(CommandDesign):
 
     def do_it(self) -> None:
 
-        # decide output dir name
+        # decide output dir name, note this does not follow the work-dir naming of
+        # eda.work/{target}.{command}
         if not self.args['output']:
-            self.args['output'] = os.path.join('.', 'eda.export', self.args['top'] + '.export')
+            if self.target:
+                name = f'{self.target}.export'
+            else:
+                name = self.args.get('top', '') + '.export'
+            self.args['output'] = os.path.join('.', 'eda.export', name)
         out_dir = self.args['output']
 
         if not self.target:

opencos/commands/multi.py

@@ -6,14 +6,14 @@ These are not intended to be overriden by child classes. They do not inherit Too
 import argparse
 import glob
 import os
-import shutil
 from pathlib import Path
 
 from opencos import util, eda_base, eda_config, export_helper, \
     eda_tool_helper
-from opencos.eda_base import CommandParallel, get_eda_exec
 from opencos.deps.deps_file import get_deps_markup_file, deps_markup_safe_load, \
     deps_data_get_all_targets, deps_list_target_sanitize
+from opencos.eda_base import CommandParallel, get_eda_exec
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import fnmatch_or_re, dep_str2list
 
 class CommandMulti(CommandParallel):
@@ -281,7 +281,7 @@ class CommandMulti(CommandParallel):
         if parsed.parallel < 1 or parsed.parallel > 256:
             self.error("Arg 'parallel' must be between 1 and 256")
 
-        command = self.get_command_from_unparsed_args(tokens=unparsed)
+        command = self.get_sub_command_from_config()
 
         # Need to know the tool for this command, either it was set correctly via --tool and/or
         # the command (class) will tell us.
@@ -425,7 +425,7 @@ class CommandMulti(CommandParallel):
         '''
         eda_path = get_eda_exec('multi')
         command = self.single_command
-        timeout = shutil.which('timeout')
+        timeout = safe_shutil_which('timeout')
 
         # Built-in support for running > 1 tool.
         all_multi_tools = self.multi_which_tools(command)

opencos/commands/sim.py

@@ -370,7 +370,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
     def check_logs_for_errors( # pylint: disable=dangerous-default-value,too-many-locals,too-many-branches
             self,
             sim_retcode: int = 0,
-            filename: str = '', file_contents_str: str = '',
+            filename: str = '',
+            file_contents_str: str = '',
             bad_strings: list = [], must_strings: list = [],
             warning_strings: list = [],
             use_bad_strings: bool = True, use_must_strings: bool = True
@@ -404,32 +405,30 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         lines = []
 
         log_fpath = ''
-        if os.path.exists(filename):
+        if os.path.isfile(filename):
             log_fpath = filename
 
         if file_contents_str:
             lines = file_contents_str.split('\n')
             log_fname = log_fpath + '(STDOUT)'
             util.debug(f'Checking log for errors: {log_fpath=} but checking from STDOUT string...')
-        elif filename:
+        elif log_fpath:
             log_fname = log_fpath
-            util.debug(f'Checking log for errors: {log_fpath=} opening file...')
-            if not os.path.exists(log_fname):
-                self.error(f'sim.check_logs_for_errors: log {log_fpath} does not exist, cannot',
-                           'check it for errors or passing strings')
-                return
+            util.info(f'Checking log filename: {log_fpath}')
             with open(log_fpath, 'r', encoding='utf-8') as f:
                 lines = f.read().splitlines()
         else:
-            self.error(f'sim.check_logs_for_errors: {log_fpath=} does not exist, and no',
-                       'file_contents_str exists to check')
+            log_fname = filename
+            self.error(f'sim.check_logs_for_errors: {log_fname=} is not a file or does not exist,',
+                       'and no file_contents_str exists to check')
 
         self.update_tool_warn_err_counts_from_log_lines(
             log_lines=lines, bad_strings=_bad_strings, warning_strings=_warning_strings
         )
 
-        if isinstance(self, Tool):
-            self.report_tool_warn_error_counts()
+        func = getattr(self, 'report_tool_warn_error_counts', None)
+        if func and isinstance(self, Tool) and callable(func):
+            self.report_tool_warn_error_counts() # pylint: disable=no-member
 
         if sim_retcode > 0:
             # We have to update artifacts first, have the caller set the error.
@@ -446,14 +445,14 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
                             hit_must_string_dict[k] = True
                 if any(bad_str in line for bad_str in _bad_strings):
                     self.error(
-                        f"log {log_fname}:{lineno} contains one of {_bad_strings=}",
+                        f"log {log_fname}:{lineno} contains one of: {_bad_strings}",
                         error_code=status_constants.EDA_SIM_LOG_HAS_BAD_STRING
                     )
 
         if any(x is None for x in hit_must_string_dict.values()):
             self.error(
-                f"Didn't get all passing patterns in log {log_fname}: {_must_strings=}",
-                f" {hit_must_string_dict=}",
+                f"Didn't get all passing patterns in log {log_fname}: {_must_strings},",
+                f" {hit_must_string_dict}",
                 error_code=status_constants.EDA_SIM_LOG_MISSING_MUST_STRING
             )
 

opencos/commands/sweep.py

@@ -72,7 +72,7 @@ class CommandSweep(CommandDesign, CommandParallel):
 
         self.check_args()
 
-        self.single_command = self.get_command_from_unparsed_args(tokens=unparsed)
+        self.single_command = self.get_sub_command_from_config()
 
         self._append_sweep_args(arg_tokens=arg_tokens)
 

opencos/commands/synth.py

@@ -67,9 +67,8 @@ class CommandSynth(CommandDesign):
         if self.stop_process_tokens_before_do_it():
             return unparsed
 
-        # add defines for this job type
         if self.args['top']:
-            # create our work dir
+            # create our work dir (from self.args['top'])
             self.create_work_dir()
             self.run_dep_commands()
             self.do_it()

opencos/commands/upload.py

@@ -4,20 +4,73 @@ Intended to be overriden by Tool based classes (such as CommandUploadVivado, etc
 '''
 
 import os
+import re
+from datetime import datetime
+from pathlib import Path
 
 from opencos.eda_base import Command, Tool
+from opencos.util import Colors, debug, info, warning, safe_emoji, import_class_from_string
+
 
 class CommandUpload(Command):
-    '''Base class command handler for: eda upload ...'''
+    '''Base class command handler for: eda upload ...
 
-    CHECK_REQUIRES = [Tool]
+    If a --tool arg is not specified, this is the default handler for 'eda upload'
+    and will attempt to choose a derived class based on the bit files found
+    '''
 
     command_name = 'upload'
 
+    # SUPPORTED_TOOLS is used
+    SUPPORTED_TOOLS = {
+        'vivado': ['.bit'],
+        'quartus': ['.sof'],
+    }
+    BIT_EXT_TO_TOOL = {}
+
+    # Child classes can set SUPPORTED_BIT_EXT = ['.bit', ..] because they
+    # should only represent one tool
+    SUPPORTED_BIT_EXT = [item for value in SUPPORTED_TOOLS.values() for item in value]
+
+
     def __init__(self, config: dict):
         Command.__init__(self, config=config)
         self.unparsed_args = []
 
+        self.args.update({
+            'bitfile': "",
+            'list-bitfiles': False,
+        })
+
+        self.str_ext = '/'.join(self.SUPPORTED_BIT_EXT).replace('.', '').upper()
+
+        help_upload_tools = '|'.join(self.config.get('auto_tools_found', []))
+        if not help_upload_tools:
+            help_upload_tools = 'TOOL'
+
+        self.args_help.update({
+            'bitfile': (
+                f'Tool specific {self.str_ext} files to upload (auto-detected if not specified)'
+                ' If you would like see full help for a given tool, use:'
+                f' {Colors.yellow}eda upload --help'
+                f' {Colors.byellow}--tool={help_upload_tools}{Colors.green}'
+            ),
+            'list-bitfiles': (
+                f'List available {self.str_ext} files.'
+                ' If you would like see full help for a given tool, use:'
+                f' {Colors.yellow}eda upload --help'
+                f' {Colors.byellow}--tool={help_upload_tools}{Colors.green}'
+            )
+        })
+
+        self.bitfiles = []
+
+        if not getattr(self, '_TOOL', ''):
+            for tool, bit_exts in self.SUPPORTED_TOOLS.items():
+                for ext in bit_exts:
+                    self.BIT_EXT_TO_TOOL[ext] = tool
+
+
     def process_tokens(
             self, tokens: list, process_all: bool = True, pwd: str = os.getcwd()
     ) -> list:
@@ -25,9 +78,144 @@ class CommandUpload(Command):
         self.unparsed_args = Command.process_tokens(
             self, tokens=tokens, process_all=False, pwd=pwd
         )
+
         if self.stop_process_tokens_before_do_it():
             return []
 
-        self.create_work_dir()
-        self.do_it()
+        self.bitfiles = self.get_list_bitfiles(display=True)
+
+        # If someone called --list-bitfiles, stop now.
+        if self.args['list-bitfiles']:
+            if not self.bitfiles:
+                self.error('No bitfiles found')
+            return []
+
+        sco = self._get_child_handling_class()
+
+        if sco is None or not isinstance(sco, Tool):
+            self.error('Could not find a suitable tool to process bitfiles')
+            return []
+
+        sco.unparsed_args = Command.process_tokens(
+            sco, tokens=tokens, process_all=False, pwd=pwd
+        )
+        sco.bitfiles = self.bitfiles
+        sco.create_work_dir()
+        sco.do_it()
         return []
+
+    def get_targets_or_files_from_unparsed_args(self) -> (list, list):
+        '''Returns (list of targets, list of files) from unparsed args or --bitfile'''
+
+        targets = []
+        files = []
+        for f in self.unparsed_args + [self.args['bitfile']]:
+            if not f:
+                continue
+            if os.path.isfile(f):
+                files.append(f)
+            elif not f.startswith('-'):
+                # avoid a arg
+                targets.append(f)
+        return targets, files
+
+
+    def get_list_bitfiles(self, display: bool = True) -> list:
+        '''Returns a list of bit files (ending with self.SUPPORTED_BIT_EXT)'''
+
+        bitfiles: list[Path] = []
+
+        targets, files = self.get_targets_or_files_from_unparsed_args()
+        targets.extend(files)
+
+        debug(f"Looking for bitfiles in {os.path.abspath('.')=}")
+        for root, _, files in os.walk("."):
+            for f in files:
+                if any(f.endswith(x) for x in self.SUPPORTED_BIT_EXT):
+                    fullpath = os.path.abspath(Path(root) / f)
+                    if os.path.isfile(fullpath) and fullpath not in bitfiles:
+                        bitfiles.append(fullpath)
+
+        matched: list[Path] = []
+        for cand in bitfiles:
+            debug(f"Looking for {cand=} in {targets=}")
+            passing = all(re.search(t, str(cand)) for t in targets)
+            if passing:
+                matched.append(cand)
+                mod_time_string = datetime.fromtimestamp(
+                    os.path.getmtime(cand)).strftime('%Y-%m-%d %H:%M:%S')
+                tool_guess = getattr(self, '_TOOL', '')
+                if not tool_guess:
+                    ext = os.path.splitext(cand)[1]
+                    tool_guess = self.BIT_EXT_TO_TOOL.get(ext, '')
+                if tool_guess:
+                    tool_guess = f'({tool_guess})'
+                if display:
+                    info(
+                        f"{safe_emoji('⏩ ')}Found matching bitfile {tool_guess}:",
+                        f"{Colors.cyan}{mod_time_string}{Colors.normal} :",
+                        f"{Colors.byellow}{cand}"
+                    )
+
+        if display and not matched:
+            if self.args['list-bitfiles']:
+                warning(f'{safe_emoji("❕ ")}--list-bitfiles: no {self.str_ext} found that matched',
+                        f'{targets}')
+            else:
+                warning(f'{safe_emoji("❕ ")} Searched for bitfiles with {self.str_ext}: none found',
+                        f'that matched {targets}')
+
+        return matched
+
+
+
+
+    def _get_child_handling_class(self) -> object:
+        '''Returns a class handle of a child to process this, which should be a Tool class
+
+        if no appropriate child is found, returns self.
+        '''
+
+        if isinstance(self, Tool):
+            # We're already a tool handling class.
+            return self
+
+        tools_found = set()
+        for bitfile in self.bitfiles:
+            ext = os.path.splitext(bitfile)[1]
+            tool_guess = self.BIT_EXT_TO_TOOL.get(ext, '')
+            if tool_guess:
+                tools_found.add(tool_guess)
+            else:
+                warning(f'For bitfile {bitfile} no tool found for it')
+                return self
+
+        if not tools_found:
+            # Probably not an error?
+            warning(f'No tools found to process bitfiles: {self.bitfiles}')
+            return self
+
+        if len(tools_found) > 1:
+            warning(f'More than one tool found ({tools_found}) to to process bitfiles:',
+                         f'{self.bitfiles}')
+            return self
+
+
+        tool = tools_found.pop() # only item in set
+        # Do we have a handler for this in our config?
+        if tool in self.config.get('tools_loaded', []):
+            tool_cfg = self.config.get('tools', {}).get(tool, {})
+            if tool_cfg:
+                cls_str = tool_cfg.get('handlers', {}).get(self.command_name, None)
+                if cls_str:
+                    cls = import_class_from_string(cls_str)
+                    if issubclass(cls, Command):
+                        info(f'For found bitfiles, can use tool={tool} and handler {cls}')
+                        sco = cls(config=self.config)
+                        return sco
+
+
+        warning(f'No handler found for tool={tool} to process bitfiles: {self.bitfiles}')
+        debug(f'config -- tools_loaded: {self.config["tools_loaded"]}')
+        debug(f'config -- tools for tool: {self.config["tools"].get(tool, "")}')
+        return self

opencos/commands/waves.py

@@ -15,10 +15,12 @@ handler).
 # pylint: disable=R0801
 
 import os
-import shutil
+import subprocess
 
 from opencos import util
 from opencos.eda_base import CommandDesign
+from opencos.files import safe_shutil_which
+from opencos.utils import vscode_helper
 
 
 class CommandWaves(CommandDesign):
@@ -51,6 +53,48 @@ class CommandWaves(CommandDesign):
             + ' to stdout',
         })
 
+    def get_versions_of_tool(self, tool: str) -> str:
+        '''Similar to Tool.get_versions(), returns the version of 'tool' for tools like:
+
+        - vaporview
+        - gtkwave
+
+        This is called by eda_tool_helper.get_handler_tool_version(tool, cmd, config)
+        '''
+
+        entry = self.config.get('tools', {}).get(tool, {})
+
+        if entry and 'requires_vscode_extension' in entry:
+            # vaporview, surfer
+            vscode_ext_name = entry.get('requires_vscode_extension', [''])[0]
+            vscode_helper.init()
+            ver = vscode_helper.EXTENSIONS.get(vscode_ext_name)
+            return ver
+
+        if entry and tool == 'gtkwave':
+            # gtkwave --version is fast.
+            proc = None
+            try:
+                proc = subprocess.run(
+                    [safe_shutil_which('gtkwave'), '--version'],
+                    capture_output=True, check=False
+                )
+            except Exception as e:
+                util.debug(f'gtkwave --version: exception {e}')
+
+            if not proc or not proc.stdout:
+                return ''
+
+            for line in proc.stdout.decode('utf-8', errors='replace').split('\n'):
+                if line.lower().startswith('gtkwave analyzer v'):
+                    parts = line.split(' ')
+                    return parts[2][1:] # trim the leading 'v' in 'v1.2.3'
+            return ''
+
+        return ''
+
+
+
 
     def get_wave_files_in_dirs(self, wave_dirs: list, quiet: bool = False) -> list:
         '''Returns list of all wave files give wave_dirs (list)'''
@@ -120,10 +164,10 @@ class CommandWaves(CommandDesign):
 
         # TODO(drew): this feels a little customized per-tool, perhaps there's a better
         # way to abstract this configuration for adding other waveform viewers.
-        # For example for each command we also have to check shutil.which, because normal Tool
+        # For example for each command we also have to check safe_shutil_which, because normal Tool
         # classs should work even w/out PATH, but these don't use Tool classes.
         if wave_file.endswith('.wdb'):
-            if 'vivado' in self.config['tools_loaded'] and shutil.which('vivado'):
+            if 'vivado' in self.config['tools_loaded'] and safe_shutil_which('vivado'):
                 tcl_name = wave_file + '.waves.tcl'
                 with open( tcl_name, 'w', encoding='utf-8') as fo :
                     print( 'current_fileset', file=fo)
@@ -141,20 +185,20 @@ class CommandWaves(CommandDesign):
                            f"{self.VSIM_TOOLS} in PATH")
         elif wave_file.endswith('.fst'):
             if ('vaporview' in self.config['tools_loaded'] or \
-                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                'surfer' in self.config['tools_loaded']) and safe_shutil_which('code'):
                 command_list = ['code', '-n', '.', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
-            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            elif 'gtkwave' in self.config['tools_loaded'] and safe_shutil_which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             else:
                 self.error(f"Don't know how to open {wave_file} without GtkWave in PATH")
         elif wave_file.endswith('.vcd'):
             if ('vaporview' in self.config['tools_loaded'] or \
-                'surfer' in self.config['tools_loaded']) and shutil.which('code'):
+                'surfer' in self.config['tools_loaded']) and safe_shutil_which('code'):
                 command_list = ['code', '-n', '.', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
-            elif 'gtkwave' in self.config['tools_loaded'] and shutil.which('gtkwave'):
+            elif 'gtkwave' in self.config['tools_loaded'] and safe_shutil_which('gtkwave'):
                 command_list = ['gtkwave', wave_file]
                 self.exec(os.path.dirname(wave_file), command_list)
             elif self._vsim_available(from_tools=self.VSIM_VCD_TOOLS):
@@ -172,7 +216,7 @@ class CommandWaves(CommandDesign):
             self, from_tools: list = VSIM_TOOLS
     ) -> bool:
         '''Returns True if 'vsim' is available (Questa or Modelsim)'''
-        return bool(shutil.which('vsim')) and \
+        return bool(safe_shutil_which('vsim')) and \
             any(x in self.config['tools_loaded'] for x in from_tools)