From d6077ea037e23f6e2c0d83dda7b5d7106f48d1a3 Mon Sep 17 00:00:00 2001 From: John MacFarlane Date: Mon, 15 Dec 2014 12:05:04 -0800 Subject: Re-added cmark_ prefix to strbuf and chunk. Reverts 225d720. --- src/buffer.c | 108 +++++++++++++++++++++++++++++------------------------------ 1 file changed, 54 insertions(+), 54 deletions(-) (limited to 'src/buffer.c') diff --git a/src/buffer.c b/src/buffer.c index 765cb46..73a9728 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -8,36 +8,36 @@ #include "buffer.h" -/* Used as default value for strbuf->ptr so that people can always - * assume ptr is non-NULL and zero terminated even for new strbufs. +/* 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 strbuf__initbuf[1]; -unsigned char strbuf__oom[1]; +unsigned char cmark_strbuf__initbuf[1]; +unsigned char cmark_strbuf__oom[1]; #define ENSURE_SIZE(b, d) \ - if ((d) > buf->asize && strbuf_grow(b, (d)) < 0) \ + if ((d) > buf->asize && cmark_strbuf_grow(b, (d)) < 0) \ return -1; #ifndef MIN #define MIN(x,y) ((xasize = 0; buf->size = 0; - buf->ptr = strbuf__initbuf; + buf->ptr = cmark_strbuf__initbuf; if (initial_size) - strbuf_grow(buf, initial_size); + cmark_strbuf_grow(buf, initial_size); } -int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom) +int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom) { unsigned char *new_ptr; int new_size; - if (buf->ptr == strbuf__oom) + if (buf->ptr == cmark_strbuf__oom) return -1; if (target_size <= buf->asize) @@ -63,7 +63,7 @@ int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom) if (!new_ptr) { if (mark_oom) - buf->ptr = strbuf__oom; + buf->ptr = cmark_strbuf__oom; return -1; } @@ -78,32 +78,32 @@ int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom) return 0; } -int strbuf_grow(strbuf *buf, int target_size) +int cmark_strbuf_grow(cmark_strbuf *buf, int target_size) { - return strbuf_try_grow(buf, target_size, true); + return cmark_strbuf_try_grow(buf, target_size, true); } -bool strbuf_oom(const strbuf *buf) +bool cmark_strbuf_oom(const cmark_strbuf *buf) { - return (buf->ptr == strbuf__oom); + return (buf->ptr == cmark_strbuf__oom); } -size_t strbuf_len(const strbuf *buf) +size_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } -void strbuf_free(strbuf *buf) +void cmark_strbuf_free(cmark_strbuf *buf) { if (!buf) return; - if (buf->ptr != strbuf__initbuf && buf->ptr != strbuf__oom) + if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom) free(buf->ptr); - strbuf_init(buf, 0); + cmark_strbuf_init(buf, 0); } -void strbuf_clear(strbuf *buf) +void cmark_strbuf_clear(cmark_strbuf *buf) { buf->size = 0; @@ -111,10 +111,10 @@ void strbuf_clear(strbuf *buf) buf->ptr[0] = '\0'; } -int strbuf_set(strbuf *buf, const unsigned char *data, int len) +int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len) { if (len <= 0 || data == NULL) { - strbuf_clear(buf); + cmark_strbuf_clear(buf); } else { if (data != buf->ptr) { ENSURE_SIZE(buf, len + 1); @@ -126,14 +126,14 @@ int strbuf_set(strbuf *buf, const unsigned char *data, int len) return 0; } -int strbuf_sets(strbuf *buf, const char *string) +int cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { - return strbuf_set(buf, + return cmark_strbuf_set(buf, (const unsigned char *)string, string ? strlen(string) : 0); } -int strbuf_putc(strbuf *buf, int c) +int cmark_strbuf_putc(cmark_strbuf *buf, int c) { ENSURE_SIZE(buf, buf->size + 2); buf->ptr[buf->size++] = c; @@ -141,7 +141,7 @@ int strbuf_putc(strbuf *buf, int c) return 0; } -int strbuf_put(strbuf *buf, const unsigned char *data, int len) +int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len) { if (len <= 0) return 0; @@ -153,12 +153,12 @@ int strbuf_put(strbuf *buf, const unsigned char *data, int len) return 0; } -int strbuf_puts(strbuf *buf, const char *string) +int cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { - return strbuf_put(buf, (const unsigned char *)string, strlen(string)); + return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); } -int strbuf_vprintf(strbuf *buf, const char *format, va_list ap) +int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) { const int expected_size = buf->size + (strlen(format) * 2); int len; @@ -174,7 +174,7 @@ int strbuf_vprintf(strbuf *buf, const char *format, va_list ap) if (len < 0) { free(buf->ptr); - buf->ptr = strbuf__oom; + buf->ptr = cmark_strbuf__oom; return -1; } @@ -189,19 +189,19 @@ int strbuf_vprintf(strbuf *buf, const char *format, va_list ap) return 0; } -int strbuf_printf(strbuf *buf, const char *format, ...) +int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) { int r; va_list ap; va_start(ap, format); - r = strbuf_vprintf(buf, format, ap); + r = cmark_strbuf_vprintf(buf, format, ap); va_end(ap); return r; } -void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf) +void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf) { int copylen; @@ -219,29 +219,29 @@ void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf) data[copylen] = '\0'; } -void strbuf_swap(strbuf *buf_a, strbuf *buf_b) +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) { - strbuf t = *buf_a; + cmark_strbuf t = *buf_a; *buf_a = *buf_b; *buf_b = t; } -unsigned char *strbuf_detach(strbuf *buf) +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { unsigned char *data = buf->ptr; - if (buf->asize == 0 || buf->ptr == strbuf__oom) { + if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) { /* return an empty string */ return (unsigned char *)calloc(1, 1); } - strbuf_init(buf, 0); + cmark_strbuf_init(buf, 0); return data; } -void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize) +void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize) { - strbuf_free(buf); + cmark_strbuf_free(buf); if (ptr) { buf->ptr = ptr; @@ -251,18 +251,18 @@ void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize) else /* pass 0 to fall back on strlen + 1 */ buf->asize = buf->size + 1; } else { - strbuf_grow(buf, asize); + cmark_strbuf_grow(buf, asize); } } -int strbuf_cmp(const strbuf *a, const strbuf *b) +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; } -int strbuf_strchr(const strbuf *buf, int c, int pos) +int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos) { const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); if (!p) @@ -271,7 +271,7 @@ int strbuf_strchr(const strbuf *buf, int c, int pos) return (int)(p - (const unsigned char *)buf->ptr); } -int strbuf_strrchr(const strbuf *buf, int c, int pos) +int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) { int i; @@ -283,7 +283,7 @@ int strbuf_strrchr(const strbuf *buf, int c, int pos) return -1; } -void strbuf_truncate(strbuf *buf, int len) +void cmark_strbuf_truncate(cmark_strbuf *buf, int len) { if (len < buf->size) { buf->size = len; @@ -291,7 +291,7 @@ void strbuf_truncate(strbuf *buf, int len) } } -void strbuf_drop(strbuf *buf, int n) +void cmark_strbuf_drop(cmark_strbuf *buf, int n) { if (n > 0) { buf->size = buf->size - n; @@ -302,7 +302,7 @@ void strbuf_drop(strbuf *buf, int n) } } -void strbuf_rtrim(strbuf *buf) +void cmark_strbuf_rtrim(cmark_strbuf *buf) { if (!buf->size) return; @@ -317,7 +317,7 @@ void strbuf_rtrim(strbuf *buf) buf->ptr[buf->size] = '\0'; } -void strbuf_trim(strbuf *buf) +void cmark_strbuf_trim(cmark_strbuf *buf) { int i = 0; @@ -327,14 +327,14 @@ void strbuf_trim(strbuf *buf) while (i < buf->size && isspace(buf->ptr[i])) i++; - strbuf_drop(buf, i); + cmark_strbuf_drop(buf, i); - strbuf_rtrim(buf); + cmark_strbuf_rtrim(buf); } // Destructively modify string, collapsing consecutive // space and newline characters into a single space. -void strbuf_normalize_whitespace(strbuf *s) +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) { bool last_char_was_space = false; int r, w; @@ -356,11 +356,11 @@ void strbuf_normalize_whitespace(strbuf *s) } } - strbuf_truncate(s, w); + cmark_strbuf_truncate(s, w); } // Destructively unescape a string: remove backslashes before punctuation chars. -extern void strbuf_unescape(strbuf *buf) +extern void cmark_strbuf_unescape(cmark_strbuf *buf) { int r, w; @@ -371,5 +371,5 @@ extern void strbuf_unescape(strbuf *buf) buf->ptr[w++] = buf->ptr[r]; } - strbuf_truncate(buf, w); + cmark_strbuf_truncate(buf, w); } -- cgit v1.2.3