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

opencos/commands/waves.py

@@ -15,10 +15,10 @@ handler).
 # pylint: disable=R0801
 
 import os
-import shutil
 
 from opencos import util
 from opencos.eda_base import CommandDesign
+from opencos.files import safe_shutil_which
 
 
 class CommandWaves(CommandDesign):
@@ -120,10 +120,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 +141,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 +172,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)
 
 

opencos/deps/deps_commands.py

@@ -13,10 +13,11 @@ my_target:
 import os
 from pathlib import Path
 import re
-import shutil
 
-from opencos.util import debug, error, warning, ShellCommandList
 from opencos.deps.defaults import SUPPORTED_COMMAND_KEYS, COMMAND_ATTRIBUTES
+from opencos.files import safe_shutil_which, PY_EXE
+from opencos.util import debug, error, warning, ShellCommandList
+
 
 THISPATH = os.path.dirname(__file__)
 PEAKRDL_CLEANUP_PY = os.path.join(THISPATH, '..', 'peakrdl_cleanup.py')
@@ -221,7 +222,7 @@ def parse_deps_peakrdl( # pylint: disable=too-many-locals
                 + ' however it is not enabled in edy.py - eda.config[dep_command_enables]')
         return None
 
-    if not shutil.which('peakrdl'):
+    if not safe_shutil_which('peakrdl'):
         error('peakrdl: is not present in shell path, or the python package is not avaiable,' \
               + f' yet we encountered a peakrdl command in {target_path=} {target_node=}')
         return None
