bluecloth 2.0.5-x86-mingw32

data/ext/resource.c

@@ -0,0 +1,155 @@
+/* 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);
+    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); i++)
+	    ___mkd_freefootnote( &T(*f->footnotes)[i] );
+	DELETE(*f->footnotes);
+	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);
+	}
+    }
+}
+
+
+/* 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 ) {
+	if ( doc->ctx ) {
+	    ___mkd_freemmiot(doc->ctx, 0);
+	    free(doc->ctx);
+	}
+
+	if ( doc->code) ___mkd_freeParagraph(doc->code);
+	if ( doc->headers ) ___mkd_freeLines(doc->headers);
+	if ( T(doc->content) ) ___mkd_freeLines(T(doc->content));
+	memset(doc, 0, sizeof doc[0]);
+	free(doc);
+    }
+}

data/ext/version.c

@@ -0,0 +1,28 @@
+#include "config.h"
+
+char markdown_version[] = VERSION
+#if DL_TAG_EXTENSION
+		" DL_TAG"
+#endif
+#if PANDOC_HEADER
+		" HEADER"
+#endif
+#if 4 != 4
+		" TAB=4"
+#endif
+#if USE_AMALLOC
+		" DEBUG"
+#endif
+#if SUPERSCRIPT
+		" SUPERSCRIPT"
+#endif
+#if RELAXED_EMPHASIS
+		" RELAXED"
+#endif
+#if DIV_QUOTE
+		" DIV"
+#endif
+#if ALPHA_LIST
+		" AL"
+#endif
+		;

data/ext/xml.c

@@ -0,0 +1,82 @@
+/* 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"
+
+/* return the xml version of a character
+ */
+static char *
+mkd_xmlchar(unsigned char c)
+{
+    switch (c) {
+    case '<':   return "&lt;";
+    case '>':   return "&gt;";
+    case '&':   return "&amp;";
+    case '"':   return "&quot;";
+    case '\'':  return "&apos;";
+    default:    if ( isascii(c) || (c & 0x80) )
+		    return 0;
+		return "";
+    }
+}
+
+
+/* write output in XML format
+ */
+int
+mkd_generatexml(char *p, int size, FILE *out)
+{
+    unsigned char c;
+    char *entity;
+
+    while ( size-- > 0 ) {
+	c = *p++;
+
+	if ( entity = mkd_xmlchar(c) )
+	    fputs(entity, out);
+	else
+	    fputc(c, out);
+    }
+    return 0;
+}
+
+
+/* build a xml'ed version of a string
+ */
+int
+mkd_xml(char *p, int size, char **res)
+{
+    unsigned char c;
+    char *entity;
+    Cstring f;
+
+    CREATE(f);
+    RESERVE(f, 100);
+
+    while ( size-- > 0 ) {
+	c = *p++;
+	if ( entity = mkd_xmlchar(c) )
+	    Cswrite(&f, entity, strlen(entity));
+	else
+	    Csputc(c, &f);
+    }
+			/* HACK ALERT! HACK ALERT! HACK ALERT! */
+    *res = T(f);	/* we know that a T(Cstring) is a character pointer */
+			/* so we can simply pick it up and carry it away, */
+    return S(f);	/* leaving the husk of the Ctring on the stack */
+			/* END HACK ALERT */
+}

data/ext/xmlpage.c

