#include <stdlib.h>

#include <assert.h>

#include <stdio.h>

#include <limits.h>

#include "cmark_ctype.h"

#include "config.h"

#include "parser.h"

#include "cmark.h"

#include "node.h"

#include "references.h"

#include "utf8.h"

#include "scanners.h"

#include "inlines.h"

#include "houdini.h"

#include "buffer.h"

#include "chunk.h"

#define CODE_INDENT 4

#define TAB_STOP 4

#ifndef MIN

#define MIN(x, y) ((x < y) ? x : y)

#define peek_at(i, n) (i)->data[n]

static bool S_last_line_blank(const cmark_node *node) {

return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0;

}

static bool S_last_line_checked(const cmark_node *node) {

return (node->flags & CMARK_NODE__LAST_LINE_CHECKED) != 0;

}

static CMARK_INLINE cmark_node_type S_type(const cmark_node *node) {

return (cmark_node_type)node->type;

}

static void S_set_last_line_blank(cmark_node *node, bool is_blank) {

if (is_blank)

node->flags |= CMARK_NODE__LAST_LINE_BLANK;

else

node->flags &= ~CMARK_NODE__LAST_LINE_BLANK;

}

static void S_set_last_line_checked(cmark_node *node) {

node->flags |= CMARK_NODE__LAST_LINE_CHECKED;

}

static CMARK_INLINE bool S_is_line_end_char(char c) {

return (c == '\n' || c == '\r');

}

static CMARK_INLINE bool S_is_space_or_tab(char c) {

return (c == ' ' || c == '\t');

}

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_mem *mem, cmark_node_type tag,

int start_line, int start_column) {

cmark_node *e;

e = (cmark_node *)mem->calloc(1, sizeof(*e));

e->mem = mem;

e->type = (uint16_t)tag;

e->flags = CMARK_NODE__OPEN;

e->start_line = start_line;

e->start_column = start_column;

e->end_line = start_line;

return e;

}

static cmark_node *make_document(cmark_mem *mem) {

cmark_node *e = make_block(mem, CMARK_NODE_DOCUMENT, 1, 1);

return e;

}

cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) {

cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));

parser->mem = mem;

cmark_node *document = make_document(mem);

cmark_strbuf_init(mem, &parser->curline, 256);

cmark_strbuf_init(mem, &parser->linebuf, 0);

cmark_strbuf_init(mem, &parser->content, 0);

parser->refmap = cmark_reference_map_new(mem);

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->thematic_break_kill_pos = 0;

parser->indent = 0;

parser->blank = false;

parser->partially_consumed_tab = false;

parser->last_line_length = 0;

parser->options = options;

parser->last_buffer_ended_with_cr = false;

return parser;

}

cmark_parser *cmark_parser_new(int options) {

extern cmark_mem DEFAULT_MEM_ALLOCATOR;

return cmark_parser_new_with_mem(options, &DEFAULT_MEM_ALLOCATOR);

}

void cmark_parser_free(cmark_parser *parser) {

cmark_mem *mem = parser->mem;

cmark_strbuf_free(&parser->curline);

cmark_strbuf_free(&parser->linebuf);

cmark_reference_map_free(parser->refmap);

mem->free(parser);

}

static cmark_node *finalize(cmark_parser *parser, cmark_node *b);

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 CMARK_INLINE bool can_contain(cmark_node_type parent_type,

cmark_node_type child_type) {

return (parent_type == CMARK_NODE_DOCUMENT ||

parent_type == CMARK_NODE_BLOCK_QUOTE ||

parent_type == CMARK_NODE_ITEM ||

(parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM));

}

static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) {

return (block_type == CMARK_NODE_PARAGRAPH ||

block_type == CMARK_NODE_HEADING ||

block_type == CMARK_NODE_CODE_BLOCK);

}

static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) {

return (block_type == CMARK_NODE_PARAGRAPH ||

block_type == CMARK_NODE_HEADING);

}

static void add_line(cmark_chunk *ch, cmark_parser *parser) {

int chars_to_tab;

int i;

if (parser->partially_consumed_tab) {

parser->offset += 1; // skip over tab

// add space characters:

chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);

for (i = 0; i < chars_to_tab; i++) {

cmark_strbuf_putc(&parser->content, ' ');

}

}

cmark_strbuf_put(&parser->content, ch->data + parser->offset,

ch->len - parser->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];

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];

if (!S_is_line_end_char(c))

continue;

cmark_strbuf_truncate(ln, i);

break;

}

}

static bool S_ends_with_blank_line(cmark_node *node) {

if (S_last_line_checked(node)) {

return(S_last_line_blank(node));

} else if ((S_type(node) == CMARK_NODE_LIST ||

S_type(node) == CMARK_NODE_ITEM) && node->last_child) {

S_set_last_line_checked(node);

return(S_ends_with_blank_line(node->last_child));

} else {

S_set_last_line_checked(node);

return (S_last_line_blank(node));

}

}

static bool resolve_reference_link_definitions(cmark_parser *parser) {

bufsize_t pos;

cmark_strbuf *node_content = &parser->content;

cmark_chunk chunk = {node_content->ptr, node_content->size};

while (chunk.len && chunk.data[0] == '[' &&

(pos = cmark_parse_reference_inline(parser->mem, &chunk,

parser->refmap))) {

chunk.data += pos;

chunk.len -= pos;

}

cmark_strbuf_drop(node_content, (node_content->size - chunk.len));

return !is_blank(node_content, 0);

}

static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {

bufsize_t pos;

cmark_node *item;

cmark_node *subitem;

cmark_node *parent;

bool has_content;

parent = b->parent;

assert(b->flags &

CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks

b->flags &= ~CMARK_NODE__OPEN;

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 (S_type(b) == CMARK_NODE_DOCUMENT ||

(S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||

(S_type(b) == CMARK_NODE_HEADING && b->as.heading.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;

}

cmark_strbuf *node_content = &parser->content;

switch (S_type(b)) {

case CMARK_NODE_PARAGRAPH:

{

has_content = resolve_reference_link_definitions(parser);

if (!has_content) {

// remove blank node (former reference def)

cmark_node_free(b);

} else {

b->len = node_content->size;

b->data = cmark_strbuf_detach(node_content);

}

break;

}

case CMARK_NODE_CODE_BLOCK:

if (!b->as.code.fenced) { // indented code

remove_trailing_blank_lines(node_content);

cmark_strbuf_putc(node_content, '\n');

} else {

// first line of contents becomes info

for (pos = 0; pos < node_content->size; ++pos) {

if (S_is_line_end_char(node_content->ptr[pos]))

break;

}

assert(pos < node_content->size);

if (pos == 0) {

b->as.code.info = NULL;

} else {

cmark_strbuf tmp = CMARK_BUF_INIT(parser->mem);

houdini_unescape_html_f(&tmp, node_content->ptr, pos);

cmark_strbuf_trim(&tmp);

cmark_strbuf_unescape(&tmp);

b->as.code.info = cmark_strbuf_detach(&tmp);

}

if (node_content->ptr[pos] == '\r')

pos += 1;

if (node_content->ptr[pos] == '\n')

pos += 1;

cmark_strbuf_drop(node_content, pos);

}

b->len = node_content->size;

b->data = cmark_strbuf_detach(node_content);

break;

case CMARK_NODE_HEADING:

case CMARK_NODE_HTML_BLOCK:

b->len = node_content->size;

b->data = cmark_strbuf_detach(node_content);

break;

case CMARK_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 (S_last_line_blank(item) && 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 ((item->next || subitem->next) &&

S_ends_with_blank_line(subitem)) {

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 *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(S_type(parent), block_type)) {

parent = finalize(parser, parent);

}

cmark_node *child =

make_block(parser->mem, 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 void process_inlines(cmark_mem *mem, 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 (contains_inlines(S_type(cur))) {

cmark_parse_inlines(mem, cur, refmap, options);

mem->free(cur->data);

cur->data = NULL;

cur->len = 0;

}

}

}

cmark_iter_free(iter);

}

static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input,

bufsize_t pos, bool interrupts_paragraph,

cmark_list **dataptr) {

unsigned char c;

bufsize_t startpos;

cmark_list *data;

bufsize_t i;

startpos = pos;

c = peek_at(input, pos);

if (c == '*' || c == '-' || c == '+') {

pos++;

if (!cmark_isspace(peek_at(input, pos))) {

return 0;

}

if (interrupts_paragraph) {

i = pos;

// require non-blank content after list marker:

while (S_is_space_or_tab(peek_at(input, i))) {

i++;

}

if (peek_at(input, i) == '\n') {

return 0;

}

}

data = (cmark_list *)mem->calloc(1, sizeof(*data));

data->marker_offset = 0; // will be adjusted later

data->list_type = CMARK_BULLET_LIST;

data->bullet_char = c;

data->start = 0;

data->delimiter = CMARK_NO_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)));

if (interrupts_paragraph && start != 1) {

return 0;

}

c = peek_at(input, pos);

if (c == '.' || c == ')') {

pos++;

if (!cmark_isspace(peek_at(input, pos))) {

return 0;

}

if (interrupts_paragraph) {

// require non-blank content after list marker:

i = pos;

while (S_is_space_or_tab(peek_at(input, i))) {

i++;

}

if (S_is_line_end_char(peek_at(input, i))) {

return 0;

}

}

data = (cmark_list *)mem->calloc(1, sizeof(*data));

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 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);

}

finalize(parser, parser->root);

// Limit total size of extra content created from reference links to

// document size to avoid superlinear growth. Always allow 100KB.

if (parser->total_size > 100000)

parser->refmap->max_ref_size = parser->total_size;

else

parser->refmap->max_ref_size = 100000;

process_inlines(parser->mem, parser->root, parser->refmap, parser->options);

cmark_strbuf_free(&parser->content);

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_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);

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);

}

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};

if (len > UINT_MAX - parser->total_size)

parser->total_size = UINT_MAX;

else

parser->total_size += len;

// Skip UTF-8 BOM if present; see #334

if (parser->line_number == 0 && parser->column == 0 && len >= 3 &&

*buffer == 0xEF && *(buffer + 1) == 0xBB &&

*(buffer + 2) == 0xBF) {

buffer += 3;

} else if (parser->last_buffer_ended_with_cr && *buffer == '\n') {

// skip NL if last buffer ended with CR ; see #117

buffer++;

}

parser->last_buffer_ended_with_cr = false;

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)) {

process = true;

break;

}

if (*eol == '\0' && eol < end) {

break;

}

}

if (eol >= end && eof) {

process = true;

}

chunk_len = (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);

} else {

cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);

}

}

buffer += chunk_len;

if (buffer < end) {

if (*buffer == '\0') {

// skip over NULL

buffer++;

} else {

// skip over line ending characters

if (*buffer == '\r') {

buffer++;

if (buffer == end)

parser->last_buffer_ended_with_cr = true;

}

if (buffer < end && *buffer == '\n')

buffer++;

}

}

}

}

static void chop_trailing_hashtags(cmark_chunk *ch) {

bufsize_t n, orig_n;

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--;

// Check for a space before the final #s:

if (n != orig_n && n >= 0 && S_is_space_or_tab(peek_at(ch, n))) {

ch->len = n;

cmark_chunk_rtrim(ch);

}

}

static int S_scan_thematic_break(cmark_parser *parser, cmark_chunk *input,

bufsize_t offset) {

bufsize_t i;

char c;

char nextc = '\0';

int count;

i = offset;

c = peek_at(input, i);

if (!(c == '*' || c == '_' || c == '-')) {

parser->thematic_break_kill_pos = i;

return 0;

}

count = 1;

while ((nextc = peek_at(input, ++i))) {

if (nextc == c) {

count++;

} else if (nextc != ' ' && nextc != '\t') {

break;

}

}

if (count >= 3 && (nextc == '\r' || nextc == '\n')) {

return (i - offset) + 1;

} else {

parser->thematic_break_kill_pos = i;

return 0;

}

}

static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) {

char c;

int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);

if (parser->first_nonspace <= parser->offset) {

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;

int chars_to_advance;

while (count > 0 && (c = peek_at(input, parser->offset))) {

if (c == '\t') {

chars_to_tab = TAB_STOP - (parser->column % TAB_STOP);

if (columns) {

parser->partially_consumed_tab = chars_to_tab > count;

chars_to_advance = MIN(count, chars_to_tab);

parser->column += chars_to_advance;

parser->offset += (parser->partially_consumed_tab ? 0 : 1);

count -= chars_to_advance;

} else {

parser->partially_consumed_tab = false;

parser->column += chars_to_tab;

parser->offset += 1;

count -= 1;

}

} else {

parser->partially_consumed_tab = false;

parser->offset += 1;

parser->column += 1; // assume ascii; block starts are ascii

count -= 1;

}

}

}

static bool S_last_child_is_open(cmark_node *container) {

return container->last_child &&

(container->last_child->flags & CMARK_NODE__OPEN);

}

static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) {

bool res = false;

bufsize_t matched = 0;

matched =

parser->indent <= 3 && peek_at(input, parser->first_nonspace) == '>';

if (matched) {

S_advance_offset(parser, input, parser->indent + 1, true);

if (S_is_space_or_tab(peek_at(input, parser->offset))) {

S_advance_offset(parser, input, 1, true);

}

res = true;

}

return res;

}

static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input,

cmark_node *container) {

bool res = false;

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);

res = true;

} else if (parser->blank && container->first_child != NULL) {

// if container->first_child is NULL, then the opening line

// of the list item was blank after the list marker; in this

// case, we are done with the list item.

S_advance_offset(parser, input, parser->first_nonspace - parser->offset,

false);

res = true;

}

return res;

}

static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *input,

cmark_node *container,

bool *should_continue) {

bool res = false;

if (!container->as.code.fenced) { // indented

if (parser->indent >= CODE_INDENT) {

S_advance_offset(parser, input, CODE_INDENT, true);

res = true;

} else if (parser->blank) {

S_advance_offset(parser, input, parser->first_nonspace - parser->offset,

false);

res = true;

}

} else { // fenced

bufsize_t 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 stop processing it:

*should_continue = false;

S_advance_offset(parser, input, matched, false);

parser->current = finalize(parser, container);

} else {

// skip opt. spaces of fence parser->offset

int i = container->as.code.fence_offset;

while (i > 0 && S_is_space_or_tab(peek_at(input, parser->offset))) {

S_advance_offset(parser, input, 1, true);

i--;

}

res = true;

}

}

return res;

}

static bool parse_html_block_prefix(cmark_parser *parser,

cmark_node *container) {

bool res = false;

int html_block_type = container->as.html_block_type;

assert(html_block_type >= 1 && html_block_type <= 7);

switch (html_block_type) {

case 1:

case 2:

case 3:

case 4:

case 5:

// these types of blocks can accept blanks

res = true;

break;

case 6:

case 7:

res = !parser->blank;

break;

}

return res;

}

static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,

bool *all_matched) {

bool should_continue = true;

*all_matched = false;

cmark_node *container = parser->root;

cmark_node_type cont_type;

while (S_last_child_is_open(container)) {

container = container->last_child;

cont_type = S_type(container);

S_find_first_nonspace(parser, input);

switch (cont_type) {

case CMARK_NODE_BLOCK_QUOTE:

if (!parse_block_quote_prefix(parser, input))

goto done;

break;

case CMARK_NODE_ITEM:

if (!parse_node_item_prefix(parser, input, container))

goto done;

break;

case CMARK_NODE_CODE_BLOCK:

if (!parse_code_block_prefix(parser, input, container, &should_continue))

goto done;

break;

case CMARK_NODE_HEADING:

// a heading can never contain more than one line

goto done;

case CMARK_NODE_HTML_BLOCK:

if (!parse_html_block_prefix(parser, container))

goto done;

break;

case CMARK_NODE_PARAGRAPH:

if (parser->blank)

goto done;

break;

default:

break;

}

}

*all_matched = true;

done:

if (!*all_matched) {

container = container->parent; // back up to last matching node

}

if (!should_continue) {

container = NULL;

}

return container;

}

static void open_new_blocks(cmark_parser *parser, cmark_node **container,

cmark_chunk *input, bool all_matched) {

bool indented;

cmark_list *data = NULL;

bool maybe_lazy = S_type(parser->current) == CMARK_NODE_PARAGRAPH;

cmark_node_type cont_type = S_type(*container);

bufsize_t matched = 0;

int lev = 0;

bool save_partially_consumed_tab;

bool has_content;

int save_offset;

int save_column;

while (cont_type != CMARK_NODE_CODE_BLOCK &&

cont_type != CMARK_NODE_HTML_BLOCK) {

S_find_first_nonspace(parser, input);

indented = parser->indent >= CODE_INDENT;

if (!indented && peek_at(input, parser->first_nonspace) == '>') {

bufsize_t blockquote_startpos = parser->first_nonspace;

S_advance_offset(parser, input,

parser->first_nonspace + 1 - parser->offset, false);

// optional following character

if (S_is_space_or_tab(peek_at(input, parser->offset))) {

S_advance_offset(parser, input, 1, true);

}

*container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE,

blockquote_startpos + 1);

} else if (!indented && (matched = scan_atx_heading_start(

input, parser->first_nonspace))) {

bufsize_t hashpos;

int level = 0;

bufsize_t heading_startpos = parser->first_nonspace;

S_advance_offset(parser, input,

parser->first_nonspace + matched - parser->offset,

false);

*container = add_child(parser, *container, CMARK_NODE_HEADING,

heading_startpos + 1);

hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace);

while (peek_at(input, hashpos) == '#') {

level++;

hashpos++;

}

(*container)->as.heading.level = level;

(*container)->as.heading.setext = false;

(*container)->as.heading.internal_offset = matched;

} else if (!indented && (matched = scan_open_code_fence(