bluecloth 2.0.6.pre120-x86-mswin32

data/ext/markdown.h

@@ -0,0 +1,146 @@
+#ifndef _MARKDOWN_D
+#define _MARKDOWN_D
+
+#include "cstring.h"
+
+/* reference-style links (and images) are stored in an array
+ * of footnotes.
+ */
+typedef struct footnote {
+    Cstring tag;		/* the tag for the reference link */
+    Cstring link;		/* what this footnote points to */
+    Cstring title;		/* what it's called (TITLE= attribute) */
+    int height, width;		/* dimensions (for image link) */
+    int dealloc;		/* deallocation needed? */
+} Footnote;
+
+/* each input line is read into a Line, which contains the line,
+ * the offset of the first non-space character [this assumes 
+ * that all tabs will be expanded to spaces!], and a pointer to
+ * the next line.
+ */
+typedef struct line {
+    Cstring text;
+    struct line *next;
+    int dle;
+} Line;
+
+
+/* a paragraph is a collection of Lines, with links to the next paragraph
+ * and (if it's a QUOTE, UL, or OL) to the reparsed contents of this
+ * paragraph.
+ */
+typedef struct paragraph {
+    struct paragraph *next;	/* next paragraph */
+    struct paragraph *down;	/* recompiled contents of this paragraph */
+    struct line *text;		/* all the text in this paragraph */
+    char *ident;		/* %id% tag for QUOTE */
+    enum { WHITESPACE=0, CODE, QUOTE, MARKUP,
+	   HTML, STYLE, DL, UL, OL, AL, LISTITEM,
+	   HDR, HR, TABLE, SOURCE } typ;
+    enum { IMPLICIT=0, PARA, CENTER} align;
+    int hnumber;		/* <Hn> for typ == HDR */
+} Paragraph;
+
+enum { ETX, SETEXT };	/* header types */
+
+
+typedef struct block {
+    enum { bTEXT, bSTAR, bUNDER } b_type;
+    int  b_count;
+    char b_char;
+    Cstring b_text;
+    Cstring b_post;
+} block;
+
+typedef STRING(block) Qblock;
+
+
+/* a magic markdown io thing holds all the data structures needed to
+ * do the backend processing of a markdown document
+ */
+typedef struct mmiot {
+    Cstring out;
+    Cstring in;
+    Qblock Q;
+    int isp;
+    STRING(Footnote) *footnotes;
+    int flags;
+#define DENY_A		0x0001
+#define DENY_IMG	0x0002
+#define DENY_SMARTY	0x0004
+#define DENY_HTML	0x0008
+#define STRICT		0x0010
+#define INSIDE_TAG	0x0020
+#define NO_PSEUDO_PROTO	0x0040
+#define CDATA_OUTPUT	0x0080
+#define NOTABLES	0x0400
+#define TOC		0x1000
+#define MKD_1_COMPAT	0x2000
+#define AUTOLINK	0x4000
+#define SAFELINK	0x8000
+#define USER_FLAGS	0xFCFF
+#define EMBEDDED	DENY_A|DENY_IMG|NO_PSEUDO_PROTO|CDATA_OUTPUT
+    char *base;
+} MMIOT;
+
+
+/*
+ * the mkdio text input functions return a document structure,
+ * which contains a header (retrieved from the document if
+ * markdown was configured * with the * --enable-pandoc-header
+ * and the document begins with a pandoc-style header) and the
+ * root of the linked list of Lines.
+ */
+typedef struct document {
+    Line *headers;		/* title -> author(s) -> date */
+    ANCHOR(Line) content;	/* uncompiled text, not valid after compile() */
+    Paragraph *code;		/* intermediate code generated by compile() */
+    int compiled;		/* set after mkd_compile() */
+    int html;			/* set after (internal) htmlify() */
+    int tabstop;		/* for properly expanding tabs (ick) */
+    MMIOT *ctx;			/* backend buffers, flags, and structures */
+    char *base;			/* url basename for url fragments */
+} Document;
+
+
+extern int  mkd_firstnonblank(Line *);
+extern int  mkd_compile(Document *, int);
+extern int  mkd_document(Document *, char **);
+extern int  mkd_generatehtml(Document *, FILE *);
+extern int  mkd_css(Document *, char **);
+extern int  mkd_generatecss(Document *, FILE *);
+#define mkd_style mkd_generatecss
+extern int  mkd_xml(char *, int , char **);
+extern int  mkd_generatexml(char *, int, FILE *);
+extern void mkd_cleanup(Document *);
+extern int  mkd_line(char *, int, char **, int);
+extern int  mkd_generateline(char *, int, FILE*, int);
+#define mkd_text mkd_generateline
+extern void mkd_basename(Document*, char *);
+extern void mkd_string_to_anchor(char*,int, void(*)(int,void*), void*);
+
+extern Document *mkd_in(FILE *, int);
+extern Document *mkd_string(char*,int, int);
+
+#define NO_HEADER	0x0100
+#define STD_TABSTOP	0x0200
+#define INPUT_MASK	(NO_HEADER|STD_TABSTOP)
+
+
+/* internal resource handling functions.
+ */
+extern void ___mkd_freeLine(Line *);
+extern void ___mkd_freeLines(Line *);
+extern void ___mkd_freeParagraph(Paragraph *);
+extern void ___mkd_freefootnote(Footnote *);
+extern void ___mkd_freefootnotes(MMIOT *);
+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_emblock(MMIOT*);
+extern void ___mkd_tidy(Cstring *);
+
+#endif/*_MARKDOWN_D*/

data/ext/mkdio.c

@@ -0,0 +1,303 @@
+/*
+ * mkdio -- markdown front end input functions
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+typedef ANCHOR(Line) LineAnchor;
+
+/* create a new blank Document
+ */
+static Document*
+new_Document()
+{
+    Document *ret = calloc(sizeof(Document), 1);
+
+    if ( ret ) {
+	if (( ret->ctx = calloc(sizeof(MMIOT), 1) ))
+	    return ret;
+	free(ret);
+    }
+    return 0;
+}
+
+
+/* add a line to the markdown input chain
+ */
+static void
+queue(Document* a, Cstring *line)
+{
+    Line *p = calloc(sizeof *p, 1);
+    unsigned char c;
+    int xp = 0;
+    int           size = S(*line);
+    unsigned char *str = (unsigned char*)T(*line);
+
+    CREATE(p->text);
+    ATTACH(a->content, p);
+
+    while ( size-- ) {
+	if ( (c = *str++) == '\t' ) {
+	    /* expand tabs into ->tabstop spaces.  We use ->tabstop
+	     * because the ENTIRE FREAKING COMPUTER WORLD uses editors
+	     * that don't do ^T/^D, but instead use tabs for indentation,
+	     * and, of course, set their tabs down to 4 spaces 
+	     */
+	    do {
+		EXPAND(p->text) = ' ';
+	    } while ( ++xp % a->tabstop );
+	}
+	else if ( c >= ' ' ) {
+	    EXPAND(p->text) = c;
+	    ++xp;
+	}
+    }
+    EXPAND(p->text) = 0;
+    S(p->text)--;
+    p->dle = mkd_firstnonblank(p);
+}
+
+
+#ifdef PANDOC_HEADER
+/* trim leading blanks from a header line
+ */
+static void
+snip(Line *p)
+{
+    CLIP(p->text, 0, 1);
+    p->dle = mkd_firstnonblank(p);
+}
+#endif
+
+
+/* build a Document from any old input.
+ */
+typedef int (*getc_func)(void*);
+
+Document *
+populate(getc_func getc, void* ctx, int flags)
+{
+    Cstring line;
+    Document *a = new_Document();
+    int c;
+#ifdef PANDOC_HEADER
+    int pandoc = 0;
+#endif
+
+    if ( !a ) return 0;
+
+    a->tabstop = (flags & STD_TABSTOP) ? 4 : TABSTOP;
+
+    CREATE(line);
+
+    while ( (c = (*getc)(ctx)) != EOF ) {
+	if ( c == '\n' ) {
+#ifdef PANDOC_HEADER
+	    if ( pandoc != EOF && pandoc < 3 ) {
+		if ( S(line) && (T(line)[0] == '%') )
+		    pandoc++;
+		else
+		    pandoc = EOF;
+	    }
+#endif
+	    queue(a, &line);
+	    S(line) = 0;
+	}
+	else if ( isprint(c) || isspace(c) || (c & 0x80) )
+	    EXPAND(line) = c;
+    }
+
+    if ( S(line) )
+	queue(a, &line);
+
+    DELETE(line);
+
+#ifdef PANDOC_HEADER
+    if ( (pandoc == 3) && !(flags & NO_HEADER) ) {
+	/* the first three lines started with %, so we have a header.
+	 * clip the first three lines out of content and hang them
+	 * off header.
+	 */
+	a->headers = T(a->content);
+	T(a->content) = a->headers->next->next->next;
+	a->headers->next->next->next = 0;
+	snip(a->headers);
+	snip(a->headers->next);
+	snip(a->headers->next->next);
+    }
+#endif
+
+    return a;
+}
+
+
+/* convert a file into a linked list
+ */
+Document *
+mkd_in(FILE *f, int flags)
+{
+    return populate((getc_func)fgetc, f, flags & INPUT_MASK);
+}
+
+
+/* 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)
+{
+    if ( !in->size ) return EOF;
+
+    --(in->size);
+
+    return *(in->data)++;
+}
+
+
+/* convert a block of text into a linked list
+ */
+Document *
+mkd_string(char *buf, int len, int flags)
+{
+    struct string_ctx about;
+
+    about.data = buf;
+    about.size = len;
+
+    return populate((getc_func)strget, &about, flags & INPUT_MASK);
+}
+
+
+/* write the html to a file (xmlified if necessary)
+ */
+int
+mkd_generatehtml(Document *p, FILE *output)
+{
+    char *doc;
+    int szdoc;
+
+    if ( (szdoc = mkd_document(p, &doc)) != EOF ) {
+	if ( p->ctx->flags & CDATA_OUTPUT )
+	    mkd_generatexml(doc, szdoc, output);
+	else
+	    fwrite(doc, szdoc, 1, output);
+	putc('\n', output);
+	return 0;
+    }
+    return -1;
+}
+
+
+/* convert some markdown text to html
+ */
+int
+markdown(Document *document, FILE *out, int flags)
+{
+    if ( mkd_compile(document, flags) ) {
+	mkd_generatehtml(document, out);
+	mkd_cleanup(document);
+	return 0;
+    }
+    return -1;
+}
+
+
+void
+mkd_basename(Document *document, char *base)
+{
+    if ( document )
+	document->base = base;
+}
+
+
+/* write out a Cstring, mangled into a form suitable for `<a href=` or `<a id=`
+ */
+void
+mkd_string_to_anchor(char *s, int len, void(*outchar)(int,void*), void *out)
+{
+    unsigned char c;
+    
+    for ( ; len-- > 0; ) {
+	c = *s++;
+	if ( c == ' ' || c == '&' || c == '<' || c == '"' )
+	    (*outchar)('+', out);
+	else if ( isalnum(c) || ispunct(c) || (c & 0x80) )
+	    (*outchar)(c, out);
+	else
+	    (*outchar)('~',out);
+    }
+}
+
+
+/*  ___mkd_reparse() a line
+ */
+static void
+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_emblock(f);
+}
+
+
+/* ___mkd_reparse() a line, returning it in malloc()ed memory
+ */
+int
+mkd_line(char *bfr, int size, char **res, int flags)
+{
+    MMIOT f;
+    int len;
+    
+    mkd_parse_line(bfr, size, &f, flags);
+
+    if ( len = S(f.out) ) {
+	/* kludge alert;  we know that T(f.out) is malloced memory,
+	 * so we can just steal it away.   This is awful -- there
+	 * should be an opaque method that transparently moves 
+	 * the pointer out of the embedded Cstring.
+	 */
+	*res = T(f.out);
+	T(f.out) = 0;
+	S(f.out) = 0;
+    }
+    else {
+	 *res = 0;
+	 len = EOF;
+     }
+    ___mkd_freemmiot(&f, 0);
+    return len;
+}
+
+
+/* ___mkd_reparse() a line, writing it to a FILE
+ */
+int
+mkd_generateline(char *bfr, int size, FILE *output, int flags)
+{
+    MMIOT f;
+
+    mkd_parse_line(bfr, size, &f, flags);
+    if ( flags & CDATA_OUTPUT )
+	mkd_generatexml(T(f.out), S(f.out), output);
+    else
+	fwrite(T(f.out), S(f.out), 1, output);
+
+    ___mkd_freemmiot(&f, 0);
+    return 0;
+}