@@ -0,0 +1,48 @@
+/*
+ * xmlpage -- write a skeletal xhtml page
+ *
+ * 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"
+
+
+int
+mkd_xhtmlpage(Document *p, int flags, FILE *out)
+{
+    char *title;
+    extern char *mkd_doc_title(Document *);
+    
+    if ( mkd_compile(p, flags) ) {
+	fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+	fprintf(out, "<!DOCTYPE html "
+		     " PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\""
+		     " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
+
+	fprintf(out, "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n");
+
+	fprintf(out, "<head>\n");
+	if ( title = mkd_doc_title(p) )
+	    fprintf(out, "<title>%s</title>\n", title);
+	mkd_generatecss(p, out);
+	fprintf(out, "</head>\n");
+	
+	fprintf(out, "<body>\n");
+	mkd_generatehtml(p, out);
+	fprintf(out, "</body>\n");
+	fprintf(out, "</html>\n");
+	
+	mkd_cleanup(p);
+
+	return 0;
+    }
+    return -1;
+}

data/lib/bluecloth.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/ruby
+
+# 
+# Bluecloth is a Ruby implementation of Markdown, a text-to-HTML conversion
+# tool.
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# == Contributors
+#
+# * Martin Chase <stillflame@FaerieMUD.org> - Peer review, helpful suggestions
+# * Florian Gross <flgr@ccan.de> - Filter options, suggestions
+#
+# This product includes software developed by David Loren Parsons
+# <http://www.pell.portland.or.us/~orc>.
+# 
+# == Version
+#
+#  $Id$
+# 
+# == License
+# 
+# :include: LICENSE
+#--
+# Please see the LICENSE file included in the distribution for copyright and licensing details.
+# 
+class BlueCloth
+
+	# Release Version
+	VERSION = '2.0.5'
+
+	# SVN Revision
+	SVNREV = %q$Rev$
+
+	# SVN Id tag
+	SVNID = %q$Id$
+
+	# The defaults for all supported options.
+	DEFAULT_OPTIONS = {
+		:remove_links    => false,
+		:remove_images   => false,
+		:smartypants     => true,
+		:pseudoprotocols => false,
+		:pandoc_headers  => false,
+		:header_labels   => false,
+		:escape_html     => false,
+		:strict_mode     => true,
+		:auto_links      => false,
+		:safe_links      => false,
+	}.freeze
+
+	# The number of characters of the original markdown source to include in the 
+	# output of #inspect
+	INSPECT_TEXT_LENGTH = 50
+
+
+	#################################################################
+	###	C L A S S   M E T H O D S
+	#################################################################
+
+	### Convert the specified +opthash+ into a flags bitmask. If it's already a
+	### Fixnum (e.g., if someone passed in an ORed flags argument instead of an
+	### opthash), just return it as-is.
+	def self::flags_from_opthash( opthash={} )
+		return opthash if opthash.is_a?( Integer )
+
+		# Support BlueCloth1-style options
+		if opthash == :filter_html || opthash == [:filter_html]
+			opthash = { :escape_html => true }
+		elsif opthash == :filter_styles
+			opthash = {}
+		elsif !opthash.is_a?( Hash )
+			raise ArgumentError, "option %p not supported" % [ opthash ]
+		end
+
+		flags = 0
+
+        if   opthash[:remove_links]    then flags |= MKD_NOLINKS;  end
+        if   opthash[:remove_images]   then flags |= MKD_NOIMAGE;  end
+        if ! opthash[:smartypants]     then flags |= MKD_NOPANTS;  end
+        if ! opthash[:pseudoprotocols] then flags |= MKD_NO_EXT;   end
+        if ! opthash[:pandoc_headers]  then flags |= MKD_NOHEADER; end
+        if   opthash[:header_labels]   then flags |= MKD_TOC;      end
+        if   opthash[:mdtest_1_compat] then flags |= MKD_1_COMPAT; end
+        if   opthash[:escape_html]     then flags |= MKD_NOHTML;   end
+        if   opthash[:strict_mode]     then flags |= MKD_STRICT;   end
+        if   opthash[:tagtext_mode]    then flags |= MKD_TAGTEXT;  end
+        if   opthash[:auto_links]      then flags |= MKD_AUTOLINK; end
+        if   opthash[:safe_links]      then flags |= MKD_SAFELINK; end
+
+		return flags
+	end
+
+
+	### Returns a Hash that reflects the settings from the specified +flags+ Integer.
+	def self::opthash_from_flags( flags=0 )
+		flags = flags.to_i
+
+		opthash = {}
+        if  ( flags & MKD_NOLINKS  ).nonzero? then opthash[:remove_links]    = true; end
+        if  ( flags & MKD_NOIMAGE  ).nonzero? then opthash[:remove_images]   = true; end
+        if !( flags & MKD_NOPANTS  ).nonzero? then opthash[:smartypants]     = true; end
+        if !( flags & MKD_NO_EXT   ).nonzero? then opthash[:pseudoprotocols] = true; end
+        if !( flags & MKD_NOHEADER ).nonzero? then opthash[:pandoc_headers]  = true; end
+        if  ( flags & MKD_TOC      ).nonzero? then opthash[:header_labels]   = true; end
+        if  ( flags & MKD_1_COMPAT ).nonzero? then opthash[:mdtest_1_compat] = true; end
+        if  ( flags & MKD_NOHTML   ).nonzero? then opthash[:escape_html]     = true; end
+        if  ( flags & MKD_STRICT   ).nonzero? then opthash[:strict_mode]     = true; end
+        if  ( flags & MKD_TAGTEXT  ).nonzero? then opthash[:tagtext_mode]    = true; end
+        if  ( flags & MKD_AUTOLINK ).nonzero? then opthash[:auto_links]      = true; end
+        if  ( flags & MKD_SAFELINK ).nonzero? then opthash[:safe_links]      = true; end
+
+		return opthash
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Return a human-readable representation of the object suitable for debugging.
+	def inspect
+		return "#<%s:0x%x text: %p; options: %p>" % [
+			self.class.name,
+			self.object_id / 2,
+			self.text.length > INSPECT_TEXT_LENGTH ?
+				self.text[ 0, INSPECT_TEXT_LENGTH - 5] + '[...]' :
+				self.text,
+			self.options,
+		]
+	end
+
+
+	### Backward-compatible method: return +true+ if the object's :escape_html option was
+	### set.
+	def filter_html
+		return self.options[:escape_html]
+	end
+
+
+	### Backward-compatible method: raises an appropriate error notifying the user that
+	### BlueCloth2 doesn't support this option.
+	def filter_html=( arg )
+		raise NotImplementedError,
+			"Sorry, this version of BlueCloth no longer supports toggling of HTML filtering" +
+			"via #filter_html=. You now must create the BlueCloth object with the :escape_html" +
+			"option set to true instead."
+	end
+
+
+
+end # class BlueCloth
+
+require 'bluecloth_ext'
+
+# Set the top-level 'Markdown' constant if it isn't already set
+::Markdown = ::BlueCloth unless defined?( ::Markdown )
+
+