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

opencos/commands/deps_help.py

@@ -10,32 +10,37 @@ it is generally run as simply
 uses no tools and will print a help text regarding DEPS markup files to stdout.
 '''
 
+# pylint: disable=line-too-long
 
 import os
 
 from opencos.eda_base import Command
 from opencos import util
+from opencos.util import Colors
 
 
-BASIC_DEPS_HELP = '''
+BASIC_DEPS_HELP = f'''
+{Colors.yellow}
+Note: you can run with one of: {Colors.cyan}--verbose, --help, --debug{Colors.yellow} to show full
+schema supported, or {Colors.cyan}--no-color{Colors.yellow} to avoid printing this text with colors.
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
-  What is a DEPS.yml file and why does `eda` use this?
-  - DEPS.yml is a fancy filelist.
+  What is a {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} file and why does `eda` use this?
+  - {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} is a fancy filelist.
   - Used to organize a project into "targets", a tool can run on a "target".
   - Allows for more than just source files attached to a "target".
     -- incdirs, defines, and args can be applied to a "target".
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
   Hello World example:
 
-  The following example is a DEPS.yml file example for a SystemVerilog simulation of
-  hello_world_tb.sv. DEPS.yml is, in short, a fancy filelist. We use them in the `eda`
+  The following example is a {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} file example for a SystemVerilog simulation of
+  hello_world_tb.sv. {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} is, in short, a fancy filelist. We use them in the `eda`
   app to organize projects.
 
---- DEPS.yml: ---
+--- {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 hello-world:           # <-- this is a named target that will be run
 
@@ -64,20 +69,20 @@ endmodule : hello_world_tb
 
 
   hello-world:
-    The target name in the DEPS.yml we named is hello-world. That is a valid target
+    The target name in the {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} we named is hello-world. That is a valid target
     that `eda` can use. Such as:
 
        eda sim --tool=verilator hello-world
 
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
    Beyond Hello World example:
 
    The following example is a DEPS.yml file for a more complex module simulation.
    It has two files in ./DEPS.yml and ./lib/DEPS.yml.
 
---- ./DEPS.yml: ---
+--- {Colors.byellow}./DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 my_fifo:                         # <-- this is a design
   incdirs: . lib                 # <-- 'incdirs' define the paths searched to find `include files
@@ -102,7 +107,7 @@ my_fifo_stress_test:             # <-- this is another TEST
   deps:
     - my_fifo_test               # aside from the define, this is same as "my_fifo_test"
 
---- lib/DEPS.yml: ---
+--- {Colors.byellow}lib/DEPS.yml{Colors.normal}{Colors.yellow}: ---
 
 lib_pkg:                         # <-- this is a package required by bin_to_gray below
   deps:
@@ -115,15 +120,15 @@ bin_to_gray:                     # <-- this is the target that was required by .
                                  # to be read before the code that uses them
     - bin_to_gray.sv             # an SV module pulled in directly
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 '''
 
 
-FULL_DEPS_HELP = '''
+FULL_DEPS_HELP = f'''
 
---------------------------------------------------------------------
+{Colors.green}--------------------------------------------------------------------{Colors.yellow}
 
