zalgo.h File Reference

Go to the source code of this file.

Macros
#define	ZALGO_MAX_MARKS   10

Functions
asciichat_error_t	zalgo_apply (const char *input, size_t length, int level, size_t max_output_bytes, char **output)
unsigned	zalgo_cell_marks (uint32_t row, uint32_t col, int level, uint16_t marks[10])

Macro Definition Documentation

ZALGO_MAX_MARKS

#define ZALGO_MAX_MARKS   10

Definition at line 4 of file zalgo.h.

Referenced by zalgo_apply(), zalgo_cell_marks(), and zalgo_cell_marks().

Function Documentation

zalgo_apply()

asciichat_error_t zalgo_apply	(	const char *	input,
		size_t	length,
		int	level,
		size_t	max_output_bytes,
		char **	output )

Decorate an ANSI frame with deterministic combining marks. Caller frees *output. REP is expanded before decoration. Only printable ASCII bases are decorated; whitespace, existing UTF-8, and escape sequences are preserved. The byte limit excludes the NUL terminator; on overflow returns an error with *output = NULL.

Decorate a frame within the caller's byte budget; errors leave no partially decorated output.

Definition at line 69 of file zalgo.c.

                                                                                                                   {
  if (!output)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing Zalgo output pointer");
  *output = NULL;
  if (!input || level < 1 || level > 10)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo requires a frame and intensity 1-10");
 
  // Bound REP expansion before allocating: a short remote frame can contain a
  // very large repeat count. Four bytes per repeated code point is conservative.
  const size_t expansion_limit = 1024 * 1024;
  size_t expansion_bound = length;
  bool has_rep = false;
  if (length > expansion_limit)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo frame exceeds expansion limit");
  for (size_t i = 0; i + 1 < length; i++) {
    if (input[i] != '\x1b' || input[i + 1] != '[')
      continue;
    size_t j = i + 2;
    uint32_t parameter = 0;
    while (j < length && ((input[j] >= '0' && input[j] <= '9') || input[j] == ';')) {
      if (input[j] == ';') {
        parameter = 0;
      } else {
        unsigned digit = (unsigned)(input[j] - '0');
        if (parameter > (UINT32_MAX - digit) / 10)
          return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo frame contains an overflowing ANSI parameter");
        parameter = parameter * 10 + digit;
      }
      j++;
    }
    if (j < length && input[j] == 'b') {
      has_rep = true;
      if (parameter > (expansion_limit - expansion_bound) / 4)
        return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo REP expansion exceeds frame limit");
      expansion_bound += (size_t)parameter * 4;
    }
    i = j;
  }
 
  char *expanded = NULL;
  defer(SAFE_FREE(expanded));
  if (has_rep) {
    expanded = ansi_expand_rle(input, length);
  } else {
    expanded = SAFE_MALLOC(length + 1, char *);
    memcpy(expanded, input, length);
    expanded[length] = '\0';
  }
  if (!expanded)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Cannot expand empty Zalgo frame");
  size_t n = strlen(expanded);
  if (n > max_output_bytes) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo frame exceeds output limit");
  }
  size_t mark_budget = max_output_bytes - n;
  size_t factor = 1 + 2 * zalgo_maximum[level - 1];
  // Every source byte introduces at most the selected level's mark limit.
  if (n > (SIZE_MAX - 1) / factor) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo frame is too large");
  }
  size_t capacity = n * factor < max_output_bytes ? n * factor : max_output_bytes;
  SAFE_MALLOC_DEFER_FREE(result, capacity + 1, char *);
  char *dst = result;
  uint32_t row = 0, col = 0;
  for (size_t i = 0; i < n;) {
    unsigned char c = (unsigned char)expanded[i];
    if (c == 0x1b) {
      size_t count = zalgo_escape_length(expanded + i, n - i);
      memcpy(dst, expanded + i, count);
      dst += count;
      i += count;
      continue;
    }
    *dst++ = expanded[i++];
    if (c == '\n') {
      row++;
      col = 0;
    } else if (c == '\r') {
      col = 0;
    } else if (c == '\t') {
      col = (col / 8 + 1) * 8;
    } else if (c >= 0x20 && c < 0x7f) {
      uint16_t marks[ZALGO_MAX_MARKS];
      unsigned count = c == ' ' ? 0 : zalgo_cell_marks(row, col, level, marks);
      col++;
      if (count * 2 > mark_budget) {
        return SET_ERRNO(ERROR_INVALID_PARAM, "Zalgo decoration exceeds output limit");
      }
      mark_budget -= count * 2;
      for (unsigned mark = 0; mark < count; mark++) {
        uint16_t cp = marks[mark];
        *dst++ = (char)(0xc0 | (cp >> 6));
        *dst++ = (char)(0x80 | (cp & 0x3f));
      }
    } else if (c >= 0xc0) {
      // Preserve multibyte characters; continuation bytes do not advance columns.
      col++;
    }
  }
  *dst = '\0';
  *output = result;
  result = NULL;
  return ASCIICHAT_OK;
}

References ansi_expand_rle(), ASCIICHAT_OK, ERROR_INVALID_PARAM, SAFE_FREE, SAFE_MALLOC, SAFE_MALLOC_DEFER_FREE, SET_ERRNO, zalgo_cell_marks(), and ZALGO_MAX_MARKS.

Referenced by session_display_write_ascii_frame().

zalgo_cell_marks()

unsigned zalgo_cell_marks	(	uint32_t	row,
		uint32_t	col,
		int	level,
		uint16_t	marks[10] )

Shared terminal/raster distribution. Returns 0-10 marks for one cell.

References ZALGO_MAX_MARKS.