opencos-eda 0.2.28__py3-none-any.whl → 0.2.32__py3-none-any.whl

opencos/tests/helpers.py

@@ -11,6 +11,19 @@ from contextlib import redirect_stdout, redirect_stderr
 from opencos import eda, util
 from opencos import deps_schema
 
+def can_run_eda_command(*commands, config: dict) -> bool:
+    '''Returns True if we have any installed tool that can run: eda <command>'''
+    runnable = []
+    for command in list(commands):
+        handler = config['command_handler'].get(command, None)
+        if not handler:
+            return False
+        if handler and getattr(handler, 'CHECK_REQUIRES', []):
+            if not all(isinstance(handler, x) for x in getattr(handler, 'CHECK_REQUIRES', [])):
+                return False
+        runnable.append(True)
+    return runnable and all(runnable)
+
 def chdir_remove_work_dir(startpath, relpath):
     '''Changes dir to startpath/relpath, removes the work directories (eda.work, eda.export*)'''
     os.chdir(os.path.join(startpath, relpath))
@@ -125,6 +138,10 @@ class Helpers:
         if logfile is None:
             logfile = self.DEFAULT_LOG
         rc = 50
+
+        # TODO(drew): There are some issues with log_it redirecting stdout from vivado
+        # and modelsim_ase. So this may not work for all tools, you may have to directly
+        # look at eda.work/{target}.sim/sim.log or xsim.log.
         with open(logfile, 'w', encoding='utf-8') as f:
             with redirect_stdout(f):
                 with redirect_stderr(f):
@@ -135,41 +152,52 @@ class Helpers:
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 
-    def is_in_log(self, *want_str, logfile=None):
+    def is_in_log(self, *want_str, logfile=None, windows_path_support=False):
         '''Check if any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line or \
+                   (windows_path_support and want_str1 in line):
                     return True
         return False
 
-    def get_log_lines_with(self, *want_str, logfile=None):
+    def get_log_lines_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of want_str args are in the logfile, or self.DEFAULT_LOG'''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
+                    ret_list.append(line)
+                elif windows_path_support and want_str1 in line:
                     ret_list.append(line)
         return ret_list
 
-    def get_log_words_with(self, *want_str, logfile=None):
+    def get_log_words_with(self, *want_str, logfile=None, windows_path_support=False):
         '''gets all log lines with any of *want_str within a single word
         in the logfile or self.DEFAULT_LOG
         '''
         if logfile is None:
             logfile = self.DEFAULT_LOG
         ret_list = []
-        want_str = ' '.join(list(want_str))
+        want_str0 = ' '.join(list(want_str))
+        want_str1 = want_str0.replace('/', '\\')
         with open(logfile, encoding='utf-8') as f:
             for line in f.readlines():
-                if want_str in line:
+                if want_str0 in line:
                     for word in line.split():
-                        if want_str in word:
+                        if want_str0 in word:
                             ret_list.append(word)
+                elif windows_path_support and want_str1 in line:
+                    for word in line.split():
+                        if want_str1 in word:
+                            ret_list.append(word)
+
         return ret_list

opencos/tests/test_deps_helpers.py

@@ -6,9 +6,53 @@
 # TODO(drew): for now, ignore long lines and docstrings
 # pylint: disable=line-too-long,missing-function-docstring
 
+from pathlib import Path
 import os
