opencos-eda 0.3.15__py3-none-any.whl → 0.3.17__py3-none-any.whl

opencos/deps/deps_processor.py

@@ -4,8 +4,11 @@ a DEPS markup files targets (applying deps, reqs, commands, tags, incdirs, defin
 CommandDesign ref object
 '''
 
+# pylint: disable=too-many-lines
+
 import argparse
 import copy
+import glob
 import os
 
 from opencos import files
@@ -418,7 +421,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 self.process_commands()
             elif key == 'reqs':
                 self.process_reqs()
-            elif key == 'deps':
+            elif key == 'deps' or \
+                 (key == 'files' and 'deps' not in self.deps_entry):
                 remaining_deps_list += self.process_deps_return_discovered_deps()
 
             if self.command_design_ref.tool_changed_respawn:
@@ -528,10 +532,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 with_args_matched_list = []
                 for k,v in with_args.items():
                     with_args_matched_list.append(False)
-                    if not apply_tag_items_tools:
+                    if not all((apply_tag_items_tools, apply_tag_items_commands)):
                         # If we didn't previously match with-tools (if with-tools was present),
-                        # then we may not match the args, b/c those are tool dependend in the
-                        # Command handling class.
+                        # or match with-commands, then we may not match the args, b/c those are
+                        # command + tool dependent in the Command handling class.
                         pass
                     elif k not in self.command_design_ref.args:
                         warning(f'{tagname=} in {self.caller_info}:',
@@ -613,7 +617,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                                                               deps_file=self.deps_file)
                         self.apply_reqs(reqs_list)
 
-                    elif key == 'deps':
+                    elif key == 'deps' or \
+                         (key == 'files' and 'deps' not in tags_dict_to_apply):
 
                         # apply deps (includes commands, stray +define+ +incdir+)
                         # treat the same way we treat self.process_deps_return_discovered_deps
@@ -861,6 +866,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         '''Returns list of deps targets to continue processing,
 
         -- iterates through 'deps' for this target (self.deps_entry['deps'])
+           -- note this will also append 'files' if that table key + list/str exists.
         -- applies to self.command_design_ref
         '''
 
@@ -872,7 +878,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         )
         return self.get_remaining_and_apply_deps(deps)
 
-    def get_remaining_and_apply_deps(self, deps:list) -> list:
+    def get_remaining_and_apply_deps(
+            self, deps: list
+    ) -> list:
         '''Given a list of deps, process what is supported in a "deps:" table in DEPS
         markup file.'''
 
@@ -880,66 +888,98 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
         # Process deps (list)
         for dep in deps:
+            deps_targets_to_resolve.extend(
+                self._get_remaining_and_apply_single_dep(dep)
+            )
+        return deps_targets_to_resolve
+
 
-            typ = type(dep)
-            if typ not in SUPPORTED_DEP_KEYS_BY_TYPE:
-                self.error(f'{self.target_node=} {dep=} in {self.deps_file=}:' \
-                           + f'has unsupported {type(dep)=} {SUPPORTED_DEP_KEYS_BY_TYPE=}')
-
-            for supported_values in SUPPORTED_DEP_KEYS_BY_TYPE.values():
-                if '*' in supported_values:
-                    continue
-                if typ in [dict,list] and any(k not in supported_values for k in dep):
-                    self.error(
-                        f'{self.target_node=} {dep=} in {self.deps_file=}: has dict-key or',
-                        f'list-item not in {SUPPORTED_DEP_KEYS_BY_TYPE[typ]=}'
-                    )
-
-            # In-line commands in the deps list, in case the results need to be in strict file
-            # order for other deps
-            if isinstance(dep, dict) and 'commands' in dep:
-
-                commands = dep['commands']
-                debug(f"Got commands {dep=} for in {self.caller_info}, {commands=}")
-
-                assert isinstance(commands, list), \
-                    f'dep commands must be a list: {dep=} in {self.caller_info}'
-
-                # For this, we need to get the returned commands (to keep strict order w/ other
-                # deps)
-                command_tuple = self.get_commands( commands=commands, dep=dep )
-                # TODO(drew): it might be cleaner to return a dict instead of list, b/c those
-                # are also ordered and we can pass type information, something like:
-                deps_targets_to_resolve.append(command_tuple)
-
-
-            elif isinstance(dep, str) and \
-                 any(dep.startswith(x) for x in ['+define+', '+incdir+']) and \
-                 self.is_command_design:
-                # Note: we still support +define+ and +incdir in the deps list.
-                # check for compile-time Verilog style plusarg, which are supported under targets
-                # These are not run-time Verilog style plusargs comsumable from within the .sv:
-                debug(f"Got plusarg (define, incdir) {dep=} for {self.caller_info}")
-                self.command_design_ref.process_plusarg(plusarg=dep, pwd=self.target_path)
+    def _get_remaining_and_apply_single_dep( # pylint: disable=too-many-branches
+            self, dep: str
+    ) -> list:
+        '''Given a single dep, process is and return targets/files that need resolving'''
 
+        deps_targets_to_resolve = []
+        typ = type(dep)
+        if typ not in SUPPORTED_DEP_KEYS_BY_TYPE:
+            self.error(f'{self.target_node=} {dep=} in {self.deps_file=}:' \
+                       + f'has unsupported {type(dep)=} {SUPPORTED_DEP_KEYS_BY_TYPE=}')
+
+        for supported_values in SUPPORTED_DEP_KEYS_BY_TYPE.values():
+            if '*' in supported_values:
+                continue
+            if typ in [dict,list] and any(k not in supported_values for k in dep):
+                self.error(
+                    f'{self.target_node=} {dep=} in {self.deps_file=}: has dict-key or',
+                    f'list-item not in {SUPPORTED_DEP_KEYS_BY_TYPE[typ]=}'
+                )
+
+        # In-line commands in the deps list, in case the results need to be in strict file
+        # order for other deps
+        if isinstance(dep, dict) and 'commands' in dep:
+
+            commands = dep['commands']
+            debug(f"Got commands {dep=} for in {self.caller_info}, {commands=}")
+
+            assert isinstance(commands, list), \
+                f'dep commands must be a list: {dep=} in {self.caller_info}'
+
+            # For this, we need to get the returned commands (to keep strict order w/ other
+            # deps)
+            command_tuple = self.get_commands( commands=commands, dep=dep )
+            # TODO(drew): it might be cleaner to return a dict instead of list, b/c those
+            # are also ordered and we can pass type information, something like:
+            deps_targets_to_resolve.append(command_tuple)
+
+
+        elif isinstance(dep, str) and \
+             any(dep.startswith(x) for x in ['+define+', '+incdir+']) and \
+             self.is_command_design:
+            # Note: we still support +define+ and +incdir in the deps list.
+            # check for compile-time Verilog style plusarg, which are supported under targets
+            # These are not run-time Verilog style plusargs comsumable from within the .sv:
+            debug(f"Got plusarg (define, incdir) {dep=} for {self.caller_info}")
+            self.command_design_ref.process_plusarg(plusarg=dep, pwd=self.target_path)
+
+        else:
+            # If we made it this far, dep better be a str type.
+            assert isinstance(dep, str), f'{dep=} {type(dep)=} must be str'
+            dep_path = self.correct_a_deps_target(target=dep, deps_dir=self.target_path)
+            debug(f"Got dep {dep_path=} for in {self.caller_info}")
+
+            if self.is_command_design and \
+               dep_path in self.command_design_ref.targets_dict or \
+               dep_path in deps_targets_to_resolve:
+                debug(f" - already processed ({dep_path}), skipping")
             else:
-                # If we made it this far, dep better be a str type.
-                assert isinstance(dep, str), f'{dep=} {type(dep)=} must be str'
-                dep_path = self.correct_a_deps_target(target=dep, deps_dir=self.target_path)
-                debug(f"Got dep {dep_path=} for in {self.caller_info}")
-
-                if self.is_command_design and \
-                   dep_path in self.command_design_ref.targets_dict or \
-                   dep_path in deps_targets_to_resolve:
-                    debug(" - already processed, skipping")
-                else:
+                # This is where we support files/deps file wildcards via glob syntax.
+                # If glob found none, we fall back to a single-file or target
+                glob_added_from_dep_path = False
+                if any(x in dep_path for x in ('*', '?', '[')):
+                    try:
+                        glob_list = glob.glob(dep_path)
+                        for fpath in glob_list:
+                            file_exists, _, _ = files.get_source_file(fpath)
+                            if file_exists:
+                                debug(f" - raw file ({fpath}), from glob ({dep_path}) adding",
+                                      "to return list...")
+                                deps_targets_to_resolve.append(fpath) # append
+                                glob_added_from_dep_path = True
+                        if glob_list and not glob_added_from_dep_path:
+                            self.error(f'No files were expanded from glob: {dep_path} in',
+                                       f'{self.caller_info}')
+                    except Exception as e:
+                        self.error(f'Unable to add files via glob {dep_path}, in',
+                                   f'{self.caller_info}exception {e}')
+
+                if not glob_added_from_dep_path:
                     file_exists, _, _ = files.get_source_file(dep_path)
                     if file_exists:
-                        debug(" - raw file, adding to return list...")
+                        debug(f" - raw file ({dep_path}), adding to return list...")
                         deps_targets_to_resolve.append(dep_path) # append, keeping file order.
                     else:
-                        debug(" - a target (not a file) needing to be resolved, adding to return",
-                              "list...")
+                        debug(f" - a target non-file ({dep_path}) needs to be resolved,",
+                              "adding to return list...")
                         deps_targets_to_resolve.append(dep_path) # append, keeping file order.
 
         # We return the list of deps or files that still need to be resolved
@@ -947,12 +987,6 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         # items in this list are either:
         #  -- string (dep or file)
         #  -- tuple (unprocessed commands, in form: (shell_commands_list, work_dir_add_srcs_list))
-        # TODO(drew): it might be cleaner to return a dict instead of list, b/c those are also
-        # ordered and we can pass type information, something like:
-        #  { dep1: 'file',
-        #    dep2: 'target',
-        #    dep3: 'command_tuple',
-        #  }
         return deps_targets_to_resolve
 
 

opencos/deps_schema.py

@@ -264,6 +264,9 @@ TARGET_TAGS_TABLE = {
 TARGET_CONTENTS = Or(
     ARRAY_OR_SPACE_SEPARATED_STRING,
     {
+        # description, info: str
+        Optional('description'): Or(str, type(None)),
+        Optional('info'): Or(str, type(None)),
         # args: array
         Optional('args'): ARRAY_OR_SPACE_SEPARATED_STRING,
         # commands: array
@@ -285,7 +288,9 @@ TARGET_CONTENTS = Or(
         # top: string
         Optional('top'): str,
         # deps: array
+        # AND/OR files: array
         Optional('deps'): TARGET_DEPS_CONTENTS,
+        Optional('files'): TARGET_DEPS_CONTENTS,
         # reqs: array
         Optional('reqs'): ARRAY_OR_SPACE_SEPARATED_STRING,
         # multi: table
@@ -334,6 +339,8 @@ FILE_SIMPLIFIED = Schema(
             Optional('METADATA'): dict,
             Optional(str): Or( # User named target contents
                 {
+                    Optional('description'): str,
+                    Optional('info'): str,
                     Optional('args'): [str],
                     Optional('defines'): {
                         Optional(str): Or(type(None), int, str),
@@ -347,6 +354,7 @@ FILE_SIMPLIFIED = Schema(
                     Optional('incdirs'): [str],
                     Optional('top'): str,
                     Optional('deps'): [str],
+                    Optional('files'): [str],
                     Optional('reqs'): [str],
                 }
             )

opencos/docs/DEPS.md

@@ -9,6 +9,9 @@ METADATA: # <table> unstructured data, any UPPERCASE first level key is not cons
 
 target-spec:
 
+  description: # <str> optional description
+  info:        # <str> optional description
+
   args: # <array or | separated str>
     - --waves
     - --sim_plusargs="+info=500"
@@ -56,6 +59,8 @@ target-spec:
                               # to compile order list.
       - peakrdl:              # <string>     ## peakrdl command to generate CSRs
 
+  files: # <Identical to "deps", will append to any deps.>
+
   reqs: # <array or | space separated string>
     - some_file.mem           # <string> aka, a non-source file required for this target.
                               # This file is checked for existence prior to invoking the tool involved, for example,
@@ -100,6 +105,7 @@ target-spec:
       args: <array or | space separated string> # args to be applied if this target is used, with a matching
                                           # tool in 'with-tools'.
       deps: <array or | space separated string, applied with tag>
+      files: <identical to deps, will append to deps>
       defines: <table, applied with tag>
       plusargs: <table, applied with tag>
       parameters: <table, applied with tag>

opencos/eda.py

@@ -20,10 +20,11 @@ from pathlib import Path
 import opencos
 from opencos import util, eda_config, eda_base
 from opencos.eda_base import Command, Tool, which_tool, print_eda_usage_line
-from opencos.eda_tool_helper import pretty_info_handler_tools
+from opencos.eda_tool_helper import DOCKER_TOOL_NOTE, pretty_info_handler_tools, \
+    tool_loaded_but_flagged_as_docker_only, get_all_handler_commands
 from opencos.files import safe_shutil_which
 from opencos.util import safe_emoji, Colors
-from opencos.utils import vsim_helper, vscode_helper
+from opencos.utils import vsim_helper, vscode_helper, docker_checks
 from opencos.utils import status_constants, str_helpers, subprocess_helpers
 
 # Configure util:
@@ -99,9 +100,17 @@ def init_config(
 def get_all_commands_help_str(config: dict) -> str:
     '''Returns a str of help based on what commands eda supports, from config'''
     all_commands_help = []
+    all_handler_commands = get_all_handler_commands(config=config)
     max_command_str_len = max(len(s) for s in config.get('DEFAULT_HANDLERS_HELP', {}).keys())
     for key, value in config.get('DEFAULT_HANDLERS_HELP', {}).items():
-        all_commands_help.append(f'    {key:<{max_command_str_len}} - {value.strip()}')
+        all_commands_help.append(
+            f'    {Colors.bcyan}{key:<{max_command_str_len}}{Colors.normal} - {value.strip()}'
+        )
+        if key in all_handler_commands:
+            all_commands_help[-1] += (
+                f'\n    {" ":<{max_command_str_len}}   '
+                f'--tool: {Colors.cyan}{", ".join(all_handler_commands[key])}{Colors.normal}'
+            )
     if all_commands_help:
         all_commands_help = [
             f'Where {Colors.byellow}COMMAND{Colors.normal} is one of:',
@@ -277,13 +286,21 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             if not exe_path:
                 exe_path = p # set on first required exe
             if not p:
-                has_all_exe = False
+                # skip the fail (has_all_exe=False) if we can run via docker.
+                if tool_cfg.get('docker_support', None):
+                    if not docker_checks.docker_ok():
+                        has_all_exe = False
+                        util.debug("... No, missing docker requirements")
+                else:
+                    has_all_exe = False
                 util.debug(f"... No, missing exe {exe}")
             for req in tool_cfg.get('requires_in_exe_path', []):
                 if p and req and str(Path(req)) not in str(Path(p)):
                     has_all_in_exe_path = False
                     util.debug(f"... No, missing path requirement {req}")
 
+
+
         has_vsim_helper = True
         if tool_cfg.get('requires_vsim_helper', False):
             # This tool name must be in opencos.utils.vsim_helper.TOOL_PATH[name].
@@ -327,6 +344,9 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
                 p = exe_path
             else:
                 p = safe_shutil_which(exe_list[0])
+            if not p and tool_cfg.get('docker_support', None) and docker_checks.docker_ok():
+                # Sets note that this tool is loaded, but only avail via docker:
+                p = DOCKER_TOOL_NOTE
             config['auto_tools_found'][name] = p # populate key-value pairs w/ first exe in list
             if name not in config['tools_loaded']:
                 config['tools_loaded'].append(name)
@@ -357,7 +377,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
             )
         return config
 
-    # If --tool was not set, look at config['auto_tools_found'] should be populated based on
+    # If --tool was not set, look at config['auto_tools_order'] should be populated based on
     # config['tools'], and if we called this method (auto_tool_setup(...)) with tool= and command=
     # arg(s). Call set_command_handlers for each command/tool we need to:
     for _command, list_of_tools in config['auto_tools_order'].items():
@@ -365,6 +385,10 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
         for _tool in list_of_tools:
             if _tool not in config['tools_loaded']:
                 continue
+            if tool_loaded_but_flagged_as_docker_only(tool=_tool, config=config):
+                # do not let this tool be the auto-handler for a command (aka, it is the
+                # chosen tool if --tool=TOOL arg not present) if it can only run via docker.
+                continue
 
             set_command_handler(
                 command=_command, tool=_tool, config=config, auto_setup=(not tool),
@@ -801,6 +825,7 @@ def main(*args):
         # And show python version:
         util.info(f'python: version {sys.version_info.major}.{sys.version_info.minor}.'
                   f'{sys.version_info.micro}')
+        util.info(f'eda from: {__file__}')
 
     # Handle --config-yml= arg
     config, unparsed = eda_config.get_eda_config(unparsed)

opencos/eda_base.py

@@ -203,7 +203,7 @@ class Tool:
         })
         # update self._EXE if config says to:
         self.set_exe(config)
-        self.get_versions()
+        self.get_versions(quiet=True)
 
         if getattr(self, 'set_tool_config_from_config', None):
             # Hook for classes like CommandSim that have a Tool derived class attached:
@@ -233,7 +233,9 @@ class Tool:
             self.get_versions()
         return str(self._TOOL) + ':' + str(self._VERSION)
 
-    def get_versions(self) -> str:
+    def get_versions( # pylint: disable=unused-argument
+            self, **kwargs
+    ) -> str:
         '''Sets and returns self._VERSION. Note that this is overriden by nearly all
 
         child Tool classes, and should limit info/warning messaging since it is part
@@ -1256,7 +1258,9 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # cached_deps: key = abspath of DEPS markup file, value is a dict with
         # keys 'data' and 'line_numbers'
         self.cached_deps = {}
-        self.targets_dict = {} # key = targets that we've already processed in DEPS files
+
+        # targets_dict: key = str(Path(target)), value is DepsFile caller_info, or path
+        self.targets_dict = {}
 
         self.has_pre_compile_dep_shell_commands = False
         self.has_post_tool_dep_shell_commands = False
@@ -1717,11 +1721,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         self.target_path, self.target = os.path.split(target)
 
-        if target in self.targets_dict:
+        if str(Path(target)) in self.targets_dict:
             # If we're encountered this target before, stop. We're not traversing again.
             return True
 
-        self.targets_dict[target] = None
+        self.targets_dict[str(Path(target))] = f'({self.target_path})'
         file_exists, fpath, forced_extension = files.get_source_file(target)
         if file_exists:
             # If the target is a file (we're at the root here processing CLI arg tokens)
@@ -1748,6 +1752,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         deps, data, deps_file = None, None, None
         found_deps_file = False
+        found_caller_info = ''
 
         if self.config['deps_markup_supported']:
             deps = DepsFile(
@@ -1763,6 +1768,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         if found_deps_file and found_target:
 
+            found_caller_info = deps.gen_caller_info(target_node)
             entry = deps.get_entry(target_node=target_node)
 
             # For convenience, use an external class for this DEPS.yml table/dict
@@ -1799,7 +1805,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                                                    caller_info=caller_info )
 
                 elif x and x not in self.targets_dict:
-                    self.targets_dict[x] = None # add it before processing.
+                    self.targets_dict[str(Path(x))] = None # add it before processing.
                     file_exists, fpath, forced_extension = files.get_source_file(x)
                     if file_exists:
                         self.add_file(filename=fpath, caller_info=caller_info,
@@ -1810,7 +1816,6 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                             x, no_recursion, caller_info=caller_info
                         )
 
-
         # Done with DEPS.yml if it existed.
 
         if not found_target:
@@ -1825,6 +1830,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 if os.path.exists(try_file):
                     self.add_file(try_file, caller_info=f'n/a::{target}::n/a')
                     found_target = True
+                    found_caller_info = os.path.split(try_file)[0]
                     break # move on to the next target
             if not found_target and error_on_not_found: # if STILL not found_this_target...
                 # allow this if --no-error-unknown-args:
@@ -1835,6 +1841,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 )
 
         # if we've found any target since being called, it means we found the one we were called for
