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

opencos/tools/quartus.py

@@ -9,16 +9,14 @@ Used for Intel FPGA synthesis, place & route, and bitstream generation.
 import os
 import re
 import shlex
-import shutil
 import subprocess
-
 from pathlib import Path
 
-from opencos import util, eda_base
-from opencos.eda_base import Tool
-from opencos.commands import (
-    CommandSynth, CommandBuild, CommandFList, CommandProj, CommandUpload, CommandOpen
-)
+from opencos import util
+from opencos.commands import CommandSynth, CommandBuild, CommandFList, CommandProj, \
+    CommandUpload, CommandOpen
+from opencos.eda_base import Tool, get_eda_exec
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh, strip_outer_quotes
 
 class ToolQuartus(Tool):
@@ -44,50 +42,88 @@ class ToolQuartus(Tool):
             'family': 'FPGA family for Quartus (e.g., Stratix IV, Arria 10, etc.)',
         })
 
+    def _try_set_version_from_version_txt(self) -> None:
+        '''Attempts to use VSIM_PATH/../version.txt to get version info
+
+        Return None, may set self._VERSION
+        '''
+        util.debug(f"quartus path = {self.quartus_exe}")
+        version_txt_filepath = os.path.join(self.quartus_base_path, '..', 'version.txt')
+        if os.path.isfile(version_txt_filepath):
+            with open(version_txt_filepath, encoding='utf-8') as f:
+                for line in f.readlines():
+                    if line.startswith('Version='):
+                        _, version = line.strip().split('=')
+                        self._VERSION = version
+                        break
+
+    def _try_set_version_from_path(self) -> None:
+        '''Attempts to use portions of VSIM_PATH to get version info
+
+        Return None, may set self._VERSION
+        '''
+        m = re.search(r'(\d+)\.(\d+)', self.quartus_exe)
+        if m:
+            version = m.group(1) + '.' + m.group(2)
+            self._VERSION = version
+
+    def _try_set_version_from_exe(self) -> None:
+        '''Attempts to run: vsim --version; (max timeout 3 sec) to get version info
+
+        Return None, may set self._VERSION
+
+        Since this may fail if we don't have a valid license, we will not error if the version
+        is not determined.
+        '''
+        try:
+            result = subprocess.run(
+                [self.quartus_exe, '--version'],
+                capture_output=True, text=True, timeout=3, check=False
+            )
+            version_match = re.search(r'Version (\d+\.\d+)', result.stdout)
+            if version_match:
+                self._VERSION = version_match.group(1)
+            else:
+                util.debug("Could not determine Quartus version from: quartus_sh --version")
+        except (
+            subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError
+        ):
+            util.debug("Could not determine Quartus version from: quartus_sh --version")
+
+
     def get_versions(self) -> str:
         if self._VERSION:
             return self._VERSION
 
-        path = shutil.which(self._EXE)
+        path = safe_shutil_which(self._EXE)
         if not path:
             self.error("Quartus not in path, need to install or add to $PATH",
                        f"(looked for '{self._EXE}')")
         else:
             self.quartus_exe = path
             self.quartus_base_path, _ = os.path.split(path)
-        self.quartus_gui_exe = shutil.which('quartus') # vs quartus_sh
 
+        self.quartus_gui_exe = safe_shutil_which(
+            os.path.join(self.quartus_base_path, 'quartus') # vs quartus_sh
+        )
 