-
-from opencos import deps_helpers
+import pytest
+
+from opencos import eda_tool_helper, deps_helpers
+
+THISPATH = os.path.dirname(__file__)
+
+# Figure out what tools the system has available, without calling eda.main(..)
+config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
+
+
+def test_get_all_targets():
+    '''Makes sure that deps_helpers.get_all_targets(filter_str:str) works'''
+
+    targets = deps_helpers.get_all_targets(
+        dirs=[
+            str(Path('../../lib/tests')),
+            str(Path('../../lib/rams/tests')),
+        ],
+        base_path=str(Path(THISPATH)),
+        filter_str='*test',
+    )
+    print(f'{targets=}')
+    assert str(Path('../../lib/rams/tests/oclib_ram2rw_test')) in targets
+    assert str(Path('../../lib/tests/oclib_fifo_test')) in targets
+    for t in targets:
+        assert t.endswith('test'), f'target {t} filter did not work *test'
+
+
+@pytest.mark.skipif(
+    not('vivado' in tools_loaded or
+        'verilator' in tools_loaded),
+    reason="requires vivado or verilator"
+)
+def test_get_all_targets_eda_multi():
+    '''Makes sure that deps_helpers.get_all_targets(filter_using_mult:str) works'''
+
+    targets = deps_helpers.get_all_targets(
+        base_path=THISPATH,
+        filter_using_multi='sim ../../lib/tests/*test ../../lib/rams/tests/*test',
+    )
+    print(f'{targets=}')
+    assert '../../lib/rams/tests/oclib_ram2rw_test' in targets
+    assert '../../lib/tests/oclib_fifo_test' in targets
+    for t in targets:
+        assert t.endswith('test'), f'target {t} filter did not work *test'
 
 
 def test_parse_deps_shell_str__no_parse():

opencos/tests/test_eda.py

@@ -24,15 +24,22 @@ from opencos.tests.helpers import eda_wrap, eda_sim_wrap, eda_elab_wrap, \
     Helpers
 
 
-thispath = os.path.dirname(__file__)
+THISPATH = os.path.dirname(__file__)
 
 def chdir_remove_work_dir(relpath):
     '''Changes dir to relpath, removes the work directories (eda.work, eda.export*)'''
-    return helpers.chdir_remove_work_dir(thispath, relpath)
+    return helpers.chdir_remove_work_dir(THISPATH, relpath)
 
 # Figure out what tools the system has available, without calling eda.main(..)
 config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
 
+def can_run_eda_sim() -> bool:
+    '''Returns True if we have any installed tool that can run: eda sim'''
+    return helpers.can_run_eda_command('sim', config=config)
+
+def can_run_eda_elab() -> bool:
+    '''Returns True if we have any installed tool that can run: eda elab'''
+    return helpers.can_run_eda_command('elab', config=config)
 
 @pytest.mark.skipif(
     'verilator' not in tools_loaded and 'vivado' not in tools_loaded,
@@ -112,7 +119,7 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
         print(f'{rc=}')
         assert rc == 0
 
-        os.chdir(os.path.join(thispath, '../../lib/tests/eda.work/oclib_fifo_test.sim'))
+        os.chdir(os.path.join(THISPATH, '../../lib/tests/eda.work/oclib_fifo_test.sim'))
         res = subprocess.run(
             [ './lint_only.sh' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             check=True
@@ -391,18 +398,19 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
 
 
 class TestMissingDepsFileErrorMessages(Helpers):
-    '''Test for missing DEPS.yml file'''
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'no_deps_here', 'empty')
+    '''Test for missing DEPS.yml file, using 'eda export' to avoid tools.'''
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'no_deps_here', 'empty')
     DEFAULT_LOG = 'eda.log'
 
     def test_bad0(self):
         '''Looks for target_bad0, but there is no DEPS file in .'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad0')
+        rc = self.log_it(command_str='export target_bad0')
         assert rc != 0
         assert self.is_in_log(
             'Trying to resolve command-line target=./target_bad0: was not found',
-            'in deps_file=None, possible targets in deps file = []'
+            'in deps_file=None, possible targets in deps file = []',
+            windows_path_support=True
         )
 
 
@@ -413,35 +421,35 @@ class TestDepsResolveErrorMessages(Helpers):
     or other less helpful information to the user. This confirms that file/target/
     linenumber information is printed when available.'''
 
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'error_msgs')
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'error_msgs')
     DEFAULT_LOG = 'eda.log'
 
     # files foo.sv, foo2.sv, target_bad0.sv, and target_bad1.sv exist.
     # files missing*.sv and targets missing* do not exist.
-    # These all run elab targets.
+    # These all "export" targets, to avoid requiring an installed tool (for example, to elab)
 
     def test_good0(self):
         '''Simple test with good target (foo)'''
         self.chdir()
-        rc = self.log_it('elab foo')
+        rc = self.log_it('export foo')
         assert rc == 0
 
     def test_good1(self):
         '''Simple test with good target (foo2)'''
         self.chdir()
-        rc = self.log_it('elab foo2')
+        rc = self.log_it('export foo2')
         assert rc == 0
 
     def test_good2(self):
         '''Simple test with good target (foo + top=foo using deps str)'''
         self.chdir()
-        rc = self.log_it('elab target_good2')
+        rc = self.log_it('export target_good2')
         assert rc == 0
 
     def test_good3(self):
         '''Simple test with good target (foo2 + top=foo2 using deps list)'''
         self.chdir()
-        rc = self.log_it('elab target_good3')
+        rc = self.log_it('export target_good3')
         assert rc == 0
 
     # Bit of a change-detector-test here, but I want to make sure the
@@ -449,133 +457,146 @@ class TestDepsResolveErrorMessages(Helpers):
     def test_bad0(self):
         '''Tests missing file in DEPS target using implicit deps str style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad0')
+        rc = self.log_it(command_str='export target_bad0')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing0.sv (file?): called from ./DEPS.yml::target_bad0::line=20,",
-            "File=missing0.sv not found in directory=."
+            "File=missing0.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad1(self):
         '''Tests missing file in DEPS target using implicit deps list style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad1')
+        rc = self.log_it(command_str='export target_bad1')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing1.sv (file?): called from ./DEPS.yml::target_bad1::line=24,",
-            "File=missing1.sv not found in directory=."
+            "File=missing1.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad2(self):
         '''Tests missing file in DEPS target using deps as str style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad2')
+        rc = self.log_it(command_str='export target_bad2')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing2.sv (file?): called from ./DEPS.yml::target_bad2::line=28,",
-            "File=missing2.sv not found in directory=."
+            "File=missing2.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad3(self):
         '''Tests missing file in DEPS target using deps as list style'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad3')
+        rc = self.log_it(command_str='export target_bad3')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing3.sv (file?): called from ./DEPS.yml::target_bad3::line=33,",
-            "File=missing3.sv not found in directory=."
+            "File=missing3.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_bad4(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), explicit deps str'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad4')
+        rc = self.log_it(command_str='export target_bad4')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target4: called from ./DEPS.yml::target_bad4::line=39,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_bad5(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), explicit deps list'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad5')
+        rc = self.log_it(command_str='export target_bad5')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target5: called from ./DEPS.yml::target_bad5::line=43,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_bad6(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), deps str'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad6')
+        rc = self.log_it(command_str='export target_bad6')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target6: called from ./DEPS.yml::target_bad6::line=47,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
+
         )
 
     def test_bad7(self):
         '''EDA on a bad target (bad target within deps of 'target_bad4'), deps list'''
         self.chdir()
-        rc = self.log_it(command_str='elab target_bad7')
+        rc = self.log_it(command_str='export target_bad7')
         assert rc != 0
         assert self.is_in_log(
             "target=./missing_target7: called from ./DEPS.yml::target_bad7::line=52,",
-            "Target not found in deps_file=./DEPS.yml"
+            "Target not found in deps_file=./DEPS.yml",
+            windows_path_support=True
         )
 
     def test_cmd_line_good0(self):
         '''EDA w/ out DEPS, on file'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv')
+        rc = self.log_it(command_str='export foo.sv')
         assert rc == 0
 
     def test_cmd_line_good1(self):
         '''EDA w/ out DEPS, on two files'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv foo2.sv')
+        rc = self.log_it(command_str='export foo.sv foo2.sv')
         assert rc == 0
 
     def test_cmd_line_bad0(self):
         '''EDA calling a non-existent target in DEPS file'''
         self.chdir()
-        rc = self.log_it(command_str='elab nope_target0')
+        rc = self.log_it(command_str='export nope_target0')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target0: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'"
+            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad1(self):
         '''EDA calling a non-existent target in DEPS file, with file that exists.'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo.sv nope_target1')
+        rc = self.log_it(command_str='export foo.sv nope_target1')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_target1: was not",
-            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'"
+            "found in deps_file=./DEPS.yml, possible targets in deps file = ['foo'",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad2(self):
         '''EDA calling a non-existent file w/out DEPS'''
         self.chdir()
-        rc = self.log_it(command_str='elab nope_file0.sv')
+        rc = self.log_it(command_str='export nope_file0.sv')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_file0.sv",
-            "(file?): File=nope_file0.sv not found in directory=."
+            "(file?): File=nope_file0.sv not found in directory=.",
+            windows_path_support=True
         )
 
     def test_cmd_line_bad3(self):
         '''EDA calling a non-existent file w/out DEPS, and a file that does exist.'''
         self.chdir()
-        rc = self.log_it(command_str='elab foo2.sv nope_file1.sv')
+        rc = self.log_it(command_str='export foo2.sv nope_file1.sv')
         assert rc != 0
         assert self.is_in_log(
             "Trying to resolve command-line target=./nope_file1.sv",
-            "(file?): File=nope_file1.sv not found in directory=."
+            "(file?): File=nope_file1.sv not found in directory=.",
+            windows_path_support=True
         )
 
 
@@ -599,6 +620,8 @@ class TestsRequiresIVerilog(Helpers):
         print(f'{rc=}')
         assert rc == 0
 
+
+@pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
 class TestDepsReqs:
     '''Tests for 'reqs' in the DEPS files. 'reqs' are requirements, like a .pcap or file
     used by SV $readmemh. They do not fit into normal compilable files (.sv, .v, .vhd[l])
@@ -647,6 +670,7 @@ class TestDepsReqs:
         assert rc != 0
 
 
+@pytest.mark.skipif(not can_run_eda_sim(), reason='no tool found to handle command: sim')
 def test_deps_command_order():
     '''Test for various "commands" within a DEPS target. This test checks that command
     order is preserved in the top-to-bottom deps order, meaning that eda.py has to collect
@@ -684,7 +708,7 @@ def test_deps_command_order():
     # Added check, we redirected to create eda.log earlier to confirm the targets worked,
     # but as a general eda.py check, all shell commands should create their own
     # {target}__shell_0.log file:
-    work_dir = os.path.join(thispath, 'deps_files/command_order', 'eda.work', 'target_test.sim')
+    work_dir = os.path.join(THISPATH, 'deps_files/command_order', 'eda.work', 'target_test.sim')
     with open(os.path.join(work_dir, 'target_echo_hi__shell_0.log'), encoding='utf-8') as f:
         text = ''.join(f.readlines()).strip()
         assert text == 'hi'
@@ -776,7 +800,7 @@ class TestDepsNoFilesTargets(Helpers):
 
 class TestDepsTags(Helpers):
     '''Series of tests for DEPS - target - tags, in ./deps_files/tags_with_tools'''
-    DEFAULT_DIR = os.path.join(thispath, 'deps_files', 'tags_with_tools')
+    DEFAULT_DIR = os.path.join(THISPATH, 'deps_files', 'tags_with_tools')
     DEFAULT_LOG = 'eda.log'
 
     @pytest.mark.skipif('verilator' not in tools_loaded, reason="requires verilator")

opencos/tests/test_tools.py

@@ -3,6 +3,7 @@
 # pylint: disable=R0801 # (similar lines in 2+ files)
 
 import os
+import sys
 import pytest
 
 from opencos import eda, util, eda_tool_helper, eda_base
@@ -29,7 +30,15 @@ def test_tools_loaded():
     '''
     assert config
     assert len(config.keys()) > 0
