From 870e63be7360b5a0097a27656048e853bc720464 Mon Sep 17 00:00:00 2001
From: John MacFarlane <jgm@berkeley.edu>
Date: Mon, 21 Jul 2014 22:29:16 -0700
Subject: Initial commit

---
 src/inlines.c | 998 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 998 insertions(+)
 create mode 100644 src/inlines.c

(limited to 'src/inlines.c')

diff --git a/src/inlines.c b/src/inlines.c
new file mode 100644
index 0000000..9e35178
--- /dev/null
+++ b/src/inlines.c
@@ -0,0 +1,998 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include "bstrlib.h"
+#include "stmd.h"
+#include "uthash.h"
+#include "debug.h"
+#include "scanners.h"
+#include "utf8.h"
+
+extern void free_reference(reference *ref) {
+  bdestroy(ref->label);
+  bdestroy(ref->url);
+  bdestroy(ref->title);
+  free(ref);
+}
+
+extern void free_reference_map(reference **refmap) {
+  /* free the hash table contents */
+  reference *s;
+  reference *tmp;
+  if (refmap != NULL) {
+    HASH_ITER(hh, *refmap, s, tmp) {
+      HASH_DEL(*refmap, s);
+      free_reference(s);
+    }
+    free(refmap);
+  }
+}
+
+// normalize reference:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+static bstring normalize_reference(bstring s)
+{
+  bstring normalized = case_fold(s);
+  int pos = 0;
+  int startpos;
+  char c;
+  while ((c = bchar(normalized, pos))) {
+    if (isspace(c)) {
+      startpos = pos;
+      // skip til next non-space
+      pos++;
+      while (isspace(bchar(s, pos))) {
+        pos++;
+      }
+      bdelete(normalized, startpos, pos - startpos);
+      binsertch(normalized, startpos, 1, ' ');
+      pos = startpos + 1;
+    }
+    pos++;
+  }
+  btrimws(normalized);
+  return normalized;
+}
+
+// Returns reference if refmap contains a reference with matching
+// label, otherwise NULL.
+extern reference* lookup_reference(reference** refmap, bstring lab)
+{
+  reference * ref = NULL;
+  bstring label = normalize_reference(lab);
+  if (refmap != NULL) {
+    HASH_FIND_STR(*refmap, (char*) label->data, ref);
+  }
+  bdestroy(label);
+  return ref;
+}
+
+extern reference* make_reference(bstring label, bstring url, bstring title)
+{
+  reference * ref;
+  ref = malloc(sizeof(reference));
+  ref->label = normalize_reference(label);
+  ref->url = bstrcpy(url);
+  ref->title = bstrcpy(title);
+  return ref;
+}
+
+extern void add_reference(reference** refmap, reference* ref)
+{
+  reference * t = NULL;
+  HASH_FIND(hh, *refmap, (char*) ref->label->data,
+            (unsigned) blength(ref->label), t);
+  if (t == NULL) {
+    HASH_ADD_KEYPTR(hh, *refmap, (char*) ref->label->data,
+                    (unsigned) blength(ref->label), ref);
+  } else {
+    free_reference(ref);  // we free this now since it won't be in the refmap
+  }
+}
+
+// Create an inline with a linkable string value.
+inline static inl* make_linkable(int t, inl* label, bstring url, bstring title)
+{
+  inl* e = (inl*) malloc(sizeof(inl));
+  e->tag = t;
+  e->content.linkable.label = label;
+  e->content.linkable.url   = url;
+  e->content.linkable.title = title;
+  e->next = NULL;
+  return e;
+}
+
+inline static inl* make_inlines(int t, inl* contents)
+{
+  inl* e = (inl*) malloc(sizeof(inl));
+  e->tag = t;
+  e->content.inlines = contents;
+  e->next = NULL;
+  return e;
+}
+
+// Create an inline with a literal string value.
+inline static inl* make_literal(int t, bstring s)
+{
+  inl* e = (inl*) malloc(sizeof(inl));
+  e->tag = t;
+  e->content.literal = s;
+  e->next = NULL;
+  return e;
+}
+
+// Create an inline with no value.
+inline static inl* make_simple(int t)
+{
+  inl* e = (inl*) malloc(sizeof(inl));
+  e->tag = t;
+  e->next = NULL;
+  return e;
+}
+
+// Macros for creating various kinds of inlines.
+#define make_str(s) make_literal(str, s)
+#define make_code(s) make_literal(code, s)
+#define make_raw_html(s) make_literal(raw_html, s)
+#define make_entity(s) make_literal(entity, s)
+#define make_linebreak() make_simple(linebreak)
+#define make_softbreak() make_simple(softbreak)
+#define make_link(label, url, title) make_linkable(link, label, url, title)
+#define make_image(alt, url, title) make_linkable(image, alt, url, title)
+#define make_emph(contents) make_inlines(emph, contents)
+#define make_strong(contents) make_inlines(strong, contents)
+
+// Free an inline list.
+extern void free_inlines(inl* e)
+{
+  inl * next;
+  while (e != NULL) {
+    switch (e->tag){
+    case str:
+    case raw_html:
+    case code:
+    case entity:
+      bdestroy(e->content.literal);
+      break;
+    case linebreak:
+    case softbreak:
+      break;
+    case link:
+    case image:
+      bdestroy(e->content.linkable.url);
+      bdestroy(e->content.linkable.title);
+      free_inlines(e->content.linkable.label);
+      break;
+    case emph:
+    case strong:
+      free_inlines(e->content.inlines);
+      break;
+    default:
+      break;
+    }
+    next = e->next;
+    free(e);
+    e = next;
+  }
+}
+
+// Append inline list b to the end of inline list a.
+// Return pointer to head of new list.
+inline static inl* append_inlines(inl* a, inl* b)
+{
+  if (a == NULL) {  // NULL acts like an empty list
+    return b;
+  }
+  inl* cur = a;
+  while (cur->next) {
+    cur = cur->next;
+  }
+  cur->next = b;
+  return a;
+}
+
+// Make a 'subject' from an input string.
+static subject* make_subject(bstring s, reference** refmap)
+{
+  subject* e = (subject*) malloc(sizeof(subject));
+  // remove final whitespace
+  brtrimws(s);
+  e->buffer = s;
+  e->pos = 0;
+  e->label_nestlevel = 0;
+  e->reference_map = refmap;
+  return e;
+}
+
+inline static int isbacktick(int c)
+{
+  return (c == '`');
+}
+
+// Return the next character in the subject, without advancing.
+// Return 0 if at the end of the subject.
+#define peek_char(subj) bchar(subj->buffer, subj->pos)
+
+// Return true if there are more characters in the subject.
+inline static int is_eof(subject* subj)
+{
+  return (subj->pos >= blength(subj->buffer));
+}
+
+// Advance the subject.  Doesn't check for eof.
+#define advance(subj) subj->pos += 1
+
+// Take characters while a predicate holds, and return a string.
+inline static bstring take_while(subject* subj, int (*f)(int))
+{
+  unsigned char c;
+  int startpos = subj->pos;
+  int len = 0;
+  while ((c = peek_char(subj)) && (*f)(c)) {
+    advance(subj);
+    len++;
+  }
+  return bmidstr(subj->buffer, startpos, len);
+}
+
+// Take one character and return a string, or NULL if eof.
+inline static bstring take_one(subject* subj)
+{
+  int startpos = subj->pos;
+  if (is_eof(subj)){
+    return NULL;
+  } else {
+    advance(subj);
+    return bmidstr(subj->buffer, startpos, 1);
+  }
+}
+
+// Try to process a backtick code span that began with a
+// span of ticks of length openticklength length (already
+// parsed).  Return 0 if you don't find matching closing
+// backticks, otherwise return the position in the subject
+// after the closing backticks.
+static int scan_to_closing_backticks(subject* subj, int openticklength)
+{
+  // read non backticks
+  char c;
+  while ((c = peek_char(subj)) && c != '`') {
+    advance(subj);
+  }
+  if (is_eof(subj)) {
+    return 0;  // did not find closing ticks, return 0
+  }
+  int numticks = 0;
+  while (peek_char(subj) == '`') {
+      advance(subj);
+      numticks++;
+  }
+  if (numticks != openticklength){
+    return(scan_to_closing_backticks(subj, openticklength));
+  }
+  return (subj->pos);
+}
+
+// Destructively modify bstring, collapsing consecutive
+// space and newline characters into a single space.
+static int normalize_whitespace(bstring s)
+{
+  bool last_char_was_space = false;
+  int pos = 0;
+  char c;
+  while ((c = bchar(s, pos))) {
+    switch (c) {
+    case ' ':
+      if (last_char_was_space) {
+        bdelete(s, pos, 1);
+      } else {
+        pos++;
+      }
+      last_char_was_space = true;
+      break;
+    case '\n':
+      if (last_char_was_space) {
+        bdelete(s, pos, 1);
+      } else {
+        bdelete(s, pos, 1);
+        binsertch(s, pos, 1, ' ');
+        pos++;
+      }
+      last_char_was_space = true;
+      break;
+    default:
+      pos++;
+      last_char_was_space = false;
+    }
+  }
+  return 0;
+}
+
+// Parse backtick code section or raw backticks, return an inline.
+// Assumes that the subject has a backtick at the current position.
+static inl* handle_backticks(subject *subj)
+{
+  bstring openticks = take_while(subj, isbacktick);
+  bstring result;
+  int ticklength = blength(openticks);
+  int startpos = subj->pos;
+  int endpos = scan_to_closing_backticks(subj, ticklength);
+  if (endpos == 0) { // not found
+    subj->pos = startpos; // rewind
+    return make_str(openticks);
+  } else {
+    bdestroy(openticks);
+    result = bmidstr(subj->buffer, startpos, endpos - startpos - ticklength);
+    btrimws(result);
+    normalize_whitespace(result);
+    return make_code(result);
+  }
+}
+
+// Scan ***, **, or * and return number scanned, or 0.
+// Don't advance position.
+static int scan_delims(subject* subj, char c, bool * can_open, bool * can_close)
+{
+  int numdelims = 0;
+  char char_before, char_after;
+  int startpos = subj->pos;
+
+  char_before = subj->pos == 0 ? '\n' : bchar(subj->buffer, subj->pos - 1);
+  while (peek_char(subj) == c) {
+    numdelims++;
+    advance(subj);
+  }
+  char_after = peek_char(subj);
+  *can_open = numdelims > 0 && numdelims <= 3 && !isspace(char_after);
+  *can_close = numdelims > 0 && numdelims <= 3 && !isspace(char_before);
+  if (c == '_') {
+    *can_open = *can_open && !isalnum(char_before);
+    *can_close = *can_close && !isalnum(char_after);
+  }
+  subj->pos = startpos;
+  return numdelims;
+}
+
+// Parse strong/emph or a fallback.
+// Assumes the subject has '_' or '*' at the current position.
+static inl* handle_strong_emph(subject* subj, char c)
+{
+  bool can_open, can_close;
+  inl * result = NULL;
+  inl ** last = malloc(sizeof(inl *));
+  inl * new;
+  inl * il;
+  inl * first_head = NULL;
+  inl * first_close = NULL;
+  int first_close_delims = 0;
+  int numdelims;
+
+  *last = NULL;
+
+  numdelims = scan_delims(subj, c, &can_open, &can_close);
+  subj->pos += numdelims;
+
+  new = make_str(bmidstr(subj->buffer, subj->pos - numdelims, numdelims));
+  *last = new;
+  first_head = new;
+  result = new;
+
+  if (!can_open || numdelims == 0) {
+    goto done;
+  }
+
+  switch (numdelims) {
+  case 1:
+    while (true) {
+      numdelims = scan_delims(subj, c, &can_open, &can_close);
+      if (numdelims >= 1 && can_close) {
+        subj->pos += 1;
+        first_head->tag = emph;
+        bdestroy(first_head->content.literal);
+        first_head->content.inlines = first_head->next;
+        first_head->next = NULL;
+        goto done;
+      } else {
+        if (!parse_inline(subj, last)) {
+          goto done;
+        }
+      }
+    }
+    break;
+  case 2:
+    while (true) {
+      numdelims = scan_delims(subj, c, &can_open, &can_close);
+      if (numdelims >= 2 && can_close) {
+        subj->pos += 2;
+        first_head->tag = strong;
+        bdestroy(first_head->content.literal);
+        first_head->content.inlines = first_head->next;
+        first_head->next = NULL;
+        goto done;
+      } else {
+        if (!parse_inline(subj, last)) {
+          goto done;
+        }
+      }
+    }
+    break;
+  case 3:
+    while (true) {
+      numdelims = scan_delims(subj, c, &can_open, &can_close);
+      if (can_close && numdelims >= 1 && numdelims <= 3 &&
+          numdelims != first_close_delims) {
+        new = make_str(bmidstr(subj->buffer, subj->pos, numdelims));
+        append_inlines(*last, new);
+        *last = new;
+        if (numdelims == 3) {
+          numdelims = 1;
+        }
+        subj->pos += numdelims;
+        if (first_close) {
+          first_head->tag = first_close_delims == 1 ? strong : emph;
+          bdestroy(first_head->content.literal);
+          first_head->content.inlines =
+            make_inlines(first_close_delims == 1 ? emph : strong,
+                         first_head->next);
+
+          il = first_head->next;
+          while (il->next && il->next != first_close) {
+            il = il->next;
+          }
+          il->next = NULL;
+
+          first_head->content.inlines->next = first_close->next;
+
+          il = first_head->content.inlines;
+          while (il->next && il->next != *last) {
+            il = il->next;
+          }
+          il->next = NULL;
+          free_inlines(*last);
+
+          first_close->next = NULL;
+          free_inlines(first_close);
+          first_head->next = NULL;
+          goto done;
+        } else {
+          first_close = *last;
+          first_close_delims = numdelims;
+        }
+      } else {
+        if (!parse_inline(subj, last)) {
+          goto done;
+        }
+      }
+    }
+    break;
+  default:
+    goto done;
+  }
+
+ done:
+  free(last);
+  return result;
+}
+
+// Parse backslash-escape or just a backslash, returning an inline.
+static inl* handle_backslash(subject *subj)
+{
+  advance(subj);
+  unsigned char nextchar = peek_char(subj);
+  if (ispunct(nextchar)) {  // only ascii symbols and newline can be escaped
+    advance(subj);
+    return make_str(bformat("%c", nextchar));
+  } else if (nextchar == '\n') {
+    advance(subj);
+    return make_linebreak();
+  } else {
+    return make_str(bfromcstr("\\"));
+  }
+}
+
+// Parse an entity or a regular "&" string.
+// Assumes the subject has an '&' character at the current position.
+static inl* handle_entity(subject* subj)
+{
+  int match;
+  inl * result;
+  match = scan_entity(subj->buffer, subj->pos);
+  if (match) {
+    result = make_entity(bmidstr(subj->buffer, subj->pos, match));
+    subj->pos += match;
+  } else {
+    advance(subj);
+    result = make_str(bfromcstr("&"));
+  }
+  return result;
+}
+
+// Like make_str, but parses entities.
+// Returns an inline sequence consisting of str and entity elements.
+static inl * make_str_with_entities(bstring s)
+{
+  inl * result = NULL;
+  inl * new;
+  int searchpos;
+  char c;
+  subject * subj = make_subject(s, NULL);
+
+  while ((c = peek_char(subj))) {
+    switch (c) {
+    case '&':
+      new = handle_entity(subj);
+      break;
+    default:
+      searchpos = bstrchrp(subj->buffer, '&', subj->pos);
+      if (searchpos == BSTR_ERR) {
+        searchpos = blength(subj->buffer);
+      }
+      new = make_str(bmidstr(subj->buffer, subj->pos, searchpos - subj->pos));
+      subj->pos = searchpos;
+    }
+    result = append_inlines(result, new);
+  }
+  free(subj);
+  return result;
+}
+
+// Destructively unescape a string: remove backslashes before punctuation chars.
+extern int unescape(bstring url)
+{
+  // remove backslashes before punctuation chars:
+  int searchpos = 0;
+  while ((searchpos = bstrchrp(url, '\\', searchpos)) != BSTR_ERR) {
+    if (ispunct(bchar(url, searchpos + 1))) {
+      bdelete(url, searchpos, 1);
+    } else {
+      searchpos++;
+    }
+  }
+  return 0;
+}
+
+// Clean a URL: remove surrounding whitespace and surrounding <>,
+// and remove \ that escape punctuation.
+static int clean_url(bstring url)
+{
+  // remove surrounding <> if any:
+  int urllength = blength(url);
+  btrimws(url);
+  if (bchar(url, 0) == '<' && bchar(url, urllength - 1) == '>') {
+    bdelete(url, 0, 1);
+    bdelete(url, urllength - 2, 1);
+  }
+  unescape(url);
+  return 0;
+}
+
+// Clean a title: remove surrounding quotes and remove \ that escape punctuation.
+static int clean_title(bstring title)
+{
+  // remove surrounding quotes if any:
+  int titlelength = blength(title);
+  if ((bchar(title, 0) == '\'' && bchar(title, titlelength - 1) == '\'') ||
+      (bchar(title, 0) == '(' && bchar(title, titlelength - 1) == ')') ||
+      (bchar(title, 0) == '"' && bchar(title, titlelength - 1) == '"')) {
+    bdelete(title, 0, 1);
+    bdelete(title, titlelength - 2, 1);
+  }
+  unescape(title);
+  return 0;
+}
+
+// Parse an autolink or HTML tag.
+// Assumes the subject has a '<' character at the current position.
+static inl* handle_pointy_brace(subject* subj)
+{
+  int matchlen = 0;
+  bstring contents;
+  inl* result;
+
+  advance(subj);  // advance past first <
+  // first try to match a URL autolink
+  matchlen = scan_autolink_uri(subj->buffer, subj->pos);
+  if (matchlen > 0) {
+    contents = bmidstr(subj->buffer, subj->pos, matchlen - 1);
+    subj->pos += matchlen;
+    result =  make_link(make_str_with_entities(contents),
+                        bstrcpy(contents), bfromcstr(""));
+    bdestroy(contents);
+    return result;
+  }
+  // next try to match an email autolink
+  matchlen = scan_autolink_email(subj->buffer, subj->pos);
+  if (matchlen > 0) {
+    contents = bmidstr(subj->buffer, subj->pos, matchlen - 1);
+    subj->pos += matchlen;
+    result = make_link(make_str_with_entities(contents),
+                       bformat("mailto:%s", contents->data),
+                       bfromcstr(""));
+    bdestroy(contents);
+    return result;
+  }
+  // finally, try to match an html tag
+  matchlen = scan_html_tag(subj->buffer, subj->pos);
+  if (matchlen > 0) {
+    contents = bmidstr(subj->buffer, subj->pos, matchlen);
+    binsertch(contents, 0, 1, '<');
+    subj->pos += matchlen;
+    return make_raw_html(contents);
+  } else {// if nothing matches, just return the opening <:
+    return make_str(bfromcstr("<"));
+  }
+}
+
+// Parse a link label.  Returns 1 if successful.
+// Unless raw_label is null, it is set to point to the raw contents of the [].
+// Assumes the subject has a '[' character at the current position.
+// Returns 0 and does not advance if no matching ] is found.
+// Note the precedence:  code backticks have precedence over label bracket
+// markers, which have precedence over *, _, and other inline formatting
+// markers. So, 2 below contains a link while 1 does not:
+// 1. [a link `with a ](/url)` character
+// 2. [a link *with emphasized ](/url) text*
+static int link_label(subject* subj, bstring* raw_label)
+{
+  int nestlevel = 0;
+  inl* tmp = NULL;
+  bstring raw;
+  int startpos = subj->pos;
+  if (subj->label_nestlevel) {
+    // if we've already checked to the end of the subject
+    // for a label, even with a different starting [, we
+    // know we won't find one here and we can just return.
+    // Note:  nestlevel 1 would be: [foo [bar]
+    // nestlevel 2 would be: [foo [bar [baz]
+    subj->label_nestlevel--;
+    return 0;
+  }
+  advance(subj);  // advance past [
+  char c;
+  while ((c = peek_char(subj)) && (c != ']' || nestlevel > 0)) {
+    switch (c) {
+    case '`':
+      tmp = handle_backticks(subj);
+      free_inlines(tmp);
+      break;
+    case '<':
+      tmp = handle_pointy_brace(subj);
+      free_inlines(tmp);
+      break;
+    case '[':  // nested []
+      nestlevel++;
+      advance(subj);
+      break;
+    case ']':  // nested []
+      nestlevel--;
+      advance(subj);
+      break;
+    case '\\':
+      advance(subj);
+      if (ispunct(peek_char(subj))) {
+        advance(subj);
+      }
+      break;
+    default:
+      advance(subj);
+    }
+  }
+  if (c == ']') {
+    if (raw_label != NULL) {
+      raw = bmidstr(subj->buffer, startpos + 1, subj->pos - (startpos + 1));
+      *raw_label = raw;
+    }
+    subj->label_nestlevel = 0;
+    advance(subj);  // advance past ]
+    return 1;
+  } else {
+    if (c == 0) {
+      subj->label_nestlevel = nestlevel;
+    }
+    subj->pos = startpos; // rewind
+    return 0;
+  }
+}
+
+// Parse a link or the link portion of an image, or return a fallback.
+static inl* handle_left_bracket(subject* subj)
+{
+  inl* lab = NULL;
+  inl* result = NULL;
+  reference* ref;
+  int n;
+  int sps;
+  int found_label;
+  int endlabel, starturl, endurl, starttitle, endtitle, endall;
+  bstring url, title, rawlabel, reflabel;
+  bstring rawlabel2 = NULL;
+  found_label = link_label(subj, &rawlabel);
+  endlabel = subj->pos;
+  if (found_label) {
+    if (peek_char(subj) == '(' &&
+        ((sps = scan_spacechars(subj->buffer, subj->pos + 1)) > -1) &&
+        ((n = scan_link_url(subj->buffer, subj->pos + 1 + sps)) > -1)) {
+      // try to parse an explicit link:
+      starturl = subj->pos + 1 + sps; // after (
+      endurl = starturl + n;
+      starttitle = endurl + scan_spacechars(subj->buffer, endurl);
+      // ensure there are spaces btw url and title
+      endtitle = (starttitle == endurl) ? starttitle :
+                 starttitle + scan_link_title(subj->buffer, starttitle);
+      endall = endtitle + scan_spacechars(subj->buffer, endtitle);
+      if (bchar(subj->buffer, endall) == ')') {
+        subj->pos = endall + 1;
+        url = bmidstr(subj->buffer, starturl, endurl - starturl);
+        clean_url(url);
+        title = bmidstr(subj->buffer, starttitle, endtitle - starttitle);
+        clean_title(title);
+        lab = parse_inlines(rawlabel, NULL);
+        bdestroy(rawlabel);
+        return make_link(lab, url, title);
+      } else {
+        // if we get here, we matched a label but didn't get further:
+        subj->pos = endlabel;
+        lab = parse_inlines(rawlabel, subj->reference_map);
+        bdestroy(rawlabel);
+        result = append_inlines(make_str(bfromcstr("[")),
+                                append_inlines(lab,
+                                               make_str(bfromcstr("]"))));
+        return result;
+      }
+    } else {
+      // Check for reference link.
+      // First, see if there's another label:
+      subj->pos = subj->pos + scan_spacechars(subj->buffer, endlabel);
+      reflabel = rawlabel;
+      // if followed by a nonempty link label, we change reflabel to it:
+      if (peek_char(subj) == '[' &&
+          link_label(subj, &rawlabel2)) {
+        if (blength(rawlabel2) > 0) {
+          reflabel = rawlabel2;
+        }
+      } else {
+        subj->pos = endlabel;
+      }
+      // lookup rawlabel in subject->reference_map:
+      ref = lookup_reference(subj->reference_map, reflabel);
+      if (ref != NULL) { // found
+        lab = parse_inlines(rawlabel, NULL);
+        result = make_link(lab, bstrcpy(ref->url), bstrcpy(ref->title));
+      } else {
+        subj->pos = endlabel;
+        lab = parse_inlines(rawlabel, subj->reference_map);
+        result = append_inlines(make_str(bfromcstr("[")),
+                               append_inlines(lab, make_str(bfromcstr("]"))));
+      }
+      bdestroy(rawlabel);
+      bdestroy(rawlabel2);
+      return result;
+    }
+  }
+  // If we fall through to here, it means we didn't match a link:
+  advance(subj);  // advance past [
+  return make_str(bfromcstr("["));
+}
+
+// Parse a hard or soft linebreak, returning an inline.
+// Assumes the subject has a newline at the current position.
+static inl* handle_newline(subject *subj)
+{
+  int nlpos = subj->pos;
+  // skip over newline
+  advance(subj);
+  // skip spaces at beginning of line
+  while (peek_char(subj) == ' ') {
+    advance(subj);
+  }
+  if (nlpos > 1 &&
+      bchar(subj->buffer, nlpos - 1) == ' ' &&
+      bchar(subj->buffer, nlpos - 2) == ' ') {
+    return make_linebreak();
+  } else {
+    return make_softbreak();
+  }
+}
+
+inline static int not_eof(subject* subj)
+{
+  return !is_eof(subj);
+}
+
+// Parse inlines while a predicate is satisfied.  Return inlines.
+extern inl* parse_inlines_while(subject* subj, int (*f)(subject*))
+{
+  inl* result = NULL;
+  inl** last = &result;
+  while ((*f)(subj) && parse_inline(subj, last)) {
+  }
+  return result;
+}
+
+// Parse an inline, advancing subject, and add it to last element.
+// Adjust tail to point to new last element of list.
+// Return 0 if no inline can be parsed, 1 otherwise.
+extern int parse_inline(subject* subj, inl ** last)
+{
+  inl* new = NULL;
+  bstring contents;
+  bstring special_chars;
+  unsigned char c;
+  int endpos;
+  c = peek_char(subj);
+  if (c == 0) {
+    return 0;
+  }
+  switch(c){
+    case '\n':
+      new = handle_newline(subj);
+      break;
+    case '`':
+      new = handle_backticks(subj);
+      break;
+    case '\\':
+      new = handle_backslash(subj);
+      break;
+    case '&':
+      new = handle_entity(subj);
+      break;
+    case '<':
+      new = handle_pointy_brace(subj);
+      break;
+    case '_':
+      if (subj->pos > 0 && (isalnum(bchar(subj->buffer, subj->pos - 1)) ||
+                            bchar(subj->buffer, subj->pos - 1) == '_')) {
+        new = make_str(take_one(subj));
+      } else {
+        new = handle_strong_emph(subj, '_');
+      }
+      break;
+    case '*':
+      new = handle_strong_emph(subj, '*');
+      break;
+    case '[':
+      new = handle_left_bracket(subj);
+      break;
+    case '!':
+      advance(subj);
+      if (peek_char(subj) == '[') {
+        new = handle_left_bracket(subj);
+        if (new != NULL && new->tag == link) {
+          new->tag = image;
+        } else {
+          new = append_inlines(make_str(bfromcstr("!")), new);
+        }
+      } else {
+        new = make_str(bfromcstr("!"));
+      }
+      break;
+    default:
+      // we read until we hit a special character
+      special_chars = bfromcstr("\n\\`&_*[]<!");
+      endpos = binchr(subj->buffer, subj->pos, special_chars);
+      bdestroy(special_chars);
+      if (endpos == subj->pos) {
+        // current char is special: read a 1-character str
+        contents = take_one(subj);
+      } else if (endpos == BSTR_ERR) {
+        // special char not found, take whole rest of buffer:
+        endpos = subj->buffer->slen;
+        contents = bmidstr(subj->buffer, subj->pos, endpos - subj->pos);
+        subj->pos = endpos;
+      } else {
+        // take buffer from subj->pos to endpos to str.
+        contents = bmidstr(subj->buffer, subj->pos, endpos - subj->pos);
+        subj->pos = endpos;
+        // if we're at a newline, strip trailing spaces.
+        if (peek_char(subj) == '\n') {
+          brtrimws(contents);
+        }
+      }
+      new = make_str(contents);
+  }
+  if (*last == NULL) {
+    *last = new;
+  } else {
+    append_inlines(*last, new);
+  }
+  return 1;
+}
+
+extern inl* parse_inlines(bstring input, reference** refmap)
+{
+  subject * subj = make_subject(input, refmap);
+  inl * result = parse_inlines_while(subj, not_eof);
+  free(subj);
+  return result;
+}
+
+// Parse zero or more space characters, including at most one newline.
+void spnl(subject* subj)
+{
+  bool seen_newline = false;
+  while (peek_char(subj) == ' ' ||
+         (!seen_newline &&
+          (seen_newline = peek_char(subj) == '\n'))) {
+    advance(subj);
+  }
+}
+
+// Parse reference.  Assumes string begins with '[' character.
+// Modify refmap if a reference is encountered.
+// Return 0 if no reference found, otherwise position of subject
+// after reference is parsed.
+extern int parse_reference(bstring input, reference** refmap)
+{
+  subject * subj = make_subject(input, NULL);
+  bstring lab = NULL;
+  bstring url = NULL;
+  bstring title = NULL;
+  int matchlen = 0;
+  int beforetitle;
+  reference * new = NULL;
+  int newpos;
+
+  // parse label:
+  if (!link_label(subj, &lab)) {
+    free(subj);
+    return 0;
+  }
+  // colon:
+  if (peek_char(subj) == ':') {
+    advance(subj);
+  } else {
+    free(subj);
+    bdestroy(lab);
+    return 0;
+  }
+  // parse link url:
+  spnl(subj);
+  matchlen = scan_link_url(subj->buffer, subj->pos);
+  if (matchlen) {
+    url = bmidstr(subj->buffer, subj->pos, matchlen);
+    clean_url(url);
+    subj->pos += matchlen;
+  } else {
+    free(subj);
+    bdestroy(lab);
+    bdestroy(url);
+    return 0;
+  }
+  // parse optional link_title
+  beforetitle = subj->pos;
+  spnl(subj);
+  matchlen = scan_link_title(subj->buffer, subj->pos);
+  if (matchlen) {
+    title = bmidstr(subj->buffer, subj->pos, matchlen);
+    clean_title(title);
+    subj->pos += matchlen;
+  } else {
+    subj->pos = beforetitle;
+    title = bfromcstr("");
+  }
+  // parse final spaces and newline:
+  while (peek_char(subj) == ' ') {
+    advance(subj);
+  }
+  if (peek_char(subj) == '\n') {
+    advance(subj);
+  } else if (peek_char(subj) != 0) {
+    free(subj);
+    bdestroy(lab);
+    bdestroy(url);
+    bdestroy(title);
+    return 0;
+  }
+  // insert reference into refmap
+  new = make_reference(lab, url, title);
+  add_reference(refmap, new);
+
+  newpos = subj->pos;
+  free(subj);
+  bdestroy(lab);
+  bdestroy(url);
+  bdestroy(title);
+  return newpos;
+}
+
-- 
cgit v1.2.3