opencos-eda 0.3.11__py3-none-any.whl → 0.3.13__py3-none-any.whl

opencos/commands/flist.py

@@ -6,11 +6,13 @@ Intended to be overriden by Tool based classes (such as CommandFListVivado, etc)
 # pylint: disable=too-many-statements
 
 import os
+import shlex
 
-from opencos import util
-from opencos.eda_base import CommandDesign
+from opencos import util, eda_config
+from opencos.eda_base import CommandDesign, Tool
 from opencos.utils.str_helpers import strip_all_quotes
 from opencos.commands.sim import parameters_dict_get_command_list
+from opencos.utils.str_helpers import strip_outer_quotes
 
 class CommandFList(CommandDesign):
     '''Base class command handler for: eda flist ...'''
@@ -19,29 +21,41 @@ class CommandFList(CommandDesign):
 
     def __init__(self, config: dict):
         CommandDesign.__init__(self, config=config)
-        self.args.update({
-            'eda-dir'            : 'eda.flist', # user can specify eda-dir if files are generated.
+
+        # If there's no tool attached, then we'll assume this flist is being created
+        # to run in `eda`, not some vendor tool.
+        self.flist_has_tool = isinstance(self, Tool)
+
+        self.flist_args = {
             'out'                : "flist.out",
             'emit-define'        : True,
             'emit-parameter'     : True,
             'emit-incdir'        : True,
+            'emit-plusargs'      : True,
             'emit-v'             : True,
             'emit-sv'            : True,
             'emit-vhd'           : True,
             'emit-cpp'           : True,
             'emit-non-sources'   : True, # as comments, from DEPS 'reqs'
+            'emit-eda-args'      : not self.flist_has_tool, # no Tool means flist for eda.
             'prefix-define'      : "+define+",
             'prefix-parameter'   : "-G",
             'prefix-incdir'      : "+incdir+",
+            'prefix-plusargs'    : "+",
             'prefix-v'           : "",
             'prefix-sv'          : "",
             'prefix-vhd'         : "",
             'prefix-cpp'         : "",
             'prefix-non-sources' : "", # as comments anyway.
-            # TODO(simon): make the define quoting work like the paths quoting
+            # NOTE - the defaults are for creating an flist that is suitable for 'eda', which for
+            # defines means: optionally single-quote the entire thing, double-quote string values
+            # only.
+            # Tool classes should override if they want to set safe-mode-defines=True.
+            # Tool classes may also avoid these args entirely in their derived CommandFList class
+            'safe-mode-defines'   : not self.flist_has_tool, # no Tool
             'bracket-quote-define': False,
             'single-quote-define': False,
-            'quote-define'       : True,
+            'quote-define'       : self.flist_has_tool, # Tool, this is NOT for eda.
             'equal-define'       : True,
             'escape-define-value': False,
             'quote-define-value' : False,
@@ -55,7 +69,14 @@ class CommandFList(CommandDesign):
 
             # ex: eda flist --print-to-stdout --emit-rel-path --quiet <target>
             'emit-rel-path'  : False,
+        }
+
+
+        self.args.update({
+            'eda-dir'            : 'eda.flist', # user can specify eda-dir if files are generated.
         })
+        self.args.update(self.flist_args)
+
         self.args_help.update({
             'print-to-stdout': "do not save file, print to stdout",
         })
@@ -75,14 +96,15 @@ class CommandFList(CommandDesign):
     def get_flist_dict(self) -> dict:
         '''Returns dict of some internal class member vars, ignores args
 
-        Useful for an extneral caller to get details about this CommandDesign child
+        Useful for an external caller to get details about this CommandDesign child
         object without generating a .f file, or having to know specifics about the
         class
         '''
         self.command_safe_set_tool_defines() # (Command.command_safe_set_tool_defines)
 
         ret = {}
-        for key in ['files_sv', 'files_v', 'files_vhd', 'defines', 'incdirs']:
+        for key in ['files_sv', 'files_v', 'files_vhd', 'defines', 'incdirs',
+                    'parameters', 'unprocessed-plusargs']:
             # These keys must exist, all are lists, defines is a dict
             x = getattr(self, key, None)
             if isinstance(x, (dict, list)):
@@ -91,6 +113,134 @@ class CommandFList(CommandDesign):
                 ret[key] = x
         return ret
 
+    def get_flist_defines_list(self) -> list:
+        '''Returns formatted list of str for known defines'''
+
+        ret = []
+        prefix = strip_all_quotes(self.args['prefix-define'])
+        for d, value in self.defines.items():
+
+            if value is None:
+                ret.append(prefix + d)
+                continue
+
+            # else, value exists:
+            safe_mode_guard_str_value = bool(
+                self.args['safe-mode-defines'] and isinstance(value, str) and ' ' in value
+            )
+
+            if self.args['bracket-quote-define']:
+                qd1 = "{"
+                qd2 = "}"
+            elif self.args['single-quote-define']:
+                qd1 = "'"
+                qd2 = "'"
+            elif self.args['quote-define']:
+                qd1 = '"'
+                qd2 = '"'
+            else:
+                qd1 = ''
+                qd2 = ''
+
+            if self.args['equal-define']:
+                ed1 = '='
+            else:
+                ed1 = ' '
+
+            if self.args['escape-define-value']:
+                value = value.replace('\\', '\\\\').replace('"', '\\"')
+            if self.args['quote-define-value']:
+                value = '"' + value + '"'
+            if safe_mode_guard_str_value:
+                value = strip_outer_quotes(value.strip('\n'))
+                value = '"' + value + '"'
+
+            if self.args['quote-define'] and value.startswith('"') and value.endswith('"'):
+                # If you wanted your define to look like:
+                # +define+"NAME=VALUE", but VALUE also has double quotes wrapping it,
+                # it's unlikely to work so we'll optimistically so escape the " wrapping value.
+                # If you have additional " in the middle of the value, good luck.
+                value = '\\"' + value[1:-1] + '\\"'
+
+            newline = prefix + qd1 + f"{d}{ed1}{value}" + qd2
+
+            if safe_mode_guard_str_value:
+                # wrap the entire thing with single-quotes, so it survives as a single
+                # token in an eda dot-f file:
+                newline = shlex.quote(newline)
+
+            ret.append(newline)
+
+        return ret
+
+    def get_flist_plusargs_list(self) -> list:
+        '''Returns formatted list of str for unprocessed plusargs
+
+        Tool based classes can override if they also want to query their own
+        processed plusargs, such as CommandSim.args[sim-plusargs']
+        '''
+        ret = []
+        for x in self.args.get('unprocessed-plusargs', []) + self.args.get('sim-plusargs', []):
+            if self.args['prefix-plusargs']:
+                if x.startswith('+'):
+                    x = x[1:] # strip leading +
+                x = self.args['prefix-plusargs'] + x
+            ret.append(x)
+        return ret
+
+    def get_flist_parameter_list(self) -> list:
+        '''Returns formatted list of str for parameters'''
+        prefix = strip_all_quotes(self.args['prefix-parameter'])
+        return parameters_dict_get_command_list(
+                params=self.parameters, arg_prefix=prefix, for_flist=True
+        )
+
+    def get_flist_eda_args_list(self) -> list:
+        '''Returns list of eda args for an eda-capable flist
+
+        - This will NOT add any util based args (--color | --no-color, --debug, etc)
+        - This will NOT add any -f/--input-file args (those are already resolved)
+
+        - This WILL add --env-file args
+        - This WILL add --config-yml args that were not default value
+
+        Not intended to be overriden by Tool based command classes.
+        '''
+        ret = []
+
+        # --env-file(s), if used:
+        for env_file in util.env_files_loaded:
+            ret.append(f'--env-file={env_file}')
+
+        # --config-yml, if non-default:
+        ret.extend(eda_config.get_config_yml_args_for_flist())
+
+        # EDA args, but not the flist specific args, and only those that were modified.
+        for arg, _ in self.modified_args.items():
+
+            if arg in self.flist_args:
+                # do not emit flist command args
+                continue
+
+            value = self.args[arg]
+            if isinstance(value, bool):
+                if value:
+                    ret.append(f'--{arg}')
+                else:
+                    ret.append(f'--no-{arg}')
+            else:
+                ret.append(f'--{arg}={value}')
+        return ret
+
+    def get_additional_flist_args_list(self) -> list:
+        '''Derived classes may override, to output additional args in the flist'''
+        return []
+
+    def get_additional_flist_files_list(self) -> list:
+        '''Derived classes may override, to output additional files in the flist'''
+        return []
+
+
     def do_it(self) -> None:
         '''do_it() is the main entry point for creating the flist(),
 
@@ -105,6 +255,30 @@ class CommandFList(CommandDesign):
             self.write_eda_config_and_args()
             return
 
+        if self.config['tool']:
+            tool_string = f' (with --tool={self.config["tool"]})'
+        else:
+            tool_string = ''
+
+        # if config['tool'] is set, but self.flist_has_tool is False, we're likely using
+        # this default handler CommandFList and the Tool class hasn't defined what they
+        # do. In this case, simply warn that this will emit a non-tool specific default flist
+        # intended for use by `eda`:
+        if self.config['tool'] and not self.flist_has_tool:
+            util.warning(f'For command="flist"{tool_string}, there is no tool',
+                         'specific handler for producing an flist. The default eda flist will',
+                         'be emitted')
+            # If this happens, you'll likely want the Tool based defines (that were never set
+            # by Tool.set_tool_defines(self) b/c we have no Tool class.
+            # TODO(drew): This is only a best-effort, we could create a derived Tool object and
+            # instead call obj.set_tool_defines(), and update self.defines instead?
+            _tool_config = self.config.get('tools', {}).get(self.config['tool'], {})
+            self.defines.update(
+                _tool_config.get('defines', {})
+            )
+
+
+
         # check if we're overwriting the output flist file.
         if self.args['print-to-stdout']:
             pass
@@ -153,41 +327,33 @@ class CommandFList(CommandDesign):
                             f = os.path.relpath(f)
                         print('##    ' + prefix + pq1 + f + pq2, file=fo)
 
+        if self.args['emit-eda-args']:
+            for newline in self.get_flist_eda_args_list():
+                print(newline, file=fo)
+
+        defines_lines = self.get_flist_defines_list()
+        if not self.args['emit-define'] and defines_lines:
+            util.warning(f'Command "flist"{tool_string}, has defines present but they were not',
+                         f'included in the output flist: {defines_lines}')
+
+        parameter_lines = self.get_flist_parameter_list()
+        if not self.args['emit-parameter'] and parameter_lines:
+            util.warning(f'Command "flist"{tool_string}, has parameters present but they were not',
+                         f'included in the output flist: {parameter_lines}')
+
+        plusarg_lines = self.get_flist_plusargs_list()
+        if not self.args['emit-plusargs'] and plusarg_lines:
+            util.warning(f'Command "flist"{tool_string}, has plusargs present but they were not',
+                         f'included in the output flist: {plusarg_lines}')
+
         if self.args['emit-define']:
-            prefix = strip_all_quotes(self.args['prefix-define'])
-            for d, value in self.defines.items():
-                if value is None:
-                    newline = prefix + d
-                else:
-                    if self.args['bracket-quote-define']:
-                        qd1 = "{"
-                        qd2 = "}"
-                    elif self.args['single-quote-define']:
-                        qd1 = "'"
-                        qd2 = "'"
-                    elif self.args['quote-define']:
-                        qd1 = '"'
-                        qd2 = '"' # rename this one when things calm down
-                    else:
-                        qd1 = ''
-                        qd2 = ''
-                    if self.args['equal-define']:
-                        ed1 = '='
-                    else:
-                        ed1 = ' '
-                    if self.args['escape-define-value']:
-                        value = value.replace('\\', '\\\\').replace('"', '\\"')
-                    if self.args['quote-define-value']:
-                        value =f'"{value}"'
-                    newline = prefix + qd1 + f"{d}{ed1}{value}" + qd2
+            for newline in defines_lines:
                 print(newline, file=fo)
 
         if self.args['emit-parameter']:
-            prefix = strip_all_quotes(self.args['prefix-parameter'])
-            for item in parameters_dict_get_command_list(
-                    params=self.parameters, arg_prefix=prefix
-            ):
-                print(item, file=fo)
+            for newline in parameter_lines:
+                print(newline, file=fo)
+
 
         if self.args['emit-incdir']:
             prefix = strip_all_quotes(self.args['prefix-incdir'])
@@ -195,12 +361,24 @@ class CommandFList(CommandDesign):
                 if self.args['emit-rel-path']:
                     i = os.path.relpath(i)
                 print(prefix + pq1 + i + pq2, file=fo)
+
+        if self.args['emit-plusargs']:
+            for newline in plusarg_lines:
+                print(newline, file=fo)
+
+
+        # Hook for derived classes to optionally print additional custom args, prior to
+        # any files:
+        for newline in self.get_additional_flist_args_list():
+            print(newline, file=fo)
+
         if self.args['emit-v']:
             prefix = strip_all_quotes(self.args['prefix-v'])
             for f in self.files_v:
                 if self.args['emit-rel-path']:
                     f = os.path.relpath(f)
                 print(prefix + pq1 + f + pq2, file=fo)
+
         if self.args['emit-sv']:
             prefix = strip_all_quotes(self.args['prefix-sv'])
             for f in self.files_sv:
@@ -220,6 +398,11 @@ class CommandFList(CommandDesign):
                     f = os.path.relpath(f)
                 print(prefix + pq1 + f + pq2, file=fo)
 
+        # Hook for derived classes to optionally print additional flist items after
+        # any files:
+        for newline in self.get_additional_flist_files_list():
+            print(newline, file=fo)
+
         if self.args['print-to-stdout']:
             print() # don't need to close fo (None)
         else:

opencos/commands/multi.py

@@ -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.
@@ -354,9 +354,11 @@ class CommandMulti(CommandParallel):
 
         if self.args['print-targets']:
             util.info('Multi print-targets (will not run jobs): -->')
-            for t in self.targets:
+            print_targets = [t[0] for t in self.targets]
+            print_targets.sort()
+            for x in print_targets:
                 # t = tuple of (target:str, tool:str), we just want the target.
-                print(f'  {t[0]}')
+                print(f'  {x}')
         else:
             util.debug("Multi: converting list of targets into list of jobs")
             self.jobs = []

opencos/commands/sim.py

@@ -12,15 +12,32 @@ Note that CommandSim is also a base class for opencos.commands.elab.CommandElab.
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 
 import os
+import shlex
 
 from opencos import util, export_helper
 from opencos.eda_base import CommandDesign, Tool
 from opencos.utils import status_constants
 
-from opencos.utils.str_helpers import sanitize_defines_for_sh, strip_outer_quotes
+from opencos.utils.str_helpers import strip_outer_quotes
 
-def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> list:
-    '''Given dict of parameters, returns a command list'''
+def parameters_dict_get_command_list(
+        params: dict, arg_prefix: str = '-G',
+        hier_delimiter: str = '.',
+        top_hier_str: str = '',
+        for_flist: bool = False
+) -> list:
+    '''Given dict of parameters, returns a command list.
+
+    Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+    so to avoid that and only set top level parameters, but still allow package or
+    hierarchy parameters to be set, you can use:
+
+    hier_delimiter='/'
+    top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+    Which will, if a parameter Name does not contain the heir delimiter, the Name
+    will be prepended with top_hier_str.
+    '''
 
     ret_list = []
     if ' ' in arg_prefix:
@@ -34,13 +51,29 @@ def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> li
         if not isinstance(v, (int, str)):
             util.warning(f'parameter {k} has value: {v}, parameters must be int/string types')
 
+        if top_hier_str and hier_delimiter not in k:
+            k = f'{top_hier_str}{k}'
+
         ret_list.extend(arg_list_prefix)
         if isinstance(v, int):
             ret_list.append(f'{arg_str_prefix}{k}={v}')
         else: # string
+            # Note if for_flist=True, then we have to take extra care on what gets
+            # double-quotes " and \".
             v = strip_outer_quotes(v.strip('\n'))
             v = '"' + v + '"'
-            ret_list.append(f'{arg_str_prefix}{k}={sanitize_defines_for_sh(v)}')
+
+            if for_flist:
+                # do not wrap with " unless there are spaces, if there are spaces
+                # wrap the entire thing with single quotes (bash)
+                if ' ' in v:
+                    ret_list.append(shlex.quote(f'{arg_str_prefix}{k}={v}'))
+                else:
+                    ret_list.append(f'{arg_str_prefix}{k}={v}')
+            else:
+                # This is for a tool, so simply guard single quotes:
+                v = v.replace("'", "\\" + "'")
+                ret_list.append(f'{arg_str_prefix}{k}={v}')
     return ret_list
 
 
@@ -79,6 +112,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             # not used by other simulators, so these can go in DEPS files for custom things
             # like -CFLAGS -O0, etc.
             'verilate-args': [],
+            'ext-defines-sv-fname': '',
+            'license-queue': False,
         })
         self.args_help.update({
             'pre-sim-tcl': (
@@ -124,6 +159,15 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             'uvm-version': (
                 'Used if --uvm is set, for example --uvm-version=1.2'
             ),
+            'ext-defines-sv-fname': (
+                'If set to empty str, --ext-defines-sv-fname="", applies defines to tool via args.'
+                ' If set to non-emtpy str as a .sv file name, such as'
+                ' --ext-defines-sv-fname=_ext_defines.sv, saves defines to a file name in the'
+                ' work-dif, and adds this file to the SV/Verilog file list ahead of other files.'
+            ),
+            'license-queue': (
+                'Set to enable env vars LICENSE_QUEUE=1 which has effects on certain simulators'
+            ),
 
         })
 
@@ -133,9 +177,24 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
 
 
 
-    def process_parameters_get_list(self, arg_prefix: str = '-G') -> list:
-        '''Returns list (suitable command list for shell or for tool) from self.parameters'''
-        return parameters_dict_get_command_list(params=self.parameters, arg_prefix=arg_prefix)
+    def process_parameters_get_list(
+            self, arg_prefix: str = '-G', **kwargs
+    ) -> list:
+        '''Returns list (suitable command list for shell or for tool) from self.parameters
+
+        Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+        so to avoid that and only set top level parameters, but still allow package or
+        hierarchy parameters to be set, you can use args (in kwargs):
+
+        hier_delimiter='/'
+        top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+        Which will, if a parameter Name does not contain the heir delimiter, the Name
+        will be prepended with top_hier_str.
+        '''
+        return parameters_dict_get_command_list(
+            params=self.parameters, arg_prefix=arg_prefix, **kwargs
+        )
 
     def process_plusarg(self, plusarg: str, pwd: str = os.getcwd()) -> None:
         '''Override for CommandDesign.process_plusarg(..)'''
@@ -159,6 +218,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         if self.stop_process_tokens_before_do_it():
             return unparsed
 
+        self.handle_arg_license_queue()
+
         # add defines for this job type
         if self.args['lint'] or self.args['stop-after-elaborate']:
             self.args['lint'] = True
@@ -572,3 +633,56 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             search_paths=self.args['work-dir'], file_extension='vcd',
             typ='waveform', description='Simulation Waveform VCD (Value Change Dump) file'
         )
+
+
+    def create_ext_defines_sv(self) -> None:
+        '''Creates _ext_defines.sv in the work-dir, adds to front of self.files_sv'''
+
+        if not self.defines:
+            return
+
+        if not self.args['ext-defines-sv-fname']:
+            return
+
+        fpath = os.path.join(self.args['work-dir'], self.args['ext-defines-sv-fname'])
+        fpath_abs = os.path.abspath(fpath)
+        if fpath_abs in self.files:
+            util.warning(f'{fpath} already exists, will overwrite. Consider changing the value',
+                         f'of arg: --ext-defines-sv-fname={self.args["ext-defines-sv-fname"]}')
+        if not fpath.endswith('.sv') and not fpath.endswith('.v'):
+            util.error(f'--ext-defines-sv-fname={self.args["ext-defines-sv-fname"]} must end with',
+                       '.v or .sv')
+            return
+
+        ifdef_guard = os.path.split(self.args['ext-defines-sv-fname'])[1].upper()
+        ifdef_guard = ifdef_guard.replace('.', '__').replace('/', '__')
+        with open(fpath, 'w', encoding='utf-8') as f:
+            f.write(f'`ifndef {ifdef_guard}\n')
+            f.write(f'`define {ifdef_guard}\n')
+            f.write('\n')
+            for key, value in self.defines.items():
+                if value is None:
+                    f.write(f'`define {key}\n')
+                else:
+                    # if the value v is a double-quoted string, such as v='"hi"' that needs
+                    # to be preserved.
+                    f.write(f'`define {key} {value}\n')
+
+            f.write('\n')
+            f.write(f'`endif // {ifdef_guard}\n')
+
+        self.files_sv.insert(0, fpath_abs)
+        self.files[fpath_abs] = True
+        self.files_caller_info[fpath_abs] = (
+            'opencos.commands.sim::CommandSim::create_ext_defines_sv'
+        )
+        util.info(f'command "sim": {fpath} created for defines: {list(self.defines.keys())}')
+
+
+    def handle_arg_license_queue(self) -> None:
+        '''Handles self.args['license-queue'] (bool) to set env vars'''
+        if not self.args['license-queue']:
+            return
+
+        if 'LICENSE_QUEUE' not in os.environ:
+            os.environ['LICENSE_QUEUE'] = '1'

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/upload.py

@@ -204,9 +204,9 @@ class CommandUpload(Command):
         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', []):
-            auto_tools_order = self.config.get('auto_tools_order', [{}])[0]
-            if tool in auto_tools_order:
-                cls_str = auto_tools_order[tool].get('handlers', {}).get(self.command_name, None)
+            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):
@@ -217,5 +217,5 @@ class CommandUpload(Command):
 
         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 -- auto_tools_order for tool: {self.config["auto_tools_order"][0][tool]}')
+        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 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)'''

opencos/deps/deps_file.py

@@ -124,6 +124,7 @@ def get_all_targets( # pylint: disable=dangerous-default-value,too-many-locals,t
             targets = list(targets)
         if not targets and error_on_empty_return:
             error(f'get_all_targets: {base_path=} {filter_using_multi=} returned no targets')
+        targets.sort()
         return targets
 
     targets = set()
@@ -144,7 +145,9 @@ def get_all_targets( # pylint: disable=dangerous-default-value,too-many-locals,t
 
     if not targets and error_on_empty_return:
         error(f'get_all_targets: {base_path=} {dirs=} {filter_str=} returned no targets')
-    return list(targets)
+    targets = list(targets)
+    targets.sort()
+    return targets
 
 
 def deps_target_get_deps_list(