-    assert len(tools_loaded) > 0
+
+    # It's possible we're running in some container or install that has no tools, for example,
+    # Windows.
+    if sys.platform.startswith('win') and \
+       not helpers.can_run_eda_command('elab', 'sim', config=config):
+        # Windows, not handlers for elab or sim:
+        pass
+    else:
+        assert len(tools_loaded) > 0
 
     def version_checker(
             obj: eda_base.Tool, chk_str: str
@@ -95,7 +104,7 @@ def test_err_fatal(command, tool, target, sim_expect_pass):
 
 
 @pytest.mark.skipif('vivado' not in tools_loaded, reason="requires vivado")
-def test_vivado_xilinx_arg():
+def test_vivado_tool_defines():
     '''This test attempts to confirm that the following class inheritance works:
 
     Command <- CommandDesign <- CommandSim <- CommandSimVivado <- CommandElabVivado
@@ -104,11 +113,15 @@ def test_vivado_xilinx_arg():
     correct ToolVivado.set_tool_defines() method, and that no other parent Command
     class has overriden it to defeat the defines that should be set.
 
-    We also run with arg --xilinx to check that defines are set as expected.
+    We also run with an added dependency (lib_ultrascale_plus_defines) to check that
+    defines are set as expected.
     '''
 
     chdir_remove_work_dir('../../lib')
-    rc = eda_wrap('elab', '--tool', 'vivado', '--xilinx', 'oclib_fifo')
+    rc = eda_wrap(
+        'elab', '--tool', 'vivado', 'third_party/vendors/xilinx/lib_ultrascale_plus_defines',
+        'oclib_fifo'
+    )
     assert rc == 0
 
     # Confirm that args and defines we expected to be set are set.
@@ -122,13 +135,8 @@ def test_vivado_xilinx_arg():
     assert 'config' in data
     assert 'eda_original_args' in data['config']
     assert 'oclib_fifo' in data['config']['eda_original_args']
-    assert '--xilinx' in data['config']['eda_original_args']
     assert data.get('target', '') == 'oclib_fifo'
 
-    assert 'xilinx' in data['args']
-    assert 'xilinx' in data['modified_args']
-    assert data['args']['xilinx'] is True
-    assert data['modified_args']['xilinx'] is True
 
     # This checks opencos.tools.vivado.ToolVivado.set_tool_defines():
     # We ran with --xilinx, so we expect certain defines to be set, others not to be set.

opencos/tools/iverilog.py

@@ -78,8 +78,6 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
     # We do not override CommandSim.do_it()
     def prepare_compile(self):
         self.set_tool_defines()
-        if self.args['xilinx']:
-            self.error('Error: --xilinx with Iverilog is not yet supported', do_exit=False)
 
         self.iverilog_command_lists = self.get_compile_command_lists()
         self.iverilog_exec_command_lists  = self.get_simulate_command_lists()

opencos/tools/modelsim_ase.py

@@ -53,8 +53,6 @@ class CommandSimModelsimAse(CommandSim, ToolModelsimAse):
         self.set_tool_defines()
         self.write_vlog_dot_f()
         self.write_vsim_dot_do(dot_do_to_write='all')
-        if self.args['xilinx']:
-            self.error('Error: --xilinx with Modelsim ASE is not yet supported', do_exit=False)
 
         vsim_command_lists = self.get_compile_command_lists()
         util.write_shell_command_file(
@@ -161,9 +159,17 @@ class CommandSimModelsimAse(CommandSim, ToolModelsimAse):
             if v is None:
                 vlog_dot_f_lines += [ f'+define+{k}' ]
             else:
-                # Generally we should only support int and str python types passed as
-                # +define+{k}={v}, but also for SystemVerilog plusargs
-                vlog_dot_f_lines += [ f'+define+{k}={sanitize_defines_for_sh(v)}' ]
+
+                # if the value v is a double-quoted string, such as v='"hi"', the
+                # entire +define+NAME="hi" needs to wrapped in double quotes with the
+                # value v double-quotes escaped: "+define+NAME=\"hi\""
+                if isinstance(v, str) and v.startswith('"') and v.endswith('"'):
+                    str_v = v.replace('"', '\\"')
+                    vlog_dot_f_lines += [ f'"+define+{k}={str_v}"' ]
+                else:
+                    # Generally we should only support int and str python types passed as
+                    # +define+{k}={v}, but also for SystemVerilog plusargs
+                    vlog_dot_f_lines += [ f'+define+{k}={sanitize_defines_for_sh(v)}' ]
 
 
         vlog_dot_f_lines += self.args['compile-args']

opencos/tools/questa.py

@@ -30,7 +30,6 @@ class ToolQuesta(Tool):
 
     def __init__(self, config: dict):
         super().__init__(config=config)
-        self.args['xilinx'] = False
         self.args['part'] = 'xcu200-fsgd2104-2-e'
 
     def get_versions(self) -> str:
@@ -65,12 +64,6 @@ class ToolQuesta(Tool):
         # i.e. has self.defines
         self.defines['OC_TOOL_QUESTA'] = None
         self.defines[f'OC_TOOL_QUESTA_{self.questa_major:d}_{self.questa_minor:d}'] = None
-        if self.args['xilinx']:
-            self.defines['OC_LIBRARY_ULTRASCALE_PLUS'] = None
-            self.defines['OC_LIBRARY'] = "1"
-        else:
-            self.defines['OC_LIBRARY_BEHAVIORAL'] = None
-            self.defines['OC_LIBRARY'] = "0"
 
 class CommandSimQuesta(CommandSim, ToolQuesta):
     '''Command handler for: eda sim --tool=questa.'''
@@ -115,12 +108,14 @@ class CommandSimQuesta(CommandSim, ToolQuesta):
         for f in self.files_sv:
             command_list += [ f ]
 
-        if self.args['xilinx']:
-            vivado_base_path = getattr(self, 'vivado_base_path', '')
-            glbl_v = vivado_base_path.replace('bin', 'data/verilog/src/glbl.v')
-            if not os.path.exists(glbl_v):
-                self.error(f"Vivado is not setup, could not find file {glbl_v=}")
-            command_list.append(glbl_v)
+        # TODO(drew): We don't natively support Xilinx Ultrascale+ glbl.v in questa yet.
+        # To do so, would need to do something along the lines of:
+        # if using_queta_and_xilinx_libs:
+        #     vivado_base_path = getattr(self, 'vivado_base_path', '')
+        #     glbl_v = vivado_base_path.replace('bin', 'data/verilog/src/glbl.v')
+        #     if not os.path.exists(glbl_v):
+        #         self.error(f"Vivado is not setup, could not find file {glbl_v=}")
+        #     command_list.append(glbl_v)
 
         # misc options
         command_list += [ '-top', self.args['top'], '-timescale', '1ns/1ps', '-work', 'work.lib']
@@ -148,12 +143,12 @@ class CommandSimQuesta(CommandSim, ToolQuesta):
 
         if util.args['verbose']:
             command_list += ['-verbose']
-        if self.args['xilinx']:
-            # this will need some work
-            self.error("NOT YET SUPPORTED, arg --xilinx set with Questa", do_exit=False)
-            # TODO(drew): to get this to work, need to add this, among other items:
-            # --> command_list += '''-L xil_defaultlib -L unisims_ver -L unimacro_ver
-            #                        -L xpm -L secureip -L xilinx_vip'''.split(" ")
+
+        # TODO(drew): We don't natively support Xilinx Ultrascale+ libraries in --tool=questa
+        # with an easy hook (like --xilinx) but we could?
+        # To get this to work, need to add this, among other items:
+        # --> command_list += '''-L xil_defaultlib -L unisims_ver -L unimacro_ver
+        #                        -L xpm -L secureip -L xilinx_vip'''.split(" ")
 
         # check if we're bailing out early
         if self.args['stop-after-elaborate']:

opencos/tools/verilator.py

@@ -107,8 +107,6 @@ class VerilatorSim(CommandSim, ToolVerilator):
     # We do not override CommandSim.do_it()
     def prepare_compile(self):
         self.set_tool_defines()
-        if self.args['xilinx']:
-            self.error('Error: --xilinx with Verilator is not yet supported', do_exit=False)
 
         # If there are C++ files here, then we will run Verilator in --cc mode:
         if self.files_cpp: