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

opencos/commands/flist.py

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

opencos/commands/multi.py

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

opencos/commands/sim.py

@@ -12,15 +12,34 @@ Note that CommandSim is also a base class for opencos.commands.elab.CommandElab.
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 
 import os
+import shlex
+
+from pathlib import Path
 
 from opencos import util, export_helper
 from opencos.eda_base import CommandDesign, Tool
 from opencos.utils import status_constants
 
-from opencos.utils.str_helpers import sanitize_defines_for_sh, strip_outer_quotes
+from opencos.utils.str_helpers import strip_outer_quotes
+
+def parameters_dict_get_command_list(
+        params: dict, arg_prefix: str = '-G',
+        hier_delimiter: str = '.',
+        top_hier_str: str = '',
+        for_flist: bool = False
+) -> list:
+    '''Given dict of parameters, returns a command list.
+
+    Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+    so to avoid that and only set top level parameters, but still allow package or
+    hierarchy parameters to be set, you can use:
 
-def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> list:
-    '''Given dict of parameters, returns a command list'''
+    hier_delimiter='/'
+    top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+    Which will, if a parameter Name does not contain the heir delimiter, the Name
+    will be prepended with top_hier_str.
+    '''
 
     ret_list = []
     if ' ' in arg_prefix:
@@ -34,13 +53,29 @@ def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> li
         if not isinstance(v, (int, str)):
             util.warning(f'parameter {k} has value: {v}, parameters must be int/string types')
 
+        if top_hier_str and hier_delimiter not in k:
+            k = f'{top_hier_str}{k}'
+
         ret_list.extend(arg_list_prefix)
         if isinstance(v, int):
             ret_list.append(f'{arg_str_prefix}{k}={v}')
         else: # string
+            # Note if for_flist=True, then we have to take extra care on what gets
+            # double-quotes " and \".
             v = strip_outer_quotes(v.strip('\n'))
             v = '"' + v + '"'
-            ret_list.append(f'{arg_str_prefix}{k}={sanitize_defines_for_sh(v)}')
+
+            if for_flist:
+                # do not wrap with " unless there are spaces, if there are spaces
+                # wrap the entire thing with single quotes (bash)
+                if ' ' in v:
+                    ret_list.append(shlex.quote(f'{arg_str_prefix}{k}={v}'))
+                else:
+                    ret_list.append(f'{arg_str_prefix}{k}={v}')
+            else:
+                # This is for a tool, so simply guard single quotes:
+                v = v.replace("'", "\\" + "'")
+                ret_list.append(f'{arg_str_prefix}{k}={v}')
     return ret_list
 
 
@@ -51,6 +86,7 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
     error_on_no_files_or_targets = True
     error_on_missing_top = True
     tool_config = {} # Children with Tool parent classes will set on Tool constructor.
+    library_map_supported = False
 
     command_name = 'sim'
 
@@ -79,6 +115,10 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             # not used by other simulators, so these can go in DEPS files for custom things
             # like -CFLAGS -O0, etc.
             'verilate-args': [],
+            'ext-defines-sv-fname': '',
+            'license-queue': False,
+            'library-map': [],
+            'add-top-library': [],
         })
         self.args_help.update({
             'pre-sim-tcl': (
@@ -124,6 +164,26 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             'uvm-version': (
                 'Used if --uvm is set, for example --uvm-version=1.2'
             ),
+            'ext-defines-sv-fname': (
+                'If set to empty str, --ext-defines-sv-fname="", applies defines to tool via args.'
+                ' If set to non-emtpy str as a .sv file name, such as'
+                ' --ext-defines-sv-fname=_ext_defines.sv, saves defines to a file name in the'
+                ' work-dif, and adds this file to the SV/Verilog file list ahead of other files.'
+            ),
+            'license-queue': (
+                'Set to enable env vars LICENSE_QUEUE=1 which has effects on certain simulators'
+            ),
+            'library-map': (
+                'list arg (can set multiple) with values LibName:Path, only supported'
+                ' by certain simulation tools.'
+                ' The Path search is relative to the tool exe, one level above the tool exe,'
+                ' or can be absolute path.'
+            ),
+            'add-top-library': (
+                'Add additional top levels, for example if you added the "unisim" library'
+                ' you may need to --add-top-library=unisim.glbl for it to work with Xilinx'
+                ' based projects that require "glbl" to be present at simulation $root scope.'
+            ),
 
         })
 
@@ -131,11 +191,29 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             'uvm-version': { 'choices': ['1.2'] },
         })
 
+        # only used if self.library_map_supported=True:
+        self.library_map = {} # lib-name: path-to.lib dict from self.args['library-map']
+
 
 
-    def process_parameters_get_list(self, arg_prefix: str = '-G') -> list:
-        '''Returns list (suitable command list for shell or for tool) from self.parameters'''
-        return parameters_dict_get_command_list(params=self.parameters, arg_prefix=arg_prefix)
+    def process_parameters_get_list(
+            self, arg_prefix: str = '-G', **kwargs
+    ) -> list:
+        '''Returns list (suitable command list for shell or for tool) from self.parameters
+
+        Some simulators will set ALL parameters with Name=Value at all levels of hierarchy,
+        so to avoid that and only set top level parameters, but still allow package or
+        hierarchy parameters to be set, you can use args (in kwargs):
+
+        hier_delimiter='/'
+        top_hier_str=f'/{TOP_MODULE_NAME}/'
+
+        Which will, if a parameter Name does not contain the heir delimiter, the Name
+        will be prepended with top_hier_str.
+        '''
+        return parameters_dict_get_command_list(
+            params=self.parameters, arg_prefix=arg_prefix, **kwargs
+        )
 
     def process_plusarg(self, plusarg: str, pwd: str = os.getcwd()) -> None:
         '''Override for CommandDesign.process_plusarg(..)'''
@@ -159,6 +237,8 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         if self.stop_process_tokens_before_do_it():
             return unparsed
 
+        self.handle_arg_license_queue()
+
         # add defines for this job type
         if self.args['lint'] or self.args['stop-after-elaborate']:
             self.args['lint'] = True
@@ -364,7 +444,7 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             cmds2 = self.get_simulate_command_lists()
             cmds3 = self.get_post_simulate_command_lists()
         '''
-        return
+        self.update_library_map()
 
 
     def check_logs_for_errors( # pylint: disable=dangerous-default-value,too-many-locals,too-many-branches
@@ -572,3 +652,107 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
             search_paths=self.args['work-dir'], file_extension='vcd',
             typ='waveform', description='Simulation Waveform VCD (Value Change Dump) file'
         )
+
+
+    def create_ext_defines_sv(self) -> None:
+        '''Creates _ext_defines.sv in the work-dir, adds to front of self.files_sv'''
+
+        if not self.defines:
+            return
+
+        if not self.args['ext-defines-sv-fname']:
+            return
+
+        fpath = os.path.join(self.args['work-dir'], self.args['ext-defines-sv-fname'])
+        fpath_abs = os.path.abspath(fpath)
+        if fpath_abs in self.files:
+            util.warning(f'{fpath} already exists, will overwrite. Consider changing the value',
+                         f'of arg: --ext-defines-sv-fname={self.args["ext-defines-sv-fname"]}')
+        if not fpath.endswith('.sv') and not fpath.endswith('.v'):
+            util.error(f'--ext-defines-sv-fname={self.args["ext-defines-sv-fname"]} must end with',
+                       '.v or .sv')
+            return
+
+        ifdef_guard = os.path.split(self.args['ext-defines-sv-fname'])[1].upper()
+        ifdef_guard = ifdef_guard.replace('.', '__').replace('/', '__')
+        with open(fpath, 'w', encoding='utf-8') as f:
+            f.write(f'`ifndef {ifdef_guard}\n')
+            f.write(f'`define {ifdef_guard}\n')
+            f.write('\n')
+            for key, value in self.defines.items():
+                if value is None:
+                    f.write(f'`define {key}\n')
+                else:
+                    # if the value v is a double-quoted string, such as v='"hi"' that needs
+                    # to be preserved.
+                    f.write(f'`define {key} {value}\n')
+
+            f.write('\n')
+            f.write(f'`endif // {ifdef_guard}\n')
+
+        self.files_sv.insert(0, fpath_abs)
+        self.files[fpath_abs] = True
+        self.files_caller_info[fpath_abs] = (
+            'opencos.commands.sim::CommandSim::create_ext_defines_sv'
+        )
+        util.info(f'command "sim": {fpath} created for defines: {list(self.defines.keys())}')
+
+
+    def handle_arg_license_queue(self) -> None:
+        '''Handles self.args['license-queue'] (bool) to set env vars'''
+        if not self.args['license-queue']:
+            return
+
+        if 'LICENSE_QUEUE' not in os.environ:
+            os.environ['LICENSE_QUEUE'] = '1'
+
+    def update_library_map(self, base_search_paths: list | None = None) -> None:
+        '''
+        Returns None, uses self.args['library-map'] to update:
+
+        - self.library_map (dict)
+        - self.args['sim-library']
+        '''
+        if not self.args['library-map']:
+            return
+
+        if not self.library_map_supported:
+            tool = self.config.get('tool', None)
+            util.warning(f'Command: sim, --tool={tool}, args for --library-map are not supported:',
+                         f'{self.args["library-map"]}')
+            return
+
+        for libmap in self.args['library-map']:
+            parts = libmap.split(':')
+            lib_name = parts[0]
+            lib_path = Path(':'.join(parts[1:]))
+            lib_abs_path = None
+
+            if not lib_name or not lib_path:
+                util.warning(f'library-map={libmap} could not parse {lib_name=} or {lib_path=}')
+                continue
+
+            if lib_name in self.library_map:
+                util.warning(
+                    f'We have already mapped "{lib_name}" to {self.library_map[lib_name]}'
+                )
+
+            # We have to go looking for lib_path though
+            search_files = [lib_path]
+            if base_search_paths and isinstance(base_search_paths, list):
+                for x in base_search_paths:
+                    search_files.append(Path(x) / lib_path)
+            for x in search_files:
+                if x.exists():
+                    lib_abs_path = x.resolve()
+                    util.info(f'library-map={libmap} found "{lib_name}" in: {lib_abs_path}')
+                    break
+                util.debug(f'library-map={libmap} searching for "{lib_name}" in: {x}')
+
+
+            if lib_abs_path:
+                self.library_map[lib_name] = lib_abs_path
+                if lib_name not in self.args['sim-library']:
+                    self.args['sim-library'].append(lib_name)
+            else:
+                util.warning(f'library-map={libmap}, for "{lib_name}" could not find {lib_path=}')

opencos/deps/deps_file.py

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

opencos/deps_schema.py

@@ -336,10 +336,10 @@ FILE_SIMPLIFIED = Schema(
                 {
                     Optional('args'): [str],
                     Optional('defines'): {
-                        Optional(str): Or(type(None), str),
+                        Optional(str): Or(type(None), int, str),
                     },
                     Optional('plusargs'): {
-                        Optional(str): Or(type(None), str),
+                        Optional(str): Or(type(None), int, str),
                     },
                     Optional('parameters'): {
                         Optional(str): str,