parkdown-libertree 1.4.26

data/ext/markdown_peg.h

@@ -0,0 +1,90 @@
+/* markdown_peg.h */
+#ifndef MARKDOWN_PEG_H
+#define MARKDOWN_PEG_H
+
+#include "markdown_lib.h"
+#include <glib.h>
+
+/* Information (label, URL and title) for a link. */
+struct Link {
+    struct Element   *label;
+    char             *url;
+    char             *title;    
+};
+
+typedef struct Link link;
+
+/* Information (label and two sources) for a media link. */
+struct Media {
+    struct Element   *label;
+    char             *source1;
+    char             *source2;
+};
+
+typedef struct Media media;
+
+/* Union for contents of an Element (string, list, link, or media). */
+union Contents {
+    char             *str;
+    struct Link      *link;
+    struct Media     *media;
+};
+
+/* Types of semantic values returned by parsers. */ 
+enum keys { LIST,   /* A generic list of values.  For ordered and bullet lists, see below. */
+            RAW,    /* Raw markdown to be processed further */
+            SPACE,
+            LINEBREAK,
+            ELLIPSIS,
+            EMDASH,
+            ENDASH,
+            ENSPACE,
+            APOSTROPHE,
+            SINGLEQUOTED,
+            DOUBLEQUOTED,
+            STR,
+            LINK,
+            IMAGE,
+            MEDIA,
+            AUDIO,
+            VIDEO,
+            CODE,
+            HTML,
+            EMPH,
+            STRONG,
+            STRIKE,
+            PLAIN,
+            PARA,
+            LISTITEM,
+            BULLETLIST,
+            ORDEREDLIST,
+            H1, H2, H3, H4, H5, H6,  /* Code assumes that these are in order. */
+            BLOCKQUOTE,
+            SPOILERBLOCK,
+            VERBATIM,
+            HASHTAG,
+            USERNAME,
+            HTMLBLOCK,
+            HRULE,
+            REFERENCE,
+            NOTE
+          };
+
+/* Semantic value of a parsing action. */
+struct Element {
+    int               key;
+    union Contents    contents;
+    struct Element    *children;
+    struct Element    *next;
+};
+
+typedef struct Element element;
+
+element * parse_references(char *string, int extensions);
+element * parse_notes(char *string, int extensions, element *reference_list);
+element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list);
+void free_element_list(element * elt);
+void free_element(element *elt);
+void print_element_list(GString *out, element *elt, int format, int exts);
+
+#endif

data/ext/parsing_functions.c

