commonmarker 0.17.11 → 0.17.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a388fc4615d46df235e0536567b730b5696f6be
-  data.tar.gz: 3f3933a0d6b4d5ba04c1addc9bd112e618c2b970
+  metadata.gz: 38d855b874ccd9a4c249fb89ee64dee0ee340cf4
+  data.tar.gz: 712809d0eb64eeeb4d9976101ba205533e7a92d9
 SHA512:
-  metadata.gz: d183bae283bc551704d5244a0483895817ac4ab0339cdf8a97838ab52afe8dc9e4f01b556f70b0de9738b2c35606f735d2972baa3093f3b6e226b0b18ab1daf0
-  data.tar.gz: f1b2ce96fed16ef6de201eb23e7a832fdbf7ca941d9158727747c9fb63211e206659bcd05752ebb0121a67d836a43f629107d9a5eef52f17bd924de1b38e4eb9
+  metadata.gz: 38abd249d3f023e13b5f6cd97a72cd421e887637964da5b3fd25badafc2326f33679af61ebf31103347648547d6ea4077a8bd4754fa02bffab538538fa9d90cd
+  data.tar.gz: 7c023d24403c1b5774dde7324f32992299376d5773b35435215da9acee613470f49451be69dbf2dc3cc1291a33e19f64a8fba41e9e0560f48d7b49ef615fb0c1

data/ext/commonmarker/arena.c

@@ -1,8 +1,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 
 static struct arena_chunk {
   size_t sz, used;

data/ext/commonmarker/autolink.h

@@ -1,7 +1,7 @@
-#ifndef AUTOLINK_H
-#define AUTOLINK_H
+#ifndef CMARK_GFM_AUTOLINK_H
+#define CMARK_GFM_AUTOLINK_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 cmark_syntax_extension *create_autolink_extension(void);
 

data/ext/commonmarker/blocks.c

@@ -13,7 +13,7 @@
 #include "syntax_extension.h"
 #include "config.h"
 #include "parser.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "references.h"
 #include "utf8.h"

data/ext/commonmarker/buffer.h

@@ -7,7 +7,7 @@
 #include <limits.h>
 #include <stdint.h>
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,32 +30,32 @@ extern unsigned char cmark_strbuf__initbuf[];
  * For the cases where CMARK_BUF_INIT cannot be used to do static
  * initialization.
  */
-CMARK_EXPORT
+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_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_free(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_len(const cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
                             const cmark_strbuf *buf);
 
@@ -65,48 +65,48 @@ static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) {
 
 #define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
                       bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_putc(cmark_strbuf *buf, int c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
                       bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_clear(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_rtrim(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_trim(cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_strbuf_unescape(cmark_strbuf *s);
 
 #ifdef __cplusplus

data/ext/commonmarker/chunk.h

@@ -4,7 +4,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "buffer.h"
 #include "memory.h"
 #include "cmark_ctype.h"

data/ext/commonmarker/cmark-gfm-core-extensions.h

@@ -0,0 +1,25 @@
+#ifndef CMARK_GFM_CORE_EXTENSIONS_H
+#define CMARK_GFM_CORE_EXTENSIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm-extension_api.h"
+#include "cmark-gfm-extensions_export.h"
+#include <stdint.h>
+
+CMARK_GFM_EXTENSIONS_EXPORT
+void cmark_gfm_core_extensions_ensure_registered(void);
+
+CMARK_GFM_EXTENSIONS_EXPORT
+uint16_t cmark_gfm_extensions_get_table_columns(cmark_node *node);
+
+CMARK_GFM_EXTENSIONS_EXPORT
+uint8_t *cmark_gfm_extensions_get_table_alignments(cmark_node *node);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/commonmarker/{cmark_extension_api.h → cmark-gfm-extension_api.h}

@@ -1,11 +1,11 @@
-#ifndef CMARK_CMARK_EXTENSION_API_H
-#define CMARK_CMARK_EXTENSION_API_H
+#ifndef CMARK_GFM_EXTENSION_API_H
+#define CMARK_GFM_EXTENSION_API_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 struct cmark_renderer;
 struct cmark_html_renderer;
@@ -170,7 +170,7 @@ typedef int (*cmark_plugin_init_func)(cmark_plugin *plugin);
  * This takes ownership of 'extension', one should not call
  * 'cmark_syntax_extension_free' on a registered extension.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_plugin_register_syntax_extension(cmark_plugin *plugin,
                                             cmark_syntax_extension *extension);
 
@@ -180,7 +180,7 @@ int cmark_plugin_register_syntax_extension(cmark_plugin *plugin,
  *  It can then be attached to a cmark_parser
  *  with the cmark_parser_attach_syntax_extension method.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_syntax_extension *cmark_find_syntax_extension(const char *name);
 
 /** Should create and add a new open block to 'parent_container' if
@@ -260,143 +260,143 @@ typedef void (*cmark_opaque_free_func) (cmark_syntax_extension *extension,
 
 /** Free a cmark_syntax_extension.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_free               (cmark_mem *mem, cmark_syntax_extension *extension);
 
 /** Return a newly-constructed cmark_syntax_extension, named 'name'.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_syntax_extension *cmark_syntax_extension_new (const char *name);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node_type cmark_syntax_extension_add_node(int is_inline);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_emphasis(cmark_syntax_extension *extension, int emphasis);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_open_block_func(cmark_syntax_extension *extension,
                                                 cmark_open_block_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_match_block_func(cmark_syntax_extension *extension,
                                                  cmark_match_block_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_match_inline_func(cmark_syntax_extension *extension,
                                                   cmark_match_inline_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_inline_from_delim_func(cmark_syntax_extension *extension,
                                                        cmark_inline_from_delim_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_special_inline_chars(cmark_syntax_extension *extension,
                                                      cmark_llist *special_chars);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_get_type_string_func(cmark_syntax_extension *extension,
                                                      cmark_get_type_string_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_can_contain_func(cmark_syntax_extension *extension,
                                                  cmark_can_contain_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_contains_inlines_func(cmark_syntax_extension *extension,
                                                       cmark_contains_inlines_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_extension *extension,
                                                        cmark_common_render_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_extension *extension,
                                                       cmark_common_render_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension *extension,
                                                   cmark_common_render_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *extension,
                                                 cmark_common_render_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_html_render_func(cmark_syntax_extension *extension,
                                                  cmark_html_render_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension *extension,
                                                  cmark_html_filter_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
                                                        cmark_commonmark_escape_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_private(cmark_syntax_extension *extension,
                                         void *priv,
                                         cmark_free_func free_func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void *cmark_syntax_extension_get_private(cmark_syntax_extension *extension);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_postprocess_func(cmark_syntax_extension *extension,
                                                  cmark_postprocess_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
                                                  cmark_opaque_free_func func);
 
 /** See the documentation for 'cmark_syntax_extension'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parser_set_backslash_ispunct_func(cmark_parser *parser,
                                              cmark_ispunct_func func);
 
 /** Return the index of the line currently being parsed, starting with 1.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_line_number(cmark_parser *parser);
 
 /** Return the offset in bytes in the line being processed.
@@ -407,7 +407,7 @@ int cmark_parser_get_line_number(cmark_parser *parser);
  *
  * Here, offset will first be 0, then 5 (the index of the 'f' character).
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_offset(cmark_parser *parser);
 
 /**
@@ -441,7 +441,7 @@ int cmark_parser_get_offset(cmark_parser *parser);
  * cmark_parser_has_partially_consumed_tab() will now return
  * 'true'.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_column(cmark_parser *parser);
 
 /** Return the absolute index in bytes of the first nonspace
@@ -456,7 +456,7 @@ int cmark_parser_get_column(cmark_parser *parser);
  * 0            offset (16) first_nonspace (28)
  * ```
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_first_nonspace(cmark_parser *parser);
 
 /** Return the absolute index of the first nonspace column coming after 'offset'
@@ -466,7 +466,7 @@ int cmark_parser_get_first_nonspace(cmark_parser *parser);
  * See the documentation for cmark_parser_get_first_nonspace() and
  * cmark_parser_get_column() for more information.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_first_nonspace_column(cmark_parser *parser);
 
 /** Return the difference between the values returned by
@@ -476,7 +476,7 @@ int cmark_parser_get_first_nonspace_column(cmark_parser *parser);
  * This is not a byte offset, as it can count one tab as multiple
  * characters.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_indent(cmark_parser *parser);
 
 /** Return 'true' if the line currently being processed has been entirely
@@ -507,7 +507,7 @@ int cmark_parser_get_indent(cmark_parser *parser);
  *
  * At this point, this function will now return 'true'.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_is_blank(cmark_parser *parser);
 
 /** Return 'true' if the value returned by cmark_parser_get_offset()
@@ -516,13 +516,13 @@ int cmark_parser_is_blank(cmark_parser *parser);
  * See the documentation for cmark_parser_get_column() for more
  * information.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_has_partially_consumed_tab(cmark_parser *parser);
 
 /** Return the length in bytes of the previously processed line, excluding potential
  * newline (\n) and carriage return (\r) trailing characters.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_get_last_line_length(cmark_parser *parser);
 
 /** Add a child to 'parent' during the parsing process.
@@ -531,7 +531,7 @@ int cmark_parser_get_last_line_length(cmark_parser *parser);
  * this function will back up till it hits a node that can, closing
  * blocks as appropriate.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node*cmark_parser_add_child(cmark_parser *parser,
                                   cmark_node *parent,
                                   cmark_node_type block_type,
@@ -542,14 +542,14 @@ cmark_node*cmark_parser_add_child(cmark_parser *parser,
  * See the documentation of cmark_parser_get_offset() and
  * cmark_parser_get_column() for more information.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parser_advance_offset(cmark_parser *parser,
                                  const char *input,
                                  int count,
                                  int columns);
 
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffer, size_t len);
 
 /** Attach the syntax 'extension' to the 'parser', to provide extra syntax
@@ -559,33 +559,33 @@ void cmark_parser_feed_reentrant(cmark_parser *parser, const char *buffer, size_
  *  Returns 'true' if the 'extension' was successfully attached,
  *  'false' otherwise.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_parser_attach_syntax_extension(cmark_parser *parser, cmark_syntax_extension *extension);
 
 /** Change the type of 'node'.
  *
  * Return 0 if the type could be changed, 1 otherwise.
  */
-CMARK_EXPORT int cmark_node_set_type(cmark_node *node, cmark_node_type type);
+CMARK_GFM_EXPORT int cmark_node_set_type(cmark_node *node, cmark_node_type type);
 
 /** Return the string content for all types of 'node'.
  *  The pointer stays valid as long as 'node' isn't freed.
  */
-CMARK_EXPORT const char *cmark_node_get_string_content(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_string_content(cmark_node *node);
 
 /** Set the string 'content' for all types of 'node'.
  *  Copies 'content'.
  */
-CMARK_EXPORT int cmark_node_set_string_content(cmark_node *node, const char *content);
+CMARK_GFM_EXPORT int cmark_node_set_string_content(cmark_node *node, const char *content);
 
 /** Get the syntax extension responsible for the creation of 'node'.
  *  Return NULL if 'node' was created because it matched standard syntax rules.
  */
-CMARK_EXPORT cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node);
+CMARK_GFM_EXPORT cmark_syntax_extension *cmark_node_get_syntax_extension(cmark_node *node);
 
 /** Set the syntax extension responsible for creating 'node'.
  */
-CMARK_EXPORT int cmark_node_set_syntax_extension(cmark_node *node,
+CMARK_GFM_EXPORT int cmark_node_set_syntax_extension(cmark_node *node,
                                                   cmark_syntax_extension *extension);
 
 /**
@@ -600,63 +600,63 @@ CMARK_EXPORT int cmark_node_set_syntax_extension(cmark_node *node,
 typedef int (*cmark_inline_predicate)(int c);
 
 /** Advance the current inline parsing offset */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_inline_parser_advance_offset(cmark_inline_parser *parser);
 
 /** Get the current inline parsing offset */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_get_offset(cmark_inline_parser *parser);
 
 /** Set the offset in bytes in the chunk being processed by the given inline parser.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_inline_parser_set_offset(cmark_inline_parser *parser, int offset);
 
 /** Gets the cmark_chunk being operated on by the given inline parser.
  * Use cmark_inline_parser_get_offset to get our current position in the chunk.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 struct cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser);
 
 /** Returns 1 if the inline parser is currently in a bracket; pass 1 for 'image'
  * if you want to know about an image-type bracket, 0 for link-type. */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int image);
 
 /** Remove the last n characters from the last child of the given node.
  * This only works where all n characters are in the single last child, and the last
  * child is CMARK_NODE_TEXT.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_node_unput(cmark_node *node, int n);
 
 
 /** Get the character located at the current inline parsing offset
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 unsigned char cmark_inline_parser_peek_char(cmark_inline_parser *parser);
 
 /** Get the character located 'pos' bytes in the current line.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 unsigned char cmark_inline_parser_peek_at(cmark_inline_parser *parser, int pos);
 
 /** Whether the inline parser has reached the end of the current line
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_is_eof(cmark_inline_parser *parser);
 
 /** Get the characters located after the current inline parsing offset
  * while 'pred' matches. Free after usage.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_inline_parser_take_while(cmark_inline_parser *parser, cmark_inline_predicate pred);
 
 /** Push a delimiter on the delimiter stack.
  * See <<http://spec.commonmark.org/0.24/#phase-2-inline-structure> for
  * more information on the parameters
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser,
                                   unsigned char c,
                                   int can_open,
@@ -665,16 +665,16 @@ void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser,
 
 /** Remove 'delim' from the delimiter stack
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_inline_parser_remove_delimiter(cmark_inline_parser *parser, delimiter *delim);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 delimiter *cmark_inline_parser_get_last_delimiter(cmark_inline_parser *parser);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_get_line(cmark_inline_parser *parser);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_get_column(cmark_inline_parser *parser);
 
 /** Convenience function to scan a given delimiter.
@@ -691,7 +691,7 @@ int cmark_inline_parser_get_column(cmark_inline_parser *parser);
  * Returns the number of delimiters encountered, in the limit
  * of 'max_delims', and advances the inline parsing offset.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
                                   int max_delims,
                                   unsigned char c,
@@ -700,16 +700,16 @@ int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
                                   int *punct_before,
                                   int *punct_after);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_manage_extensions_special_characters(cmark_parser *parser, int add);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_arena_push(void);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_arena_pop(void);
 
 #ifdef __cplusplus