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

opencos/eda_deps_bash_completion.bash

@@ -1,14 +1,34 @@
 #!/usr/bin/env bash
 
 # How to use?
-# 1) copy this script locally and source it.
+# 1) run:
+#        eda_show_autocomplete
+#    for instructions, will likely show you the location of this file,
+#    eda_deps_bash_completion.bash, for you to source. Does not require uv.
+#
+# 2) Given the result from (1), and if you use uv, add the following to your
+#    ~/.bashrc:
+#        # Make sure 'eda' is a valid executable when not in a venv:
+#        if ! type -P "eda" &>/dev/null; then
+#            uv tool install --python 3.14 opencos-eda >/dev/null 2>&1
+#            echo "uv tool installed opencos-eda"
+#        fi
+#        if [ -f PATH-FROM-STEP-1 ]; then
+#            . PATH-FROM-STEP-1
+#        fi
+#
+# 3) copy this script locally and source it.
 #    For example:
 #    > source ~/sh/eda_deps_bash_completion.bash
-#    You can put this in your .bashrc.
-# 2) From you venv activate script:
-#    (bottom of activate script, assuming python3.10):
+#    You can put this in your .bashrc. Note you will need a venv active or
+#    "eda" isn't in your path yet.
+#
+# 4) Have it sourced when you start your venv. Note this doesn't play as nicely
+#    with "uv" due to having a less stable .venv, but you can add this to your
+#    VENV_NAME/bin/activate script:
+#    (bottom of activate script, assuming python3.XX):
 #     script_dir=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-#     . $script_dir/../lib/python3.10/site-packages/opencos/eda_deps_bash_completion.bash
+#     . $script_dir/../lib/python3.XX/site-packages/opencos/eda_deps_bash_completion.bash
 
 
 # scripts via pyproject.toml:
@@ -17,6 +37,15 @@ SCRIPT_NAME="eda"
 # how we get the completion targets:
 EXTRACTION_SCRIPT_NAME="eda_targets"
 
+EDA_WORDS="sim lint elab synth flist proj multi tools-multi sweep build \
+    waves upload open export shell targets lec \
+    +define+ +incdirs+ \
+    --help --quiet --verbose --debug \
+    --tool --seed --top --keep --force --fake --lint --work-dir \
+    --stop-before-compile --stop-after-compile --stop-before-elaborate \
+    --export --export-run --export-json \
+"
+
 _eda_script_completion() {
 
     # Set up for additional completions
@@ -28,22 +57,15 @@ _eda_script_completion() {
     if [[ $(type -P "$EXTRACTION_SCRIPT_NAME") ]]; then
         keys=$("$EXTRACTION_SCRIPT_NAME" "$cur")
         if [[ -n "$keys" ]]; then
-            completions=($(compgen -W "$keys" -- "$cur"))
+            completions=($(compgen -W "$keys $EDA_WORDS" -- "$cur"))
         fi
     fi
 
     if [ -z "${completions}" ]; then
         # If we didn't find anything in a DEPS.[yml|yaml|toml|json], then use:
-        # 1. a bunch of known eda words or args.
-        eda_words="multi sim elab flist build synth waves proj waves targets \
-                    +define+ +incdirs+ \
-                    --help --quiet --verbose --debug \
-                    --tool --seed --top --keep --force --fake --lint --work-dir \
-                    --stop-before-compile --stop-after-compile --stop-before-elaborate \
-                    --export --export-run --export-json \
-                    "
+        # -- a bunch of known eda words or args.
         # 2. a glob the current word to mimic normal bash:
-        completions=($(compgen -W "${eda_words}" -G "${cur}*" -- "$cur"))
+        completions=($(compgen -W "$EDA_WORDS" -G "${cur}*" -- "$cur"))
     fi
 
     COMPREPLY=("${completions[@]}")

opencos/files.py

@@ -13,6 +13,7 @@ as part of a verilog $readmemh, etc)
 '''
 
 import os
+import shutil
 
 # Ways to force files not ending in .sv to be systemverilog (for tools
 # that require -sv vs Verilog-2001'''
@@ -31,8 +32,12 @@ FORCE_PREFIX_DICT = {
 
 ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))
 
-def get_source_file(target:str) -> (bool, str, str):
+def get_source_file(target: str) -> (bool, str, str):
     '''Returns tuple: bool if file exists, filepath str, and optional forced file type str'''
+
+    if '$' in target:
+        target = os.path.expandvars(target)
+
     if os.path.isfile(target):
         # target exists as a file, return True w/ original target:
         return True, target, ''