@@ -0,0 +1,128 @@
+/* parsing_functions.c - Functions for parsing markdown and
+ * freeing element lists. */
+
+/* These yy_* functions come from markdown_parser.c which is
+ * generated from markdown_parser.leg
+ * */
+typedef int (*yyrule)();
+
+extern int yyparse();
+extern int yyparsefrom(yyrule);
+extern int yy_References();
+extern int yy_Notes();
+extern int yy_Doc();
+
+#include "utility_functions.h"
+#include "parsing_functions.h"
+#include "markdown_peg.h"
+
+static void free_element_contents(element elt);
+
+/* free_element_list - free list of elements recursively */
+void free_element_list(element * elt) {
+    element * next = NULL;
+    while (elt != NULL) {
+        next = elt->next;
+        free_element_contents(*elt);
+        if (elt->children != NULL) {
+            free_element_list(elt->children);
+            elt->children = NULL;
+        }
+        free(elt);
+        elt = next;
+    }
+}
+
+/* free_element_contents - free element contents depending on type */
+static void free_element_contents(element elt) {
+    switch (elt.key) {
+      case STR:
+      case SPACE:
+      case RAW:
+      case HTMLBLOCK:
+      case HTML:
+      case VERBATIM:
+      case CODE:
+      case NOTE:
+        free(elt.contents.str);
+        elt.contents.str = NULL;
+        break;
+      case LINK:
+      case IMAGE:
+      case REFERENCE:
+        free(elt.contents.link->url);
+        elt.contents.link->url = NULL;
+        free(elt.contents.link->title);
+        elt.contents.link->title = NULL;
+        free_element_list(elt.contents.link->label);
+        free(elt.contents.link);
+        elt.contents.link = NULL;
+        break;
+      case MEDIA:
+      case AUDIO:
+      case VIDEO:
+        free(elt.contents.media->source1);
+        elt.contents.media->source1 = NULL;
+        free(elt.contents.media->source2);
+        elt.contents.media->source2 = NULL;
+        free_element_list(elt.contents.media->label);
+        free(elt.contents.media);
+        elt.contents.media = NULL;
+        break;
+      default:
+        ;
+    }
+}
+
+/* free_element - free element and contents */
+void free_element(element *elt) {
+    free_element_contents(*elt);
+    free(elt);
+}
+
+element * parse_references(char *string, int extensions) {
+
+    char *oldcharbuf;
+    syntax_extensions = extensions;
+
+    oldcharbuf = charbuf;
+    charbuf = string;
+    yyparsefrom(yy_References);    /* first pass, just to collect references */
+    charbuf = oldcharbuf;
+
+    return references;
+}
+
+element * parse_notes(char *string, int extensions, element *reference_list) {
+
+    char *oldcharbuf;
+    notes = NULL;
+    syntax_extensions = extensions;
+
+    if (extension(EXT_NOTES)) {
+        references = reference_list;
+        oldcharbuf = charbuf;
+        charbuf = string;
+        yyparsefrom(yy_Notes);     /* second pass for notes */
+        charbuf = oldcharbuf;
+    }
+
+    return notes;
+}
+
+element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list) {
+
+    char *oldcharbuf;
+    syntax_extensions = extensions;
+    references = reference_list;
+    notes = note_list;
+
+    oldcharbuf = charbuf;
+    charbuf = string;
+
+    yyparsefrom(yy_Doc);
+
+    charbuf = oldcharbuf;          /* restore charbuf to original value */
+    return parse_result;
+
+}

data/ext/utility_functions.c

@@ -0,0 +1,217 @@
+/* utility_functions.c - List manipulation functions, element
+ * constructors, and macro definitions for leg markdown parser. */
+
+#include "utility_functions.h"
+#include "markdown_peg.h"
+
+#include <string.h>
+#include <assert.h>
+
+
+/**********************************************************************
+
+  List manipulation functions
+
+ ***********************************************************************/
+
+/* cons - cons an element onto a list, returning pointer to new head */
+element * cons(element *new, element *list) {
+    assert(new != NULL);
+    new->next = list;
+    return new;
+}
+
+/* reverse - reverse a list, returning pointer to new list */
+element *reverse(element *list) {
+    element *new = NULL;
+    element *next = NULL;
+    while (list != NULL) {
+        next = list->next;
+        new = cons(list, new);
+        list = next;
+    }
+    return new;
+}
+
+/* concat_string_list - concatenates string contents of list of STR elements.
+ * Frees STR elements as they are added to the concatenation. */
+GString *concat_string_list(element *list) {
+    GString *result;
+    element *next;
+    result = g_string_new("");
+    while (list != NULL) {
+        assert(list->key == STR);
+        assert(list->contents.str != NULL);
+        g_string_append(result, list->contents.str);
+        next = list->next;
+        free_element(list);
+        list = next;
+    }
+    return result;
+}
+
+/**********************************************************************
+
+  Global variables used in parsing
+
+ ***********************************************************************/
+
+char *charbuf = "";     /* Buffer of characters to be parsed. */
+element *references = NULL;    /* List of link references found. */
+element *notes = NULL;         /* List of footnotes found. */
+element *parse_result;  /* Results of parse. */
+int syntax_extensions;  /* Syntax extensions selected. */
+
+/**********************************************************************
+
+  Auxiliary functions for parsing actions.
+  These make it easier to build up data structures (including lists)
+  in the parsing actions.
+
+ ***********************************************************************/
+
+/* mk_element - generic constructor for element */
+element * mk_element(int key) {
+    element *result = malloc(sizeof(element));
+    result->key = key;
+    result->children = NULL;
+    result->next = NULL;
+    result->contents.str = NULL;
+    return result;
+}
+
+/* mk_str - constructor for STR element */
+element * mk_str(char *string) {
+    element *result;
+    assert(string != NULL);
+    result = mk_element(STR);
+    result->contents.str = strdup(string);
+    return result;
+}
+
+/* mk_str_from_list - makes STR element by concatenating a
+ * reversed list of strings, adding optional extra newline */
+element * mk_str_from_list(element *list, bool extra_newline) {
+    element *result;
+    GString *c = concat_string_list(reverse(list));
+    if (extra_newline)
+        g_string_append(c, "\n");
+    result = mk_element(STR);
+    result->contents.str = c->str;
+    g_string_free(c, false);
+    return result;
+}
+
+/* mk_list - makes new list with key 'key' and children the reverse of 'lst'.
+ * This is designed to be used with cons to build lists in a parser action.
+ * The reversing is necessary because cons adds to the head of a list. */
+element * mk_list(int key, element *lst) {
+    element *result;
+    result = mk_element(key);
+    result->children = reverse(lst);
+    return result;
+}
+
+/* mk_link - constructor for LINK element */
+element * mk_link(element *label, char *url, char *title) {
+    element *result;
+    result = mk_element(LINK);
+    result->contents.link = malloc(sizeof(link));
+    result->contents.link->label = label;
+    result->contents.link->url = strdup(url);
+    result->contents.link->title = strdup(title);
+    return result;
+}
+
+/* mk_media - constructor for AUDIO and VIDEO element */
+element * mk_media(element *label, char *source1, char *source2) {
+    element *result;
+    result = mk_element(MEDIA);
+    result->contents.media = malloc(sizeof(media));
+    result->contents.media->label = label;
+    result->contents.media->source1 = strdup(source1);
+    result->contents.media->source2 = strdup(source2);
+    return result;
+}
+
+/* extension = returns true if extension is selected */
+bool extension(int ext) {
+    return (syntax_extensions & ext);
+}
+
+/* match_inlines - returns true if inline lists match (case-insensitive...) */
+bool match_inlines(element *l1, element *l2) {
+    while (l1 != NULL && l2 != NULL) {
+        if (l1->key != l2->key)
+            return false;
+        switch (l1->key) {
+        case SPACE:
+        case LINEBREAK:
+        case ELLIPSIS:
+        case EMDASH:
+        case ENDASH:
+        case APOSTROPHE:
+            break;
+        case CODE:
+        case STR:
+        case HTML:
+            if (strcasecmp(l1->contents.str, l2->contents.str) == 0)
+                break;
+            else
+                return false;
+        case EMPH:
+        case STRONG:
+        case LIST:
+        case SINGLEQUOTED:
+        case DOUBLEQUOTED:
+            if (match_inlines(l1->children, l2->children))
+                break;
+            else
+                return false;
+        case LINK:
+        case IMAGE:
+            return false;  /* No links or images within links */
+        default:
+            fprintf(stderr, "match_inlines encountered unknown key = %d\n", l1->key);
+            exit(EXIT_FAILURE);
+            break;
+        }
+        l1 = l1->next;
+        l2 = l2->next;
+    }
+    return (l1 == NULL && l2 == NULL);  /* return true if both lists exhausted */
+}
+
+/* find_reference - return true if link found in references matching label.
+ * 'link' is modified with the matching url and title. */
+bool find_reference(link *result, element *label) {
+    element *cur = references;  /* pointer to walk up list of references */
+    link *curitem;
+    while (cur != NULL) {
+        curitem = cur->contents.link;
+        if (match_inlines(label, curitem->label)) {
+            *result = *curitem;
+            return true;
+        }
+        else
+            cur = cur->next;
+    }
+    return false;
+}
+
+/* find_note - return true if note found in notes matching label.
+if found, 'result' is set to point to matched note. */
+
+bool find_note(element **result, char *label) {
+   element *cur = notes;  /* pointer to walk up list of notes */
+   while (cur != NULL) {
+       if (strcmp(label, cur->contents.str) == 0) {
+           *result = cur;
+           return true;
+       }
+       else
+           cur = cur->next;
+   }
+   return false;
+}
+

data/lib/markdown.rb

@@ -0,0 +1 @@
+require 'peg_markdown'

data/lib/peg_markdown.rb

@@ -0,0 +1,104 @@
+require 'peg_markdown.so'
+
+# Front-end to jgm's peg-markdown implementation of Markdown, the humane
+# text markup language.
+#
+# A simple processor:
+#   >>> puts Markdown.new("Hello, World.").to_html
+#   <p>Hello, World.</p>
+#
+# With other stuff:
+#   >>> puts Markdown.new("_Hello -- World!_", :smart, :filter_html).to_html
+#   <p><em>Hello World!</em></p>
+#
+class PEGMarkdown
+
+  # Original Markdown formatted text.
+  attr_reader :text
+
+  # Set true to have smarty-like quote translation performed.
+  attr_accessor :smart
+
+  # Set true to have footnotes processed.
+  attr_accessor :notes
+
+  # Do not output <style> tags included in the source text.
+  attr_accessor :filter_styles
+
+  # Do not output any raw HTML included in the source text.
+  attr_accessor :filter_html
+
+  # Included for compatibility with RedCloth's interface.
+  attr_accessor :fold_lines
+
+  # Set true to enable strike-through extension.
+  attr_accessor :strike
+
+  # Set true to enable autolink extension.
+  attr_accessor :autolink
+
+  # Set true to enable hard wrap extension.
+  attr_accessor :hard_wrap
+
+  # Set true to disable rendering of images.
+  attr_accessor :no_images
+
+  # Set true to enable audio/video extension.
+  attr_accessor :media
+
+  # Set true to enable codeblock extension.
+  attr_accessor :codeblock
+
+  # Set true to enable hashtags extension.
+  attr_accessor :hashtags
+
+  # Set true to enable usernames extension.
+  attr_accessor :usernames
+
+  # Set true to enable spoilerblock extension.
+  attr_accessor :spoilerblock
+
+  # Create a new Markdown processor. The +text+ argument is a string
+  # containing Markdown text. Variable other arguments may be supplied to
+  # set various processing options:
+  #
+  # * <tt>:smart</tt> - Enable SmartyPants processing.
+  # * <tt>:notes</tt> - Enable footnotes.
+  # * <tt>:filter_styles</tt> - Do not output <style> tags included in the
+  #   source text.
+  # * <tt>:filter_html</tt> - Do not output raw HTML included in the
+  #   source text.
+  # * <tt>:fold_lines</tt> - RedCloth compatible line folding (not used).
+  # * <tt>:strike</tt> - Enable strike-through extension.
+  # * <tt>:autolink</tt> - Enable autolinking of bare URLs.
+  # * <tt>:hard_wrap</tt> - Insert line breaks inside paragraphs.
+  # * <tt>:no_images</tt> - Treat image links as if they were plain links.
+  # * <tt>:media</tt> - Replace audio/video links with HTML5 audio/video objects.
+  # * <tt>:codeblock</tt> - Render block enclosed in ~~~ as verbatim section.
+  # * <tt>:hashtags</tt> - Mark hashtags.
+  # * <tt>:usernames</tt> - Mark usernames.
+  # * <tt>:spoilerblock</tt> - Render block prefixed with ?> as spoiler section.
+  #
+  def initialize(text, *extensions)
+    @text = text
+    @smart = false
+    @notes = false
+    @filter_styles = false
+    @filter_html = false
+    @strike = false
+    @autolink = false
+    @hard_wrap = false
+    @no_images = false
+    @media = false
+    @codeblock = false
+    @hashtags = false
+    @usernames = false
+    @spoilerblock = false
+    extensions.each { |e| send("#{e}=", true) }
+  end
+
+  alias to_s text
+
+end
+
+Markdown = PEGMarkdown unless defined? Markdown