commonmarker 0.3.0 → 0.4.0

data/ext/commonmarker/cmark/src/node.h

@@ -13,68 +13,67 @@ extern "C" {
 #include "chunk.h"
 
 typedef struct {
-	cmark_list_type   list_type;
-	int               marker_offset;
-	int               padding;
-	int               start;
-	cmark_delim_type  delimiter;
-	unsigned char     bullet_char;
-	bool              tight;
+  cmark_list_type list_type;
+  int marker_offset;
+  int padding;
+  int start;
+  cmark_delim_type delimiter;
+  unsigned char bullet_char;
+  bool tight;
 } cmark_list;
 
 typedef struct {
-	cmark_chunk       info;
-	cmark_chunk       literal;
-	int               fence_length;
-	/* fence_offset must be 0-3, so we can use int8_t */
-	int8_t            fence_offset;
-	unsigned char     fence_char;
-	bool              fenced;
+  cmark_chunk info;
+  cmark_chunk literal;
+  int fence_length;
+  /* fence_offset must be 0-3, so we can use int8_t */
+  int8_t fence_offset;
+  unsigned char fence_char;
+  bool fenced;
 } cmark_code;
 
 typedef struct {
-	int level;
-	bool setext;
+  int level;
+  bool setext;
 } cmark_header;
 
 typedef struct {
-	cmark_chunk url;
-	cmark_chunk title;
+  cmark_chunk url;
+  cmark_chunk title;
 } cmark_link;
 
 struct cmark_node {
-	struct cmark_node *next;
-	struct cmark_node *prev;
-	struct cmark_node *parent;
-	struct cmark_node *first_child;
-	struct cmark_node *last_child;
-
-	void *user_data;
-
-	int start_line;
-	int start_column;
-	int end_line;
-	int end_column;
-
-	cmark_node_type type;
-
-	bool open;
-	bool last_line_blank;
-
-	cmark_strbuf string_content;
-
-	union {
-		cmark_chunk       literal;
-		cmark_list        list;
-		cmark_code        code;
-		cmark_header      header;
-		cmark_link        link;
-		int               html_block_type;
-	} as;
+  struct cmark_node *next;
+  struct cmark_node *prev;
+  struct cmark_node *parent;
+  struct cmark_node *first_child;
+  struct cmark_node *last_child;
+
+  void *user_data;
+
+  int start_line;
+  int start_column;
+  int end_line;
+  int end_column;
+
+  cmark_node_type type;
+
+  bool open;
+  bool last_line_blank;
+
+  cmark_strbuf string_content;
+
+  union {
+    cmark_chunk literal;
+    cmark_list list;
+    cmark_code code;
+    cmark_header header;
+    cmark_link link;
+    int html_block_type;
+  } as;
 };
 
-CMARK_EXPORT int
-cmark_node_check(cmark_node *node, FILE *out);
+CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
 
 #ifdef __cplusplus
 }

data/ext/commonmarker/cmark/src/parser.h

@@ -12,20 +12,20 @@ extern "C" {
 #define MAX_LINK_LABEL_LENGTH 1000
 
 struct cmark_parser {
-	struct cmark_reference_map *refmap;
-	struct cmark_node* root;
-	struct cmark_node* current;
-	int line_number;
-	bufsize_t offset;
-	bufsize_t column;
-	bufsize_t first_nonspace;
-	bufsize_t first_nonspace_column;
-	int indent;
-	bool blank;
-	cmark_strbuf *curline;
-	bufsize_t last_line_length;
-	cmark_strbuf *linebuf;
-	int options;
+  struct cmark_reference_map *refmap;
+  struct cmark_node *root;
+  struct cmark_node *current;
+  int line_number;
+  bufsize_t offset;
+  bufsize_t column;
+  bufsize_t first_nonspace;
+  bufsize_t first_nonspace_column;
+  int indent;
+  bool blank;
+  cmark_strbuf *curline;
+  bufsize_t last_line_length;
+  cmark_strbuf *linebuf;
+  int options;
 };
 
 #ifdef __cplusplus

data/ext/commonmarker/cmark/src/references.c

@@ -5,150 +5,140 @@
 #include "inlines.h"
 #include "chunk.h"
 
-static unsigned int
-refhash(const unsigned char *link_ref)
-{
-	unsigned int hash = 0;
+static unsigned int refhash(const unsigned char *link_ref) {
+  unsigned int hash = 0;
 
-	while (*link_ref)
-		hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash;
+  while (*link_ref)
+    hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash;
 
-	return hash;
+  return hash;
 }
 
-static void reference_free(cmark_reference *ref)
-{
-	if(ref != NULL) {
-		free(ref->label);
-		cmark_chunk_free(&ref->url);
-		cmark_chunk_free(&ref->title);
-		free(ref);
-	}
+static void reference_free(cmark_reference *ref) {
+  if (ref != NULL) {
+    free(ref->label);
+    cmark_chunk_free(&ref->url);
+    cmark_chunk_free(&ref->title);
+    free(ref);
+  }
 }
 
 // normalize reference:  collapse internal whitespace to single space,
 // remove leading/trailing whitespace, case fold
 // Return NULL if the reference name is actually empty (i.e. composed
 // solely from whitespace)
-static unsigned char *normalize_reference(cmark_chunk *ref)
-{
-	cmark_strbuf normalized = GH_BUF_INIT;
-	unsigned char *result;
+static unsigned char *normalize_reference(cmark_chunk *ref) {
+  cmark_strbuf normalized = GH_BUF_INIT;
+  unsigned char *result;
 
-	if(ref == NULL)
-		return NULL;
+  if (ref == NULL)
+    return NULL;
 
-	if (ref->len == 0)
-		return NULL;
+  if (ref->len == 0)
+    return NULL;
 
-	utf8proc_case_fold(&normalized, ref->data, ref->len);
-	cmark_strbuf_trim(&normalized);
-	cmark_strbuf_normalize_whitespace(&normalized);
+  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
+  cmark_strbuf_trim(&normalized);
+  cmark_strbuf_normalize_whitespace(&normalized);
 
-	result = cmark_strbuf_detach(&normalized);
-	assert(result);
+  result = cmark_strbuf_detach(&normalized);
+  assert(result);
 
-	if (result[0] == '\0') {
-		free(result);
-		return NULL;
-	}
+  if (result[0] == '\0') {
+    free(result);
+    return NULL;
+  }
 
-	return result;
+  return result;
 }
 
-static void add_reference(cmark_reference_map *map, cmark_reference* ref)
-{
-	cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE];
+static void add_reference(cmark_reference_map *map, cmark_reference *ref) {
+  cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE];
 
-	while (t) {
-		if (t->hash == ref->hash &&
-		    !strcmp((char *)t->label, (char *)ref->label)) {
-			reference_free(ref);
-			return;
-		}
+  while (t) {
+    if (t->hash == ref->hash && !strcmp((char *)t->label, (char *)ref->label)) {
+      reference_free(ref);
+      return;
+    }
 
-		t = t->next;
-	}
+    t = t->next;
+  }
 
-	map->table[ref->hash % REFMAP_SIZE] = ref;
+  map->table[ref->hash % REFMAP_SIZE] = ref;
 }
 
-void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url,
-                            cmark_chunk *title)
-{
-	cmark_reference *ref;
-	unsigned char *reflabel = normalize_reference(label);
-
-	/* empty reference name, or composed from only whitespace */
-	if (reflabel == NULL)
-		return;
-
-	ref = (cmark_reference *)calloc(1, sizeof(*ref));
-	if(ref != NULL) {
-		ref->label = reflabel;
-		ref->hash = refhash(ref->label);
-		ref->url = cmark_clean_url(url);
-		ref->title = cmark_clean_title(title);
-		ref->next = NULL;
-
-		add_reference(map, ref);
-	}
+void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title) {
+  cmark_reference *ref;
+  unsigned char *reflabel = normalize_reference(label);
+
+  /* empty reference name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  ref = (cmark_reference *)calloc(1, sizeof(*ref));
+  if (ref != NULL) {
+    ref->label = reflabel;
+    ref->hash = refhash(ref->label);
+    ref->url = cmark_clean_url(url);
+    ref->title = cmark_clean_title(title);
+    ref->next = NULL;
+
+    add_reference(map, ref);
+  }
 }
 
 // Returns reference if refmap contains a reference with matching
 // label, otherwise NULL.
-cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label)
-{
-	cmark_reference *ref = NULL;
-	unsigned char *norm;
-	unsigned int hash;
-
-	if (label->len > MAX_LINK_LABEL_LENGTH)
-		return NULL;
-
-	if (map == NULL)
-		return NULL;
-
-	norm = normalize_reference(label);
-	if (norm == NULL)
-		return NULL;
-
-	hash = refhash(norm);
-	ref = map->table[hash % REFMAP_SIZE];
-
-	while (ref) {
-		if (ref->hash == hash &&
-		    !strcmp((char *)ref->label, (char *)norm))
-			break;
-		ref = ref->next;
-	}
-
-	free(norm);
-	return ref;
+cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
+                                        cmark_chunk *label) {
+  cmark_reference *ref = NULL;
+  unsigned char *norm;
+  unsigned int hash;
+
+  if (label->len > MAX_LINK_LABEL_LENGTH)
+    return NULL;
+
+  if (map == NULL)
+    return NULL;
+
+  norm = normalize_reference(label);
+  if (norm == NULL)
+    return NULL;
+
+  hash = refhash(norm);
+  ref = map->table[hash % REFMAP_SIZE];
+
+  while (ref) {
+    if (ref->hash == hash && !strcmp((char *)ref->label, (char *)norm))
+      break;
+    ref = ref->next;
+  }
+
+  free(norm);
+  return ref;
 }
 
-void cmark_reference_map_free(cmark_reference_map *map)
-{
-	unsigned int i;
+void cmark_reference_map_free(cmark_reference_map *map) {
+  unsigned int i;
 
-	if(map == NULL)
-		return;
+  if (map == NULL)
+    return;
 
-	for (i = 0; i < REFMAP_SIZE; ++i) {
-		cmark_reference *ref = map->table[i];
-		cmark_reference *next;
+  for (i = 0; i < REFMAP_SIZE; ++i) {
+    cmark_reference *ref = map->table[i];
+    cmark_reference *next;
 
-		while (ref) {
-			next = ref->next;
-			reference_free(ref);
-			ref = next;
-		}
-	}
+    while (ref) {
+      next = ref->next;
+      reference_free(ref);
+      ref = next;
+    }
+  }
 
-	free(map);
+  free(map);
 }
 
-cmark_reference_map *cmark_reference_map_new(void)
-{
-	return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map));
+cmark_reference_map *cmark_reference_map_new(void) {
+  return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map));
 }

data/ext/commonmarker/cmark/src/references.h

@@ -10,25 +10,27 @@ extern "C" {
 #define REFMAP_SIZE 16
 
 struct cmark_reference {
-	struct cmark_reference *next;
-	unsigned char *label;
-	cmark_chunk url;
-	cmark_chunk title;
-	unsigned int hash;
+  struct cmark_reference *next;
+  unsigned char *label;
+  cmark_chunk url;
+  cmark_chunk title;
+  unsigned int hash;
 };
 
 typedef struct cmark_reference cmark_reference;
 
 struct cmark_reference_map {
-	cmark_reference *table[REFMAP_SIZE];
+  cmark_reference *table[REFMAP_SIZE];
 };
 
 typedef struct cmark_reference_map cmark_reference_map;
 
 cmark_reference_map *cmark_reference_map_new(void);
 void cmark_reference_map_free(cmark_reference_map *map);
-cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label);
-extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title);
+cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
+                                        cmark_chunk *label);
+extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                                   cmark_chunk *url, cmark_chunk *title);
 
 #ifdef __cplusplus
 }