+        if found_target:
+            self.targets_dict[str(Path(target))] = f'({found_caller_info})'
         return found_target
 
     def add_file( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
@@ -2107,10 +2115,14 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                     # (not from DEPS.yml) we need to override self.target if that was set. Otherwise
                     # it won't save to the correct work-dir:
                     self.target = self.args['top']
+                    self.targets_dict[str(Path(self.target_path) / self.target)] = (
+                        f'({os.path.split(top_path)[-1]})'
+                    )
                     self.top_details['inferred_from_last_added_source_file'] = top_path
 
-
-        util.info(f'{self.command_name}: top-most target name: {self.target}')
+        caller_info_lookup = str(Path(self.target_path) / self.target)
+        util.info(f'{self.command_name}: top-most target name: {self.target}',
+                  f'{self.targets_dict.get(caller_info_lookup, "")}')
 
         if self.error_on_missing_top and not self.args.get('top', ''):
             self.error("Did not get a --top or DEPS top, required to run command",

opencos/eda_config.py

@@ -55,7 +55,7 @@ class Defaults:
         'auto_tools_order',
     ])
     supported_config_tool_keys = set([
-        'exe', 'handlers',
+        'exe', 'docker_support', 'handlers',
         'requires_env', 'requires_py', 'requires_cmd', 'requires_in_exe_path',
         'requires_vsim_helper',
         'requires_vscode_extension',
@@ -76,6 +76,7 @@ class Defaults:
         'simulate-waivers',
         'simulate-coverage-tcl',
         'coverage-args',
+        'tcl-command-args',
     ])
 
 EDA_OUTPUT_CONFIG_FNAME = 'eda_output_config.yml'

