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

opencos/commands/sim.py

@@ -44,7 +44,7 @@ def parameters_dict_get_command_list(params: dict, arg_prefix: str = '-G') -> li
     return ret_list
 
 
-class CommandSim(CommandDesign):
+class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
     '''Base class command handler for: eda sim ...'''
 
     CHECK_REQUIRES = [Tool] # Used by check_command_handler_cls()
@@ -72,6 +72,9 @@ class CommandSim(CommandDesign):
             'optimize': False,
             'log-bad-strings': ['ERROR: ', 'FATAL: ', 'Error: ', 'Fatal: '],
             'log-must-strings': [],
+            'log-warning-strings': ['WARNING: ', 'Warning: '],
+            'uvm': False,
+            'uvm-version': '1.2',
             # verilate-args: list of args you can only pass to Verilator,
             # not used by other simulators, so these can go in DEPS files for custom things
             # like -CFLAGS -O0, etc.
@@ -91,6 +94,8 @@ class CommandSim(CommandDesign):
             'log-must-strings': ('strings that are required by the log to not-fail the simulation.'
                                  ' Some tools use these at only certain phases'
                                  ' (compile/elab/sim).'),
+            'log-warning-strings': ('strings that if present will be counted in the total tool'
+                                    ' warnings at end of simulation'),
             'pass-pattern': ('Additional string required to pass a simulation, appends to'
                              ' log-must-strings'),
             'sim-args':      'args added to final "simulation" step',
@@ -111,12 +116,22 @@ class CommandSim(CommandDesign):
             'waves': 'Include waveforms, if possible for tool',
             'waves-start': 'Starting time of waveform capture, if possible for tool',
             'test-mode': ('stops the command early without executing, if --gui is present will'
-                          ' instead test without spawning gui')
+                          ' instead test without spawning gui'),
+            'uvm': (
+                'Attempts to support UVM (aka 1.2 if --uvm-version=1.2) for the'
+                ' the simulation tool. May add libraries for uvm, tool dependent.'
+            ),
+            'uvm-version': (
+                'Used if --uvm is set, for example --uvm-version=1.2'
+            ),
+
+        })
 
+        self.args_kwargs.update({
+            'uvm-version': { 'choices': ['1.2'] },
         })
 
 
-        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'''
@@ -182,14 +197,14 @@ class CommandSim(CommandDesign):
 
         # Collect (overwrite CommandSim) the bad and must strings, if present,
         # from our config.tools.verilator:
-        for tool_config_key in ['log-bad-strings', 'log-must-strings']:
+        for tool_config_key in ('log-bad-strings', 'log-must-strings', 'log-warning-strings'):
             if len(self.tool_config.get(tool_config_key, [])) > 0:
                 self.args[tool_config_key] = self.tool_config.get(tool_config_key, [])
 
 
     # Methods that derived classes may override:
 
-    def run_commands_check_logs( # pylint: disable=dangerous-default-value
+    def run_commands_check_logs( # pylint: disable=dangerous-default-value,too-many-locals
             self, commands: list , check_logs: bool = True, log_filename=None,
             bad_strings: list = [],
             must_strings: list = [],
@@ -197,7 +212,10 @@ class CommandSim(CommandDesign):
     ) -> None:
         '''Returns None, runs all commands (each element is a list) and checks logs
 
-        for bad-strings and must-strings (args or class member vars)
+        for bad-strings and must-strings (args or class member vars).
+
+        Will add any bad_strings or tool log-warning-strings to self, so tool
+        related warning/error counts can be reported later.
         '''
 
         for obj in commands:
@@ -212,7 +230,7 @@ class CommandSim(CommandDesign):
             if not work_dir:
                 work_dir = self.args['work-dir']
 
-            util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}')
+            util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}, {log_filename=}')
 
             log_fname = None
             if tee_fpath:
@@ -220,11 +238,18 @@ class CommandSim(CommandDesign):
             if log_filename:
                 log_fname = log_filename
 
-
-            _, stdout, _ = self.exec(
-                work_dir=work_dir, command_list=clist, tee_fpath=tee_fpath
+            # track the retcode because we run stop_on_error=False (to count warnings/errors)
+            _, stdout, retcode = self.exec(
+                work_dir=work_dir, command_list=clist, tee_fpath=tee_fpath,
+                stop_on_error=False,
             )
 
+            if check_logs and not log_fname and bad_strings:
+                util.warning(
+                    f'{self.get_info_job_name()}: check_logs=True but no log file set',
+                    f'(run --debug for more info), for command: {" ".join(clist)}'
+                )
+
             if check_logs and log_fname:
                 # Note this call will check on stdout if not GUI, not opening the log_fname,
                 # but if this is GUI we normally lose stdout and have to open the log.
@@ -234,6 +259,7 @@ class CommandSim(CommandDesign):
                     file_contents_str = stdout
 
                 self.check_logs_for_errors(
+                    sim_retcode=retcode,
                     filename=os.path.join(work_dir, log_fname),
                     file_contents_str=file_contents_str,
                     bad_strings=bad_strings, must_strings=must_strings,
@@ -244,6 +270,10 @@ class CommandSim(CommandDesign):
                     name=os.path.join(work_dir, log_fname),
                     typ='text', description='Simulator stdout/stderr log file'
                 )
+            if retcode:
+                self.error(
+                    f"{self.get_info_job_name()}: exec returned with error code: {retcode}"
+                )
 
     def do_export(self) -> None:
         '''CommandSim helper for handling args --export*
@@ -337,9 +367,13 @@ class CommandSim(CommandDesign):
         '''
         return
 
+
     def check_logs_for_errors( # pylint: disable=dangerous-default-value,too-many-locals,too-many-branches
-            self, filename: str = '', file_contents_str: str = '',
+            self,
+            sim_retcode: int = 0,
+            filename: str = '', file_contents_str: str = '',
             bad_strings: list = [], must_strings: list = [],
+            warning_strings: list = [],
             use_bad_strings: bool = True, use_must_strings: bool = True
     ) -> None:
         '''Returns None, checks logs using args bad_strings, must_strings,
@@ -358,6 +392,8 @@ class CommandSim(CommandDesign):
         if use_must_strings:
             _must_strings = must_strings + self.args.get('log-must-strings', [])
 
+        _warning_strings = warning_strings + self.args.get('log-warning-strings', [])
+
         if self.args['pass-pattern'] != "":
             _must_strings.append(self.args['pass-pattern'])
 
@@ -389,6 +425,20 @@ class CommandSim(CommandDesign):
             self.error(f'sim.check_logs_for_errors: {log_fpath=} does not exist, and no',
                        'file_contents_str exists to check')
 
+        self.update_tool_warn_err_counts_from_log_lines(
+            log_lines=lines, bad_strings=_bad_strings, warning_strings=_warning_strings
+        )
+
+        if isinstance(self, Tool):
+            self.report_tool_warn_error_counts()
+
+        if sim_retcode > 0:
+            # We have to update artifacts first, have the caller set the error.
+            # Skip the checking for bad strings or must strings, because we've already
+            # failed, but we did the important counting of Error and Warning lines above,
+            # and reported it.
+            return
+
         if lines:
             for lineno, line in enumerate(lines):
                 if any(must_str in line for must_str in _must_strings):

opencos/eda.py

@@ -410,7 +410,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
 
     deferred_tokens = unparsed
     if not command:
-        util.error("Didn't get a command!")
+        util.error("'eda' didn't get a command, or command is invalid (run with --help to see",
+                   "valid commands)!")
         return 2
 
     sco = config['command_handler'][command](config=config) # sub command object
@@ -430,7 +431,12 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
        command not in config.get('command_determines_tool', []) and \
        command not in config.get('command_tool_is_optional', []):
         use_tool = which_tool(command, config)
-        util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        if use_tool:
+            util.info(f"--tool not specified, using default for {command=}: {use_tool}")
+        else:
+            # Not all commands have a hard requirement on tool (such as 'multi') because we
+            # haven't examined sub-commands yet.
+            util.info(f'--tool not specified, will attempt to determine tool(s) for {command=}.')
         setattr(sco, 'auto_tool_applied', True)
 
     rc = check_command_handler_cls(command_obj=sco, command=command, parsed_args=parsed)
@@ -483,12 +489,60 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
         if not isinstance(sco, cls):
             # If someone set --tool verilator for command=synth, then our 'sco' will have defaulted
             # to CommandSynth with no tool attached. If we don't have a tool set, error and return.
