format.c File Reference

Log format parser implementation. More...

Go to the source code of this file.

Functions
log_template_t *	log_template_parse (const char *format_str, bool console_only)
void	log_template_free (log_template_t *format)
int	log_template_apply (const log_template_t *format, char *buf, size_t buf_size, log_level_t level, const char *timestamp, const char *file, int line, const char *func, uint64_t tid, const char *message, bool use_colors, uint64_t time_nanoseconds)

Detailed Description

Log format parser implementation.

Definition in file log/format.c.

Function Documentation

log_template_apply()

int log_template_apply	(	const log_template_t *	format,
		char *	buf,
		size_t	buf_size,
		log_level_t	level,
		const char *	timestamp,
		const char *	file,
		int	line,
		const char *	func,
		uint64_t	tid,
		const char *	message,
		bool	use_colors,
		uint64_t	time_nanoseconds
	)

Definition at line 455 of file log/format.c.

                                                                                        {
  if (!format || !buf || buf_size == 0) {
    return -1;
  }
 
  int total_written = 0;
  char *p = buf;
  size_t remaining = buf_size - 1; /* Reserve space for null terminator */
 
  (void)timestamp; /* May be used in future; for now, LOG_FORMAT_TIME uses custom formatting */
 
  for (size_t i = 0; i < format->spec_count; i++) {
    const log_format_spec_t *spec = &format->specs[i];
    int written = 0;
 
    switch (spec->type) {
    case LOG_FORMAT_LITERAL:
      written = safe_snprintf(p, remaining + 1, "%s", spec->literal ? spec->literal : "");
      break;
 
    case LOG_FORMAT_TIME:
      /* Format time using custom time formatter */
      if (spec->literal) {
        written = time_format_now(spec->literal, p, remaining + 1);
        if (written <= 0) {
          log_debug("time_format_now failed for format: %s", spec->literal);
          written = 0;
        }
      }
      break;
 
    case LOG_FORMAT_LEVEL:
      /* Log level as string (DEV, DEBUG, INFO, WARN, ERROR, FATAL) */
      written = safe_snprintf(p, remaining + 1, "%s", get_level_string(level));
      break;
 
    case LOG_FORMAT_LEVEL_ALIGNED:
      /* Log level padded to exactly 5 characters (prevents truncation to [DEBU]/[ERRO]) */
      written = safe_snprintf(p, remaining + 1, "%s", get_level_string_padded(level));
      break;
 
    case LOG_FORMAT_FILE:
      if (file) {
        written = safe_snprintf(p, remaining + 1, "%s", file);
      }
      break;
 
    case LOG_FORMAT_FILE_RELATIVE:
      if (file) {
        const char *rel_file = extract_project_relative_path(file);
        written = safe_snprintf(p, remaining + 1, "%s", rel_file);
      }
      break;
 
    case LOG_FORMAT_LINE:
      if (line > 0) {
        written = safe_snprintf(p, remaining + 1, "%d", line);
      }
      break;
 
    case LOG_FORMAT_FUNC:
      if (func) {
        written = safe_snprintf(p, remaining + 1, "%s", func);
      }
      break;
 
    case LOG_FORMAT_TID:
      written = safe_snprintf(p, remaining + 1, "%llu", (unsigned long long)tid);
      break;
 
    case LOG_FORMAT_MICROSECONDS: {
      /* Extract microseconds from nanoseconds (ns_value % 1_000_000_000 / 1000) */
      long nanoseconds = (long)(time_nanoseconds % NS_PER_SEC_INT);
      long microseconds = nanoseconds / 1000;
      if (microseconds < 0)
        microseconds = 0;
      if (microseconds > 999999)
        microseconds = 999999;
      written = safe_snprintf(p, remaining + 1, "%06ld", microseconds);
      break;
    }
 
    case LOG_FORMAT_NANOSECONDS: {
      /* Extract nanoseconds component (ns_value % 1_000_000_000) */
      long nanoseconds = (long)(time_nanoseconds % NS_PER_SEC_INT);
      if (nanoseconds < 0)
        nanoseconds = 0;
      if (nanoseconds > 999999999)
        nanoseconds = 999999999;
      written = safe_snprintf(p, remaining + 1, "%09ld", nanoseconds);
      break;
    }
 
    case LOG_FORMAT_STRFTIME_CODE: {
      /* strftime format code (like %H, %M, %S, %A, %B, etc.)
       * Let strftime handle all the parsing and validation */
      if (spec->literal) {
        /* Construct format string with % prefix */
        size_t fmt_len = spec->literal_len + 1;
        char *format_str = SAFE_MALLOC(fmt_len + 1, char *);
        if (format_str) {
          format_str[0] = '%';
          memcpy(format_str + 1, spec->literal, spec->literal_len);
          format_str[fmt_len] = '\0';
          written = time_format_now(format_str, p, remaining + 1);
          if (written <= 0) {
            log_debug("time_format_now failed for format code: %s", format_str);
            written = 0;
          }
          SAFE_FREE(format_str);
        }
      }
      break;
    }
 
    case LOG_FORMAT_MESSAGE:
      if (message) {
        written = safe_snprintf(p, remaining + 1, "%s", message);
      }
      break;
 
    case LOG_FORMAT_COLORED_MESSAGE: {
      /* Apply colorize_log_message() for number/unit/hex highlighting (keeps text white) */
      if (message) {
        const char *colorized_msg = colorize_log_message(message);
        written = safe_snprintf(p, remaining + 1, "%s", colorized_msg);
      }
      break;
    }
 
    case LOG_FORMAT_COLORLOG_LEVEL:
      /* Color code for the log level (placeholder for future color support) */
      (void)use_colors; /* Suppress unused parameter warning */
      written = 0;
      break;
 
    case LOG_FORMAT_COLOR: {
      /* Parse and apply %color(LEVEL, content)
       * literal stores "LEVEL,content" where LEVEL is the color level name (or "*" for current level)
       * and content is a format string to render and colorize */
      if (!spec->literal || spec->literal_len == 0) {
        written = 0;
        break;
      }
 
      /* Find the comma separating LEVEL and content */
      const char *comma_pos = strchr(spec->literal, ',');
      if (!comma_pos) {
        /* Invalid format - no comma found */
        log_debug("log_template_apply: %%color format missing comma in: %s", spec->literal);
        written = 0;
        break;
      }
 
      /* Extract level name (before comma) */
      size_t level_len = comma_pos - spec->literal;
      char level_name[32];
      if (level_len >= sizeof(level_name)) {
        /* Level name too long */
        written = 0;
        break;
      }
      memcpy(level_name, spec->literal, level_len);
      level_name[level_len] = '\0';
 
      /* Parse level name to log_color_t (pass current level for "*" support) */
      log_color_t color = parse_color_level(level_name, level);
 
      /* Extract content (after comma), skip leading whitespace */
      const char *content_start = comma_pos + 1;
      while (*content_start == ' ' || *content_start == '\t') {
        content_start++;
      }
 
      /* Render content recursively */
      char content_buf[512];
      int content_len = render_format_content(content_start, content_buf, sizeof(content_buf), level, timestamp, file,
                                              line, func, tid, message, use_colors, time_nanoseconds);
 
      if (content_len < 0 || content_len >= (int)sizeof(content_buf)) {
        written = 0;
        break;
      }
 
      /* Apply color to rendered content using colored_string */
      const char *colored_content = colored_string(color, content_buf);
 
      /* Copy colored content to output buffer */
      written = safe_snprintf(p, remaining + 1, "%s", colored_content);
      break;
    }
 
    case LOG_FORMAT_NEWLINE:
      /* Platform-aware newline */
#ifdef _WIN32
      written = safe_snprintf(p, remaining + 1, "\r\n");
#else
      written = safe_snprintf(p, remaining + 1, "\n");
#endif
      break;
 
    default:
      break;
    }
 
    if (written < 0) {
      /* snprintf error */
      return -1;
    }
 
    if ((size_t)written > remaining) {
      /* Buffer overflow prevention */
      log_debug("log_template_apply: buffer overflow prevented");
      return -1;
    }
 
    p += written;
    remaining -= written;
    total_written += written;
  }
 
  *p = '\0';
  return total_written;
}

References colored_string(), colorize_log_message(), extract_project_relative_path(), get_level_string_padded(), safe_snprintf(), and time_format_now().

Referenced by platform_print_backtrace_symbols().

log_template_free()

void log_template_free

(

log_template_t *

format

)

Definition at line 293 of file log/format.c.

                                               {
  if (!format) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null format");
    return;
  }
 
  if (format->specs) {
    for (size_t i = 0; i < format->spec_count; i++) {
      if (format->specs[i].literal) {
        SAFE_FREE(format->specs[i].literal);
      }
    }
    SAFE_FREE(format->specs);
  }
 
  if (format->original) {
    SAFE_FREE(format->original);
  }
 
  SAFE_FREE(format);
}

Referenced by log_destroy(), and log_set_format().

log_template_parse()

log_template_t * log_template_parse	(	const char *	format_str,
		bool	console_only
	)

Definition at line 289 of file log/format.c.

                                                                              {
  return parse_format_string(format_str, console_only);
}

Referenced by log_set_format().