path: root/src/blocks.c

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <stdbool.h>
#include <ctype.h>

#include "stmd.h"
#include "utf8.h"
#include "html/houdini.h"
#include "scanners.h"
#include "uthash.h"

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

static void incorporate_line(strbuf *ln, int line_number, node_block** curptr);
static void finalize(node_block* b, int line_number);

static node_block* make_block(int tag, int start_line, int start_column)
{
    node_block* e;
    e = (node_block*) malloc(sizeof(node_block));
    e->tag = tag;
    e->open = true;
    e->last_line_blank = false;
    e->start_line = start_line;
    e->start_column = start_column;
    e->end_line = start_line;
    e->children = NULL;
    e->last_child = NULL;
    e->parent = NULL;
    e->top = NULL;
    e->attributes.refmap = NULL;
    strbuf_init(&e->string_content, 32);
    e->inline_content = NULL;
    e->next = NULL;
    e->prev = NULL;
    return e;
}

// Create a root document node_block.
extern node_block* make_document()
{
    node_block * e = make_block(BLOCK_DOCUMENT, 1, 1);
    reference * map = NULL;
    reference ** refmap;
    refmap = (reference**) malloc(sizeof(reference*));
    *refmap = map;
    e->attributes.refmap = refmap;
    e->top = e;
    return e;
}

// Returns true if line has only space characters, else false.
bool is_blank(strbuf *s, int offset)
{
    while (offset < s->size) {
        switch (s->ptr[offset]) {
            case '\n':
                return true;
            case ' ':
                offset++;
                break;
            default:
                return false;
        }
    }

    return true;
}

static inline bool can_contain(int parent_type, int child_type)
{
    return ( parent_type == BLOCK_DOCUMENT ||
            parent_type == BLOCK_BQUOTE ||
            parent_type == BLOCK_LIST_ITEM ||
            (parent_type == BLOCK_LIST && child_type == BLOCK_LIST_ITEM) );
}

static inline bool accepts_lines(int block_type)
{
    return (block_type == BLOCK_PARAGRAPH ||
            block_type == BLOCK_ATX_HEADER ||
            block_type == BLOCK_INDENTED_CODE ||
            block_type == BLOCK_FENCED_CODE);
}

static void add_line(node_block* node_block, chunk *ch, int offset)
{
    assert(node_block->open);
    strbuf_put(&node_block->string_content, ch->data + offset, ch->len - offset);
}

static void remove_trailing_blank_lines(strbuf *ln)
{
    int i;

    for (i = ln->size - 1; i >= 0; --i) {
        char c = ln->ptr[i];

        if (c != ' ' && c != '\t' && c != '\r' && c != '\n')
            break;
    }

    if (i < 0) {
        strbuf_clear(ln);
        return;
    }

    i = strbuf_strchr(ln, '\n', i);
    if (i >= 0)
        strbuf_truncate(ln, i);
}

// Check to see if a node_block ends with a blank line, descending
// if needed into lists and sublists.
static bool ends_with_blank_line(node_block* node_block)
{
    if (node_block->last_line_blank) {
        return true;
    }
    if ((node_block->tag == BLOCK_LIST || node_block->tag == BLOCK_LIST_ITEM) && node_block->last_child) {
        return ends_with_blank_line(node_block->last_child);
    } else {
        return false;
    }
}

// Break out of all containing lists
static int break_out_of_lists(node_block ** bptr, int line_number)
{
    node_block * container = *bptr;
    node_block * b = container->top;
    // find first containing BLOCK_LIST:
    while (b && b->tag != BLOCK_LIST) {
        b = b->last_child;
    }
    if (b) {
        while (container && container != b) {
            finalize(container, line_number);
            container = container->parent;
        }
        finalize(b, line_number);
        *bptr = b->parent;
    }
    return 0;
}


