kicad/thirdparty/markdown2html/md_parser/markdown.c

/* markdown.c - generic markdown parser */

/*
 * Copyright (c) 2009, Natacha Porté
 * Copyright (c) 2011, Vicent Marti
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "markdown.h"
#include "stack.h"

#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>

#if defined(_WIN32)
#define strncasecmp _strnicmp
#endif

#define REF_TABLE_SIZE  8

#define BUFFER_BLOCK    0
#define BUFFER_SPAN     1

#define MKD_LI_END      8 /* internal list flag */

#define gperf_case_strncmp( s1, s2, n ) strncasecmp( s1, s2, n )
#define GPERF_DOWNCASE      1
#define GPERF_CASE_STRNCMP  1
#include "html_blocks.h"

/***************
* LOCAL TYPES *
***************/

/* link_ref: reference to a link */
struct link_ref
{
    unsigned int id;

    struct buf* link;
    struct buf* title;

    struct link_ref* next;
};

/* char_trigger: function pointer to render active chars */
/*   returns the number of chars taken care of */
/*   data is the pointer of the beginning of the span */
/*   offset is the number of valid chars before data */
struct sd_markdown;
typedef size_t (* char_trigger)( struct buf* ob, struct sd_markdown* rndr, uint8_t* data, size_t offset,
                size_t size );

static size_t char_emphasis( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_linebreak( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_codespan( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_escape( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_entity( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_langle_tag( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_autolink_url( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_autolink_email( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_autolink_www( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_link( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );
static size_t char_superscript( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size );

enum markdown_char_t
{
    MD_CHAR_NONE = 0,
    MD_CHAR_EMPHASIS,
    MD_CHAR_CODESPAN,
    MD_CHAR_LINEBREAK,
    MD_CHAR_LINK,
    MD_CHAR_LANGLE,
    MD_CHAR_ESCAPE,
    MD_CHAR_ENTITITY,
    MD_CHAR_AUTOLINK_URL,
    MD_CHAR_AUTOLINK_EMAIL,
    MD_CHAR_AUTOLINK_WWW,
    MD_CHAR_SUPERSCRIPT,
};

static char_trigger markdown_char_ptrs[] =
{
    NULL,
    &char_emphasis,
    &char_codespan,
    &char_linebreak,
    &char_link,
    &char_langle_tag,
    &char_escape,
    &char_entity,
    &char_autolink_url,
    &char_autolink_email,
    &char_autolink_www,
    &char_superscript,
};

/* render • structure containing one particular render */
struct sd_markdown
{
    struct sd_callbacks cb;
    void* opaque;

    struct link_ref* refs[REF_TABLE_SIZE];
    uint8_t active_char[256];
    struct stack work_bufs[2];
    unsigned int ext_flags;
    size_t max_nesting;
    int in_link_body;
};

/***************************
* HELPER FUNCTIONS *
***************************/

static inline struct buf* rndr_newbuf( struct sd_markdown* rndr, int type )
{
    static const size_t buf_size[2] = { 256, 64 };
    struct buf* work = NULL;
    struct stack* pool = &rndr->work_bufs[type];

    if( pool->size < pool->asize
        && pool->item[pool->size] != NULL )
    {
        work = pool->item[pool->size++];
        work->size = 0;
    }
    else
    {
        work = bufnew( buf_size[type] );
        stack_push( pool, work );
    }

    return work;
}


static inline void rndr_popbuf( struct sd_markdown* rndr, int type )
{
    rndr->work_bufs[type].size--;
}


static void unscape_text( struct buf* ob, struct buf* src )
{
    size_t i = 0, org;

    while( i < src->size )
    {
        org = i;

        while( i < src->size && src->data[i] != '\\' )
            i++;

        if( i > org )
            bufput( ob, src->data + org, i - org );

        if( i + 1 >= src->size )
            break;

        bufputc( ob, src->data[i + 1] );
        i += 2;
    }
}


static unsigned int hash_link_ref( const uint8_t* link_ref, size_t length )
{
    size_t i;
    unsigned int hash = 0;

    for( i = 0; i < length; ++i )
        hash = tolower( link_ref[i] ) + (hash << 6) + (hash << 16) - hash;

    return hash;
}


static struct link_ref* add_link_ref( struct link_ref** references,
        const uint8_t* name, size_t name_size )
{
    struct link_ref* ref = calloc( 1, sizeof(struct link_ref) );

    if( !ref )
        return NULL;

    ref->id = hash_link_ref( name, name_size );
    ref->next = references[ref->id % REF_TABLE_SIZE];

    references[ref->id % REF_TABLE_SIZE] = ref;
    return ref;
}


static struct link_ref* find_link_ref( struct link_ref** references, uint8_t* name, size_t length )
{
    unsigned int hash = hash_link_ref( name, length );
    struct link_ref* ref = NULL;

    ref = references[hash % REF_TABLE_SIZE];

    while( ref != NULL )
    {
        if( ref->id == hash )
            return ref;

        ref = ref->next;
    }

    return NULL;
}


static void free_link_refs( struct link_ref** references )
{
    size_t i;

    for( i = 0; i < REF_TABLE_SIZE; ++i )
    {
        struct link_ref* r = references[i];
        struct link_ref* next;

        while( r )
        {
            next = r->next;
            bufrelease( r->link );
            bufrelease( r->title );
            free( r );
            r = next;
        }
    }
}


/*
 * Check whether a char is a Markdown space.
 *
 * Right now we only consider spaces the actual
 * space and a newline: tabs and carriage returns
 * are filtered out during the preprocessing phase.
 *
 * If we wanted to actually be UTF-8 compliant, we
 * should instead extract an Unicode codepoint from
 * this character and check for space properties.
 */
static inline int _isspace( int c )
{
    return c == ' ' || c == '\n';
}


/****************************
* INLINE PARSING FUNCTIONS *
****************************/

/* is_mail_autolink • looks for the address part of a mail autolink and '>' */
/* this is less strict than the original markdown e-mail address matching */
static size_t is_mail_autolink( uint8_t* data, size_t size )
{
    size_t i = 0, nb = 0;

    /* address is assumed to be: [-@._a-zA-Z0-9]+ with exactly one '@' */
    for( i = 0; i < size; ++i )
    {
        if( isalnum( data[i] ) )
            continue;

        switch( data[i] )
        {
        case '@':
            nb++;

        case '-':
        case '.':
        case '_':
            break;

        case '>':
            return (nb == 1) ? i + 1 : 0;

        default:
            return 0;
        }
    }

    return 0;
}


/* tag_length • returns the length of the given tag, or 0 is it's not valid */
static size_t tag_length( uint8_t* data, size_t size, enum mkd_autolink* autolink )
{
    size_t i, j;

    /* a valid tag can't be shorter than 3 chars */
    if( size < 3 )
        return 0;

    /* begins with a '<' optionally followed by '/', followed by letter or number */
    if( data[0] != '<' )
        return 0;

    i = (data[1] == '/') ? 2 : 1;

    if( !isalnum( data[i] ) )
        return 0;

    /* scheme test */
    *autolink = MKDA_NOT_AUTOLINK;

    /* try to find the beginning of an URI */
    while( i < size && (isalnum( data[i] ) || data[i] == '.' || data[i] == '+' || data[i] == '-') )
        i++;

    if( i > 1 && data[i] == '@' )
    {
        if( ( j = is_mail_autolink( data + i, size - i ) ) != 0 )
        {
            *autolink = MKDA_EMAIL;
            return i + j;
        }
    }

    if( i > 2 && data[i] == ':' )
    {
        *autolink = MKDA_NORMAL;
        i++;
    }

    /* completing autolink test: no whitespace or ' or " */
    if( i >= size )
        *autolink = MKDA_NOT_AUTOLINK;

    else if( *autolink )
    {
        j = i;

        while( i < size )
        {
            if( data[i] == '\\' )
                i += 2;
            else if( data[i] == '>' || data[i] == '\''
                     || data[i] == '"' || data[i] == ' ' || data[i] == '\n' )
                break;
            else
                i++;
        }

        if( i >= size )
            return 0;

        if( i > j && data[i] == '>' )
            return i + 1;

        /* one of the forbidden chars has been found */
        *autolink = MKDA_NOT_AUTOLINK;
    }

    /* looking for sometinhg looking like a tag end */
    while( i < size && data[i] != '>' )
        i++;

    if( i >= size )
        return 0;

    return i + 1;
}


/* parse_inline • parses inline markdown elements */
static void parse_inline( struct buf* ob, struct sd_markdown* rndr, uint8_t* data, size_t size )
{
    size_t i = 0, end = 0;
    uint8_t action  = 0;
    struct buf work = { 0, 0, 0, 0 };

    if( rndr->work_bufs[BUFFER_SPAN].size +
        rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting )
        return;

    while( i < size )
    {
        /* copying inactive chars into the output */
        while( end < size && (action = rndr->active_char[data[end]]) == 0 )
        {
            end++;
        }

        if( rndr->cb.normal_text )
        {
            work.data = data + i;
            work.size = end - i;
            rndr->cb.normal_text( ob, &work, rndr->opaque );
        }
        else
            bufput( ob, data + i, end - i );

        if( end >= size )
            break;

        i = end;

        end = markdown_char_ptrs[(int) action]( ob, rndr, data + i, i, size - i );

        if( !end )    /* no action from the callback */
            end = i + 1;
        else
        {
            i += end;
            end = i;
        }
    }
}


/* find_emph_char • looks for the next emph uint8_t, skipping other constructs */
static size_t find_emph_char( uint8_t* data, size_t size, uint8_t c )
{
    size_t i = 1;

    while( i < size )
    {
        while( i < size && data[i] != c && data[i] != '`' && data[i] != '[' )
            i++;

        if( i == size )
            return 0;

        if( data[i] == c )
            return i;

        /* not counting escaped chars */
        if( i && data[i - 1] == '\\' )
        {
            i++; continue;
        }

        if( data[i] == '`' )
        {
            size_t span_nb = 0, bt;
            size_t tmp_i = 0;

            /* counting the number of opening backticks */
            while( i < size && data[i] == '`' )
            {
                i++; span_nb++;
            }

            if( i >= size )
                return 0;

            /* finding the matching closing sequence */
            bt = 0;

            while( i < size && bt < span_nb )
            {
                if( !tmp_i && data[i] == c )
                    tmp_i = i;

                if( data[i] == '`' )
                    bt++;
                else
                    bt = 0;

                i++;
            }

            if( i >= size )
                return tmp_i;
        }
        /* skipping a link */
        else if( data[i] == '[' )
        {
            size_t tmp_i = 0;
            uint8_t cc;

            i++;

            while( i < size && data[i] != ']' )
            {
                if( !tmp_i && data[i] == c )
                    tmp_i = i;

                i++;
            }

            i++;

            while( i < size && (data[i] == ' ' || data[i] == '\n') )
                i++;

            if( i >= size )
                return tmp_i;

            switch( data[i] )
            {
            case '[':
                cc = ']'; break;

            case '(':
                cc = ')'; break;

            default:

                if( tmp_i )
                    return tmp_i;
                else
                    continue;
            }

            i++;

            while( i < size && data[i] != cc )
            {
                if( !tmp_i && data[i] == c )
                    tmp_i = i;

                i++;
            }

            if( i >= size )
                return tmp_i;

            i++;
        }
    }

    return 0;
}


/* parse_emph1 • parsing single emphase */
/* closed by a symbol not preceded by whitespace and not followed by symbol */
static size_t parse_emph1( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        uint8_t c )
{
    size_t i = 0, len;
    struct buf* work = 0;
    int r;

    if( !rndr->cb.emphasis )
        return 0;

    /* skipping one symbol if coming from emph3 */
    if( size > 1 && data[0] == c && data[1] == c )
        i = 1;

    while( i < size )
    {
        len = find_emph_char( data + i, size - i, c );

        if( !len )
            return 0;

        i += len;

        if( i >= size )
            return 0;

        if( data[i] == c && !_isspace( data[i - 1] ) )
        {
            if( rndr->ext_flags & MKDEXT_NO_INTRA_EMPHASIS )
            {
                if( i + 1 < size && isalnum( data[i + 1] ) )
                    continue;
            }

            work = rndr_newbuf( rndr, BUFFER_SPAN );
            parse_inline( work, rndr, data, i );
            r = rndr->cb.emphasis( ob, work, rndr->opaque );
            rndr_popbuf( rndr, BUFFER_SPAN );
            return r ? i + 1 : 0;
        }
    }

    return 0;
}


/* parse_emph2 • parsing single emphase */
static size_t parse_emph2( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        uint8_t c )
{
    int (* render_method)( struct buf* ob, const struct buf* text, void* opaque );
    size_t i = 0, len;
    struct buf* work = 0;
    int r;

    render_method = (c == '~') ? rndr->cb.strikethrough : rndr->cb.double_emphasis;

    if( !render_method )
        return 0;

    while( i < size )
    {
        len = find_emph_char( data + i, size - i, c );

        if( !len )
            return 0;

        i += len;

        if( i + 1 < size && data[i] == c && data[i + 1] == c && i && !_isspace( data[i - 1] ) )
        {
            work = rndr_newbuf( rndr, BUFFER_SPAN );
            parse_inline( work, rndr, data, i );
            r = render_method( ob, work, rndr->opaque );
            rndr_popbuf( rndr, BUFFER_SPAN );
            return r ? i + 2 : 0;
        }

        i++;
    }

    return 0;
}


/* parse_emph3 • parsing single emphase */
/* finds the first closing tag, and delegates to the other emph */
static size_t parse_emph3( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        uint8_t c )
{
    size_t i = 0, len;
    int r;

    while( i < size )
    {
        len = find_emph_char( data + i, size - i, c );

        if( !len )
            return 0;

        i += len;

        /* skip whitespace preceded symbols */
        if( data[i] != c || _isspace( data[i - 1] ) )
            continue;

        if( i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->cb.triple_emphasis )
        {
            /* triple symbol found */
            struct buf* work = rndr_newbuf( rndr, BUFFER_SPAN );

            parse_inline( work, rndr, data, i );
            r = rndr->cb.triple_emphasis( ob, work, rndr->opaque );
            rndr_popbuf( rndr, BUFFER_SPAN );
            return r ? i + 3 : 0;
        }
        else if( i + 1 < size && data[i + 1] == c )
        {
            /* double symbol found, handing over to emph1 */
            len = parse_emph1( ob, rndr, data - 2, size + 2, c );

            if( !len )
                return 0;
            else
                return len - 2;
        }
        else
        {
            /* single symbol found, handing over to emph2 */
            len = parse_emph2( ob, rndr, data - 1, size + 1, c );

            if( !len )
                return 0;
            else
                return len - 1;
        }
    }

    return 0;
}


/* char_emphasis • single and double emphasis parsing */
static size_t char_emphasis( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    uint8_t c = data[0];
    size_t  ret;

    if( rndr->ext_flags & MKDEXT_NO_INTRA_EMPHASIS )
    {
        if( offset > 0 && !_isspace( data[-1] ) && data[-1] != '>' )
            return 0;
    }

    if( size > 2 && data[1] != c )
    {
        /* whitespace cannot follow an opening emphasis;
         * strikethrough only takes two characters '~~' */
        if( c == '~' || _isspace( data[1] )
            || ( ret = parse_emph1( ob, rndr, data + 1, size - 1, c ) ) == 0 )
            return 0;

        return ret + 1;
    }

    if( size > 3 && data[1] == c && data[2] != c )
    {
        if( _isspace( data[2] ) || ( ret = parse_emph2( ob, rndr, data + 2, size - 2, c ) ) == 0 )
            return 0;

        return ret + 2;
    }

    if( size > 4 && data[1] == c && data[2] == c && data[3] != c )
    {
        if( c == '~' || _isspace( data[3] )
            || ( ret = parse_emph3( ob, rndr, data + 3, size - 3, c ) ) == 0 )
            return 0;

        return ret + 3;
    }

    return 0;
}


/* char_linebreak • '\n' preceded by two spaces (assuming linebreak != 0) */
static size_t char_linebreak( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    if( offset < 2 || data[-1] != ' ' || data[-2] != ' ' )
        return 0;

    /* removing the last space from ob and rendering */
    while( ob->size && ob->data[ob->size - 1] == ' ' )
        ob->size--;

    return rndr->cb.linebreak( ob, rndr->opaque ) ? 1 : 0;
}


/* char_codespan • '`' parsing a code span (assuming codespan != 0) */
static size_t char_codespan( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    size_t end, nb = 0, i, f_begin, f_end;

    /* counting the number of backticks in the delimiter */
    while( nb < size && data[nb] == '`' )
        nb++;

    /* finding the next delimiter */
    i = 0;

    for( end = nb; end < size && i < nb; end++ )
    {
        if( data[end] == '`' )
            i++;
        else
            i = 0;
    }

    if( i < nb && end >= size )
        return 0;    /* no matching delimiter */

    /* trimming outside whitespaces */
    f_begin = nb;

    while( f_begin < end && data[f_begin] == ' ' )
        f_begin++;

    f_end = end - nb;

    while( f_end > nb && data[f_end - 1] == ' ' )
        f_end--;

    /* real code span */
    if( f_begin < f_end )
    {
        struct buf work = { data + f_begin, f_end - f_begin, 0, 0 };

        if( !rndr->cb.codespan( ob, &work, rndr->opaque ) )
            end = 0;
    }
    else
    {
        if( !rndr->cb.codespan( ob, 0, rndr->opaque ) )
            end = 0;
    }

    return end;
}


/* char_escape • '\\' backslash escape */
static size_t char_escape( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    static const char* escape_chars = "\\`*_{}[]()#+-.!:|&<>^~";
    struct buf work = { 0, 0, 0, 0 };

    if( size > 1 )
    {
        if( strchr( escape_chars, data[1] ) == NULL )
            return 0;

        if( rndr->cb.normal_text )
        {
            work.data = data + 1;
            work.size = 1;
            rndr->cb.normal_text( ob, &work, rndr->opaque );
        }
        else
            bufputc( ob, data[1] );
    }
    else if( size == 1 )
    {
        bufputc( ob, data[0] );
    }

    return 2;
}


/* char_entity • '&' escaped when it doesn't belong to an entity */
/* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */
static size_t char_entity( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    size_t end = 1;
    struct buf work = { 0, 0, 0, 0 };

    if( end < size && data[end] == '#' )
        end++;

    while( end < size && isalnum( data[end] ) )
        end++;

    if( end < size && data[end] == ';' )
        end++;      /* real entity */
    else
        return 0;   /* lone '&' */

    if( rndr->cb.entity )
    {
        work.data = data;
        work.size = end;
        rndr->cb.entity( ob, &work, rndr->opaque );
    }
    else
        bufput( ob, data, end );

    return end;
}


/* char_langle_tag • '<' when tags or autolinks are allowed */
static size_t char_langle_tag( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    enum mkd_autolink altype = MKDA_NOT_AUTOLINK;
    size_t end = tag_length( data, size, &altype );
    struct buf work = { data, end, 0, 0 };
    int ret = 0;

    if( end > 2 )
    {
        if( rndr->cb.autolink && altype != MKDA_NOT_AUTOLINK )
        {
            struct buf* u_link = rndr_newbuf( rndr, BUFFER_SPAN );
            work.data = data + 1;
            work.size = end - 2;
            unscape_text( u_link, &work );
            ret = rndr->cb.autolink( ob, u_link, altype, rndr->opaque );
            rndr_popbuf( rndr, BUFFER_SPAN );
        }
        else if( rndr->cb.raw_html_tag )
            ret = rndr->cb.raw_html_tag( ob, &work, rndr->opaque );
    }

    if( !ret )
        return 0;
    else
        return end;
}


static size_t char_autolink_www( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    struct buf* link, * link_url, * link_text;
    size_t link_len, rewind;

    if( !rndr->cb.link || rndr->in_link_body )
        return 0;

    link = rndr_newbuf( rndr, BUFFER_SPAN );

    if( ( link_len = sd_autolink__www( &rewind, link, data, offset, size, 0 ) ) > 0 )
    {
        link_url = rndr_newbuf( rndr, BUFFER_SPAN );
        BUFPUTSL( link_url, "http://" );
        bufput( link_url, link->data, link->size );

        ob->size -= rewind;

        if( rndr->cb.normal_text )
        {
            link_text = rndr_newbuf( rndr, BUFFER_SPAN );
            rndr->cb.normal_text( link_text, link, rndr->opaque );
            rndr->cb.link( ob, link_url, NULL, link_text, rndr->opaque );
            rndr_popbuf( rndr, BUFFER_SPAN );
        }
        else
        {
            rndr->cb.link( ob, link_url, NULL, link, rndr->opaque );
        }

        rndr_popbuf( rndr, BUFFER_SPAN );
    }

    rndr_popbuf( rndr, BUFFER_SPAN );
    return link_len;
}


static size_t char_autolink_email( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    struct buf* link;
    size_t link_len, rewind;

    if( !rndr->cb.autolink || rndr->in_link_body )
        return 0;

    link = rndr_newbuf( rndr, BUFFER_SPAN );

    if( ( link_len = sd_autolink__email( &rewind, link, data, offset, size, 0 ) ) > 0 )
    {
        ob->size -= rewind;
        rndr->cb.autolink( ob, link, MKDA_EMAIL, rndr->opaque );
    }

    rndr_popbuf( rndr, BUFFER_SPAN );
    return link_len;
}


static size_t char_autolink_url( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    struct buf* link;
    size_t link_len, rewind;

    if( !rndr->cb.autolink || rndr->in_link_body )
        return 0;

    link = rndr_newbuf( rndr, BUFFER_SPAN );

    if( ( link_len = sd_autolink__url( &rewind, link, data, offset, size, 0 ) ) > 0 )
    {
        ob->size -= rewind;
        rndr->cb.autolink( ob, link, MKDA_NORMAL, rndr->opaque );
    }

    rndr_popbuf( rndr, BUFFER_SPAN );
    return link_len;
}


/* char_link • '[': parsing a link or an image */
static size_t char_link( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    int is_img = (offset && data[-1] == '!'), level;
    size_t i = 1, txt_e, link_b = 0, link_e = 0, title_b = 0, title_e = 0;
    struct buf* content     = 0;
    struct buf* link        = 0;
    struct buf* title       = 0;
    struct buf* u_link      = 0;
    size_t org_work_size    = rndr->work_bufs[BUFFER_SPAN].size;
    int text_has_nl = 0, ret = 0;
    int in_title = 0, qtype = 0;

    /* checking whether the correct renderer exists */
    if( (is_img && !rndr->cb.image) || (!is_img && !rndr->cb.link) )
        goto cleanup;

    /* looking for the matching closing bracket */
    for( level = 1; i < size; i++ )
    {
        if( data[i] == '\n' )
            text_has_nl = 1;

        else if( data[i - 1] == '\\' )
            continue;

        else if( data[i] == '[' )
            level++;

        else if( data[i] == ']' )
        {
            level--;

            if( level <= 0 )
                break;
        }
    }

    if( i >= size )
        goto cleanup;

    txt_e = i;
    i++;

    /* skip any amount of whitespace or newline */
    /* (this is much more laxist than original markdown syntax) */
    while( i < size && _isspace( data[i] ) )
        i++;

    /* inline style link */
    if( i < size && data[i] == '(' )
    {
        /* skipping initial whitespace */
        i++;

        while( i < size && _isspace( data[i] ) )
            i++;

        link_b = i;

        /* looking for link end: ' " ) */
        while( i < size )
        {
            if( data[i] == '\\' )
                i += 2;
            else if( data[i] == ')' )
                break;
            else if( i >= 1 && _isspace( data[i - 1] ) && (data[i] == '\'' || data[i] == '"') )
                break;
            else
                i++;
        }

        if( i >= size )
            goto cleanup;

        link_e = i;

        /* looking for title end if present */
        if( data[i] == '\'' || data[i] == '"' )
        {
            qtype = data[i];
            in_title = 1;
            i++;
            title_b = i;

            while( i < size )
            {
                if( data[i] == '\\' )
                    i += 2;
                else if( data[i] == qtype )
                {
                    in_title = 0; i++;
                }
                else if( (data[i] == ')') && !in_title )
                    break;
                else
                    i++;
            }

            if( i >= size )
                goto cleanup;

            /* skipping whitespaces after title */
            title_e = i - 1;

            while( title_e > title_b && _isspace( data[title_e] ) )
                title_e--;

            /* checking for closing quote presence */
            if( data[title_e] != '\'' &&  data[title_e] != '"' )
            {
                title_b = title_e = 0;
                link_e  = i;
            }
        }

        /* remove whitespace at the end of the link */
        while( link_e > link_b && _isspace( data[link_e - 1] ) )
            link_e--;

        /* remove optional angle brackets around the link */
        if( data[link_b] == '<' )
            link_b++;

        if( data[link_e - 1] == '>' )
            link_e--;

        /* building escaped link and title */
        if( link_e > link_b )
        {
            link = rndr_newbuf( rndr, BUFFER_SPAN );
            bufput( link, data + link_b, link_e - link_b );
        }

        if( title_e > title_b )
        {
            title = rndr_newbuf( rndr, BUFFER_SPAN );
            bufput( title, data + title_b, title_e - title_b );
        }

        i++;
    }
    /* reference style link */
    else if( i < size && data[i] == '[' )
    {
        struct buf id = { 0, 0, 0, 0 };
        struct link_ref* lr;

        /* looking for the id */
        i++;
        link_b = i;

        while( i < size && data[i] != ']' )
            i++;

        if( i >= size )
            goto cleanup;

        link_e = i;

        /* finding the link_ref */
        if( link_b == link_e )
        {
            if( text_has_nl )
            {
                struct buf* b = rndr_newbuf( rndr, BUFFER_SPAN );
                size_t j;

                for( j = 1; j < txt_e; j++ )
                {
                    if( data[j] != '\n' )
                        bufputc( b, data[j] );
                    else if( data[j - 1] != ' ' )
                        bufputc( b, ' ' );
                }

                id.data = b->data;
                id.size = b->size;
            }
            else
            {
                id.data = data + 1;
                id.size = txt_e - 1;
            }
        }
        else
        {
            id.data = data + link_b;
            id.size = link_e - link_b;
        }

        lr = find_link_ref( rndr->refs, id.data, id.size );

        if( !lr )
            goto cleanup;

        /* keeping link and title from link_ref */
        link = lr->link;
        title = lr->title;
        i++;
    }
    /* shortcut reference style link */
    else
    {
        struct buf id = { 0, 0, 0, 0 };
        struct link_ref* lr;

        /* crafting the id */
        if( text_has_nl )
        {
            struct buf* b = rndr_newbuf( rndr, BUFFER_SPAN );
            size_t j;

            for( j = 1; j < txt_e; j++ )
            {
                if( data[j] != '\n' )
                    bufputc( b, data[j] );
                else if( data[j - 1] != ' ' )
                    bufputc( b, ' ' );
            }

            id.data = b->data;
            id.size = b->size;
        }
        else
        {
            id.data = data + 1;
            id.size = txt_e - 1;
        }

        /* finding the link_ref */
        lr = find_link_ref( rndr->refs, id.data, id.size );

        if( !lr )
            goto cleanup;

        /* keeping link and title from link_ref */
        link = lr->link;
        title = lr->title;

        /* rewinding the whitespace */
        i = txt_e + 1;
    }

    /* building content: img alt is escaped, link content is parsed */
    if( txt_e > 1 )
    {
        content = rndr_newbuf( rndr, BUFFER_SPAN );

        if( is_img )
        {
            bufput( content, data + 1, txt_e - 1 );
        }
        else
        {
            /* disable autolinking when parsing inline the
             * content of a link */
            rndr->in_link_body = 1;
            parse_inline( content, rndr, data + 1, txt_e - 1 );
            rndr->in_link_body = 0;
        }
    }

    if( link )
    {
        u_link = rndr_newbuf( rndr, BUFFER_SPAN );
        unscape_text( u_link, link );
    }

    /* calling the relevant rendering function */
    if( is_img )
    {
        if( ob->size && ob->data[ob->size - 1] == '!' )
            ob->size -= 1;

        ret = rndr->cb.image( ob, u_link, title, content, rndr->opaque );
    }
    else
    {
        ret = rndr->cb.link( ob, u_link, title, content, rndr->opaque );
    }

    /* cleanup */
cleanup:
    rndr->work_bufs[BUFFER_SPAN].size = (int) org_work_size;
    return ret ? i : 0;
}


static size_t char_superscript( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t offset,
        size_t size )
{
    size_t sup_start, sup_len;
    struct buf* sup;

    if( !rndr->cb.superscript )
        return 0;

    if( size < 2 )
        return 0;

    if( data[1] == '(' )
    {
        sup_start = sup_len = 2;

        while( sup_len < size && data[sup_len] != ')' && data[sup_len - 1] != '\\' )
            sup_len++;

        if( sup_len == size )
            return 0;
    }
    else
    {
        sup_start = sup_len = 1;

        while( sup_len < size && !_isspace( data[sup_len] ) )
            sup_len++;
    }

    if( sup_len - sup_start == 0 )
        return (sup_start == 2) ? 3 : 0;

    sup = rndr_newbuf( rndr, BUFFER_SPAN );
    parse_inline( sup, rndr, data + sup_start, sup_len - sup_start );
    rndr->cb.superscript( ob, sup, rndr->opaque );
    rndr_popbuf( rndr, BUFFER_SPAN );

    return (sup_start == 2) ? sup_len + 1 : sup_len;
}


/*********************************
* BLOCK-LEVEL PARSING FUNCTIONS *
*********************************/

/* is_empty • returns the line length when it is empty, 0 otherwise */
static size_t is_empty( uint8_t* data, size_t size )
{
    size_t i;

    for( i = 0; i < size && data[i] != '\n'; i++ )
        if( data[i] != ' ' )
            return 0;



    return i + 1;
}


/* is_hrule • returns whether a line is a horizontal rule */
static int is_hrule( uint8_t* data, size_t size )
{
    size_t i = 0, n = 0;
    uint8_t c;

    /* skipping initial spaces */
    if( size < 3 )
        return 0;

    if( data[0] == ' ' )
    {
        i++;

        if( data[1] == ' ' )
        {
            i++;

            if( data[2] == ' ' )
            {
                i++;
            }
        }
    }

    /* looking at the hrule uint8_t */
    if( i + 2 >= size
        || (data[i] != '*' && data[i] != '-' && data[i] != '_') )
        return 0;

    c = data[i];

    /* the whole line must be the char or whitespace */
    while( i < size && data[i] != '\n' )
    {
        if( data[i] == c )
            n++;
        else if( data[i] != ' ' )
            return 0;

        i++;
    }

    return n >= 3;
}


/* check if a line begins with a code fence; return the
 * width of the code fence */
static size_t prefix_codefence( uint8_t* data, size_t size )
{
    size_t i = 0, n = 0;
    uint8_t c;

    /* skipping initial spaces */
    if( size < 3 )
        return 0;

    if( data[0] == ' ' )
    {
        i++;

        if( data[1] == ' ' )
        {
            i++;

            if( data[2] == ' ' )
            {
                i++;
            }
        }
    }

    /* looking at the hrule uint8_t */
    if( i + 2 >= size || !(data[i] == '~' || data[i] == '`') )
        return 0;

    c = data[i];

    /* the whole line must be the uint8_t or whitespace */
    while( i < size && data[i] == c )
    {
        n++; i++;
    }

    if( n < 3 )
        return 0;

    return i;
}


/* check if a line is a code fence; return its size if it is */
static size_t is_codefence( uint8_t* data, size_t size, struct buf* syntax )
{
    size_t i = 0, syn_len = 0;
    uint8_t* syn_start;

    i = prefix_codefence( data, size );

    if( i == 0 )
        return 0;

    while( i < size && data[i] == ' ' )
        i++;

    syn_start = data + i;

    if( i < size && data[i] == '{' )
    {
        i++; syn_start++;

        while( i < size && data[i] != '}' && data[i] != '\n' )
        {
            syn_len++; i++;
        }

        if( i == size || data[i] != '}' )
            return 0;

        /* strip all whitespace at the beginning and the end
         * of the {} block */
        while( syn_len > 0 && _isspace( syn_start[0] ) )
        {
            syn_start++; syn_len--;
        }

        while( syn_len > 0 && _isspace( syn_start[syn_len - 1] ) )
            syn_len--;

        i++;
    }
    else
    {
        while( i < size && !_isspace( data[i] ) )
        {
            syn_len++; i++;
        }
    }

    if( syntax )
    {
        syntax->data = syn_start;
        syntax->size = syn_len;
    }

    while( i < size && data[i] != '\n' )
    {
        if( !_isspace( data[i] ) )
            return 0;

        i++;
    }

    return i + 1;
}


/* is_atxheader • returns whether the line is a hash-prefixed header */
static int is_atxheader( struct sd_markdown* rndr, uint8_t* data, size_t size )
{
    if( data[0] != '#' )
        return 0;

    if( rndr->ext_flags & MKDEXT_SPACE_HEADERS )
    {
        size_t level = 0;

        while( level < size && level < 6 && data[level] == '#' )
            level++;

        if( level < size && data[level] != ' ' )
            return 0;
    }

    return 1;
}


/* is_headerline • returns whether the line is a setext-style hdr underline */
static int is_headerline( uint8_t* data, size_t size )
{
    size_t i = 0;

    /* test of level 1 header */
    if( data[i] == '=' )
    {
        for( i = 1; i < size && data[i] == '='; i++ )
            ;

        while( i < size && data[i] == ' ' )
            i++;

        return (i >= size || data[i] == '\n') ? 1 : 0;
    }

    /* test of level 2 header */
    if( data[i] == '-' )
    {
        for( i = 1; i < size && data[i] == '-'; i++ )
            ;

        while( i < size && data[i] == ' ' )
            i++;

        return (i >= size || data[i] == '\n') ? 2 : 0;
    }

    return 0;
}


static int is_next_headerline( uint8_t* data, size_t size )
{
    size_t i = 0;

    while( i < size && data[i] != '\n' )
        i++;

    if( ++i >= size )
        return 0;

    return is_headerline( data + i, size - i );
}


/* prefix_quote • returns blockquote prefix length */
static size_t prefix_quote( uint8_t* data, size_t size )
{
    size_t i = 0;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == '>' )
    {
        if( i + 1 < size && data[i + 1] == ' ' )
            return i + 2;

        return i + 1;
    }

    return 0;
}


/* prefix_code • returns prefix length for block code*/
static size_t prefix_code( uint8_t* data, size_t size )
{
    if( size > 3 && data[0] == ' ' && data[1] == ' '
        && data[2] == ' ' && data[3] == ' ' )
        return 4;

    return 0;
}


/* prefix_oli • returns ordered list item prefix */
static size_t prefix_oli( uint8_t* data, size_t size )
{
    size_t i = 0;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i >= size || data[i] < '0' || data[i] > '9' )
        return 0;

    while( i < size && data[i] >= '0' && data[i] <= '9' )
        i++;

    if( i + 1 >= size || data[i] != '.' || data[i + 1] != ' ' )
        return 0;

    if( is_next_headerline( data + i, size - i ) )
        return 0;

    return i + 2;
}


/* prefix_uli • returns ordered list item prefix */
static size_t prefix_uli( uint8_t* data, size_t size )
{
    size_t i = 0;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i < size && data[i] == ' ' )
        i++;

    if( i + 1 >= size
        || (data[i] != '*' && data[i] != '+' && data[i] != '-')
        || data[i + 1] != ' ' )
        return 0;

    if( is_next_headerline( data + i, size - i ) )
        return 0;

    return i + 2;
}


/* parse_block • parsing of one block, returning next uint8_t to parse */
static void parse_block( struct buf* ob, struct sd_markdown* rndr,
        uint8_t* data, size_t size );


/* parse_blockquote • handles parsing of a blockquote fragment */
static size_t parse_blockquote( struct buf* ob, struct sd_markdown* rndr, uint8_t* data,
        size_t size )
{
    size_t beg, end = 0, pre, work_size = 0;
    uint8_t* work_data = 0;
    struct buf* out = 0;

    out = rndr_newbuf( rndr, BUFFER_BLOCK );
    beg = 0;

    while( beg < size )
    {
        for( end = beg + 1; end < size && data[end - 1] != '\n'; end++ )
            ;

        pre = prefix_quote( data + beg, end - beg );

        if( pre )
            beg += pre;    /* skipping prefix */

        /* empty line followed by non-quote line */
        else if( is_empty( data + beg, end - beg )
                 && ( end >= size || ( prefix_quote( data + end, size - end ) == 0
                                       && !is_empty( data + end, size - end ) ) ) )
            break;

        if( beg < end )    /* copy into the in-place working buffer */
        {
            /* bufput(work, data + beg, end - beg); */
            if( !work_data )
                work_data = data + beg;
            else if( data + beg != work_data + work_size )
                memmove( work_data + work_size, data + beg, end - beg );

            work_size += end - beg;
        }

        beg = end;
    }

    parse_block( out, rndr, work_data, work_size );

    if( rndr->cb.blockquote )
        rndr->cb.blockquote( ob, out, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_BLOCK );
    return end;
}


static size_t parse_htmlblock( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        int do_render );

/* parse_blockquote • handles parsing of a regular paragraph */
static size_t parse_paragraph( struct buf* ob, struct sd_markdown* rndr, uint8_t* data,
        size_t size )
{
    size_t i = 0, end = 0;
    int level = 0;
    struct buf work = { data, 0, 0, 0 };

    while( i < size )
    {
        for( end = i + 1; end < size && data[end - 1] != '\n'; end++ )    /* empty */
            ;

        if( is_empty( data + i, size - i ) )
            break;

        if( ( level = is_headerline( data + i, size - i ) ) != 0 )
            break;

        if( is_atxheader( rndr, data + i, size - i )
            || is_hrule( data + i, size - i )
            || prefix_quote( data + i, size - i ) )
        {
            end = i;
            break;
        }

        /*
         * Early termination of a paragraph with the same logic
         * as Markdown 1.0.0. If this logic is applied, the
         * Markdown 1.0.3 test suite won't pass cleanly
         *
         * :: If the first character in a new line is not a letter,
         * let's check to see if there's some kind of block starting
         * here
         */
        if( (rndr->ext_flags & MKDEXT_LAX_SPACING) && !isalnum( data[i] ) )
        {
            if( prefix_oli( data + i, size - i )
                || prefix_uli( data + i, size - i ) )
            {
                end = i;
                break;
            }

            /* see if an html block starts here */
            if( data[i] == '<' && rndr->cb.blockhtml
                && parse_htmlblock( ob, rndr, data + i, size - i, 0 ) )
            {
                end = i;
                break;
            }

            /* see if a code fence starts here */
            if( (rndr->ext_flags & MKDEXT_FENCED_CODE) != 0
                && is_codefence( data + i, size - i, NULL ) != 0 )
            {
                end = i;
                break;
            }
        }

        i = end;
    }

    work.size = i;

    while( work.size && data[work.size - 1] == '\n' )
        work.size--;

    if( !level )
    {
        struct buf* tmp = rndr_newbuf( rndr, BUFFER_BLOCK );
        parse_inline( tmp, rndr, work.data, work.size );

        if( rndr->cb.paragraph )
            rndr->cb.paragraph( ob, tmp, rndr->opaque );

        rndr_popbuf( rndr, BUFFER_BLOCK );
    }
    else
    {
        struct buf* header_work;

        if( work.size )
        {
            size_t beg;
            i = work.size;
            work.size -= 1;

            while( work.size && data[work.size] != '\n' )
                work.size -= 1;

            beg = work.size + 1;

            while( work.size && data[work.size - 1] == '\n' )
                work.size -= 1;

            if( work.size > 0 )
            {
                struct buf* tmp = rndr_newbuf( rndr, BUFFER_BLOCK );
                parse_inline( tmp, rndr, work.data, work.size );

                if( rndr->cb.paragraph )
                    rndr->cb.paragraph( ob, tmp, rndr->opaque );

                rndr_popbuf( rndr, BUFFER_BLOCK );
                work.data += beg;
                work.size = i - beg;
            }
            else
                work.size = i;
        }

        header_work = rndr_newbuf( rndr, BUFFER_SPAN );
        parse_inline( header_work, rndr, work.data, work.size );

        if( rndr->cb.header )
            rndr->cb.header( ob, header_work, (int) level, rndr->opaque );

        rndr_popbuf( rndr, BUFFER_SPAN );
    }

    return end;
}


/* parse_fencedcode • handles parsing of a block-level code fragment */
static size_t parse_fencedcode( struct buf* ob, struct sd_markdown* rndr, uint8_t* data,
        size_t size )
{
    size_t beg, end;
    struct buf* work = 0;
    struct buf  lang = { 0, 0, 0, 0 };

    beg = is_codefence( data, size, &lang );

    if( beg == 0 )
        return 0;

    work = rndr_newbuf( rndr, BUFFER_BLOCK );

    while( beg < size )
    {
        size_t fence_end;
        struct buf fence_trail = { 0, 0, 0, 0 };

        fence_end = is_codefence( data + beg, size - beg, &fence_trail );

        if( fence_end != 0 && fence_trail.size == 0 )
        {
            beg += fence_end;
            break;
        }

        for( end = beg + 1; end < size && data[end - 1] != '\n'; end++ )
            ;

        if( beg < end )
        {
            /* verbatim copy to the working buffer,
             *   escaping entities */
            if( is_empty( data + beg, end - beg ) )
                bufputc( work, '\n' );
            else
                bufput( work, data + beg, end - beg );
        }

        beg = end;
    }

    if( work->size && work->data[work->size - 1] != '\n' )
        bufputc( work, '\n' );

    if( rndr->cb.blockcode )
        rndr->cb.blockcode( ob, work, lang.size ? &lang : NULL, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_BLOCK );
    return beg;
}


static size_t parse_blockcode( struct buf* ob, struct sd_markdown* rndr, uint8_t* data,
        size_t size )
{
    size_t beg, end, pre;
    struct buf* work = 0;

    work = rndr_newbuf( rndr, BUFFER_BLOCK );

    beg = 0;

    while( beg < size )
    {
        for( end = beg + 1; end < size && data[end - 1] != '\n'; end++ )
        {
        }

        ;
        pre = prefix_code( data + beg, end - beg );

        if( pre )
            beg += pre;    /* skipping prefix */
        else if( !is_empty( data + beg, end - beg ) )
            /* non-empty non-prefixed line breaks the pre */
            break;

        if( beg < end )
        {
            /* verbatim copy to the working buffer,
             *   escaping entities */
            if( is_empty( data + beg, end - beg ) )
                bufputc( work, '\n' );
            else
                bufput( work, data + beg, end - beg );
        }

        beg = end;
    }

    while( work->size && work->data[work->size - 1] == '\n' )
        work->size -= 1;

    bufputc( work, '\n' );

    if( rndr->cb.blockcode )
        rndr->cb.blockcode( ob, work, NULL, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_BLOCK );
    return beg;
}


/* parse_listitem • parsing of a single list item */
/*	assuming initial prefix is already removed */
static size_t parse_listitem( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        int* flags )
{
    struct buf* work = 0, * inter = 0;
    size_t beg = 0, end, pre, sublist = 0, orgpre = 0, i;
    int in_empty = 0, has_inside_empty = 0, in_fence = 0;

    /* keeping track of the first indentation prefix */
    while( orgpre < 3 && orgpre < size && data[orgpre] == ' ' )
        orgpre++;

    beg = prefix_uli( data, size );

    if( !beg )
        beg = prefix_oli( data, size );

    if( !beg )
        return 0;

    /* skipping to the beginning of the following line */
    end = beg;

    while( end < size && data[end - 1] != '\n' )
        end++;

    /* getting working buffers */
    work = rndr_newbuf( rndr, BUFFER_SPAN );
    inter = rndr_newbuf( rndr, BUFFER_SPAN );

    /* putting the first line into the working buffer */
    bufput( work, data + beg, end - beg );
    beg = end;

    /* process the following lines */
    while( beg < size )
    {
        size_t has_next_uli = 0, has_next_oli = 0;

        end++;

        while( end < size && data[end - 1] != '\n' )
            end++;

        /* process an empty line */
        if( is_empty( data + beg, end - beg ) )
        {
            in_empty = 1;
            beg = end;
            continue;
        }

        /* calculating the indentation */
        i = 0;

        while( i < 4 && beg + i < end && data[beg + i] == ' ' )
            i++;

        pre = i;

        if( rndr->ext_flags & MKDEXT_FENCED_CODE )
        {
            if( is_codefence( data + beg + i, end - beg - i, NULL ) != 0 )
                in_fence = !in_fence;
        }

        /* Only check for new list items if we are **not** inside
         * a fenced code block */
        if( !in_fence )
        {
            has_next_uli = prefix_uli( data + beg + i, end - beg - i );
            has_next_oli = prefix_oli( data + beg + i, end - beg - i );
        }

        /* checking for ul/ol switch */
        if( in_empty && (
                ( (*flags & MKD_LIST_ORDERED) && has_next_uli )
                || (!(*flags & MKD_LIST_ORDERED) && has_next_oli) ) )
        {
            *flags |= MKD_LI_END;
            break;    /* the following item must have same list type */
        }

        /* checking for a new item */
        if( ( has_next_uli && !is_hrule( data + beg + i, end - beg - i ) ) || has_next_oli )
        {
            if( in_empty )
                has_inside_empty = 1;

            if( pre == orgpre )     /* the following item must have */
                break;              /* the same indentation */

            if( !sublist )
                sublist = work->size;
        }
        /* joining only indented stuff after empty lines;
         * note that now we only require 1 space of indentation
         * to continue a list */
        else if( in_empty && pre == 0 )
        {
            *flags |= MKD_LI_END;
            break;
        }
        else if( in_empty )
        {
            bufputc( work, '\n' );
            has_inside_empty = 1;
        }

        in_empty = 0;

        /* adding the line without prefix into the working buffer */
        bufput( work, data + beg + i, end - beg - i );
        beg = end;
    }

    /* render of li contents */
    if( has_inside_empty )
        *flags |= MKD_LI_BLOCK;

    if( *flags & MKD_LI_BLOCK )
    {
        /* intermediate render of block li */
        if( sublist && sublist < work->size )
        {
            parse_block( inter, rndr, work->data, sublist );
            parse_block( inter, rndr, work->data + sublist, work->size - sublist );
        }
        else
            parse_block( inter, rndr, work->data, work->size );
    }
    else
    {
        /* intermediate render of inline li */
        if( sublist && sublist < work->size )
        {
            parse_inline( inter, rndr, work->data, sublist );
            parse_block( inter, rndr, work->data + sublist, work->size - sublist );
        }
        else
            parse_inline( inter, rndr, work->data, work->size );
    }

    /* render of li itself */
    if( rndr->cb.listitem )
        rndr->cb.listitem( ob, inter, *flags, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_SPAN );
    rndr_popbuf( rndr, BUFFER_SPAN );
    return beg;
}


/* parse_list • parsing ordered or unordered list block */
static size_t parse_list( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        int flags )
{
    struct buf* work = 0;
    size_t i = 0, j;

    work = rndr_newbuf( rndr, BUFFER_BLOCK );

    while( i < size )
    {
        j = parse_listitem( work, rndr, data + i, size - i, &flags );
        i += j;

        if( !j || (flags & MKD_LI_END) )
            break;
    }

    if( rndr->cb.list )
        rndr->cb.list( ob, work, flags, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_BLOCK );
    return i;
}


/* parse_atxheader • parsing of atx-style headers */
static size_t parse_atxheader( struct buf* ob, struct sd_markdown* rndr, uint8_t* data,
        size_t size )
{
    size_t level = 0;
    size_t i, end, skip;

    while( level < size && level < 6 && data[level] == '#' )
        level++;

    for( i = level; i < size && data[i] == ' '; i++ )
        ;

    for( end = i; end < size && data[end] != '\n'; end++ )
        ;

    skip = end;

    while( end && data[end - 1] == '#' )
        end--;

    while( end && data[end - 1] == ' ' )
        end--;

    if( end > i )
    {
        struct buf* work = rndr_newbuf( rndr, BUFFER_SPAN );

        parse_inline( work, rndr, data + i, end - i );

        if( rndr->cb.header )
            rndr->cb.header( ob, work, (int) level, rndr->opaque );

        rndr_popbuf( rndr, BUFFER_SPAN );
    }

    return skip;
}


/* htmlblock_end • checking end of HTML block : </tag>[ \t]*\n[ \t*]\n */
/*	returns the length on match, 0 otherwise */
static size_t htmlblock_end_tag( const char* tag,
        size_t tag_len,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size )
{
    size_t i, w;

    /* checking if tag is a match */
    if( tag_len + 3 >= size
        || strncasecmp( (char*) data + 2, tag, tag_len ) != 0
        || data[tag_len + 2] != '>' )
        return 0;

    /* checking white lines */
    i = tag_len + 3;
    w = 0;

    if( i < size && ( w = is_empty( data + i, size - i ) ) == 0 )
        return 0;    /* non-blank after tag */

    i += w;
    w = 0;

    if( i < size )
        w = is_empty( data + i, size - i );

    return i + w;
}


static size_t htmlblock_end( const char* curtag,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        int start_of_line )
{
    size_t tag_size = strlen( curtag );
    size_t i = 1, end_tag;
    int block_lines = 0;

    while( i < size )
    {
        i++;

        while( i < size && !(data[i - 1] == '<' && data[i] == '/') )
        {
            if( data[i] == '\n' )
                block_lines++;

            i++;
        }

        /* If we are only looking for unindented tags, skip the tag
         * if it doesn't follow a newline.
         *
         * The only exception to this is if the tag is still on the
         * initial line; in that case it still counts as a closing
         * tag
         */
        if( start_of_line && block_lines > 0 && data[i - 2] != '\n' )
            continue;

        if( i + 2 + tag_size >= size )
            break;

        end_tag = htmlblock_end_tag( curtag, tag_size, rndr, data + i - 1, size - i + 1 );

        if( end_tag )
            return i + end_tag - 1;
    }

    return 0;
}


/* parse_htmlblock • parsing of inline HTML block */
static size_t parse_htmlblock( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        int do_render )
{
    size_t i, j = 0, tag_end;
    const char* curtag = NULL;
    struct buf  work = { data, 0, 0, 0 };

    /* identification of the opening tag */
    if( size < 2 || data[0] != '<' )
        return 0;

    i = 1;

    while( i < size && data[i] != '>' && data[i] != ' ' )
        i++;

    if( i < size )
        curtag = find_block_tag( (char*) data + 1, (int) i - 1 );

    /* handling of special cases */
    if( !curtag )
    {
        /* HTML comment, laxist form */
        if( size > 5 && data[1] == '!' && data[2] == '-' && data[3] == '-' )
        {
            i = 5;

            while( i < size && !(data[i - 2] == '-' && data[i - 1] == '-' && data[i] == '>') )
                i++;

            i++;

            if( i < size )
                j = is_empty( data + i, size - i );

            if( j )
            {
                work.size = i + j;

                if( do_render && rndr->cb.blockhtml )
                    rndr->cb.blockhtml( ob, &work, rndr->opaque );

                return work.size;
            }
        }

        /* HR, which is the only self-closing block tag considered */
        if( size > 4 && (data[1] == 'h' || data[1] == 'H') && (data[2] == 'r' || data[2] == 'R') )
        {
            i = 3;

            while( i < size && data[i] != '>' )
                i++;

            if( i + 1 < size )
            {
                i++;
                j = is_empty( data + i, size - i );

                if( j )
                {
                    work.size = i + j;

                    if( do_render && rndr->cb.blockhtml )
                        rndr->cb.blockhtml( ob, &work, rndr->opaque );

                    return work.size;
                }
            }
        }

        /* no special case recognised */
        return 0;
    }

    /* looking for an unindented matching closing tag */
    /*	followed by a blank line */
    tag_end = htmlblock_end( curtag, rndr, data, size, 1 );

    /* if not found, trying a second pass looking for indented match */
    /* but not if tag is "ins" or "del" (following original Markdown.pl) */
    if( !tag_end && strcmp( curtag, "ins" ) != 0 && strcmp( curtag, "del" ) != 0 )
    {
        tag_end = htmlblock_end( curtag, rndr, data, size, 0 );
    }

    if( !tag_end )
        return 0;

    /* the end of the block has been found */
    work.size = tag_end;

    if( do_render && rndr->cb.blockhtml )
        rndr->cb.blockhtml( ob, &work, rndr->opaque );

    return tag_end;
}


static void parse_table_row( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        size_t columns,
        int* col_data,
        int header_flag )
{
    size_t i = 0, col;
    struct buf* row_work = 0;

    if( !rndr->cb.table_cell || !rndr->cb.table_row )
        return;

    row_work = rndr_newbuf( rndr, BUFFER_SPAN );

    if( i < size && data[i] == '|' )
        i++;

    for( col = 0; col < columns && i < size; ++col )
    {
        size_t cell_start, cell_end;
        struct buf* cell_work;

        cell_work = rndr_newbuf( rndr, BUFFER_SPAN );

        while( i < size && _isspace( data[i] ) )
            i++;

        cell_start = i;

        while( i < size && data[i] != '|' )
            i++;

        cell_end = i - 1;

        while( cell_end > cell_start && _isspace( data[cell_end] ) )
            cell_end--;

        parse_inline( cell_work, rndr, data + cell_start, 1 + cell_end - cell_start );
        rndr->cb.table_cell( row_work, cell_work, col_data[col] | header_flag, rndr->opaque );

        rndr_popbuf( rndr, BUFFER_SPAN );
        i++;
    }

    for( ; col < columns; ++col )
    {
        struct buf empty_cell = { 0, 0, 0, 0 };
        rndr->cb.table_cell( row_work, &empty_cell, col_data[col] | header_flag, rndr->opaque );
    }

    rndr->cb.table_row( ob, row_work, rndr->opaque );

    rndr_popbuf( rndr, BUFFER_SPAN );
}


static size_t parse_table_header( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size,
        size_t* columns,
        int** column_data )
{
    int pipes;
    size_t i = 0, col, header_end, under_end;

    pipes = 0;

    while( i < size && data[i] != '\n' )
        if( data[i++] == '|' )
            pipes++;



    if( i == size || pipes == 0 )
        return 0;

    header_end = i;

    while( header_end > 0 && _isspace( data[header_end - 1] ) )
        header_end--;

    if( data[0] == '|' )
        pipes--;

    if( header_end && data[header_end - 1] == '|' )
        pipes--;

    *columns = pipes + 1;
    *column_data = calloc( *columns, sizeof(int) );

    /* Parse the header underline */
    i++;

    if( i < size && data[i] == '|' )
        i++;

    under_end = i;

    while( under_end < size && data[under_end] != '\n' )
        under_end++;

    for( col = 0; col < *columns && i < under_end; ++col )
    {
        size_t dashes = 0;

        while( i < under_end && data[i] == ' ' )
            i++;

        if( data[i] == ':' )
        {
            i++; (*column_data)[col] |= MKD_TABLE_ALIGN_L;
            dashes++;
        }

        while( i < under_end && data[i] == '-' )
        {
            i++; dashes++;
        }

        if( i < under_end && data[i] == ':' )
        {
            i++; (*column_data)[col] |= MKD_TABLE_ALIGN_R;
            dashes++;
        }

        while( i < under_end && data[i] == ' ' )
            i++;

        if( i < under_end && data[i] != '|' )
            break;

        if( dashes < 3 )
            break;

        i++;
    }

    if( col < *columns )
        return 0;

    parse_table_row(
            ob, rndr, data,
            header_end,
            *columns,
            *column_data,
            MKD_TABLE_HEADER
            );

    return under_end + 1;
}


static size_t parse_table( struct buf* ob,
        struct sd_markdown* rndr,
        uint8_t* data,
        size_t size )
{
    size_t i;

    struct buf* header_work = 0;
    struct buf* body_work = 0;

    size_t columns;
    int* col_data = NULL;

    header_work = rndr_newbuf( rndr, BUFFER_SPAN );
    body_work = rndr_newbuf( rndr, BUFFER_BLOCK );

    i = parse_table_header( header_work, rndr, data, size, &columns, &col_data );

    if( i > 0 )
    {
        while( i < size )
        {
            size_t row_start;
            int pipes = 0;

            row_start = i;

            while( i < size && data[i] != '\n' )
                if( data[i++] == '|' )
                    pipes++;



            if( pipes == 0 || i == size )
            {
                i = row_start;
                break;
            }

            parse_table_row(
                    body_work,
                    rndr,
                    data + row_start,
                    i - row_start,
                    columns,
                    col_data, 0
                    );

            i++;
        }

        if( rndr->cb.table )
            rndr->cb.table( ob, header_work, body_work, rndr->opaque );
    }

    free( col_data );
    rndr_popbuf( rndr, BUFFER_SPAN );
    rndr_popbuf( rndr, BUFFER_BLOCK );
    return i;
}


/* parse_block • parsing of one block, returning next uint8_t to parse */
static void parse_block( struct buf* ob, struct sd_markdown* rndr, uint8_t* data, size_t size )
{
    size_t beg, end, i;
    uint8_t* txt_data;

    beg = 0;

    if( rndr->work_bufs[BUFFER_SPAN].size +
        rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting )
        return;

    while( beg < size )
    {
        txt_data = data + beg;
        end = size - beg;

        if( is_atxheader( rndr, txt_data, end ) )
            beg += parse_atxheader( ob, rndr, txt_data, end );

        else if( data[beg] == '<' && rndr->cb.blockhtml
                 && ( i = parse_htmlblock( ob, rndr, txt_data, end, 1 ) ) != 0 )
            beg += i;

        else if( ( i = is_empty( txt_data, end ) ) != 0 )
            beg += i;

        else if( is_hrule( txt_data, end ) )
        {
            if( rndr->cb.hrule )
                rndr->cb.hrule( ob, rndr->opaque );

            while( beg < size && data[beg] != '\n' )
                beg++;

            beg++;
        }
        else if( (rndr->ext_flags & MKDEXT_FENCED_CODE) != 0
                 && ( i = parse_fencedcode( ob, rndr, txt_data, end ) ) != 0 )
            beg += i;

        else if( (rndr->ext_flags & MKDEXT_TABLES) != 0
                 && ( i = parse_table( ob, rndr, txt_data, end ) ) != 0 )
            beg += i;

        else if( prefix_quote( txt_data, end ) )
            beg += parse_blockquote( ob, rndr, txt_data, end );

        else if( prefix_code( txt_data, end ) )
            beg += parse_blockcode( ob, rndr, txt_data, end );

        else if( prefix_uli( txt_data, end ) )
            beg += parse_list( ob, rndr, txt_data, end, 0 );

        else if( prefix_oli( txt_data, end ) )
            beg += parse_list( ob, rndr, txt_data, end, MKD_LIST_ORDERED );

        else
            beg += parse_paragraph( ob, rndr, txt_data, end );
    }
}


/*********************
* REFERENCE PARSING *
*********************/

/* is_ref • returns whether a line is a reference or not */
static int is_ref( const uint8_t* data, size_t beg, size_t end, size_t* last,
        struct link_ref** refs )
{
/*	int n; */
    size_t i = 0;
    size_t id_offset, id_end;
    size_t link_offset, link_end;
    size_t title_offset, title_end;
    size_t line_end;

    /* up to 3 optional leading spaces */
    if( beg + 3 >= end )
        return 0;

    if( data[beg] == ' ' )
    {
        i = 1;

        if( data[beg + 1] == ' ' )
        {
            i = 2;

            if( data[beg + 2] == ' ' )
            {
                i = 3;

                if( data[beg + 3] == ' ' )
                    return 0;
            }
        }
    }

    i += beg;

    /* id part: anything but a newline between brackets */
    if( data[i] != '[' )
        return 0;

    i++;
    id_offset = i;

    while( i < end && data[i] != '\n' && data[i] != '\r' && data[i] != ']' )
        i++;

    if( i >= end || data[i] != ']' )
        return 0;

    id_end = i;

    /* spacer: colon (space | tab)* newline? (space | tab)* */
    i++;

    if( i >= end || data[i] != ':' )
        return 0;

    i++;

    while( i < end && data[i] == ' ' )
        i++;

    if( i < end && (data[i] == '\n' || data[i] == '\r') )
    {
        i++;

        if( i < end && data[i] == '\r' && data[i - 1] == '\n' )
            i++;
    }

    while( i < end && data[i] == ' ' )
        i++;

    if( i >= end )
        return 0;

    /* link: whitespace-free sequence, optionally between angle brackets */
    if( data[i] == '<' )
        i++;

    link_offset = i;

    while( i < end && data[i] != ' ' && data[i] != '\n' && data[i] != '\r' )
        i++;

    if( data[i - 1] == '>' )
        link_end = i - 1;
    else
        link_end = i;

    /* optional spacer: (space | tab)* (newline | '\'' | '"' | '(' ) */
    while( i < end && data[i] == ' ' )
        i++;

    if( i < end && data[i] != '\n' && data[i] != '\r'
        && data[i] != '\'' && data[i] != '"' && data[i] != '(' )
        return 0;

    line_end = 0;

    /* computing end-of-line */
    if( i >= end || data[i] == '\r' || data[i] == '\n' )
        line_end = i;

    if( i + 1 < end && data[i] == '\n' && data[i + 1] == '\r' )
        line_end = i + 1;

    /* optional (space|tab)* spacer after a newline */
    if( line_end )
    {
        i = line_end + 1;

        while( i < end && data[i] == ' ' )
            i++;
    }

    /* optional title: any non-newline sequence enclosed in '"()
     *               alone on its line */
    title_offset = title_end = 0;

    if( i + 1 < end
        && (data[i] == '\'' || data[i] == '"' || data[i] == '(') )
    {
        i++;
        title_offset = i;

        /* looking for EOL */
        while( i < end && data[i] != '\n' && data[i] != '\r' )
            i++;

        if( i + 1 < end && data[i] == '\n' && data[i + 1] == '\r' )
            title_end = i + 1;
        else
            title_end = i;

        /* stepping back */
        i -= 1;

        while( i > title_offset && data[i] == ' ' )
            i -= 1;

        if( i > title_offset
            && (data[i] == '\'' || data[i] == '"' || data[i] == ')') )
        {
            line_end = title_end;
            title_end = i;
        }
    }

    if( !line_end || link_end == link_offset )
        return 0;    /* garbage after the link empty link */

    /* a valid ref has been found, filling-in return structures */
    if( last )
        *last = line_end;

    if( refs )
    {
        struct link_ref* ref;

        ref = add_link_ref( refs, data + id_offset, id_end - id_offset );

        if( !ref )
            return 0;

        ref->link = bufnew( link_end - link_offset );
        bufput( ref->link, data + link_offset, link_end - link_offset );

        if( title_end > title_offset )
        {
            ref->title = bufnew( title_end - title_offset );
            bufput( ref->title, data + title_offset, title_end - title_offset );
        }
    }

    return 1;
}


static void expand_tabs( struct buf* ob, const uint8_t* line, size_t size )
{
    size_t i = 0, tab = 0;

    while( i < size )
    {
        size_t org = i;

        while( i < size && line[i] != '\t' )
        {
            i++; tab++;
        }

        if( i > org )
            bufput( ob, line + org, i - org );

        if( i >= size )
            break;

        do {
            bufputc( ob, ' ' ); tab++;
        } while( tab % 4 );

        i++;
    }
}


/**********************
* EXPORTED FUNCTIONS *
**********************/

struct sd_markdown* sd_markdown_new( unsigned int extensions,
        size_t max_nesting,
        const struct sd_callbacks* callbacks,
        void* opaque )
{
    struct sd_markdown* md = NULL;

    assert( max_nesting > 0 && callbacks );

    md = malloc( sizeof(struct sd_markdown) );

    if( !md )
        return NULL;

    memcpy( &md->cb, callbacks, sizeof(struct sd_callbacks) );

    stack_init( &md->work_bufs[BUFFER_BLOCK], 4 );
    stack_init( &md->work_bufs[BUFFER_SPAN], 8 );

    memset( md->active_char, 0x0, 256 );

    if( md->cb.emphasis || md->cb.double_emphasis || md->cb.triple_emphasis )
    {
        md->active_char['*'] = MD_CHAR_EMPHASIS;
        md->active_char['_'] = MD_CHAR_EMPHASIS;

        if( extensions & MKDEXT_STRIKETHROUGH )
            md->active_char['~'] = MD_CHAR_EMPHASIS;
    }

    if( md->cb.codespan )
        md->active_char['`'] = MD_CHAR_CODESPAN;

    if( md->cb.linebreak )
        md->active_char['\n'] = MD_CHAR_LINEBREAK;

    if( md->cb.image || md->cb.link )
        md->active_char['['] = MD_CHAR_LINK;

    md->active_char['<'] = MD_CHAR_LANGLE;
    md->active_char['\\'] = MD_CHAR_ESCAPE;
    md->active_char['&'] = MD_CHAR_ENTITITY;

    if( extensions & MKDEXT_AUTOLINK )
    {
        md->active_char[':'] = MD_CHAR_AUTOLINK_URL;
        md->active_char['@'] = MD_CHAR_AUTOLINK_EMAIL;
        md->active_char['w'] = MD_CHAR_AUTOLINK_WWW;
    }

    if( extensions & MKDEXT_SUPERSCRIPT )
        md->active_char['^'] = MD_CHAR_SUPERSCRIPT;

    /* Extension data */
    md->ext_flags = extensions;
    md->opaque = opaque;
    md->max_nesting = max_nesting;
    md->in_link_body = 0;

    return md;
}


void sd_markdown_render( struct buf* ob,
        const uint8_t* document,
        size_t doc_size,
        struct sd_markdown* md )
{
#define MARKDOWN_GROW( x ) ( (x) + ( (x) >> 1 ) )
    static const char UTF8_BOM[] = { 0xEF, 0xBB, 0xBF };

    struct buf* text;
    size_t beg, end;

    text = bufnew( 64 );

    if( !text )
        return;

    /* Preallocate enough space for our buffer to avoid expanding while copying */
    bufgrow( text, doc_size );

    /* reset the references table */
    memset( &md->refs, 0x0, REF_TABLE_SIZE * sizeof(void*) );

    /* first pass: looking for references, copying everything else */
    beg = 0;

    /* Skip a possible UTF-8 BOM, even though the Unicode standard
     * discourages having these in UTF-8 documents */
    if( doc_size >= 3 && memcmp( document, UTF8_BOM, 3 ) == 0 )
        beg += 3;

    while( beg < doc_size )    /* iterating over lines */
        if( is_ref( document, beg, doc_size, &end, md->refs ) )
            beg = end;
        else    /* skipping to the next line */
        {
            end = beg;

            while( end < doc_size && document[end] != '\n' && document[end] != '\r' )
                end++;

            /* adding the line body if present */
            if( end > beg )
                expand_tabs( text, document + beg, end - beg );

            while( end < doc_size && (document[end] == '\n' || document[end] == '\r') )
            {
                /* add one \n per newline */
                if( document[end] == '\n' || (end + 1 < doc_size && document[end + 1] != '\n') )
                    bufputc( text, '\n' );

                end++;
            }

            beg = end;
        }



    /* pre-grow the output buffer to minimize allocations */
    bufgrow( ob, MARKDOWN_GROW( text->size ) );

    /* second pass: actual rendering */
    if( md->cb.doc_header )
        md->cb.doc_header( ob, md->opaque );

    if( text->size )
    {
        /* adding a final newline if not already present */
        if( text->data[text->size - 1] != '\n' &&  text->data[text->size - 1] != '\r' )
            bufputc( text, '\n' );

        parse_block( ob, md, text->data, text->size );
    }

    if( md->cb.doc_footer )
        md->cb.doc_footer( ob, md->opaque );

    /* clean-up */
    bufrelease( text );
    free_link_refs( md->refs );

    assert( md->work_bufs[BUFFER_SPAN].size == 0 );
    assert( md->work_bufs[BUFFER_BLOCK].size == 0 );
}


void sd_markdown_free( struct sd_markdown* md )
{
    size_t i;

    for( i = 0; i < (size_t) md->work_bufs[BUFFER_SPAN].asize; ++i )
        bufrelease( md->work_bufs[BUFFER_SPAN].item[i] );

    for( i = 0; i < (size_t) md->work_bufs[BUFFER_BLOCK].asize; ++i )
        bufrelease( md->work_bufs[BUFFER_BLOCK].item[i] );

    stack_free( &md->work_bufs[BUFFER_SPAN] );
    stack_free( &md->work_bufs[BUFFER_BLOCK] );

    free( md );
}


void sd_version( int* ver_major, int* ver_minor, int* ver_revision )
{
    *ver_major  = SUNDOWN_VER_MAJOR;
    *ver_minor  = SUNDOWN_VER_MINOR;
    *ver_revision = SUNDOWN_VER_REVISION;
}


/* vim: set filetype=c: */