-   Full DEPS.yml schema:
+   Full {Colors.byellow}DEPS.yml{Colors.normal}{Colors.yellow} schema:
 
 ```
 DEFAULTS: # <table> defaults applied to ALL targets in this file, local targets ** override ** the defaults.
@@ -140,6 +145,14 @@ target-spec:
     SOME_DEFINE: value
     SOME_DEFINE_NO_VALUE:   # we just leave this blank, or use nil (yaml's None)
 
+  plusargs: # <table>
+    variable0: value
+    variable1:              # blank for no value, or use nil (yaml's None)
+
+  parameters: # <table>
+    SomeParameter: value
+    SOME_OTHER_PARAMETER: value
+
   incdirs: # <array>
     - some/relative/path
 
@@ -150,20 +163,22 @@ target-spec:
     - some_file.sv               # <string> aka, a file
     - sv@some_file.txt           # <string> aka, ext@file where we'd like a file not ending in .sv to be
                                  # treated as a .sv file for tools.
-                                 # Supported for sv@, v@, vhdl@, cpp@
+                                 # Supported for sv@, v@, vhdl@, cpp@, sdc@, f@, py@, makefile@
     - commands:                  # <table> with key 'commands' for a <array>:  support for built-in commands
                                  # Note this cannot be confused for other targets or files.
       - shell: # <string>
-        var-subst-args: # <bool> default false. If true, substitute vars in commands, such as {fpga}
-                        # substituted from eda arg --fpga=SomeFpga, such that {fpga} becomes SomeFpga
+        var-subst-args: # <bool> default false. If true, substitute vars in commands, such as {{fpga}}
+                        # substituted from eda arg --fpga=SomeFpga, such that {{fpga}} becomes SomeFpga
         var-subst-os-env:  #<bool> default false. If true, substitute vars in commands using os.environ vars,
-                           # such as {FPGA} could get substituted by env value for $FPGA
-        tee: # <string> optional filename, otherwise shell commands write to {target-spec}__shell_0.log
+                           # such as {{FPGA}} could get substituted by env value for $FPGA
+        tee: # <string> optional filename, otherwise shell commands write to {{target-spec}}__shell_0.log
         run-from-work-dir: #<bool> default true. If false, runs from the directory of this DEPS file.
         filepath-subst-target-dir: #<bool> default true. If false, disables shell file path
 	                               substituion on this target's directory (this DEPS file dir).
         dirpath-subst-target-dir: #<bool> default false. If true, enables shell directory path
 	                              substituion on this target's directory (this DEPS file dir).
+        run-after-tool: # <bool> default false. Set to true to run after any EDA tools, or
+	                any command handlers have completed.
       - shell: echo "Hello World!"
       - work-dir-add-sources: # <array or | space separated string>, this is how to add generated files
                               # to compile order list.
@@ -196,6 +211,8 @@ target-spec:
     args: # <array or | space separated string>
     deps: # <array or | space separated string> # Note: not implemented yet
     defines: ## <table>
+    plusargs: ## <table>
+    parameters: ## <table>
     incdirs: ## <array>
 
   tags: # <table> this is the currently support tags features in a target.
@@ -215,6 +232,8 @@ target-spec:
                                           # tool in 'with-tools'.
       deps: <array or | space separated string, applied with tag>
       defines: <table, applied with tag>
+      plusargs: <table, applied with tag>
+      parameters: <table, applied with tag>
       incdirs: <array, applied with tag>
       replace-config-tools: <table>  # spec matching eda_config_defaults.yml::tools.<tool> (replace merge strategy)
       additive-config-tools: <table> # spec matching eda_config_defaults.yml::tools.<tool> (additive merge strategy)

opencos/commands/sim.py

@@ -300,7 +300,6 @@ class CommandSim(CommandDesign): # pylint: disable=too-many-public-methods
         tool = self.args.get('tool', None)
         # Certain args are allow-listed here
         deps_file_args = []
-        print(f'SUPER DREW DEBUG: {self.get_command_line_args()=}')
         for a in self.get_command_line_args():
             if any(a.startswith(x) for x in [
                     '--compile-args',

opencos/deps/deps_file.py

@@ -16,7 +16,7 @@ from opencos.util import debug, error
 from opencos.utils.markup_helpers import yaml_safe_load, toml_load_only_root_line_numbers, \
     markup_writer, markup_dumper
 from opencos.utils.str_helpers import fnmatch_or_re, dep_str2list, pretty_list_columns_manual, \
-    is_valid_target_name, VALID_TARGET_INFO_STR
+    is_valid_target_name, VALID_TARGET_INFO_STR, get_shorter_path_str_rel_vs_abs
 from opencos.utils.subprocess_helpers import subprocess_run_background
 from opencos.utils.status_constants import EDA_DEPS_FILE_NOT_FOUND, EDA_DEPS_TARGET_NOT_FOUND
 
@@ -270,9 +270,12 @@ class DepsFile:
         return f'line={self.line_numbers.get(target_node, "")}'
 
     def gen_caller_info(self, target: str) -> str:
-        '''Given a full target name (path/to/my_target) return caller_info str for debug'''
+        '''Given a full target name (path/to/my_target) return caller_info str for debug
+
+        Use abspath if the str is shorter, for the path information part.
+        '''
         return '::'.join([
-            self.rel_deps_file,
+            get_shorter_path_str_rel_vs_abs(rel_path=self.rel_deps_file),
             target,
             self.get_approx_line_number_str(target)
         ])
@@ -298,90 +301,90 @@ class DepsFile:
         some caller_info(str). This is more useful for YAML or TOML markup where we have
         caller_info.
         '''
-        if target_node not in self.data:
-            found_target = False
 
-            if target_node.startswith('-'):
-                # likely an unparsed arg that made it this far.
-                util.warning(f"Ignoring unparsed argument '{target_node}'")
-                return False
+        if target_node in self.data:
+            debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
+            return True
 
-            # For error printing, prefer relative paths:
-            if self.target_path:
-                t_path = os.path.relpath(self.target_path) + os.path.sep
-            else:
-                t_path = ''
-            t_node = target_node
-            t_full = os.path.join(t_path, t_node)
+        if target_node.startswith('-'):
+            # likely an unparsed arg that made it this far.
+            util.warning(f"Ignoring unparsed argument '{target_node}'")
+            return False
 
-            if not is_valid_target_name(target_node):
-                util.warning(
-                    f"In file {self.rel_deps_file}, {target_node} {VALID_TARGET_INFO_STR}"
-                )
+        # For error printing, prefer relative paths, unless the abspath is shorter:
+        if self.target_path:
+            t_path = os.path.relpath(self.target_path) + os.path.sep
+            t_path = get_shorter_path_str_rel_vs_abs(rel_path=t_path)
+        else:
+            t_path = ''
+        t_node = target_node
+        t_full = os.path.join(t_path, t_node)
 
-            if not caller_info:
-                # If we don't have caller_info, likely came from command line (or DEPS JSON data):
-                if '.' in target_node:
-                    # Likely a filename (target_node does not include path)
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full} (file?):',
-                        f'File={t_node} not found in directory={t_path}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                elif not self.rel_deps_file:
-                    # target, but there's no DEPS file
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full}:',
-                        f'but path {t_path} has no DEPS markup file (DEPS.yml)',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                else:
-                    self.warning_show_available_targets()
-                    self.error_ifarg(
-                        f'Trying to resolve command-line target={t_full}:',
-                        f'was not found in deps_file={self.rel_deps_file}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_TARGET_NOT_FOUND
-                    )
+        if not is_valid_target_name(target_node):
+            util.warning(
+                f"In file {self.rel_deps_file}, {target_node} {VALID_TARGET_INFO_STR}"
+            )
 
+        if not caller_info:
+            # If we don't have caller_info, likely came from command line (or DEPS JSON data):
+            if '.' in target_node:
+                # Likely a filename (target_node does not include path)
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full} (file?):',
+                    f'File={t_node} not found in directory={t_path}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            elif not self.rel_deps_file:
+                # target, but there's no DEPS file
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full}:',
+                    f'but path {t_path} has no DEPS markup file (DEPS.yml)',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
             else:
-                # If we have caller_info, then this was a recursive call from another
-                # DEPS file. It should already have the useful error messaging:
-
-                if '.' in target_node:
-                    # Likely a filename (target_node does not include path)
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full} (file?):',
-                        f'called from {caller_info},',
-                        f'File={t_node} not found in directory={t_path}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                elif not self.rel_deps_file:
-                    # target, but there's no DEPS file
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full}:',
-                        f'called from {caller_info},',
-                        f'but {t_path} has no DEPS markup file (DEPS.yml)',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_FILE_NOT_FOUND
-                    )
-                else:
-                    self.warning_show_available_targets()
-                    self.error_ifarg(
-                        f'Trying to resolve target={t_full}:',
-                        f'called from {caller_info},',
-                        f'Target not found in deps_file={self.rel_deps_file}',
-                        arg='error-unknown-args',
-                        error_code=EDA_DEPS_TARGET_NOT_FOUND
-                    )
+                self.warning_show_available_targets()
+                self.error_ifarg(
+                    f'Trying to resolve command-line target={t_full}:',
+                    f'was not found in deps_file={self.rel_deps_file}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_TARGET_NOT_FOUND
+                )
+
         else:
-            debug(f'Found {target_node=} in deps_file={self.rel_deps_file}')
-            found_target = True
+            # If we have caller_info, then this was a recursive call from another
+            # DEPS file. It should already have the useful error messaging:
+
+            if '.' in target_node:
+                # Likely a filename (target_node does not include path)
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full} (file?):',
+                    f'called from {caller_info},',
+                    f'File={t_node} not found in directory={t_path}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            elif not self.rel_deps_file:
+                # target, but there's no DEPS file
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full}:',
+                    f'called from {caller_info},',
+                    f'but {t_path} has no DEPS markup file (DEPS.yml)',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_FILE_NOT_FOUND
+                )
+            else:
+                self.warning_show_available_targets()
+                self.error_ifarg(
+                    f'Trying to resolve target={t_full}:',
+                    f'called from {caller_info},',
+                    f'Target not found in deps_file={self.rel_deps_file}',
+                    arg='error-unknown-args',
+                    error_code=EDA_DEPS_TARGET_NOT_FOUND
+                )
 
-        return found_target
+        return False
 
 
     def get_entry(self, target_node) -> dict:

opencos/eda.py

@@ -204,9 +204,12 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         has_all_exe = True
         has_all_in_exe_path = True
+        exe_path = None
         for exe in exe_list:
             assert exe != '', f'{name=} {value=} value missing "exe" {exe=}'
             p = shutil.which(exe)
+            if not exe_path:
+                exe_path = p # set on first required exe
             if not p:
                 has_all_exe = False
                 util.debug(f"... No, missing exe {exe}")
@@ -217,10 +220,11 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         has_vsim_helper = True
         if value.get('requires_vsim_helper', False):
-            # This tool name must be in opencos.utils.vsim_helper.TOOL_IS[name].
+            # This tool name must be in opencos.utils.vsim_helper.TOOL_PATH[name].
             # Special case for vsim being used by a lot of tools.
             vsim_helper.init() # only runs checks once internally
-            has_vsim_helper = vsim_helper.TOOL_IS.get(name, False)
+            exe_path = vsim_helper.TOOL_PATH[name]
+            has_vsim_helper = bool(exe_path)
 
         has_vscode_helper = True
         needs_vscode_extensions = value.get('requires_vscode_extension', None)
@@ -254,18 +258,24 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
 
         if all((has_all_py, has_all_env, has_all_exe, has_all_in_exe_path,
                 has_vsim_helper, has_vscode_helper)):
-            exe = exe_list[0]
-            p = shutil.which(exe)
-            config['auto_tools_found'][name] = exe # populate key-value pairs w/ first exe in list
+            if exe_path:
+                p = exe_path
+            else:
+                p = shutil.which(exe_list[0])
+            config['auto_tools_found'][name] = p # populate key-value pairs w/ first exe in list
             if not quiet:
                 util.info(f"Detected {name} ({p})")
-            tool_setup(tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config)
+            tool_setup(
+                tool=name, quiet=True, auto_setup=True, warnings=warnings, config=config
+            )
 
     return config
 
 
-def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool = False,
-               warnings: bool = True):
+def tool_setup(
+        tool: str, config: dict, quiet: bool = False, auto_setup: bool = False,
+        warnings: bool = True
+):
     ''' Adds items to config["tools_loaded"] (set) and updates config['command_handler'].
 
     config is potentially updated for entry ['command_handler'][command] with a Tool class.
@@ -613,9 +623,36 @@ def main(*args):
     util.global_log.stop()
     return main_ret
 
+def main_show_autocomplete_instructions() -> None:
+    ''' Executable script entry point - eda_show_autocomplete
+
+    from pyproject.toml::project.scripts. Shows instructions on how to enable bash autocomplete
+    '''
+    source_filepath = opencos.__file__.replace(
+        '__init__.py', 'eda_deps_bash_completion.bash'
+    )
+    if os.path.exists(source_filepath):
+        print(
+            f"{Colors.yellow}To enable bash autocompletion with"
+            f" {Colors.bold}eda{Colors.normal}{Colors.yellow} script (uv not equired):"
+        )
+        print(f"{Colors.normal}")
+        print(f"    source {source_filepath}")
+        print("")
+        print(f"{Colors.yellow}Feel free to inspect this script prior to sourcing.")
+        print(f"{Colors.normal}")
+        sys.exit(0)
+    else:
+        util.error(f"It appears the following file(s) doe not exist: {source_filepath}")
+        sys.exit(1)
+
 
 def main_cli() -> None:
-    ''' Returns None, will exit with return code. Entry point for package script or __main__.'''
+    ''' Executable script entry point - eda
+
+    from pyproject.tom::project.scripts, or from __main__.
+    Returns None, will exit with return code.
+    '''
     signal.signal(signal.SIGINT, signal_handler)
     util.global_exit_allowed = True
     # Strip eda or eda.py from sys.argv, we know who we are if called from __main__:

opencos/eda_base.py

@@ -45,6 +45,9 @@ def print_base_help() -> None:
 def print_eda_usage_line(no_targets: bool = False, command_name='COMMAND') -> None:
     '''Prints line for eda [options] COMMAND [options] FILES|TARGETS,...'''
     print(f'{safe_emoji("🔦 ")}Usage:')
+    print(f'    {Colors.bold}{Colors.yellow}eda_targets PATTERN')
+    print(f'    {Colors.bold}{Colors.yellow}eda_show_autocomplete{Colors.normal}')
+    print()
     if no_targets:
         print(
             (f'    {Colors.bold}{Colors.yellow}eda {Colors.cyan}[options]'
@@ -208,11 +211,12 @@ class Tool:
     def set_exe(self, config: dict) -> None:
         '''Sets self._EXE based on config'''
         if self._TOOL and self._TOOL in config.get('auto_tools_order', [{}])[0]:
-            exe = config.get('auto_tools_order', [{}])[0][self._TOOL].get('exe', '')
-            if exe and isinstance(exe, list):
-                exe = exe[0] # pick first
+            # config['auto_tools_found'] has the first exe full path:
+            exe = config.get('auto_tools_found', {}).get(self._TOOL)
             if exe and exe != self._EXE:
-                util.info(f'Override for {self._TOOL} using exe {exe}')
+                # Note that shutil.which() on the exe leaf may not match, this does NOT
+                # modify os.environ['PATH'].
+                util.debug(f'{self._TOOL} using exe: {exe}')
                 self._EXE = exe
 
     def get_tool_name(self) -> str:

opencos/eda_config.py

@@ -390,11 +390,18 @@ def tool_try_add_to_path( # pylint: disable=too-many-branches
         util.error(f'--tool setting for {tool}: {user_exe} is not an executable')
         return name
 
-    user_exe = shutil.which(exe)
+    user_exe = shutil.which(user_exe)
 
     if update_config:
         if isinstance(config_exe, list):
             config['auto_tools_order'][0][name]['exe'][0] = user_exe
+            for index,value in enumerate(config_exe[1:]):
+                # update all entries, if we can, if the value is also in 'path'
+                # from our set --tool=Name=path/exe
+                new_value = os.path.join(path, os.path.split(value)[1])
+                if os.path.exists(new_value) and shutil.which(new_value) and \
+                   os.access(new_value, os.X_OK):
+                    config['auto_tools_order'][0][name]['exe'][index] = new_value
         else:
             config['auto_tools_order'][0][name]['exe'] = user_exe
         util.debug(f'For {tool=}, auto_tools_order config updated')

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/tools/questa_common.py

@@ -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,7 +33,6 @@ 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:

opencos/tools/verilator.py

@@ -30,6 +30,7 @@ class ToolVerilator(Tool):
     def get_versions(self) -> str:
         if self._VERSION:
             return self._VERSION
+        # __init__ would have set self.EXE to full path.
         path = shutil.which(self._EXE)
         if not path:
             self.error(f'"{self._EXE}" not in path or not installed, see {self._URL})')

opencos/utils/str_helpers.py

@@ -203,3 +203,10 @@ def strip_ansi_color(text: str) -> str:
     '''Strip ANSI color characters from str'''
     ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
     return ansi_escape.sub('', text)
+
+def get_shorter_path_str_rel_vs_abs(rel_path: str) -> str:
+    '''Returns the shorter of relative path (input arg) vs abspath (converted)'''
+    apath = os.path.abspath(rel_path)
+    if len(apath) < len(rel_path):
+        return apath
+    return rel_path