| # @file DebugMacroCheck.py | |
| # | |
| # A script that checks if DEBUG macros are formatted properly. | |
| # | |
| # In particular, that print format specifiers are defined | |
| # with the expected number of arguments in the variable | |
| # argument list. | |
| # | |
| # Copyright (c) Microsoft Corporation. All rights reserved. | |
| # SPDX-License-Identifier: BSD-2-Clause-Patent | |
| ## | |
| from argparse import RawTextHelpFormatter | |
| import logging | |
| import os | |
| import re | |
| import regex | |
| import sys | |
| import shutil | |
| import timeit | |
| import yaml | |
| from edk2toollib.utility_functions import RunCmd | |
| from io import StringIO | |
| from pathlib import Path, PurePath | |
| from typing import Dict, Iterable, List, Optional, Tuple | |
| PROGRAM_NAME = "Debug Macro Checker" | |
| class GitHelpers: | |
| """ | |
| Collection of Git helpers. | |
| Will be moved to a more generic module and imported in the future. | |
| """ | |
| @staticmethod | |
| def get_git_ignored_paths(directory_path: PurePath) -> List[Path]: | |
| """Returns ignored files in this git repository. | |
| Args: | |
| directory_path (PurePath): Path to the git directory. | |
| Returns: | |
| List[Path]: List of file absolute paths to all files ignored | |
| in this git repository. If git is not found, an empty | |
| list will be returned. | |
| """ | |
| if not shutil.which("git"): | |
| logging.warn( | |
| "Git is not found on this system. Git submodule paths will " | |
| "not be considered.") | |
| return [] | |
| out_stream_buffer = StringIO() | |
| exit_code = RunCmd("git", "ls-files --other", | |
| workingdir=str(directory_path), | |
| outstream=out_stream_buffer, | |
| logging_level=logging.NOTSET) | |
| if exit_code != 0: | |
| return [] | |
| rel_paths = out_stream_buffer.getvalue().strip().splitlines() | |
| abs_paths = [] | |
| for path in rel_paths: | |
| abs_paths.append(Path(directory_path, path)) | |
| return abs_paths | |
| @staticmethod | |
| def get_git_submodule_paths(directory_path: PurePath) -> List[Path]: | |
| """Returns submodules in the given workspace directory. | |
| Args: | |
| directory_path (PurePath): Path to the git directory. | |
| Returns: | |
| List[Path]: List of directory absolute paths to the root of | |
| each submodule found from this folder. If submodules are not | |
| found, an empty list will be returned. | |
| """ | |
| if not shutil.which("git"): | |
| return [] | |
| if os.path.isfile(directory_path.joinpath(".gitmodules")): | |
| out_stream_buffer = StringIO() | |
| exit_code = RunCmd( | |
| "git", "config --file .gitmodules --get-regexp path", | |
| workingdir=str(directory_path), | |
| outstream=out_stream_buffer, | |
| logging_level=logging.NOTSET) | |
| if exit_code != 0: | |
| return [] | |
| submodule_paths = [] | |
| for line in out_stream_buffer.getvalue().strip().splitlines(): | |
| submodule_paths.append( | |
| Path(directory_path, line.split()[1])) | |
| return submodule_paths | |
| else: | |
| return [] | |
| class QuietFilter(logging.Filter): | |
| """A logging filter that temporarily suppresses message output.""" | |
| def __init__(self, quiet: bool = False): | |
| """Class constructor method. | |
| Args: | |
| quiet (bool, optional): Indicates if messages are currently being | |
| printed (False) or not (True). Defaults to False. | |
| """ | |
| self._quiet = quiet | |
| def filter(self, record: logging.LogRecord) -> bool: | |
| """Quiet filter method. | |
| Args: | |
| record (logging.LogRecord): A log record object that the filter is | |
| applied to. | |
| Returns: | |
| bool: True if messages are being suppressed. Otherwise, False. | |
| """ | |
| return not self._quiet | |
| class ProgressFilter(logging.Filter): | |
| """A logging filter that suppresses 'Progress' messages.""" | |
| def filter(self, record: logging.LogRecord) -> bool: | |
| """Progress filter method. | |
| Args: | |
| record (logging.LogRecord): A log record object that the filter is | |
| applied to. | |
| Returns: | |
| bool: True if the message is not a 'Progress' message. Otherwise, | |
| False. | |
| """ | |
| return not record.getMessage().startswith("\rProgress") | |
| class CacheDuringProgressFilter(logging.Filter): | |
| """A logging filter that suppresses messages during progress operations.""" | |
| _message_cache = [] | |
| @property | |
| def message_cache(self) -> List[logging.LogRecord]: | |
| """Contains a cache of messages accumulated during time of operation. | |
| Returns: | |
| List[logging.LogRecord]: List of log records stored while the | |
| filter was active. | |
| """ | |
| return self._message_cache | |
| def filter(self, record: logging.LogRecord): | |
| """Cache progress filter that suppresses messages during progress | |
| display output. | |
| Args: | |
| record (logging.LogRecord): A log record to cache. | |
| """ | |
| self._message_cache.append(record) | |
| def check_debug_macros(macros: Iterable[Dict[str, str]], | |
| file_dbg_path: str, | |
| **macro_subs: str | |
| ) -> Tuple[int, int, int]: | |
| """Checks if debug macros contain formatting errors. | |
| Args: | |
| macros (Iterable[Dict[str, str]]): : A groupdict of macro matches. | |
| This is an iterable of dictionaries with group names from the regex | |
| match as the key and the matched string as the value for the key. | |
| file_dbg_path (str): The file path (or other custom string) to display | |
| in debug messages. | |
| macro_subs (Dict[str,str]): Variable-length keyword and replacement | |
| value string pairs to substitute during debug macro checks. | |
| Returns: | |
| Tuple[int, int, int]: A tuple of the number of formatting errors, | |
| number of print specifiers, and number of arguments for the macros | |
| given. | |
| """ | |
| macro_subs = {k.lower(): v for k, v in macro_subs.items()} | |
| arg_cnt, failure_cnt, print_spec_cnt = 0, 0, 0 | |
| for macro in macros: | |
| # Special Specifier Handling | |
| processed_dbg_str = macro['dbg_str'].strip().lower() | |
| logging.debug(f"Inspecting macro: {macro}") | |
| # Make any macro substitutions so further processing is applied | |
| # to the substituted value. | |
| for k in macro_subs.keys(): | |
| processed_dbg_str = processed_dbg_str.replace(k, macro_subs[k]) | |
| logging.debug("Debug macro string after replacements: " | |
| f"{processed_dbg_str}") | |
| # These are very rarely used in debug strings. They are somewhat | |
| # more common in HII code to control text displayed on the | |
| # console. Due to the rarity and likelihood usage is a mistake, | |
| # a warning is shown if found. | |
| specifier_display_replacements = ['%n', '%h', '%e', '%b', '%v'] | |
| for s in specifier_display_replacements: | |
| if s in processed_dbg_str: | |
| logging.warning(f"File: {file_dbg_path}") | |
| logging.warning(f" {s} found in string and ignored:") | |
| logging.warning(f" \"{processed_dbg_str}\"") | |
| processed_dbg_str = processed_dbg_str.replace(s, '') | |
| # These are miscellaneous print specifiers that do not require | |
| # special parsing and simply need to be replaced since they do | |
| # have a corresponding argument associated with them. | |
| specifier_other_replacements = ['%%', '\r', '\n'] | |
| for s in specifier_other_replacements: | |
| if s in processed_dbg_str: | |
| processed_dbg_str = processed_dbg_str.replace(s, '') | |
| processed_dbg_str = re.sub( | |
| r'%[.\-+ ,Ll0-9]*\*[.\-+ ,Ll0-9]*[a-zA-Z]', '%_%_', | |
| processed_dbg_str) | |
| logging.debug(f"Final macro before print specifier scan: " | |
| f"{processed_dbg_str}") | |
| print_spec_cnt = processed_dbg_str.count('%') | |
| # Need to take into account parentheses between args in function | |
| # calls that might be in the args list. Use regex module for | |
| # this one since the recursive pattern match helps simplify | |
| # only matching commas outside nested call groups. | |
| if macro['dbg_args'] is None: | |
| processed_arg_str = "" | |
| else: | |
| processed_arg_str = macro['dbg_args'].strip() | |
| argument_other_replacements = ['\r', '\n'] | |
| for r in argument_other_replacements: | |
| if s in processed_arg_str: | |
| processed_arg_str = processed_arg_str.replace(s, '') | |
| processed_arg_str = re.sub(r' +', ' ', processed_arg_str) | |
| # Handle special case of commas in arg strings - remove them for | |
| # final count to pick up correct number of argument separating | |
| # commas. | |
| processed_arg_str = re.sub( | |
| r'([\"\'])(?:|\\.|[^\\])*?(\1)', | |
| '', | |
| processed_arg_str) | |
| arg_matches = regex.findall( | |
| r'(?:\((?:[^)(]+|(?R))*+\))|(,)', | |
| processed_arg_str, | |
| regex.MULTILINE) | |
| arg_cnt = 0 | |
| if processed_arg_str != '': | |
| arg_cnt = arg_matches.count(',') | |
| if print_spec_cnt != arg_cnt: | |
| logging.error(f"File: {file_dbg_path}") | |
| logging.error(f" Message = {macro['dbg_str']}") | |
| logging.error(f" Arguments = \"{processed_arg_str}\"") | |
| logging.error(f" Specifier Count = {print_spec_cnt}") | |
| logging.error(f" Argument Count = {arg_cnt}") | |
| failure_cnt += 1 | |
| return failure_cnt, print_spec_cnt, arg_cnt | |
| def get_debug_macros(file_contents: str) -> List[Dict[str, str]]: | |
| """Extract debug macros from the given file contents. | |
| Args: | |
| file_contents (str): A string of source file contents that may | |
| contain debug macros. | |
| Returns: | |
| List[Dict[str, str]]: A groupdict of debug macro regex matches | |
| within the file contents provided. | |
| """ | |
| # This is the main regular expression that is responsible for identifying | |
| # DEBUG macros within source files and grouping the macro message string | |
| # and macro arguments strings so they can be further processed. | |
| r = regex.compile( | |
| r'(?>(?P<prologue>DEBUG\s*\(\s*\((?:.*?,))(?:\s*))(?P<dbg_str>.*?(?:\"' | |
| r'(?:[^\"\\]|\\.)*\".*?)*)(?:(?(?=,)(?<dbg_args>.*?(?=(?:\s*\)){2}\s*;' | |
| r'))))(?:\s*\)){2,};?', | |
| regex.MULTILINE | regex.DOTALL) | |
| return [m.groupdict() for m in r.finditer(file_contents)] | |
| def check_macros_in_string(src_str: str, | |
| file_dbg_path: str, | |
| **macro_subs: str) -> Tuple[int, int, int]: | |
| """Checks for debug macro formatting errors in a string. | |
| Args: | |
| src_str (str): Contents of the string with debug macros. | |
| file_dbg_path (str): The file path (or other custom string) to display | |
| in debug messages. | |
| macro_subs (Dict[str,str]): Variable-length keyword and replacement | |
| value string pairs to substitute during debug macro checks. | |
| Returns: | |
| Tuple[int, int, int]: A tuple of the number of formatting errors, | |
| number of print specifiers, and number of arguments for the macros | |
| in the string given. | |
| """ | |
| return check_debug_macros( | |
| get_debug_macros(src_str), file_dbg_path, **macro_subs) | |
| def check_macros_in_file(file: PurePath, | |
| file_dbg_path: str, | |
| show_utf8_decode_warning: bool = False, | |
| **macro_subs: str) -> Tuple[int, int, int]: | |
| """Checks for debug macro formatting errors in a file. | |
| Args: | |
| file (PurePath): The file path to check. | |
| file_dbg_path (str): The file path (or other custom string) to display | |
| in debug messages. | |
| show_utf8_decode_warning (bool, optional): Indicates whether to show | |
| warnings if UTF-8 files fail to decode. Defaults to False. | |
| macro_subs (Dict[str,str]): Variable-length keyword and replacement | |
| value string pairs to substitute during debug macro checks. | |
| Returns: | |
| Tuple[int, int, int]: A tuple of the number of formatting errors, | |
| number of print specifiers, and number of arguments for the macros | |
| in the file given. | |
| """ | |
| try: | |
| return check_macros_in_string( | |
| file.read_text(encoding='utf-8'), file_dbg_path, | |
| **macro_subs) | |
| except UnicodeDecodeError as e: | |
| if show_utf8_decode_warning: | |
| logging.warning( | |
| f"{file_dbg_path} UTF-8 decode error.\n" | |
| " Debug macro code check skipped!\n" | |
| f" -> {str(e)}") | |
| return 0, 0, 0 | |
| def check_macros_in_directory(directory: PurePath, | |
| file_extensions: Iterable[str] = ('.c',), | |
| ignore_git_ignore_files: Optional[bool] = True, | |
| ignore_git_submodules: Optional[bool] = True, | |
| show_progress_bar: Optional[bool] = True, | |
| show_utf8_decode_warning: bool = False, | |
| **macro_subs: str | |
| ) -> int: | |
| """Checks files with the given extension in the given directory for debug | |
| macro formatting errors. | |
| Args: | |
| directory (PurePath): The path to the directory to check. | |
| file_extensions (Iterable[str], optional): An iterable of strings | |
| representing file extensions to check. Defaults to ('.c',). | |
| ignore_git_ignore_files (Optional[bool], optional): Indicates whether | |
| files ignored by git should be ignored for the debug macro check. | |
| Defaults to True. | |
| ignore_git_submodules (Optional[bool], optional): Indicates whether | |
| files located in git submodules should not be checked. Defaults to | |
| True. | |
| show_progress_bar (Optional[bool], optional): Indicates whether to | |
| show a progress bar to show progress status while checking macros. | |
| This is more useful on a very large directories. Defaults to True. | |
| show_utf8_decode_warning (bool, optional): Indicates whether to show | |
| warnings if UTF-8 files fail to decode. Defaults to False. | |
| macro_subs (Dict[str,str]): Variable-length keyword and replacement | |
| value string pairs to substitute during debug macro checks. | |
| Returns: | |
| int: Count of debug macro errors in the directory. | |
| """ | |
| def _get_file_list(root_directory: PurePath, | |
| extensions: Iterable[str]) -> List[Path]: | |
| """Returns a list of files recursively located within the path. | |
| Args: | |
| root_directory (PurePath): A directory Path object to the root | |
| folder. | |
| extensions (Iterable[str]): An iterable of strings that | |
| represent file extensions to recursively search for within | |
| root_directory. | |
| Returns: | |
| List[Path]: List of file Path objects to files found in the | |
| given directory with the given extensions. | |
| """ | |
| def _show_file_discovered_message(file_count: int, | |
| elapsed_time: float) -> None: | |
| print(f"\rDiscovered {file_count:,} files in", | |
| f"{current_start_delta:-.0f}s" | |
| f"{'.' * min(int(current_start_delta), 40)}", end="\r") | |
| start_time = timeit.default_timer() | |
| previous_indicator_time = start_time | |
| files = [] | |
| for file in root_directory.rglob('*'): | |
| if file.suffix in extensions: | |
| files.append(Path(file)) | |
| # Give an indicator progress is being made | |
| # This has a negligible impact on overall performance | |
| # with print emission limited to half second intervals. | |
| current_time = timeit.default_timer() | |
| current_start_delta = current_time - start_time | |
| if current_time - previous_indicator_time >= 0.5: | |
| # Since this rewrites the line, it can be considered a form | |
| # of progress bar | |
| if show_progress_bar: | |
| _show_file_discovered_message(len(files), | |
| current_start_delta) | |
| previous_indicator_time = current_time | |
| if show_progress_bar: | |
| _show_file_discovered_message(len(files), current_start_delta) | |
| print() | |
| return files | |
| logging.info(f"Checking Debug Macros in directory: " | |
| f"{directory.resolve()}\n") | |
| logging.info("Gathering the overall file list. This might take a" | |
| "while.\n") | |
| start_time = timeit.default_timer() | |
| file_list = set(_get_file_list(directory, file_extensions)) | |
| end_time = timeit.default_timer() - start_time | |
| logging.debug(f"[PERF] File search found {len(file_list):,} files in " | |
| f"{end_time:.2f} seconds.") | |
| if ignore_git_ignore_files: | |
| logging.info("Getting git ignore files...") | |
| start_time = timeit.default_timer() | |
| ignored_file_paths = GitHelpers.get_git_ignored_paths(directory) | |
| end_time = timeit.default_timer() - start_time | |
| logging.debug(f"[PERF] File ignore gathering took {end_time:.2f} " | |
| f"seconds.") | |
| logging.info("Ignoring git ignore files...") | |
| logging.debug(f"File list count before git ignore {len(file_list):,}") | |
| start_time = timeit.default_timer() | |
| file_list = file_list.difference(ignored_file_paths) | |
| end_time = timeit.default_timer() - start_time | |
| logging.info(f" {len(ignored_file_paths):,} files are ignored by git") | |
| logging.info(f" {len(file_list):,} files after removing " | |
| f"ignored files") | |
| logging.debug(f"[PERF] File ignore calculation took {end_time:.2f} " | |
| f"seconds.") | |
| if ignore_git_submodules: | |
| logging.info("Ignoring git submodules...") | |
| submodule_paths = GitHelpers.get_git_submodule_paths(directory) | |
| if submodule_paths: | |
| logging.debug(f"File list count before git submodule exclusion " | |
| f"{len(file_list):,}") | |
| start_time = timeit.default_timer() | |
| file_list = [f for f in file_list | |
| if not f.is_relative_to(*submodule_paths)] | |
| end_time = timeit.default_timer() - start_time | |
| for path in enumerate(submodule_paths): | |
| logging.debug(" {0}. {1}".format(*path)) | |
| logging.info(f" {len(submodule_paths):,} submodules found") | |
| logging.info(f" {len(file_list):,} files will be examined after " | |
| f"excluding files in submodules") | |
| logging.debug(f"[PERF] Submodule exclusion calculation took " | |
| f"{end_time:.2f} seconds.") | |
| else: | |
| logging.warning("No submodules found") | |
| logging.info(f"\nStarting macro check on {len(file_list):,} files.") | |
| cache_progress_filter = CacheDuringProgressFilter() | |
| handler = next((h for h in logging.getLogger().handlers if h.get_name() == | |
| 'stdout_logger_handler'), None) | |
| if handler is not None: | |
| handler.addFilter(cache_progress_filter) | |
| start_time = timeit.default_timer() | |
| failure_cnt, file_cnt = 0, 0 | |
| for file_cnt, file in enumerate(file_list): | |
| file_rel_path = str(file.relative_to(directory)) | |
| failure_cnt += check_macros_in_file( | |
| file, file_rel_path, show_utf8_decode_warning, | |
| **macro_subs)[0] | |
| if show_progress_bar: | |
| _show_progress(file_cnt, len(file_list), | |
| f" {failure_cnt} errors" if failure_cnt > 0 else "") | |
| if show_progress_bar: | |
| _show_progress(len(file_list), len(file_list), | |
| f" {failure_cnt} errors" if failure_cnt > 0 else "") | |
| print("\n", flush=True) | |
| end_time = timeit.default_timer() - start_time | |
| if handler is not None: | |
| handler.removeFilter(cache_progress_filter) | |
| for record in cache_progress_filter.message_cache: | |
| handler.emit(record) | |
| logging.debug(f"[PERF] The macro check operation took {end_time:.2f} " | |
| f"seconds.") | |
| _log_failure_count(failure_cnt, file_cnt) | |
| return failure_cnt | |
| def _log_failure_count(failure_count: int, file_count: int) -> None: | |
| """Logs the failure count. | |
| Args: | |
| failure_count (int): Count of failures to log. | |
| file_count (int): Count of files with failures. | |
| """ | |
| if failure_count > 0: | |
| logging.error("\n") | |
| logging.error(f"{failure_count:,} debug macro errors in " | |
| f"{file_count:,} files") | |
| def _show_progress(step: int, total: int, suffix: str = '') -> None: | |
| """Print progress of tick to total. | |
| Args: | |
| step (int): The current step count. | |
| total (int): The total step count. | |
| suffix (str): String to print at the end of the progress bar. | |
| """ | |
| global _progress_start_time | |
| if step == 0: | |
| _progress_start_time = timeit.default_timer() | |
| terminal_col = shutil.get_terminal_size().columns | |
| var_consume_len = (len("Progress|\u2588| 000.0% Complete 000s") + | |
| len(suffix)) | |
| avail_len = terminal_col - var_consume_len | |
| percent = f"{100 * (step / float(total)):3.1f}" | |
| filled = int(avail_len * step // total) | |
| bar = '\u2588' * filled + '-' * (avail_len - filled) | |
| step_time = timeit.default_timer() - _progress_start_time | |
| print(f'\rProgress|{bar}| {percent}% Complete {step_time:-3.0f}s' | |
| f'{suffix}', end='\r') | |
| def _module_invocation_check_macros_in_directory_wrapper() -> int: | |
| """Provides an command-line argument wrapper for checking debug macros. | |
| Returns: | |
| int: The system exit code value. | |
| """ | |
| import argparse | |
| import builtins | |
| def _check_dir_path(dir_path: str) -> bool: | |
| """Returns the absolute path if the path is a directory." | |
| Args: | |
| dir_path (str): A directory file system path. | |
| Raises: | |
| NotADirectoryError: The directory path given is not a directory. | |
| Returns: | |
| bool: True if the path is a directory else False. | |
| """ | |
| abs_dir_path = os.path.abspath(dir_path) | |
| if os.path.isdir(dir_path): | |
| return abs_dir_path | |
| else: | |
| raise NotADirectoryError(abs_dir_path) | |
| def _check_file_path(file_path: str) -> bool: | |
| """Returns the absolute path if the path is a file." | |
| Args: | |
| file_path (str): A file path. | |
| Raises: | |
| FileExistsError: The path is not a valid file. | |
| Returns: | |
| bool: True if the path is a valid file else False. | |
| """ | |
| abs_file_path = os.path.abspath(file_path) | |
| if os.path.isfile(file_path): | |
| return abs_file_path | |
| else: | |
| raise FileExistsError(file_path) | |
| def _quiet_print(*args, **kwargs): | |
| """Replaces print when quiet is requested to prevent printing messages. | |
| """ | |
| pass | |
| root_logger = logging.getLogger() | |
| root_logger.setLevel(logging.DEBUG) | |
| stdout_logger_handler = logging.StreamHandler(sys.stdout) | |
| stdout_logger_handler.set_name('stdout_logger_handler') | |
| stdout_logger_handler.setLevel(logging.INFO) | |
| stdout_logger_handler.setFormatter(logging.Formatter('%(message)s')) | |
| root_logger.addHandler(stdout_logger_handler) | |
| parser = argparse.ArgumentParser( | |
| prog=PROGRAM_NAME, | |
| description=( | |
| "Checks for debug macro formatting " | |
| "errors within files recursively located within " | |
| "a given directory."), | |
| formatter_class=RawTextHelpFormatter) | |
| io_req_group = parser.add_mutually_exclusive_group(required=True) | |
| io_opt_group = parser.add_argument_group( | |
| "Optional input and output") | |
| git_group = parser.add_argument_group("Optional git control") | |
| io_req_group.add_argument('-w', '--workspace-directory', | |
| type=_check_dir_path, | |
| help="Directory of source files to check.\n\n") | |
| io_req_group.add_argument('-i', '--input-file', nargs='?', | |
| type=_check_file_path, | |
| help="File path for an input file to check.\n\n" | |
| "Note that some other options do not apply " | |
| "if a single file is specified such as " | |
| "the\ngit options and file extensions.\n\n") | |
| io_opt_group.add_argument('-l', '--log-file', | |
| nargs='?', | |
| default=None, | |
| const='debug_macro_check.log', | |
| help="File path for log output.\n" | |
| "(default: if the flag is given with no " | |
| "file path then a file called\n" | |
| "debug_macro_check.log is created and used " | |
| "in the current directory)\n\n") | |
| io_opt_group.add_argument('-s', '--substitution-file', | |
| type=_check_file_path, | |
| help="A substitution YAML file specifies string " | |
| "substitutions to perform within the debug " | |
| "macro.\n\nThis is intended to be a simple " | |
| "mechanism to expand the rare cases of pre-" | |
| "processor\nmacros without directly " | |
| "involving the pre-processor. The file " | |
| "consists of one or more\nstring value " | |
| "pairs where the key is the identifier to " | |
| "replace and the value is the value\nto " | |
| "replace it with.\n\nThis can also be used " | |
| "as a method to ignore results by " | |
| "replacing the problematic string\nwith a " | |
| "different string.\n\n") | |
| io_opt_group.add_argument('-v', '--verbose-log-file', | |
| action='count', | |
| default=0, | |
| help="Set file logging verbosity level.\n" | |
| " - None: Info & > level messages\n" | |
| " - '-v': + Debug level messages\n" | |
| " - '-vv': + File name and function\n" | |
| " - '-vvv': + Line number\n" | |
| " - '-vvvv': + Timestamp\n" | |
| "(default: verbose logging is not enabled)" | |
| "\n\n") | |
| io_opt_group.add_argument('-n', '--no-progress-bar', action='store_true', | |
| help="Disables progress bars.\n" | |
| "(default: progress bars are used in some" | |
| "places to show progress)\n\n") | |
| io_opt_group.add_argument('-q', '--quiet', action='store_true', | |
| help="Disables console output.\n" | |
| "(default: console output is enabled)\n\n") | |
| io_opt_group.add_argument('-u', '--utf8w', action='store_true', | |
| help="Shows warnings for file UTF-8 decode " | |
| "errors.\n" | |
| "(default: UTF-8 decode errors are not " | |
| "shown)\n\n") | |
| git_group.add_argument('-df', '--do-not-ignore-git-ignore-files', | |
| action='store_true', | |
| help="Do not ignore git ignored files.\n" | |
| "(default: files in git ignore files are " | |
| "ignored)\n\n") | |
| git_group.add_argument('-ds', '--do-not-ignore-git_submodules', | |
| action='store_true', | |
| help="Do not ignore files in git submodules.\n" | |
| "(default: files in git submodules are " | |
| "ignored)\n\n") | |
| parser.add_argument('-e', '--extensions', nargs='*', default=['.c'], | |
| help="List of file extensions to include.\n" | |
| "(default: %(default)s)") | |
| args = parser.parse_args() | |
| if args.quiet: | |
| # Don't print in the few places that directly print | |
| builtins.print = _quiet_print | |
| stdout_logger_handler.addFilter(QuietFilter(args.quiet)) | |
| if args.log_file: | |
| file_logger_handler = logging.FileHandler(filename=args.log_file, | |
| mode='w', encoding='utf-8') | |
| # In an ideal world, everyone would update to the latest Python | |
| # minor version (3.10) after a few weeks/months. Since that's not the | |
| # case, resist from using structural pattern matching in Python 3.10. | |
| # https://peps.python.org/pep-0636/ | |
| if args.verbose_log_file == 0: | |
| file_logger_handler.setLevel(logging.INFO) | |
| file_logger_formatter = logging.Formatter( | |
| '%(levelname)-8s %(message)s') | |
| elif args.verbose_log_file == 1: | |
| file_logger_handler.setLevel(logging.DEBUG) | |
| file_logger_formatter = logging.Formatter( | |
| '%(levelname)-8s %(message)s') | |
| elif args.verbose_log_file == 2: | |
| file_logger_handler.setLevel(logging.DEBUG) | |
| file_logger_formatter = logging.Formatter( | |
| '[%(filename)s - %(funcName)20s() ] %(levelname)-8s ' | |
| '%(message)s') | |
| elif args.verbose_log_file == 3: | |
| file_logger_handler.setLevel(logging.DEBUG) | |
| file_logger_formatter = logging.Formatter( | |
| '[%(filename)s:%(lineno)s - %(funcName)20s() ] ' | |
| '%(levelname)-8s %(message)s') | |
| elif args.verbose_log_file == 4: | |
| file_logger_handler.setLevel(logging.DEBUG) | |
| file_logger_formatter = logging.Formatter( | |
| '%(asctime)s [%(filename)s:%(lineno)s - %(funcName)20s() ]' | |
| ' %(levelname)-8s %(message)s') | |
| else: | |
| file_logger_handler.setLevel(logging.DEBUG) | |
| file_logger_formatter = logging.Formatter( | |
| '%(asctime)s [%(filename)s:%(lineno)s - %(funcName)20s() ]' | |
| ' %(levelname)-8s %(message)s') | |
| file_logger_handler.addFilter(ProgressFilter()) | |
| file_logger_handler.setFormatter(file_logger_formatter) | |
| root_logger.addHandler(file_logger_handler) | |
| logging.info(PROGRAM_NAME + "\n") | |
| substitution_data = {} | |
| if args.substitution_file: | |
| logging.info(f"Loading substitution file {args.substitution_file}") | |
| with open(args.substitution_file, 'r') as sf: | |
| substitution_data = yaml.safe_load(sf) | |
| if args.workspace_directory: | |
| return check_macros_in_directory( | |
| Path(args.workspace_directory), | |
| args.extensions, | |
| not args.do_not_ignore_git_ignore_files, | |
| not args.do_not_ignore_git_submodules, | |
| not args.no_progress_bar, | |
| args.utf8w, | |
| **substitution_data) | |
| else: | |
| curr_dir = Path(__file__).parent | |
| input_file = Path(args.input_file) | |
| rel_path = str(input_file) | |
| if input_file.is_relative_to(curr_dir): | |
| rel_path = str(input_file.relative_to(curr_dir)) | |
| logging.info(f"Checking Debug Macros in File: " | |
| f"{input_file.resolve()}\n") | |
| start_time = timeit.default_timer() | |
| failure_cnt = check_macros_in_file( | |
| input_file, | |
| rel_path, | |
| args.utf8w, | |
| **substitution_data)[0] | |
| end_time = timeit.default_timer() - start_time | |
| logging.debug(f"[PERF] The file macro check operation took " | |
| f"{end_time:.2f} seconds.") | |
| _log_failure_count(failure_cnt, 1) | |
| return failure_cnt | |
| if __name__ == '__main__': | |
| # The exit status value is the number of macro formatting errors found. | |
| # Therefore, if no macro formatting errors are found, 0 is returned. | |
| # Some systems require the return value to be in the range 0-127, so | |
| # a lower maximum of 100 is enforced to allow a wide range of potential | |
| # values with a reasonably large maximum. | |
| try: | |
| sys.exit(max(_module_invocation_check_macros_in_directory_wrapper(), | |
| 100)) | |
| except KeyboardInterrupt: | |
| logging.warning("Exiting due to keyboard interrupt.") | |
| # Actual formatting errors are only allowed to reach 100. | |
| # 101 signals a keyboard interrupt. | |
| sys.exit(101) | |
| except FileExistsError as e: | |
| # 102 signals a file not found error. | |
| logging.critical(f"Input file {e.args[0]} does not exist.") | |
| sys.exit(102) |