opencos-eda 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

opencos/deps/deps_file.py

@@ -249,8 +249,11 @@ class DepsFile:
                 self.rel_deps_file = os.path.join(os.path.relpath(deps_path), deps_leaf)
 
         self.error = getattr(command_design_ref, 'error', None)
+        self.error_ifarg = getattr(command_design_ref, 'error_ifarg', None)
         if not self.error:
             self.error = util.error
+        if not self.error_ifarg:
+            self.error_ifarg = util.error
 
 
     def found(self) -> bool:
@@ -287,7 +290,9 @@ class DepsFile:
                       f'{targets_str}'))
 
 
-    def lookup(self, target_node: str, caller_info: str) -> bool:
+    def lookup(  # pylint: disable=too-many-branches
+            self, target_node: str, caller_info: str
+    ) -> bool:
         '''Returns True if the target_node is in the DEPS markup file. If not, error with
 
         some caller_info(str). This is more useful for YAML or TOML markup where we have
@@ -295,16 +300,20 @@ class DepsFile:
         '''
         if target_node not in self.data:
             found_target = False
-            # For error printing, prefer relative paths:
-            t_path = os.path.relpath(self.target_path) + os.path.sep
-            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
 
+            # 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 not is_valid_target_name(target_node):
                 util.warning(
                     f"In file {self.rel_deps_file}, {target_node} {VALID_TARGET_INFO_STR}"
@@ -314,19 +323,28 @@ class DepsFile:
                 # 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(f'Trying to resolve command-line target={t_full} (file?):',
-                               f'File={t_node} not found in directory={t_path}',
-                               error_code=EDA_DEPS_FILE_NOT_FOUND)
+                    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(f'Trying to resolve command-line target={t_full}:',
-                               f'but path {t_path} has no DEPS markup file (DEPS.yml)',
-                               error_code=EDA_DEPS_FILE_NOT_FOUND)
+                    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(f'Trying to resolve command-line target={t_full}:',
-                               f'was not found in deps_file={self.rel_deps_file}',
-                               error_code=EDA_DEPS_TARGET_NOT_FOUND)
+                    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:
                 # If we have caller_info, then this was a recursive call from another
@@ -334,22 +352,31 @@ class DepsFile:
 
                 if '.' in target_node:
                     # Likely a filename (target_node does not include path)
-                    self.error(f'Trying to resolve target={t_full} (file?):',
-                               f'called from {caller_info},',
-                               f'File={t_node} not found in directory={t_path}',
-                               error_code=EDA_DEPS_FILE_NOT_FOUND)
+                    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(f'Trying to resolve target={t_full}:',
-                               f'called from {caller_info},',
-                               f'but {t_path} has no DEPS markup file (DEPS.yml)',
-                               error_code=EDA_DEPS_FILE_NOT_FOUND)
+                    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(f'Trying to resolve target={t_full}:',
-                               f'called from {caller_info},',
-                               f'Target not found in deps_file={self.rel_deps_file}',
-                               error_code=EDA_DEPS_TARGET_NOT_FOUND)
+                    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
+                    )
         else:
             debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
             found_target = True

opencos/deps/deps_processor.py

@@ -4,11 +4,13 @@ a DEPS markup files targets (applying deps, reqs, commands, tags, incdirs, defin
 CommandDesign ref object
 '''
 
+import argparse
 import os
 
 from opencos import files
 from opencos import eda_config
-from opencos.util import debug, info, warning, error
+from opencos.util import debug, info, warning, error, read_tokens_from_dot_f, \
+    patch_args_for_dir
 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
@@ -48,6 +50,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         self.target_path = target_path
         self.target_node = target_node # for debug
         self.deps_file = deps_file # for debug
+        self.deps_dir, _ = os.path.split(deps_file)
         self.caller_info = caller_info
 
         assert isinstance(deps_entry, dict), \
@@ -150,7 +153,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         return tokens
 
 
-    def apply_args(self, args_list:list) -> list:
+    def apply_args( # pylint: disable=too-many-locals,too-many-branches
+            self, args_list:list
+    ) -> list:
         '''Given args_list, applies them to our self.command_design_ref obj
 
         This will return unparsed args that weren't in the self.command_design_ref.args keys
@@ -162,10 +167,54 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                        f"in {self.caller_info}")
         tokens = dep_str2list(args_list)
 
+        # patch args relative to the DEPS (if self.deps_dir exists) so things like
+        # --build-tcl=<file> for relative <file> works when calling targets from any directory.
+        tokens = patch_args_for_dir(
+            tokens=tokens, patch_dir=self.deps_dir, caller_info=self.caller_info
+        )
+
         # We're going to run an ArgumentParser here, which is not the most efficient
         # thing to do b/c it runs on all of self.command_design_ref.args (dict) even
         # if we're applying a single token.
 
+        # Since some args (util.py, eda_config.py, eda.py) can only be handled from command
+        # line, it would be nice if -f or --input-file is handled from DEPS, so we'll special
+        # case that now. Recursively resolve -f / --input-file.
+        parser = argparse.ArgumentParser(
+            prog='deps_processor -f/--input-file', add_help=False, allow_abbrev=False
+        )
+        parser.add_argument('-f', '--input-file', default=[], action='append',
+                            help=(
+                                'Input .f file to be expanded as eda args, defines, incdirs,'
+                                ' files, or targets.'
+                            ))
+        try:
+            parsed, unparsed = parser.parse_known_args(tokens + [''])
+            tokens2 = list(filter(None, unparsed))
+        except argparse.ArgumentError:
+            error('deps_processor -f/--input-file, problem attempting to parse_known_args for:',
+                  f'{tokens}')
+            tokens2 = tokens
+
+        if parsed.input_file:
+            dotf_tokens = []
+            for filepath in parsed.input_file:
+                # Since this isn't command line, we have to assume the path is relative
+                # to this DEPS file.
+                if not os.path.isabs(filepath):
+                    filepath = os.path.join(self.deps_dir, filepath)
+                dotf_tokens.extend(read_tokens_from_dot_f(
+                    filepath=filepath, caller_info=self.caller_info, verbose=True
+                ))
+
+            # put the .f files before the unparsed args.
+            tokens2 = dotf_tokens + tokens2
+
+            # recurse until we've resolved nested .f files.
+            return self.apply_args(args_list=tokens2)
+
+        tokens = tokens2 # if no --input-file values, keep parsing the remaining tokens2
+
         # We have to special-case anything with --tool[=value] in tokens, otherwise
         # 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
@@ -180,11 +229,38 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         _, unparsed = self.command_design_ref.run_argparser_on_list(
             tokens=tokens
         )
+
         # Annoying, but check for plusargs in unparsed, and have referenced CommandDesign
         # or CommandSim class handle it with process_plusarg.
-        for arg in unparsed:
+        for arg in list(unparsed):
             if arg.startswith('+'):
                 self.command_design_ref.process_plusarg(plusarg=arg, pwd=self.target_path)
+                unparsed.remove(arg)
+
+        # For any leftover files, or targets, attempt to process those too:
+        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)
+
+            file_exists, fpath, forced_extension = files.get_source_file(target)
+            if file_exists:
+                _, file_ext = os.path.splitext(fpath)
+                if forced_extension or file_ext:
+                    self.command_design_ref.add_file(fpath, caller_info=self.caller_info,
+                                                     forced_extension=forced_extension)
+                    unparsed.remove(arg)
+
+            else:
+                if not os.path.isdir(target) and \
+                   self.command_design_ref.resolve_target_core(
+                       target=target, no_recursion=False, caller_info=self.caller_info,
+                       error_on_not_found=False
+                   ):
+                    unparsed.remove(arg)
 
         if unparsed:
             # This is only a warning - because things like CommandFlist may not have every

opencos/eda_base.py

@@ -230,6 +230,7 @@ class Command: # pylint: disable=too-many-public-methods
             'enable-tags': [],
             'disable-tags': [],
             'test-mode': False,
+            'error-unknown-args': True,
         })
         self.args_help.update({
             'stop-before-compile': ('stop this run before any compile (if possible for tool) and'
@@ -249,6 +250,9 @@ class Command: # pylint: disable=too-many-public-methods
                             ' --disable-tags has higher precedence than --enable-tags.'),
             'test-mode': ('command and tool dependent, usually stops the command early without'
                           ' executing.'),
+            'error-unknown-args': (
+                'Enable errors on unknown/unparsable args, or unknown/nonexistent files, or targets'
+            ),
         })
         self.modified_args = {}
         self.config = copy.deepcopy(config) # avoid external modifications.
@@ -495,9 +499,12 @@ class Command: # pylint: disable=too-many-public-methods
 
         # Do some minimal type handling, preserving the type(self.args[key])
         if key not in self.args:
-            self.error(f'set_arg, {key=} not in self.args {value=}',
-                       f'({self.command_name=}, {self.__class__.__name__=})',
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_ifarg(
+                f'set_arg, {key=} not in self.args {value=}',
+                f'({self.command_name=}, {self.__class__.__name__=})',
+                arg='error-unknown-args',
+                error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR
+            )
 
         cur_value = self.args[key]
 
@@ -692,9 +699,12 @@ class Command: # pylint: disable=too-many-public-methods
         _, unparsed = self.run_argparser_on_list(tokens)
         if process_all and unparsed:
             self.warning_show_known_args()
-            self.error(f"Didn't understand argument: '{unparsed=}' in",
-                       f" {self.command_name=} context, {pwd=}",
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_ifarg(
+                f"Didn't understand argument: '{unparsed=}' in",
+                f"{self.command_name=} context, {pwd=}",
+                arg='error-unknown-args',
+                error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR
+            )
 
         return unparsed
 
@@ -910,6 +920,20 @@ class Command: # pylint: disable=too-many-public-methods
         lines.append(self.pretty_str_known_args(command=commands[-1])) # use last command if > 1
         util.warning("\n".join(lines))
 
+    def error_ifarg(
+            self, *msg, arg: str, error_code: int = status_constants.EDA_COMMAND_OR_ARGS_ERROR
+    ) -> None:
+        '''For errors involving an unknown --arg, they can be optionally disabled
+
+        using CLI: --no-error-unknown-args, and this method arg='error-uknown-arg'
+
+        Note if arg is not present in self.args, the error is enabled.
+        '''
+        if self.args.get(arg, True):
+            self.error(*msg, error_code=error_code)
+        else:
+            util.warning(*msg)
+
 
 class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     '''CommandDesign is the eda base class for command handlers that need to track files.
@@ -1392,7 +1416,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         return self.resolve_target_core(target, no_recursion, caller_info)
 
     def resolve_target_core( # pylint: disable=too-many-locals,too-many-branches
-            self, target: str, no_recursion: bool, caller_info: str = ''
+            self, target: str, no_recursion: bool, caller_info: str = '',
+            error_on_not_found: bool = True
     ) -> bool:
         '''Returns True if target is found. recursive point for resolving path or DEPS markup
         target names.'''
@@ -1481,14 +1506,18 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     self.add_file(try_file, caller_info=f'n/a::{target}::n/a')
                     found_target = True
                     break # move on to the next target
-            if not found_target: # if STILL not found_this_target...
-                self.error(f"Unable to resolve {target=}",
-                           error_code=status_constants.EDA_DEPS_TARGET_NOT_FOUND)
+            if not found_target and error_on_not_found: # if STILL not found_this_target...
+                # allow this if --no-error-unknown-args:
+                self.error_ifarg(
+                    f"Unable to resolve {target=}",
+                    arg='error-unknown-args',
+                    error_code=status_constants.EDA_DEPS_TARGET_NOT_FOUND
+                )
 
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
 
-    def add_file(
+    def add_file( # pylint: disable=too-many-locals,too-many-branches
             self, filename: str, use_abspath: bool = True, add_to_non_sources: bool = False,
             caller_info: str = '', forced_extension: str = ''
     ) -> str:
@@ -1512,6 +1541,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         vhdl_file_ext_list = known_file_ext_dict.get('vhdl', [])
         cpp_file_ext_list = known_file_ext_dict.get('cpp', [])
         sdc_file_ext_list = known_file_ext_dict.get('synth_constraints', [])
+        dotf_file_ext_list = known_file_ext_dict.get('dotf', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1544,6 +1574,13 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         elif file_ext in sdc_file_ext_list:
             self.files_sdc.append(file_abspath)
             util.debug(f"Added SDC file {filename} as {file_abspath}")
+        elif file_ext in dotf_file_ext_list:
+            # a stray .f file as a source file, sure why not support it:
+            dp = DepsProcessor(command_design_ref=self, deps_entry={}, target='',
+                               target_path='', target_node='', deps_file='',
+                               caller_info=caller_info)
+            dp.apply_args(args_list=[f'-f={file_abspath}'])
+            del dp
         else:
             # unknown file extension. In these cases we link the file to the working directory
             # so it is available (for example, a .mem file that is expected to exist with relative
@@ -1637,9 +1674,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         if process_all and possible_unparsed_args:
             _tool = self.safe_which_tool()
             self.warning_show_known_args()
-            self.error(f"Didn't understand unparsed args: {possible_unparsed_args}, for command",
-                       f"'{self.command_name}', tool '{_tool}'",
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_ifarg(
+                f"Didn't understand unparsed args: {possible_unparsed_args}, for command",
+                f"'{self.command_name}', tool '{_tool}'",
+                arg='error-unknown-args',
+                error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR
+            )
 
         remove_list = []
         last_potential_top_file = ('', '')   # (top, fpath)
@@ -1697,9 +1737,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # we were unable to figure out what this command line token is for...
         if process_all and unparsed:
             self.warning_show_known_args()
-            self.error(f"Didn't understand remaining args or targets {unparsed=} for command",
-                       f"'{self.command_name}'",
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_ifarg(
+                f"Didn't understand remaining args or targets {unparsed=} for command",
+                f"'{self.command_name}'",
+                arg='error-unknown-args',
+                error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR
+            )
 
         # handle a missing self.args['top'] with last filepath or last target:
         if not self.args.get('top', ''):
@@ -2244,9 +2287,12 @@ class CommandParallel(Command):
         bad_remaining_args = [x for x in single_cmd_unparsed if x.startswith('-')]
         if bad_remaining_args:
             self.warning_show_known_args(command=f'{self.command_name} {command}')
-            self.error(f'for {self.command_name} {command=} the following args are unknown',
-                       f'{bad_remaining_args}',
-                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            self.error_ifarg(
+                f'for {self.command_name} {command=} the following args are unknown',
+                f'{bad_remaining_args}',
+                arg='error-unknown-args',
+                error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR
+            )
 
         # Remove unparsed args starting with '+', since those are commonly sent downstream to
         # single job (example, CommandSim plusargs).

opencos/eda_config_defaults.yml

@@ -91,6 +91,9 @@ file_extensions:
   synth_constraints:
     - .sdc
     - .xdc
+  dotf:
+    - .f
+    - .vc
 
   inferred_top:
     # file extensions that we can infer "top" module from, if --top omitted.

opencos/files.py

@@ -24,6 +24,7 @@ FORCE_PREFIX_DICT = {
     'vhdl@': 'vhdl',
     'cpp@': 'cpp',
     'sdc@': 'synth_constraints',
+    'f@': 'dotf'
 }
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))

opencos/tests/helpers.py

@@ -9,12 +9,14 @@ from pathlib import Path
 
 from contextlib import redirect_stdout, redirect_stderr
 
-from opencos import eda
-from opencos import deps_schema
+from opencos import eda, eda_tool_helper, deps_schema
 from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils import status_constants
 from opencos.utils.subprocess_helpers import subprocess_run_background
 
+# Figure out what tools the system has available, without calling eda.main(..)
+config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
+
 
 def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
     '''Because eda_wrap calls eda_main(..) and will continue running
@@ -30,11 +32,11 @@ def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
         status_constants.EDA_DEFAULT_ERROR
     )
 
-def can_run_eda_command(*commands, config: dict) -> bool:
+def can_run_eda_command(*commands, cfg: dict = config) -> bool:
     '''Returns True if we have any installed tool that can run: eda <command>'''
     runnable = []
     for command in list(commands):
-        handler = config['command_handler'].get(command, None)
+        handler = cfg['command_handler'].get(command, None)
         if not handler:
             return False
         if handler and getattr(handler, 'CHECK_REQUIRES', []):
@@ -44,7 +46,7 @@ def can_run_eda_command(*commands, config: dict) -> bool:
         # We cannot run tools that have disable-auto set:
         tool = getattr(handler, '_TOOL', '')
         if handler and tool:
-            entry = config['auto_tools_order'][0].get(tool, {})
+            entry = cfg['auto_tools_order'][0].get(tool, {})
             if entry and entry.get('disable-auto', False):
                 # This tool cannot automatically run our command.
                 return False
@@ -52,6 +54,14 @@ def can_run_eda_command(*commands, config: dict) -> bool:
         runnable.append(True)
     return runnable and all(runnable)
 
+def can_run_eda_sim(cfg: dict = config) -> bool:
+    '''Returns True if we have any installed tool that can run: eda sim'''
+    return can_run_eda_command('sim', cfg=cfg)
+
+def can_run_eda_elab(cfg: dict = config) -> bool:
+    '''Returns True if we have any installed tool that can run: eda elab'''
+    return can_run_eda_command('elab', cfg=cfg)
+
 def chdir_remove_work_dir(startpath, relpath):
     '''Changes dir to startpath/relpath, removes the work directories (eda.work, eda.export*)'''
     os.chdir(os.path.join(str(Path(startpath)), str(Path(relpath))))
@@ -171,6 +181,7 @@ class Helpers:
         '''Changes directory to self.DEFAULT_DIR and removes eda.work, eda.export paths'''
         chdir_remove_work_dir('', self.DEFAULT_DIR)
 
+
     def _resolve_logfile(self, logfile=None) -> str:
         '''Returns the logfile's filepath'''
         ret = logfile
@@ -232,7 +243,7 @@ class Helpers:
         return rc
 
     def is_in_log(self, *want_str, logfile=None, windows_path_support=False):
-        '''Check if any of want_str args are in the logfile, or self.DEFAULT_LOG'''
+        '''Check if want_str (joined) is in the logfile, or self.DEFAULT_LOG'''
         logfile = self._resolve_logfile(logfile)
         want_str0 = ' '.join(list(want_str))
         want_str1 = want_str0.replace('/', '\\')

opencos/tests/test_eda.py

@@ -23,11 +23,12 @@ import subprocess
 
 import pytest
 
-from opencos import eda, eda_tool_helper
+from opencos import eda
 from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.tests import helpers
 from opencos.tests.helpers import eda_wrap, eda_sim_wrap, eda_elab_wrap, \
-    Helpers
+    Helpers, tools_loaded, can_run_eda_sim
+
 
 
 THISPATH = os.path.dirname(__file__)
@@ -36,17 +37,6 @@ def chdir_remove_work_dir(relpath):
     '''Changes dir to relpath, removes the work directories (eda.work, eda.export*)'''
     return helpers.chdir_remove_work_dir(THISPATH, relpath)
 
-# Figure out what tools the system has available, without calling eda.main(..)
-config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
-
-def can_run_eda_sim() -> bool:
-    '''Returns True if we have any installed tool that can run: eda sim'''
-    return helpers.can_run_eda_command('sim', config=config)
-
-def can_run_eda_elab() -> bool:
-    '''Returns True if we have any installed tool that can run: eda elab'''
-    return helpers.can_run_eda_command('elab', config=config)
-
 @pytest.mark.skipif(
     'verilator' not in tools_loaded and 'vivado' not in tools_loaded,
     reason="requires verilator OR vivado"

opencos/tests/test_tools.py

@@ -6,25 +6,23 @@ import os
 import sys
 import pytest
 
-from opencos import eda, eda_tool_helper, eda_base
+from opencos import eda, eda_base
 
 from opencos.tools.verilator import ToolVerilator
 from opencos.tools.vivado import ToolVivado
 from opencos.tools.cocotb import ToolCocotb
 from opencos.tests import helpers
-from opencos.tests.helpers import eda_wrap, eda_wrap_is_sim_fail
+from opencos.tests.helpers import eda_wrap, eda_wrap_is_sim_fail, config, tools_loaded
 from opencos.utils.markup_helpers import yaml_safe_load
 from opencos.utils import status_constants
 
 
-thispath = os.path.dirname(__file__)
+THISPATH = os.path.dirname(__file__)
 
 def chdir_remove_work_dir(relpath):
     '''Changes dir to relpath, removes the work directories (eda.work, eda.export*)'''
-    return helpers.chdir_remove_work_dir(thispath, relpath)
+    return helpers.chdir_remove_work_dir(THISPATH, relpath)
 
-# Figure out what tools the system has available, without calling eda.main(..)
-config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
 
 def test_tools_loaded():
     '''Does not directly call 'eda.main' instead create a few Tool
@@ -37,7 +35,7 @@ def test_tools_loaded():
     # It's possible we're running in some container or install that has no tools, for example,
     # Windows.
     if sys.platform.startswith('win') and \
-       not helpers.can_run_eda_command('elab', 'sim', config=config):
+       not helpers.can_run_eda_command('elab', 'sim', cfg=config):
         # Windows, not handlers for elab or sim:
         pass
     else:
@@ -129,7 +127,7 @@ def test_sim_elab_tools_pass_or_fail(command, tool, target, sim_expect_pass, add
         added_args = added_sim_args_str.split()
 
     relative_dir = "deps_files/test_err_fatal"
-    os.chdir(os.path.join(thispath, relative_dir))
+    os.chdir(os.path.join(THISPATH, relative_dir))
     rc = eda.main(command, '--tool', tool, *(added_args), target)
     print(f'{rc=}')
     if command != 'sim' or sim_expect_pass:

opencos/util.py

@@ -435,25 +435,67 @@ def load_env_file(env_file: str) -> None:
     else:
         warning(f'--env-file {env_file} does not exist and is not loaded.')
 
-def read_tokens_from_dot_f(filepath: str) -> list:
+def patch_args_for_dir(tokens: list, patch_dir: str, caller_info: str) -> list:
+    '''Given list of args, attempt to correct for relative dir'''
+
+    # deal with relative path args or files.
+    # Note the dot-f file could have been in a different directory (-f=path/to/my.f)
+    # As a workaround to deal with relative paths, attempt to replace relative
+    # path args within this dotf contents - so they are relative the dotf dir:
+    if not os.path.isdir(patch_dir):
+        return tokens
+
+    ret = []
+    for word in tokens:
+        if word.startswith('-') and '=' in word:
+            parts = word.split('=')
+            leftarg = parts[0] + '='
+            word = '='.join(parts[1:])
+        elif word.startswith('+incdir+'):
+            # do for +incdir+ too
+            leftarg = '+incdir+'
+            word = word[len('+incdir+'):]
+        else:
+            leftarg = ''
+
+        if word and not os.path.isabs(word) and \
+           os.path.exists(os.path.join(patch_dir, word)):
+            # fix relative path of word, or --arg=word
+            word = os.path.abspath(os.path.join(patch_dir, word))
+            info(f'Using relative path {patch_dir} for arg/token: {leftarg}{word}',
+                 f'{caller_info}')
+        ret.append(f'{leftarg}{word}')
+    return ret
+
+def read_tokens_from_dot_f(filepath: str, caller_info: str = '', verbose: bool = False) -> list:
     '''Returns list of tokens from a .f file, with ENV vars expanded'''
 
     # Let's defer 'info' printing out what input files were opened until after
     # args['quiet'] and debug is resolved (which may be in these .f files)
-    debug(f"Opening -f / --input-file '{filepath}' for contents")
+    start_str = f"Opening -f / --input-file '{filepath}' for contents {caller_info}"
+    if verbose:
+        info(start_str)
+    else:
+        debug(start_str)
     if not os.path.isfile(filepath):
-        error(f'-f (or --input-file): {filepath} does not exist',
+        error(f'-f (or --input-file): {filepath} does not exist {caller_info}',
               error_code=status_constants.EDA_GENERAL_FILE_NOT_FOUND)
         return []
     if os.path.abspath(filepath) in dot_f_files_expanded:
         error(f'-f (or --input-file): {filepath} has already been expanded',
-              'cannot traverse again (duplicate arg or nested .f files)')
+              f'cannot traverse again (duplicate arg or nested .f files) {caller_info}')
     dot_f_files_expanded.add(os.path.abspath(filepath))
     tokens = []
+    dotf_file_dir, _ = os.path.split(filepath)
     with open(filepath, encoding='utf-8') as f:
         for line in f:
             line = os.path.expandvars(line.strip())
-            tokens.extend(line.split())
+            if not line or line.startswith('#') or line.startswith('//'):
+                continue
+            words = line.split()
+            tokens.extend(patch_args_for_dir(
+                tokens=words, patch_dir=dotf_file_dir, caller_info=f"(from dotf {filepath})"
+            ))
     return tokens
 
 
@@ -471,7 +513,7 @@ def process_debug_args(parsed: argparse.Namespace) -> None:
 
 
 def process_tokens( # pylint: disable=too-many-branches
-        tokens: list
+        tokens: list, caller_info: str = ''
 ) -> (argparse.Namespace, list):
     '''Processes tokens (unparsed args list) on util's ArgumentParser
 
@@ -517,13 +559,15 @@ def process_tokens( # pylint: disable=too-many-branches
     if parsed.input_file:
         dotf_tokens = []
         for filepath in parsed.input_file:
-            dotf_tokens.extend(read_tokens_from_dot_f(filepath))
+            dotf_tokens.extend(read_tokens_from_dot_f(
+                filepath=filepath, caller_info=caller_info
+            ))
 
         # put the .f files before the unparsed args.
         tokens2 = dotf_tokens + tokens2
 
         # recurse until we've resolved nested .f files.
-        return process_tokens(tokens=tokens2)
+        return process_tokens(tokens=tokens2, caller_info=f'(from {parsed.input_file[-1]})')
 
 
     # Continue with all normal parsing beyond --debug and -f/--input-file,

{opencos_eda-0.3.0.dist-info → opencos_eda-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.3.0
+Version: 0.3.2
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos

{opencos_eda-0.3.0.dist-info → opencos_eda-0.3.2.dist-info}/RECORD

@@ -3,9 +3,9 @@ opencos/_version.py,sha256=KaWIjS0c08g-C0fgYY1kXwSPqhOFxaq5pYEeoZhOR_I,617
 opencos/_waves_pkg.sv,sha256=TL5YT9lT-fn2FD54MbVVZROmZ7vtW3ScA_rM2eRzKmU,2068
 opencos/deps_schema.py,sha256=VUdXuq43mKfM-U4x7DSA28-MH1Xqxre6V7Ttw2DeOqI,16762
 opencos/eda.py,sha256=91E-EsyZS-uRadApP-h2onW6rpvLBnrpJoT_9tRtsS8,23322
-opencos/eda_base.py,sha256=oJ8ISAN6IykQfun8eVNuzjggQ5RvIKeWwQ85Wv4ww_4,107887
+opencos/eda_base.py,sha256=jf4t11UPj39swL41z-EJiGTOnHvRScaQc-SAjpZ5XI4,109651
 opencos/eda_config.py,sha256=z3yQOPGBX7-yKp6BdQYfJ9eOJf-Jctl-mwCDj3vj2BI,12712
-opencos/eda_config_defaults.yml,sha256=u1kzmclo5nElsn2BHOIYHk9_djbL0rUts4CLWYJbuc8,16036
+opencos/eda_config_defaults.yml,sha256=LF0yAncYeaPtZIoAfEeo2aiDXT4cjYa99soGks0WRzM,16063
 opencos/eda_config_max_verilator_waivers.yml,sha256=lTAU4IOEbUWVlPzuer1YYhIyxpPINeA4EJqcRIT-Ymk,840
 opencos/eda_config_reduced.yml,sha256=cQ9jY4J7EvAbeHTiP6bvpDSVJAYiitjLZPSxxLKIEbk,1440
 opencos/eda_deps_bash_completion.bash,sha256=jMkQKY82HBgOnQeMdA1hMrXguRFtB52SMBxUemKovL4,1958
@@ -14,11 +14,11 @@ opencos/eda_extract_targets.py,sha256=POlxZfqf2dNH2nc1CEw5B_53vSHAicSTkpU9_-2_6Z
 opencos/eda_tool_helper.py,sha256=_YgobDLEWW6Fzdr976LxaCDZ4DKRyuMs5CrYQHaTPrU,2558
 opencos/export_helper.py,sha256=5BnrkhiieJBgYKAryhXD7HSGtrgvXQpZ8B5ltdrhbRY,22649
 opencos/export_json_convert.py,sha256=tSIMbLFtc_Fo66EhFovMii1v_qJYyFZJrPNnoPdW7L0,4182
-opencos/files.py,sha256=aoq0O2KfISzZb-Vi_q_0TTGBER9xJc--FkVZf0ga7pA,1549
+opencos/files.py,sha256=AQOnsrvoc0r76LiFrkoMbwOGdUO1FpBiFY_jyyI_ve8,1566
 opencos/names.py,sha256=Y2aJ5wgpbNIJ-_P5xUXnHMv_h-zMOX2Rt6iLuduqC1Q,1213
 opencos/peakrdl_cleanup.py,sha256=vHNGtalTrIVP335PhRjPt9RhoccgpK1HJAi-E4M8Kc8,736
 opencos/seed.py,sha256=IL9Yg-r9SLSRseMVWaEHmuw2_DNi_eyut11EafoNTsU,942
-opencos/util.py,sha256=KK5_lSKSf8O6Wp-CtQ9bTg-izBEPkuxGh_N64DJhE-0,40038
+opencos/util.py,sha256=ffaSoDDOsL6mx_fYgAyJA8fawsxZ5YHKqs67b8iW5rw,41921
 opencos/commands/__init__.py,sha256=oOOQmn5_jHAMSOfA3swJJ7mdoyHsJA0lJwKPTudlTns,1125
 opencos/commands/build.py,sha256=mvJYxk5J15k0Cr8R7oIdIIdsEtWV3gE-LnPweVwtSDo,1487
 opencos/commands/deps_help.py,sha256=WDrU7H9sypzDAxe_CHqhW5B_scbQMzBEdf-v-Jcfd5Q,10682
@@ -40,22 +40,22 @@ opencos/commands/waves.py,sha256=nrp3ALwfJujZns44tgCgia_dEedQyKe0T3fuws8h39U,769
 opencos/deps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/deps/defaults.py,sha256=NXh3V4oInrBVlDw64B2OCI77wzdn1NtaD64srhBnmZU,1486
 opencos/deps/deps_commands.py,sha256=q4JfSfzRO2nM2zdNT4enCy33FokEytZYQJn1HJ6osJk,16606
-opencos/deps/deps_file.py,sha256=nVZWrq6PVhWig1yMNpy8w_7LQJ1rgb7Js0N1ngoqLio,16306
-opencos/deps/deps_processor.py,sha256=i8R6lNSVc_ybTnC16qmGevB3Y-pkcbxkZaT04HTLE8Y,37890
+opencos/deps/deps_file.py,sha256=YQ5ftYvppRTqUto22r-XDH6-bcMO7cA-WiJ7QzPjljY,17103
+opencos/deps/deps_processor.py,sha256=DBaMUEnpoIL4xaNPs2f2AFGcWLST5pP_Qgup9r-8D7M,41403
 opencos/hw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/hw/oc_cli.py,sha256=U1JGlshLZhtd0LgndZFBZVltAj_HemdhbjO_Zo8ZuVM,132252
 opencos/hw/pcie.py,sha256=VUJljaZJYgScAAx5yn7F6GoA8K9eTcw24otYZbkMpYs,3035
 opencos/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 opencos/tests/custom_config.yml,sha256=TRoVM9ZFKPOA_8JmlpzaMhnGO1txmaD14N_8P1oqzew,257
-opencos/tests/helpers.py,sha256=9KHSZ1JMmo2nUbJYiRehmNqd1mNQ29XbzReu_tHkxjk,11234
+opencos/tests/helpers.py,sha256=wkEzYRt78B4b7Qni2GoWcncrhWjZ3nLhDMHtPYvvW8w,11725
 opencos/tests/test_build.py,sha256=FQAxOpLVQShAHD_L5rqJctPeSAoqoOCNFI0RXflLuY0,387
 opencos/tests/test_deps_helpers.py,sha256=uQZxleh6aKO-mZQhagHh5xLIBbpQ8dav7-5D0eemq_g,8164
 opencos/tests/test_deps_schema.py,sha256=T3P9KjaMyKsk8b7snNVvNSsom2hIJcg6Z9apYiXoH9Y,941
-opencos/tests/test_eda.py,sha256=fkJvBiwPczs3Yl3zwl_1Upx-siJsGDrjEVipzpiw8vc,37880
+opencos/tests/test_eda.py,sha256=PhAFCqoZxUhjuSvNeHpTHdwt8UhHjRdVppesgcWBX64,37407
 opencos/tests/test_eda_elab.py,sha256=AjU4WMYtFoHpNe1Z4yWWpxDKy4V_hAjL5rl3jqphZrk,3179
 opencos/tests/test_eda_synth.py,sha256=BtBrNVJ9C-LJt3K0wNNS5ukEVrET16AbRXl2IzxudJ8,5744
 opencos/tests/test_oc_cli.py,sha256=w-F-LjSSWVql3D2WG8tcV4_C52i-hL_2WT3oDpKQn9s,734
-opencos/tests/test_tools.py,sha256=-WMpDZexAgko0FAcfiuASqSKNNL0Mr1ztag05808Upc,13735
+opencos/tests/test_tools.py,sha256=JFjwq8YJPxaALbIEZUA-1VR8O_N-zmmM4ueboFEYA4Y,13589
 opencos/tests/deps_files/command_order/DEPS.yml,sha256=PSzBBJDSU8ccCy3Ls5j_ws_vepmUkTIgWjaMjBhNbSg,806
 opencos/tests/deps_files/error_msgs/DEPS.yml,sha256=fYvHouIscOlr8V28bqx9SoxRBpDBLX4AG-AkVXh8qbo,717
 opencos/tests/deps_files/iverilog_test/DEPS.yml,sha256=vDylEuLt642lhRSvOr3F5ziB5lhPSwkaUGN4_mWJw-c,40
@@ -88,10 +88,10 @@ opencos/utils/str_helpers.py,sha256=726ScK5-v7QkBi-zqESKZLsOl2_ya4vVJ5ZhxJqmBFo,
 opencos/utils/subprocess_helpers.py,sha256=xemAGPey6M0sWY_FElvr-Z0phCfdjaC-znP8FKihPaE,3535
 opencos/utils/vscode_helper.py,sha256=9nHyMUIL-gzfW-qLH06sgaCnVK-YTOtu6pusitNNhL8,1363
 opencos/utils/vsim_helper.py,sha256=1johPOGbjbMgnCDSTpgsQcSuAquiqq1Y2MBxS6WY6b4,1552
-opencos_eda-0.3.0.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-opencos_eda-0.3.0.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
-opencos_eda-0.3.0.dist-info/METADATA,sha256=KFNlElAF1mTMOenvOMpVfD5MRlIj1shxNBUiFGTuTQM,666
-opencos_eda-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opencos_eda-0.3.0.dist-info/entry_points.txt,sha256=6n1T5NwVYDhN5l1h5zmyT197G4pE0SySDreB0QJzJR0,218
-opencos_eda-0.3.0.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
-opencos_eda-0.3.0.dist-info/RECORD,,
+opencos_eda-0.3.2.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+opencos_eda-0.3.2.dist-info/licenses/LICENSE.spdx,sha256=8gn1610RMP6eFgT3Hm6q9VKXt0RvdTItL_oxMo72jII,189
+opencos_eda-0.3.2.dist-info/METADATA,sha256=0PgS7CqBIdwYkBXPQ_6PaCFCNFKEsRz5G_owk48zkJI,666
+opencos_eda-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opencos_eda-0.3.2.dist-info/entry_points.txt,sha256=6n1T5NwVYDhN5l1h5zmyT197G4pE0SySDreB0QJzJR0,218
+opencos_eda-0.3.2.dist-info/top_level.txt,sha256=J4JDP-LpRyJqPNeh9bSjx6yrLz2Mk0h6un6YLmtqql4,8
+opencos_eda-0.3.2.dist-info/RECORD,,