rdiscount 2.0.7.3 → 2.1.6

data/ext/markdown.h

@@ -23,10 +23,20 @@ typedef struct footnote {
  * that all tabs will be expanded to spaces!], and a pointer to
  * the next line.
  */
+typedef enum { chk_text, chk_code,
+	       chk_hr, chk_dash,
+	       chk_tilde, chk_backtick,
+	       chk_equal } line_type;
 typedef struct line {
     Cstring text;
     struct line *next;
-    int dle;
+    int dle;			/* leading indent on the line */
+    int flags;			/* special attributes for this line */
+#define PIPECHAR	0x01		/* line contains a | */
+#define CHECKED		0x02
+
+    line_type kind;
+    int count;
 } Line;
 
 
@@ -71,6 +81,12 @@ typedef struct callback_data {
 } Callback_data;
 
 
+struct escaped { 
+    char *text;
+    struct escaped *up;
+} ;
+
+
 /* a magic markdown io thing holds all the data structures needed to
  * do the backend processing of a markdown document
  */
@@ -80,6 +96,7 @@ typedef struct mmiot {
     Qblock Q;
     int isp;
     int reference;
+    struct escaped *esc;
     char *ref_prefix;
     STRING(Footnote) *footnotes;
     DWORD flags;
@@ -105,6 +122,7 @@ typedef struct mmiot {
 #define MKD_NOALPHALIST	0x00080000
 #define MKD_NODLIST	0x00100000
 #define MKD_EXTRA_FOOTNOTE 0x00200000
+#define MKD_NOSTYLE	0x00400000
 #define IS_LABEL	0x08000000
 #define USER_FLAGS	0x0FFFFFFF
 #define INPUT_MASK	(MKD_NOHEADER|MKD_TABSTOP)
@@ -137,6 +155,16 @@ typedef struct document {
 } Document;
 
 
+/*
+ * economy FILE-type structure for pulling characters out of a
+ * fixed-length string.
+ */
+struct string_stream {
+    const char *data;	/* the unread data */
+    int   size;		/* and how much is there? */
+} ;
+
+
 extern int  mkd_firstnonblank(Line *);
 extern int  mkd_compile(Document *, DWORD);
 extern int  mkd_document(Document *, char **);
@@ -156,7 +184,10 @@ typedef int (*mkd_sta_function_t)(const int,const void*);
 extern void mkd_string_to_anchor(char*,int, mkd_sta_function_t, void*, int);
 
 extern Document *mkd_in(FILE *, DWORD);
-extern Document *mkd_string(char*,int, DWORD);
+extern Document *mkd_string(const char*,int, DWORD);
+
+extern Document *gfm_in(FILE *, DWORD);
+extern Document *gfm_string(const char*,int, DWORD);
 
 extern void mkd_initialize();
 extern void mkd_shlib_destructor();
@@ -174,8 +205,14 @@ extern void ___mkd_initmmiot(MMIOT *, void *);
 extern void ___mkd_freemmiot(MMIOT *, void *);
 extern void ___mkd_freeLineRange(Line *, Line *);
 extern void ___mkd_xml(char *, int, FILE *);
-extern void ___mkd_reparse(char *, int, int, MMIOT*);
+extern void ___mkd_reparse(char *, int, int, MMIOT*, char*);
 extern void ___mkd_emblock(MMIOT*);
 extern void ___mkd_tidy(Cstring *);
 
+extern Document *__mkd_new_Document();
+extern void __mkd_enqueue(Document*, Cstring *);
+extern void __mkd_header_dle(Line *);
+
+extern int  __mkd_io_strget(struct string_stream *);
+
 #endif/*_MARKDOWN_D*/

data/ext/mkdio.c

@@ -18,13 +18,13 @@ typedef ANCHOR(Line) LineAnchor;
 
 /* create a new blank Document
  */
-static Document*
-new_Document()
+Document*
+__mkd_new_Document()
 {
     Document *ret = calloc(sizeof(Document), 1);
 
     if ( ret ) {
-	if (( ret->ctx = calloc(sizeof(MMIOT), 1) )) {
+	if ( ret->ctx = calloc(sizeof(MMIOT), 1) ) {
 	    ret->magic = VALID_DOCUMENT;
 	    return ret;
 	}
@@ -34,10 +34,11 @@ new_Document()
 }
 
 
-/* add a line to the markdown input chain
+/* add a line to the markdown input chain, expanding tabs and
+ * noting the presence of special characters as we go.
  */
-static void
-queue(Document* a, Cstring *line)
+void
+__mkd_enqueue(Document* a, Cstring *line)
 {
     Line *p = calloc(sizeof *p, 1);
     unsigned char c;
@@ -60,6 +61,8 @@ queue(Document* a, Cstring *line)
 	    } while ( ++xp % a->tabstop );
 	}
 	else if ( c >= ' ' ) {
+	    if ( c == '|' )
+		p->flags |= PIPECHAR;
 	    EXPAND(p->text) = c;
 	    ++xp;
 	}
@@ -72,8 +75,8 @@ queue(Document* a, Cstring *line)
 
 /* trim leading blanks from a header line
  */
-static void
-header_dle(Line *p)
+void
+__mkd_header_dle(Line *p)
 {
     CLIP(p->text, 0, 1);
     p->dle = mkd_firstnonblank(p);
@@ -88,7 +91,7 @@ Document *
 populate(getc_func getc, void* ctx, int flags)
 {
     Cstring line;
-    Document *a = new_Document();
+    Document *a = __mkd_new_Document();
     int c;
     int pandoc = 0;
 
@@ -106,7 +109,7 @@ populate(getc_func getc, void* ctx, int flags)
 		else
 		    pandoc = EOF;
 	    }
-	    queue(a, &line);
+	    __mkd_enqueue(a, &line);
 	    S(line) = 0;
 	}
 	else if ( isprint(c) || isspace(c) || (c & 0x80) )
@@ -114,7 +117,7 @@ populate(getc_func getc, void* ctx, int flags)
     }
 
     if ( S(line) )
-	queue(a, &line);
+	__mkd_enqueue(a, &line);
 
     DELETE(line);
 
@@ -125,9 +128,9 @@ populate(getc_func getc, void* ctx, int flags)
 	 */
 	Line *headers = T(a->content);
 
-	a->title = headers;             header_dle(a->title);
-	a->author= headers->next;       header_dle(a->author);
-	a->date  = headers->next->next; header_dle(a->date);
+	a->title = headers;             __mkd_header_dle(a->title);
+	a->author= headers->next;       __mkd_header_dle(a->author);
+	a->date  = headers->next->next; __mkd_header_dle(a->date);
 
 	T(a->content) = headers->next->next->next;
     }
@@ -147,14 +150,8 @@ mkd_in(FILE *f, DWORD flags)
 
 /* return a single character out of a buffer
  */
-struct string_ctx {
-    char *data;		/* the unread data */
-    int   size;		/* and how much is there? */
-} ;
-
-
-static int
-strget(struct string_ctx *in)
+int
+__mkd_io_strget(struct string_stream *in)
 {
     if ( !in->size ) return EOF;
 
@@ -167,14 +164,14 @@ strget(struct string_ctx *in)
 /* convert a block of text into a linked list
  */
 Document *
-mkd_string(char *buf, int len, DWORD flags)
+mkd_string(const char *buf, int len, DWORD flags)
 {
-    struct string_ctx about;
+    struct string_stream about;
 
     about.data = buf;
     about.size = len;
 
-    return populate((getc_func)strget, &about, flags & INPUT_MASK);
+    return populate((getc_func)__mkd_io_strget, &about, flags & INPUT_MASK);
 }
 
 
@@ -225,7 +222,7 @@ mkd_string_to_anchor(char *s, int len, mkd_sta_function_t outchar,
 
     size = mkd_line(s, len, &line, IS_LABEL);
     
-    if ( labelformat && size && !isalpha(line[0]) )
+    if ( labelformat && (size>0) && !isalpha(line[0]) )
 	(*outchar)('L',out);
     for ( i=0; i < size ; i++ ) {
 	c = line[i];
@@ -233,7 +230,7 @@ mkd_string_to_anchor(char *s, int len, mkd_sta_function_t outchar,
 	    if ( isalnum(c) || (c == '_') || (c == ':') || (c == '-') || (c == '.' ) )
 		(*outchar)(c, out);
 	    else
-		(*outchar)('.',out);
+		(*outchar)('.', out);
 	}
 	else
 	    (*outchar)(c,out);
@@ -251,7 +248,7 @@ mkd_parse_line(char *bfr, int size, MMIOT *f, int flags)
 {
     ___mkd_initmmiot(f, 0);
     f->flags = flags & USER_FLAGS;
-    ___mkd_reparse(bfr, size, 0, f);
+    ___mkd_reparse(bfr, size, 0, f, 0);
     ___mkd_emblock(f);
 }
 

data/ext/mkdio.h

@@ -10,7 +10,12 @@ typedef unsigned int mkd_flag_t;
 /* line builder for markdown()
  */
 MMIOT *mkd_in(FILE*,mkd_flag_t);		/* assemble input from a file */
-MMIOT *mkd_string(char*,int,mkd_flag_t);	/* assemble input from a buffer */
+MMIOT *mkd_string(const char*,int,mkd_flag_t);	/* assemble input from a buffer */
+
+/* line builder for github flavoured markdown
+ */
+MMIOT *gfm_in(FILE*,mkd_flag_t);		/* assemble input from a file */
+MMIOT *gfm_string(const char*,int,mkd_flag_t);	/* assemble input from a buffer */
 
 void mkd_basename(MMIOT*,char*);
 
@@ -21,7 +26,7 @@ void mkd_shlib_destructor();
 /* compilation, debugging, cleanup
  */
 int mkd_compile(MMIOT*, mkd_flag_t);
-int mkd_cleanup(MMIOT*);
+void mkd_cleanup(MMIOT*);
 
 /* markup functions
  */
@@ -84,6 +89,7 @@ void mkd_ref_prefix(MMIOT*, char*);
 #define MKD_TAGTEXT	0x00000020	/* process text inside an html tag; no
 					 * <em>, no <bold>, no html or [] expansion */
 #define MKD_NO_EXT	0x00000040	/* don't allow pseudo-protocols */
+#define MKD_NOEXT	MKD_NO_EXT	/* ^^^ (aliased for user convenience) */
 #define MKD_CDATA	0x00000080	/* generate code for xml ![CDATA[...]] */
 #define MKD_NOSUPERSCRIPT 0x00000100	/* no A^B */
 #define MKD_NORELAXED	0x00000200	/* emphasis happens /everywhere/ */
@@ -99,6 +105,7 @@ void mkd_ref_prefix(MMIOT*, char*);
 #define MKD_NOALPHALIST	0x00080000	/* forbid alphabetic lists */
 #define MKD_NODLIST	0x00100000	/* forbid definition lists */
 #define MKD_EXTRA_FOOTNOTE 0x00200000	/* enable markdown extra-style footnotes */
+#define MKD_NOSTYLE	0x00400000	/* don't extract <style> blocks */
 #define MKD_EMBED	MKD_NOLINKS|MKD_NOIMAGE|MKD_TAGTEXT
 
 /* special flags for mkd_in() and mkd_string()

data/ext/mktags.c

@@ -0,0 +1,89 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#include <stdio.h>
+
+#define __WITHOUT_AMALLOC 1
+#include "cstring.h"
+#include "tags.h"
+
+STRING(struct kw) blocktags;
+
+
+/* define a html block tag
+ */
+static void
+define_one_tag(char *id, int selfclose)
+{
+    struct kw *p = &EXPAND(blocktags);
+
+    p->id = id;
+    p->size = strlen(id);
+    p->selfclose = selfclose;
+}
+
+
+/* case insensitive string sort (for qsort() and bsearch() of block tags)
+ */
+static int
+casort(struct kw *a, struct kw *b)
+{
+    if ( a->size != b->size )
+	return a->size - b->size;
+    return strncasecmp(a->id, b->id, b->size);
+}
+
+
+/* stupid cast to make gcc shut up about the function types being
+ * passed into qsort() and bsearch()
+ */
+typedef int (*stfu)(const void*,const void*);
+
+
+/* load in the standard collection of html tags that markdown supports
+ */
+main()
+{
+    int i;
+
+#define KW(x)	define_one_tag(x, 0)
+#define SC(x)	define_one_tag(x, 1)
+
+    KW("STYLE");
+    KW("SCRIPT");
+    KW("ADDRESS");
+    KW("BDO");
+    KW("BLOCKQUOTE");
+    KW("CENTER");
+    KW("DFN");
+    KW("DIV");
+    KW("OBJECT");
+    KW("H1");
+    KW("H2");
+    KW("H3");
+    KW("H4");
+    KW("H5");
+    KW("H6");
+    KW("LISTING");
+    KW("NOBR");
+    KW("UL");
+    KW("P");
+    KW("OL");
+    KW("DL");
+    KW("PLAINTEXT");
+    KW("PRE");
+    KW("TABLE");
+    KW("WBR");
+    KW("XMP");
+    SC("HR");
+    KW("IFRAME");
+    KW("MAP");
+
+    qsort(T(blocktags), S(blocktags), sizeof(struct kw), (stfu)casort);
+
+    printf("static struct kw blocktags[] = {\n");
+    for (i=0; i < S(blocktags); i++)
+	printf("   { \"%s\", %d, %d },\n", T(blocktags)[i].id, T(blocktags)[i].size, T(blocktags)[i].selfclose );
+    printf("};\n\n");
+    printf("#define NR_blocktags %d\n", S(blocktags));
+    exit(0);
+}

data/ext/pgm_options.c

@@ -0,0 +1,138 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2007-2011 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <unistd.h>
+#include <mkdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "config.h"
+#include "amalloc.h"
+
+#if HAVE_LIBGEN_H
+#include <libgen.h>
+#endif
+
+static struct _opt {
+    char *name;
+    char *desc;
+    int off;
+    int skip;
+    int sayenable;
+    mkd_flag_t flag;
+} opts[] = {
+    { "tabstop",       "default (4-space) tabstops", 0, 0, 1, MKD_TABSTOP  },
+    { "image",         "images",                     1, 0, 1, MKD_NOIMAGE  },
+    { "links",         "links",                      1, 0, 1, MKD_NOLINKS  },
+    { "relax",         "emphasis inside words",      1, 1, 1, MKD_STRICT   },
+    { "strict",        "emphasis inside words",      0, 0, 1, MKD_STRICT   },
+    { "tables",        "tables",                     1, 0, 1, MKD_NOTABLES },
+    { "header",        "pandoc-style headers",       1, 0, 1, MKD_NOHEADER },
+    { "html",          "raw html",                   1, 0, 1, MKD_NOHTML   },
+    { "ext",           "extended protocols",         1, 0, 1, MKD_NO_EXT   },
+    { "cdata",         "generate cdata",             0, 0, 0, MKD_CDATA    },
+    { "smarty",        "smartypants",                1, 0, 1, MKD_NOPANTS  },
+    { "pants",         "smartypants",                1, 1, 1, MKD_NOPANTS  },
+    { "toc",           "tables of contents",         0, 0, 1, MKD_TOC      },
+    { "autolink",      "autolinking",                0, 0, 1, MKD_AUTOLINK },
+    { "safelink",      "safe links",                 0, 0, 1, MKD_SAFELINK },
+    { "strikethrough", "strikethrough",              1, 0, 1, MKD_NOSTRIKETHROUGH },
+    { "del",           "strikethrough",              1, 1, 1, MKD_NOSTRIKETHROUGH },
+    { "superscript",   "superscript",                1, 0, 1, MKD_NOSUPERSCRIPT },
+    { "emphasis",      "emphasis inside words",      0, 0, 1, MKD_NORELAXED },
+    { "divquote",      ">%class% blockquotes",       1, 0, 1, MKD_NODIVQUOTE },
+    { "alphalist",     "alpha lists",                1, 0, 1, MKD_NOALPHALIST },
+    { "definitionlist","definition lists",           1, 0, 1, MKD_NODLIST },
+    { "1.0",           "markdown 1.0 compatibility", 0, 0, 1, MKD_1_COMPAT },
+    { "footnotes",     "markdown extra footnotes",   0, 0, 1, MKD_EXTRA_FOOTNOTE },
+    { "footnote",      "markdown extra footnotes",   0, 1, 1, MKD_EXTRA_FOOTNOTE },
+    { "style",         "extract style blocks",       1, 0, 1, MKD_NOSTYLE },
+} ;
+
+#define NR(x)	(sizeof x / sizeof x[0])
+
+
+typedef int (*stfu)(const void *, const void *);
+
+int
+sort_by_name(struct _opt *a, struct _opt *b)
+{
+    return strcmp(a->name,b->name);
+}
+
+int
+sort_by_flag(struct _opt *a, struct _opt *b)
+{
+    return a->flag - b->flag;
+}
+
+
+void
+show_flags(int byname)
+{
+    int i;
+
+    if ( byname ) {
+	qsort(opts, NR(opts), sizeof(opts[0]), (stfu)sort_by_name);
+    
+	for (i=0; i < NR(opts); i++)
+	    if ( ! opts[i].skip )
+		fprintf(stderr, "%16s : %s\n", opts[i].name, opts[i].desc);
+    }
+    else {
+	qsort(opts, NR(opts), sizeof(opts[0]), (stfu)sort_by_flag);
+	
+	for (i=0; i < NR(opts); i++)
+	    if ( ! opts[i].skip ) {
+		fprintf(stderr, "%08lx : ", (long)opts[i].flag);
+		if ( opts[i].sayenable )
+		    fprintf(stderr, opts[i].off ? "disable " : "enable ");
+		fprintf(stderr, "%s\n", opts[i].desc);
+	    }
+    }
+}
+    
+
+int
+set_flag(mkd_flag_t *flags, char *optionstring)
+{
+    int i;
+    int enable;
+    char *arg;
+
+    for ( arg = strtok(optionstring, ","); arg; arg = strtok(NULL, ",") ) {
+	if ( *arg == '+' || *arg == '-' )
+	    enable = (*arg++ == '+') ? 1 : 0;
+	else if ( strncasecmp(arg, "no", 2) == 0 ) {
+	    arg += 2;
+	    enable = 0;
+	}
+	else
+	    enable = 1;
+
+	for ( i=0; i < NR(opts); i++ )
+	    if ( strcasecmp(arg, opts[i].name) == 0 )
+		break;
+
+	if ( i < NR(opts) ) {
+	    if ( opts[i].off )
+		enable = !enable;
+		
+	    if ( enable )
+		*flags |= opts[i].flag;
+	    else
+		*flags &= ~opts[i].flag;
+	}
+	else
+	    return 0;
+    }
+    return 1;
+}