rdiscountwl 1.0.0.1

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,146 @@
+/* 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>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#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; /* this opt is a synonym */
+    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 },
+    { "dldiscount",    "discount-style definition lists", 1, 0, 1, MKD_NODLDISCOUNT },
+    { "dlextra",       "extra-style definition lists", 0, 0, 1, MKD_DLEXTRA },
+    { "fencedcode",    "fenced code blocks",         0, 0, 1, MKD_FENCEDCODE },
+    { "idanchor",      "id= anchors in TOC",         0, 0, 1, MKD_IDANCHOR },
+    { "githubtags",    "permit - and _ in element names", 0, 0, 0, MKD_GITHUBTAGS },
+    { "urlencodedanchor", "urlencode special chars in TOC links", 0, 0, 0, MKD_URLENCODEDANCHOR },
+} ;
+
+#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;
+}

data/ext/pgm_options.h

@@ -0,0 +1,9 @@
+#ifndef PGM_OPTIONS_D
+#define PGM_OPTIONS_D
+
+#include <mkdio.h>
+
+int set_flag(mkd_flag_t *flags, char *optionstring);
+void show_flags(int byname);
+
+#endif/*PGM_OPTIONS_D*/

data/ext/rdiscount.c

@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <locale.h>
+#include "ruby.h"
+#include "mkdio.h"
+
+typedef struct {
+    char *accessor_name;
+    int flag;
+} AccessorFlagPair;
+
+/* 
+ * Maps accessor names on the RDiscount object to Discount flags.
+ * 
+ * The following flags are handled specially:
+ * - MKD_TABSTOP: Always set.
+ * - MKD_NOHEADER: Always set.
+ * - MKD_DLEXTRA: Always set. (For compatibility with RDiscount 2.1.8 and earlier.)
+ * - MKD_FENCEDCODE: Always set. (For compatibility with RDiscount 2.1.8 and earlier.)
+ * - MKD_GITHUBTAGS: Always set. (For compatibility with RDiscount 2.1.8 and earlier.)
+ * - MKD_NOPANTS: Set unless the "smart" accessor returns true.
+ * 
+ * See rb_rdiscount__get_flags() for the detailed implementation.
+ */
+static AccessorFlagPair ACCESSOR_2_FLAG[] = {
+    { "filter_html", MKD_NOHTML },
+    { "footnotes", MKD_EXTRA_FOOTNOTE },
+    { "generate_toc", MKD_TOC },
+    { "no_image", MKD_NOIMAGE },
+    { "no_links", MKD_NOLINKS },
+    { "no_tables", MKD_NOTABLES },
+    { "strict", MKD_STRICT },
+    { "autolink", MKD_AUTOLINK },
+    { "safelink", MKD_SAFELINK },
+    { "no_pseudo_protocols", MKD_NO_EXT },
+    { "no_superscript", MKD_NOSUPERSCRIPT },
+    { "no_strikethrough", MKD_NOSTRIKETHROUGH },
+    { NULL, 0 }     /* sentinel */
+};
+
+static VALUE rb_cRDiscount;
+
+int rb_rdiscount__get_flags(VALUE ruby_obj)
+{
+    AccessorFlagPair *entry;
+    
+    /* compile flags */
+    int flags = MKD_TABSTOP | MKD_NOHEADER | MKD_DLEXTRA | MKD_FENCEDCODE | MKD_GITHUBTAGS;
+    
+    /* The "smart" accessor turns OFF the MKD_NOPANTS flag. */
+    if ( rb_funcall(ruby_obj, rb_intern("smart"), 0) != Qtrue ) {
+        flags = flags | MKD_NOPANTS;
+    }
+    
+    /* Handle standard flags declared in ACCESSOR_2_FLAG */
+    for ( entry = ACCESSOR_2_FLAG; entry->accessor_name; entry++ ) {
+        if ( rb_funcall(ruby_obj, rb_intern(entry->accessor_name), 0) == Qtrue ) {
+            flags = flags | entry->flag;
+        }
+    }
+    
+    return flags;
+}
+
+static VALUE
+rb_rdiscount_to_html(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    char *res;
+    int szres;
+    VALUE encoding;
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    VALUE buf = rb_str_buf_new(1024);
+    Check_Type(text, T_STRING);
+
+    int flags = rb_rdiscount__get_flags(self);
+    
+    /* 
+     * Force Discount to use ASCII character encoding for isalnum(), isalpha(),
+     * and similar functions.
+     * 
+     * Ruby tends to use UTF-8 encoding, which is ill-defined for these
+     * functions since they expect 8-bit codepoints (and UTF-8 has codepoints
+     * of at least 21 bits).
+     */
+    char *old_locale = strdup(setlocale(LC_CTYPE, NULL));
+    setlocale(LC_CTYPE, "C");   /* ASCII (and passthru characters > 127) */
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_document(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+    setlocale(LC_CTYPE, old_locale);
+    free(old_locale);
+
+    /* force the input encoding */
+    if ( rb_respond_to(text, rb_intern("encoding")) ) {
+        encoding = rb_funcall(text, rb_intern("encoding"), 0);
+        rb_funcall(buf, rb_intern("force_encoding"), 1, encoding);
+    }
+
+    return buf;
+}
+
+static VALUE
+rb_rdiscount_toc_content(int argc, VALUE *argv, VALUE self)
+{
+    char *res;
+    int szres;
+
+    int flags = rb_rdiscount__get_flags(self);
+
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+
+    /* allocate a ruby string buffer and wrap it in a stream */
+    VALUE buf = rb_str_buf_new(4096);
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_toc(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+    return buf;
+}
+
+
+void Init_rdiscount()
+{
+    rb_cRDiscount = rb_define_class("RDiscount", rb_cObject);
+    rb_define_method(rb_cRDiscount, "to_html", rb_rdiscount_to_html, -1);
+    rb_define_method(rb_cRDiscount, "toc_content", rb_rdiscount_toc_content, -1);
+}
+
+/* vim: set ts=4 sw=4: */

data/ext/resource.c

@@ -0,0 +1,159 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "config.h"
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+/* free a (single) line
+ */
+void
+___mkd_freeLine(Line *ptr)
+{
+    DELETE(ptr->text);
+    free(ptr);
+}
+
+
+/* free a list of lines
+ */
+void
+___mkd_freeLines(Line *p)
+{
+    if (p->next)
+	 ___mkd_freeLines(p->next);
+    ___mkd_freeLine(p);
+}
+
+
+/* bye bye paragraph.
+ */
+void
+___mkd_freeParagraph(Paragraph *p)
+{
+    if (p->next)
+	___mkd_freeParagraph(p->next);
+    if (p->down)
+	___mkd_freeParagraph(p->down);
+    if (p->text)
+	___mkd_freeLines(p->text);
+    if (p->ident)
+	free(p->ident);
+    if (p->lang)
+	free(p->lang);
+    free(p);
+}
+
+
+/* bye bye footnote.
+ */
+void
+___mkd_freefootnote(Footnote *f)
+{
+    DELETE(f->tag);
+    DELETE(f->link);
+    DELETE(f->title);
+}
+
+
+/* bye bye footnotes.
+ */
+void
+___mkd_freefootnotes(MMIOT *f)
+{
+    int i;
+
+    if ( f->footnotes ) {
+	for (i=0; i < S(f->footnotes->note); i++)
+	    ___mkd_freefootnote( &T(f->footnotes->note)[i] );
+	DELETE(f->footnotes->note);
+	free(f->footnotes);
+    }
+}
+
+
+/* initialize a new MMIOT
+ */
+void
+___mkd_initmmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	memset(f, 0, sizeof *f);
+	CREATE(f->in);
+	CREATE(f->out);
+	CREATE(f->Q);
+	if ( footnotes )
+	    f->footnotes = footnotes;
+	else {
+	    f->footnotes = malloc(sizeof f->footnotes[0]);
+	    CREATE(f->footnotes->note);
+	}
+    }
+}
+
+
+/* free the contents of a MMIOT, but leave the object alone.
+ */
+void
+___mkd_freemmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	DELETE(f->in);
+	DELETE(f->out);
+	DELETE(f->Q);
+	if ( f->footnotes != footnotes )
+	    ___mkd_freefootnotes(f);
+	memset(f, 0, sizeof *f);
+    }
+}
+
+
+/* free lines up to an barrier.
+ */
+void
+___mkd_freeLineRange(Line *anchor, Line *stop)
+{
+    Line *r = anchor->next;
+
+    if ( r != stop ) {
+	while ( r && (r->next != stop) )
+	    r = r->next;
+	if ( r ) r->next = 0;
+	___mkd_freeLines(anchor->next);
+    }
+    anchor->next = 0;
+}
+
+
+/* clean up everything allocated in __mkd_compile()
+ */
+void
+mkd_cleanup(Document *doc)
+{
+    if ( doc && (doc->magic == VALID_DOCUMENT) ) {
+	if ( doc->ctx ) {
+	    ___mkd_freemmiot(doc->ctx, 0);
+	    free(doc->ctx);
+	}
+
+	if ( doc->code) ___mkd_freeParagraph(doc->code);
+	if ( doc->title) ___mkd_freeLine(doc->title);
+	if ( doc->author) ___mkd_freeLine(doc->author);
+	if ( doc->date) ___mkd_freeLine(doc->date);
+	if ( T(doc->content) ) ___mkd_freeLines(T(doc->content));
+	memset(doc, 0, sizeof doc[0]);
+	free(doc);
+    }
+}

