commonmarker 0.17.11 → 0.17.12

data/ext/commonmarker/cmark-gfm-extensions_export.h

@@ -0,0 +1,42 @@
+
+#ifndef CMARK_GFM_EXTENSIONS_EXPORT_H
+#define CMARK_GFM_EXTENSIONS_EXPORT_H
+
+#ifdef CMARK_GFM_EXTENSIONS_STATIC_DEFINE
+#  define CMARK_GFM_EXTENSIONS_EXPORT
+#  define CMARK_GFM_EXTENSIONS_NO_EXPORT
+#else
+#  ifndef CMARK_GFM_EXTENSIONS_EXPORT
+#    ifdef libcmark_gfm_extensions_EXPORTS
+        /* We are building this library */
+#      define CMARK_GFM_EXTENSIONS_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define CMARK_GFM_EXTENSIONS_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef CMARK_GFM_EXTENSIONS_NO_EXPORT
+#    define CMARK_GFM_EXTENSIONS_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED_EXPORT
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED_EXPORT CMARK_GFM_EXTENSIONS_EXPORT CMARK_GFM_EXTENSIONS_DEPRECATED
+#endif
+
+#ifndef CMARK_GFM_EXTENSIONS_DEPRECATED_NO_EXPORT
+#  define CMARK_GFM_EXTENSIONS_DEPRECATED_NO_EXPORT CMARK_GFM_EXTENSIONS_NO_EXPORT CMARK_GFM_EXTENSIONS_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef CMARK_GFM_EXTENSIONS_NO_DEPRECATED
+#    define CMARK_GFM_EXTENSIONS_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* CMARK_GFM_EXTENSIONS_EXPORT_H */

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

@@ -1,10 +1,10 @@
-#ifndef CMARK_CMARK_H
-#define CMARK_CMARK_H
+#ifndef CMARK_GFM_H
+#define CMARK_GFM_H
 
 #include <stdio.h>
 #include <stdint.h>
-#include "cmark_export.h"
-#include "cmark_version.h"
+#include "cmark-gfm_export.h"
+#include "cmark-gfm_version.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -25,7 +25,7 @@ extern "C" {
  * UTF-8-encoded string. It is the caller's responsibility
  * to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_markdown_to_html(const char *text, size_t len, int options);
 
 /** ## Node Structure
@@ -109,19 +109,19 @@ typedef struct cmark_mem {
 /** The default memory allocator; uses the system's calloc,
  * realloc and free.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_mem *cmark_get_default_mem_allocator();
 
 /** An arena allocator; uses system calloc to allocate large
  * slabs of memory.  Memory in these slabs is not reused at all.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_mem *cmark_get_arena_mem_allocator();
 
 /** Resets the arena allocator, quickly returning all used memory
  * to the operating system.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_arena_reset(void);
 
 /** Callback for freeing user data with a 'cmark_mem' context.
@@ -151,7 +151,7 @@ typedef struct _cmark_llist
 /** Append an element to the linked list, return the possibly modified
  * head of the list.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_llist * cmark_llist_append    (cmark_mem         * mem,
                                      cmark_llist       * head,
                                      void              * data);
@@ -159,14 +159,14 @@ cmark_llist * cmark_llist_append    (cmark_mem         * mem,
 /** Free the list starting with 'head', calling 'free_func' with the
  *  data pointer of each of its elements
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void          cmark_llist_free_full (cmark_mem         * mem,
                                      cmark_llist       * head,
                                      cmark_free_func     free_func);
 
 /** Free the list starting with 'head'
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void          cmark_llist_free      (cmark_mem         * mem,
                                      cmark_llist       * head);
 
@@ -178,18 +178,18 @@ void          cmark_llist_free      (cmark_mem         * mem,
  * other required properties, which it is the caller's responsibility
  * to assign.
  */
-CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type);
+CMARK_GFM_EXPORT cmark_node *cmark_node_new(cmark_node_type type);
 
 /** Same as `cmark_node_new`, but explicitly listing the memory
  * allocator used to allocate the node.  Note:  be sure to use the same
  * allocator for every node in a tree, or bad things can happen.
  */
-CMARK_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type,
+CMARK_GFM_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type,
                                                  cmark_mem *mem);
 
 /** Frees the memory allocated for a node and any children.
  */
-CMARK_EXPORT void cmark_node_free(cmark_node *node);
+CMARK_GFM_EXPORT void cmark_node_free(cmark_node *node);
 
 /**
  * ## Tree Traversal
@@ -198,24 +198,24 @@ CMARK_EXPORT void cmark_node_free(cmark_node *node);
 /** Returns the next node in the sequence after 'node', or NULL if
  * there is none.
  */
-CMARK_EXPORT cmark_node *cmark_node_next(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node *cmark_node_next(cmark_node *node);
 
 /** Returns the previous node in the sequence after 'node', or NULL if
  * there is none.
  */
-CMARK_EXPORT cmark_node *cmark_node_previous(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node *cmark_node_previous(cmark_node *node);
 
 /** Returns the parent of 'node', or NULL if there is none.
  */
-CMARK_EXPORT cmark_node *cmark_node_parent(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node *cmark_node_parent(cmark_node *node);
 
 /** Returns the first child of 'node', or NULL if 'node' has no children.
  */
-CMARK_EXPORT cmark_node *cmark_node_first_child(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node *cmark_node_first_child(cmark_node *node);
 
 /** Returns the last child of 'node', or NULL if 'node' has no children.
  */
-CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node *cmark_node_last_child(cmark_node *node);
 
 /**
  * ## Iterator
@@ -274,40 +274,40 @@ typedef enum {
  * The memory allocated for the iterator should be released using
  * 'cmark_iter_free' when it is no longer needed.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_iter *cmark_iter_new(cmark_node *root);
 
 /** Frees the memory allocated for an iterator.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_iter_free(cmark_iter *iter);
 
 /** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`,
  * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`).
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_event_type cmark_iter_next(cmark_iter *iter);
 
 /** Returns the current node.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node *cmark_iter_get_node(cmark_iter *iter);
 
 /** Returns the current event type.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_event_type cmark_iter_get_event_type(cmark_iter *iter);
 
 /** Returns the root node.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node *cmark_iter_get_root(cmark_iter *iter);
 
 /** Resets the iterator so that the current node is 'current' and
  * the event type is 'event_type'.  The new current node must be a
  * descendant of the root node or the root node itself.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
                       cmark_event_type event_type);
 
@@ -317,42 +317,42 @@ void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
 
 /** Returns the user data of 'node'.
  */
-CMARK_EXPORT void *cmark_node_get_user_data(cmark_node *node);
+CMARK_GFM_EXPORT void *cmark_node_get_user_data(cmark_node *node);
 
 /** Sets arbitrary user data for 'node'.  Returns 1 on success,
  * 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data);
+CMARK_GFM_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data);
 
 /** Set free function for user data */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_node_set_user_data_free_func(cmark_node *node,
                                         cmark_free_func free_func);
 
 /** Returns the type of 'node', or `CMARK_NODE_NONE` on error.
  */
-CMARK_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node);
+CMARK_GFM_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node);
 
 /** Like 'cmark_node_get_type', but returns a string representation
     of the type, or `"<unknown>"`.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 const char *cmark_node_get_type_string(cmark_node *node);
 
 /** Returns the string contents of 'node', or an empty
     string if none is set.  Returns NULL if called on a
     node that does not have string content.
  */
-CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_literal(cmark_node *node);
 
 /** Sets the string contents of 'node'.  Returns 1 on success,
  * 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_literal(cmark_node *node, const char *content);
+CMARK_GFM_EXPORT int cmark_node_set_literal(cmark_node *node, const char *content);
 
 /** Returns the heading level of 'node', or 0 if 'node' is not a heading.
  */
-CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_heading_level(cmark_node *node);
 
 /* For backwards compatibility */
 #define cmark_node_get_header_level cmark_node_get_heading_level
@@ -360,126 +360,126 @@ CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node);
 
 /** Sets the heading level of 'node', returning 1 on success and 0 on error.
  */
-CMARK_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level);
+CMARK_GFM_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level);
 
 /** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node'
  * is not a list.
  */
-CMARK_EXPORT cmark_list_type cmark_node_get_list_type(cmark_node *node);
+CMARK_GFM_EXPORT cmark_list_type cmark_node_get_list_type(cmark_node *node);
 
 /** Sets the list type of 'node', returning 1 on success and 0 on error.
  */
-CMARK_EXPORT int cmark_node_set_list_type(cmark_node *node,
+CMARK_GFM_EXPORT int cmark_node_set_list_type(cmark_node *node,
                                           cmark_list_type type);
 
 /** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node'
  * is not a list.
  */
-CMARK_EXPORT cmark_delim_type cmark_node_get_list_delim(cmark_node *node);
+CMARK_GFM_EXPORT cmark_delim_type cmark_node_get_list_delim(cmark_node *node);
 
 /** Sets the list delimiter type of 'node', returning 1 on success and 0
  * on error.
  */
-CMARK_EXPORT int cmark_node_set_list_delim(cmark_node *node,
+CMARK_GFM_EXPORT int cmark_node_set_list_delim(cmark_node *node,
                                            cmark_delim_type delim);
 
 /** Returns starting number of 'node', if it is an ordered list, otherwise 0.
  */
-CMARK_EXPORT int cmark_node_get_list_start(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_list_start(cmark_node *node);
 
 /** Sets starting number of 'node', if it is an ordered list. Returns 1
  * on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_list_start(cmark_node *node, int start);
+CMARK_GFM_EXPORT int cmark_node_set_list_start(cmark_node *node, int start);
 
 /** Returns 1 if 'node' is a tight list, 0 otherwise.
  */
-CMARK_EXPORT int cmark_node_get_list_tight(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_list_tight(cmark_node *node);
 
 /** Sets the "tightness" of a list.  Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight);
+CMARK_GFM_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight);
 
 /** Returns the info string from a fenced code block.
  */
-CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_fence_info(cmark_node *node);
 
 /** Sets the info string in a fenced code block, returning 1 on
  * success and 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info);
+CMARK_GFM_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info);
 
 /** Sets code blocks fencing details
  */
-CMARK_EXPORT int cmark_node_set_fenced(cmark_node * node, int fenced,
+CMARK_GFM_EXPORT int cmark_node_set_fenced(cmark_node * node, int fenced,
     int length, int offset, char character);
 
 /** Returns code blocks fencing details
  */
-CMARK_EXPORT int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, char *character);
+CMARK_GFM_EXPORT int cmark_node_get_fenced(cmark_node *node, int *length, int *offset, char *character);
 
 /** Returns the URL of a link or image 'node', or an empty string
     if no URL is set.  Returns NULL if called on a node that is
     not a link or image.
  */
-CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_url(cmark_node *node);
 
 /** Sets the URL of a link or image 'node'. Returns 1 on success,
  * 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_url(cmark_node *node, const char *url);
+CMARK_GFM_EXPORT int cmark_node_set_url(cmark_node *node, const char *url);
 
 /** Returns the title of a link or image 'node', or an empty
     string if no title is set.  Returns NULL if called on a node
     that is not a link or image.
  */
-CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_title(cmark_node *node);
 
 /** Sets the title of a link or image 'node'. Returns 1 on success,
  * 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title);
+CMARK_GFM_EXPORT int cmark_node_set_title(cmark_node *node, const char *title);
 
 /** Returns the literal "on enter" text for a custom 'node', or
     an empty string if no on_enter is set.  Returns NULL if called
     on a non-custom node.
  */
-CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_on_enter(cmark_node *node);
 
 /** Sets the literal text to render "on enter" for a custom 'node'.
     Any children of the node will be rendered after this text.
     Returns 1 on success 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node,
+CMARK_GFM_EXPORT int cmark_node_set_on_enter(cmark_node *node,
                                          const char *on_enter);
 
 /** Returns the literal "on exit" text for a custom 'node', or
     an empty string if no on_exit is set.  Returns NULL if
     called on a non-custom node.
  */
-CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node);
+CMARK_GFM_EXPORT const char *cmark_node_get_on_exit(cmark_node *node);
 
 /** Sets the literal text to render "on exit" for a custom 'node'.
     Any children of the node will be rendered before this text.
     Returns 1 on success 0 on failure.
  */
-CMARK_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit);
+CMARK_GFM_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit);
 
 /** Returns the line on which 'node' begins.
  */
-CMARK_EXPORT int cmark_node_get_start_line(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_start_line(cmark_node *node);
 
 /** Returns the column at which 'node' begins.
  */
-CMARK_EXPORT int cmark_node_get_start_column(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_start_column(cmark_node *node);
 
 /** Returns the line on which 'node' ends.
  */
-CMARK_EXPORT int cmark_node_get_end_line(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_end_line(cmark_node *node);
 
 /** Returns the column at which 'node' ends.
  */
-CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node);
+CMARK_GFM_EXPORT int cmark_node_get_end_column(cmark_node *node);
 
 /**
  * ## Tree Manipulation
@@ -488,40 +488,40 @@ CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node);
 /** Unlinks a 'node', removing it from the tree, but not freeing its
  * memory.  (Use 'cmark_node_free' for that.)
  */
-CMARK_EXPORT void cmark_node_unlink(cmark_node *node);
+CMARK_GFM_EXPORT void cmark_node_unlink(cmark_node *node);
 
 /** Inserts 'sibling' before 'node'.  Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_insert_before(cmark_node *node,
+CMARK_GFM_EXPORT int cmark_node_insert_before(cmark_node *node,
                                           cmark_node *sibling);
 
 /** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling);
+CMARK_GFM_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling);
 
 /** Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does
  * not free its memory).
  * Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode);
+CMARK_GFM_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode);
 
 /** Adds 'child' to the beginning of the children of 'node'.
  * Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_prepend_child(cmark_node *node, cmark_node *child);
+CMARK_GFM_EXPORT int cmark_node_prepend_child(cmark_node *node, cmark_node *child);
 
 /** Adds 'child' to the end of the children of 'node'.
  * Returns 1 on success, 0 on failure.
  */
-CMARK_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child);
+CMARK_GFM_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child);
 
 /** Consolidates adjacent text nodes.
  */
-CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root);
+CMARK_GFM_EXPORT void cmark_consolidate_text_nodes(cmark_node *root);
 
 /** Ensures a node and all its children own their own chunk memory.
  */
-CMARK_EXPORT void cmark_node_own(cmark_node *root);
+CMARK_GFM_EXPORT void cmark_node_own(cmark_node *root);
 
 /**
  * ## Parsing
@@ -547,27 +547,27 @@ CMARK_EXPORT void cmark_node_own(cmark_node *root);
 
 /** Creates a new parser object.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_parser *cmark_parser_new(int options);
 
 /** Creates a new parser object with the given memory allocator
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
 
 /** Frees memory allocated for a parser object.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parser_free(cmark_parser *parser);
 
 /** Feeds a string of length 'len' to 'parser'.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len);
 
 /** Finish parsing and return a pointer to a tree of nodes.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node *cmark_parser_finish(cmark_parser *parser);
 
 /** Parse a CommonMark document in 'buffer' of length 'len'.
@@ -575,14 +575,14 @@ cmark_node *cmark_parser_finish(cmark_parser *parser);
  * the node tree should be released using 'cmark_node_free'
  * when it is no longer needed.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node *cmark_parse_document(const char *buffer, size_t len, int options);
 
 /** Parse a CommonMark document in file 'f', returning a pointer to
  * a tree of nodes.  The memory allocated for the node tree should be
  * released using 'cmark_node_free' when it is no longer needed.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_node *cmark_parse_file(FILE *f, int options);
 
 /**
@@ -592,74 +592,74 @@ cmark_node *cmark_parse_file(FILE *f, int options);
 /** Render a 'node' tree as XML.  It is the caller's responsibility
  * to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_xml(cmark_node *root, int options);
 
 /** As for 'cmark_render_xml', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_xml_with_mem(cmark_node *root, int options, cmark_mem *mem);
 
 /** Render a 'node' tree as an HTML fragment.  It is up to the user
  * to add an appropriate header and footer. It is the caller's
  * responsibility to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_html(cmark_node *root, int options, cmark_llist *extensions);
 
 /** As for 'cmark_render_html', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_html_with_mem(cmark_node *root, int options, cmark_llist *extensions, cmark_mem *mem);
 
 /** Render a 'node' tree as a groff man page, without the header.
  * It is the caller's responsibility to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_man(cmark_node *root, int options, int width);
 
 /** As for 'cmark_render_man', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_man_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
 
 /** Render a 'node' tree as a commonmark document.
  * It is the caller's responsibility to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_commonmark(cmark_node *root, int options, int width);
 
 /** As for 'cmark_render_commonmark', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_commonmark_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
 
 /** Render a 'node' tree as a plain text document.
  * It is the caller's responsibility to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_plaintext(cmark_node *root, int options, int width);
 
 /** As for 'cmark_render_plaintext', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
 
 /** Render a 'node' tree as a LaTeX document.
  * It is the caller's responsibility to free the returned buffer.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_latex(cmark_node *root, int options, int width);
 
 /** As for 'cmark_render_latex', but specifying the allocator to use for
  * the resulting string.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
 
 /**
@@ -751,13 +751,13 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  *
  * In hexadecimal format, the number 0x010203 represents version 1.2.3.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_version(void);
 
 /** The library version string for runtime checks. Also available as
  * macro CMARK_VERSION_STRING for compile time checks.
  */
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 const char *cmark_version_string(void);
 
 /** # AUTHORS