Prefix names in buffer.h

5 files changed, 82 insertions, 46 deletions

diff --git a/src/buffer.h b/src/buffer.h
index 63d6202..9cfd5b9 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -9,12 +9,12 @@
 typedef struct {
 	unsigned char *ptr;
 	int asize, size;
-} strbuf;
+} cmark_strbuf;
 
-extern unsigned char strbuf__initbuf[];
-extern unsigned char strbuf__oom[];
+extern unsigned char cmark_strbuf__initbuf[];
+extern unsigned char cmark_strbuf__oom[];
 
-#define GH_BUF_INIT { strbuf__initbuf, 0, 0 }
+#define CMARK_GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 }
 
 /**
  * Initialize a strbuf structure.
@@ -22,7 +22,7 @@ extern unsigned char strbuf__oom[];
  * For the cases where GH_BUF_INIT cannot be used to do static
  * initialization.
  */
-extern void strbuf_init(strbuf *buf, int initial_size);
+extern void cmark_strbuf_init(cmark_strbuf *buf, int initial_size);
 
 /**
  * Attempt to grow the buffer to hold at least `target_size` bytes.
@@ -32,7 +32,7 @@ extern void strbuf_init(strbuf *buf, int initial_size);
  * existing buffer content will be preserved, but calling code must handle
  * that buffer was not expanded.
  */
-extern int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom);
+extern int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom);
 
 /**
  * Grow the buffer to hold at least `target_size` bytes.
@@ -42,13 +42,13 @@ extern int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom);
  *
  * @return 0 on success or -1 on failure
  */
-static inline int strbuf_grow(strbuf *buf, int target_size)
+static inline 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);
 }
 
-extern void strbuf_free(strbuf *buf);
-extern void strbuf_swap(strbuf *buf_a, strbuf *buf_b);
+extern void cmark_strbuf_free(cmark_strbuf *buf);
+extern void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
 
 /**
  * Test if there have been any reallocation failures with this strbuf.
@@ -61,29 +61,29 @@ extern void strbuf_swap(strbuf *buf_a, strbuf *buf_b);
  *
  * @return false if no error, true if allocation error
  */
-static inline bool strbuf_oom(const strbuf *buf)
+static inline bool cmark_strbuf_oom(const cmark_strbuf *buf)
 {
-	return (buf->ptr == strbuf__oom);
+	return (buf->ptr == cmark_strbuf__oom);
 }
 
 
-static inline size_t strbuf_len(const strbuf *buf)
+static inline size_t cmark_strbuf_len(const cmark_strbuf *buf)
 {
 	return buf->size;
 }
 
-extern int strbuf_cmp(const strbuf *a, const strbuf *b);
+extern int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
 
-extern void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize);
-extern unsigned char *strbuf_detach(strbuf *buf);
-extern void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf);
+extern void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize);
+extern unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
+extern void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf);
 
-static inline const char *strbuf_cstr(const strbuf *buf)
+static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf)
 {
 	return (char *)buf->ptr;
 }
 
-#define strbuf_at(buf, n) ((buf)->ptr[n])
+#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
 
 /*
  * Functions below that return int value error codes will return 0 on
@@ -93,23 +93,59 @@ static inline const char *strbuf_cstr(const strbuf *buf)
  * return code of these functions and call them in a series then just call
  * strbuf_oom at the end.
  */
-extern int strbuf_set(strbuf *buf, const unsigned char *data, int len);
-extern int strbuf_sets(strbuf *buf, const char *string);
-extern int strbuf_putc(strbuf *buf, int c);
-extern int strbuf_put(strbuf *buf, const unsigned char *data, int len);
-extern int strbuf_puts(strbuf *buf, const char *string);
-extern int strbuf_printf(strbuf *buf, const char *format, ...)
+extern int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len);
+extern int cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
+extern int cmark_strbuf_putc(cmark_strbuf *buf, int c);
+extern int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len);
+extern int cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
+extern int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...)
 	__attribute__((format (printf, 2, 3)));
-extern int strbuf_vprintf(strbuf *buf, const char *format, va_list ap);
-extern void strbuf_clear(strbuf *buf);
-
-int strbuf_strchr(const strbuf *buf, int c, int pos);
-int strbuf_strrchr(const strbuf *buf, int c, int pos);
-void strbuf_drop(strbuf *buf, int n);
-void strbuf_truncate(strbuf *buf, int len);
-void strbuf_rtrim(strbuf *buf);
-void strbuf_trim(strbuf *buf);
-void strbuf_normalize_whitespace(strbuf *s);
-void strbuf_unescape(strbuf *s);
+extern int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap);
+extern void cmark_strbuf_clear(cmark_strbuf *buf);
+
+int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos);
+int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos);
+void cmark_strbuf_drop(cmark_strbuf *buf, int n);
+void cmark_strbuf_truncate(cmark_strbuf *buf, int len);
+void cmark_strbuf_rtrim(cmark_strbuf *buf);
+void cmark_strbuf_trim(cmark_strbuf *buf);
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
+void cmark_strbuf_unescape(cmark_strbuf *s);
+
+#ifndef CMARK_NO_SHORT_NAMES
+  #define strbuf                        cmark_strbuf
+  #define strbuf__initbuf               cmark_strbuf__initbuf
+  #define strbuf__oom                   cmark_strbuf__oom
+  #define GH_BUF_INIT                   CMARK_GH_BUF_INIT
+  #define strbuf_init                   cmark_strbuf_init
+  #define strbuf_try_grow               cmark_strbuf_try_grow
+  #define strbuf_grow                   cmark_strbuf_grow
+  #define strbuf_free                   cmark_strbuf_free
+  #define strbuf_swap                   cmark_strbuf_swap
+  #define strbuf_oom                    cmark_strbuf_oom
+  #define strbuf_len                    cmark_strbuf_len
+  #define strbuf_cmp                    cmark_strbuf_cmp
+  #define strbuf_attach                 cmark_strbuf_attach
+  #define strbuf_detach                 cmark_strbuf_detach
+  #define strbuf_copy_cstr              cmark_strbuf_copy_cstr
+  #define strbuf_cstr                   cmark_strbuf_cstr
+  #define strbuf_at                     cmark_strbuf_at
+  #define strbuf_set                    cmark_strbuf_set
+  #define strbuf_sets                   cmark_strbuf_sets
+  #define strbuf_putc                   cmark_strbuf_putc
+  #define strbuf_put                    cmark_strbuf_put
+  #define strbuf_puts                   cmark_strbuf_puts
+  #define strbuf_printf                 cmark_strbuf_printf
+  #define strbuf_vprintf                cmark_strbuf_vprintf
+  #define strbuf_clear                  cmark_strbuf_clear
+  #define strbuf_strchr                 cmark_strbuf_strchr
+  #define strbuf_strrchr                cmark_strbuf_strrchr
+  #define strbuf_drop                   cmark_strbuf_drop
+  #define strbuf_truncate               cmark_strbuf_truncate
+  #define strbuf_rtrim                  cmark_strbuf_rtrim
+  #define strbuf_trim                   cmark_strbuf_trim
+  #define strbuf_normalize_whitespace   cmark_strbuf_normalize_whitespace
+  #define strbuf_unescape               cmark_strbuf_unescape
+#endif
 
 #endif
diff --git a/src/chunk.h b/src/chunk.h
index 015bbf9..208880a 100644
--- a/src/chunk.h
+++ b/src/chunk.h
@@ -79,12 +79,12 @@ static inline chunk chunk_dup(const chunk *ch, int pos, int len)
 	return c;
 }
 
-static inline chunk chunk_buf_detach(strbuf *buf)
+static inline chunk chunk_buf_detach(cmark_strbuf *buf)
 {
 	chunk c;
 
 	c.len = buf->size;
-	c.data = strbuf_detach(buf);
+	c.data = cmark_strbuf_detach(buf);
 	c.alloc = 1;
 
 	return c;
diff --git a/src/cmark.h b/src/cmark.h
index 5f0d5f7..1ffbcf1 100644
--- a/src/cmark.h
+++ b/src/cmark.h
@@ -63,7 +63,7 @@ struct FencedCodeData {
 	int               fence_length;
 	int               fence_offset;
 	unsigned char     fence_char;
-	strbuf            info;
+	cmark_strbuf      info;
 };
 
 struct node_block {
@@ -90,7 +90,7 @@ struct node_block {
 	struct node_block* last_child;
 	struct node_block* parent;
 	struct node_block* top;
-	strbuf string_content;
+	cmark_strbuf string_content;
 	node_inl* inline_content;
 
 	union  {
@@ -116,7 +116,7 @@ node_block *cmark_parse_file(FILE *f);
 void cmark_free_nodes(node_block *e);
 
 void cmark_debug_print(node_block *root);
-void cmark_render_html(strbuf *html, node_block *root);
+void cmark_render_html(cmark_strbuf *html, node_block *root);
 
 unsigned char *cmark_markdown_to_html(unsigned char *text, int len);
 
diff --git a/src/inlines.h b/src/inlines.h
index 8c6e2cb..623a075 100644
--- a/src/inlines.h
+++ b/src/inlines.h
@@ -5,9 +5,9 @@ unsigned char *clean_url(chunk *url);
 unsigned char *clean_autolink(chunk *url, int is_email);
 unsigned char *clean_title(chunk *title);
 
-node_inl* parse_inlines(strbuf *input, reference_map *refmap);
+node_inl* parse_inlines(cmark_strbuf *input, reference_map *refmap);
 void free_inlines(node_inl* e);
 
-int parse_reference_inline(strbuf *input, reference_map *refmap);
+int parse_reference_inline(cmark_strbuf *input, reference_map *refmap);
 
 #endif
diff --git a/src/utf8.h b/src/utf8.h
index 496eae9..7584761 100644
--- a/src/utf8.h
+++ b/src/utf8.h
@@ -4,10 +4,10 @@
 #include <stdint.h>
 #include "buffer.h"
 
-void utf8proc_case_fold(strbuf *dest, const uint8_t *str, int len);
-void utf8proc_encode_char(int32_t uc, strbuf *buf);
+void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len);
+void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
 int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst);
 int utf8proc_charlen(const uint8_t *str, int str_len);
-void utf8proc_detab(strbuf *dest, const uint8_t *line, size_t size);
+void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, size_t size);
 
 #endif