-            util.warning(f"{command=} is using handling class '{type(sco)}' (but missing",
-                         f"requirement {cls}, likely because we aren't using a derived class",
-                         "for a specific tool)")
-            parsed_tool = getattr(parsed_args, 'tool', '??')
-            return util.error(f"EDA {command=} for tool '{parsed_tool}' is not",
-                              f"supported (this tool '{parsed_tool}' cannot run {command=})")
+            parsed_tool =  getattr(parsed_args, 'tool', '')
+            auto_tool_entry = command_obj.config.get(
+                'auto_tools_order', [{}])[0].get(parsed_tool, {})
+            if parsed_tool and not auto_tool_entry:
+                util.warning(
+                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
+                    f"but missing requirement {cls}, likely because the tool was not loaded",
+                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                )
+                return util.error(
+                    f"EDA {command=} for tool '{parsed_tool}' cannot be run because tool",
+                    f"'{parsed_tool}' is not known to `eda`. It does not exist in the config:",
+                    "see informational message for --config-yml, and check that file's",
+                    "auto_tools_order."
+                )
+            if parsed_tool:
+                util.warning(
+                    f"{command=} for tool '{parsed_tool}' is using handling class '{type(sco)}',",
+                    f"but missing requirement {cls}, likely because the tool was not loaded",
+                    "(not in PATH) or mis-configured (such as missing a Tool based class)"
+                )
+                for k,v in auto_tool_entry.items():
+                    if k == 'exe' or k.startswith('requires_cmd'):
+                        util.warning(
+                            f"tool '{parsed_tool}' has requirements that may not have been met --",
+                            f"{k}: {v}"
+                        )
+                    if k == 'requires_vsim_helper':
+                        if found_tool := vsim_helper.found():
+                            util.warning(
+                                f"tool '{parsed_tool}' was not found, vsim appears to be for tool",
+                                f"'{found_tool}'"
+                            )
+
+                return util.error(
+                    f"EDA {command=} for tool '{parsed_tool}' is not supported (tool",
+                    f"'{parsed_tool}' cannot run {command=}). It is likely that tool",
+                    f"'{parsed_tool}' is not in PATH, or was unable to be loaded due to missing",
+                    "requirements, or missing information when checking the exe version."
+                )
+
+            # No parsed_tool.
+            util.warning(
+                f"{command=} for default tool (--tool not set) is using handling class",
+                f"'{type(sco)}', but missing requirement {cls}, likely because the tool was not",
+                "loaded (not in PATH) or mis-configured (such as missing a Tool based class)"
+            )
+            return util.error(
+                f"EDA {command=} for default tool (--tool not set) is not supported (default",
+                f"tool cannot run {command=}). It appears that no suitable default tool to run",
+                f"{command=} was automatically found, was not in PATH, or was unable to be loaded",
+                "due to missing requirements, or missing information when checking the exe version."
+            )
+
     return 0
 
 

opencos/eda_base.py

@@ -178,6 +178,10 @@ class Tool:
         # a Command object's self.args instead of the class Tool.args. Safely create it
         # if it doesn't exist:
         self._VERSION = None
+
+        self.tool_warning_count = 0
+        self.tool_error_count = 0
+
         if getattr(self, 'args', None) is None:
             self.args = {}
         if getattr(self, 'args_help', None) is None:
@@ -225,12 +229,30 @@ class Tool:
         '''Sets and returns self._VERSION'''
         return self._VERSION
 
+    def report_tool_warn_error_counts(self) -> None:
+        '''Reports info line based on self.tool_error_count and self.tool_warning_count.'''
+        tool_name = get_class_tool_name(self)
+        if not tool_name:
+            return
+
+        info_color = Colors.green
+        start = ''
+        if self.tool_error_count or self.tool_warning_count:
+            start = safe_emoji('🔶 ')
+            info_color = Colors.yellow
+        util.info(
+            f"{start}Tool - {tool_name}, total counts:",
+            f"{Colors.bold}{self.tool_warning_count} tool warnings{Colors.normal}{info_color},",
+            f"{Colors.bold}{self.tool_error_count} tool errors",
+            color=info_color
+        )
+
     def set_tool_defines(self) -> None:
         '''Derived classes may override, sets any additional defines based on tool.'''
         return
 
 
-class Command: # pylint: disable=too-many-public-methods
+class Command: # pylint: disable=too-many-public-methods,too-many-instance-attributes
     '''Base class for all: eda COMMAND
 
     The Command class should be used when you don't require files, otherwise consider
@@ -244,6 +266,8 @@ class Command: # pylint: disable=too-many-public-methods
             self.args = {}
         if getattr(self, 'args_help', None) is None:
             self.args_help = {}
+        if getattr(self, 'args_kwargs', None) is None:
+            self.args_kwargs = {}
         self.args.update({
             "keep" : False,
             "force" : False,
@@ -332,6 +356,13 @@ class Command: # pylint: disable=too-many-public-methods
         self.tool_changed_respawn = {}
 
 
+    def get_info_job_name(self) -> str:
+        '''Returns an informational string of the job name, using: command - tool - top'''
+        return ' - '.join(
+            x for x in (self.command_name, self.args.get('tool', ''),
+                        self.args.get('top', '')) if x
+        )
+
     def error(self, *args, **kwargs) -> None:
         '''Returns None, child classes can call self.error(..) instead of util.error,
 