opencos/eda_config_defaults.yml

@@ -47,7 +47,7 @@ DEFAULT_HANDLERS_HELP:
   targets:     List all possible targets given glob path.
   lec:         Run equivalence on two designs.
   deps-help:   Provide help about DEPS markup files, or schema using --verbose or --help.
-  help:        This help (without args), or i.e. "eda help sim" for specific help.
+  help:        This help (without args), or i.e. "eda sim --help [--tool=TOOL]" for specific help.
 
 
 
@@ -270,6 +270,7 @@ tools:
 
   verilator:
     exe: verilator
+    docker_support: true
     handlers:
       lint: opencos.tools.verilator.VerilatorLint
       elab: opencos.tools.verilator.VerilatorElab
@@ -682,9 +683,15 @@ tools:
     requires_cmd:
       - yosys -m slang
     handlers:
+      flist: opencos.tools.slang_yosys.CommandFListSlangYosys
       elab:  opencos.tools.slang_yosys.CommandElabSlangYosys
       synth: opencos.tools.slang_yosys.CommandSynthSlangYosys
       lec:   opencos.tools.slang_yosys.CommandLecSlangYosys
+    tcl-command-args:
+      read_slang:
+        - --ignore-unknown-modules
+        - --best-effort-hierarchy
+        - --ignore-timing
     defines:
       OC_TOOL_YOSYS: null
       OC_TOOL_SLANG: null
@@ -717,5 +724,6 @@ tools:
     requires_cmd:
       - yosys
     handlers:
+      flist: opencos.tools.slang_yosys.CommonFListYosys
       synth: opencos.tools.slang_yosys.CommonSynthYosys
       lec:   opencos.tools.slang_yosys.CommandLecYosys