data/ext/setup.c

@@ -0,0 +1,39 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * 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 <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+#include "tags.h"
+    
+static int need_to_initrng = 1;
+
+void
+mkd_initialize()
+{
+
+    if ( need_to_initrng ) {
+	need_to_initrng = 0;
+	INITRNG(time(0));
+    }
+}
+
+
+void
+mkd_shlib_destructor()
+{
+    mkd_deallocate_tags();
+}
+

data/ext/tags.c

@@ -0,0 +1,94 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#define __WITHOUT_AMALLOC 1
+#include "cstring.h"
+#include "tags.h"
+
+STRING(struct kw) extratags;
+
+/* the standard collection of tags are built and sorted when
+ * discount is configured, so all we need to do is pull them
+ * in and use them.
+ *
+ * Additional tags still need to be allocated, sorted, and deallocated.
+ */
+#include "blocktags"
+
+
+/* define an additional html block tag
+ */
+void
+mkd_define_tag(char *id, int selfclose)
+{
+    struct kw *p;
+
+    /* only add the new tag if it doesn't exist in
+     * either the standard or extra tag tables.
+     */
+    if ( !(p = mkd_search_tags(id, strlen(id))) ) {
+	/* extratags could be deallocated */
+	if ( S(extratags) == 0 )
+	    CREATE(extratags);
+	p = &EXPAND(extratags);
+	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*);
+
+
+/* sort the list of extra html block tags for later searching
+ */
+void
+mkd_sort_tags()
+{
+    qsort(T(extratags), S(extratags), sizeof(struct kw), (stfu)casort);
+}
+
+
+/* look for a token in the html block tag list
+ */
+struct kw*
+mkd_search_tags(char *pat, int len)
+{
+    struct kw key;
+    struct kw *ret;
+    
+    key.id = pat;
+    key.size = len;
+    
+    if ( (ret=bsearch(&key,blocktags,NR_blocktags,sizeof key,(stfu)casort)) )
+	return ret;
+
+    if ( S(extratags) )
+	return bsearch(&key,T(extratags),S(extratags),sizeof key,(stfu)casort);
+    
+    return 0;
+}
+
+
+/* destroy the extratags list (for shared libraries)
+ */
+void
+mkd_deallocate_tags()
+{
+    if ( S(extratags) > 0 )
+	DELETE(extratags);
+} /* mkd_deallocate_tags */

data/ext/tags.h

@@ -0,0 +1,19 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#ifndef _TAGS_D
+#define _TAGS_D
+
+struct kw {
+    char *id;
+    int  size;
+    int  selfclose;
+} ;
+
+
+struct kw* mkd_search_tags(char *, int);
+void mkd_prepare_tags();
+void mkd_deallocate_tags();
+void mkd_sort_tags();
+void mkd_define_tag(char *, int);
+
+#endif