aboutsummaryrefslogtreecommitdiff
path: root/src/buffer.h
blob: e1ff60a067372a8f9b3c09b06c4fc1ad9c2814d4 (plain) 
    

  1. #ifndef INCLUDE_buffer_h__
    2. 

  2. #define INCLUDE_buffer_h__
    3. 

  3. 

  4. #include <stdbool.h>
    5. 

  5. #include <stddef.h>
    6. 

  6. #include <stdarg.h>
    7. 

  7. #include <sys/types.h>
    8. 

  8. 

  9. typedef struct {
    10. 

  10.     unsigned char *ptr;
    11. 

  11.     int asize, size;
    12. 

  12. } cmark_strbuf;
    13. 

  13. 

  14. __attribute__((visibility("default")))
    15. 

  15. extern unsigned char cmark_strbuf__initbuf[];
    16. 

  16. 

  17. __attribute__((visibility("default")))
    18. 

  18. extern unsigned char cmark_strbuf__oom[];
    19. 

  19. 

  20. #define CMARK_GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 }
    21. 

  21. 

  22. /**
    23. 

  23.  * Initialize a strbuf structure.
    24. 

  24.  *
    25. 

  25.  * For the cases where GH_BUF_INIT cannot be used to do static
    26. 

  26.  * initialization.
    27. 

  27.  */
    28. 

  28. __attribute__((visibility("default")))
    29. 

  29. extern void cmark_strbuf_init(cmark_strbuf *buf, int initial_size);
    30. 

  30. 

  31. /**
    32. 

  32.  * Attempt to grow the buffer to hold at least `target_size` bytes.
    33. 

  33.  *
    34. 

  34.  * If the allocation fails, this will return an error.  If mark_oom is true,
    35. 

  35.  * this will mark the buffer as invalid for future operations; if false,
    36. 

  36.  * existing buffer content will be preserved, but calling code must handle
    37. 

  37.  * that buffer was not expanded.
    38. 

  38.  */
    39. 

  39. __attribute__((visibility("default")))
    40. 

  40. extern int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom);
    41. 

  41. 

  42. /**
    43. 

  43.  * Grow the buffer to hold at least `target_size` bytes.
    44. 

  44.  *
    45. 

  45.  * If the allocation fails, this will return an error and the buffer will be
    46. 

  46.  * marked as invalid for future operations, invaliding contents.
    47. 

  47.  *
    48. 

  48.  * @return 0 on success or -1 on failure
    49. 

  49.  */
    50. 

  50. static inline int cmark_strbuf_grow(cmark_strbuf *buf, int target_size)
    51. 

  51. {
    52. 

  52.     return cmark_strbuf_try_grow(buf, target_size, true);
    53. 

  53. }
    54. 

  54. 

  55. __attribute__((visibility("default")))
    56. 

  56. extern void cmark_strbuf_free(cmark_strbuf *buf);
    57. 

  57. __attribute__((visibility("default")))
    58. 

  58. extern void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
    59. 

  59. 

  60. /**
    61. 

  61.  * Test if there have been any reallocation failures with this strbuf.
    62. 

  62.  *
    63. 

  63.  * Any function that writes to a strbuf can fail due to memory allocation
    64. 

  64.  * issues.  If one fails, the strbuf will be marked with an OOM error and
    65. 

  65.  * further calls to modify the buffer will fail.  Check strbuf_oom() at the
    66. 

  66.  * end of your sequence and it will be true if you ran out of memory at any
    67. 

  67.  * point with that buffer.
    68. 

  68.  *
    69. 

  69.  * @return false if no error, true if allocation error
    70. 

  70.  */
    71. 

  71. static inline bool cmark_strbuf_oom(const cmark_strbuf *buf)
    72. 

  72. {
    73. 

  73.     return (buf->ptr == cmark_strbuf__oom);
    74. 

  74. }
    75. 

  75. 

  76. 

  77. static inline size_t cmark_strbuf_len(const cmark_strbuf *buf)
    78. 

  78. {
    79. 

  79.     return buf->size;
    80. 

  80. }
    81. 

  81. 

  82. __attribute__((visibility("default")))
    83. 

  83. extern int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
    84. 

  84. 

  85. __attribute__((visibility("default")))
    86. 

  86. extern void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize);
    87. 

  87. __attribute__((visibility("default")))
    88. 

  88. extern unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
    89. 

  89. __attribute__((visibility("default")))
    90. 

  90. extern void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf);
    91. 

  91. 

  92. static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf)
    93. 

  93. {
    94. 

  94.     return (char *)buf->ptr;
    95. 

  95. }
    96. 

  96. 

  97. #define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
    98. 

  98. 

  99. /*
    100. 

  100.  * Functions below that return int value error codes will return 0 on
    101. 

  101.  * success or -1 on failure (which generally means an allocation failed).
    102. 

  102.  * Using a strbuf where the allocation has failed with result in -1 from
    103. 

  103.  * all further calls using that buffer.  As a result, you can ignore the
    104. 

  104.  * return code of these functions and call them in a series then just call
    105. 

  105.  * strbuf_oom at the end.
    106. 

  106.  */
    107. 

  107. __attribute__((visibility("default")))
    108. 

  108. extern int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len);
    109. 

  109. __attribute__((visibility("default")))
    110. 

  110. extern int cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
    111. 

  111. __attribute__((visibility("default")))
    112. 

  112. extern int cmark_strbuf_putc(cmark_strbuf *buf, int c);
    113. 

  113. __attribute__((visibility("default")))
    114. 

  114. extern int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len);
    115. 

  115. __attribute__((visibility("default")))
    116. 

  116. extern int cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
    117. 

  117. __attribute__((visibility("default")))
    118. 

  118. extern int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...)
    119. 

  119.     __attribute__((format (printf, 2, 3)));
    120. 

  120. __attribute__((visibility("default")))
    121. 

  121. extern int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap);
    122. 

  122. __attribute__((visibility("default")))
    123. 

  123. extern void cmark_strbuf_clear(cmark_strbuf *buf);
    124. 

  124. 

  125. __attribute__((visibility("default")))
    126. 

  126. int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos);
    127. 

  127. __attribute__((visibility("default")))
    128. 

  128. int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos);
    129. 

  129. __attribute__((visibility("default")))
    130. 

  130. void cmark_strbuf_drop(cmark_strbuf *buf, int n);
    131. 

  131. __attribute__((visibility("default")))
    132. 

  132. void cmark_strbuf_truncate(cmark_strbuf *buf, int len);
    133. 

  133. __attribute__((visibility("default")))
    134. 

  134. void cmark_strbuf_rtrim(cmark_strbuf *buf);
    135. 

  135. __attribute__((visibility("default")))
    136. 

  136. void cmark_strbuf_trim(cmark_strbuf *buf);
    137. 

  137. __attribute__((visibility("default")))
    138. 

  138. void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
    139. 

  139. __attribute__((visibility("default")))
    140. 

  140. void cmark_strbuf_unescape(cmark_strbuf *s);
    141. 

  141. 

  142. #ifndef CMARK_NO_SHORT_NAMES
    143. 

  143.   #define strbuf                        cmark_strbuf
    144. 

  144.   #define strbuf__initbuf               cmark_strbuf__initbuf
    145. 

  145.   #define strbuf__oom                   cmark_strbuf__oom
    146. 

  146.   #define GH_BUF_INIT                   CMARK_GH_BUF_INIT
    147. 

  147.   #define strbuf_init                   cmark_strbuf_init
    148. 

  148.   #define strbuf_try_grow               cmark_strbuf_try_grow
    149. 

  149.   #define strbuf_grow                   cmark_strbuf_grow
    150. 

  150.   #define strbuf_free                   cmark_strbuf_free
    151. 

  151.   #define strbuf_swap                   cmark_strbuf_swap
    152. 

  152.   #define strbuf_oom                    cmark_strbuf_oom
    153. 

  153.   #define strbuf_len                    cmark_strbuf_len
    154. 

  154.   #define strbuf_cmp                    cmark_strbuf_cmp
    155. 

  155.   #define strbuf_attach                 cmark_strbuf_attach
    156. 

  156.   #define strbuf_detach                 cmark_strbuf_detach
    157. 

  157.   #define strbuf_copy_cstr              cmark_strbuf_copy_cstr
    158. 

  158.   #define strbuf_cstr                   cmark_strbuf_cstr
    159. 

  159.   #define strbuf_at                     cmark_strbuf_at
    160. 

  160.   #define strbuf_set                    cmark_strbuf_set
    161. 

  161.   #define strbuf_sets                   cmark_strbuf_sets
    162. 

  162.   #define strbuf_putc                   cmark_strbuf_putc
    163. 

  163.   #define strbuf_put                    cmark_strbuf_put
    164. 

  164.   #define strbuf_puts                   cmark_strbuf_puts
    165. 

  165.   #define strbuf_printf                 cmark_strbuf_printf
    166. 

  166.   #define strbuf_vprintf                cmark_strbuf_vprintf
    167. 

  167.   #define strbuf_clear                  cmark_strbuf_clear
    168. 

  168.   #define strbuf_strchr                 cmark_strbuf_strchr
    169. 

  169.   #define strbuf_strrchr                cmark_strbuf_strrchr
    170. 

  170.   #define strbuf_drop                   cmark_strbuf_drop
    171. 

  171.   #define strbuf_truncate               cmark_strbuf_truncate
    172. 

  172.   #define strbuf_rtrim                  cmark_strbuf_rtrim
    173. 

  173.   #define strbuf_trim                   cmark_strbuf_trim
    174. 

  174.   #define strbuf_normalize_whitespace   cmark_strbuf_normalize_whitespace
    175. 

  175.   #define strbuf_unescape               cmark_strbuf_unescape
    176. 

  176. #endif
    177. 

  177. 

  178. #endif
    179.
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-26 03:17:37 +0000