opencos-eda 0.2.53__tar.gz → 0.2.54__tar.gz

{opencos_eda-0.2.53/opencos_eda.egg-info → opencos_eda-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.2.53
+Version: 0.2.54
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/commands/flist.py

@@ -214,6 +214,6 @@ class CommandFList(CommandDesign):
             print() # don't need to close fo (None)
         else:
             fo.close()
-            util.info(f"Created {self.args['out']}")
+            util.info(f"Created file: {self.args['out']}")
 
         self.write_eda_config_and_args()

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/commands/sim.py

@@ -355,6 +355,50 @@ class CommandSim(CommandDesign):
                 error_code=status_constants.EDA_SIM_LOG_MISSING_MUST_STRING
             )
 
+    def write_sh_scripts_to_work_dir(
+            self, compile_lists: list, elaborate_lists: list, simulate_lists: list,
+            compile_line_breaks: bool = True,
+            elaborate_line_breaks: bool = False,
+            simulate_line_breaks: bool = False,
+            simulate_sh_fname: str = 'simulate.sh'
+    ) -> None:
+        '''Writes compile.sh, elaborate.sh, simulate.sh (if present), all.sh to work-dir
+
+        Will include the pre_compile_dep_shell_commands.sh if those are present.
+        compile_line_breaks defaults to True (one word per line w/ line breaks added)
+        '''
+
+        all_lists = [] # list - of - (command-list)
+        if self.has_dep_shell_commands:
+            all_lists = [
+                ['./pre_compile_dep_shell_commands.sh']
+            ]
+
+        if compile_lists:
+            util.write_shell_command_file(dirpath=self.args['work-dir'], filename='compile.sh',
+                                          command_lists=compile_lists,
+                                          line_breaks=compile_line_breaks)
+            all_lists.append(['./compile.sh'])
+
+        if elaborate_lists:
+            util.write_shell_command_file(dirpath=self.args['work-dir'], filename='elaborate.sh',
+                                          command_lists=elaborate_lists,
+                                          line_breaks=elaborate_line_breaks)
+            all_lists.append(['./elaborate.sh'])
+
+        if simulate_lists:
+            util.write_shell_command_file(dirpath=self.args['work-dir'], filename=simulate_sh_fname,
+                                          command_lists=simulate_lists,
+                                          line_breaks=simulate_line_breaks)
+            all_lists.append(['./' + simulate_sh_fname])
+
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='all.sh',
+                                      command_lists=all_lists)
+
+        self.write_eda_config_and_args()
+
+
+
     # Methods that derived classes must override:
 
     def compile(self) -> None:

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/eda_base.py

@@ -252,7 +252,7 @@ class Command: # pylint: disable=too-many-public-methods
         })
         self.modified_args = {}
         self.config = copy.deepcopy(config) # avoid external modifications.
-        self.target = ""
+        self.target = "" # is set as the 'top' or final target short-name (no path info)
         self.target_path = ""
         self.status = 0
         self.errors_log_f = None
@@ -943,6 +943,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         self.targets_dict = {} # key = targets that we've already processed in DEPS files
         self.last_added_source_file_inferred_top = ''
 
+        self.has_dep_shell_commands = False
+
 
     def run_dep_commands(self) -> None:
         '''Run shell/peakrdl style commands from DEPS files
@@ -993,10 +995,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
             d['exec_list'] = clist # update to tee_fpath is set.
 
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'], filename='pre_compile_dep_shell_commands.sh',
-            command_lists=all_cmds_lists
-        )
+        if all_cmds_lists:
+            util.write_shell_command_file(
+                dirpath=self.args['work-dir'], filename='pre_compile_dep_shell_commands.sh',
+                command_lists=all_cmds_lists
+            )
+            self.has_dep_shell_commands = True
 
         for i, d in enumerate(self.dep_shell_commands):
             util.info(f'run_dep_shell_commands {i=}: {d=}')
@@ -1556,11 +1560,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
 
         # handle a missing self.args['top'] with last filepath or last target:
         if not self.args.get('top', ''):
+            top_path = ''
             if not last_potential_top_isfile and last_potential_top_target[0]:
                 # If we have a target name from DEPS, prefer to use that.
-                self.args['top'], self.args['top-path'] = last_potential_top_target
+                self.args['top'], top_path = last_potential_top_target
                 util.info("--top not specified, inferred from target:",
-                          f"{self.args['top']} ({self.args['top-path']})")
+                          f"{self.args['top']} ({top_path})")
 
             else:
                 best_top_fname = self.last_added_source_file_inferred_top
@@ -1570,26 +1575,29 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
             if not self.args['top'] and last_potential_top_file[0]:
                 # If we don't have a target name, and no top name yet, then go looking for the
                 # module name in the final source file added.
-                self.args['top-path'] = last_potential_top_file[1] # from tuple: (top, fpath)
+                top_path = last_potential_top_file[1] # from tuple: (top, fpath)
                 self.args['top'] = util.get_inferred_top_module_name(
                     module_guess=last_potential_top_file[0],
                     module_fpath=last_potential_top_file[1]
                 )
                 if self.args['top']:
                     util.info("--top not specified, inferred from final source file:",
-                              f"{self.args['top']} ({self.args['top-path']})")
+                              f"{self.args['top']} ({top_path})")
                     # If top wasn't set, and we're using the final command-line 'arg' filename
                     # (not from DEPS.yml) we need to override self.target if that was set. Otherwise
                     # it won't save to the correct work-dir:
                     self.target = self.args['top']
 
+
+        util.info(f'{self.command_name}: top-most target name: {self.target}')
+
         if self.error_on_missing_top and not self.args.get('top', ''):
             self.error("Did not get a --top or DEPS top, required to run command",
                        f"'{self.command_name}' for tool={self.args.get('tool', None)}",
                        error_code=status_constants.EDA_COMMAND_MISSING_TOP)
 
         if self.tool_changed_respawn:
-            util.warning(
+            util.info(
                 'CommandDesign: need to respawn due to tool change to',
                 f'\'{self.tool_changed_respawn["tool"]}\' from',
                 f'\'{self.tool_changed_respawn["orig_tool"]}\'',
@@ -1615,7 +1623,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         for k,v in self.args.items():
 
             # Some args cannot be extracted and work, so omit these:
-            if k in ['top-path'] + remove_args:
+            if k in remove_args:
                 continue
             if any(k.startswith(x) for x in remove_args_startswith):
                 continue
@@ -1637,9 +1645,6 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         return ret
 
 
-#_THREADS_START = 0
-#_THREADS_DONE = 0
-
 class ThreadStats:
     '''To avoid globals for two ints, keep a class holder so CommandParallel and
     CommandParallelWorker can share values'''

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tests/test_eda.py

@@ -170,7 +170,7 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
         assert res.stderr == b''
 
         res = subprocess.run(
-            [ './simulate_only.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            [ './simulate.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             check=True
         )
         rc = res.returncode

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tools/cocotb.py

@@ -122,20 +122,12 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
 
         # Write shell scripts
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='cocotb_test.sh',
-            command_lists=self.cocotb_command_lists,
-            line_breaks=True
-        )
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='all.sh',
-            command_lists=[
-                ['./pre_compile_dep_shell_commands.sh'],
-                ['./cocotb_test.sh'],
-            ]
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=[],
+            elaborate_lists=[],
+            simulate_lists=self.cocotb_command_lists,
+            simulate_line_breaks=True,
+            simulate_sh_fname='cocotb_test.sh'
         )
 
     def _find_cocotb_test_files(self):
@@ -317,7 +309,7 @@ def run_cocotb_test():
         runner = get_runner(simulator)
 
         build_args = []
-        
+
         if simulator == "verilator":
             build_args.extend({list(self.args.get('verilate-args', []))!r})
 

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tools/iverilog.py

@@ -84,32 +84,12 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
 
         paths = ['logs']
         util.safe_mkdirs(base=self.args['work-dir'], new_dirs=paths)
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='compile_only.sh',
-            command_lists=self.iverilog_command_lists,
-            line_breaks=True
-        )
-
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='simulate_only.sh',
-            command_lists=self.iverilog_exec_command_lists
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=self.iverilog_command_lists,
+            elaborate_lists=[],
+            simulate_lists=self.iverilog_exec_command_lists
         )
 
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='all.sh',
-            command_lists = [
-                ['./pre_compile_dep_shell_commands.sh'],
-                ['./compile_only.sh'],
-                ['./simulate_only.sh'],
-            ]
-        )
-
-        self.write_eda_config_and_args()
-
     def compile(self):
         if self.args['stop-before-compile']:
             return

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tools/modelsim_ase.py

@@ -82,15 +82,12 @@ class CommandSimModelsimAse(CommandSim, ToolModelsimAse):
             command_lists=vsim_command_lists
         )
 
+        # Write simulate.sh and all.sh to work-dir:
         vsim_command_lists = self.get_simulate_command_lists()
-        util.write_shell_command_file(
-            dirpath=self.args['work-dir'],
-            filename='all.sh',
-            command_lists = [['./pre_compile_dep_shell_commands.sh']] + vsim_command_lists
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=[], elaborate_lists=[], simulate_lists=vsim_command_lists
         )
 
-        self.write_eda_config_and_args()
-
     def compile(self):
         if self.args['stop-before-compile']:
             # don't run anything, save everyting we've already run in _prep_compile()

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tools/quartus.py

@@ -30,12 +30,13 @@ class ToolQuartus(Tool):
     quartus_release = None
     quartus_base_path = ''
     quartus_exe = ''
+    quartus_gui_exe = ''
 
     def __init__(self, config: dict):
         super().__init__(config=config)
         self.args.update({
-            'part': 'EP4SGX230KF40C2',
-            'family': 'Stratix IV',
+            'part': 'A3CY135BM16AE6S',
+            'family': 'Agilex 3',
         })
         self.args_help.update({
             'part': 'Device used for commands: synth, build.',
@@ -53,6 +54,7 @@ class ToolQuartus(Tool):
         else:
             self.quartus_exe = path
             self.quartus_base_path, _ = os.path.split(path)
+        self.quartus_gui_exe = shutil.which('quartus') # vs quartus_sh
 
 
 
@@ -157,15 +159,15 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
         # Add artifact tracking
         util.artifacts.add_extension(
             search_paths=self.args['work-dir'], file_extension='qpf',
-            typ='project', description='Quartus Project File'
+            typ='tcl', description='Quartus Project File'
         )
         util.artifacts.add_extension(
             search_paths=self.args['work-dir'], file_extension='qsf',
-            typ='project', description='Quartus Settings File'
+            typ='tcl', description='Quartus Settings File'
         )
         util.artifacts.add_extension(
             search_paths=self.args['work-dir'], file_extension='rpt',
-            typ='report', description='Quartus Synthesis Report'
+            typ='text', description='Quartus Synthesis Report'
         )
 
         self.exec(self.args['work-dir'], command_list)
@@ -187,27 +189,9 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
             f"set_global_assignment -name TOP_LEVEL_ENTITY {top}",
         ]
 
-        # Create a symbolic link or copy the include file to resolve lib/ paths
-        for incdir in self.incdirs:
-            if 'lib' in incdir:
-                lib_defines = os.path.join(incdir, 'oclib_defines.vh')
-                if os.path.exists(lib_defines):
-                    # Copy the include file to the work directory as lib/oclib_defines.vh
-                    work_lib_dir = os.path.join(self.args['work-dir'], 'lib')
-                    os.makedirs(work_lib_dir, exist_ok=True)
-                    work_lib_defines = os.path.join(work_lib_dir, 'oclib_defines.vh')
-
-                    shutil.copy2(lib_defines, work_lib_defines)
-
-                    # Add the copied file as a source
-                    rel_path = os.path.relpath(
-                        work_lib_defines, self.args['work-dir']
-                    ).replace('\\', '/')
-                    tcl_lines.append(
-                        f"set_global_assignment -name VERILOG_FILE \"{rel_path}\""
-                    )
-                    break
         # 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:
         for f in self.files_v:
             rel_path = os.path.relpath(f, self.args['work-dir']).replace('\\', '/')
             tcl_lines.append(f"set_global_assignment -name VERILOG_FILE \"{rel_path}\"")
@@ -219,25 +203,8 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
             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
-        project_root = None
         for incdir in self.incdirs:
             tcl_lines.append(f"set_global_assignment -name SEARCH_PATH \"{incdir}\"")
-            # Find the project root (where lib/ directory exists)
-            if 'lib' in incdir and os.path.exists(incdir):
-                parent_dir = os.path.dirname(incdir)
-                if os.path.exists(os.path.join(parent_dir, 'lib')):
-                    project_root = parent_dir
-
-        # Set the project root as the main search path so "lib/oclib_defines.vh" resolves correctly
-        if project_root:
-            tcl_lines.append(
-                f"set_global_assignment -name SEARCH_PATH \"{project_root}\""
-            )
-            # Add the lib directory as an include path
-            lib_path = os.path.join(project_root, 'lib').replace('\\', '/')
-            tcl_lines.append(
-                f"set_global_assignment -name USER_LIBRARIES \"{lib_path}\""
-            )
 
         # Add all include directories as user libraries for better include resolution
         for incdir in self.incdirs:
@@ -262,9 +229,8 @@ class CommandSynthQuartus(CommandSynth, ToolQuartus):
 
         tcl_lines += [
             "# Run synthesis",
-            "execute_flow -analysis_and_elaboration",
-            "execute_flow -compile",
-            "project_close"
+            'flng::run_flow_command -flow "compile" -end "dni_synthesis"',
+            'flng::run_flow_command -flow "compile" -end "sta_early" -resume',
         ]
 
         with open(tcl_file, 'w', encoding='utf-8') as ftcl:
@@ -283,22 +249,24 @@ class CommandBuildQuartus(CommandBuild, ToolQuartus):
             'proj': False,
             'resynth': False,
             'reset': False,
+            'add-tcl-files': [],
+            'flow-tcl-files': [],
         })
 
-    def do_it(self):
+    def do_it(self) -> None: # pylint: disable=too-many-branches,too-many-statements
         # add defines for this job
         self.set_tool_defines()
         self.write_eda_config_and_args()
 
         # create FLIST
-        flist_file = os.path.join(self.args['work-dir'],'build.flist')
-        util.debug(f"CommandBuildQuartus: {self.args['top-path']=}")
+        flist_file = os.path.abspath(os.path.join(self.args['work-dir'], 'build.flist'))
+        util.debug(f"CommandBuildQuartus: top={self.args['top']} target={self.target}",
+                   f"design={self.args['design']}")
 
-        eda_path = eda_base.get_eda_exec('flist')
         command_list = [
-            eda_path, 'flist',
+            eda_base.get_eda_exec('flist'), 'flist',
+            '--no-default-log',
             '--tool=' + self.args['tool'],
-            self.args['top-path'],
             '--force',
             '--out=' + flist_file,
             '--no-quote-define',
@@ -314,46 +282,85 @@ class CommandBuildQuartus(CommandBuild, ToolQuartus):
             '--prefix-vhd=' + shlex.quote("set_global_assignment -name VHDL_FILE "),
             '--emit-rel-path',  # Use relative paths for better portability
         ]
+
+        # create an eda.flist_input.f that we'll pass to flist:
+        with open(os.path.join(self.args['work-dir'], 'eda.flist_input.f'),
+                  'w', encoding='utf-8') as f:
+            f.write('\n'.join(self.files_v + self.files_sv + self.files_vhd + ['']))
+        command_list.append('--input-file=eda.flist_input.f')
+
+
         for key,value in self.defines.items():
             if value is None:
                 command_list += [ f"+define+{key}" ]
             else:
                 command_list += [ shlex.quote(f"+define+{key}={value}") ]
 
-        cwd = util.getcwd()
-        util.debug(f"CommandBuildQuartus: {cwd=}")
-
         # Write out a .sh command for debug
         command_list = util.ShellCommandList(command_list, tee_fpath='run_eda_flist.log')
         util.write_shell_command_file(dirpath=self.args['work-dir'], filename='run_eda_flist.sh',
                                       command_lists=[command_list], line_breaks=True)
 
-        self.exec(cwd, command_list, tee_fpath=command_list.tee_fpath)
+        self.exec(work_dir=self.args['work-dir'], command_list=command_list,
+                  tee_fpath=command_list.tee_fpath)
 
         if self.args['job-name'] == "":
             self.args['job-name'] = self.args['design']
-        project_dir = 'project.'+self.args['job-name']
+        project_dir = 'project.' + self.args['job-name']
 
         # Create a simple Quartus build TCL script
-        build_tcl_file = os.path.join(self.args['work-dir'], 'build.tcl')
+        build_tcl_file = os.path.abspath(os.path.join(self.args['work-dir'], 'build.tcl'))
+        build_tcl_lines = [
+            '# Quartus Build Script',
+            '',
+            f'set Top {self.args["top"]}'
+            '',
+            'load_package flow',
+            f'project_new {self.args["design"]} -overwrite',
+            f'set_global_assignment -name FAMILY \"{self.args["family"]}\"',
+            f'set_global_assignment -name DEVICE {self.args["part"]}',
+            'set_global_assignment -name TOP_LEVEL_ENTITY "$Top"',
+            '',
+            '# Source the flist file',
+            'source build.flist',
+            '',
+        ]
+
+        # If we have additinal TCL files via --add-tcl-files, then source those too:
+        if self.args['add-tcl-files']:
+            build_tcl_lines.append('')
+            build_tcl_lines.append('# Source TCL files from --add-tcl-files args')
+            for fname in self.args['add-tcl-files']:
+                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('')
+
+        # If we don't have any args for --flow-tcl-files, then use a default flow:
+        if not self.args['flow-tcl-files']:
+            build_tcl_lines.extend([
+                '# Default flow for compile',
+                'flng::run_flow_command -flow "compile"',
+                ''
+            ])
+        else:
+            build_tcl_lines.append('')
+            build_tcl_lines.append('# Flow TCL files from --flow-tcl-files args')
+            for fname in self.args['flow-tcl-files']:
+                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('')
+
         with open(build_tcl_file, 'w', encoding='utf-8') as ftcl:
-            ftcl.write(f'''# Quartus Build Script
-load_package flow
-project_new {self.args['design']} -overwrite
-set_global_assignment -name FAMILY "{self.args['family']}"
-set_global_assignment -name DEVICE {self.args['part']}
-set_global_assignment -name TOP_LEVEL_ENTITY {self.args['top']}
-
-# Source the flist file
-source [lindex $argv 1]
-
-# Run synthesis and compile
-execute_flow -compile
-project_close
-''')
-
-        # launch Quartus build
-        command_list = [self.quartus_exe, '-t', build_tcl_file, project_dir, flist_file]
+            ftcl.write('\n'.join(build_tcl_lines))
+
+        # launch Quartus build, from work-dir:
+        command_list_gui = [self.quartus_gui_exe, '-t', 'build.tcl', project_dir]
+        command_list = [self.quartus_exe, '-t', 'build.tcl', project_dir]
+        saved_qpf_filename = self.args["design"] + '.qpf'
         if not util.args['verbose']:
             command_list.append('-q')
 
@@ -361,28 +368,63 @@ project_close
         command_list = util.ShellCommandList(command_list, tee_fpath=None)
         util.write_shell_command_file(dirpath=self.args['work-dir'], filename='run_quartus.sh',
                                       command_lists=[command_list], line_breaks=True)
+        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='run_quartus_gui.sh',
+                                      command_lists=[
+                                          command_list_gui,
+                                          ['quartus', saved_qpf_filename], # reopen when done.
+                                      ], line_breaks=True)
 
         # Add artifact tracking for build
+        artifacts_search_paths = [
+            self.args['work-dir'],
+            os.path.join(self.args['work-dir'], 'output_files'),
+        ]
+
         util.artifacts.add_extension(
-            search_paths=self.args['work-dir'], file_extension='sof',
+            search_paths=artifacts_search_paths, file_extension='sof',
             typ='bitstream', description='Quartus SRAM Object File (bitstream)'
         )
         util.artifacts.add_extension(
-            search_paths=self.args['work-dir'], file_extension='pof',
+            search_paths=artifacts_search_paths, file_extension='pof',
             typ='bitstream', description='Quartus Programmer Object File'
         )
         util.artifacts.add_extension(
-            search_paths=self.args['work-dir'], file_extension='fit.rpt',
-            typ='report', description='Quartus Fitter Report'
+            search_paths=artifacts_search_paths, file_extension='rpt',
+            typ='text', description='Quartus Timing, Fitter, or other report'
         )
         util.artifacts.add_extension(
-            search_paths=self.args['work-dir'], file_extension='sta.rpt',
-            typ='report', description='Quartus Timing Analyzer Report'
+            search_paths=artifacts_search_paths, file_extension='summary',
+            typ='text', description='Quartus Timing, Fitter, or other summary'
         )
 
-        self.exec(cwd, command_list, tee_fpath=command_list.tee_fpath)
+        if self.args['stop-before-compile']:
+            util.info(f"--stop-before-compile set: scripts in : {self.args['work-dir']}")
+            return
+
+
+        if self.args['gui'] and self.quartus_gui_exe:
+            self.exec(
+                work_dir=self.args['work-dir'], command_list=command_list_gui
+            )
+        else:
+            self.exec(
+                work_dir=self.args['work-dir'], command_list=command_list,
+                tee_fpath=command_list.tee_fpath
+            )
+        if not os.path.isfile(os.path.join(self.args['work-dir'], saved_qpf_filename)):
+            self.error('Saved project file does not exist:',
+                       os.path.join(self.args['work-dir'], saved_qpf_filename))
+
         util.info(f"Build 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.
+        if self.args['gui'] and self.quartus_gui_exe:
+            self.exec(
+                work_dir=self.args['work-dir'],
+                command_list=['quartus', saved_qpf_filename]
+            )
+
 
 class CommandFListQuartus(CommandFList, ToolQuartus):
     '''CommandFListQuartus is a command handler for: eda flist --tool=quartus'''
@@ -485,7 +527,7 @@ class CommandUploadQuartus(CommandUpload, ToolQuartus):
         self.args.update({
             'sof-file': "",
             'cable': "1",
-            'device': "1", 
+            'device': "1",
             'list-cables': False,
             'list-devices': False,
             'list-sof-files': False,

{opencos_eda-0.2.53 → opencos_eda-0.2.54}/opencos/tools/questa.py

@@ -101,22 +101,11 @@ class CommandSimQuesta(CommandSim, ToolQuesta):
         self.vlog_commands = self.get_compile_command_lists()
         self.vopt_commands = self.get_elaborate_command_lists()
         self.vsim_commands = self.get_simulate_command_lists()
-
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='compile.sh',
-                                      command_lists=self.vlog_commands)
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='elaborate.sh',
-                                      command_lists=self.vopt_commands)
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='simulate.sh',
-                                      command_lists=self.vsim_commands)
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='all.sh',
-                                      command_lists = [
-                                          ['./pre_compile_dep_shell_commands.sh'],
-                                          ['./compile.sh'],
-                                          ['./elaborate.sh'],
-                                          ['./simulate.sh'],
-                                      ])
-
-        self.write_eda_config_and_args()
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=self.vlog_commands,
+            elaborate_lists=self.vopt_commands,
+            simulate_lists=self.vsim_commands
+        )
 
     def compile(self):
         if self.args['stop-before-compile']: