zalgo.c File Reference

Go to the source code of this file.

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

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 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[ZALGO_MAX_MARKS] )

Definition at line 19 of file zalgo.c.

                                                                                                  {
  if (level < 1 || level > 10 || !marks)
    return 0;
  static const unsigned coverage[] = {3, 6, 10, 18, 28, 40, 55, 70, 85, 100};
  static const unsigned minimum[] = {1, 1, 1, 1, 1, 1, 2, 3, 4, 6};
  static const uint16_t short_marks[] = {0x0334, 0x0335, 0x0336, 0x0337, 0x0338};
  static const uint16_t stack_marks[] = {0x0300, 0x0301, 0x0302, 0x0303, 0x0308, 0x030a,
                                         0x0310, 0x0311, 0x0324, 0x0325, 0x0329, 0x0330};
  unsigned index = (unsigned)level - 1;
  uint32_t hash = zalgo_hash((uint32_t)((uint64_t)row * UINT64_C(0x9e3779b9)) ^ col ^ UINT32_C(0x5a17));
  if (hash % 100 >= coverage[index])
    return 0;
  unsigned count = minimum[index] + ((hash >> 8) % 256) * (zalgo_maximum[index] - minimum[index] + 1) / 256;
  for (unsigned mark = 0; mark < count; mark++) {
    uint32_t choice = zalgo_hash((uint32_t)((uint64_t)hash + mark));
    marks[mark] = mark == 0 ? short_marks[choice % 5] : stack_marks[choice % 12];
  }
  return count;
}

References index, and ZALGO_MAX_MARKS.

Referenced by zalgo_apply().