-
-        # Get version based on install path name or by running quartus_sh --version
-        util.debug(f"quartus path = {self.quartus_exe}")
-        m = re.search(r'(\d+)\.(\d+)', self.quartus_exe)
-        if m:
-            version = m.group(1) + '.' + m.group(2)
-            self._VERSION = version
-        else:
-            # Try to get version by running quartus_sh --version
-            try:
-                result = subprocess.run(
-                    [self.quartus_exe, '--version'],
-                    capture_output=True, text=True, timeout=10, check=False
-                )
-                version_match = re.search(r'Version (\d+\.\d+)', result.stdout)
-                if version_match:
-                    self._VERSION = version_match.group(1)
-                else:
-                    self.error("Could not determine Quartus version")
-            except (
-                subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError
-            ):
-                self.error("Could not determine Quartus version")
+        # Get version based on install path name:
+        # 1. if ../version.txt exists, use that
+        # 2. Use the path name if it has version information
+        # 3. or by running quartus_sh --version (max timeout=3)
+        # If we cannot find the version return '' and warn, do not error.
+        self._try_set_version_from_version_txt()
+        if not self._VERSION:
+            self._try_set_version_from_path()
+        if not self._VERSION:
+            self._try_set_version_from_exe()
 
         if self._VERSION:
             numbers_list = self._VERSION.split('.')
             self.quartus_year = int(numbers_list[0])
             self.quartus_release = int(numbers_list[1])
         else:
-            self.error(f"Quartus version not found, quartus path = {self.quartus_exe}")
+            util.warning(f"Quartus version not found, quartus path = {self.quartus_exe}")
         return self._VERSION
 
     def set_tool_defines(self) -> None:
@@ -151,7 +187,6 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
         self.write_tcl_file(tcl_file=tcl_file)
 
         # execute Quartus synthesis
-        command_list_gui = [self.quartus_gui_exe, '-t', tcl_file]
         command_list = [
             self.quartus_exe, '-t', tcl_file
         ]
@@ -172,11 +207,7 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
             typ='text', description='Quartus Synthesis Report'
         )
 
-        if self.args['gui'] and self.quartus_gui_exe:
-            self.exec(self.args['work-dir'], command_list_gui)
-        else:
-            self.exec(self.args['work-dir'], command_list)
-
+        self.exec(self.args['work-dir'], command_list)
 
         saved_qpf_filename = self.args["top"] + '.qpf'
         if not os.path.isfile(os.path.join(self.args['work-dir'], saved_qpf_filename)):
@@ -185,8 +216,13 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
 
         util.info(f"Synthesis done, results are in: {self.args['work-dir']}")
 
-        # Note: in GUI mode, if you ran: quaruts -t build.tcl, it will exit on completion,
-        # so we'll re-open the project.
+        # Note: in GUI mode, if we were to run:
+        #   ran: quaruts -t build.tcl
+        # it treats the tcl script as running "headless" as a pre-script, and won't open the
+        # GUI anyway, and will exit on completion,
+        # Instead we:
+        # 1. always run with quartus_sh, so text goes to stdout
+        # 2. we'll re-open the project in GUI mode, here:
         if self.args['gui'] and self.quartus_gui_exe:
             self.exec(
                 work_dir=self.args['work-dir'],
@@ -212,19 +248,22 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
         # Add source files (convert to relative paths and use forward slashes)
         # Note that default of self.args['all-sv'] is False so we should have added
         # all files to self.files_sv instead of files_v:
+        # Note that tcl uses POSIX paths, so \\ -> /
         for f in self.files_v:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name VERILOG_FILE \"{rel_path}\"")
         for f in self.files_sv:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name SYSTEMVERILOG_FILE \"{rel_path}\"")
         for f in self.files_vhd:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name VHDL_FILE \"{rel_path}\"")
 
         # Add include directories - Quartus needs the base directory where "lib/" can be found
         for incdir in self.incdirs:
-            tcl_lines.append(f"set_global_assignment -name SEARCH_PATH \"{incdir}\"")
+            tcl_lines.append(
+                f"set_global_assignment -name SEARCH_PATH \"{Path(incdir).as_posix()}\""
+            )
 
         # Parameters -->  set_parameter -name <Parameter_Name> <Value>
         for k,v in self.parameters.items():
@@ -242,7 +281,7 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
         for incdir in self.incdirs:
             if os.path.exists(incdir):
                 tcl_lines.append(
-                    f"set_global_assignment -name USER_LIBRARIES \"{incdir}\""
+                    f"set_global_assignment -name USER_LIBRARIES \"{Path(incdir).as_posix()}\""
                 )
 
         # Add defines