static void finalize(node_block* b, int line_number)
{
    int firstlinelen;
    int pos;
    node_block* item;
    node_block* subitem;

    if (!b->open)
        return; // don't do anything if the node_block is already closed

    b->open = false;
    if (line_number > b->start_line) {
        b->end_line = line_number - 1;
    } else {
        b->end_line = line_number;
    }

    switch (b->tag) {
        case BLOCK_PARAGRAPH:
            pos = 0;
            while (strbuf_at(&b->string_content, 0) == '[' &&
                    (pos = parse_reference(&b->string_content, b->top->attributes.refmap))) {

                strbuf_drop(&b->string_content, pos);
            }
            if (is_blank(&b->string_content, 0)) {
                b->tag = BLOCK_REFERENCE_DEF;
            }
            break;

        case BLOCK_INDENTED_CODE:
            remove_trailing_blank_lines(&b->string_content);
            strbuf_putc(&b->string_content, '\n');
            break;

        case BLOCK_FENCED_CODE:
            // first line of contents becomes info
            firstlinelen = strbuf_strchr(&b->string_content, '\n', 0);

            strbuf_init(&b->attributes.fenced_code_data.info, 0);
            houdini_unescape_html_f(
                &b->attributes.fenced_code_data.info,
                b->string_content.ptr,
                firstlinelen
            );

            strbuf_drop(&b->string_content, firstlinelen + 1);

            strbuf_trim(&b->attributes.fenced_code_data.info);
            unescape_buffer(&b->attributes.fenced_code_data.info);
            break;

        case BLOCK_LIST: // determine tight/loose status
            b->attributes.list_data.tight = true; // tight by default
            item = b->children;

            while (item) {
                // check for non-final non-empty list item ending with blank line:
                if (item->last_line_blank && item->next) {
                    b->attributes.list_data.tight = false;
                    break;
                }
                // recurse into children of list item, to see if there are
                // spaces between them:
                subitem = item->children;
                while (subitem) {
                    if (ends_with_blank_line(subitem) &&
                            (item->next || subitem->next)) {
                        b->attributes.list_data.tight = false;
                        break;
                    }
                    subitem = subitem->next;
                }
                if (!(b->attributes.list_data.tight)) {
                    break;
                }
                item = item->next;
            }

            break;

        default:
            break;
    }
}

// Add a node_block as child of another.  Return pointer to child.
extern node_block* add_child(node_block* parent,
        int block_type, int start_line, int start_column)
{
    assert(parent);

    // if 'parent' isn't the kind of node_block that can accept this child,
    // then back up til we hit a node_block that can.
    while (!can_contain(parent->tag, block_type)) {
        finalize(parent, start_line);
        parent = parent->parent;
    }

    node_block* child = make_block(block_type, start_line, start_column);
    child->parent = parent;
    child->top = parent->top;

    if (parent->last_child) {
        parent->last_child->next = child;
        child->prev = parent->last_child;
    } else {
        parent->children = child;
        child->prev = NULL;
    }
    parent->last_child = child;
    return child;
}

// Free a node_block list and any children.
extern void free_blocks(node_block* e)
{
    node_block * next;
    while (e != NULL) {
        next = e->next;
        free_inlines(e->inline_content);
        strbuf_free(&e->string_content);
        if (e->tag == BLOCK_FENCED_CODE) {
            strbuf_free(&e->attributes.fenced_code_data.info);
        } else if (e->tag == BLOCK_DOCUMENT) {
            free_reference_map(e->attributes.refmap);
        }
        free_blocks(e->children);
        free(e);
        e = next;
    }
}

// Walk through node_block and all children, recursively, parsing
// string content into inline content where appropriate.
void process_inlines(node_block* cur, reference** refmap)
{
    switch (cur->tag) {
        case BLOCK_PARAGRAPH:
        case BLOCK_ATX_HEADER:
        case BLOCK_SETEXT_HEADER:
            cur->inline_content = parse_inlines(&cur->string_content, refmap);
            // MEM
            // strbuf_free(&cur->string_content);
            break;

        default:
            break;
    }

    node_block *child = cur->children;
    while (child != NULL) {
        process_inlines(child, refmap);
        child = child->next;
    }
}

// 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 int parse_list_marker(chunk *input, int pos, struct ListData ** dataptr)
{
    unsigned char c;
    int startpos;
    struct ListData * data;

    startpos = pos;
    c = peek_at(input, pos);

    if ((c == '*' || c == '-' || c == '+') && !scan_hrule(input, pos)) {
        pos++;
        if (!isspace(peek_at(input, pos))) {
            return 0;
        }
        data = malloc(sizeof(struct ListData));
        data->marker_offset = 0; // will be adjusted later
        data->list_type = bullet;
        data->bullet_char = c;
        data->start = 1;
        data->delimiter = period;
        data->tight = false;

    } else if (isdigit(c)) {
        int start = 0;

        do {
            start = (10 * start) + (peek_at(input, pos) - '0');
            pos++;
        } while (isdigit(peek_at(input, pos)));

        c = peek_at(input, pos);
        if (c == '.' || c == ')') {
            pos++;
            if (!isspace(peek_at(input, pos))) {
                return 0;
            }
            data = malloc(sizeof(struct ListData));
            data->marker_offset = 0; // will be adjusted later
            data->list_type = ordered;
            data->bullet_char = 0;
            data->start = start;
            data->delimiter = (c == '.' ? period : parens);
            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(struct ListData list_data,
        struct ListData 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 node_block *finalize_document(node_block *document, int linenum)
{
    while (document != document->top) {
        finalize(document, linenum);
        document = document->parent;
    }

    finalize(document, linenum);
    process_inlines(document, document->attributes.refmap);

    return document;
}

extern node_block *stmd_parse_file(FILE *f)
{
    strbuf line = GH_BUF_INIT;
    unsigned char buffer[4096];
    int linenum = 1;
    node_block *document = make_document();

    while (fgets((char *)buffer, sizeof(buffer), f)) {
        utf8proc_detab(&line, buffer, strlen((char *)buffer));
        incorporate_line(&line, linenum, &document);
        strbuf_clear(&line);
        linenum++;
    }

    strbuf_free(&line);
    return finalize_document(document, linenum);
}

extern node_block *stmd_parse_document(const unsigned char *buffer, size_t len)
{
    strbuf line = GH_BUF_INIT;
    int linenum = 1;
    const unsigned char *end = buffer + len;
    node_block *document = make_document();

    while (buffer < end) {
        const unsigned char *eol = memchr(buffer, '\n', end - buffer);

        if (!eol) {
            utf8proc_detab(&line, buffer, end - buffer);
            buffer = end;
        } else {
            utf8proc_detab(&line, buffer, (eol - buffer) + 1);
            buffer += (eol - buffer) + 1;
        }

        incorporate_line(&line, linenum, &document);
        strbuf_clear(&line);
        linenum++;
    }

    strbuf_free(&line);
    return finalize_document(document, linenum);
}

static void chop_trailing_hashtags(chunk *ch)
{
    int n;

    chunk_rtrim(ch);
    n = ch->len - 1;

    // if string ends in #s, remove these:
    while (n >= 0 && peek_at(ch, n) == '#')
        n--;

    // the last # was escaped, so we include it.
    if (n >= 0 && peek_at(ch, n) == '\\')
        n++;

    ch->len = n + 1;
}

// Process one line at a time, modifying a node_block.
static void incorporate_line(strbuf *line, int line_number, node_block** curptr)
{
    node_block* last_matched_container;
    int offset = 0;
    int matched = 0;
    int lev = 0;
    int i;
    struct ListData * data = NULL;
    bool all_matched = true;
    node_block* container;
    node_block* cur = *curptr;
    bool blank = false;
    int first_nonspace;
    int indent;
    chunk input;

    input.data = line->ptr;
    input.len = line->size;

    // container starts at the document root.
    container = cur->top;

    // for each containing node_block, try to parse the associated line start.
    // bail out on failure:  container will point to the last matching node_block.

    while (container->last_child && container->last_child->open) {
        container = container->last_child;

        first_nonspace = offset;
        while (peek_at(&input, first_nonspace) == ' ') {
            first_nonspace++;
        }

        indent = first_nonspace - offset;
        blank = peek_at(&input, first_nonspace) == '\n';

        if (container->tag == BLOCK_BQUOTE) {
            matched = indent <= 3 && peek_at(&input, first_nonspace) == '>';
            if (matched) {
                offset = first_nonspace + 1;
                if (peek_at(&input, offset) == ' ')
                    offset++;
            } else {
                all_matched = false;
            }

        } else if (container->tag == BLOCK_LIST_ITEM) {

            if (indent >= container->attributes.list_data.marker_offset +
                    container->attributes.list_data.padding) {
                offset += container->attributes.list_data.marker_offset +
                    container->attributes.list_data.padding;
            } else if (blank) {
                offset = first_nonspace;
            } else {
                all_matched = false;
            }

        } else if (container->tag == BLOCK_INDENTED_CODE) {

            if (indent >= CODE_INDENT) {
                offset += CODE_INDENT;
            } else if (blank) {
                offset = first_nonspace;
            } else {
                all_matched = false;
            }

        } else if (container->tag == BLOCK_ATX_HEADER ||
                container->tag == BLOCK_SETEXT_HEADER) {

            // a header can never contain more than one line
            all_matched = false;

        } else if (container->tag == BLOCK_FENCED_CODE) {

            // skip optional spaces of fence offset
            i = container->attributes.fenced_code_data.fence_offset;
            while (i > 0 && peek_at(&input, offset) == ' ') {
                offset++;
                i--;
            }

        } else if (container->tag == BLOCK_HTML) {

            if (blank) {
                all_matched = false;
            }

        } else if (container->tag == BLOCK_PARAGRAPH) {

            if (blank) {
                container->last_line_blank = true;
                all_matched = false;
            }

        }

        if (!all_matched) {
            container = container->parent;  // back up to last matching node_block
            break;
        }
    }

    last_matched_container = container;

    // check to see if we've hit 2nd blank line, break out of list:
    if (blank && container->last_line_blank) {
        break_out_of_lists(&container, line_number);
    }

    // unless last matched container is code node_block, try new container starts:
    while (container->tag != BLOCK_FENCED_CODE && container->tag != BLOCK_INDENTED_CODE &&
            container->tag != BLOCK_HTML) {

        first_nonspace = offset;
        while (peek_at(&input, first_nonspace) == ' ')
            first_nonspace++;

        indent = first_nonspace - offset;
        blank = peek_at(&input, first_nonspace) == '\n';

        if (indent >= CODE_INDENT) {
            if (cur->tag != BLOCK_PARAGRAPH && !blank) {
                offset += CODE_INDENT;
                container = add_child(container, BLOCK_INDENTED_CODE, line_number, offset + 1);
            } else { // indent > 4 in lazy line
                break;
            }

        } else if (peek_at(&input, first_nonspace) == '>') {

            offset = first_nonspace + 1;
            // optional following character
            if (peek_at(&input, offset) == ' ')
                offset++;
            container = add_child(container, BLOCK_BQUOTE, line_number, offset + 1);

        } else if ((matched = scan_atx_header_start(&input, first_nonspace))) {

            offset = first_nonspace + matched;
            container = add_child(container, BLOCK_ATX_HEADER, line_number, offset + 1);

            int hashpos = chunk_strchr(&input, '#', first_nonspace);
            int level = 0;

            while (peek_at(&input, hashpos) == '#') {
                level++;
                hashpos++;
            }
            container->attributes.header_level = level;

        } else if ((matched = scan_open_code_fence(&input, first_nonspace))) {

            container = add_child(container, BLOCK_FENCED_CODE, line_number, first_nonspace + 1);
            container->attributes.fenced_code_data.fence_char = peek_at(&input, first_nonspace);
            container->attributes.fenced_code_data.fence_length = matched;
            container->attributes.fenced_code_data.fence_offset = first_nonspace - offset;
            offset = first_nonspace + matched;

        } else if ((matched = scan_html_block_tag(&input, first_nonspace))) {

            container = add_child(container, BLOCK_HTML, line_number, first_nonspace + 1);
            // note, we don't adjust offset because the tag is part of the text

        } else if (container->tag == BLOCK_PARAGRAPH &&
                (lev = scan_setext_header_line(&input, first_nonspace)) &&
                // check that there is only one line in the paragraph:
                strbuf_strrchr(&container->string_content, '\n',
                    strbuf_len(&container->string_content) - 2) < 0) {

            container->tag = BLOCK_SETEXT_HEADER;
            container->attributes.header_level = lev;
            offset = input.len - 1;

        } else if (!(container->tag == BLOCK_PARAGRAPH && !all_matched) &&
                (matched = scan_hrule(&input, first_nonspace))) {

            // it's only now that we know the line is not part of a setext header:
            container = add_child(container, BLOCK_HRULE, line_number, first_nonspace + 1);
            finalize(container, line_number);
            container = container->parent;
            offset = input.len - 1;

        } else if ((matched = parse_list_marker(&input, first_nonspace, &data))) {

            // compute padding:
            offset = first_nonspace + matched;
            i = 0;
            while (i <= 5 && peek_at(&input, offset + i) == ' ') {
                i++;
            }
            // i = number of spaces after marker, up to 5
            if (i >= 5 || i < 1 || peek_at(&input, offset) == '\n') {
                data->padding = matched + 1;
                if (i > 0) {
                    offset += 1;
                }
            } else {
                data->padding = matched + i;
                offset += i;
            }

            // check container; if it's a list, see if this list item
            // can continue the list; otherwise, create a list container.

            data->marker_offset = indent;

            if (container->tag != BLOCK_LIST ||
                    !lists_match(container->attributes.list_data, *data)) {
                container = add_child(container, BLOCK_LIST, line_number,
                        first_nonspace + 1);
                container->attributes.list_data = *data;
            }

            // add the list item
            container = add_child(container, BLOCK_LIST_ITEM, line_number,
                    first_nonspace + 1);
            /* TODO: static */
            container->attributes.list_data = *data;
            free(data);

        } else {
            break;
        }

        if (accepts_lines(container->tag)) {
            // if it's a line container, it can't contain other containers
            break;
        }
    }

    // what remains at offset is a text line.  add the text to the
    // appropriate container.

    first_nonspace = offset;
    while (peek_at(&input, first_nonspace) == ' ')
        first_nonspace++;

    indent = first_nonspace - offset;
    blank = peek_at(&input, first_nonspace) == '\n';

    // node_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 = (blank &&
            container->tag != BLOCK_BQUOTE &&
            container->tag != BLOCK_FENCED_CODE &&
            !(container->tag == BLOCK_LIST_ITEM &&
                container->children == NULL &&
                container->start_line == line_number));

    node_block *cont = container;
    while (cont->parent) {
        cont->parent->last_line_blank = false;
        cont = cont->parent;
    }

    if (cur != last_matched_container &&
            container == last_matched_container &&
            !blank &&
            cur->tag == BLOCK_PARAGRAPH &&
            strbuf_len(&cur->string_content) > 0) {

        add_line(cur, &input, offset);

    } else { // not a lazy continuation

        // finalize any blocks that were not matched and set cur to container:
        while (cur != last_matched_container) {
            finalize(cur, line_number);
            cur = cur->parent;
            assert(cur != NULL);
        }

        if (container->tag == BLOCK_INDENTED_CODE) {

            add_line(container, &input, offset);

        } else if (container->tag == BLOCK_FENCED_CODE) {
            matched = 0;

            if (indent <= 3 &&
                peek_at(&input, first_nonspace) == container->attributes.fenced_code_data.fence_char) {
                int fence_len = scan_close_code_fence(&input, first_nonspace);
                if (fence_len > container->attributes.fenced_code_data.fence_length)
                    matched = 1;
            }

            if (matched) {
                // if closing fence, don't add line to container; instead, close it:
                finalize(container, line_number);
                container = container->parent; // back up to parent
            } else {
                add_line(container, &input, offset);
            }

        } else if (container->tag == BLOCK_HTML) {

            add_line(container, &input, offset);

        } else if (blank) {

            // ??? do nothing

        } else if (container->tag == BLOCK_ATX_HEADER) {

            chop_trailing_hashtags(&input);
            add_line(container, &input, first_nonspace);
            finalize(container, line_number);
            container = container->parent;

        } else if (accepts_lines(container->tag)) {

            add_line(container, &input, first_nonspace);

        } else if (container->tag != BLOCK_HRULE && container->tag != BLOCK_SETEXT_HEADER) {

            // create paragraph container for line
            container = add_child(container, BLOCK_PARAGRAPH, line_number, first_nonspace + 1);
            add_line(container, &input, first_nonspace);

        } else {
            assert(false);
        }

        *curptr = container;
    }
}