opencos-eda 0.3.3__py3-none-any.whl → 0.3.6__py3-none-any.whl

opencos/commands/sim.py

@@ -145,6 +145,7 @@ class CommandSim(CommandDesign):
             self.run_dep_commands()
             self.do_it()
             self.run_post_tool_dep_commands()
+            self.report_pass_fail()
         return unparsed
 
 
@@ -198,6 +199,9 @@ class CommandSim(CommandDesign):
 
             clist = list(obj).copy()
             tee_fpath = getattr(obj, 'tee_fpath', None)
+            work_dir = getattr(obj, 'work_dir', None)
+            if not work_dir:
+                work_dir = self.args['work-dir']
 
             util.debug(f'run_commands_check_logs: {clist=}, {tee_fpath=}')
 
@@ -207,24 +211,28 @@ class CommandSim(CommandDesign):
             if log_filename:
                 log_fname = log_filename
 
+
             _, stdout, _ = self.exec(
-                work_dir=self.args['work-dir'], command_list=clist, tee_fpath=tee_fpath
+                work_dir=work_dir, command_list=clist, tee_fpath=tee_fpath
             )
 
             if check_logs and log_fname:
                 # Note this call will check on stdout if not GUI, not opening the log_fname,
                 # but if this is GUI we normally lose stdout and have to open the log.
-                gui_mode = self.args.get('gui', False)
-                file_contents_str = '' if gui_mode else stdout
+                if self.args.get('gui', False):
+                    file_contents_str = ''
+                else:
+                    file_contents_str = stdout
+
                 self.check_logs_for_errors(
-                    filename=os.path.join(self.args['work-dir'], log_fname),
+                    filename=os.path.join(work_dir, log_fname),
                     file_contents_str=file_contents_str,
                     bad_strings=bad_strings, must_strings=must_strings,
                     use_bad_strings=use_bad_strings, use_must_strings=use_must_strings
                 )
             if log_fname:
                 self.artifacts_add(
-                    name=os.path.join(self.args['work-dir'], log_fname),
+                    name=os.path.join(work_dir, log_fname),
                     typ='text', description='Simulator stdout/stderr log file'
                 )
 
@@ -253,6 +261,7 @@ class CommandSim(CommandDesign):
         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',
@@ -265,7 +274,8 @@ class CommandSim(CommandDesign):
                     '--stop-',
                     '--lint-',
                     '--verilate',
-                    '--verilator']):
+                    '--verilator',
+                    '--cocotb-test-']):
                 deps_file_args.append(a)
 
         export_obj.run(

opencos/deps/defaults.py

@@ -33,6 +33,7 @@ SUPPORTED_TARGET_TABLE_KEYS = set([
     'defines',
     'parameters',
     'incdirs',
+    'plusargs',
     'top',
     'deps',
     'reqs',

opencos/deps/deps_processor.py

@@ -10,7 +10,7 @@ import os
 from opencos import files
 from opencos import eda_config
 from opencos.util import debug, info, warning, error, read_tokens_from_dot_f, \
-    patch_args_for_dir
+    patch_args_for_dir, load_env_file
 from opencos.utils.str_helpers import dep_str2list
 from opencos.deps.deps_file import deps_target_get_deps_list
 from opencos.deps.deps_commands import deps_commands_handler
@@ -77,7 +77,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         ).get('command_handler', {}).keys()
 
 
-    def apply_defines(self, defines_dict: dict):
+    def apply_defines(self, defines_dict: dict) -> None:
         '''Given defines_dict, applies them to our self.command_design_ref obj'''
         if not isinstance(defines_dict, dict):
             self.error(f"{defines_dict=} is not type dict, can't apply defines,",
@@ -95,7 +95,19 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 self.command_design_ref.process_plusarg(f'+define+{k}={v}')
 
 
-    def apply_parameters(self, parameters_dict: dict):
+    def apply_plusargs(self, plusargs_dict: dict) -> None:
+        '''Given plusarsg_dict, applies them to our self.command_design_ref obj'''
+        if not isinstance(plusargs_dict, dict):
+            self.error(f"{plusargs_dict=} is not type dict, can't apply plusargs,",
+                       f"in {self.caller_info}")
+        for k,v in plusargs_dict.items():
+            if v is None or v == '':
+                self.command_design_ref.process_plusarg(f'+{k}')
+            else:
+                self.command_design_ref.process_plusarg(f'+{k}={v}')
+
+
+    def apply_parameters(self, parameters_dict: dict) -> None:
         '''Given parameters_dict, applies them to our self.command_design_ref obj'''
         if not isinstance(parameters_dict, dict):
             self.error(f"{parameters_dict=} is not type dict, can't apply defines,",
@@ -110,7 +122,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 )
 
 
-    def apply_incdirs(self, incdirs_list:list):
+    def apply_incdirs(self, incdirs_list:list) -> None:
         '''Given incdirs_list, applies them to our self.command_design_ref obj'''
         if not isinstance(incdirs_list, (str, list)):
             self.error(f"{incdirs_list=} is not type str/list, can't apply incdirs",
@@ -180,9 +192,15 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         # Since some args (util.py, eda_config.py, eda.py) can only be handled from command
         # line, it would be nice if -f or --input-file is handled from DEPS, so we'll special
         # case that now. Recursively resolve -f / --input-file.
+        # Do similary for --env-file (also only supported in util.py)
         parser = argparse.ArgumentParser(
             prog='deps_processor -f/--input-file', add_help=False, allow_abbrev=False
         )
+        parser.add_argument('--env-file', default=[], action='append',
+                            help=(
+                                "dotenv file(s) to pass ENV vars, (default: .env loaded first,"
+                                " subsequent files' vars override .env"
+                            ))
         parser.add_argument('-f', '--input-file', default=[], action='append',
                             help=(
                                 'Input .f file to be expanded as eda args, defines, incdirs,'
@@ -213,7 +231,12 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
             # recurse until we've resolved nested .f files.
             return self.apply_args(args_list=tokens2)
 
-        tokens = tokens2 # if no --input-file values, keep parsing the remaining tokens2
+        if parsed.env_file:
+            for env_file in parsed.env_file:
+                load_env_file(env_file)
+
+        # if no --input-file/--env-file values, keep parsing the remaining tokens2:
+        tokens = tokens2
 
         # We have to special-case anything with --tool[=value] in tokens, otherwise
         # the user may think they were allowed to set --tool, but in our flow the Command handler
@@ -290,7 +313,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 caller_info=self.caller_info
             )
 
-    def process_deps_entry(self):
+    def process_deps_entry( # pylint: disable=too-many-branches
+            self
+    ) -> list:
         '''Main entry point (after creating DepsProcessor obj) to resolve a deps target
 
         Example usage:
@@ -303,22 +328,6 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         This method will apply all target features to the CommandDesign ref object as
         we traverse.
 
-        Supported target keys:
-         -- tags (or equivalent, to support multiple define/incdir/deps for a target)
-            -- supports tag-name, with-tools, with-args, args, defines, incdirs, deps
-                 ** to be applied if a tool matches.
-            -- TODO(drew): other features in docs/DEPS.md not yet implemented.
-         -- multi: ignore-this-target: - commands (handled in eda.py CommandMulti.resolve_target)
-         -- Named eda commands
-            -- (partially done) sim or other eda commands (eda.py command specific things)
-                basically, check the command, and apply/merge values to 'entry'?
-         -- args
-         -- defines
-         -- incdirs
-         -- top.
-         -- commands (not in deps)
-         -- deps
-
         TODO(drew): This does not yet support conditional inclusions based on defines,
          like the old DEPS files did with pattern:
             SOME_DEFINE ?  dep_if_define_present : dep_if_define_not_present
@@ -344,6 +353,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 remaining_deps_list += self.process_tags()
             elif key == 'defines':
                 self.process_defines()
+            elif key == 'plusargs':
+                self.process_plusargs()
             elif key == 'parameters':
                 self.process_parameters()
             elif key == 'incdirs':
@@ -520,6 +531,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         # apply defines:
                         self.apply_defines(value.get('defines', {}))
 
+                    if key == 'plusargs':
+                        # apply plusargs:
+                        self.apply_plusargs(value.get('plusargs', {}))
+
                     elif key == 'parameters':
                         self.apply_parameters(value.get('parameters', {}))
 
@@ -598,7 +613,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         return ret_deps_added_from_tags
 
 
-    def process_defines(self):
+    def process_defines(self) -> None:
         '''Returns None, applies defines (dict, if any) from self.deps_entry to
         self.command_design_ref.'''
 
@@ -614,7 +629,28 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
         self.apply_defines(entry_defines)
 
-    def process_parameters(self):
+
+    def process_plusargs(self) -> None:
+        '''Returns None, applies plusargs (dict, if any) from self.deps_entry to
+        self.command_design_ref.
+
+        These work w/ the same rules as defines (no value, or value int/str)
+        '''
+
+        # Plusargs:
+        # apply command specific plusargs, with higher priority than the a
+        # deps_entry['sim']['plusargs'] entry,
+        # do this with dict1.update(dict2):
+        entry_plusargs = {}
+        entry_plusargs.update(self.deps_entry.get('plusargs', {}))
+        entry_plusargs.update(self.entry_eda_command.get('plusargs', {}))
+        assert isinstance(entry_plusargs, dict), \
+            f'{entry_plusargs=} for in {self.caller_info} must be a dict'
+
+        self.apply_plusargs(entry_plusargs)
+
+
+    def process_parameters(self) -> None:
         '''Returns None, applies parameters (dict, if any) from self.deps_entry to
         self.command_design_ref.'''
 

opencos/deps_schema.py

@@ -17,6 +17,9 @@ my_target_name:
   incdirs:                           <---- incdirs, optional array (or string)
     - ./
 
+  plusargs:                          <---- plusargs, optional table
+    some_plusarg: 32
+
   top: tb                            <---- top, optional string
 
   deps:
@@ -63,6 +66,7 @@ my_target_name:
   defines:                           <---- defines, optional table
   parameters:                        <---- parameters, optional table
   incdirs:                           <---- incdirs, optional array (or string)
+  plusargs:                          <---- plusargs, optional table
   top: tb                            <---- top, optional string
   deps:                              <---- TARGET_DEPS_CONTENTS schema
     - some_file.sv                   <---- string file name
@@ -216,6 +220,9 @@ TARGET_EDA_COMMAND_ENTRY_TABLE = {
     Optional('defines'): {
         Optional(str): Or(str, int, type(None)),
     },
+    Optional('plusargs'): {
+        Optional(str): Or(str, int, type(None)),
+    },
     Optional('parameters'): {
         Optional(str): Or(str, int),
     },
@@ -241,6 +248,9 @@ TARGET_TAGS_TABLE = {
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        Optional('plusargs'): {
+            Optional(str): Or(str, int, type(None)),
+        },
         Optional('parameters'): {
             Optional(str): Or(str, int),
         },
@@ -262,6 +272,10 @@ TARGET_CONTENTS = Or(
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        # plusargs: table of key-value; value null or string
+        Optional('plusargs'): {
+            Optional(str): Or(str, int, type(None)),
+        },
         # parameters: table of key-value
         Optional('parameters'): {
             Optional(str): Or(str, int),
@@ -324,6 +338,9 @@ FILE_SIMPLIFIED = Schema(
                     Optional('defines'): {
                         Optional(str): Or(type(None), str),
                     },
+                    Optional('plusargs'): {
+                        Optional(str): Or(type(None), str),
+                    },
                     Optional('parameters'): {
                         Optional(str): str,
                     },

opencos/eda.py

@@ -20,10 +20,11 @@ from pathlib import Path
 
 import opencos
 from opencos import util, eda_config, eda_base
+from opencos.util import safe_emoji
 from opencos.eda_base import Tool, which_tool, get_eda_exec
 from opencos.utils import vsim_helper, vscode_helper
 from opencos.utils.subprocess_helpers import subprocess_run_background
-from opencos.utils import status_constants, str_helpers
+from opencos.utils import status_constants, str_helpers, subprocess_helpers
 
 # Configure util:
 util.progname = "EDA"
@@ -50,7 +51,7 @@ def init_config(
     # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
     # the actual class using importlib (via opencos.util)
 
-    eda_config.tool_try_add_to_path(tool)
+    eda_config.update_config_auto_tool_order_for_tool(tool=tool, config=config)
 
     config['command_handler'] = {}
     for _cmd, str_class in config['DEFAULT_HANDLERS'].items():
@@ -95,15 +96,15 @@ def usage(tokens: list, config: dict, command: str = "", tool: str = "") -> int:
 
     if command == "":
         print(
-"""
-Usage:
+f"""
+{safe_emoji("🔦 ")}Usage:
     eda [<options>] <command> [options] <files|targets, ...>
 """
         )
         print(get_all_commands_help_str(config=config))
         print(
-"""
-And <files|targets, ...> is one or more source file or DEPS markup file target,
+f"""
+{safe_emoji("❕ ")}where <files|targets, ...> is one or more source file or DEPS markup file target,
     such as .v, .sv, .vhd[l], .cpp files, or a target key in a DEPS.[yml|yaml|toml|json].
     Note that you can prefix source files with `sv@`, `v@`, `vhdl@` or `cpp@` to
     force use that file as systemverilog, verilog, vhdl, or C++, respectively.
@@ -163,10 +164,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
       If so, updates config['auto_tools_order'][tool]['exe']
     '''
 
-
-    tool = eda_config.update_config_auto_tool_order_for_tool(
-        tool=tool, config=config
-    )
+    tool = eda_config.tool_arg_remove_path_information(tool)
 
     assert 'auto_tools_order' in config
     assert isinstance(config['auto_tools_order'], list)
@@ -275,9 +273,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
 
     '''
 
-    tool = eda_config.update_config_auto_tool_order_for_tool(
-        tool=tool, config=config
-    )
+    tool = eda_config.tool_arg_remove_path_information(tool)
 
     if not quiet and not auto_setup:
         util.info(f"Setup for tool: '{tool}'")
@@ -389,6 +385,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
     if not is_interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
+        # This will handle any --tool=<name>=/path/to/bin also, so don't have to
+        # run tool_setup(..) on its own.
         config = init_config(
             config, tool=parsed.tool,
             run_auto_tool_setup=run_auto_tool_setup
@@ -406,13 +404,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
             for arg in unparsed:
                 if not arg.startswith('-'):
                     command = arg
-        if parsed.tool:
-            tool_setup(parsed.tool, config=config)
         return usage(tokens=unparsed, config=config, command=command, tool=parsed.tool)
 
-    if parsed.tool:
-        tool_setup(parsed.tool, config=config)
-
     deferred_tokens = unparsed
     if not command:
         util.error("Didn't get a command!")
@@ -503,7 +496,8 @@ def check_command_handler_cls(command_obj:object, command:str, parsed_args) -> i
 def signal_handler(sig, frame) -> None: # pylint: disable=unused-argument
     '''Handles Ctrl-C, called by main_cli() if running from command line'''
     util.fancy_stop()
-    util.info('Received Ctrl+C...', start='\nINFO: [EDA] ')
+    util.error(f'{safe_emoji("❌ ")}Received Ctrl+C...', start='\nINFO: [EDA] ')
+    subprocess_helpers.cleanup_all()
     util.exit(-1)
 
 # **************************************************************

opencos/eda_base.py

@@ -24,7 +24,7 @@ from pathlib import Path
 from opencos import seed, util, files
 from opencos import eda_config
 
-from opencos.util import Colors
+from opencos.util import Colors, safe_emoji
 from opencos.utils.str_helpers import sprint_time, strip_outer_quotes, string_or_space, \
     indent_wrap_long_text, pretty_list_columns_manual
 from opencos.utils.subprocess_helpers import subprocess_run_background
@@ -44,7 +44,9 @@ def print_base_help() -> None:
 
 def get_argparser() -> argparse.ArgumentParser:
     '''Returns the ArgumentParser for general eda CLI'''
-    parser = argparse.ArgumentParser(prog='eda options', add_help=False, allow_abbrev=False)
+    parser = argparse.ArgumentParser(
+        prog=f'{safe_emoji("🔎 ")}eda options', add_help=False, allow_abbrev=False
+    )
     parser.add_argument('-q', '--quit', action='store_true',
                         help=(
                             'For interactive mode (eda called with no options, command, or'
@@ -313,6 +315,18 @@ class Command: # pylint: disable=too-many-public-methods
             util.error(f"command '{self.command_name}' has previous errors")
         return self.status > 0
 
+    def report_pass_fail(self) -> None:
+        '''Reports an INFO line with pass/fail information'''
+        job_name = ' - '.join(
+            x for x in (self.command_name, self.args.get('tool', ''),
+                        self.args.get('top', '')) if x
+        )
+        if self.status_any_error():
+            util.info(f'{safe_emoji("❌ ")}{job_name}: Errors observed.', color=Colors.red)
+        else:
+            util.info(f'{safe_emoji("✅ ")}{job_name}: No errors observed.')
+
+
     def which_tool(self, command:str) -> str:
         '''Returns a str for the tool name used for the requested command'''
         return which_tool(command, config=self.config)
@@ -462,7 +476,8 @@ class Command: # pylint: disable=too-many-public-methods
         if not tee_fpath and getattr(command_list, 'tee_fpath', None):
             tee_fpath = getattr(command_list, 'tee_fpath', '')
         if not quiet:
-            util.info(f"exec: {' '.join(command_list)} (in {work_dir}, {tee_fpath=})")
+            util.info(f"{safe_emoji('⏩ ')}exec: {' '.join(command_list)}",
+                      f"(in {work_dir}, {tee_fpath=})")
 
         stdout, stderr, return_code = subprocess_run_background(
             work_dir=work_dir,
@@ -484,7 +499,8 @@ class Command: # pylint: disable=too-many-public-methods
                 self.error(f"exec: returned with error (return code: {return_code})",
                            error_code=self.status)
             else:
-                util.debug(f"exec: returned with error (return code: {return_code})")
+                util.debug(f"{safe_emoji('❌ ')}exec: returned with error (return code:",
+                           f"{return_code})")
         else:
             util.debug(f"exec: returned without error (return code: {return_code})")
         return stderr, stdout, return_code
@@ -564,7 +580,9 @@ class Command: # pylint: disable=too-many-public-methods
         # parsed.args-with-dashes is not legal python. Some of self.args.keys() still have - or _,
         # so this will handle both.
         # Also, preference is for self.args.keys(), to be str with - dashes
-        parser = argparse.ArgumentParser(prog='eda', add_help=False, allow_abbrev=False)
+        parser = argparse.ArgumentParser(
+            prog=f'{safe_emoji("🔎 ")}eda', add_help=False, allow_abbrev=False
+        )
         bool_action_kwargs = util.get_argparse_bool_action_kwargs()
 
         if not parser_arg_list:
@@ -594,6 +612,7 @@ class Command: # pylint: disable=too-many-public-methods
                 help_kwargs = {'help': f'default={value}'}
             else:
                 help_kwargs = {'help': f'{type(value).__name__} default={value}'}
+            help_kwargs['help'] = help_kwargs['help'].replace('%', '%%')
 
 
             # It's important to set the default=None on these, except for list types where default
@@ -796,7 +815,7 @@ class Command: # pylint: disable=too-many-public-methods
         util.info('Help:')
         # using bare 'print' here, since help was requested, avoids --color and --quiet
         print()
-        print('Usage:')
+        print(f'{safe_emoji("🔦 ")}Usage:')
         if no_targets:
             print(f'    eda [options] {self.command_name} [options]')
         else:
@@ -810,10 +829,10 @@ class Command: # pylint: disable=too-many-public-methods
             return
 
         if self.command_name:
-            lines.append(f"Generic help for command='{self.command_name}'"
+            lines.append(f"{safe_emoji('🔧 ')}Generic help for command='{self.command_name}'"
                          f" (using '{self.__class__.__name__}')")
         else:
-            lines.append("Generic help (from class Command):")
+            lines.append("{safe_emoji('🔧 ')}Generic help (from class Command):")
 
         # Attempt to run argparser on args, but don't error if it fails.
         unparsed = []
@@ -979,6 +998,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         self.files_vhd = []
         self.files_cpp = []
         self.files_sdc = []
+        self.files_py = []
+        self.files_makefile = []
         self.files_non_source = []
         self.files_caller_info = {}
         self.dep_shell_commands = [] # each list entry is a {}
@@ -1138,7 +1159,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                 self.files[new_key] = True
 
         my_file_lists_list = [self.files_v, self.files_sv, self.files_vhd, self.files_cpp,
-                              self.files_sdc]
+                              self.files_sdc, self.files_py, self.files_makefile]
         for my_file_list in my_file_lists_list:
             for i,value in enumerate(my_file_list):
                 if value and isinstance(value, str) and \
@@ -1156,9 +1177,11 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         need to be copied or linked to the work-dir. For example, if some SV assumes it
         can $readmemh('file_that_is_here.txt') but we're running out of work-dir. Linking
         is the easy work-around vs trying to run-in-place of all SV files.
+
+        Note that we also include .py and Makefile(s) in this.
         '''
 
-        for fname in self.files_non_source:
+        for fname in self.files_non_source + self.files_py + self.files_makefile:
             _, leaf_fname = os.path.split(fname)
             destfile = os.path.join(self.args['work-dir'], leaf_fname)
             relfname = os.path.relpath(fname)
@@ -1517,7 +1540,7 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         # if we've found any target since being called, it means we found the one we were called for
         return found_target
 
-    def add_file( # pylint: disable=too-many-locals,too-many-branches
+    def add_file( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
             self, filename: str, use_abspath: bool = True, add_to_non_sources: bool = False,
             caller_info: str = '', forced_extension: str = ''
     ) -> str:
@@ -1542,6 +1565,8 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
         cpp_file_ext_list = known_file_ext_dict.get('cpp', [])
         sdc_file_ext_list = known_file_ext_dict.get('synth_constraints', [])
         dotf_file_ext_list = known_file_ext_dict.get('dotf', [])
+        py_file_ext_list = known_file_ext_dict.get('python', [])
+        makefile_ext_list = known_file_ext_dict.get('makefile', [])
 
         if forced_extension:
             # If forced_extension='systemverilog', then use the first known extension for
@@ -1581,6 +1606,12 @@ class CommandDesign(Command): # pylint: disable=too-many-instance-attributes
                                caller_info=caller_info)
             dp.apply_args(args_list=[f'-f={file_abspath}'])
             del dp
+        elif file_ext in py_file_ext_list:
+            self.files_py.append(file_abspath)
+            util.debug(f"Added Python file {filename} as {file_abspath}")
+        elif file_ext in makefile_ext_list or os.path.split(filename)[1] == 'Makefile':
+            self.files_makefile.append(file_abspath)
+            util.debug(f"Added Makefile {filename} as {file_abspath}")
         else:
             # unknown file extension. In these cases we link the file to the working directory
             # so it is available (for example, a .mem file that is expected to exist with relative
@@ -2113,21 +2144,22 @@ class CommandParallel(Command):
                     work_queue.put((jobs_launched, command_list, job['name'], cwd))
                     suffix = "<START>"
                     if fancy_mode:
-                        util.fancy_print(job_text+suffix, worker)
+                        util.fancy_print(job_text + suffix, worker)
                     elif failed_jobs:
                         # if we aren't in fancy mode, we will print a START line, periodic RUNNING
                         # lines, and PASS/FAIL line per-job
-                        util.print_orange(job_text + Colors.yellow + suffix)
+                        util.print_yellow(job_text, end='')
+                        util.print_foreground_color(suffix)
                     else:
-                        util.print_yellow(job_text + Colors.yellow + suffix)
+                        util.print_foreground_color(job_text + suffix)
                 else:
                     # single-threaded job launch, we are going to print out job info as we start
                     # each job... no newline. since non-verbose silences the job and prints only
                     # <PASS>/<FAIL> after the trailing "..." we leave here
                     if failed_jobs:
-                        util.print_orange(job_text, end="")
-                    else:
                         util.print_yellow(job_text, end="")
+                    else:
+                        util.print_foreground_color(job_text, end="")
                     job_done_number = jobs_launched
                     job_done_name = job['name']
                     job_start_time = time.time()
@@ -2181,9 +2213,10 @@ class CommandParallel(Command):
                         if fancy_mode:
                             util.fancy_print(f"{job_text}{suffix}", t['worker'])
                         elif failed_jobs:
-                            util.print_orange(job_text + Colors.yellow + suffix)
+                            util.print_yellow(job_text, end='')
+                            util.print_foreground_color(suffix)
                         else:
-                            util.print_yellow(job_text + Colors.yellow + suffix)
+                            util.print_foreground_color(job_text + suffix)
 
             # shared job completion code
             # single or multi-threaded, we can arrive here to harvest <= 1 jobs, and need
@@ -2191,36 +2224,52 @@ class CommandParallel(Command):
             # printed, ready for pass/fail
             if job_done:
                 jobs_complete += 1
+                this_job_failed = False
                 if job_done_return_code is None or job_done_return_code:
-                    # embed the color code, to change color of pass/fail during the
-                    # util.print_orange/yellow below
                     if job_done_return_code == 124:
                         # bash uses 124 for bash timeout errors, if that was preprended to the
                         # command list.
-                        suffix = f"{Colors.red}<TOUT: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<TOUT{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     else:
-                        suffix = f"{Colors.red}<FAIL: {sprint_time(job_done_run_time)}>"
+                        suffix = (
+                            f"<FAIL{safe_emoji(' ❌')}:"
+                            f" {sprint_time(job_done_run_time)}>"
+                        )
+                        this_job_failed = True
                     failed_jobs.append(job_done_name)
                 else:
-                    suffix = f"{Colors.green}<PASS: {sprint_time(job_done_run_time)}>"
+                    suffix = (
+                        f"<PASS{safe_emoji(' ✅')}:"
+                        f" {sprint_time(job_done_run_time)}>"
+                    )
                     passed_jobs.append(job_done_name)
                 # we want to print in one shot, because in fancy modes that's all that we're allowed
                 job_done_text = "" if job_done_quiet else sprint_job_line(job_done_number,
                                                                           job_done_name)
-                if failed_jobs:
-                    util.print_orange(f"{job_done_text}{suffix}")
-                else:
+                if this_job_failed:
+                    util.print_red(f"{job_done_text}{suffix}")
+                elif failed_jobs:
                     util.print_yellow(f"{job_done_text}{suffix}")
+                else:
+                    util.print_green(f"{job_done_text}{suffix}")
                 self.jobs_status[job_done_number-1] = job_done_return_code
 
             if not anything_done:
                 time.sleep(0.25) # if nothing happens for an iteration, chill out a bit
 
         if total_jobs:
-            emoji = "< :) >" if (len(passed_jobs) == total_jobs) else "< :( >"
-            util.info(sprint_job_line(final=True, job_name="jobs passed") + emoji, start="")
+            if len(passed_jobs) == total_jobs:
+                emojitxt = safe_emoji('😀', ':)')
+            else:
+                emojitxt = safe_emoji('😦', ':(')
+            util.info(sprint_job_line(final=True, job_name="jobs passed") + f"< {emojitxt} >",
+                      start="")
         else:
-            util.info("Parallel: <No jobs found>")
+            util.info(f"Parallel: <{safe_emoji('❓ ')}No jobs found>")
         # Make sure all jobs have a set status:
         for i, rc in enumerate(self.jobs_status):
             if rc is None or not isinstance(rc, int):