commonmarker 0.23.10 → 2.1.1

data/ext/commonmarker/buffer.c

@@ -1,278 +0,0 @@
-#include <stdarg.h>
-#include <string.h>
-#include <assert.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <limits.h>
-
-#include "config.h"
-#include "cmark_ctype.h"
-#include "buffer.h"
-
-/* Used as default value for cmark_strbuf->ptr so that people can always
- * assume ptr is non-NULL and zero terminated even for new cmark_strbufs.
- */
-unsigned char cmark_strbuf__initbuf[1];
-
-#ifndef MIN
-#define MIN(x, y) ((x < y) ? x : y)
-#endif
-
-void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
-                       bufsize_t initial_size) {
-  buf->mem = mem;
-  buf->asize = 0;
-  buf->size = 0;
-  buf->ptr = cmark_strbuf__initbuf;
-
-  if (initial_size > 0)
-    cmark_strbuf_grow(buf, initial_size);
-}
-
-static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) {
-  cmark_strbuf_grow(buf, buf->size + add);
-}
-
-void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
-  assert(target_size > 0);
-
-  if (target_size < buf->asize)
-    return;
-
-  if (target_size > (bufsize_t)(INT32_MAX / 2)) {
-    fprintf(stderr,
-      "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n",
-         (INT32_MAX / 2));
-    abort();
-  }
-
-  /* Oversize the buffer by 50% to guarantee amortized linear time
-   * complexity on append operations. */
-  bufsize_t new_size = target_size + target_size / 2;
-  new_size += 1;
-  new_size = (new_size + 7) & ~7;
-
-  buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL,
-                                                new_size);
-  buf->asize = new_size;
-}
-
-bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; }
-
-void cmark_strbuf_free(cmark_strbuf *buf) {
-  if (!buf)
-    return;
-
-  if (buf->ptr != cmark_strbuf__initbuf)
-    buf->mem->free(buf->ptr);
-
-  cmark_strbuf_init(buf->mem, buf, 0);
-}
-
-void cmark_strbuf_clear(cmark_strbuf *buf) {
-  buf->size = 0;
-
-  if (buf->asize > 0)
-    buf->ptr[0] = '\0';
-}
-
-void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
-                      bufsize_t len) {
-  if (len <= 0 || data == NULL) {
-    cmark_strbuf_clear(buf);
-  } else {
-    if (data != buf->ptr) {
-      if (len >= buf->asize)
-        cmark_strbuf_grow(buf, len);
-      memmove(buf->ptr, data, len);
-    }
-    buf->size = len;
-    buf->ptr[buf->size] = '\0';
-  }
-}
-
-void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) {
-  cmark_strbuf_set(buf, (const unsigned char *)string,
-                   string ? (bufsize_t)strlen(string) : 0);
-}
-
-void cmark_strbuf_putc(cmark_strbuf *buf, int c) {
-  S_strbuf_grow_by(buf, 1);
-  buf->ptr[buf->size++] = (unsigned char)(c & 0xFF);
-  buf->ptr[buf->size] = '\0';
-}
-
-void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
-                      bufsize_t len) {
-  if (len <= 0)
-    return;
-
-  S_strbuf_grow_by(buf, len);
-  memmove(buf->ptr + buf->size, data, len);
-  buf->size += len;
-  buf->ptr[buf->size] = '\0';
-}
-
-void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) {
-  cmark_strbuf_put(buf, (const unsigned char *)string, (bufsize_t)strlen(string));
-}
-
-void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
-                            const cmark_strbuf *buf) {
-  bufsize_t copylen;
-
-  assert(buf);
-  if (!data || datasize <= 0)
-    return;
-
-  data[0] = '\0';
-
-  if (buf->size == 0 || buf->asize <= 0)
-    return;
-
-  copylen = buf->size;
-  if (copylen > datasize - 1)
-    copylen = datasize - 1;
-  memmove(data, buf->ptr, copylen);
-  data[copylen] = '\0';
-}
-
-void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) {
-  cmark_strbuf t = *buf_a;
-  *buf_a = *buf_b;
-  *buf_b = t;
-}
-
-unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) {
-  unsigned char *data = buf->ptr;
-
-  if (buf->asize == 0) {
-    /* return an empty string */
-    return (unsigned char *)buf->mem->calloc(1, 1);
-  }
-
-  cmark_strbuf_init(buf->mem, buf, 0);
-  return data;
-}
-
-int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) {
-  int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
-  return (result != 0) ? result
-                       : (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
-}
-
-bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
-  if (pos >= buf->size)
-    return -1;
-  if (pos < 0)
-    pos = 0;
-
-  const unsigned char *p =
-      (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos);
-  if (!p)
-    return -1;
-
-  return (bufsize_t)(p - (const unsigned char *)buf->ptr);
-}
-
-bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
-  if (pos < 0 || buf->size == 0)
-    return -1;
-  if (pos >= buf->size)
-    pos = buf->size - 1;
-
-  bufsize_t i;
-  for (i = pos; i >= 0; i--) {
-    if (buf->ptr[i] == (unsigned char)c)
-      return i;
-  }
-
-  return -1;
-}
-
-void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) {
-  if (len < 0)
-    len = 0;
-
-  if (len < buf->size) {
-    buf->size = len;
-    buf->ptr[buf->size] = '\0';
-  }
-}
-
-void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) {
-  if (n > 0) {
-    if (n > buf->size)
-      n = buf->size;
-    buf->size = buf->size - n;
-    if (buf->size)
-      memmove(buf->ptr, buf->ptr + n, buf->size);
-
-    buf->ptr[buf->size] = '\0';
-  }
-}
-
-void cmark_strbuf_rtrim(cmark_strbuf *buf) {
-  if (!buf->size)
-    return;
-
-  while (buf->size > 0) {
-    if (!cmark_isspace(buf->ptr[buf->size - 1]))
-      break;
-
-    buf->size--;
-  }
-
-  buf->ptr[buf->size] = '\0';
-}
-
-void cmark_strbuf_trim(cmark_strbuf *buf) {
-  bufsize_t i = 0;
-
-  if (!buf->size)
-    return;
-
-  while (i < buf->size && cmark_isspace(buf->ptr[i]))
-    i++;
-
-  cmark_strbuf_drop(buf, i);
-
-  cmark_strbuf_rtrim(buf);
-}
-
-// Destructively modify string, collapsing consecutive
-// space and newline characters into a single space.
-void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) {
-  bool last_char_was_space = false;
-  bufsize_t r, w;
-
-  for (r = 0, w = 0; r < s->size; ++r) {
-    if (cmark_isspace(s->ptr[r])) {
-      if (!last_char_was_space) {
-        s->ptr[w++] = ' ';
-        last_char_was_space = true;
-      }
-    } else {
-      s->ptr[w++] = s->ptr[r];
-      last_char_was_space = false;
-    }
-  }
-
-  cmark_strbuf_truncate(s, w);
-}
-
-// Destructively unescape a string: remove backslashes before punctuation chars.
-extern void cmark_strbuf_unescape(cmark_strbuf *buf) {
-  bufsize_t r, w;
-
-  for (r = 0, w = 0; r < buf->size; ++r) {
-    if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1]))
-      r++;
-
-    buf->ptr[w++] = buf->ptr[r];
-  }
-
-  cmark_strbuf_truncate(buf, w);
-}

data/ext/commonmarker/buffer.h

@@ -1,116 +0,0 @@
-#ifndef CMARK_BUFFER_H
-#define CMARK_BUFFER_H
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <string.h>
-#include <limits.h>
-#include <stdint.h>
-#include "config.h"
-#include "cmark-gfm.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  cmark_mem *mem;
-  unsigned char *ptr;
-  bufsize_t asize, size;
-} cmark_strbuf;
-
-extern unsigned char cmark_strbuf__initbuf[];
-
-#define CMARK_BUF_INIT(mem)                                                    \
-  { mem, cmark_strbuf__initbuf, 0, 0 }
-
-/**
- * Initialize a cmark_strbuf structure.
- *
- * For the cases where CMARK_BUF_INIT cannot be used to do static
- * initialization.
- */
-CMARK_GFM_EXPORT
-void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
-                       bufsize_t initial_size);
-
-/**
- * Grow the buffer to hold at least `target_size` bytes.
- */
-CMARK_GFM_EXPORT
-void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_free(cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
-
-CMARK_GFM_EXPORT
-bufsize_t cmark_strbuf_len(const cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
-
-CMARK_GFM_EXPORT
-unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
-                            const cmark_strbuf *buf);
-
-static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) {
-  return (char *)buf->ptr;
-}
-
-#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
-                      bufsize_t len);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_putc(cmark_strbuf *buf, int c);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
-                      bufsize_t len);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_clear(cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos);
-
-CMARK_GFM_EXPORT
-bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_rtrim(cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_trim(cmark_strbuf *buf);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
-
-CMARK_GFM_EXPORT
-void cmark_strbuf_unescape(cmark_strbuf *s);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif