commonmarker 0.17.11 → 0.17.12

data/ext/commonmarker/cmark-gfm_export.h

@@ -0,0 +1,42 @@
+
+#ifndef CMARK_GFM_EXPORT_H
+#define CMARK_GFM_EXPORT_H
+
+#ifdef CMARK_GFM_STATIC_DEFINE
+#  define CMARK_GFM_EXPORT
+#  define CMARK_GFM_NO_EXPORT
+#else
+#  ifndef CMARK_GFM_EXPORT
+#    ifdef libcmark_gfm_EXPORTS
+        /* We are building this library */
+#      define CMARK_GFM_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define CMARK_GFM_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef CMARK_GFM_NO_EXPORT
+#    define CMARK_GFM_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED
+#  define CMARK_GFM_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED_EXPORT
+#  define CMARK_GFM_DEPRECATED_EXPORT CMARK_GFM_EXPORT CMARK_GFM_DEPRECATED
+#endif
+
+#ifndef CMARK_GFM_DEPRECATED_NO_EXPORT
+#  define CMARK_GFM_DEPRECATED_NO_EXPORT CMARK_GFM_NO_EXPORT CMARK_GFM_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef CMARK_GFM_NO_DEPRECATED
+#    define CMARK_GFM_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* CMARK_GFM_EXPORT_H */

data/ext/commonmarker/cmark-gfm_version.h

@@ -0,0 +1,7 @@
+#ifndef CMARK_GFM_VERSION_H
+#define CMARK_GFM_VERSION_H
+
+#define CMARK_GFM_VERSION ((0 << 24) | (28 << 16) | (3 << 8) | 15)
+#define CMARK_GFM_VERSION_STRING "0.28.3.gfm.15"
+
+#endif

data/ext/commonmarker/cmark.c

@@ -4,15 +4,15 @@
 #include "registry.h"
 #include "node.h"
 #include "houdini.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "buffer.h"
 
 cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION;
 cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE;
 
-int cmark_version() { return CMARK_VERSION; }
+int cmark_version() { return CMARK_GFM_VERSION; }
 
-const char *cmark_version_string() { return CMARK_VERSION_STRING; }
+const char *cmark_version_string() { return CMARK_GFM_VERSION_STRING; }
 
 static void *xcalloc(size_t nmem, size_t size) {
   void *ptr = calloc(nmem, size);

data/ext/commonmarker/cmark_ctype.h

@@ -5,25 +5,25 @@
 extern "C" {
 #endif
 
-#include "cmark_export.h"
+#include "cmark-gfm_export.h"
 
 /** Locale-independent versions of functions from ctype.h.
  * We want cmark to behave the same no matter what the system locale.
  */
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isspace(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_ispunct(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalnum(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isdigit(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalpha(char c);
 
 #ifdef __cplusplus

data/ext/commonmarker/commonmark.c

@@ -5,7 +5,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"
@@ -35,7 +35,7 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
       c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
         (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
-         c == '>' || c == '\\' || c == '`' || c == '!' ||
+         c == '>' || c == '\\' || c == '`' || c == '~' || c == '!' ||
          (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
          (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
           // begin_content doesn't get set to false til we've passed digits

data/ext/commonmarker/commonmarker.c

@@ -1,11 +1,11 @@
 #include "commonmarker.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "node.h"
 #include "registry.h"
 #include "parser.h"
 #include "syntax_extension.h"
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 static VALUE rb_mNodeError;
 static VALUE rb_mNode;
@@ -1041,8 +1041,8 @@ static VALUE rb_node_get_table_alignments(VALUE self) {
   VALUE ary;
   Data_Get_Struct(self, cmark_node, node);
 
-  column_count = cmarkextensions_get_table_columns(node);
-  alignments = cmarkextensions_get_table_alignments(node);
+  column_count = cmark_gfm_extensions_get_table_columns(node);
+  alignments = cmark_gfm_extensions_get_table_alignments(node);
 
   if (!column_count || !alignments) {
     rb_raise(rb_mNodeError, "could not get column_count or alignments");
@@ -1193,5 +1193,5 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_define_method(rb_mNode, "html_escape_href", rb_html_escape_href, 1);
   rb_define_method(rb_mNode, "html_escape_html", rb_html_escape_html, 1);
 
-  core_extensions_ensure_registered();
+  cmark_gfm_core_extensions_ensure_registered();
 }

data/ext/commonmarker/commonmarker.h

@@ -5,7 +5,7 @@
 #define __MSXML_LIBRARY_DEFINED__
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "ruby.h"
 #include "ruby/encoding.h"
 

data/ext/commonmarker/core-extensions.c

@@ -1,4 +1,4 @@
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 #include "autolink.h"
 #include "strikethrough.h"
 #include "table.h"
@@ -15,7 +15,7 @@ static int core_extensions_registration(cmark_plugin *plugin) {
   return 1;
 }
 
-void core_extensions_ensure_registered(void) {
+void cmark_gfm_core_extensions_ensure_registered(void) {
   static int registered = 0;
 
   if (!registered) {

data/ext/commonmarker/ext_scanners.h

@@ -1,5 +1,5 @@
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 #ifdef __cplusplus
 extern "C" {

data/ext/commonmarker/footnotes.c

@@ -1,4 +1,4 @@
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "parser.h"
 #include "footnotes.h"
 #include "inlines.h"

data/ext/commonmarker/houdini.h

@@ -31,22 +31,22 @@ extern "C" {
 #define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
 #define HOUDINI_UNESCAPED_SIZE(x) (x)
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
                                       bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src,
                                 bufsize_t size, int secure);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
                                  bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
                                     bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
 

data/ext/commonmarker/houdini_href_e.c

@@ -7,7 +7,7 @@
 /*
  * The following characters will not be escaped:
  *
- *		-_.+!*'(),%#@?=;:/,+&$ alphanum
+ *		-_.+!*'(),%#@?=;:/,+&$~ alphanum
  *
  * Note that this character set is the addition of:
  *
@@ -35,7 +35,7 @@ static const char HREF_SAFE[] = {
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

data/ext/commonmarker/html.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 #include "cmark_ctype.h"
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "scanners.h"
 #include "syntax_extension.h"

data/ext/commonmarker/inlines.c

@@ -7,7 +7,7 @@
 #include "node.h"
 #include "parser.h"
 #include "references.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "utf8.h"
 #include "scanners.h"

data/ext/commonmarker/inlines.h

@@ -10,7 +10,7 @@ extern "C" {
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
 cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
                          cmark_map *refmap,

data/ext/commonmarker/iterator.c

@@ -3,7 +3,7 @@
 
 #include "config.h"
 #include "node.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "iterator.h"
 
 cmark_iter *cmark_iter_new(cmark_node *root) {

data/ext/commonmarker/iterator.h

@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "memory.h"
 
 typedef struct {

data/ext/commonmarker/latex.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"

data/ext/commonmarker/linked_list.c

@@ -1,6 +1,6 @@
 #include <stdlib.h>
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) {
   cmark_llist *tmp;

data/ext/commonmarker/man.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"

data/ext/commonmarker/node.h

@@ -8,8 +8,8 @@ extern "C" {
 #include <stdio.h>
 #include <stdint.h>
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 #include "buffer.h"
 #include "chunk.h"
 
@@ -89,7 +89,7 @@ struct cmark_node {
 static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) {
   return node->content.mem;
 }
-CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+CMARK_GFM_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
 
 static CMARK_INLINE bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) {
 	return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_BLOCK;
@@ -107,7 +107,7 @@ static CMARK_INLINE bool CMARK_NODE_INLINE_P(cmark_node *node) {
 	return node != NULL && CMARK_NODE_TYPE_INLINE_P((cmark_node_type) node->type);
 }
 
-CMARK_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
+CMARK_GFM_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
 
 #ifdef __cplusplus
 }

data/ext/commonmarker/plugin.h

@@ -5,8 +5,8 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 
 /**
  * cmark_plugin:

data/ext/commonmarker/references.c

@@ -1,4 +1,4 @@
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "parser.h"
 #include "references.h"
 #include "inlines.h"

data/ext/commonmarker/registry.c

@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "syntax_extension.h"
 #include "registry.h"
 #include "plugin.h"

data/ext/commonmarker/registry.h

@@ -5,16 +5,16 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "plugin.h"
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_register_plugin(cmark_plugin_init_func reg_fn);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_release_plugins(void);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem);
 
 #ifdef __cplusplus

data/ext/commonmarker/render.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "buffer.h"
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "utf8.h"
 #include "render.h"
 #include "node.h"

data/ext/commonmarker/scanners.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_SCANNERS_H
 #define CMARK_SCANNERS_H
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "chunk.h"
 
 #ifdef __cplusplus

data/ext/commonmarker/strikethrough.c

@@ -51,7 +51,6 @@ static delimiter *insert(cmark_syntax_extension *self, cmark_parser *parser,
 
   cmark_node_set_syntax_extension(strikethrough, self);
 
-  cmark_node_set_string_content(strikethrough, "~");
   tmp = cmark_node_next(opener->inl_text);
 
   while (tmp) {
@@ -94,7 +93,7 @@ static int can_contain(cmark_syntax_extension *extension, cmark_node *node,
 static void commonmark_render(cmark_syntax_extension *extension,
                               cmark_renderer *renderer, cmark_node *node,
                               cmark_event_type ev_type, int options) {
-  renderer->out(renderer, node, cmark_node_get_string_content(node), false, LITERAL);
+  renderer->out(renderer, node, "~~", false, LITERAL);
 }
 
 static void latex_render(cmark_syntax_extension *extension,

data/ext/commonmarker/strikethrough.h

@@ -1,7 +1,7 @@
-#ifndef STRIKETHROUGH_H
-#define STRIKETHROUGH_H
+#ifndef CMARK_GFM_STRIKETHROUGH_H
+#define CMARK_GFM_STRIKETHROUGH_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 extern cmark_node_type CMARK_NODE_STRIKETHROUGH;
 cmark_syntax_extension *create_strikethrough_extension(void);