opencos-eda 0.2.55__py3-none-any.whl → 0.2.57__py3-none-any.whl

opencos/commands/flist.py

@@ -10,6 +10,7 @@ import os
 from opencos import util
 from opencos.eda_base import CommandDesign
 from opencos.utils.str_helpers import strip_all_quotes
+from opencos.commands.sim import parameters_dict_get_command_list
 
 class CommandFList(CommandDesign):
     '''Base class command handler for: eda flist ...'''
@@ -22,6 +23,7 @@ class CommandFList(CommandDesign):
             'eda-dir'            : 'eda.flist', # user can specify eda-dir if files are generated.
             'out'                : "flist.out",
             'emit-define'        : True,
+            'emit-parameter'     : True,
             'emit-incdir'        : True,
             'emit-v'             : True,
             'emit-sv'            : True,
@@ -29,6 +31,7 @@ class CommandFList(CommandDesign):
             'emit-cpp'           : True,
             'emit-non-sources'   : True, # as comments, from DEPS 'reqs'
             'prefix-define'      : "+define+",
+            'prefix-parameter'   : "-G",
             'prefix-incdir'      : "+incdir+",
             'prefix-v'           : "",
             'prefix-sv'          : "",
@@ -179,6 +182,13 @@ class CommandFList(CommandDesign):
                     newline = prefix + qd1 + f"{d}{ed1}{value}" + qd2
                 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)
+
         if self.args['emit-incdir']:
             prefix = strip_all_quotes(self.args['prefix-incdir'])
             for i in self.incdirs:

opencos/commands/lec.py

@@ -27,6 +27,7 @@ class CommandLec(CommandDesign):
         self.args.update({
             'designs': [],
             'synth': True,
+            'flatten-all': True,
         })
         self.args_help.update({
             'designs': (
@@ -34,6 +35,9 @@ class CommandLec(CommandDesign):
                 ' use this arg twice'
             ),
             'synth': 'run synthesis on the two designs prior to running LEC',
+            'flatten-all': (
+                'arg passed to "synth" if run with --synth, to disable use --no-flatten-all'
+            ),
         })
 
         self.synth_design_verilog_fpaths = ['', '']

opencos/commands/multi.py

@@ -327,6 +327,10 @@ class CommandMulti(CommandParallel):
 
         if parsed.fail_if_no_targets and len(self.targets) == 0:
             self.error(f'Multi: --fail-if-no-targets set, and {self.targets=}')
+        if not all_multi_tools:
+            possible_tools = self.all_handler_commands.get(command, [])
+            self.error(f'Multi: no tools to run for {command=}, available tools: {possible_tools}')
+
         util.info("Multi: About to run: ", end="")
 
         def get_pretty_targets_tuple_as_list(l:list):

opencos/commands/sim.py

@@ -17,6 +17,33 @@ 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
+
+def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> list:
+    '''Given dict of parameters, returns a command list'''
+
+    ret_list = []
+    if ' ' in arg_prefix:
+        arg_list_prefix = arg_prefix.split()
+        arg_str_prefix = ''
+    else:
+        arg_list_prefix = []
+        arg_str_prefix = arg_prefix
+
+    for k,v in params.items():
+        if not isinstance(v, (int, str)):
+            util.warning(f'parameter {k} has value: {v}, parameters must be int/string types')
+
+        ret_list.extend(arg_list_prefix)
+        if isinstance(v, int):
+            ret_list.append(f'{arg_str_prefix}{k}={v}')
+        else: # string
+            v = strip_outer_quotes(v.strip('\n'))
+            v = '"' + v + '"'
+            ret_list.append(f'{arg_str_prefix}{k}={sanitize_defines_for_sh(v)}')
+    return ret_list
+
+
 class CommandSim(CommandDesign):
     '''Base class command handler for: eda sim ...'''
 
@@ -80,6 +107,10 @@ class CommandSim(CommandDesign):
 
         self.args['verilate-args'] = []
 
+    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_plusarg(self, plusarg: str, pwd: str = os.getcwd()) -> None:
         '''Override for CommandDesign.process_plusarg(..)'''
         maybe_plusarg = CommandDesign.process_plusarg(self, plusarg, pwd)

opencos/deps/defaults.py

