opencos-eda 0.2.52__py3-none-any.whl → 0.2.54__py3-none-any.whl

opencos/tools/questa.py

@@ -14,7 +14,7 @@ import shutil
 
 from opencos import util
 from opencos.eda_base import Tool
-from opencos.commands import CommandSim
+from opencos.commands import CommandSim, CommandFList
 
 class ToolQuesta(Tool):
     '''Base class for CommandSimQuesta, collects version information about qrun'''
@@ -23,6 +23,7 @@ class ToolQuesta(Tool):
     _EXE = 'qrun'
 
     starter_edition = False # Aka, modelsim_ase
+    use_vopt = shutil.which('vopt') # vopt exists in qrun/vsim framework, and we'll use it.
     sim_exe = '' # vsim or qrun
     sim_exe_base_path = ''
     questa_major = None
@@ -74,126 +75,193 @@ class CommandSimQuesta(CommandSim, ToolQuesta):
         CommandSim.__init__(self, config)
         ToolQuesta.__init__(self, config=self.config)
         # add args specific to this simulator
-        self.args['gui'] = False
-        self.args['tcl-file'] = "sim.tcl"
+        self.args.update({
+            'gui': False,
+            'tcl-file': 'sim.tcl',
+            'work-lib': 'work',
+        })
+        self.args_help.update({
+            'gui': 'Run Questa in GUI mode',
+            'tcl-file': 'name of TCL file to be created for Questa simulation',
+            'work-lib': 'Questa work library name',
+        })
+
         self.shell_command = self.sim_exe # set by ToolQuesta.get_versions(self)
+        self.vlog_commands = []
+        self.vopt_commands = []
+        self.vsim_commands = []
 
     def set_tool_defines(self):
         ToolQuesta.set_tool_defines(self)
 
-    def do_it(self):
-        # add defines for this job
+    # We do not override CommandSim.do_it(), CommandSim.check_logs_for_errors(...)
+
+    def prepare_compile(self):
+        self.set_tool_defines()
+        self.vlog_commands = self.get_compile_command_lists()
+        self.vopt_commands = self.get_elaborate_command_lists()
+        self.vsim_commands = self.get_simulate_command_lists()
+        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']:
+            return
+        self.run_commands_check_logs(
+            self.vlog_commands, check_logs=True, log_filename='vlog.log'
+        )
+
+    def elaborate(self):
+        if self.args['stop-before-compile'] or self.args['stop-after-compile']:
+            return
+        self.run_commands_check_logs(
+            self.vopt_commands, check_logs=True, log_filename='vopt.log'
+        )
+
+    def simulate(self):
+        if self.args['stop-before-compile'] or self.args['stop-after-compile'] or \
+           self.args['stop-after-elaborate']:
+            return
+        self.run_commands_check_logs(
+            self.vsim_commands, check_logs=True, log_filename='vsim.log'
+        )
+
+    def get_compile_command_lists(self, **kwargs) -> list:
         self.set_tool_defines()