@@ -359,7 +390,6 @@ class Command: # pylint: disable=too-many-public-methods
                     f'ERROR: [eda] ({self.command_name}) {" ".join(list(args))}',
                     file=self.errors_log_f
                 )
-
         self.status = util.error(*args, **kwargs) # error_code passed and returned via kwargs
 
     def stop_process_tokens_before_do_it(self) -> bool:
@@ -374,24 +404,28 @@ class Command: # pylint: disable=too-many-public-methods
             return True
         return False
 
-    def status_any_error(self, report=True) -> bool:
+    def status_any_error(self, report: bool = True) -> bool:
         '''Used by derived classes process_tokens() to know an error was reached
-        and to not perform the command. Necessary for pytests that use eda.main()'''
-        if report and self.status > 0:
+        and to not perform the command. Necessary for pytests that use eda.main()
+
+        Note we also check any parent Tool class for tool_error_count > 0
+        '''
+        any_err = False
+        if self.status > 0:
+            any_err = True
+        elif isinstance(self, Tool) and getattr(self, 'tool_error_count', 0):
+            util.warning(f'eda_base.py internal: Command status={self.status}, but',
+                         f'Tool tool_error_count={getattr(self, "tool_error_count", 0)}')
+            any_err = True
+        if report and any_err:
             util.error(f"command '{self.command_name}' has previous errors")
-        return self.status > 0
+        return any_err
 
     def report_pass_fail(self) -> None:
         '''Reports an INFO line with pass/fail information'''
-        job_name = ' - '.join(
-            x for x in (self.command_name, self.args.get('tool', ''),
-                        self.args.get('top', '')) if x
-        )
-        if self.status_any_error():
-            util.info(f'{safe_emoji("❌ ")}{job_name}: Errors observed.', color=Colors.red)
-        else:
-            util.info(f'{safe_emoji("✅ ")}{job_name}: No errors observed.')
-
+        job_name = self.get_info_job_name()
+        if not self.status_any_error():
+            util.info(f'{safe_emoji("✅ ")}{job_name}: {Colors.bold}No errors observed.')
 
     def which_tool(self, command:str) -> str:
         '''Returns a str for the tool name used for the requested command'''
@@ -557,16 +591,17 @@ class Command: # pylint: disable=too-many-public-methods
         if return_code > 0:
             if return_code == 1:
                 self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE1
-            if return_code == 255:
+            elif return_code == 255:
                 self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE255
             else:
                 self.status = status_constants.EDA_EXEC_NONZERO_RETURN_CODE2
+
             if stop_on_error:
                 self.error(f"exec: returned with error (return code: {return_code})",
                            error_code=self.status)
             else:
-                util.debug(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
-                           f"{return_code})")
+                util.info(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
+                          f"{return_code})")
         else:
             util.debug(f"exec: returned without error (return code: {return_code})")
         return stderr, stdout, return_code
@@ -680,6 +715,10 @@ class Command: # pylint: disable=too-many-public-methods
                 help_kwargs = {'help': f'{type(value).__name__} default={value}'}
             help_kwargs['help'] = help_kwargs['help'].replace('%', '%%')
 
+            # Update with any self.args_kwargs for this key
+            if self.args_kwargs.get(key, {}):
+                help_kwargs.update(self.args_kwargs.get(key, {}))
+
 
             # It's important to set the default=None on these, except for list types where default
             # is []. If the parsed Namespace has values set to None or [], we do not update. This
@@ -1040,6 +1079,26 @@ class Command: # pylint: disable=too-many-public-methods
             util.warning(*msg)
 
 
+    def update_tool_warn_err_counts_from_log_lines(
+            self, log_lines: list, bad_strings: list, warning_strings: list
+    ) -> None:
+        '''Given lines (list of str) from a log, update self.tool_[error|warning]_count values
+
+        Since Tool class is not always a parent in Command/CommandDesign/CommandSim, we
+        have to modfiy these member names safely for pylint.
+
+        Derived classes may override this, especially if the Tool is known and reports
+        the complete error/warning summary counts in a certain way.
+        '''
+        if not isinstance(self, Tool):
+            return
+        for line in log_lines:
+            if any(bad_str in line for bad_str in bad_strings):
+                setattr(self, 'tool_error_count', getattr(self, 'tool_error_count', 0) + 1)
+            if any(warn_str in line for warn_str in warning_strings):
+                setattr(self, 'tool_warning_count', getattr(self, 'tool_warning_count', 0) + 1)
+
+
 class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
     '''CommandDesign is the eda base class for command handlers that need to track files.
 

opencos/eda_config.py

@@ -57,6 +57,7 @@ class Defaults:
         'defines',
         'log-bad-strings',
         'log-must-strings',
+        'log-warning-strings',
         'sim-libraries',
         'compile-args',
         'compile-waves-args',

opencos/eda_config_defaults.yml

@@ -154,6 +154,8 @@ tools:
 
   verilator:
     defines: { }
+    log-warning-strings:
+      - "%Warning"
     log-bad-strings:
       - "%Error"
       - "%Fatal"
@@ -239,8 +241,11 @@ tools:
     defines:
       OC_TOOL_RIVIERA: 1
       RIVIERA: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - "VSIM: Simulation has finished"
     compile-args: |
@@ -261,8 +266,11 @@ tools:
     defines:
       OC_ASSERT_PROPERTY_NOT_SUPPORTED: 1
       OC_TOOL_MODELSIM_ASE: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - " vsim "
       - "Errors: 0"
@@ -286,8 +294,11 @@ tools:
   questa_fse:
     defines:
       OC_TOOL_QUESTA_FSE: 1
+    log-warning-strings:
+      - "Warning: "
     log-bad-strings:
-      - "Error:"
+      - "Error: "
+      - "Fatal: "
     log-must-strings:
       - " vsim "
       - "Errors: 0"
@@ -309,6 +320,9 @@ tools:
 
 
   iverilog:
+    log-warning-strings:
+      - "Warning:"
+      - "WARNING:"
     log-bad-strings:
       - "Error:"
       - "ERROR:"
@@ -328,6 +342,9 @@ tools:
   cocotb:
     defines:
       OC_TOOL_COCOTB: null
+    log-warning-strings:
+      - "Warning:"
+      - "WARNING:"
     log-bad-strings:
       - "ERROR"
       - "FAILED"
@@ -344,6 +361,14 @@ tools:
       OC_TOOL_QUARTUS: null
 
   vivado:
+    log-warning-strings:
+      - "WARNING: "
+      - "Warning: "
+    log-bad-strings:
+      - "FATAL: "
+      - "Fatal: "
+      - "ERROR: "
+      - "Error: "
     sim-libraries:
       - xil_defaultlib
       - unisims_ver
@@ -485,7 +510,7 @@ auto_tools_order:
         lec:   opencos.tools.slang_yosys.CommandLecYosys
 
     questa:
-      exe: qrun
+      exe: vsim
       requires_vsim_helper: True
       handlers:
         lint: opencos.tools.questa.CommandLintQuesta
@@ -503,13 +528,14 @@ auto_tools_order:
         elab: opencos.tools.riviera.CommandElabRiviera
         sim:  opencos.tools.riviera.CommandSimRiviera
 
-    modelsim_ase:
+    questa_fe:
       exe: vsim
       requires_vsim_helper: True
       handlers:
-        lint: opencos.tools.modelsim_ase.CommandLintModelsimAse
-        elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
-        sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
+        lint: opencos.tools.questa_fe.CommandLintQuestaFe
+        elab: opencos.tools.questa_fe.CommandElabQuestaFe
+        sim: opencos.tools.questa_fe.CommandSimQuestaFe
+        flist: opencos.tools.questa_fe.CommandFListQuestaFe
 
     questa_fse:  # free student edition, works similar to modelsim_ase
       exe: vsim
@@ -520,6 +546,14 @@ auto_tools_order:
         sim:  opencos.tools.questa_fse.CommandSimQuestaFse
         flist: opencos.tools.questa_fse.CommandFListQuestaFse
 
+    modelsim_ase:
+      exe: vsim
+      requires_vsim_helper: True
+      handlers:
+        lint: opencos.tools.modelsim_ase.CommandLintModelsimAse
+        elab: opencos.tools.modelsim_ase.CommandElabModelsimAse
+        sim:  opencos.tools.modelsim_ase.CommandSimModelsimAse
+
     iverilog:
       exe: iverilog
       handlers: