summaryrefslogtreecommitdiff
path: root/src/blocks.c
diff options
context:
space:
mode:
authorJohn MacFarlane <jgm@berkeley.edu>2015-07-27 21:35:54 -0700
committerJohn MacFarlane <jgm@berkeley.edu>2015-07-27 21:35:54 -0700
commit62cb38bf8a826125fba0034221343aa70dd3d415 (patch)
tree67348fa88068e1fdb2fca04d74c0ce60072bd280 /src/blocks.c
parentaca7161e53ec40f6979d024d84afeb36fa911292 (diff)
Use clang-format, llvm style, for formatting.
* Reformatted all source files. * Added 'format' target to Makefile. * Removed 'astyle' target. * Updated .editorconfig.
Diffstat (limited to 'src/blocks.c')
-rw-r--r--src/blocks.c1856
1 files changed, 909 insertions, 947 deletions
diff --git a/src/blocks.c b/src/blocks.c
index 8828a11..c466fc2 100644
--- a/src/blocks.c
+++ b/src/blocks.c
@@ -19,1036 +19,998 @@
#define peek_at(i, n) (i)->data[n]
-static inline bool
-S_is_line_end_char(char c)
-{
- return (c == '\n' || c == '\r');
+static inline bool S_is_line_end_char(char c) {
+ return (c == '\n' || c == '\r');
}
-static void
-S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len,
- bool eof);
-
-static void
-S_process_line(cmark_parser *parser, const unsigned char *buffer,
- bufsize_t bytes);
-
-static cmark_node* make_block(cmark_node_type tag, int start_line, int start_column)
-{
- cmark_node* e;
-
- e = (cmark_node *)calloc(1, sizeof(*e));
- if(e != NULL) {
- e->type = tag;
- e->open = true;
- e->start_line = start_line;
- e->start_column = start_column;
- e->end_line = start_line;
- cmark_strbuf_init(&e->string_content, 32);
- }
-
- return e;
+static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
+ size_t len, bool eof);
+
+static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
+ bufsize_t bytes);
+
+static cmark_node *make_block(cmark_node_type tag, int start_line,
+ int start_column) {
+ cmark_node *e;
+
+ e = (cmark_node *)calloc(1, sizeof(*e));
+ if (e != NULL) {
+ e->type = tag;
+ e->open = true;
+ e->start_line = start_line;
+ e->start_column = start_column;
+ e->end_line = start_line;
+ cmark_strbuf_init(&e->string_content, 32);
+ }
+
+ return e;
}
// Create a root document node.
-static cmark_node* make_document()
-{
- cmark_node *e = make_block(NODE_DOCUMENT, 1, 1);
- return e;
+static cmark_node *make_document() {
+ cmark_node *e = make_block(NODE_DOCUMENT, 1, 1);
+ return e;
}
-cmark_parser *cmark_parser_new(int options)
-{
- cmark_parser *parser = (cmark_parser*)malloc(sizeof(cmark_parser));
- cmark_node *document = make_document();
- cmark_strbuf *line = (cmark_strbuf*)malloc(sizeof(cmark_strbuf));
- cmark_strbuf *buf = (cmark_strbuf*)malloc(sizeof(cmark_strbuf));
- cmark_strbuf_init(line, 256);
- cmark_strbuf_init(buf, 0);
-
- parser->refmap = cmark_reference_map_new();
- parser->root = document;
- parser->current = document;
- parser->line_number = 0;
- parser->offset = 0;
- parser->column = 0;
- parser->first_nonspace = 0;
- parser->first_nonspace_column = 0;
- parser->indent = 0;
- parser->blank = false;
- parser->curline = line;
- parser->last_line_length = 0;
- parser->linebuf = buf;
- parser->options = options;
-
- return parser;
+cmark_parser *cmark_parser_new(int options) {
+ cmark_parser *parser = (cmark_parser *)malloc(sizeof(cmark_parser));
+ cmark_node *document = make_document();
+ cmark_strbuf *line = (cmark_strbuf *)malloc(sizeof(cmark_strbuf));
+ cmark_strbuf *buf = (cmark_strbuf *)malloc(sizeof(cmark_strbuf));
+ cmark_strbuf_init(line, 256);
+ cmark_strbuf_init(buf, 0);
+
+ parser->refmap = cmark_reference_map_new();
+ parser->root = document;
+ parser->current = document;
+ parser->line_number = 0;
+ parser->offset = 0;
+ parser->column = 0;
+ parser->first_nonspace = 0;
+ parser->first_nonspace_column = 0;
+ parser->indent = 0;
+ parser->blank = false;
+ parser->curline = line;
+ parser->last_line_length = 0;
+ parser->linebuf = buf;
+ parser->options = options;
+
+ return parser;
}
-void cmark_parser_free(cmark_parser *parser)
-{
- cmark_strbuf_free(parser->curline);
- free(parser->curline);
- cmark_strbuf_free(parser->linebuf);
- free(parser->linebuf);
- cmark_reference_map_free(parser->refmap);
- free(parser);
+void cmark_parser_free(cmark_parser *parser) {
+ cmark_strbuf_free(parser->curline);
+ free(parser->curline);
+ cmark_strbuf_free(parser->linebuf);
+ free(parser->linebuf);
+ cmark_reference_map_free(parser->refmap);
+ free(parser);
}
-static cmark_node*
-finalize(cmark_parser *parser, cmark_node* b);
+static cmark_node *finalize(cmark_parser *parser, cmark_node *b);
// Returns true if line has only space characters, else false.
-static bool is_blank(cmark_strbuf *s, bufsize_t offset)
-{
- while (offset < s->size) {
- switch (s->ptr[offset]) {
- case '\r':
- case '\n':
- return true;
- case ' ':
- offset++;
- break;
- case '\t':
- offset++;
- break;
- default:
- return false;
- }
- }
-
- return true;
+static bool is_blank(cmark_strbuf *s, bufsize_t offset) {
+ while (offset < s->size) {
+ switch (s->ptr[offset]) {
+ case '\r':
+ case '\n':
+ return true;
+ case ' ':
+ offset++;
+ break;
+ case '\t':
+ offset++;
+ break;
+ default:
+ return false;
+ }
+ }
+
+ return true;
}
-static inline bool can_contain(cmark_node_type parent_type, cmark_node_type child_type)
-{
- return ( parent_type == NODE_DOCUMENT ||
- parent_type == NODE_BLOCK_QUOTE ||
- parent_type == NODE_ITEM ||
- (parent_type == NODE_LIST && child_type == NODE_ITEM) );
+static inline bool can_contain(cmark_node_type parent_type,
+ cmark_node_type child_type) {
+ return (parent_type == NODE_DOCUMENT || parent_type == NODE_BLOCK_QUOTE ||
+ parent_type == NODE_ITEM ||
+ (parent_type == NODE_LIST && child_type == NODE_ITEM));
}
-static inline bool accepts_lines(cmark_node_type block_type)
-{
- return (block_type == NODE_PARAGRAPH ||
- block_type == NODE_HEADER ||
- block_type == NODE_CODE_BLOCK);
+static inline bool accepts_lines(cmark_node_type block_type) {
+ return (block_type == NODE_PARAGRAPH || block_type == NODE_HEADER ||
+ block_type == NODE_CODE_BLOCK);
}
-static void add_line(cmark_node* node, cmark_chunk *ch, bufsize_t offset)
-{
- assert(node->open);
- cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset);
+static void add_line(cmark_node *node, cmark_chunk *ch, bufsize_t offset) {
+ assert(node->open);
+ cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset);
}
-static void remove_trailing_blank_lines(cmark_strbuf *ln)
-{
- bufsize_t i;
- unsigned char c;
-
- for (i = ln->size - 1; i >= 0; --i) {
- c = ln->ptr[i];
+static void remove_trailing_blank_lines(cmark_strbuf *ln) {
+ bufsize_t i;
+ unsigned char c;
- if (c != ' ' && c != '\t' && !S_is_line_end_char(c))
- break;
- }
+ for (i = ln->size - 1; i >= 0; --i) {
+ c = ln->ptr[i];
- if (i < 0) {
- cmark_strbuf_clear(ln);
- return;
- }
+ if (c != ' ' && c != '\t' && !S_is_line_end_char(c))
+ break;
+ }
+ if (i < 0) {
+ cmark_strbuf_clear(ln);
+ return;
+ }
- for(; i < ln->size; ++i) {
- c = ln->ptr[i];
+ for (; i < ln->size; ++i) {
+ c = ln->ptr[i];
- if (!S_is_line_end_char(c))
- continue;
+ if (!S_is_line_end_char(c))
+ continue;
- cmark_strbuf_truncate(ln, i);
- break;
- }
+ cmark_strbuf_truncate(ln, i);
+ break;
+ }
}
// Check to see if a node ends with a blank line, descending
// if needed into lists and sublists.
-static bool ends_with_blank_line(cmark_node* node)
-{
- cmark_node *cur = node;
- while (cur != NULL) {
- if (cur->last_line_blank) {
- return true;
- }
- if (cur->type == NODE_LIST || cur->type == NODE_ITEM) {
- cur = cur->last_child;
- } else {
- cur = NULL;
- }
- }
- return false;
+static bool ends_with_blank_line(cmark_node *node) {
+ cmark_node *cur = node;
+ while (cur != NULL) {
+ if (cur->last_line_blank) {
+ return true;
+ }
+ if (cur->type == NODE_LIST || cur->type == NODE_ITEM) {
+ cur = cur->last_child;
+ } else {
+ cur = NULL;
+ }
+ }
+ return false;
}
// Break out of all containing lists
-static int break_out_of_lists(cmark_parser *parser, cmark_node ** bptr)
-{
- cmark_node *container = *bptr;
- cmark_node *b = parser->root;
- // find first containing NODE_LIST:
- while (b && b->type != NODE_LIST) {
- b = b->last_child;
- }
- if (b) {
- while (container && container != b) {
- container = finalize(parser, container);
- }
- finalize(parser, b);
- *bptr = b->parent;
- }
- return 0;
+static int break_out_of_lists(cmark_parser *parser, cmark_node **bptr) {
+ cmark_node *container = *bptr;
+ cmark_node *b = parser->root;
+ // find first containing NODE_LIST:
+ while (b && b->type != NODE_LIST) {
+ b = b->last_child;
+ }
+ if (b) {
+ while (container && container != b) {
+ container = finalize(parser, container);
+ }
+ finalize(parser, b);
+ *bptr = b->parent;
+ }
+ return 0;
}
-
-static cmark_node*
-finalize(cmark_parser *parser, cmark_node* b)
-{
- bufsize_t pos;
- cmark_node* item;
- cmark_node* subitem;
- cmark_node* parent;
-
- parent = b->parent;
-
- assert(b->open); // shouldn't call finalize on closed blocks
- b->open = false;
-
- if (parser->curline->size == 0) {
- // end of input - line number has not been incremented
- b->end_line = parser->line_number;
- b->end_column = parser->last_line_length;
- } else if (b->type == NODE_DOCUMENT ||
- (b->type == NODE_CODE_BLOCK && b->as.code.fenced) ||
- (b->type == NODE_HEADER && b->as.header.setext)) {
- b->end_line = parser->line_number;
- b->end_column = parser->curline->size;
- if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n')
- b->end_column -= 1;
- if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r')
- b->end_column -= 1;
- } else {
- b->end_line = parser->line_number - 1;
- b->end_column = parser->last_line_length;
- }
-
- switch (b->type) {
- case NODE_PARAGRAPH:
- while (cmark_strbuf_at(&b->string_content, 0) == '[' &&
- (pos = cmark_parse_reference_inline(&b->string_content, parser->refmap))) {
-
- cmark_strbuf_drop(&b->string_content, pos);
- }
- if (is_blank(&b->string_content, 0)) {
- // remove blank node (former reference def)
- cmark_node_free(b);
- }
- break;
-
- case NODE_CODE_BLOCK:
- if (!b->as.code.fenced) { // indented code
- remove_trailing_blank_lines(&b->string_content);
- cmark_strbuf_putc(&b->string_content, '\n');
- } else {
-
- // first line of contents becomes info
- for (pos = 0; pos < b->string_content.size; ++pos) {
- if (S_is_line_end_char(b->string_content.ptr[pos]))
- break;
- }
- assert(pos < b->string_content.size);
-
- cmark_strbuf tmp = GH_BUF_INIT;
- houdini_unescape_html_f(
- &tmp,
- b->string_content.ptr,
- pos
- );
- cmark_strbuf_trim(&tmp);
- cmark_strbuf_unescape(&tmp);
- b->as.code.info = cmark_chunk_buf_detach(&tmp);
-
- if (b->string_content.ptr[pos] == '\r')
- pos += 1;
- if (b->string_content.ptr[pos] == '\n')
- pos += 1;
- cmark_strbuf_drop(&b->string_content, pos);
- }
- b->as.code.literal = cmark_chunk_buf_detach(&b->string_content);
- break;
-
- case NODE_HTML:
- b->as.literal = cmark_chunk_buf_detach(&b->string_content);
- break;
-
- case NODE_LIST: // determine tight/loose status
- b->as.list.tight = true; // tight by default
- item = b->first_child;
-
- while (item) {
- // check for non-final non-empty list item ending with blank line:
- if (item->last_line_blank && item->next) {
- b->as.list.tight = false;
- break;
- }
- // recurse into children of list item, to see if there are
- // spaces between them:
- subitem = item->first_child;
- while (subitem) {
- if (ends_with_blank_line(subitem) &&
- (item->next || subitem->next)) {
- b->as.list.tight = false;
- break;
- }
- subitem = subitem->next;
- }
- if (!(b->as.list.tight)) {
- break;
- }
- item = item->next;
- }
-
- break;
-
- default:
- break;
- }
- return parent;
+static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
+ bufsize_t pos;
+ cmark_node *item;
+ cmark_node *subitem;
+ cmark_node *parent;
+
+ parent = b->parent;
+
+ assert(b->open); // shouldn't call finalize on closed blocks
+ b->open = false;
+
+ if (parser->curline->size == 0) {
+ // end of input - line number has not been incremented
+ b->end_line = parser->line_number;
+ b->end_column = parser->last_line_length;
+ } else if (b->type == NODE_DOCUMENT ||
+ (b->type == NODE_CODE_BLOCK && b->as.code.fenced) ||
+ (b->type == NODE_HEADER && b->as.header.setext)) {
+ b->end_line = parser->line_number;
+ b->end_column = parser->curline->size;
+ if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\n')
+ b->end_column -= 1;
+ if (b->end_column && parser->curline->ptr[b->end_column - 1] == '\r')
+ b->end_column -= 1;
+ } else {
+ b->end_line = parser->line_number - 1;
+ b->end_column = parser->last_line_length;
+ }
+
+ switch (b->type) {
+ case NODE_PARAGRAPH:
+ while (cmark_strbuf_at(&b->string_content, 0) == '[' &&
+ (pos = cmark_parse_reference_inline(&b->string_content,
+ parser->refmap))) {
+
+ cmark_strbuf_drop(&b->string_content, pos);
+ }
+ if (is_blank(&b->string_content, 0)) {
+ // remove blank node (former reference def)
+ cmark_node_free(b);
+ }
+ break;
+
+ case NODE_CODE_BLOCK:
+ if (!b->as.code.fenced) { // indented code
+ remove_trailing_blank_lines(&b->string_content);
+ cmark_strbuf_putc(&b->string_content, '\n');
+ } else {
+
+ // first line of contents becomes info
+ for (pos = 0; pos < b->string_content.size; ++pos) {
+ if (S_is_line_end_char(b->string_content.ptr[pos]))
+ break;
+ }
+ assert(pos < b->string_content.size);
+
+ cmark_strbuf tmp = GH_BUF_INIT;
+ houdini_unescape_html_f(&tmp, b->string_content.ptr, pos);
+ cmark_strbuf_trim(&tmp);
+ cmark_strbuf_unescape(&tmp);
+ b->as.code.info = cmark_chunk_buf_detach(&tmp);
+
+ if (b->string_content.ptr[pos] == '\r')
+ pos += 1;
+ if (b->string_content.ptr[pos] == '\n')
+ pos += 1;
+ cmark_strbuf_drop(&b->string_content, pos);
+ }
+ b->as.code.literal = cmark_chunk_buf_detach(&b->string_content);
+ break;
+
+ case NODE_HTML:
+ b->as.literal = cmark_chunk_buf_detach(&b->string_content);
+ break;
+
+ case NODE_LIST: // determine tight/loose status
+ b->as.list.tight = true; // tight by default
+ item = b->first_child;
+
+ while (item) {
+ // check for non-final non-empty list item ending with blank line:
+ if (item->last_line_blank && item->next) {
+ b->as.list.tight = false;
+ break;
+ }
+ // recurse into children of list item, to see if there are
+ // spaces between them:
+ subitem = item->first_child;
+ while (subitem) {
+ if (ends_with_blank_line(subitem) && (item->next || subitem->next)) {
+ b->as.list.tight = false;
+ break;
+ }
+ subitem = subitem->next;
+ }
+ if (!(b->as.list.tight)) {
+ break;
+ }
+ item = item->next;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+ return parent;
}
// Add a node as child of another. Return pointer to child.
-static cmark_node* add_child(cmark_parser *parser, cmark_node* parent,
- cmark_node_type block_type, int start_column)
-{
- assert(parent);
-
- // if 'parent' isn't the kind of node that can accept this child,
- // then back up til we hit a node that can.
- while (!can_contain(parent->type, block_type)) {
- parent = finalize(parser, parent);
- }
-
- cmark_node* child = make_block(block_type, parser->line_number, start_column);
- child->parent = parent;
-
- if (parent->last_child) {
- parent->last_child->next = child;
- child->prev = parent->last_child;
- } else {
- parent->first_child = child;
- child->prev = NULL;
- }
- parent->last_child = child;
- return child;
+static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
+ cmark_node_type block_type, int start_column) {
+ assert(parent);
+
+ // if 'parent' isn't the kind of node that can accept this child,
+ // then back up til we hit a node that can.
+ while (!can_contain(parent->type, block_type)) {
+ parent = finalize(parser, parent);
+ }
+
+ cmark_node *child = make_block(block_type, parser->line_number, start_column);
+ child->parent = parent;
+
+ if (parent->last_child) {
+ parent->last_child->next = child;
+ child->prev = parent->last_child;
+ } else {
+ parent->first_child = child;
+ child->prev = NULL;
+ }
+ parent->last_child = child;
+ return child;
}
-
// Walk through node and all children, recursively, parsing
// string content into inline content where appropriate.
-static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int options)
-{
- cmark_iter *iter = cmark_iter_new(root);
- cmark_node *cur;
- cmark_event_type ev_type;
-
- while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
- cur = cmark_iter_get_node(iter);
- if (ev_type == CMARK_EVENT_ENTER) {
- if (cur->type == NODE_PARAGRAPH ||
- cur->type == NODE_HEADER) {
- cmark_parse_inlines(cur, refmap, options);
- }
- }
- }
-
- cmark_iter_free(iter);
+static void process_inlines(cmark_node *root, cmark_reference_map *refmap,
+ int options) {
+ cmark_iter *iter = cmark_iter_new(root);
+ cmark_node *cur;
+ cmark_event_type ev_type;
+
+ while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+ cur = cmark_iter_get_node(iter);
+ if (ev_type == CMARK_EVENT_ENTER) {
+ if (cur->type == NODE_PARAGRAPH || cur->type == NODE_HEADER) {
+ cmark_parse_inlines(cur, refmap, options);
+ }
+ }
+ }
+
+ cmark_iter_free(iter);
}
// Attempts to parse a list item marker (bullet or enumerated).
// On success, returns length of the marker, and populates
// data with the details. On failure, returns 0.
-static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, cmark_list **dataptr)
-{
- unsigned char c;
- bufsize_t startpos;
- cmark_list *data;
-
- startpos = pos;
- c = peek_at(input, pos);
-
- if (c == '*' || c == '-' || c == '+') {
- pos++;
- if (!cmark_isspace(peek_at(input, pos))) {
- return 0;
- }
- data = (cmark_list *)calloc(1, sizeof(*data));
- if(data == NULL) {
- return 0;
- } else {
- data->marker_offset = 0; // will be adjusted later
- data->list_type = CMARK_BULLET_LIST;
- data->bullet_char = c;
- data->start = 1;
- data->delimiter = CMARK_PERIOD_DELIM;
- data->tight = false;
- }
- } else if (cmark_isdigit(c)) {
- int start = 0;
- int digits = 0;
-
- do {
- start = (10 * start) + (peek_at(input, pos) - '0');
- pos++;
- digits++;
- // We limit to 9 digits to avoid overflow,
- // assuming max int is 2^31 - 1
- // This also seems to be the limit for 'start' in some browsers.
- } while (digits < 9 && cmark_isdigit(peek_at(input, pos)));
-
- c = peek_at(input, pos);
- if (c == '.' || c == ')') {
- pos++;
- if (!cmark_isspace(peek_at(input, pos))) {
- return 0;
- }
- data = (cmark_list *)calloc(1, sizeof(*data));
- if(data == NULL) {
- return 0;
- } else {
- data->marker_offset = 0; // will be adjusted later
- data->list_type = CMARK_ORDERED_LIST;
- data->bullet_char = 0;
- data->start = start;
- data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM);
- data->tight = false;
- }
- } else {
- return 0;
- }
-
- } else {
- return 0;
- }
-
- *dataptr = data;
- return (pos - startpos);
+static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos,
+ cmark_list **dataptr) {
+ unsigned char c;
+ bufsize_t startpos;
+ cmark_list *data;
+
+ startpos = pos;
+ c = peek_at(input, pos);
+
+ if (c == '*' || c == '-' || c == '+') {
+ pos++;
+ if (!cmark_isspace(peek_at(input, pos))) {
+ return 0;
+ }
+ data = (cmark_list *)calloc(1, sizeof(*data));
+ if (data == NULL) {
+ return 0;
+ } else {
+ data->marker_offset = 0; // will be adjusted later
+ data->list_type = CMARK_BULLET_LIST;
+ data->bullet_char = c;
+ data->start = 1;
+ data->delimiter = CMARK_PERIOD_DELIM;
+ data->tight = false;
+ }
+ } else if (cmark_isdigit(c)) {
+ int start = 0;
+ int digits = 0;
+
+ do {
+ start = (10 * start) + (peek_at(input, pos) - '0');
+ pos++;
+ digits++;
+ // We limit to 9 digits to avoid overflow,
+ // assuming max int is 2^31 - 1
+ // This also seems to be the limit for 'start' in some browsers.
+ } while (digits < 9 && cmark_isdigit(peek_at(input, pos)));
+
+ c = peek_at(input, pos);
+ if (c == '.' || c == ')') {
+ pos++;
+ if (!cmark_isspace(peek_at(input, pos))) {
+ return 0;
+ }
+ data = (cmark_list *)calloc(1, sizeof(*data));
+ if (data == NULL) {
+ return 0;
+ } else {
+ data->marker_offset = 0; // will be adjusted later
+ data->list_type = CMARK_ORDERED_LIST;
+ data->bullet_char = 0;
+ data->start = start;
+ data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM);
+ data->tight = false;
+ }
+ } else {
+ return 0;
+ }
+
+ } else {
+ return 0;
+ }
+
+ *dataptr = data;
+ return (pos - startpos);
}
// Return 1 if list item belongs in list, else 0.
-static int lists_match(cmark_list *list_data, cmark_list *item_data)
-{
- return (list_data->list_type == item_data->list_type &&
- list_data->delimiter == item_data->delimiter &&
- // list_data->marker_offset == item_data.marker_offset &&
- list_data->bullet_char == item_data->bullet_char);
+static int lists_match(cmark_list *list_data, cmark_list *item_data) {
+ return (list_data->list_type == item_data->list_type &&
+ list_data->delimiter == item_data->delimiter &&
+ // list_data->marker_offset == item_data.marker_offset &&
+ list_data->bullet_char == item_data->bullet_char);
}
-static cmark_node *finalize_document(cmark_parser *parser)
-{
- while (parser->current != parser->root) {
- parser->current = finalize(parser, parser->current);
- }
+static cmark_node *finalize_document(cmark_parser *parser) {
+ while (parser->current != parser->root) {
+ parser->current = finalize(parser, parser->current);
+ }
- finalize(parser, parser->root);
- process_inlines(parser->root, parser->refmap, parser->options);
+ finalize(parser, parser->root);
+ process_inlines(parser->root, parser->refmap, parser->options);
- return parser->root;
+ return parser->root;
}
-cmark_node *cmark_parse_file(FILE *f, int options)
-{
- unsigned char buffer[4096];
- cmark_parser *parser = cmark_parser_new(options);
- size_t bytes;
- cmark_node *document;
-
- while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) {
- bool eof = bytes < sizeof(buffer);
- S_parser_feed(parser, buffer, bytes, eof);
- if (eof) {
- break;
- }
- }
-
- document = cmark_parser_finish(parser);
- cmark_parser_free(parser);
- return document;
+cmark_node *cmark_parse_file(FILE *f, int options) {
+ unsigned char buffer[4096];
+ cmark_parser *parser = cmark_parser_new(options);
+ size_t bytes;
+ cmark_node *document;
+
+ while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) {
+ bool eof = bytes < sizeof(buffer);
+ S_parser_feed(parser, buffer, bytes, eof);
+ if (eof) {
+ break;
+ }
+ }
+
+ document = cmark_parser_finish(parser);
+ cmark_parser_free(parser);
+ return document;
}
-cmark_node *cmark_parse_document(const char *buffer, size_t len, int options)
-{
- cmark_parser *parser = cmark_parser_new(options);
- cmark_node *document;
+cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) {
+ cmark_parser *parser = cmark_parser_new(options);
+ cmark_node *document;
- S_parser_feed(parser, (const unsigned char *)buffer, len, true);
+ S_parser_feed(parser, (const unsigned char *)buffer, len, true);
- document = cmark_parser_finish(parser);
- cmark_parser_free(parser);
- return document;
+ document = cmark_parser_finish(parser);
+ cmark_parser_free(parser);
+ return document;
}
-void
-cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len)
-{
- S_parser_feed(parser, (const unsigned char *)buffer, len, false);
+void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) {
+ S_parser_feed(parser, (const unsigned char *)buffer, len, false);
}
-static void
-S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len,
- bool eof)
-{
- const unsigned char *end = buffer + len;
- static const uint8_t repl[] = {239, 191, 189};
-
- while (buffer < end) {
- const unsigned char *eol;
- bufsize_t chunk_len;
- bool process = false;
- for (eol = buffer; eol < end; ++eol) {
- if (S_is_line_end_char(*eol)) {
- if (eol < end && *eol == '\r')
- eol++;
- if (eol < end && *eol == '\n')
- eol++;
- process = true;
- break;
- }
- if (*eol == '\0' && eol < end) {
- break;
- }
- }
- if (eol >= end && eof) {
- process = true;
- }
-
- chunk_len = cmark_strbuf_check_bufsize(eol - buffer);
- if (process) {
- if (parser->linebuf->size > 0) {
- cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
- S_process_line(parser, parser->linebuf->ptr,
- parser->linebuf->size);
- cmark_strbuf_clear(parser->linebuf);
- } else {
- S_process_line(parser, buffer, chunk_len);
- }
- } else {
- if (eol < end && *eol == '\0') {
- // omit NULL byte
- cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
- // add replacement character
- cmark_strbuf_put(parser->linebuf, repl, 3);
- chunk_len += 1; // so we advance the buffer past NULL
- } else {
- cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
- }
- }
-
- buffer += chunk_len;
- }
+static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
+ size_t len, bool eof) {
+ const unsigned char *end = buffer + len;
+ static const uint8_t repl[] = {239, 191, 189};
+
+ while (buffer < end) {
+ const unsigned char *eol;
+ bufsize_t chunk_len;
+ bool process = false;
+ for (eol = buffer; eol < end; ++eol) {
+ if (S_is_line_end_char(*eol)) {
+ if (eol < end && *eol == '\r')
+ eol++;
+ if (eol < end && *eol == '\n')
+ eol++;
+ process = true;
+ break;
+ }
+ if (*eol == '\0' && eol < end) {
+ break;
+ }
+ }
+ if (eol >= end && eof) {
+ process = true;
+ }
+
+ chunk_len = cmark_strbuf_check_bufsize(eol - buffer);
+ if (process) {
+ if (parser->linebuf->size > 0) {
+ cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
+ S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size);
+ cmark_strbuf_clear(parser->linebuf);
+ } else {
+ S_process_line(parser, buffer, chunk_len);
+ }
+ } else {
+ if (eol < end && *eol == '\0') {
+ // omit NULL byte
+ cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
+ // add replacement character
+ cmark_strbuf_put(parser->linebuf, repl, 3);
+ chunk_len += 1; // so we advance the buffer past NULL
+ } else {
+ cmark_strbuf_put(parser->linebuf, buffer, chunk_len);
+ }
+ }
+
+ buffer += chunk_len;
+ }
}
-static void chop_trailing_hashtags(cmark_chunk *ch)
-{
- bufsize_t n, orig_n;
+static void chop_trailing_hashtags(cmark_chunk *ch) {
+ bufsize_t n, orig_n;
- cmark_chunk_rtrim(ch);
- orig_n = n = ch->len - 1;
+ cmark_chunk_rtrim(ch);
+ orig_n = n = ch->len - 1;
- // if string ends in space followed by #s, remove these:
- while (n >= 0 && peek_at(ch, n) == '#')
- n--;
+ // if string ends in space followed by #s, remove these:
+ while (n >= 0 && peek_at(ch, n) == '#')
+ n--;
- // Check for a space before the final #s:
- if (n != orig_n && n >= 0 &&
- (peek_at(ch, n) == ' ' || peek_at(ch, n) == '\t')) {
- ch->len = n;
- cmark_chunk_rtrim(ch);
- }
+ // Check for a space before the final #s:
+ if (n != orig_n && n >= 0 &&
+ (peek_at(ch, n) == ' ' || peek_at(ch, n) == '\t')) {
+ ch->len = n;
+ cmark_chunk_rtrim(ch);
+ }
}
-static void
-S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input)
-{
- char c;
- int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
-
- parser->first_nonspace = parser->offset;
- parser->first_nonspace_column = parser->column;
- while ((c = peek_at(input, parser->first_nonspace))) {
- if (c == ' ') {
- parser->first_nonspace += 1;
- parser->first_nonspace_column += 1;
- chars_to_tab = chars_to_tab - 1;
- if (chars_to_tab == 0) {
- chars_to_tab = TAB_STOP;
- }
- } else if (c == '\t') {
- parser->first_nonspace += 1;
- parser->first_nonspace_column += chars_to_tab;
- chars_to_tab = TAB_STOP;
- } else {
- break;
- }
- }
-
- parser->indent = parser->first_nonspace_column - parser->column;
- parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace));
+static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) {
+ char c;
+ int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);
+
+ parser->first_nonspace = parser->offset;
+ parser->first_nonspace_column = parser->column;
+ while ((c = peek_at(input, parser->first_nonspace))) {
+ if (c == ' ') {
+ parser->first_nonspace += 1;
+ parser->first_nonspace_column += 1;
+ chars_to_tab = chars_to_tab - 1;
+ if (chars_to_tab == 0) {
+ chars_to_tab = TAB_STOP;
+ }
+ } else if (c == '\t') {
+ parser->first_nonspace += 1;
+ parser->first_nonspace_column += chars_to_tab;
+ chars_to_tab = TAB_STOP;
+ } else {
+ break;
+ }
+ }
+
+ parser->indent = parser->first_nonspace_column - parser->column;
+ parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace));
}
-static void
-S_advance_offset(cmark_parser *parser, cmark_chunk *input, bufsize_t count, bool columns)
-{
- char c;
- int chars_to_tab;
- while (count > 0 && (c = peek_at(input, parser->offset))) {
- if (c == '\t') {
- chars_to_tab = 4 - (parser->column % TAB_STOP);
- parser->column += chars_to_tab;
- parser->offset += 1;
- count -= (columns ? chars_to_tab : 1);
- } else {
- parser->offset += 1;
- parser->column += 1; // assume ascii; block starts are ascii
- count -= 1;
- }
- }
+static void S_advance_offset(cmark_parser *parser, cmark_chunk *input,
+ bufsize_t count, bool columns) {
+ char c;
+ int chars_to_tab;
+ while (count > 0 && (c = peek_at(input, parser->offset))) {
+ if (c == '\t') {
+ chars_to_tab = 4 - (parser->column % TAB_STOP);
+ parser->column += chars_to_tab;
+ parser->offset += 1;
+ count -= (columns ? chars_to_tab : 1);
+ } else {
+ parser->offset += 1;
+ parser->column += 1; // assume ascii; block starts are ascii
+ count -= 1;
+ }
+ }
}
-
-static void
-S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t bytes)
-{
- cmark_node* last_matched_container;
- bufsize_t matched = 0;
- int lev = 0;
- int i;
- cmark_list *data = NULL;
- bool all_matched = true;
- cmark_node* container;
- bool indented;
- cmark_chunk input;
- bool maybe_lazy;
-
- if (parser->options & CMARK_OPT_VALIDATE_UTF8) {
- utf8proc_check(parser->curline, buffer, bytes);
- } else {
- cmark_strbuf_put(parser->curline, buffer, bytes);
- }
- parser->offset = 0;
- parser->column = 0;
- parser->blank = false;
-
- input.data = parser->curline->ptr;
- input.len = parser->curline->size;
-
- // container starts at the document root.
- container = parser->root;
-
- parser->line_number++;
-
- // for each containing node, try to parse the associated line start.
- // bail out on failure: container will point to the last matching node.
-
- while (container->last_child && container->last_child->open) {
- container = container->last_child;
-
- S_find_first_nonspace(parser, &input);
-
- if (container->type == NODE_BLOCK_QUOTE) {
- matched = parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>';
- if (matched) {
- S_advance_offset(parser, &input, parser->indent + 1, true);
- if (peek_at(&input, parser->offset) == ' ')
- parser->offset++;
- } else {
- all_matched = false;
- }
-
- } else if (container->type == NODE_ITEM) {
- if (parser->indent >= container->as.list.marker_offset +
- container->as.list.padding) {
- S_advance_offset(parser, &input,
- container->as.list.marker_offset +
- container->as.list.padding, true);
- } else if (parser->blank) {
- S_advance_offset(parser, &input,
- parser->first_nonspace - parser->offset, false);
- } else {
- all_matched = false;
- }
-
- } else if (container->type == NODE_CODE_BLOCK) {
-
- if (!container->as.code.fenced) { // indented
- if (parser->indent >= CODE_INDENT) {
- S_advance_offset(parser, &input, CODE_INDENT, true);
- } else if (parser->blank) {
- S_advance_offset(parser, &input,
- parser->first_nonspace - parser->offset,
- false);
- } else {
- all_matched = false;
- }
- } else { // fenced
- matched = 0;
- if (parser->indent <= 3 &&
- (peek_at(&input, parser->first_nonspace) ==
- container->as.code.fence_char)) {
- matched = scan_close_code_fence(&input,
- parser->first_nonspace);
- }
- if (matched >= container->as.code.fence_length) {
- // closing fence - and since we're at
- // the end of a line, we can return:
- all_matched = false;
- S_advance_offset(parser, &input, matched, false);
- parser->current = finalize(parser, container);
- goto finished;
- } else {
- // skip opt. spaces of fence parser->offset
- i = container->as.code.fence_offset;
- while (i > 0 &&
- peek_at(&input, parser->offset) == ' ') {
- S_advance_offset(parser, &input, 1, false);
- i--;
- }
- }
- }
- } else if (container->type == NODE_HEADER) {
-
- // a header can never contain more than one line
- all_matched = false;
-
- } else if (container->type == NODE_HTML) {
-
- switch (container->as.html_block_type) {
- case 1:
- case 2:
- case 3:
- case 4:
- case 5:
- // these types of blocks can accept blanks
- break;
- case 6:
- case 7:
- if (parser->blank) {
- all_matched = false;
- }
- break;
- default:
- fprintf(stderr,
- "Error (%s:%d): Unknown HTML block type %d\n",
- __FILE__, __LINE__,
- container->as.html_block_type);
- exit(1);
- }
-
- } else if (container->type == NODE_PARAGRAPH) {
-
- if (parser->blank) {
- all_matched = false;
- }
-
- }
-
- if (!all_matched) {
- container = container->parent; // back up to last matching node
- break;
- }
- }
-
- last_matched_container = container;
-
- // check to see if we've hit 2nd blank line, break out of list:
- if (parser->blank && container->last_line_blank) {
- break_out_of_lists(parser, &container);
- }
-
- maybe_lazy = parser->current->type == NODE_PARAGRAPH;
- // try new container starts:
- while (container->type != NODE_CODE_BLOCK &&
- container->type != NODE_HTML) {
-
- S_find_first_nonspace(parser, &input);
- indented = parser->indent >= CODE_INDENT;
-
- if (!indented && peek_at(&input, parser->first_nonspace) == '>') {
-
- S_advance_offset(parser, &input, parser->first_nonspace + 1 - parser->offset, false);
- // optional following character
- if (peek_at(&input, parser->offset) == ' ')
- S_advance_offset(parser, &input, 1, false);
- container = add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1);
-
- } else if (!indented && (matched = scan_atx_header_start(&input, parser->first_nonspace))) {
-
- S_advance_offset(parser, &input,
- parser->first_nonspace + matched - parser->offset, false);
- container = add_child(parser, container, NODE_HEADER, parser->offset + 1);
-
- bufsize_t hashpos = cmark_chunk_strchr(&input, '#', parser->first_nonspace);
- int level = 0;
-
- while (peek_at(&input, hashpos) == '#') {
- level++;
- hashpos++;
- }
- container->as.header.level = level;
- container->as.header.setext = false;
-
- } else if (!indented && (matched = scan_open_code_fence(&input, parser->first_nonspace))) {
-
- container = add_child(parser, container, NODE_CODE_BLOCK, parser->first_nonspace + 1);
- container->as.code.fenced = true;
- container->as.code.fence_char = peek_at(&input, parser->first_nonspace);
- container->as.code.fence_length = matched;
- container->as.code.fence_offset = parser->first_nonspace - parser->offset;
- container->as.code.info = cmark_chunk_literal("");
- S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false);
-
- } else if (!indented &&
- ((matched = scan_html_block_start(&input, parser->first_nonspace)) ||
- (container->type != NODE_PARAGRAPH &&
- (matched = scan_html_block_start_7(&input, parser->first_nonspace))))) {
-
- container = add_child(parser, container, NODE_HTML, parser->first_nonspace + 1);
- container->as.html_block_type = matched;
- // note, we don't adjust parser->offset because the tag is part of the text
-
- } else if (!indented &&
- container->type == NODE_PARAGRAPH &&
- (lev = scan_setext_header_line(&input, parser->first_nonspace)) &&
- // check that there is only one line in the paragraph:
- (cmark_strbuf_strrchr(&container->string_content, '\n',
- cmark_strbuf_len(&container->string_content) - 2) < 0)) {
-
- container->type = NODE_HEADER;
- container->as.header.level = lev;
- container->as.header.setext = true;
- S_advance_offset(parser, &input, input.len - 1 - parser->offset, false);
-
- } else if (!indented &&
- !(container->type == NODE_PARAGRAPH &&
- !all_matched) &&
- (matched = scan_hrule(&input, parser->first_nonspace))) {
-
- // it's only now that we know the line is not part of a setext header:
- container = add_child(parser, container, NODE_HRULE, parser->first_nonspace + 1);
- container = finalize(parser, container);
- S_advance_offset(parser, &input, input.len - 1 - parser->offset, false);
-
- } else if ((matched = parse_list_marker(&input, parser->first_nonspace, &data)) &&
- (!indented || container->type == NODE_LIST)) {
- // Note that we can have new list items starting with >= 4
- // spaces indent, as long as the list container is still open.
-
- // compute padding:
- S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false);
- i = 0;
- while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') {
- i++;
- }
- // i = number of spaces after marker, up to 5
- if (i >= 5 || i < 1 ||
- S_is_line_end_char(peek_at(&input, parser->offset))) {
- data->padding = matched + 1;
- if (i > 0) {
- S_advance_offset(parser, &input, 1, false);
- }
- } else {
- data->padding = matched + i;
- S_advance_offset(parser, &input, i, true);
- }
-
- // check container; if it's a list, see if this list item
- // can continue the list; otherwise, create a list container.
-
- data->marker_offset = parser->indent;
-
- if (container->type != NODE_LIST ||
- !lists_match(&container->as.list, data)) {
- container = add_child(parser, container, NODE_LIST,
- parser->first_nonspace + 1);
-
- memcpy(&container->as.list, data, sizeof(*data));
- }
-
- // add the list item
- container = add_child(parser, container, NODE_ITEM,
- parser->first_nonspace + 1);
- /* TODO: static */
- memcpy(&container->as.list, data, sizeof(*data));
- free(data);
-
- } else if (indented && !maybe_lazy && !parser->blank) {
- S_advance_offset(parser, &input, CODE_INDENT, true);
- container = add_child(parser, container, NODE_CODE_BLOCK, parser->offset + 1);
- container->as.code.fenced = false;
- container->as.code.fence_char = 0;
- container->as.code.fence_length = 0;
- container->as.code.fence_offset = 0;
- container->as.code.info = cmark_chunk_literal("");
-
- } else {
- break;
- }
-
- if (accepts_lines(container->type)) {
- // if it's a line container, it can't contain other containers
- break;
- }
- maybe_lazy = false;
- }
-
- // what remains at parser->offset is a text line. add the text to the
- // appropriate container.
-
- S_find_first_nonspace(parser, &input);
-
- if (parser->blank && container->last_child) {
- container->last_child->last_line_blank = true;
- }
-
- // block quote lines are never blank as they start with >
- // and we don't count blanks in fenced code for purposes of tight/loose
- // lists or breaking out of lists. we also don't set last_line_blank
- // on an empty list item.
- container->last_line_blank = (parser->blank &&
- container->type != NODE_BLOCK_QUOTE &&
- container->type != NODE_HEADER &&
- !(container->type == NODE_CODE_BLOCK &&
- container->as.code.fenced) &&
- !(container->type == NODE_ITEM &&
- container->first_child == NULL &&
- container->start_line == parser->line_number));
-
- cmark_node *cont = container;
- while (cont->parent) {
- cont->parent->last_line_blank = false;
- cont = cont->parent;
- }
-
- if (parser->current != last_matched_container &&
- container == last_matched_container &&
- !parser->blank &&
- parser->current->type == NODE_PARAGRAPH &&
- cmark_strbuf_len(&parser->current->string_content) > 0) {
-
- add_line(parser->current, &input, parser->offset);
-
- } else { // not a lazy continuation
-
- // finalize any blocks that were not matched and set cur to container:
- while (parser->current != last_matched_container) {
- parser->current = finalize(parser, parser->current);
- assert(parser->current != NULL);
- }
-
- if (container->type == NODE_CODE_BLOCK) {
-
- add_line(container, &input, parser->offset);
-
- } else if (container->type == NODE_HTML) {
-
- add_line(container, &input, parser->offset);
-
- int matches_end_condition;
- switch (container->as.html_block_type) {
- case 1:
- // </script>, </style>, </pre>
- matches_end_condition =
- scan_html_block_end_1(&input, parser->first_nonspace);
- break;
- case 2:
- // -->
- matches_end_condition =
- scan_html_block_end_2(&input, parser->first_nonspace);
- break;
- case 3:
- // ?>
- matches_end_condition =
- scan_html_block_end_3(&input, parser->first_nonspace);
- break;
- case 4:
- // >
- matches_end_condition =
- scan_html_block_end_4(&input, parser->first_nonspace);
- break;
- case 5:
- // ]]>
- matches_end_condition =
- scan_html_block_end_5(&input, parser->first_nonspace);
- break;
- default:
- matches_end_condition = 0;
- break;
- }
-
- if (matches_end_condition) {
- container = finalize(parser, container);
- assert(parser->current != NULL);
- }
-
- } else if (parser->blank) {
-
- // ??? do nothing
-
- } else if (accepts_lines(container->type)) {
-
- if (container->type == NODE_HEADER &&
- container->as.header.setext == false) {
- chop_trailing_hashtags(&input);
- }
- add_line(container, &input, parser->first_nonspace);
-
- } else {
- // create paragraph container for line
- container = add_child(parser, container, NODE_PARAGRAPH, parser->first_nonspace + 1);
- add_line(container, &input, parser->first_nonspace);
-
- }
-
- parser->current = container;
- }
+static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
+ bufsize_t bytes) {
+ cmark_node *last_matched_container;
+ bufsize_t matched = 0;
+ int lev = 0;
+ int i;
+ cmark_list *data = NULL;
+ bool all_matched = true;
+ cmark_node *container;
+ bool indented;
+ cmark_chunk input;
+ bool maybe_lazy;
+
+ if (parser->options & CMARK_OPT_VALIDATE_UTF8) {
+ utf8proc_check(parser->curline, buffer, bytes);
+ } else {
+ cmark_strbuf_put(parser->curline, buffer, bytes);
+ }
+ parser->offset = 0;
+ parser->column = 0;
+ parser->blank = false;
+
+ input.data = parser->curline->ptr;
+ input.len = parser->curline->size;
+
+ // container starts at the document root.
+ container = parser->root;
+
+ parser->line_number++;
+
+ // for each containing node, try to parse the associated line start.
+ // bail out on failure: container will point to the last matching node.
+
+ while (container->last_child && container->last_child->open) {
+ container = container->last_child;
+
+ S_find_first_nonspace(parser, &input);
+
+ if (container->type == NODE_BLOCK_QUOTE) {
+ matched =
+ parser->indent <= 3 && peek_at(&input, parser->first_nonspace) == '>';
+ if (matched) {
+ S_advance_offset(parser, &input, parser->indent + 1, true);
+ if (peek_at(&input, parser->offset) == ' ')
+ parser->offset++;
+ } else {
+ all_matched = false;
+ }
+
+ } else if (container->type == NODE_ITEM) {
+ if (parser->indent >=
+ container->as.list.marker_offset + container->as.list.padding) {
+ S_advance_offset(parser, &input, container->as.list.marker_offset +
+ container->as.list.padding,
+ true);
+ } else if (parser->blank) {
+ S_advance_offset(parser, &input,
+ parser->first_nonspace - parser->offset, false);
+ } else {
+ all_matched = false;
+ }
+
+ } else if (container->type == NODE_CODE_BLOCK) {
+
+ if (!container->as.code.fenced) { // indented
+ if (parser->indent >= CODE_INDENT) {
+ S_advance_offset(parser, &input, CODE_INDENT, true);
+ } else if (parser->blank) {
+ S_advance_offset(parser, &input,
+ parser->first_nonspace - parser->offset, false);
+ } else {
+ all_matched = false;
+ }
+ } else { // fenced
+ matched = 0;
+ if (parser->indent <= 3 && (peek_at(&input, parser->first_nonspace) ==
+ container->as.code.fence_char)) {
+ matched = scan_close_code_fence(&input, parser->first_nonspace);
+ }
+ if (matched >= container->as.code.fence_length) {
+ // closing fence - and since we're at
+ // the end of a line, we can return:
+ all_matched = false;
+ S_advance_offset(parser, &input, matched, false);
+ parser->current = finalize(parser, container);
+ goto finished;
+ } else {
+ // skip opt. spaces of fence parser->offset
+ i = container->as.code.fence_offset;
+ while (i > 0 && peek_at(&input, parser->offset) == ' ') {
+ S_advance_offset(parser, &input, 1, false);
+ i--;
+ }
+ }
+ }
+ } else if (container->type == NODE_HEADER) {
+
+ // a header can never contain more than one line
+ all_matched = false;
+
+ } else if (container->type == NODE_HTML) {
+
+ switch (container->as.html_block_type) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ // these types of blocks can accept blanks
+ break;
+ case 6:
+ case 7:
+ if (parser->blank) {
+ all_matched = false;
+ }
+ break;
+ default:
+ fprintf(stderr, "Error (%s:%d): Unknown HTML block type %d\n", __FILE__,
+ __LINE__, container->as.html_block_type);
+ exit(1);
+ }
+
+ } else if (container->type == NODE_PARAGRAPH) {
+
+ if (parser->blank) {
+ all_matched = false;
+ }
+ }
+
+ if (!all_matched) {
+ container = container->parent; // back up to last matching node
+ break;
+ }
+ }
+
+ last_matched_container = container;
+
+ // check to see if we've hit 2nd blank line, break out of list:
+ if (parser->blank && container->last_line_blank) {
+ break_out_of_lists(parser, &container);
+ }
+
+ maybe_lazy = parser->current->type == NODE_PARAGRAPH;
+ // try new container starts:
+ while (container->type != NODE_CODE_BLOCK && container->type != NODE_HTML) {
+
+ S_find_first_nonspace(parser, &input);
+ indented = parser->indent >= CODE_INDENT;
+
+ if (!indented && peek_at(&input, parser->first_nonspace) == '>') {
+
+ S_advance_offset(parser, &input,
+ parser->first_nonspace + 1 - parser->offset, false);
+ // optional following character
+ if (peek_at(&input, parser->offset) == ' ')
+ S_advance_offset(parser, &input, 1, false);
+ container =
+ add_child(parser, container, NODE_BLOCK_QUOTE, parser->offset + 1);
+
+ } else if (!indented && (matched = scan_atx_header_start(
+ &input, parser->first_nonspace))) {
+
+ S_advance_offset(parser, &input,
+ parser->first_nonspace + matched - parser->offset,
+ false);
+ container = add_child(parser, container, NODE_HEADER, parser->offset + 1);
+
+ bufsize_t hashpos =
+ cmark_chunk_strchr(&input, '#', parser->first_nonspace);
+ int level = 0;
+
+ while (peek_at(&input, hashpos) == '#') {
+ level++;
+ hashpos++;
+ }
+ container->as.header.level = level;
+ container->as.header.setext = false;
+
+ } else if (!indented && (matched = scan_open_code_fence(
+ &input, parser->first_nonspace))) {
+
+ container = add_child(parser, container, NODE_CODE_BLOCK,
+ parser->first_nonspace + 1);
+ container->as.code.fenced = true;
+ container->as.code.fence_char = peek_at(&input, parser->first_nonspace);
+ container->as.code.fence_length = matched;
+ container->as.code.fence_offset = parser->first_nonspace - parser->offset;
+ container->as.code.info = cmark_chunk_literal("");
+ S_advance_offset(parser, &input,
+ parser->first_nonspace + matched - parser->offset,
+ false);
+
+ } else if (!indented && ((matched = scan_html_block_start(
+ &input, parser->first_nonspace)) ||
+ (container->type != NODE_PARAGRAPH &&
+ (matched = scan_html_block_start_7(
+ &input, parser->first_nonspace))))) {
+
+ container =
+ add_child(parser, container, NODE_HTML, parser->first_nonspace + 1);
+ container->as.html_block_type = matched;
+ // note, we don't adjust parser->offset because the tag is part of the
+ // text
+
+ } else if (!indented && container->type == NODE_PARAGRAPH &&
+ (lev =
+ scan_setext_header_line(&input, parser->first_nonspace)) &&
+ // check that there is only one line in the paragraph:
+ (cmark_strbuf_strrchr(
+ &container->string_content, '\n',
+ cmark_strbuf_len(&container->string_content) - 2) < 0)) {
+
+ container->type = NODE_HEADER;
+ container->as.header.level = lev;
+ container->as.header.setext = true;
+ S_advance_offset(parser, &input, input.len - 1 - parser->offset, false);
+
+ } else if (!indented &&
+ !(container->type == NODE_PARAGRAPH && !all_matched) &&
+ (matched = scan_hrule(&input, parser->first_nonspace))) {
+
+ // it's only now that we know the line is not part of a setext header:
+ container =
+ add_child(parser, container, NODE_HRULE, parser->first_nonspace + 1);
+ container = finalize(parser, container);
+ S_advance_offset(parser, &input, input.len - 1 - parser->offset, false);
+
+ } else if ((matched =
+ parse_list_marker(&input, parser->first_nonspace, &data)) &&
+ (!indented || container->type == NODE_LIST)) {
+ // Note that we can have new list items starting with >= 4
+ // spaces indent, as long as the list container is still open.
+
+ // compute padding:
+ S_advance_offset(parser, &input,
+ parser->first_nonspace + matched - parser->offset,
+ false);
+ i = 0;
+ while (i <= 5 && peek_at(&input, parser->offset + i) == ' ') {
+ i++;
+ }
+ // i = number of spaces after marker, up to 5
+ if (i >= 5 || i < 1 ||
+ S_is_line_end_char(peek_at(&input, parser->offset))) {
+ data->padding = matched + 1;
+ if (i > 0) {
+ S_advance_offset(parser, &input, 1, false);
+ }
+ } else {
+ data->padding = matched + i;
+ S_advance_offset(parser, &input, i, true);
+ }
+
+ // check container; if it's a list, see if this list item
+ // can continue the list; otherwise, create a list container.
+
+ data->marker_offset = parser->indent;
+
+ if (container->type != NODE_LIST ||
+ !lists_match(&container->as.list, data)) {
+ container =
+ add_child(parser, container, NODE_LIST, parser->first_nonspace + 1);
+
+ memcpy(&container->as.list, data, sizeof(*data));
+ }
+
+ // add the list item
+ container =
+ add_child(parser, container, NODE_ITEM, parser->first_nonspace + 1);
+ /* TODO: static */
+ memcpy(&container->as.list, data, sizeof(*data));
+ free(data);
+
+ } else if (indented && !maybe_lazy && !parser->blank) {
+ S_advance_offset(parser, &input, CODE_INDENT, true);
+ container =
+ add_child(parser, container, NODE_CODE_BLOCK, parser->offset + 1);
+ container->as.code.fenced = false;
+ container->as.code.fence_char = 0;
+ container->as.code.fence_length = 0;
+ container->as.code.fence_offset = 0;
+ container->as.code.info = cmark_chunk_literal("");
+
+ } else {
+ break;
+ }
+
+ if (accepts_lines(container->type)) {
+ // if it's a line container, it can't contain other containers
+ break;
+ }
+ maybe_lazy = false;
+ }
+
+ // what remains at parser->offset is a text line. add the text to the
+ // appropriate container.
+
+ S_find_first_nonspace(parser, &input);
+
+ if (parser->blank && container->last_child) {
+ container->last_child->last_line_blank = true;
+ }
+
+ // block quote lines are never blank as they start with >
+ // and we don't count blanks in fenced code for purposes of tight/loose
+ // lists or breaking out of lists. we also don't set last_line_blank
+ // on an empty list item.
+ container->last_line_blank =
+ (parser->blank && container->type != NODE_BLOCK_QUOTE &&
+ container->type != NODE_HEADER &&
+ !(container->type == NODE_CODE_BLOCK && container->as.code.fenced) &&
+ !(container->type == NODE_ITEM && container->first_child == NULL &&
+ container->start_line == parser->line_number));
+
+ cmark_node *cont = container;
+ while (cont->parent) {
+ cont->parent->last_line_blank = false;
+ cont = cont->parent;
+ }
+
+ if (parser->current != last_matched_container &&
+ container == last_matched_container && !parser->blank &&
+ parser->current->type == NODE_PARAGRAPH &&
+ cmark_strbuf_len(&parser->current->string_content) > 0) {
+
+ add_line(parser->current, &input, parser->offset);
+
+ } else { // not a lazy continuation
+
+ // finalize any blocks that were not matched and set cur to container:
+ while (parser->current != last_matched_container) {
+ parser->current = finalize(parser, parser->current);
+ assert(parser->current != NULL);
+ }
+
+ if (container->type == NODE_CODE_BLOCK) {
+
+ add_line(container, &input, parser->offset);
+
+ } else if (container->type == NODE_HTML) {
+
+ add_line(container, &input, parser->offset);
+
+ int matches_end_condition;
+ switch (container->as.html_block_type) {
+ case 1:
+ // </script>, </style>, </pre>
+ matches_end_condition =
+ scan_html_block_end_1(&input, parser->first_nonspace);
+ break;
+ case 2:
+ // -->
+ matches_end_condition =
+ scan_html_block_end_2(&input, parser->first_nonspace);
+ break;
+ case 3:
+ // ?>
+ matches_end_condition =
+ scan_html_block_end_3(&input, parser->first_nonspace);
+ break;
+ case 4:
+ // >
+ matches_end_condition =
+ scan_html_block_end_4(&input, parser->first_nonspace);
+ break;
+ case 5:
+ // ]]>
+ matches_end_condition =
+ scan_html_block_end_5(&input, parser->first_nonspace);
+ break;
+ default:
+ matches_end_condition = 0;
+ break;
+ }
+
+ if (matches_end_condition) {
+ container = finalize(parser, container);
+ assert(parser->current != NULL);
+ }
+
+ } else if (parser->blank) {
+
+ // ??? do nothing
+
+ } else if (accepts_lines(container->type)) {
+
+ if (container->type == NODE_HEADER &&
+ container->as.header.setext == false) {
+ chop_trailing_hashtags(&input);
+ }
+ add_line(container, &input, parser->first_nonspace);
+
+ } else {
+ // create paragraph container for line
+ container = add_child(parser, container, NODE_PARAGRAPH,
+ parser->first_nonspace + 1);
+ add_line(container, &input, parser->first_nonspace);
+ }
+
+ parser->current = container;
+ }
finished:
- parser->last_line_length = parser->curline->size;
- if (parser->last_line_length &&
- parser->curline->ptr[parser->last_line_length - 1] == '\n')
- parser->last_line_length -= 1;
- if (parser->last_line_length &&
- parser->curline->ptr[parser->last_line_length - 1] == '\r')
- parser->last_line_length -= 1;
-
- cmark_strbuf_clear(parser->curline);
-
+ parser->last_line_length = parser->curline->size;
+ if (parser->last_line_length &&
+ parser->curline->ptr[parser->last_line_length - 1] == '\n')
+ parser->last_line_length -= 1;
+ if (parser->last_line_length &&
+ parser->curline->ptr[parser->last_line_length - 1] == '\r')
+ parser->last_line_length -= 1;
+
+ cmark_strbuf_clear(parser->curline);
}
-cmark_node *cmark_parser_finish(cmark_parser *parser)
-{
- if (parser->linebuf->size) {
- S_process_line(parser, parser->linebuf->ptr,
- parser->linebuf->size);
- cmark_strbuf_clear(parser->linebuf);
- }
+cmark_node *cmark_parser_finish(cmark_parser *parser) {
+ if (parser->linebuf->size) {
+ S_process_line(parser, parser->linebuf->ptr, parser->linebuf->size);
+ cmark_strbuf_clear(parser->linebuf);
+ }
- finalize_document(parser);
+ finalize_document(parser);
- if (parser->options & CMARK_OPT_NORMALIZE) {
- cmark_consolidate_text_nodes(parser->root);
- }
+ if (parser->options & CMARK_OPT_NORMALIZE) {
+ cmark_consolidate_text_nodes(parser->root);
+ }
- cmark_strbuf_free(parser->curline);
+ cmark_strbuf_free(parser->curline);
#if CMARK_DEBUG_NODES
- if (cmark_node_check(parser->root, stderr)) {
- abort();
- }
+ if (cmark_node_check(parser->root, stderr)) {
+ abort();
+ }
#endif
- return parser->root;
+ return parser->root;
}