-        self.write_eda_config_and_args()
-
-        # it all gets done with one command
-        command_list = [ self.shell_command, "-64", "-sv" ]
-
-        # incdirs
-        for value in self.incdirs:
-            command_list += [ f"+incdir+{value}" ]
-
-        # defines
-        for key, value in self.defines.items():
-            if value is None:
-                command_list += [ f"+define+{key}" ]
-            elif isinstance(value, str) and "\'" in value:
-                command_list += [ f"\"+define+{key}={value}\"" ]
-            else:
-                command_list += [ f"\'+define+{key}={value}\'" ]
-
-        # compile verilog
-        for f in self.files_v:
-            command_list += [ f ]
-
-        # compile systemverilog
-        for f in self.files_sv:
-            command_list += [ f ]
-
-        # 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']
-        # TODO(drew): most of these should move to eda_config_defaults.yml
-        command_list += [
-            # avoid warnings about defaulting to "var" which isn't LRM behavior
-            '-svinputport=net',
-            #  Existing package 'xxxx_pkg' at line 9 will be overwritten.
-            '-suppress', 'vlog-2275',
-            #  Extra checking for conflict in always_comb and always_latch variables at vopt time
-            '-suppress', 'vlog-2583',
-            #  Missing connection for port 'xxxx' (The default port value will be used)
+        ret = []
+
+        # Create work library
+        vlib_cmd = [os.path.join(self.sim_exe_base_path, 'vlib'), self.args['work-lib']]
+        ret.append(vlib_cmd)
+
+        # Map work library
+        vmap_cmd = [os.path.join(self.sim_exe_base_path, 'vmap'), 'work', self.args['work-lib']]
+        ret.append(vmap_cmd)
+
+        # Compile files
+        if self.files_v or self.files_sv:
+            vlog_cmd = [os.path.join(self.sim_exe_base_path, 'vlog'), '-64', '-sv']
+
+            # Add include directories
+            for incdir in self.incdirs:
+                vlog_cmd += [f'+incdir+{incdir}']
+
+            # Add defines
+            for key, value in self.defines.items():
+                if value is None:
+                    vlog_cmd += [f'+define+{key}']
+                else:
+                    vlog_cmd += [f'+define+{key}={value}']
+
+            # Add suppression flags
+            vlog_cmd += [
+                '-svinputport=net',
+                '-suppress', 'vlog-2275',
+                '-suppress', 'vlog-2583',
+            ]
+
+            # Add source files
+            vlog_cmd += self.files_v + self.files_sv
+
+            ret.append(vlog_cmd)
+
+        # Compile VHDL files if any
+        if self.files_vhd:
+            vcom_cmd = [os.path.join(self.sim_exe_base_path, 'vcom'), '-64']
+            vcom_cmd += self.files_vhd
+            ret.append(vcom_cmd)
+
+        return ret
+
+    def get_elaborate_command_lists(self, **kwargs) -> list:
+        if self.args['stop-after-compile']:
+            return []
+
+        vopt_cmd = [os.path.join(self.sim_exe_base_path, 'vopt'), '-64']
+
+        # Add optimization flags
+        vopt_cmd += [
             '-suppress', 'vopt-13159',
-            #  Too few port connections for 'uAW_FIFO'.  Expected 10, found 8
             '-suppress', 'vopt-2685',
-            #  Missing connection for port 'almostEmpty' ... same message for inputs and outputs.
             '-note', 'vopt-2718',
         ]
-        if self.args['gui']:
-            command_list += ['-gui=interactive', '+acc', '-i']
-        elif self.args['waves']:
-            command_list += ['+acc', '-c']
-        else:
-            command_list += ['-c']
 
-        if util.args['verbose']:
-            command_list += ['-verbose']
+        if self.args['gui'] or self.args['waves']:
+            vopt_cmd += ['+acc']
 
-        # 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(" ")
+        # Add top module and output
+        vopt_cmd += [self.args['top'], '-o', 'opt_design']
 
-        # check if we're bailing out early
-        if self.args['stop-after-elaborate']:
-            command_list += ['-elab', 'elab.output', '-do', '"quit"' ]
+        return [vopt_cmd]
 
-        # create TCL
+    def get_simulate_command_lists(self, **kwargs) -> list:
+        # Create TCL file
         tcl_name = os.path.abspath(os.path.join(self.args['work-dir'], self.args['tcl-file']))
-        with open( tcl_name, 'w', encoding='utf-8' ) as fo:
+
+        if self.args['waves']:
+            util.artifacts.add_extension(
+                search_paths=self.args['work-dir'], file_extension='wlf',
+                typ='waveform', description='Questa Waveform WLF file'
+            )
+
+        with open(tcl_name, 'w', encoding='utf-8') as fo:
             if self.args['waves']:
                 if self.args['waves-start']:
                     print(f"run {self.args['waves-start']} ns", file=fo)
                 print("add wave -r /*", file=fo)
             print("run -all", file=fo)
-            if not self.args['gui']:
+            if self.run_in_batch_mode():
                 print("quit", file=fo)
-        command_list += ['-do', tcl_name ]
 
-        # execute snapshot
-        self.exec(self.args['work-dir'], command_list)
+        # Create vsim command
+        vsim_cmd = [os.path.join(self.sim_exe_base_path, 'vsim'), '-64']
 
-    # Note that CommandSimQuesta doesn't yet follow the framework from CommandSim.do_it()
-    # so we have to define all helper methods for pylint:
+        if not self.run_in_batch_mode():
+            vsim_cmd += ['-gui']
+        else:
+            vsim_cmd += ['-c']
 
-    def compile(self) -> None:
-        pass
+        if util.args['verbose']:
+            vsim_cmd += ['-verbose']
 
-    def elaborate(self) -> None:
-        pass
+        # Add simulation arguments
+        vsim_cmd += ['-do', tcl_name, 'opt_design']
 
-    def simulate(self) -> None:
-        pass
+        return [vsim_cmd]
 
-    def get_compile_command_lists(self, **kwargs) -> list:
+    def get_post_simulate_command_lists(self, **kwargs) -> list:
         return []
 
-    def get_elaborate_command_lists(self, **kwargs) -> list:
-        return []
+    def run_in_batch_mode(self) -> bool:
+        '''Returns bool if we should run in batch mode (-c) from command line'''
+        if self.args['test-mode']:
+            return True
+        if self.args['gui']:
+            return False
+        return True
 
-    def get_simulate_command_lists(self, **kwargs) -> list:
-        return []
+    def artifacts_add(self, name: str, typ: str, description: str) -> None:
+        '''Override from Command.artifacts_add for better descriptions'''
+        _, leafname = os.path.split(name)
+        if leafname == 'vsim.log':
+            description = 'Questa simulation step (3/3) log from stdout/stderr'
+        elif leafname == 'vopt.log':
+            description = 'Questa elaboration step (2/3) log from stdout/stderr'
+        elif leafname == 'vlog.log':
+            description = 'Questa compile step (1/3) log from stdout/stderr'
 
-    def get_post_simulate_command_lists(self, **kwargs) -> list:
-        return []
+        super().artifacts_add(name=name, typ=typ, description=description)
+
+
+class CommandFListQuesta(CommandFList, ToolQuesta):
+    '''CommandFListQuesta is a command handler for: eda flist --tool=questa'''
+
+    def __init__(self, config: dict):
+        CommandFList.__init__(self, config=config)
+        ToolQuesta.__init__(self, config=self.config)
 
 
 class CommandElabQuesta(CommandSimQuesta):

opencos/tools/questa_fse.py

@@ -11,6 +11,7 @@ For: Questa Intel Starter FPGA Edition-64 vsim 20XX.X Simulator
 import os
 
 from opencos.tools.modelsim_ase import CommandSimModelsimAse
+from opencos.tools.questa import CommandFListQuesta
 
 
 class CommandSimQuestaFse(CommandSimModelsimAse):
@@ -20,6 +21,7 @@ class CommandSimQuestaFse(CommandSimModelsimAse):
     '''
     _TOOL = 'questa_fse'
     _EXE = 'vsim'
+    use_vopt = True
 
     def __init__(self, config: dict):
         # this will setup with self._TOOL = modelsim_ase, which is not ideal so
@@ -57,3 +59,11 @@ class CommandElabQuestaFse(CommandSimQuestaFse):
     def __init__(self, config:dict):
         super().__init__(config)
         self.args['stop-after-elaborate'] = True
+
+
+class CommandFListQuestaFse(CommandFListQuesta):
+    '''CommandFListQuestaFse is a command handler for: eda flist --tool=questa_fse'''
+
+    def __init__(self, config: dict):
+        CommandFListQuesta.__init__(self, config=config)
+        self._TOOL = 'questa_fse'

opencos/tools/riviera.py

@@ -19,6 +19,7 @@ class ToolRiviera(ToolModelsimAse):
 
     _TOOL = 'riviera'
     _EXE = 'vsim'
+    use_vopt = False
 
     def get_versions(self) -> str:
         if self._VERSION:

opencos/tools/verilator.py

@@ -135,24 +135,18 @@ class VerilatorSim(CommandSim, ToolVerilator):
         paths = ['obj_dir', '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.verilate_command_lists, line_breaks=True)
-
         util.write_shell_command_file(dirpath=self.args['work-dir'], filename='lint_only.sh',
                                       command_lists=self.lint_only_command_lists, line_breaks=True)
 
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='simulate_only.sh',
-                                      command_lists = self.verilated_exec_command_lists +
-                                      (self.verilated_post_exec_coverage_command_lists
-                                       if self.args.get('coverage', True) else [])
-                                      )
-
-        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'],
-                                      ])
+        sim_cmd_lists = self.verilated_exec_command_lists + \
+            (self.verilated_post_exec_coverage_command_lists
+             if self.args.get('coverage', True) else [])
+
+        self.write_sh_scripts_to_work_dir(
+            compile_lists=self.verilate_command_lists,
+            elaborate_lists=[],
+            simulate_lists=sim_cmd_lists
+        )
 
 
     def compile(self):

opencos/tools/vivado.py

@@ -5,6 +5,7 @@ upload, flist, open, proj.
 '''
 
 # pylint: disable=R0801 # (setting similar, but not identical, self.defines key/value pairs)
+# pylint: disable=too-many-lines
 
 import os
 import re
@@ -152,22 +153,11 @@ class CommandSimVivado(CommandSim, ToolVivado):
         self.xvlog_commands = self.get_compile_command_lists()
         self.xelab_commands = self.get_elaborate_command_lists()
         self.xsim_commands = self.get_simulate_command_lists()
-
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='compile.sh',
-                                      command_lists=self.xvlog_commands)
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='elaborate.sh',
-                                      command_lists=self.xelab_commands)
-        util.write_shell_command_file(dirpath=self.args['work-dir'], filename='simulate.sh',
-                                      command_lists=self.xsim_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.xvlog_commands,
+            elaborate_lists=self.xelab_commands,
+            simulate_lists=self.xsim_commands
+        )
 
     def compile(self):
         if self.args['stop-before-compile']:
@@ -259,7 +249,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
                     print(f"run {self.args['waves-start']} ns", file=fo)
                 print("log_wave -recursive *", file=fo)
             print("run -all", file=fo)
-            if not self.args['gui']:
+            if not self.args['gui'] or self.args['test-mode']:
                 print("exit", file=fo)
 
         sv_seed = str(self.args['seed'])
@@ -280,7 +270,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
         if sys.platform == "win32":
             command_list[0] += ".bat"
         command_list += self.tool_config.get('simulate-args', 'snapshot --stats').split()
-        if self.args['gui']:
+        if self.args['gui'] and not self.args['test-mode']:
             command_list += ['-gui']
         command_list += [
             '--tclbatch', tcl_name.replace('\\','\\\\'),  # needed for windows paths
@@ -652,14 +642,15 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         self.write_eda_config_and_args()
 
         # create FLIST
-        flist_file = os.path.join(self.args['work-dir'],'build.flist')
-        util.debug(f"CommandBuildVivado: {self.args['top-path']=}")
+        flist_file = os.path.abspath(os.path.join(self.args['work-dir'],'build.flist'))
+        util.debug(f"CommandBuildVivado: 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',
+            '--no-default-log',
             '--tool=' + self.args['tool'],
-            self.args['top-path'],
             '--force',
             '--out=' + flist_file,
             #'--no-emit-incdir',
@@ -677,6 +668,14 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
             '--prefix-v=' + shlex.quote("add_files -norecurse "),
             '--prefix-vhd=' + shlex.quote("add_files -norecurse "),
         ]
+
+        # 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}" ]
@@ -691,7 +690,10 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         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(cwd, command_list, tee_fpath=command_list.tee_fpath)
+        # Run this from work-dir
+        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']
@@ -701,7 +703,7 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         command_list = [self.vivado_exe]
         command_list += [
             '-mode',
-            'gui' if self.args['gui'] else 'batch',
+            'gui' if self.args['gui'] and not self.args['test-mode'] else 'batch',
             '-log', os.path.join(self.args['work-dir'], self.args['top'] + '.build.log')
         ]
         if not util.args['verbose']:
@@ -724,6 +726,11 @@ class CommandBuildVivado(CommandBuild, ToolVivado):
         util.write_shell_command_file(dirpath=self.args['work-dir'], filename='run_vivado.sh',
                                       command_lists=[command_list], line_breaks=True)
 
+        if self.args['stop-before-compile']:
+            util.info(f"--stop-before-compile set: scripts in : {self.args['work-dir']}")
+            return
+
+        # Run this from current working dir (not work-dir)
         self.exec(cwd, command_list, tee_fpath=command_list.tee_fpath)
         util.info(f"Build done, results are in: {self.args['work-dir']}")
 

opencos/util.py

@@ -88,6 +88,7 @@ class ArtifactTypes(Enum):
     DOTF = 4
     TCL = 5
     SHELL = 6
+    BITSTREAM = 7
 
 class Artifacts:
     '''Class to hold file artifacts, for logs generated by EDA, or other artifcats created
@@ -224,16 +225,17 @@ class UtilLogger:
     # util's argparser: --no-default-log, --logfile=<name>, or --force-logfile=<name>
     default_log_enabled = False
     default_log_filepath = os.path.join('eda.work', 'eda.log')
+    default_log_disable_with_args = ['-h', '--help'] # common argparse help
     enable = True
 
     def clear(self) -> None:
-        '''Resets internals'''
+        '''Resets some internals for logging, but preserve others'''
         self.file = None
         self.filepath = ''
         self.time_last = 0
 
     def stop(self) -> None:
-        '''Closes open log, resets internals'''
+        '''Closes open log, resets some internals'''
         if self.file:
             self.write_timestamp(f'stop - {self.filepath}')
             info(f"Closing logfile: {self.filepath}")
@@ -364,9 +366,28 @@ def get_argparser() -> argparse.ArgumentParser:
                               ' using $OC_ROOT/bin'))
     parser.add_argument('--artifacts-json', **bool_action_kwargs,
                         help='Store a work-dir/artifacts.json file of known tool output files')
+    parser.add_argument('-f', '--input-file', default=[], action='append',
+                        help=(
+                            'Input .f file to be expanded as eda'
+                            ' args/defines/incdirs/files/targets'))
     return parser
 
 
+def get_argparser_args_list(parser: object = None) -> list:
+    '''Returns list of all args, all items will include the -- prefix (--help, etc)'''
+    if not isinstance(parser, argparse.ArgumentParser):
+        return []
+    return list(vars(parser).get('_option_string_actions', {}).keys())
+
+
+def get_argparsers_args_list(parsers: list) -> list:
+    '''Returns list of all args from list of parsers, all items have -- prefix (--help, etc)'''
+    _args_list = []
+    for parser in parsers:
+        _args_list.extend(get_argparser_args_list(parser))
+    return list(dict.fromkeys(_args_list)) # uniqify, preserve order
+
+
 def get_argparser_short_help(parser: object = None) -> str:
     '''Returns short help for our ArgumentParser'''
     if not parser:
@@ -393,28 +414,81 @@ def process_token(arg: list) -> bool:
     return False
 
 
-def process_tokens(tokens:list) -> (argparse.Namespace, list):
+def read_tokens_from_dot_f(filepath: str) -> list:
+    '''Returns list of tokens from a .f file'''
+    debug(f"Opening -f / --input-file '{filepath}' for contents")
+    if not os.path.isfile(filepath):
+        error(f'-f (or --input-file): {filepath} does not exist',
+              error_code=status_constants.EDA_GENERAL_FILE_NOT_FOUND)
+        return []
+    tokens = []
+    with open(filepath, encoding='utf-8') as f:
+        for line in f:
+            tokens.extend(line.split())
+    return tokens
+
+def process_debug_args(parsed: argparse.Namespace) -> None:
+    '''Sets global debug_level based on parsed args'''
+    global debug_level # pylint: disable=global-statement
+
+    if parsed.debug_level:
+        set_debug_level(parsed.debug_level)
+    elif parsed.debug:
+        set_debug_level(1)
+    elif parsed.debug is False:
+        # not None, explicitly set to False via --no-debug
+        debug_level = 0
+
+
+def process_tokens(tokens: list) -> (argparse.Namespace, list):
     '''Processes tokens (unparsed args list) on util's ArgumentParser
 
     Returns tuple of (parsed Namespace, unparsed args list)
     '''
     global debug_level # pylint: disable=global-statement
+    debug_level = 0
 
-    parser = get_argparser()
+    # Deal with --debug, --debug-level, and expand all parsed.input_file (list) tokens first,
+    # for now put dot-f file contents in front of of tokens, do this in a separate custom
+    # argparser.
+    bool_action_kwargs = get_argparse_bool_action_kwargs()
+    parser = argparse.ArgumentParser(
+        prog='opencos -f/--input-file', add_help=False, allow_abbrev=False
+    )
+    parser.add_argument('--debug', **bool_action_kwargs,
+                        help='Display additional debug messaging level 1 or higher')
+    parser.add_argument('--debug-level', type=int, default=0,
+                        help='Set debug level messaging (default: 0)')
+    parser.add_argument('-f', '--input-file', default=[], action='append',
+                        help=(
+                            'Input .f file to be expanded as eda'
+                            ' args/defines/incdirs/files/targets'))
     try:
         parsed, unparsed = parser.parse_known_args(tokens + [''])
+        tokens2 = list(filter(None, unparsed))
+    except argparse.ArgumentError:
+        error(f'util -f/--input-file, problem attempting to parse_known_args for: {tokens}')
+
+    process_debug_args(parsed=parsed)
+    debug(f'util.process_tokens: {parsed=} {unparsed=} from: {tokens}')
+
+    for filepath in parsed.input_file:
+        tokens2[0:0] = read_tokens_from_dot_f(filepath)
+
+    # Continue with all normal parsing beyond --debug and -f/--input-file,
+    # Note that we re-parse everything in case there was --debug or --debug-level in
+    # the .f file(s), or anything else that this argparser would pick up.
+    parser = get_argparser()
+    try:
+        parsed, unparsed = parser.parse_known_args(tokens2 + [''])
         unparsed = list(filter(None, unparsed))
     except argparse.ArgumentError:
-        error(f'problem attempting to parse_known_args for {tokens=}')
+        error(f'util: problem attempting to parse_known_args for tokens={tokens2}')
 
-    if parsed.debug_level:
-        set_debug_level(parsed.debug_level)
-    elif parsed.debug:
-        set_debug_level(1)
-    else:
-        debug_level = 0
+    process_debug_args(parsed=parsed)
 
-    debug(f'util.process_tokens: {parsed=} {unparsed=}  from {tokens=}')
+    if parsed.input_file:
+        warning(f'Skipping nested -f/--input-file(s) {parsed.input_file}')
 
     # clear existing artifacts dicts (mostly for pytests repeatedly calling eda.main),
     # set artifacts.enabled based on args['artifacts-json']
@@ -426,7 +500,7 @@ def process_tokens(tokens:list) -> (argparse.Namespace, list):
         start_log(parsed.logfile, force=False)
     elif parsed.default_log and \
          not parsed.version and \
-         not any(x in unparsed for x in ('help', '-h', '--help')) and \
+         not any(x in unparsed for x in global_log.default_log_disable_with_args) and \
          (parsed.force_logfile is None and parsed.logfile is None):
         # Use a forced logfile in the eda.work/eda.log:
         # avoid this if someone has --help arg not yet parsed.
@@ -434,9 +508,9 @@ def process_tokens(tokens:list) -> (argparse.Namespace, list):
         start_log(global_log.default_log_filepath, force=True)
 
     parsed_as_dict = vars(parsed)
-    for key,value in parsed_as_dict.items():
+    for key, value in parsed_as_dict.items():
         key = key.replace('_', '-')
-        if value is not None:
+        if key in args and value is not None:
             args[key] = value # only update with non-None values to our global 'args' dict
 
     return parsed, unparsed