rdiscount 2.2.0.1 → 2.2.7

data/ext/markdown.c

@@ -147,12 +147,12 @@ typedef struct _flo {
 #define floindex(x) (x.i)
 
 
-static int
+static unsigned int
 flogetc(FLO *f)
 {
     if ( f && f->t ) {
 	if ( f->i < S(f->t->text) )
-	    return T(f->t->text)[f->i++];
+	    return (unsigned char)T(f->t->text)[f->i++];
 	f->t = f->t->next;
 	f->i = 0;
 	return flogetc(f);
@@ -170,8 +170,10 @@ splitline(Line *t, int cutpoint)
 	tmp->next = t->next;
 	t->next = tmp;
 
-	tmp->dle = t->dle;
 	SUFFIX(tmp->text, T(t->text)+cutpoint, S(t->text)-cutpoint);
+	EXPAND(tmp->text) = 0;
+	S(tmp->text)--;
+	
 	S(t->text) = cutpoint;
     }
 }
@@ -187,7 +189,7 @@ splitline(Line *t, int cutpoint)
  * types.
  */
 static void
-checkline(Line *l, DWORD flags)
+checkline(Line *l, mkd_flag_t flags)
 {
     int eol, i;
     int dashes = 0, spaces = 0,
@@ -213,11 +215,11 @@ checkline(Line *l, DWORD flags)
 	switch (c) {
 	case '-':  UNLESS_FENCED(dashes = 1); break;
 	case ' ':  UNLESS_FENCED(spaces = 1); break;
-	case '=':  equals = 1; break;
+	case '=':  UNLESS_FENCED(equals = 1); break;
 	case '_':  UNLESS_FENCED(underscores = 1); break;
 	case '*':  stars = 1; break;
 	default:
-	    if (flags & MKD_FENCEDCODE) {
+	    if ( is_flag_set(flags, MKD_FENCEDCODE) ) {
 		switch (c) {
 		case '~':  if (other) return; is_fence_char = 1; tildes = 1; break;
 		case '`':  if (other) return; is_fence_char = 1; backticks = 1; break;
@@ -379,7 +381,7 @@ iscode(Line *t)
 
 
 static inline int
-ishr(Line *t, DWORD flags)
+ishr(Line *t, mkd_flag_t flags)
 {
     if ( ! (t->flags & CHECKED) )
 	checkline(t, flags);
@@ -391,7 +393,7 @@ ishr(Line *t, DWORD flags)
 
 
 static int
-issetext(Line *t, int *htyp, DWORD flags)
+issetext(Line *t, int *htyp, mkd_flag_t flags)
 {
     Line *n;
     
@@ -413,7 +415,7 @@ issetext(Line *t, int *htyp, DWORD flags)
 
 
 static int
-ishdr(Line *t, int *htyp, DWORD flags)
+ishdr(Line *t, int *htyp, mkd_flag_t flags)
 {
     /* ANY leading `#`'s make this into an ETX header
      */
@@ -429,7 +431,7 @@ ishdr(Line *t, int *htyp, DWORD flags)
 
 
 static inline int
-end_of_block(Line *t, DWORD flags)
+end_of_block(Line *t, mkd_flag_t flags)
 {
     int dummy;
     
@@ -441,9 +443,9 @@ end_of_block(Line *t, DWORD flags)
 
 
 static Line*
-is_discount_dt(Line *t, int *clip, DWORD flags)
+is_discount_dt(Line *t, int *clip, mkd_flag_t flags)
 {
-    if ( !(flags & MKD_NODLDISCOUNT)
+    if ( !is_flag_set(flags, MKD_NODLDISCOUNT)
 	   && t
 	   && t->next
 	   && (S(t->text) > 2)
@@ -470,9 +472,9 @@ is_extra_dd(Line *t)
 
 
 static Line*
-is_extra_dt(Line *t, int *clip, DWORD flags)
+is_extra_dt(Line *t, int *clip, mkd_flag_t flags)
 {
-    if ( flags & MKD_DLEXTRA
+    if ( is_flag_set(flags, MKD_DLEXTRA)
 	   && t
 	   && t->next && S(t->text) && T(t->text)[0] != '='
 		      && T(t->text)[S(t->text)-1] != '=') {
@@ -494,7 +496,7 @@ is_extra_dt(Line *t, int *clip, DWORD flags)
 
 
 static Line*
-isdefinition(Line *t, int *clip, int *kind, DWORD flags)
+isdefinition(Line *t, int *clip, int *kind, mkd_flag_t flags)
 {
     Line *ret;
 
@@ -508,7 +510,7 @@ isdefinition(Line *t, int *clip, int *kind, DWORD flags)
 
 
 static int
-islist(Line *t, int *clip, DWORD flags, int *list_type)
+islist(Line *t, int *clip, mkd_flag_t flags, int *list_type)
 {
     int i, j;
     char *q;
@@ -516,21 +518,22 @@ islist(Line *t, int *clip, DWORD flags, int *list_type)
     if ( end_of_block(t, flags) )
 	return 0;
 
-    if ( !(flags & (MKD_NODLIST|MKD_STRICT)) && isdefinition(t,clip,list_type,flags) )
+    if ( !(is_flag_set(flags, MKD_NODLIST) || is_flag_set(flags, MKD_STRICT))
+				      && isdefinition(t,clip,list_type,flags) )
 	return DL;
 
     if ( strchr("*-+", T(t->text)[t->dle]) && isspace(T(t->text)[t->dle+1]) ) {
 	i = nextnonblank(t, t->dle+1);
 	*clip = (i > 4) ? 4 : i;
 	*list_type = UL;
-	return AL;
+	return is_flag_set(flags, MKD_EXPLICITLIST) ? UL : AL;
     }
 
     if ( (j = nextblank(t,t->dle)) > t->dle ) {
 	if ( T(t->text)[j-1] == '.' ) {
 
-	    if ( !(flags & (MKD_NOALPHALIST|MKD_STRICT))
-				    && (j == t->dle + 2)
+	    if ( !(is_flag_set(flags, MKD_NOALPHALIST) || is_flag_set(flags, MKD_STRICT))
+			  && (j == t->dle + 2)
 			  && isalpha(T(t->text)[t->dle]) ) {
 		j = nextnonblank(t,j);
 		*clip = (j > 4) ? 4 : j;
@@ -608,8 +611,7 @@ codeblock(Paragraph *p)
     Line *t = p->text, *r;
 
     for ( ; t; t = r ) {
-	CLIP(t->text,0,4);
-	t->dle = mkd_firstnonblank(t);
+	__mkd_trim_line(t,4);
 
 	if ( !( (r = skipempty(t->next)) && iscode(r)) ) {
 	    ___mkd_freeLineRange(t,r);
@@ -622,9 +624,9 @@ codeblock(Paragraph *p)
 
 
 static int
-iscodefence(Line *r, int size, line_type kind, DWORD flags)
+iscodefence(Line *r, int size, line_type kind, mkd_flag_t flags)
 {
-    if ( !(flags & MKD_FENCEDCODE) )
+    if ( !is_flag_set(flags, MKD_FENCEDCODE) )
 	return 0;
 
     if ( !(r->flags & CHECKED) )
@@ -636,39 +638,40 @@ iscodefence(Line *r, int size, line_type kind, DWORD flags)
 	return (r->kind == chk_tilde || r->kind == chk_backtick) && (r->count >= size);
 }
 
+
 static Paragraph *
-fencedcodeblock(ParagraphRoot *d, Line **ptr, DWORD flags)
+fencedcodeblock(ParagraphRoot *d, Line **ptr, mkd_flag_t flags)
 {
     Line *first, *r;
     Paragraph *ret;
 
     first = (*ptr);
-    
+
     /* don't allow zero-length code fences
-     */
+    */
     if ( (first->next == 0) || iscodefence(first->next, first->count, 0, flags) )
 	return 0;
 
     /* find the closing fence, discard the fences,
-     * return a Paragraph with the contents
-     */
+    * return a Paragraph with the contents
+    */
     for ( r = first; r && r->next; r = r->next )
 	if ( iscodefence(r->next, first->count, first->kind, flags) ) {
 	    (*ptr) = r->next->next;
 	    ret = Pp(d, first->next, CODE);
-      if (S(first->text) - first->count > 0) {
-        char *lang_attr = T(first->text) + first->count;
-        while ( *lang_attr != 0 && *lang_attr == ' ' ) lang_attr++;
-        ret->lang = strdup(lang_attr);
-      }
-      else {
-        ret->lang = 0;
-      }
-	    ___mkd_freeLine(first);
-	    ___mkd_freeLine(r->next);
-	    r->next = 0;
-	    return ret;
+	    if (S(first->text) - first->count > 0) {
+		char *lang_attr = T(first->text) + first->count;
+		while ( *lang_attr != 0 && *lang_attr == ' ' ) lang_attr++;
+		ret->lang = strdup(lang_attr);
+	    }
+	    else {
+		ret->lang = 0;
 	}
+	___mkd_freeLine(first);
+	___mkd_freeLine(r->next);
+	r->next = 0;
+	return ret;
+    }
     return 0;
 }
 
@@ -692,7 +695,7 @@ centered(Line *first, Line *last)
 
 
 static int
-endoftextblock(Line *t, int toplevelblock, DWORD flags)
+endoftextblock(Line *t, int toplevelblock, mkd_flag_t flags)
 {
     int z;
 
@@ -712,7 +715,7 @@ endoftextblock(Line *t, int toplevelblock, DWORD flags)
 
 
 static Line *
-textblock(Paragraph *p, int toplevel, DWORD flags)
+textblock(Paragraph *p, int toplevel, mkd_flag_t flags)
 {
     Line *t, *next;
 
@@ -747,12 +750,12 @@ szmarkerclass(char *p)
 #define iscsschar(c) (isalpha(c) || (c == '-') || (c == '_') )
 
 static int
-isdivmarker(Line *p, int start, DWORD flags)
+isdivmarker(Line *p, int start, mkd_flag_t flags)
 {
     char *s;
     int last, i;
 
-    if ( flags & (MKD_NODIVQUOTE|MKD_STRICT) )
+    if ( is_flag_set(flags, MKD_NODIVQUOTE) || is_flag_set(flags, MKD_STRICT) )
 	return 0;
 
     start = nextnonblank(p, start);
@@ -786,7 +789,7 @@ isdivmarker(Line *p, int start, DWORD flags)
  * way the markdown sample web form at Daring Fireball works.
  */
 static Line *
-quoteblock(Paragraph *p, DWORD flags)
+quoteblock(Paragraph *p, mkd_flag_t flags)
 {
     Line *t, *q;
     int qp;
@@ -803,9 +806,8 @@ quoteblock(Paragraph *p, DWORD flags)
 	    /* clip next space, if any */
 	    if ( T(t->text)[qp] == ' ' )
 		qp++;
-	    CLIP(t->text, 0, qp);
+	    __mkd_trim_line(t,qp);
 	    UNCHECK(t);
-	    t->dle = mkd_firstnonblank(t);
 	}
 
 	q = skipempty(t->next);
@@ -847,16 +849,40 @@ typedef int (*linefn)(Line *);
  * marker, but multiple paragraphs need to start with a 4-space indent.
  */
 static Line *
-listitem(Paragraph *p, int indent, DWORD flags, linefn check)
+listitem(Paragraph *p, int indent, mkd_flag_t flags, linefn check)
 {
     Line *t, *q;
     int clip = indent;
     int z;
+#ifdef GITHUB_CHECKBOX
+    int firstpara = 1;
+    int ischeck;
+#define CHECK_NOT 0
+#define CHECK_NO 1
+#define CHECK_YES 2
+#endif
 
     for ( t = p->text; t ; t = q) {
-	CLIP(t->text, 0, clip);
 	UNCHECK(t);
-	t->dle = mkd_firstnonblank(t);
+	__mkd_trim_line(t, clip);
+
+#ifdef GITHUB_CHECKBOX
+	if ( firstpara ) {
+	    ischeck = CHECK_NOT;
+	    if ( strncmp(T(t->text)+t->dle, "[ ]", 3) == 0 )
+		ischeck = CHECK_NO;
+	    else if ( strncasecmp(T(t->text)+t->dle, "[x]", 3) == 0 )
+		ischeck = CHECK_YES;
+
+	    if ( ischeck != CHECK_NOT ) {
+		__mkd_trim_line(t, 3);
+		p->flags |= GITHUB_CHECK;
+		if ( ischeck == CHECK_YES )
+		    p->flags |= IS_CHECKED;
+	    }
+	    firstpara = 0;
+	}
+#endif
 
         /* even though we had to trim a long leader off this item,
          * the indent for trailing paragraphs is still 4...
@@ -1005,6 +1031,28 @@ tgood(char c)
 }
 
 
+/*
+ * eat lines for a markdown extra footnote
+ */
+static Line *
+extrablock(Line *p)
+{
+    Line *np;
+    
+    while ( p && p->next ) {
+	np = p->next;
+
+	if ( np->dle < 4 && np->dle < S(np->text) ) {
+	    p->next = 0;
+	    return np;
+	}
+	__mkd_trim_line(np,4);
+	p = np;
+    }
+    return 0;
+}
+
+
 /*
  * add a new (image or link) footnote to the footnote table
  */
@@ -1020,20 +1068,31 @@ addfootnote(Line *p, MMIOT* f)
     CREATE(foot->tag);
     CREATE(foot->link);
     CREATE(foot->title);
+    foot->text = 0;
     foot->flags = foot->height = foot->width = 0;
 
+    /* keep the footnote label */
     for (j=i=p->dle+1; T(p->text)[j] != ']'; j++)
 	EXPAND(foot->tag) = T(p->text)[j];
-
     EXPAND(foot->tag) = 0;
     S(foot->tag)--;
+
+    /* consume the closing ]: */
     j = nextnonblank(p, j+2);
 
-    if ( (f->flags & MKD_EXTRA_FOOTNOTE) && (T(foot->tag)[0] == '^') ) {
-	/* need to consume all lines until non-indented block? */
-	while ( j < S(p->text) )
-	    EXPAND(foot->title) = T(p->text)[j++];
-	goto skip_to_end;
+    if ( is_flag_set(f->flags, MKD_EXTRA_FOOTNOTE) && (T(foot->tag)[0] == '^') ) {
+	/* markdown extra footnote: All indented lines past this point;
+	 * the first line includes the footnote reference, so we need to
+	 * snip that out as we go.
+	 */
+	foot->flags |= EXTRA_FOOTNOTE;
+	__mkd_trim_line(p,j);
+
+	np = extrablock(p);
+
+	foot->text = compile(p, 0, f);
+
+	return np;
     }
 
     while ( (j < S(p->text)) && !isspace(T(p->text)[j]) )
@@ -1044,8 +1103,7 @@ addfootnote(Line *p, MMIOT* f)
 
     if ( T(p->text)[j] == '=' ) {
 	sscanf(T(p->text)+j, "=%dx%d", &foot->width, &foot->height);
-	while ( (j < S(p->text)) && !isspace(T(p->text)[j]) )
-	    ++j;
+	j = nextblank(p, j);
 	j = nextnonblank(p,j);
     }
 
@@ -1075,7 +1133,6 @@ addfootnote(Line *p, MMIOT* f)
 	--S(foot->title);
     }
 
-skip_to_end:
     ___mkd_freeLine(p);
     return np;
 }
@@ -1113,6 +1170,22 @@ consume(Line *ptr, int *eaten)
 }
 
 
+typedef ANCHOR(Line) Cache;
+
+static void
+uncache(Cache *cache, ParagraphRoot *d, MMIOT *f)
+{
+    Paragraph *p;
+
+    if ( T(*cache) ) {
+	E(*cache)->next = 0;
+	p = Pp(d, 0, SOURCE);
+	p->down = compile(T(*cache), 1, f);
+	T(*cache) = E(*cache) = 0;
+    }
+}
+
+
 /*
  * top-level compilation; break the document into
  * style, html, and source blocks with footnote links
@@ -1122,25 +1195,21 @@ static Paragraph *
 compile_document(Line *ptr, MMIOT *f)
 {
     ParagraphRoot d = { 0, 0 };
-    ANCHOR(Line) source = { 0, 0 };
+    Cache source = { 0, 0 };
     Paragraph *p = 0;
     struct kw *tag;
     int eaten, unclosed;
+    int previous_was_break = 1;
 
     while ( ptr ) {
-	if ( !(f->flags & MKD_NOHTML) && (tag = isopentag(ptr)) ) {
+	if ( !is_flag_set(f->flags, MKD_NOHTML) && (tag = isopentag(ptr)) ) {
 	    int blocktype;
 	    /* If we encounter a html/style block, compile and save all
 	     * of the cached source BEFORE processing the html/style.
 	     */
-	    if ( T(source) ) {
-		E(source)->next = 0;
-		p = Pp(&d, 0, SOURCE);
-		p->down = compile(T(source), 1, f);
-		T(source) = E(source) = 0;
-	    }
+	    uncache(&source, &d, f);
 	    
-	    if ( f->flags & MKD_NOSTYLE )
+	    if (is_flag_set(f->flags, MKD_NOSTYLE) )
 		blocktype = HTML;
 	    else
 		blocktype = strcmp(tag->id, "STYLE") == 0 ? STYLE : HTML;
@@ -1151,6 +1220,7 @@ compile_document(Line *ptr, MMIOT *f)
 		p->down = compile(p->text, 1, f);
 		p->text = 0;
 	    }
+	    previous_was_break = 1;
 	}
 	else if ( isfootnote(ptr) ) {
 	    /* footnotes, like cats, sleep anywhere; pull them
@@ -1158,23 +1228,27 @@ compile_document(Line *ptr, MMIOT *f)
 	     * later processing
 	     */
 	    ptr = consume(addfootnote(ptr, f), &eaten);
+	    previous_was_break = 1;
+	}
+	else if ( previous_was_break && iscodefence(ptr,3,0,f->flags)) {
+	    uncache(&source, &d, f);
+	    if ( !fencedcodeblock(&d, &ptr, f->flags) ) /* just source */
+		goto attach;
 	}
 	else {
+    attach:
 	    /* source; cache it up to wait for eof or the
 	     * next html/style block
 	     */
 	    ATTACH(source,ptr);
+	    previous_was_break = blankline(ptr);
 	    ptr = ptr->next;
 	}
     }
-    if ( T(source) ) {
-	/* if there's any cached source at EOF, compile
-	 * it now.
-	 */
-	E(source)->next = 0;
-	p = Pp(&d, 0, SOURCE);
-	p->down = compile(T(source), 1, f);
-    }
+    /* if there's any cached source at EOF, compile
+     * it now.
+     */
+    uncache(&source, &d, f);
     return T(d);
 }
 
@@ -1194,7 +1268,7 @@ actually_a_table(MMIOT *f, Line *pp)
     int c;
 
     /* tables need to be turned on */
-    if ( f->flags & (MKD_STRICT|MKD_NOTABLES) )
+    if ( is_flag_set(f->flags, MKD_STRICT) || is_flag_set(f->flags, MKD_NOTABLES) )
 	return 0;
 
     /* tables need three lines */
@@ -1249,10 +1323,11 @@ compile(Line *ptr, int toplevel, MMIOT *f)
     ptr = consume(ptr, &para);
 
     while ( ptr ) {
+
 	if ( iscode(ptr) ) {
 	    p = Pp(&d, ptr, CODE);
 	    
-	    if ( f->flags & MKD_1_COMPAT) {
+	    if ( is_flag_set(f->flags, MKD_1_COMPAT) ) {
 		/* HORRIBLE STANDARDS KLUDGE: the first line of every block
 		 * has trailing whitespace trimmed off.
 		 */
@@ -1290,13 +1365,39 @@ compile(Line *ptr, int toplevel, MMIOT *f)
 	    ptr = headerblock(p, hdr_type);
 	}
 	else {
-	    p = Pp(&d, ptr, MARKUP);
-	    ptr = textblock(p, toplevel, f->flags);
-	    /* tables are a special kind of paragraph */
-	    if ( actually_a_table(f, p->text) )
-		p->typ = TABLE;
+	    /* either markup or an html block element
+	     */
+	    struct kw *tag;
+	    int unclosed = 1;
+
+	    p = Pp(&d, ptr, MARKUP);	/* default to regular markup,
+					 * then check if it's an html
+					 * block.   If it IS an html
+					 * block, htmlblock() will
+					 * populate this paragraph &
+					 * all we need to do is reset
+					 * the paragraph type to HTML,
+					 * otherwise the paragraph
+					 * remains empty and ready for
+					 * processing with textblock()
+					 */
+	    
+	    if ( !is_flag_set(f->flags, MKD_NOHTML) && (tag = isopentag(ptr)) ) {
+		/* possibly an html block
+		 */
+		
+		ptr = htmlblock(p, tag, &unclosed);
+		if ( ! unclosed ) {
+		    p->typ = HTML;
+		}
+	    }
+	    if ( unclosed ) {
+		ptr = textblock(p, toplevel, f->flags);
+		/* tables are a special kind of paragraph */
+		if ( actually_a_table(f, p->text) )
+		    p->typ = TABLE;
+	    }
 	}
-
 	if ( (para||toplevel) && !p->align )
 	    p->align = PARA;
 
@@ -1321,7 +1422,7 @@ compile(Line *ptr, int toplevel, MMIOT *f)
  * prepare and compile `text`, returning a Paragraph tree.
  */
 int
-mkd_compile(Document *doc, DWORD flags)
+mkd_compile(Document *doc, mkd_flag_t flags)
 {
     if ( !doc )
 	return 0;
@@ -1329,9 +1430,10 @@ mkd_compile(Document *doc, DWORD flags)
     flags &= USER_FLAGS;
     
     if ( doc->compiled ) {
-	if ( doc->ctx->flags == flags )
+	if ( doc->ctx->flags == flags && !doc->dirty)
 	    return 1;
 	else {
+	    doc->compiled = doc->dirty = 0;
 	    if ( doc->code)
 		___mkd_freeParagraph(doc->code);
 	    if ( doc->ctx->footnotes )