@@ -268,7 +307,7 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
         for f in sdc_files:
             for attr in ('SDC_FILE', 'SYN_SDC_FILE', 'RTL_SDC_FILE'):
                 tcl_lines.extend([
-                    f"set_global_assignment -name {attr} \"{f}\""
+                    f"set_global_assignment -name {attr} \"{Path(f).as_posix()}\""
                 ])
         tcl_lines.append("set_global_assignment -name SYNTH_TIMING_DRIVEN_SYNTHESIS ON")
 
@@ -331,7 +370,7 @@ class CommandBuildQuartus(CommandBuild, ToolQuartus):
                    f"design={self.args['design']}")
 
         command_list = [
-            eda_base.get_eda_exec('flist'), 'flist',
+            get_eda_exec('flist'), 'flist',
             '--no-default-log',
             '--tool=' + self.args['tool'],
             '--force',
@@ -411,7 +450,7 @@ class CommandBuildQuartus(CommandBuild, ToolQuartus):
                 fname_abs = os.path.abspath(fname)
                 if not os.path.isfile(fname_abs):
                     self.error(f'add-tcl-files: "{fname_abs}"; does not exist')
-                build_tcl_lines.append(f'source {fname_abs}')
+                build_tcl_lines.append(f'source {Path(fname_abs).as_posix()}')
             build_tcl_lines.append('')
 
         # If we don't have any args for --flow-tcl-files, then use a default flow:
@@ -428,7 +467,7 @@ class CommandBuildQuartus(CommandBuild, ToolQuartus):
                 fname_abs = os.path.abspath(fname)
                 if not os.path.isfile(fname_abs):
                     self.error(f'flow-tcl-files: "{fname_abs}"; does not exist')
-                build_tcl_lines.append(f'source {fname_abs}')
+                build_tcl_lines.append(f'source {Path(fname_abs).as_posix()}')
             build_tcl_lines.append('')
 
         with open(build_tcl_file, 'w', encoding='utf-8') as ftcl:
@@ -552,20 +591,22 @@ class CommandProjQuartus(CommandProj, ToolQuartus):
             f"set_global_assignment -name TOP_LEVEL_ENTITY {top}",
         ]
 
-        # Add source files
+        # Add source files, tcl prefers POSIX paths even in Windows Powershell.
         for f in self.files_v:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name VERILOG_FILE \"{rel_path}\"")
         for f in self.files_sv:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name SYSTEMVERILOG_FILE \"{rel_path}\"")
         for f in self.files_vhd:
-            rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
+            rel_path = Path(os.path.relpath(f, self.args['work-dir'])).as_posix()
             tcl_lines.append(f"set_global_assignment -name VHDL_FILE \"{rel_path}\"")
 
         # Add include directories
         for incdir in self.incdirs:
-            tcl_lines.append(f"set_global_assignment -name SEARCH_PATH \"{incdir}\"")
+            tcl_lines.append(
+                f"set_global_assignment -name SEARCH_PATH \"{Path(incdir).as_posix()}\""
+            )
 
         # Add defines
         for key, value in self.defines.items():
@@ -575,9 +616,10 @@ class CommandProjQuartus(CommandProj, ToolQuartus):
                 tcl_lines.append(f"set_global_assignment -name VERILOG_MACRO \"{key}={value}\"")
 
         # Add constraints if available
-        if self.files_sdc:
-            for sdc_file in self.files_sdc:
-                tcl_lines.append(f"set_global_assignment -name SDC_FILE \"{sdc_file}\"")
+        for sdc_file in self.files_sdc:
+            tcl_lines.append(
+                f"set_global_assignment -name SDC_FILE \"{Path(sdc_file).as_posix()}\""
+            )
 
         tcl_lines += [
             "project_close",
@@ -601,116 +643,109 @@ class CommandProjQuartus(CommandProj, ToolQuartus):
 class CommandUploadQuartus(CommandUpload, ToolQuartus):
     '''CommandUploadQuartus is a command handler for: eda upload --tool=quartus'''
 
+    SUPPORTED_BIT_EXT = ['.sof']
+
     def __init__(self, config: dict):
         CommandUpload.__init__(self, config)
         ToolQuartus.__init__(self, config=self.config)
         # add args specific to this tool
         self.args.update({
-            'sof-file': "",
             'cable': "1",
             'device': "1",
             'list-cables': False,
             'list-devices': False,
-            'list-sof-files': False,
-            'tcl-file': "upload.tcl",
-            'log-file': "upload.log",
         })
         self.args_help.update({
-            'sof-file': 'SOF file to upload (auto-detected if not specified)',
             'cable': 'Cable number to use for programming',
             'device': 'Device number on the cable',
             'list-cables': 'List available programming cables',
             'list-devices': 'List available devices on cable',
-            'list-sof-files': 'List available SOF files',
-            'tcl-file': 'name of TCL file to be created for upload',
-            'log-file': 'log file for upload operation',
         })
 
+        # Support mulitple arg keys for bitfile and list-bitfiles, so
+        # --sof-file and --list-sof-files work the same.
+        self.args_args.update({
+            'bitfile': ['sof-file'],
+            'list-bitfiles': ['list-sof-files'],
+        })
+        self.args_help.update({
+            'bitfile': 'SOF file to upload (auto-detected if not specified)',
+            'list-bitfiles': 'List available SOF files',
+        })
+
+
     def do_it(self):  # pylint: disable=too-many-branches,too-many-statements,too-many-locals
+        '''
+        Note this is called directly by opencos.commands.CommandUpload, based
+         on which bitfile(s) were found, or if --tool=quartus was set
+
+        We do not need to handle --list-bitfiles, was handled by CommandUpload.
+        '''
+
         # add defines for this job
         self.set_tool_defines()
         self.write_eda_config_and_args()
 
+        # Find quartus_pgm executable, we'll want the one from the same path
+        # that was used for our self._EXE (ToolQuartus).
+        quartus_pgm = safe_shutil_which(os.path.join(self.quartus_base_path, 'quartus_pgm'))
+        if not quartus_pgm:
+            self.error("quartus_pgm not found in PATH")
+            return
+
+        # Handle --list-cables
+        if self.args['list-cables']:
+            util.info("Listing available cables...")
+            command_list = [quartus_pgm, '--auto']
+            _, stdout, _ = self.exec(self.args['work-dir'], command_list)
+            util.info("Available cables listed above")
+            return
+
         sof_file = None
-        if self.args['sof-file']:
-            if os.path.isfile(self.args['sof-file']):
-                sof_file = self.args['sof-file']
-            else:
-                self.error(f"Specified SOF file does not exist: {self.args['sof-file']}")
+        if self.args['bitfile']:
+            if os.path.isfile(self.args['bitfile']):
+                sof_file = self.args['bitfile']
+
+        # self.bitfiles was already set by CommandUpload.process_tokens()
+        if len(self.bitfiles) == 1:
+            sof_file = self.bitfiles[0]
 
         # Auto-discover SOF file if not specified
-        if not sof_file and not self.args['list-cables'] and not self.args['list-devices']:
-            sof_files = []
-            util.debug(f"Looking for SOF files in {os.path.abspath('.')}")
-            for root, _, files in os.walk("."):
-                for f in files:
-                    if f.endswith(".sof"):
-                        fullpath = os.path.abspath(os.path.join(root, f))
-                        sof_files.append(fullpath)
-                        util.info(f"Found SOF file: {fullpath}")
-
-            if len(sof_files) == 1:
-                sof_file = sof_files[0]
-            elif len(sof_files) > 1:
-                if self.args['list-sof-files']:
-                    util.info("Multiple SOF files found:")
-                    for sf in sof_files:
-                        util.info(f"  {sf}")
-                    return
-                self.error("Multiple SOF files found, please specify --sof-file")
-            elif not sof_files:
-                if self.args['list-sof-files']:
-                    util.info("No SOF files found")
-                    return
-                self.error("No SOF files found")
-
-        # Generate TCL script
-        script_file = Path(self.args['tcl-file'])
+        if not sof_file:
+            # CommandUpload already displayed them, and exited on --list-bitfiles.
+            if len(self.bitfiles) > 1:
+                self.error("Multiple SOF files found, please specify --sof-file or --bitfile",
+                           "or use a different search pattern")
+                return
+
+            self.error("No SOF files found")
+            return
+
+        util.info(f"Programming with SOF file: {sof_file}")
 
-        try:
-            with script_file.open("w", encoding="utf-8") as fout:
-                fout.write('load_package quartus_pgm\n')
-
-                if self.args['list-cables']:
-                    fout.write('foreach cable [get_hardware_names] {\n')
-                    fout.write('    puts "Cable: $cable"\n')
-                    fout.write('}\n')
-
-                if self.args['list-devices']:
-                    cable_idx = int(self.args["cable"]) - 1
-                    fout.write(f'set cable [lindex [get_hardware_names] {cable_idx}]\n')
-                    fout.write('foreach device [get_device_names -hardware_name $cable] {\n')
-                    fout.write('    puts "Device: $device"\n')
-                    fout.write('}\n')
-
-                if sof_file:
-                    cable_idx2 = int(self.args["cable"]) - 1
-                    device_idx = int(self.args["device"]) - 1
-                    fout.write(f'set cable [lindex [get_hardware_names] {cable_idx2}]\n')
-                    device_cmd = (
-                        f'set device [lindex [get_device_names -hardware_name $cable] {device_idx}]'
-                    )
-                    fout.write(device_cmd)
-                    fout.write('set_global_assignment -name USE_CONFIGURATION_DEVICE OFF\n')
-                    fout.write('execute_flow -compile\n')
-                    fout.write(f'quartus_pgm -c $cable -m jtag -o "p;{sof_file}@$device"\n')
-
-        except Exception as exc:
-            self.error(f"Cannot create {script_file}: {exc}")
-
-        if sof_file:
-            util.info(f"Programming with SOF file: {sof_file}")
-        else:
-            util.info("Listing cables/devices only")
 
         # Execute Quartus programmer
+        # Format: quartus_pgm -c <cable> -m jtag -o "p;<sof_file>@<device>"
+        cable = self.args['cable']
+        device = self.args['device']
+        operation = f"p;{sof_file}@{device}"
+
         command_list = [
-            self.quartus_exe, '-t', str(script_file)
+            quartus_pgm, '-c', cable, '-m', 'jtag', '-o', operation
         ]
-        if not util.args['verbose']:
-            command_list.append('-q')
 
-        self.exec(self.args['work-dir'], command_list)
+        _, stdout, _ = self.exec(self.args['work-dir'], command_list)
+
+        # Do some log scraping
+        for line in stdout.split('\n'):
+            if any(x in line for x in ('Warning', 'WARNING')):
+                self.tool_warning_count += 1
+            elif any(x in line for x in ('Error', 'ERROR')):
+                self.tool_error_count += 1
+
+        self.report_tool_warn_error_counts()
+        self.report_pass_fail()
+
         util.info("Upload operation completed")
 
 

opencos/tools/questa_common.py

@@ -11,11 +11,11 @@ Contains classes for ToolQuesta, and CommonSimQuesta.
 
 import os
 import re
-import shutil
 
 from opencos import util
 from opencos.commands import sim, CommandSim, CommandFList
 from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 class ToolQuesta(Tool):
@@ -34,10 +34,49 @@ class ToolQuesta(Tool):
     def __init__(self, config: dict):
         super().__init__(config=config)
 
+
+    def _try_set_version_from_release_notes(self) -> None:
+        '''Attempts to use a RELEASE_NOTES.txt file to get version info
+
+        Return None, may set self._VERSION
+
+        {path}/../docs/rlsnotes/RELEASE_NOTES.txt, where first line
+        '''
+        release_notes_txt_filepath = os.path.join(
+            self.sim_exe_base_path, '..', 'docs', 'rlsnotes', 'RELEASE_NOTES.txt'
+        )
+        if not os.path.isfile(release_notes_txt_filepath):
+            return
+
+        with open(release_notes_txt_filepath, encoding='utf-8') as f:
+            for line in f.readlines():
+                if line.strip().startswith('Release Notes For'):
+                    m = re.search(r'(\d+)\.(\d+)', line)
+                    if m:
+                        self.questa_major = int(m.group(1))
+                        self.questa_minor = int(m.group(2))
+                        self._VERSION = str(self.questa_major) + '.' + str(self.questa_minor)
+                        util.debug(f'version {self._VERSION} ({release_notes_txt_filepath})')
+                        break
+
+    def _try_set_version_from_path(self) -> None:
+        '''Attempts to use portions of exe path to get version info
+
+        Return None, may set self._VERSION
+        '''
+        m = re.search(r'(\d+)\.(\d+)', self.sim_exe_base_path)
+        if m:
+            self.questa_major = int(m.group(1))
+            self.questa_minor = int(m.group(2))
+            self._VERSION = str(self.questa_major) + '.' + str(self.questa_minor)
+        else:
+            util.warning("Questa path doesn't specificy version, expecting (d+.d+)")
+
+
     def get_versions(self) -> str:
         if self._VERSION:
             return self._VERSION
-        path = shutil.which(self._EXE)
+        path = safe_shutil_which(self._EXE)
         if not path:
             self.error(f"{self._EXE} not in path, need to setup",
                        "(i.e. source /opt/intelFPGA_pro/23.4/settings64.sh")
@@ -51,13 +90,15 @@ class ToolQuesta(Tool):
             self.sim_exe = path
             self.sim_exe_base_path, _ = os.path.split(path)
 
-        m = re.search(r'(\d+)\.(\d+)', path)
-        if m:
-            self.questa_major = int(m.group(1))
-            self.questa_minor = int(m.group(2))
-            self._VERSION = str(self.questa_major) + '.' + str(self.questa_minor)
-        else:
-            self.error("Questa path doesn't specificy version, expecting (d+.d+)")
+        # For Questa family, we will get the version from the path.
+        # 1. (if present): {path}/../docs/rlsnotes/RELEASE_NOTES.txt, where first line
+        #   shows the full version.
+        # 2. else, use the path
+        self._try_set_version_from_release_notes()
+
+        if not self._VERSION:
+            self._try_set_version_from_path()
+
         return self._VERSION
 
     def set_tool_defines(self):

opencos/tools/riviera.py

@@ -7,12 +7,12 @@ Contains classes for ToolRiviera, CommandSimRiviera, CommandElabRiviera.
 # pylint: disable=R0801 # (duplicate code in derived classes, such as if-condition return.)
 
 import os
-import shutil
 import subprocess
 
 from opencos import util
-from opencos.tools.questa_common import ToolQuesta, CommonSimQuesta
 from opencos.commands import CommandFList
+from opencos.files import safe_shutil_which
+from opencos.tools.questa_common import ToolQuesta, CommonSimQuesta
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 from opencos.utils import status_constants
 
@@ -27,7 +27,7 @@ class ToolRiviera(ToolQuesta):
     def get_versions(self) -> str:
         if self._VERSION:
             return self._VERSION
-        path = shutil.which(self._EXE)
+        path = safe_shutil_which(self._EXE)
         if not path:
             self.error(f"{self._EXE} not in path, need to setup or add to PATH")
             util.debug(f"{path=}")
@@ -35,6 +35,7 @@ class ToolRiviera(ToolQuesta):
             self.sim_exe = path
             self.sim_exe_base_path, _ = os.path.split(path)
 
+        # vsim -version is very fast and does not require a license:
         version_ret = subprocess.run(
             [self.sim_exe, '-version'],
             capture_output=True,
@@ -56,7 +57,7 @@ class ToolRiviera(ToolQuesta):
         #  Aldec, Inc. Riviera-PRO version 2025.04.139.9738 built for Linux64 on May 30, 2025
         left, right = stdout.split('version')
         if 'Riviera' not in left:
-            self.error(f'{stdout}: does not show Riviera')
+            util.warning(f'riviera version parsing: {stdout}: does not show "Riviera"')
         self._VERSION = right.split()[0]
         return self._VERSION