cocotb 2.0.0b1__cp313-cp313-win32.whl → 2.0.0rc2__cp313-cp313-win32.whl

cocotb/logging.py

@@ -10,74 +10,125 @@ Everything related to logging
 
 import logging
 import os
+import re
 import sys
+import time
+import warnings
 from functools import wraps
 from pathlib import Path
-from typing import Union
+from typing import Optional, Tuple, Union
 
-from cocotb import _ANSI, simulator
+import cocotb.simtime
+from cocotb import simulator
+from cocotb._ANSI import ANSI
 from cocotb._deprecation import deprecated
-from cocotb._utils import want_color_output
-from cocotb.utils import get_sim_time, get_time_from_sim_steps
+from cocotb.simtime import get_sim_time
+from cocotb.utils import get_time_from_sim_steps
 
-try:
-    _suppress = int(os.environ.get("COCOTB_REDUCED_LOG_FMT", "1"))
-except ValueError:
-    _suppress = 1
+__all__ = (
+    "ANSI",
+    "SimLog",
+    "SimLogFormatter",
+    "SimTimeContextFilter",
+    "default_config",
+    "strip_ansi",
+)
 
-# Column alignment
-_LEVEL_CHARS = len("CRITICAL")
-_RECORD_CHARS = 34
-_FILENAME_CHARS = 20
-_LINENO_CHARS = 4
-_FUNCNAME_CHARS = 31
+ANSI.__module__ = __name__
 
 # Custom log level
 logging.TRACE = 5  # type: ignore[attr-defined]  # type checkers don't like adding module attributes after the fact
 logging.addLevelName(5, "TRACE")
 
 
-__all__ = (
-    "SimColourLogFormatter",
-    "SimLog",
-    "SimLogFormatter",
-    "SimTimeContextFilter",
-    "default_config",
-)
+strip_ansi: bool = False
+"""Whether the default formatter should strip ANSI (color) escape codes from log messages.
+
+Defaults to ``True`` if ``stdout`` is not a TTY and ``False`` otherwise;
+but can be overridden with the :envvar:`NO_COLOR` or :envvar:`COCOTB_ANSI_OUTPUT` environment variable.
+"""
 
 
-def default_config() -> None:
+def default_config(
+    reduced_log_fmt: bool = True,
+    strip_ansi: Optional[bool] = None,
+    prefix_format: Optional[str] = None,
+) -> None:
     """Apply the default cocotb log formatting to the root logger.
 
-    This hooks up the logger to write to stdout, using either
-    :class:`SimColourLogFormatter` or :class:`SimLogFormatter` depending
-    on whether colored output is requested. It also adds a
-    :class:`SimTimeContextFilter` filter so that
-    :attr:`~logging.LogRecord.created_sim_time` is available to the formatter.
+    This hooks up the logger to write to stdout, using :class:`SimLogFormatter` for formatting.
+    It also adds a :class:`SimTimeContextFilter` filter so that the
+    :attr:`~logging.LogRecord.created_sim_time` attribute on :class:`~logging.LogRecord`
+    is available to the formatter.
 
     If desired, this logging configuration can be overwritten by calling
-    ``logging.basicConfig(..., force=True)`` (in Python 3.8 onwards), or by
-    manually resetting the root logger instance.
+    ``logging.basicConfig(..., force=True)`` (in Python 3.8 onwards),
+    or by manually resetting the root logger instance.
     An example of this can be found in the section on :ref:`rotating-logger`.
 
+    Args:
+        reduced_log_fmt:
+            If ``True``, use a reduced log format that does not include the
+            filename, line number, and function name in the log prefix.
+
+            .. versionadded:: 2.0
+
+        strip_ansi:
+            If ``True``, strip ANSI (color) escape codes in log messages.
+            If ``False``, do not strip ANSI escape codes in log messages.
+            If ``None``, use the value of :data:`strip_ansi`.
+
+            .. versionadded:: 2.0
+
+        prefix_format:
+            An f-string to build a prefix for each log message.
+
+            .. versionadded:: 2.0
+
     .. versionadded:: 1.4
 
     .. versionchanged:: 2.0
-        No longer set the log level of the ``cocotb`` and ``gpi`` loggers.
+        Now captures warnings and outputs them through the logging system using
+        :func:`logging.captureWarnings`.
     """
+    logging.basicConfig()
+
     hdlr = logging.StreamHandler(sys.stdout)
     hdlr.addFilter(SimTimeContextFilter())
-    if want_color_output():
-        hdlr.setFormatter(SimColourLogFormatter())
-    else:
-        hdlr.setFormatter(SimLogFormatter())
-
-    logging.basicConfig()
+    hdlr.setFormatter(
+        SimLogFormatter(
+            reduced_log_fmt=reduced_log_fmt,
+            strip_ansi=strip_ansi,
+            prefix_format=prefix_format,
+        )
+    )
     logging.getLogger().handlers = [hdlr]  # overwrite default handlers
 
+    logging.getLogger("cocotb").setLevel(logging.INFO)
+    logging.getLogger("gpi").setLevel(logging.INFO)
 
-def _init(_: object) -> None:
-    """Set cocotb and pygpi log levels."""
+    logging.captureWarnings(True)
+
+
+def _init() -> None:
+    """cocotb-specific logging setup.
+
+    - Decides whether ANSI escape code stripping is desired by checking
+      :envvar:`NO_COLOR` and :envvar:`COCOTB_ANSI_OUTPUT`.
+    - Initializes the GPI logger and sets up the GPI logging optimization.
+    - Sets the log level of the ``"cocotb"`` and ``"gpi"`` loggers based on
+      :envvar:`COCOTB_LOG_LEVEL` and :envvar:`GPI_LOG_LEVEL`, respectively.
+    """
+    global strip_ansi
+    strip_ansi = not sys.stdout.isatty()  # default to color for TTYs
+    if os.getenv("NO_COLOR", ""):
+        strip_ansi = True
+    ansi_output = os.getenv("COCOTB_ANSI_OUTPUT")
+    if ansi_output is not None:
+        strip_ansi = not int(ansi_output)
+    in_gui = os.getenv("GUI")
+    if in_gui is not None:
+        strip_ansi = bool(int(in_gui))
 
     # Monkeypatch "gpi" logger with function that also sets a PyGPI-local logger level
     # as an optimization.
@@ -95,8 +146,11 @@ def _init(_: object) -> None:
     simulator.initialize_logger(_log_from_c, logging.getLogger)
 
     # Set "cocotb" and "gpi" logger based on environment variables
-    def set_level(logger_name: str, envvar: str, default_level: str) -> None:
-        log_level = os.environ.get(envvar, default_level)
+    def set_level(logger_name: str, envvar: str) -> None:
+        log_level = os.environ.get(envvar)
+        if log_level is None:
+            return
+
         log_level = log_level.upper()
 
         logger = logging.getLogger(logger_name)
@@ -113,18 +167,24 @@ def _init(_: object) -> None:
                 f"levels: {valid_levels}"
             ) from None
 
-    set_level("gpi", "GPI_LOG_LEVEL", "INFO")
-    set_level("cocotb", "COCOTB_LOG_LEVEL", "INFO")
+    set_level("gpi", "GPI_LOG_LEVEL")
+    set_level("cocotb", "COCOTB_LOG_LEVEL")
 
 
-def _setup_formatter(_: object) -> None:
-    """Setup cocotb's logging formatter."""
-    default_config()
+def _configure(_: object) -> None:
+    """Configure basic logging."""
+    reduced_log_fmt = True
+    try:
+        reduced_log_fmt = bool(int(os.environ.get("COCOTB_REDUCED_LOG_FMT", "1")))
+    except ValueError:
+        pass
+    prefix_format = os.environ.get("COCOTB_LOG_PREFIX", None)
+    default_config(reduced_log_fmt=reduced_log_fmt, prefix_format=prefix_format)
 
 
 @deprecated('Use `logging.getLogger(f"{name}.0x{ident:x}")` instead')
 def SimLog(name: str, ident: Union[int, None] = None) -> logging.Logger:
-    """Like logging.getLogger, but append a numeric identifier to the name.
+    """Like :func:`logging.getLogger`, but append a numeric identifier to the name.
 
     Args:
         name: Logger name.
@@ -146,18 +206,12 @@ class SimTimeContextFilter(logging.Filter):
     """
     A filter to inject simulator times into the log records.
 
-    This uses the approach described in the :ref:`Python logging cookbook <python:filters-contextual>`.
-
-    This adds the :attr:`~logging.LogRecord.created_sim_time` attribute.
+    This uses the approach described in the :ref:`Python logging cookbook <python:filters-contextual>`
+    which adds the :attr:`~logging.LogRecord.created_sim_time` attribute.
 
     .. versionadded:: 1.4
     """
 
-    # needed to make our docs render well
-    def __init__(self) -> None:
-        """"""
-        super().__init__()
-
     def filter(self, record: logging.LogRecord) -> bool:
         try:
             record.created_sim_time = get_sim_time()
@@ -174,13 +228,65 @@ class SimLogFormatter(logging.Formatter):
     This will only add simulator timestamps if the handler object this
     formatter is attached to has a :class:`SimTimeContextFilter` filter
     attached, which cocotb ensures by default.
+
+    See :func:`.default_config` for a description of the arguments.
     """
 
-    # Removes the arguments from the base class. Docstring needed to make
-    # sphinx happy.
-    def __init__(self) -> None:
-        """Takes no arguments."""
-        super().__init__()
+    loglevel2colour = {
+        logging.TRACE: "",  # type: ignore[attr-defined]  # type checkers don't like adding module attributes after the fact
+        logging.DEBUG: "",
+        logging.INFO: "",
+        logging.WARNING: ANSI.YELLOW_FG,
+        logging.ERROR: ANSI.RED_FG,
+        logging.CRITICAL: ANSI.RED_BG + ANSI.BLACK_FG,
+    }
+
+    prefix_func_globals = {
+        "time": time,
+        "simtime": cocotb.simtime,
+        "ANSI": ANSI,
+    }
+
+    def __init__(
+        self,
+        *,
+        reduced_log_fmt: bool = True,
+        strip_ansi: Union[bool, None] = None,
+        prefix_format: Optional[str] = None,
+    ) -> None:
+        self._reduced_log_fmt = reduced_log_fmt
+        self._strip_ansi = strip_ansi
+        self._prefix_func = (
+            eval(
+                f"lambda record: f'''{prefix_format}'''",
+                type(self).prefix_func_globals,
+            )
+            if prefix_format is not None
+            else None
+        )
+        self._ansi_escape_pattern = re.compile(
+            r"""
+                (?: # either 7-bit C1, two bytes, ESC Fe (omitting CSI)
+                    \x1B
+                    [@-Z\\-_]
+                |   # or a single 8-bit byte Fe (omitting CSI)
+                    [\x80-\x9A\x9C-\x9F]
+                |   # or CSI + control codes
+                    (?: # 7-bit CSI, ESC [
+                        \x1B\[
+                    |   # 8-bit CSI, 9B
+                        \x9B
+                    )
+                    [0-?]*  # Parameter bytes
+                    [ -/]*  # Intermediate bytes
+                    [@-~]   # Final byte
+                )
+            """,
+            re.VERBOSE,
+        )
+
+    def strip_ansi(self) -> bool:
+        return strip_ansi if self._strip_ansi is None else self._strip_ansi
 
     # Justify and truncate
     @staticmethod
@@ -195,88 +301,108 @@ class SimLogFormatter(logging.Formatter):
             return ".." + string[(chars - 2) * -1 :]
         return string.rjust(chars)
 
-    def _format(
-        self, level: str, record: logging.LogRecord, msg: str, coloured: bool = False
-    ) -> str:
+    def formatPrefix(self, record: logging.LogRecord) -> Tuple[str, int]:
         sim_time = getattr(record, "created_sim_time", None)
         if sim_time is None:
             sim_time_str = "  -.--ns"
         else:
             time_ns = get_time_from_sim_steps(sim_time, "ns")
             sim_time_str = f"{time_ns:6.2f}ns"
-        prefix = (
-            sim_time_str.rjust(11)
-            + " "
-            + level
-            + " "
-            + self.ljust(record.name, _RECORD_CHARS)
-            + " "
-        )
-        if not _suppress:
-            prefix += (
-                self.rjust(Path(record.filename).name, _FILENAME_CHARS)
-                + ":"
-                + self.ljust(str(record.lineno), _LINENO_CHARS)
-                + " in "
-                + self.ljust(str(record.funcName), _FUNCNAME_CHARS)
-                + " "
-            )
 
-        # these lines are copied from the built-in logger
+        if self.strip_ansi():
+            highlight_start = ""
+            highlight_end = ""
+        else:
+            highlight_start = self.loglevel2colour.get(record.levelno, "")
+            highlight_end = ANSI.DEFAULT
+
+        if self._prefix_func is not None:
+            prefix = self._prefix_func(record)
+            stripped_prefix = self._ansi_escape_pattern.sub("", prefix)
+            prefix_len = len(stripped_prefix)
+            return prefix, prefix_len
+        else:
+            prefix = f"{sim_time_str:>11} {highlight_start}{record.levelname:<8}{highlight_end} {self.ljust(record.name, 34)} "
+            if not self._reduced_log_fmt:
+                prefix = f"{prefix}{self.rjust(Path(record.filename).name, 20)}:{record.lineno:<4} in {self.ljust(str(record.funcName), 31)} "
+
+            prefix_len = len(prefix) - len(highlight_start) - len(highlight_end)
+            return prefix, prefix_len
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        msg = record.getMessage()
+
+        if self.strip_ansi():
+            highlight_start = ""
+            highlight_end = ""
+            msg = self._ansi_escape_pattern.sub("", msg)
+        else:
+            highlight_start = self.loglevel2colour.get(record.levelno, "")
+            highlight_end = ANSI.DEFAULT
+
+        msg = f"{highlight_start}{msg}{highlight_end}"
+
+        return msg
+
+    def formatExcInfo(self, record: logging.LogRecord) -> str:
+        msg = ""
+
+        # these lines are copied and updated from the built-in logger
         if record.exc_info:
             # Cache the traceback text to avoid converting it multiple times
             # (it's constant anyway)
             if not record.exc_text:
                 record.exc_text = self.formatException(record.exc_info)
         if record.exc_text:
-            if msg[-1:] != "\n":
-                msg = msg + "\n"
-            msg = msg + record.exc_text
+            msg += record.exc_text
+        if record.stack_info:
+            if not msg.endswith("\n"):
+                msg += "\n"
+            msg += self.formatStack(record.stack_info)
 
-        prefix_len = len(prefix)
-        if coloured:
-            prefix_len -= len(level) - _LEVEL_CHARS
-        pad = "\n" + " " * (prefix_len)
-        return prefix + pad.join(msg.split("\n"))
+        return msg
 
     def format(self, record: logging.LogRecord) -> str:
-        """Prettify the log output by annotating with simulation time."""
+        prefix, prefix_len = self.formatPrefix(record)
+        msg = self.formatMessage(record)
+        exc_info = self.formatExcInfo(record)
 
-        msg = record.getMessage()
-        level = record.levelname.ljust(_LEVEL_CHARS)
+        lines = msg.splitlines()
+        lines.extend(exc_info.splitlines())
 
-        return self._format(level, record, msg)
+        # add prefix to first line of message
+        lines[0] = prefix + lines[0]
 
+        # add padding to each line of message
+        pad = "\n" + " " * prefix_len
+        return pad.join(lines)
 
-class SimColourLogFormatter(SimLogFormatter):
-    """Log formatter to provide consistent log message handling."""
 
-    loglevel2colour = {
-        logging.TRACE: "%s",  # type: ignore[attr-defined]  # type checkers don't like adding module attributes after the fact
-        logging.DEBUG: "%s",
-        logging.INFO: "%s",
-        logging.WARNING: _ANSI.COLOR_WARNING + "%s" + _ANSI.COLOR_DEFAULT,
-        logging.ERROR: _ANSI.COLOR_ERROR + "%s" + _ANSI.COLOR_DEFAULT,
-        logging.CRITICAL: _ANSI.COLOR_CRITICAL + "%s" + _ANSI.COLOR_DEFAULT,
-    }
-
-    def format(self, record: logging.LogRecord) -> str:
-        """Prettify the log output by annotating with simulation time."""
+class SimColourLogFormatter(SimLogFormatter):
+    """Log formatter similar to :class:`SimLogFormatter`, but with colored output by default.
 
-        msg = record.getMessage()
+    .. deprecated:: 2.0
+        Use :class:`!SimLogFormatter` with ``strip_ansi=False`` instead.
+    """
 
-        # Need to colour each line in case coloring is applied in the message
-        msg = "\n".join(
-            [
-                SimColourLogFormatter.loglevel2colour.get(record.levelno, "%s") % line
-                for line in msg.split("\n")
-            ]
+    def __init__(
+        self,
+        *,
+        reduced_log_fmt: bool = True,
+        strip_ansi: Union[bool, None] = False,
+        prefix_format: Optional[str] = None,
+    ) -> None:
+        warnings.warn(
+            "SimColourLogFormatter is deprecated and will be removed in a future release. "
+            "Use SimLogFormatter with `strip_ansi=False` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(
+            reduced_log_fmt=reduced_log_fmt,
+            strip_ansi=strip_ansi,
+            prefix_format=prefix_format,
         )
-        level = SimColourLogFormatter.loglevel2colour.get(
-            record.levelno, "%s"
-        ) % record.levelname.ljust(_LEVEL_CHARS)
-
-        return self._format(level, record, msg, coloured=True)
 
 
 def _log_from_c(

cocotb/regression.py

@@ -18,6 +18,7 @@ import warnings
 from enum import auto
 from importlib import import_module
 from typing import (
+    TYPE_CHECKING,
     Callable,
     Coroutine,
     List,
@@ -27,10 +28,10 @@ from typing import (
 import cocotb
 import cocotb._gpi_triggers
 import cocotb.handle
-from cocotb import _ANSI, simulator
-from cocotb._base_triggers import Trigger
+from cocotb import logging as cocotb_logging
+from cocotb import simulator
 from cocotb._decorators import Parameterized, Test
-from cocotb._extended_awaitables import SimTimeoutError, with_timeout
+from cocotb._extended_awaitables import with_timeout
 from cocotb._gpi_triggers import GPITrigger, Timer
 from cocotb._outcomes import Error, Outcome
 from cocotb._test import RunningTest
@@ -40,11 +41,14 @@ from cocotb._utils import (
     DocEnum,
     remove_traceback_frames,
     safe_divide,
-    want_color_output,
 )
 from cocotb._xunit_reporter import XUnitReporter
+from cocotb.logging import ANSI
+from cocotb.simtime import get_sim_time
 from cocotb.task import Task
-from cocotb.utils import get_sim_time
+
+if TYPE_CHECKING:
+    from cocotb._base_triggers import Trigger
 
 __all__ = (
     "Parameterized",
@@ -62,7 +66,12 @@ TestFactory.__module__ = __name__
 
 
 class SimFailure(BaseException):
-    """A Test failure due to simulator failure."""
+    """A Test failure due to simulator failure.
+
+    .. caution::
+        Not to be raised or caught within a test.
+        Only used for marking expected failure with ``expect_error`` in :func:`cocotb.test`.
+    """
 
 
 _logger = logging.getLogger(__name__)
@@ -128,6 +137,11 @@ class RegressionManager:
     :attr:`skipped`, and :attr:`failures` hold placeholder values.
     """
 
+    COLOR_TEST = ANSI.BLUE_FG
+    COLOR_PASSED = ANSI.GREEN_FG
+    COLOR_SKIPPED = ANSI.YELLOW_FG
+    COLOR_FAILED = ANSI.RED_FG
+
     _timer1 = Timer(1)
 
     def __init__(self) -> None:
@@ -365,13 +379,7 @@ class RegressionManager:
 
             @functools.wraps(f)
             async def func(*args: object, **kwargs: object) -> None:
-                running_co = Task(f(*args, **kwargs))
-
-                try:
-                    await with_timeout(running_co, timeout, self._test.timeout_unit)
-                except SimTimeoutError:
-                    running_co.cancel()
-                    raise
+                await with_timeout(f(*args, **kwargs), timeout, self._test.timeout_unit)
         else:
             func = self._test.func
 
@@ -539,8 +547,8 @@ class RegressionManager:
 
     def _log_test_start(self) -> None:
         """Called by :meth:`_execute` to log that a test is starting."""
-        hilight_start = _ANSI.COLOR_TEST if want_color_output() else ""
-        hilight_end = _ANSI.COLOR_DEFAULT if want_color_output() else ""
+        hilight_start = "" if cocotb_logging.strip_ansi else self.COLOR_TEST
+        hilight_end = "" if cocotb_logging.strip_ansi else ANSI.DEFAULT
         self.log.info(
             "%srunning%s %s (%d/%d)%s",
             hilight_start,
@@ -573,8 +581,8 @@ class RegressionManager:
         """Called by :meth:`_execute` when a test is skipped."""
 
         # log test results
-        hilight_start = _ANSI.COLOR_SKIPPED if want_color_output() else ""
-        hilight_end = _ANSI.COLOR_DEFAULT if want_color_output() else ""
+        hilight_start = "" if cocotb_logging.strip_ansi else self.COLOR_SKIPPED
+        hilight_end = "" if cocotb_logging.strip_ansi else ANSI.DEFAULT
         self.log.info(
             "%sskipping%s %s (%d/%d)%s",
             hilight_start,
@@ -616,8 +624,8 @@ class RegressionManager:
         """Called by :meth:`_execute` when a test initialization fails."""
 
         # log test results
-        hilight_start = _ANSI.COLOR_FAILED if want_color_output() else ""
-        hilight_end = _ANSI.COLOR_DEFAULT if want_color_output() else ""
+        hilight_start = "" if cocotb_logging.strip_ansi else self.COLOR_FAILED
+        hilight_end = "" if cocotb_logging.strip_ansi else ANSI.DEFAULT
         self.log.exception(
             "%sFailed to initialize%s %s! (%d/%d)%s",
             hilight_start,
@@ -662,8 +670,8 @@ class RegressionManager:
         result: Union[Exception, None],
         msg: Union[str, None],
     ) -> None:
-        start_hilight = _ANSI.COLOR_PASSED if want_color_output() else ""
-        stop_hilight = _ANSI.COLOR_DEFAULT if want_color_output() else ""
+        start_hilight = "" if cocotb_logging.strip_ansi else self.COLOR_PASSED
+        stop_hilight = "" if cocotb_logging.strip_ansi else ANSI.DEFAULT
         if msg is None:
             rest = ""
         else:
@@ -715,8 +723,8 @@ class RegressionManager:
         result: Union[BaseException, None],
         msg: Union[str, None],
     ) -> None:
-        start_hilight = _ANSI.COLOR_FAILED if want_color_output() else ""
-        stop_hilight = _ANSI.COLOR_DEFAULT if want_color_output() else ""
+        start_hilight = "" if cocotb_logging.strip_ansi else self.COLOR_FAILED
+        stop_hilight = "" if cocotb_logging.strip_ansi else ANSI.DEFAULT
         if msg is None:
             rest = ""
         else:
@@ -821,28 +829,28 @@ class RegressionManager:
         summary += LINE_SEP
 
         test_line = "** {a:<{a_len}}  {start}{b:^{b_len}}{end}  {c:>{c_len}.2f}   {d:>{d_len}.2f}   {e:>{e_len}}  **\n"
+        hilite: str
+        lolite: str
         for result in self._test_results:
-            hilite = ""
-            lolite = ""
-
             if result.passed is None:
                 ratio = "-.--"
                 pass_fail_str = "SKIP"
-                if want_color_output():
-                    hilite = _ANSI.COLOR_SKIPPED
-                    lolite = _ANSI.COLOR_DEFAULT
+                hilite = self.COLOR_SKIPPED
+                lolite = ANSI.DEFAULT
             elif result.passed:
                 ratio = format(result.ratio, "0.2f")
                 pass_fail_str = "PASS"
-                if want_color_output():
-                    hilite = _ANSI.COLOR_PASSED
-                    lolite = _ANSI.COLOR_DEFAULT
+                hilite = self.COLOR_PASSED
+                lolite = ANSI.DEFAULT
             else:
                 ratio = format(result.ratio, "0.2f")
                 pass_fail_str = "FAIL"
-                if want_color_output():
-                    hilite = _ANSI.COLOR_FAILED
-                    lolite = _ANSI.COLOR_DEFAULT
+                hilite = self.COLOR_FAILED
+                lolite = ANSI.DEFAULT
+
+            if cocotb_logging.strip_ansi:
+                hilite = ""
+                lolite = ""
 
             test_dict = {
                 "a": result.test_fullname,

cocotb/share/include/cocotb_utils.h

@@ -19,9 +19,9 @@
 #define xstr(a) str(a)
 #define str(a) #a
 
-extern "C" COCOTBUTILS_EXPORT void* utils_dyn_open(const char* lib_name);
-extern "C" COCOTBUTILS_EXPORT void* utils_dyn_sym(void* handle,
-                                                  const char* sym_name);
+extern "C" COCOTBUTILS_EXPORT void *utils_dyn_open(const char *lib_name);
+extern "C" COCOTBUTILS_EXPORT void *utils_dyn_sym(void *handle,
+                                                  const char *sym_name);
 extern "C" COCOTBUTILS_EXPORT int is_python_context;
 
 // to_python and to_simulator are implemented as macros instead of functions so