@@ -31,6 +31,7 @@ KNOWN_EDA_COMMANDS = set([
 SUPPORTED_TARGET_TABLE_KEYS = set([
     'args',
     'defines',
+    'parameters',
     'incdirs',
     'top',
     'deps',
@@ -52,6 +53,7 @@ SUPPORTED_TAG_KEYS = set([
     'deps',
     'reqs',
     'defines',
+    'parameters',
     'incdirs',
     'replace-config-tools',
     'additive-config-tools',

opencos/deps/deps_processor.py

@@ -91,6 +91,22 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         v = v.replace('%SEED%', str(self.args.get('seed', 1)))
                 self.command_design_ref.process_plusarg(f'+define+{k}={v}')
 
+
+    def apply_parameters(self, parameters_dict: dict):
+        '''Given parameters_dict, applies them to our self.command_design_ref obj'''
+        if not isinstance(parameters_dict, dict):
+            self.error(f"{parameters_dict=} is not type dict, can't apply defines,",
+                       f"in {self.caller_info}")
+        for k,v in parameters_dict.items():
+            if v is None or v == '' or not isinstance(v, (int, str, bool)):
+                warning(f'parameter {k} has value: {v}, parameters must be bool/int/string types',
+                        f'from {self.caller_info}')
+            else:
+                self.command_design_ref.set_parameter(
+                    name=k, value=v, caller_info=self.caller_info
+                )
+
+
     def apply_incdirs(self, incdirs_list:list):
         '''Given incdirs_list, applies them to our self.command_design_ref obj'''
         if not isinstance(incdirs_list, (str, list)):
@@ -252,6 +268,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 remaining_deps_list += self.process_tags()
             elif key == 'defines':
                 self.process_defines()
+            elif key == 'parameters':
+                self.process_parameters()
             elif key == 'incdirs':
                 self.process_incdirs()
             elif key == 'top':
@@ -426,6 +444,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         # apply defines:
                         self.apply_defines(value.get('defines', {}))
 
+                    elif key == 'parameters':
+                        self.apply_parameters(value.get('parameters', {}))
+
                     elif key == 'incdirs':
                         # apply incdirs:
                         self.apply_incdirs(value.get('incdirs', []))
@@ -517,6 +538,22 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
         self.apply_defines(entry_defines)
 
+    def process_parameters(self):
+        '''Returns None, applies parameters (dict, if any) from self.deps_entry to
+        self.command_design_ref.'''
+
+        # Parameters:
+        # apply command specific parameters, with higher priority than the a
+        # deps_entry['sim']['parameters'] entry,
+        # do this with dict1.update(dict2):
+        entry_parameters = {}
+        entry_parameters.update(self.deps_entry.get('parameters', {}))
+        entry_parameters.update(self.entry_eda_command.get('parameters', {}))
+        assert isinstance(entry_parameters, dict), \
+            f'{entry_parameters=} for in {self.caller_info} must be a dict'
+
+        self.apply_parameters(entry_parameters)
+
     def process_incdirs(self) -> None:
         '''Returns None, applies incdirs (dict, if any) from self.deps_entry to
         self.command_design_ref.'''
@@ -700,7 +737,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 deps_targets_to_resolve.append(command_tuple)
 
 
-            elif isinstance(dep, str) and any(dep.startswith(x) for x in ['+define+', '+incdir']):
+            elif isinstance(dep, str) and \
+                 any(dep.startswith(x) for x in ['+define+', '+incdir+']):
                 # 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:

opencos/deps_schema.py

@@ -11,6 +11,9 @@ my_target_name:
   defines:                           <---- defines, optional table
     USER_DEFINE_VALUE: 12
 
+  parameters:                        <---- parameters, optional table
+    USER_PARAM_VALUE: 12
+
   incdirs:                           <---- incdirs, optional array (or string)
     - ./
 
@@ -32,6 +35,9 @@ my_target_name:
   defines:                           <---- defines, optional table of (key: str Or null)
     USER_DEFINE_VALUE: 12
 
+  parameters:                        <---- parameters, optional table
+    USER_PARAM_VALUE: 12
+
   incdirs:                           <---- incdirs, optional array of strings
     - ./
 
@@ -55,6 +61,7 @@ METADATA:                            <---- (optional) unstructured table
 
 my_target_name:
   defines:                           <---- defines, optional table
+  parameters:                        <---- parameters, optional table
   incdirs:                           <---- incdirs, optional array (or string)
   top: tb                            <---- top, optional string
   deps:                              <---- TARGET_DEPS_CONTENTS schema
@@ -105,6 +112,8 @@ my_target_name:
                                            to the current target for this named eda command.
     defines:                         <---- optional table, defines to be applied to the current
                                            target for this named eda command.
+    parameters:                      <---- optional table, parameters to be applied to the current
+                                           target to for this named eda command.
     incdirs:                         <---- optional array (or string) incdirs to be applied to
                                            the current target for this named eda command.
   tags:                              <---- tags, optional table using TARGET_TAGS_TABLE schema.
@@ -204,6 +213,9 @@ TARGET_EDA_COMMAND_ENTRY_TABLE = {
     Optional('defines'): {
         Optional(str): Or(str, int, type(None)),
     },
+    Optional('parameters'): {
+        Optional(str): Or(str, int),
+    },
     Optional('incdirs'): ARRAY_OR_SPACE_SEPARATED_STRING,
 }
 
@@ -226,6 +238,9 @@ TARGET_TAGS_TABLE = {
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        Optional('parameters'): {
+            Optional(str): Or(str, int),
+        },
         Optional('incdirs'): ARRAY_OR_SPACE_SEPARATED_STRING,
         Optional('replace-config-tools'): dict,
         Optional('additive-config-tools'): dict,
@@ -244,6 +259,10 @@ TARGET_CONTENTS = Or(
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        # parameters: table of key-value
+        Optional('parameters'): {
+            Optional(str): Or(str, int),
+        },
         # incdirs: array
         Optional('incdirs'): ARRAY_OR_SPACE_SEPARATED_STRING,
         # top: string
@@ -302,6 +321,9 @@ FILE_SIMPLIFIED = Schema(
                     Optional('defines'): {
                         Optional(str): Or(type(None), str),
                     },
+                    Optional('parameters'): {
+                        Optional(str): str,
+                    },
                     Optional('incdirs'): [str],
                     Optional('top'): str,
                     Optional('deps'): [str],

opencos/eda.py

@@ -49,6 +49,9 @@ def init_config(
 
     # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
     # the actual class using importlib (via opencos.util)
+
+    eda_config.tool_try_add_to_path(tool)
+
     config['command_handler'] = {}
     for _cmd, str_class in config['DEFAULT_HANDLERS'].items():
         cls = util.import_class_from_string(str_class)
@@ -329,7 +332,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
     config['tools_loaded'].add(tool)
 
 
-def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-many-locals
+def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-many-locals,too-many-return-statements
         tokens: list, original_args: list, config: dict, is_interactive=False
 ) -> int:
     '''Returns bash/sh style return code int (0 pass, non-zero fail).
@@ -416,6 +419,15 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
         return 2
 
     sco = config['command_handler'][command](config=config) # sub command object
+    if not parsed.tool:
+        # then what was the auto selected tool?
+        sco_tool = getattr(sco, '_TOOL', '')
+        if sco_tool in config['auto_tools_order'][0] and \
+           config['auto_tools_order'][0][sco_tool].get('disable-auto', False):
+            util.error(f'Cannot use tool={sco_tool} without arg --tool, it cannot be selected',
+                       'automatically')
+            return status_constants.EDA_COMMAND_OR_ARGS_ERROR
+
     util.debug(f'{command=}')
     util.debug(f'{sco.config=}')
     util.debug(f'{type(sco)=}')

opencos/eda_base.py

@@ -831,7 +831,33 @@ class Command: # pylint: disable=too-many-public-methods
                 lines.append(indent_me(f"  --{k:20} : string     : {vstr:12}{khelp}"))
             else:
                 lines.append(indent_me(f"  --{k:20} : <unknown>  : {vstr:12}{khelp}"))
+
+        lines.append('')
+        lines.append(indent_me((
+            "  -G<parameterName>=<value>      "
+            " Add parameter to top level, support bit/int/string types only."
+            " Example: -GDEPTH=8 (DEPTH treated as SV int/integer)."
+            " -GENABLE=1 (ENABLED treated as SV bit/int/integer)."
+            " -GName=eda (Name treated as SV string \"eda\")."
+        )))
+        lines.append(indent_me((
+            "  +define+<defineName>           "
+            " Add define w/out value to tool ahead of SV sources"
+            " Example: +define+SIM_SPEEDUP"
+        )))
+        lines.append(indent_me((
+            "  +define+<defineName>=<value>   "
+            " Add define w/ value to tool ahead of SV sources"
+            " Example: +define+TECH_LIB=2 +define+FULL_NAME=\"E D A\""
+        )))
+        lines.append(indent_me((
+            "  +incdir+<path>                 "
+            " Add path (absolute or relative) for include directories"
+            " for SystemVerilog `include \"<some-file>.svh\""
+            " Example: +incdir+../lib"
+        )))
         lines.append('')
+
         for line in lines:
             print(line)
 
@@ -922,6 +948,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             ),
         })
         self.defines = {}
+        self.parameters = {}
         self.incdirs = []
         self.files = {}
         self.files_v = []
@@ -1086,10 +1113,72 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # TODO(drew): Use the helper method in util for this instead to peek in file contents?
         return os.path.splitext(os.path.basename(name))[0]
 
+    def set_parameter(
+            self, name: str, value, caller_info: str = '(CLI)',
+            wrap_str_double_quotes: bool = True
+    ) -> None:
+        '''Safe wrapper for setting a parameter (can only set once, from CLI or DEPS)'''
+
+        if name in self.parameters:
+            util.debug("Parameter not set because it is already modified",
+                       f"(via -G<Name>=<Value>): {name}={value}; orig value",
+                       f'{self.parameters[name]} from {caller_info}')
+        else:
+            if isinstance(value, bool):
+                value = int(value)
+            elif isinstance(value, str):
+                value = strip_outer_quotes(value.strip('\n'))
+                if wrap_str_double_quotes:
+                    value = '"' + value + '"'
+            self.parameters[name] = value
+            util.debug(f"Parameter (via -G<Name>=<Value>): {name}={value}",
+                       f'from {caller_info}')
+
+
+    def process_parameter_arg(
+            self, text: str, pwd: str = os.getcwd()
+    ) -> None:
+        '''Retuns None, parses -G<Name>=<Value> adds to internal self.parameters.'''
+
+        # Deal with raw CLI/bash/powershell argparser, strip all outer quotes.
+        text = strip_outer_quotes(text)
+        if not pwd:
+            pwd = ''
+
+        if not text.startswith('-G'):
+            self.error(f"Didn't understand -G parameter arg: '{text}'",
+                       error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+            return
+
+        text = text[2:] # strip leading -G
+        m = re.match(r'^(\w+)$', text)
+        if m:
+            k = m.group(1)
+            util.warning(f"Parameter {k} has no value and will not be applied")
+            return
+        m = re.match(r'^(\w+)\=(\S+)$', text)
+        if not m:
+            m = re.match(r'^(\w+)\=(\"[^\"]*\")$', text)
+        if m:
+            k = m.group(1)
+            v = m.group(2)
+            # since this is coming from a CLI string, we have to guess at types,
+            # for int or bool (not str) and convert bool to int:
+            if not isinstance(v, (int, str)):
+                self.error(f"Didn't understand -G parameter arg: name={k} value={v}",
+                           f"value must be int/str type, from: '{text}'",
+                           error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+                return
+            try:
+                v = int(v)
+            except ValueError:
+                pass
+            self.set_parameter(k, v)
+
 
     def process_plusarg( # pylint: disable=too-many-branches
             self, plusarg: str, pwd: str = os.getcwd()
-    ) -> None:
+    ) -> str:
         '''Retuns str, parses a +define+, +incdir+, +key=value str; adds to internal.
 
         Adds to self.defines, self.incdirs,
@@ -1112,7 +1201,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 k = m.group(1)
                 self.defines[k] = None
                 util.debug(f"Defined {k}")
-                return None
+                return ''
             m = re.match(r'^(\w+)\=(\S+)$', plusarg)
             if not m:
                 m = re.match(r'^(\w+)\=(\"[^\"]*\")$', plusarg)
@@ -1126,10 +1215,10 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                         v = v.replace('%SEED%', str(self.args.get('seed', 1)))
                 self.defines[k] = v
                 util.debug(f"Defined {k}={v}")
-                return None
+                return ''
             self.error(f"Didn't understand +define+: '{plusarg}'",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
-            return None
+            return ''
 
         if plusarg.startswith('+incdir+'):
             plusarg = plusarg[len('+incdir+'):]
@@ -1139,16 +1228,16 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 if incdir not in self.incdirs:
                     self.incdirs.append(os.path.abspath(incdir))
                     util.debug(f"Added include dir '{os.path.abspath(incdir)}'")
-                return None
+                return ''
             self.error(f"Didn't understand +incdir+: '{plusarg}'",
                        error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
-            return None
+            return ''
 
         # remaining plusargs as stored in self.args['unprocessed-plusargs'] (list)
         if plusarg.startswith('+'):
             if not self.config.get('bare_plusarg_supported', False):
                 self.error(f"bare plusarg(s) are not supported: {plusarg}'")
-                return None
+                return ''
             if plusarg not in self.args['unprocessed-plusargs']:
                 self.args['unprocessed-plusargs'].append(plusarg)
                 # For anything added to unprocessed-plusarg, we have to return it, to let
@@ -1157,7 +1246,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         self.error(f"Didn't understand +plusarg: '{plusarg}'",
                    error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
-        return None
+        return ''
 
 
     def append_shell_commands(self, cmds : list) -> None:
@@ -1439,8 +1528,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         unparsed = Command.process_tokens(self, tokens, process_all=False, pwd=pwd)
         util.debug(f'CommandDesign - after Command.process_tokens(..) {unparsed=}')
 
-        # deal with +define+ or +incdir+, consume it and remove from unparsed
-        # walk the list, remove all items after we're done.
+        # deal with +define+, +incdir+, +(plusargName)+, or -GParameterName=Value:
+        # consume it and remove from unparsed, walk the list, remove all items after we're done.
         remove_list = []
         for token in unparsed:
             # Since this is a raw argparser, we may have args that come from shlex.quote(token),
@@ -1454,6 +1543,15 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 plusarg = strip_outer_quotes(token)
                 self.process_plusarg(plusarg, pwd=pwd)
                 remove_list.append(token)
+                continue
+
+            # Parameters in -G<word>=<something>
+            m = re.match(r"^\'?\-G\w+\=.+", token)
+            if m:
+                # Copy and strip all outer ' or " on the text:
+                param = strip_outer_quotes(token)
+                self.process_parameter_arg(param, pwd=pwd)
+                remove_list.append(token)
 
         for x in remove_list:
             unparsed.remove(x)

opencos/eda_config.py

@@ -47,7 +47,7 @@ class Defaults:
         'exe', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
         'requires_vsim_helper', 'requires_vscode_extension',
-        'disable-tools-multi',
+        'disable-tools-multi', 'disable-auto',
     ])
     supported_config_tool_keys = set([
         'defines',
@@ -158,6 +158,9 @@ def update_config_auto_tool_order_for_tool(tool: str, config: dict) -> str:
 
     user_exe = shutil.which(user_exe)
 
+    # try adding to $PATH if in form --tool=/path/to/exe
+    tool_try_add_to_path(tool)
+
     if tool not in config['auto_tools_order'][0]:
         return tool
     if not user_exe:
@@ -305,7 +308,8 @@ def write_eda_config_and_args(
     fullpath = os.path.join(dirpath, filename)
     data = {}
     for x in ['command_name', 'config', 'target', 'args', 'modified_args', 'defines',
-              'incdirs', 'files_v', 'files_sv', 'files_vhd']:
+              'incdirs', 'files_v', 'files_sv', 'files_vhd', 'files_cpp', 'files_sdc',
+              'files_non_source']:
         # Use deep copy b/c otherwise these are references to opencos.eda.
         data[x] = copy.deepcopy(getattr(command_obj_ref, x, ''))
 
@@ -321,3 +325,34 @@ def write_eda_config_and_args(
             data['config'][k] = str(v)
 
     yaml_safe_writer(data=data, filepath=fullpath)
+
+
+def tool_try_add_to_path(tool: str) -> None:
+    '''Since we support --tool=<name>=/path/to/bin/exe, attempt to prepend $PATH
+
+    with this information for this tool (which will nicely affect all subprocesses,
+    but not wreck our original shell).'''
+
+    if not tool or '=' not in tool:
+        return
+
+    name, exe = tool.split('=')
+    if os.path.isdir(name):
+        # Someone passes us --tool=<name>=/path/to/bin/ (did not have exe)
+        path = name
+    else:
+        # Someone passes us --tool=<name>=/path/to/bin/exe, remove the exe.
+        path, _ = os.path.split(exe)
+    if not path:
+        return
+
+    path = os.path.abspath(path)
+    if os.path.isdir(path):
+        paths = os.environ['PATH'].split(':')
+        if path not in paths:
+            os.environ['PATH'] = path + ':' + os.environ['PATH']
+            util.info(f'--tool={tool} has path information, prepending PATH with: {path}')
+        else:
+            util.info(f'--tool={tool} has path information, but {path} already in $PATH')
+    if exe and os.path.isfile(exe):
+        util.info(f'--tool={tool} has path information, using exe {shutil.which(exe)}')

opencos/eda_config_defaults.yml

@@ -516,6 +516,7 @@ auto_tools_order:
         sim:  opencos.tools.iverilog.CommandSimIverilog
 
     cocotb:
+      disable-auto: True # do not allow this to run `eda sim` with --tool not set
       exe: python
       requires_cmd:
         - python -c "import cocotb; print(cocotb.__version__)"

opencos/export_helper.py

@@ -286,7 +286,11 @@ def get_list_sv_included_files(
         # If we have more than N levels of `include hunting, then rethink this.
         # For example, some codebases would do their file dependencies as `include
         # as part of their header guards, which could be ~100 levels of nesting.
-        for fname,traversed in sv_included_files_dict.items():
+
+        # make a copy of keys so we don't alter during traversal of the dict:
+        fnames = list(sv_included_files_dict.keys())
+        for fname in fnames:
+            traversed = sv_included_files_dict[fname]
             if not traversed:
                 included_files_list = find_sv_included_files_within_file(
                     filename=fname,
@@ -387,6 +391,13 @@ class ExportHelper:
         paths.
         '''
 
+        # We'll copy files_sv and files_v later, along with discovered included files,
+        # need to copy any others:
+        remaing_files_to_cp = []
+        for x in self.cmd_design_obj.files.keys():
+            if x not in self.cmd_design_obj.files_v + self.cmd_design_obj.files_sv:
+                remaing_files_to_cp.append(x)
+
         # Also sets our list of included files.
         self.included_files = get_list_sv_included_files(
             all_src_files=self.cmd_design_obj.files_sv + self.cmd_design_obj.files_v,
@@ -398,7 +409,8 @@ class ExportHelper:
 
         info(f"export_helper: {self.target=} included files {self.included_files=}")
 
-        for filename in self.cmd_design_obj.files_non_source:
+
+        for filename in remaing_files_to_cp:
             dst = os.path.join(self.out_dir, os.path.split(filename)[1])
             if not os.path.exists(dst):
                 shutil.copy(src=filename, dst=dst)
@@ -415,11 +427,13 @@ class ExportHelper:
 
         info(f'export_helper: Creating DEPS.yml for {self.target=} in {self.out_dir=}')
 
-        # Need to strip path information from our files_sv and files_v:
+        # Need to strip path information from our files_sv and files_v
+        # (and all source files: cpp, sdc, etc; but skip the non-source files):
         deps_files = []
-        for fullpath in self.cmd_design_obj.files_sv + self.cmd_design_obj.files_v:
-            filename = os.path.split(fullpath)[1]
-            deps_files.append(filename)
+        for fullpath in self.cmd_design_obj.files.keys():
+            if fullpath not in self.cmd_design_obj.files_non_source:
+                filename = os.path.split(fullpath)[1]
+                deps_files.append(filename)
 
 
         data = {

opencos/hw/oc_cli.py

@@ -2508,7 +2508,7 @@ name_tables = { 'OC_VENDOR' : {},
                }
 
 def parse_names():
-    name_tables.update(opencos_names.table) #update our global name_table from names.py
+    name_tables.update(opencos_names.NAMES) #update our global name_table from names.py
 
 def lookup_table_string(table, index):
     if isinstance(table, str) and table in name_tables:

opencos/names.py

@@ -13,11 +13,12 @@ just needs to set a couple of these statically.
 all values in this file are in hex.
 '''
 
-table = {
+NAMES = {
 
     'OC_VENDOR': {
         0: "None",
         1: "Xilinx",
+        2: "Altera",
     },
 
     'OC_BOARD': {
@@ -28,11 +29,13 @@ table = {
         4: "U55N",
         5: "U50C",
         6: "PYNQ-Z2",
+        7: "AG3C_DEVKIT",
     },
 
     'OC_LIBRARY': {
         0: "None",
         1: "Ultrascale+",
+        2: "Agilex3"
     },
 
     'PLL_TYPES': {