@@ -47,3 +52,23 @@ def get_source_file(target:str) -> (bool, str, str):
 
     # target or fpath didn't exist, return False with the original target:
     return False, target, ''
+
+
+def safe_shutil_which(path: str) -> str:
+    '''Windows/WSL compatible Wrapper for shutil.which that checks for 'path':
+
+    - path
+    - path.exe
+    - path.bat
+
+    Returns full path str returned by shutil.which
+    '''
+    for ext in ('', '.exe', 'bat'):
+        if found := shutil.which(f'{path}{ext}'):
+            return found
+    return ''
+
+# Note that in Windows, 'python' will return the venv or uv version, 'python3' will
+# return the installed version (which may not be what you want), so we'll prefer
+# 'python':
+PY_EXE = safe_shutil_which('python') or safe_shutil_which('python3')

opencos/tools/cocotb.py

@@ -4,12 +4,12 @@ Contains classes for ToolCocotb, CommandSimCocotb.
 '''
 
 import os
-import shutil
 import subprocess
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which, PY_EXE
 from opencos.utils import status_constants
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 from opencos.tools import verilator # For default waivers.
@@ -30,7 +30,7 @@ class ToolCocotb(Tool):
             return self._VERSION
 
         # Check if python is available
-        python_path = shutil.which('python') or shutil.which('python3')
+        python_path = PY_EXE
         if not python_path:
             self.error('"python" or "python3" not in path, required for cocotb')
         else:
@@ -128,7 +128,7 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             util.warning('--cocotb-simulator is not set, a simulation cannot be run with'
                          'this arg value')
             return
-        exe = shutil.which(simulator)
+        exe = safe_shutil_which(simulator)
         if not exe:
             util.warning(f'--cocotb-simulator={simulator}, {simulator} is not present in PATH',
                          'a simulation cannot be run with this arg value')
@@ -330,7 +330,7 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
     def _generate_runner_script_content(self, test_module: str, hdl_sources: list) -> str:
         '''Generate the content for the Python runner script'''
 
-        if shutil.which('verilator'):
+        if safe_shutil_which('verilator'):
             # TODO(drew): this shortcuts if verilator is truly usable,
             # consider using eda_tool_helper to get "tools_loaded", which
             # is not set in self.config['tools_loaded'] when --tool=cocotb.

opencos/tools/invio.py

@@ -5,9 +5,9 @@
 import importlib.util
 
 from opencos import util
-from opencos.tools import invio_helpers
-from opencos.eda_base import Tool
 from opencos.commands import CommandElab
+from opencos.eda_base import Tool
+from opencos.tools import invio_helpers
 
 
 

opencos/tools/invio_yosys.py

@@ -8,6 +8,7 @@ import os
 import importlib.util
 
 from opencos import util
+from opencos.files import PY_EXE
 from opencos.tools import invio_helpers
 from opencos.tools.yosys import ToolYosys, CommonSynthYosys
 
@@ -100,7 +101,7 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
 
 
         invio_command_list = util.ShellCommandList(
-            ['python3', invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
+            [PY_EXE, invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
         )
 
         # Optinally create and run a sta.f:

opencos/tools/iverilog.py

@@ -3,12 +3,12 @@
 Contains classes for ToolIverilog CommandSimIverilog, CommandElabIverilog.
 '''
 
-import shutil
 import subprocess
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 
@@ -28,7 +28,7 @@ class ToolIverilog(Tool):
         if self._VERSION:
             return self._VERSION
 
-        iverilog_path = shutil.which(self._EXE)
+        iverilog_path = safe_shutil_which(self._EXE)
         if iverilog_path is None:
             self.error(f'"{self._EXE}" not in path, need to get it ({self._URL})')
         else:

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):
@@ -48,16 +46,17 @@ class ToolQuartus(Tool):
         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}")
@@ -151,7 +150,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 +170,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 +179,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 +211,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 +244,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 +270,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 +333,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 +413,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 +430,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 +554,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 +579,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 +606,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'])
-
-        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")
+        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}")
+
 
         # 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):
@@ -25,7 +25,7 @@ class ToolQuesta(Tool):
     _EXE = 'vsim'
 
     starter_edition = False
-    use_vopt = shutil.which('vopt') # vopt exists in qrun/vsim framework, and we'll use it.
+    use_vopt = False # set manually or by get_versions() (after __init__ has set self._EXE)
     sim_exe = '' # vsim or qrun
     sim_exe_base_path = ''
     questa_major = None
@@ -33,12 +33,11 @@ class ToolQuesta(Tool):
 
     def __init__(self, config: dict):
         super().__init__(config=config)
-        self.args['part'] = 'xcu200-fsgd2104-2-e'
 
     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")

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=}")