@@ -255,11 +256,10 @@ def parse_deps_peakrdl( # pylint: disable=too-many-locals
 
     sv_files += [ f'peakrdl/{top}_pkg.sv', f'peakrdl/{top}.sv' ]
 
-
     shell_commands = [
-        [ 'peakrdl', 'regblock', '-o', str(Path('peakrdl/'))] + args_list,
+        [ safe_shutil_which('peakrdl'), 'regblock', '-o', str(Path('peakrdl/'))] + args_list,
         # Edit file to apply some verilator waivers, etc, from peakrdl_cleanup.py:
-        [ 'python3', PEAKRDL_CLEANUP_PY, str(Path(f'peakrdl/{top}.sv')),
+        [ PY_EXE, PEAKRDL_CLEANUP_PY, str(Path(f'peakrdl/{top}.sv')),
           str(Path(f'peakrdl/{top}.sv')) ],
     ]
 

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/deps/deps_processor.py

@@ -5,15 +5,17 @@ CommandDesign ref object
 '''
 
 import argparse
+import copy
 import os
 
 from opencos import files
 from opencos import eda_config
-from opencos.util import debug, info, warning, error, read_tokens_from_dot_f, \
+from opencos.util import Colors, debug, info, warning, error, read_tokens_from_dot_f, \
     patch_args_for_dir, load_env_file
 from opencos.utils.str_helpers import dep_str2list
 from opencos.deps.deps_file import deps_target_get_deps_list
 from opencos.deps.deps_commands import deps_commands_handler
+from opencos.utils.dict_helpers import dict_diff
 
 from opencos.deps.defaults import SUPPORTED_TARGET_TABLE_KEYS, SUPPORTED_TAG_KEYS, \
     SUPPORTED_DEP_KEYS_BY_TYPE
@@ -53,6 +55,14 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         self.deps_dir, _ = os.path.split(deps_file)
         self.caller_info = caller_info
 
+        # Check if it's a Command instead of CommandDesign:
+        self.is_command_design = bool(
+            getattr(command_design_ref, 'process_plusarg', None) and \
+            getattr(command_design_ref, 'set_parameter', None) and \
+            isinstance(getattr(command_design_ref, 'incdirs', None), list)
+        )
+
+
         assert isinstance(deps_entry, dict), \
             f'{deps_entry=} for {target_node=} in {deps_file=} must be a dict'
         assert command_design_ref is not None, \
@@ -79,6 +89,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
     def apply_defines(self, defines_dict: dict) -> None:
         '''Given defines_dict, applies them to our self.command_design_ref obj'''
+        if not self.is_command_design:
+            return
         if not isinstance(defines_dict, dict):
             self.error(f"{defines_dict=} is not type dict, can't apply defines,",
                        f"in {self.caller_info}")
@@ -97,6 +109,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
     def apply_plusargs(self, plusargs_dict: dict) -> None:
         '''Given plusarsg_dict, applies them to our self.command_design_ref obj'''
+        if not self.is_command_design:
+            return
         if not isinstance(plusargs_dict, dict):
             self.error(f"{plusargs_dict=} is not type dict, can't apply plusargs,",
                        f"in {self.caller_info}")
@@ -109,6 +123,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
     def apply_parameters(self, parameters_dict: dict) -> None:
         '''Given parameters_dict, applies them to our self.command_design_ref obj'''
+        if not self.is_command_design:
+            return
         if not isinstance(parameters_dict, dict):
             self.error(f"{parameters_dict=} is not type dict, can't apply defines,",
                        f"in {self.caller_info}")
@@ -124,6 +140,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
     def apply_incdirs(self, incdirs_list:list) -> None:
         '''Given incdirs_list, applies them to our self.command_design_ref obj'''
+        if not self.is_command_design:
+            return
         if not isinstance(incdirs_list, (str, list)):
             self.error(f"{incdirs_list=} is not type str/list, can't apply incdirs",
                        f"in {self.caller_info}")
@@ -135,38 +153,59 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 debug(f'Added include dir {abspath} from {self.caller_info}')
 
 
-    def _apply_args_check_tools(self, tokens: list) -> list:
-        '''Helper for apply_args(list), returns list strips --tool args under certain conditions'''
+    def _apply_args_check_tools(self, tokens: list, tagname: str) -> list:
+        '''Helper for apply_args(list), returns list strips --tool args under certain conditions
+
+        Basically, we want to see if a DEPS target want to set arg --tool, if so:
+        Accept it:
+          - this is not a tool class
+          - tool was automatically chosen by eda.py's auto-tool-order (--tool not set at
+             CLI)
+          - accepting means set self.args['tool'], so we can respawn with this.
+        Reject/Warn if:
+          - previous tool was not automatically applied (--tool was set at CLI)
+            and you're trying to change the --tool value.
+          - This can happen if you have complicated DEPS targets trying to set the
+            tool to different values.
+        '''
 
+        parser = argparse.ArgumentParser(
+            prog='deps_processor --tool', add_help=False, allow_abbrev=False
+        )
+        parser.add_argument('--tool', default='')
+        try:
+            parsed, unparsed = parser.parse_known_args(tokens + [''])
+            tokens2 = list(filter(None, unparsed))
+        except argparse.ArgumentError:
+            error('deps_processor --tool problem attempting to parse_known_args for:',
+                  f'{tokens}, {self.caller_info} {tagname}')
+            tokens2 = tokens
+
+        _tool_class = 'tool' in self.args
         _orig_tool = self.args.get('tool', '')
-        if not self.command_design_ref.auto_tool_applied and \
-           any(x.startswith('--tool') for x in tokens) and _orig_tool:
-            warn_tool = ''
-            for i, item in enumerate(list(tokens)):
-                if item == '--tool':
-                    if tokens[i + 1] != _orig_tool:
-                        warn_tool = tokens[i + 1]
-                    tokens[i : i+2] = ['', ''] # remove this and next arg
-                elif item.startswith('--tool='):
-                    if item[7:] != _orig_tool:
-                        warn_tool = item
-                    tokens[i] = '' # remove just this arg.
-
-            if warn_tool:
-                warning(
-                    f'Attempting to set --tool {warn_tool} from DEPS',
-                    f'(file={self.deps_file}:{self.target_node})',
-                    f'however the tool was already chosen as: {_orig_tool}. The --tool arg will',
-                    f'not be applied from: {tokens}'
-                )
 
-            tokens = [item for item in tokens if item != ''] # remove blanks
+        if not self.command_design_ref.auto_tool_applied and \
+           _tool_class and parsed.tool and _orig_tool \
+           and parsed.tool != _orig_tool:
+            # tool arg present, --tool in this DEPS args, and tool already set.
+            warning(
+                f'Attempting to set --tool {parsed.tool} from DEPS',
+                f'(file={self.deps_file}:{self.target_node})',
+                f'however the tool was already chosen as: {_orig_tool}. The --tool arg will',
+                f'not be applied from: {tokens}'
+            )
+        elif (self.command_design_ref.auto_tool_applied or not _tool_class) and parsed.tool:
+            # tool arg wasn't present (not a Tool class), or it was auto-applied,
+            # then add the arg anyway so we can later respawn with the correct tool.
+            self.args['tool'] = parsed.tool
+            debug(f'setting arg.tool to {parsed.tool=} from {self.caller_info}')
 
-        return tokens
+        # remove blanks, '--tool[=value| value]' removed.
+        return [item for item in tokens2 if item != '']
 
 
-    def apply_args( # pylint: disable=too-many-locals,too-many-branches
-            self, args_list:list
+    def apply_args( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+            self, args_list:list, tagname: str = ''
     ) -> list:
         '''Given args_list, applies them to our self.command_design_ref obj
 
@@ -174,9 +213,15 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         unparsed args will show up as eda.py warnings, but will not fail. Most callers do not
         use the unparsed args from this method.
         '''
+        if tagname:
+            tagname = f'{tagname=}'
+
         if not isinstance(args_list, (str, list)):
             self.error(f"{args_list=} is not type str/list, can't apply args",
-                       f"in {self.caller_info}")
+                       f"in {self.caller_info} {tagname}")
+
+        prev_args = copy.deepcopy(self.args)
+
         tokens = dep_str2list(args_list)
 
         # patch args relative to the DEPS (if self.deps_dir exists) so things like
@@ -211,7 +256,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             tokens2 = list(filter(None, unparsed))
         except argparse.ArgumentError:
             error('deps_processor -f/--input-file, problem attempting to parse_known_args for:',
-                  f'{tokens}')
+                  f'{tokens}, {self.caller_info} {tagname}')
             tokens2 = tokens
 
         if parsed.input_file:
@@ -242,13 +287,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         # the user may think they were allowed to set --tool, but in our flow the Command handler
         # (self.command_design_ref) has already been chosen, so setting the tool can have
         # strange side-effects.
+        _tool_class = 'tool' in self.args
         _orig_tool = self.args.get('tool', '')
-        tokens = self._apply_args_check_tools(tokens=tokens)
-        if not tokens:
-            return []
+        tokens = self._apply_args_check_tools(tokens=tokens, tagname=tagname)
 
         debug(f'deps_processor - custom apply_args with {tokens=}',
-              f'from {self.caller_info}')
+              f'from {self.caller_info} {tagname}')
         _, unparsed = self.command_design_ref.run_argparser_on_list(
             tokens=tokens
         )
@@ -256,7 +300,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         # Annoying, but check for plusargs in unparsed, and have referenced CommandDesign
         # or CommandSim class handle it with process_plusarg.
         for arg in list(unparsed):
-            if arg.startswith('+'):
+            if arg.startswith('+') and self.is_command_design:
                 self.command_design_ref.process_plusarg(plusarg=arg, pwd=self.target_path)
                 unparsed.remove(arg)
 
@@ -264,10 +308,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         for arg in list(unparsed):
             # Since this isn't command line, we have to assume for files, the path is relative
             # to this DEPS file.
-            if os.path.isabs(arg):
-                target = arg
-            else:
-                target = os.path.join(self.deps_dir, arg)
+            target = self.correct_a_deps_target(target=arg, deps_dir=self.deps_dir)
 
             file_exists, fpath, forced_extension = files.get_source_file(target)
             if file_exists:
@@ -279,6 +320,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
             else:
                 if not os.path.isdir(target) and \
+                   self.is_command_design and \
                    self.command_design_ref.resolve_target_core(
                        target=target, no_recursion=False, caller_info=self.caller_info,
                        error_on_not_found=False
@@ -293,7 +335,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             warning(f'For {self.command_design_ref.command_name}:' \
                     + f' in {self.caller_info} has unknown args {unparsed=}')
 
-        if self.command_design_ref.auto_tool_applied and _orig_tool != self.args.get('tool', ''):
+        if (self.command_design_ref.auto_tool_applied or not _tool_class) and \
+            _orig_tool != self.args.get('tool', ''):
+            # If there was an auto tool applied (tool class or not) then attempt to pick
+            # a new sub-command-object with that tool.
             debug(f'deps_processor.apply_args: tool changed, {self.args["tool"]=}, will attempt',
                   f'to respawn the job using original args: {self.config["eda_original_args"]}')
             self.command_design_ref.tool_changed_respawn = {
@@ -302,6 +347,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 'from': self.caller_info,
             }
 
+        diff_args = dict_diff(prev_args, self.args)
+        if diff_args:
+            args_list = [item for item in args_list if item != ''] # remove blanks
+            info(f'{Colors.yellow}{self.caller_info} {tagname}{Colors.green}:',
+                 f'applying args for {args_list}: {Colors.cyan}{diff_args}')
+
         return unparsed
 
     def apply_reqs(self, reqs_list:list) -> None:
@@ -551,9 +602,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                                     ' skipped args due to args disabled.')
                         if args_list:
                             # This will apply knowns args to the target dep:
-                            info(f'{tagname=} in {self.caller_info=}:',
+                            debug(f'{tagname=} in {self.caller_info=}:',
                                  f'applying args for {args_list=}')
-                            self.apply_args(args_list)
+                            self.apply_args(args_list, tagname=tagname)
 
                     elif key == 'reqs':
                         reqs_list = deps_target_get_deps_list(entry=value,
@@ -578,11 +629,16 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 # apply replace-config-tools
                 # This will replace lists (compile-waivers).
                 tool_config = value.get('replace-config-tools', {}).get(tool, None)
-                if tool_config and not deps_tags_enables.get('replace-config-tools', None):
+                ref_has_tool_config = isinstance(
+                    getattr(self.command_design_ref, 'tool_config', None), dict
+                )
+                if tool_config and (not deps_tags_enables.get('replace-config-tools', None) or \
+                                    not ref_has_tool_config):
                     tool_config = None
                     warning(f'{tagname=} in {self.caller_info}:',
-                            ' skipped replace-config-tools b/c it is disabled.')
-                if tool_config and isinstance(tool_config, dict):
+                            'skipped replace-config-tools b/c it is disabled or not present for',
+                            'this tool and command')
+                if ref_has_tool_config and tool_config and isinstance(tool_config, dict):
                     # apply it to self.tool_config:
                     info(f'{tagname=} in {self.caller_info}:',
                          f'applying replace-config-tools for {tool=}: {tool_config}')
@@ -595,11 +651,13 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 # apply additive-config-tools
                 # This will append to lists (compile-waivers)
                 tool_config = value.get('additive-config-tools', {}).get(tool, None)
-                if tool_config and not deps_tags_enables.get('additive-config-tools', None):
+                if tool_config and (not deps_tags_enables.get('additive-config-tools', None) or \
+                                    not ref_has_tool_config):
                     tool_config = None
                     warning(f'{tagname=} in {self.caller_info}:',
-                            ' skipped additive-config-tools b/c it is disabled.')
-                if tool_config and isinstance(tool_config, dict):
+                            ' skipped additive-config-tools b/c it is disable or not present for',
+                            'this tool and command')
+                if ref_has_tool_config and tool_config and isinstance(tool_config, dict):
                     # apply it to self.tool_config:
                     info(f'{tagname=} in {self.caller_info}:',
                          f'applying additive-config-tools for {tool=}: {tool_config}')
@@ -774,6 +832,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
         shell_commands_list, work_dir_add_srcs_list = self.get_commands(commands=commands, dep=dep)
 
+        if shell_commands_list and \
+           not self.is_command_design:
+            warning(f'Not applying shell commands from {self.caller_info}, not supported',
+                    'for this tool and command')
+            return
+
         # add these commands lists to self.command_design_ref:
         # Process all shell_commands_list:
         # This will track each shell command with its target_node and target_path
@@ -850,7 +914,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
 
             elif isinstance(dep, str) and \
-                 any(dep.startswith(x) for x in ['+define+', '+incdir+']):
+                 any(dep.startswith(x) for x in ['+define+', '+incdir+']) and \
+                 self.is_command_design:
                 # Note: we still support +define+ and +incdir in the deps list.
                 # check for compile-time Verilog style plusarg, which are supported under targets
                 # These are not run-time Verilog style plusargs comsumable from within the .sv:
@@ -860,10 +925,11 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             else:
                 # If we made it this far, dep better be a str type.
                 assert isinstance(dep, str), f'{dep=} {type(dep)=} must be str'
-                dep_path = os.path.join(self.target_path, dep)
+                dep_path = self.correct_a_deps_target(target=dep, deps_dir=self.target_path)
                 debug(f"Got dep {dep_path=} for in {self.caller_info}")
 
-                if dep_path in self.command_design_ref.targets_dict or \
+                if self.is_command_design and \
+                   dep_path in self.command_design_ref.targets_dict or \
                    dep_path in deps_targets_to_resolve:
                     debug(" - already processed, skipping")
                 else:
@@ -888,3 +954,16 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         #    dep3: 'command_tuple',
         #  }
         return deps_targets_to_resolve
+
+
+    def correct_a_deps_target(self, target: str, deps_dir: str) -> str:
+        '''Give a target/file in a deps: list, return a patched version
+
+        - $VAR replacment
+        - relative to current DEPS file dir (or not if it was abspath)
+        '''
+        if self.config['deps_expandvars_enable']:
+            target = os.path.expandvars(target)
+        if not os.path.isabs(target):
+            target = os.path.join(deps_dir, target)
+        return target