data/ext/mkdio.h

@@ -0,0 +1,79 @@
+#ifndef _MKDIO_D
+#define _MKDIO_D
+
+#include <stdio.h>
+
+typedef void MMIOT;
+
+/* line builder for markdown()
+ */
+MMIOT *mkd_in(FILE*,int);		/* assemble input from a file */
+MMIOT *mkd_string(char*,int,int);	/* assemble input from a buffer */
+
+void mkd_basename(MMIOT*,char*);
+
+/* compilation, debugging, cleanup
+ */
+int mkd_compile(MMIOT*, int);
+int mkd_cleanup(MMIOT*);
+
+/* markup functions
+ */
+int mkd_dump(MMIOT*, FILE*, int, char*);
+int markdown(MMIOT*, FILE*, int);
+int mkd_line(char *, int, char **, int);
+void mkd_string_to_anchor(char *, int, int (*)(int,void*), void*);
+int mkd_xhtmlpage(MMIOT*,int,FILE*);
+
+/* header block access
+ */
+char* mkd_doc_title(MMIOT*);
+char* mkd_doc_author(MMIOT*);
+char* mkd_doc_date(MMIOT*);
+
+/* compiled data access
+ */
+int mkd_document(MMIOT*, char**);
+int mkd_toc(MMIOT*, char**);
+int mkd_css(MMIOT*, char **);
+int mkd_xml(char *, int, char **);
+
+/* write-to-file functions
+ */
+int mkd_generatehtml(MMIOT*,FILE*);
+int mkd_generatetoc(MMIOT*,FILE*);
+int mkd_generatexml(char *, int,FILE*);
+int mkd_generatecss(MMIOT*,FILE*);
+#define mkd_style mkd_generatecss
+int mkd_generateline(char *, int, FILE*, int);
+#define mkd_text mkd_generateline
+
+/* version#.
+ */
+extern char markdown_version[];
+
+/* special flags for markdown() and mkd_text()
+ */
+#define MKD_NOLINKS	0x0001	/* don't do link processing, block <a> tags  */
+#define MKD_NOIMAGE	0x0002	/* don't do image processing, block <img> */
+#define MKD_NOPANTS	0x0004	/* don't run smartypants() */
+#define MKD_NOHTML	0x0008	/* don't allow raw html through AT ALL */
+#define MKD_STRICT	0x0010	/* disable SUPERSCRIPT, RELAXED_EMPHASIS */
+#define MKD_TAGTEXT	0x0020	/* process text inside an html tag; no
+				 * <em>, no <bold>, no html or [] expansion */
+#define MKD_NO_EXT	0x0040	/* don't allow pseudo-protocols */
+#define MKD_CDATA	0x0080	/* generate code for xml ![CDATA[...]] */
+#define MKD_NOTABLES	0x0400	/* disallow tables */
+#define MKD_TOC		0x1000	/* do table-of-contents processing */
+#define MKD_1_COMPAT	0x2000	/* compatability with MarkdownTest_1.0 */
+#define MKD_AUTOLINK	0x4000	/* make http://foo.com link even without <>s */
+#define MKD_SAFELINK	0x8000	/* paranoid check for link protocol */
+#define MKD_EMBED	MKD_NOLINKS|MKD_NOIMAGE|MKD_TAGTEXT
+
+/* special flags for mkd_in() and mkd_string()
+ */
+#define MKD_NOHEADER	0x0100	/* don't process header blocks */
+#define MKD_TABSTOP	0x0200	/* expand tabs to 4 spaces */
+
+
+#endif/*_MKDIO_D*/