opencos-eda 0.3.10__py3-none-any.whl → 0.3.11__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):
@@ -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):
@@ -37,7 +37,7 @@ class ToolQuesta(Tool):
     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=}")

opencos/tools/slang.py

@@ -6,12 +6,12 @@ Contains classes for ToolSlang, CommandElabSlang
 # pylint: disable=R0801 # (calling functions with same arguments)
 
 import os
-import shutil
 import subprocess
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandElab
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 
@@ -30,14 +30,18 @@ class ToolSlang(Tool):
     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 get it ({self._URL}')
         else:
             self.slang_exe = path
             self.slang_base_path, _ = os.path.split(path)
-            self.slang_tidy_exe = os.path.join(self.slang_base_path, 'slang-tidy')
-            self.slang_hier_exe = os.path.join(self.slang_base_path, 'slang-hier')
+            self.slang_tidy_exe = safe_shutil_which(
+                os.path.join(self.slang_base_path, 'slang-tidy')
+            )
+            self.slang_hier_exe = safe_shutil_which(
+                os.path.join(self.slang_base_path, 'slang-hier')
+            )
 
         version_ret = subprocess.run(
             [self.slang_exe, '--version'],
@@ -204,7 +208,7 @@ class CommandElabSlang(CommandElab, ToolSlang):
         command_list = [self.slang_exe]
 
         if self.args['tidy']:
-            if not shutil.which(self.slang_tidy_exe):
+            if not safe_shutil_which(self.slang_tidy_exe):
                 util.warning("Running tool slang with --tidy, but 'slang-tidy'",
                              "not in PATH, using 'slang' instead")
             else:
@@ -213,7 +217,7 @@ class CommandElabSlang(CommandElab, ToolSlang):
         if self.args['hier']:
             if self.args['tidy']:
                 util.warning('Running with --tidy and --heir, will attempt to use slang-hier')
-            elif not shutil.which(self.slang_hier_exe):
+            elif not safe_shutil_which(self.slang_hier_exe):
                 util.warning("Running tool slang with --hier, but 'slang-hier'",
                              "not in PATH, using 'slang' instead")
             else:

opencos/tools/slang_yosys.py

@@ -119,6 +119,7 @@ class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
         )
 
         # In case --top was not set:
+        # TODO(drew): Can we skip this if it was an inferred top???
         if not any(x.startswith('--top') for x in read_slang_cmd):
             read_slang_cmd.append(f'--top {self.args["top"]}')
 

opencos/tools/surelog.py

@@ -3,12 +3,13 @@
 Contains classes for ToolSurelog, CommandElabSurelog
 '''
 
-import shutil
+
 import subprocess
 
 from opencos import util
-from opencos.eda_base import Tool
 from opencos.commands import CommandElab
+from opencos.eda_base import Tool
+from opencos.files import safe_shutil_which
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 
@@ -24,7 +25,7 @@ class ToolSurelog(Tool):
     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 get it ({self._URL})')
         else:

opencos/tools/verilator.py

@@ -7,13 +7,13 @@ Contains classes for ToolVerilator and VerilatorSim, VerilatorElab.
 
 import multiprocessing
 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
 from opencos.utils.str_helpers import sanitize_defines_for_sh
 
 class ToolVerilator(Tool):
@@ -31,7 +31,7 @@ class ToolVerilator(Tool):
         if self._VERSION:
             return self._VERSION
         # __init__ would have set self.EXE to full path.
-        path = shutil.which(self._EXE)
+        path = safe_shutil_which(self._EXE)
         if not path:
             self.error(f'"{self._EXE}" not in path or not installed, see {self._URL})')
         else:
@@ -40,7 +40,7 @@ class ToolVerilator(Tool):
 
         # Let's get the verilator_coverage path from the same place as verilator.
         if path:
-            self.verilator_coverage_exe = shutil.which(
+            self.verilator_coverage_exe = safe_shutil_which(
                 os.path.join(self.verilator_base_path, 'verilator_coverage')
             )
         if not self.verilator_coverage_exe: