jeremy-RedCloth 4.1.1

data/ext/redcloth_scan/redcloth_inline.rl

@@ -0,0 +1,159 @@
+/*
+ * redcloth_inline.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+%%{
+
+  machine redcloth_inline;
+
+  # links
+  mtext_noquotes = mtext -- '"' ;
+  quoted_mtext = '"' mtext_noquotes '"' ;
+  mtext_including_quotes = (mtext_noquotes ' "' mtext_noquotes '" ' mtext_noquotes?)+ ;
+  link_says = ( C_noactions "."* " "* ((quoted_mtext | mtext_including_quotes | mtext_noquotes) -- '":') ) >A %{ STORE("link_text"); } ;
+  link_says_noquotes_noactions = ( C_noquotes_noactions "."* " "* ((mtext_noquotes) -- '":') ) ;
+  link = ( '"' link_says '":' %A uri %{ STORE_URL("href"); } ) >X ;
+  link_noquotes_noactions = ( '"' link_says_noquotes_noactions '":' uri ) ;
+  bracketed_link = ( '["' link_says '":' %A uri %{ STORE("href"); } :> "]" ) >X ;
+
+  # images
+  image_src = ( uri ) >A %{ STORE("src"); } ;
+  image_is = ( A2 C ". "? image_src :> title? ) ;
+  image_link = ( ":" uri >A %{ STORE_URL("href"); } ) ;
+  image = ( "!" image_is "!" %A image_link? ) >X ;
+  bracketed_image = ( "[!" image_is "!" %A image_link? "]" ) >X ;
+
+  # footnotes
+  footno = "[" >X %A digit+ %T "]" ;
+
+  # markup
+  end_markup_phrase = (" " | PUNCT | EOF | LF) @{ fhold; };
+  code = "["? "@" >X mtext >A %T :> "@" "]"? ;
+  code_tag_start = "<code" [^>]* ">" ;
+  code_tag_end = "</code>" ;
+  script_tag = ( "<script" [^>]* ">" (default+ -- "</script>") "</script>" LF? ) >X >A %T ;
+  notextile = "<notextile>" >X (default+ -- "</notextile>") >A %T "</notextile>";
+  strong = "["? "*" >X mtext >A %T :> "*" "]"? ;
+  b = "["? "**" >X mtext >A %T :> "**" "]"? ;
+  em = "["? "_" >X mtext >A %T :> "_" "]"? ;
+  i = "["? "__" >X mtext >A %T :> "__" "]"? ;
+  del = "[-" >X C ( mtext ) >A %T :>> "-]" ;
+  emdash_parenthetical_phrase_with_spaces = " -- " mtext " -- " ;
+  del_phrase = (( " " >A %{ STORE("beginning_space"); } "-") >X C ( mtext ) >A %T :>> ( "-" end_markup_phrase )) - emdash_parenthetical_phrase_with_spaces ;
+  ins = "["? "+" >X mtext >A %T :> "+" "]"? ;
+  sup = "[^" >X mtext >A %T :> "^]" ;
+  sup_phrase = ( "^" when starts_phrase) >X ( mtext ) >A %T :>> ( "^" end_markup_phrase ) ;
+  sub = "[~" >X mtext >A %T :> "~]" ;
+  sub_phrase = ( "~" when starts_phrase) >X ( mtext ) >A %T :>> ( "~" end_markup_phrase ) ;
+  span = "[%" >X mtext >A %T :> "%]" ;
+  span_phrase = (("%" when starts_phrase) >X ( mtext ) >A %T :>> ( "%" end_markup_phrase )) ;
+  cite = "["? "??" >X mtext >A %T :> "??" "]"? ;
+  ignore = "["? "==" >X %A mtext %T :> "==" "]"? ;
+  snip = "["? "```" >X %A mtext %T :> "```" "]"? ;
+  
+  # quotes
+  quote1 = "'" >X %A mtext %T :> "'" ;
+  non_quote_chars_or_link = (chars -- '"') | link_noquotes_noactions ;
+  mtext_inside_quotes = ( non_quote_chars_or_link (mspace non_quote_chars_or_link)* ) ;
+  html_tag_up_to_attribute_quote = "<" Name space+ NameAttr space* "=" space* ;
+  quote2 = ('"' >X %A ( mtext_inside_quotes - (mtext_inside_quotes html_tag_up_to_attribute_quote ) ) %T :> '"' ) ;
+  multi_paragraph_quote = (('"' when starts_line) >X  %A ( chars -- '"' ) %T );
+  
+  # html
+  start_tag = ( "<" Name space+ AttrSet* (AttrEnd)? ">" | "<" Name ">" ) >X >A %T ;
+  empty_tag = ( "<" Name space+ AttrSet* (AttrEnd)? "/>" | "<" Name "/>" ) >X >A %T ;
+  end_tag = ( "</" Name space* ">" ) >X >A %T ;
+  html_comment = ("<!--" (default+) :>> "-->") >X >A %T;
+
+  # glyphs
+  ellipsis = ( " "? >A %T "..." ) >X ;
+  emdash = "--" ;
+  arrow = "->" ;
+  endash = " - " ;
+  acronym = ( [A-Z] >A [A-Z0-9]{2,} %T "(" default+ >A %{ STORE("title"); } :> ")" ) >X ;
+  caps_noactions = upper{3,} ;
+  caps = ( caps_noactions >A %*T ) >X ;
+  dim_digit = [0-9.]+ ;
+  prime = ("'" | '"')?;
+  dim_noactions = dim_digit prime (("x" | " x ") dim_digit prime) %T (("x" | " x ") dim_digit prime)? ;
+  dim = dim_noactions >X >A %T ;
+  tm = [Tt] [Mm] ;
+  trademark = " "? ( "[" tm "]" | "(" tm ")" ) ;
+  reg = [Rr] ;
+  registered = " "? ( "[" reg "]" | "(" reg ")" ) ;
+  cee = [Cc] ;
+  copyright = ( "[" cee "]" | "(" cee ")" ) ;
+  entity = ( "&" %A ( '#' digit+ | ( alpha ( alpha | digit )+ ) ) %T ';' ) >X ;
+  
+  # info
+  redcloth_version = "[RedCloth::VERSION]" ;
+
+  other_phrase = phrase -- dim_noactions;
+
+  code_tag := |*
+    code_tag_end { CAT(block); fgoto main; };
+    default => esc_pre;
+  *|;
+
+  main := |*
+    
+    image { INLINE(block, "image"); };
+    bracketed_image { INLINE(block, "image"); };
+    
+    link { PARSE_LINK_ATTR("link_text"); PASS(block, "name", "link"); };
+    bracketed_link { PARSE_LINK_ATTR("link_text"); PASS(block, "name", "link"); };
+    
+    code { PARSE_ATTR("text"); PASS_CODE(block, "text", "code", opts); };
+    code_tag_start { CAT(block); fgoto code_tag; };
+    notextile { INLINE(block, "notextile"); };
+    strong { PARSE_ATTR("text"); PASS(block, "text", "strong"); };
+    b { PARSE_ATTR("text"); PASS(block, "text", "b"); };
+    em { PARSE_ATTR("text"); PASS(block, "text", "em"); };
+    i { PARSE_ATTR("text"); PASS(block, "text", "i"); };
+    del { PASS(block, "text", "del"); };
+    del_phrase { PASS(block, "text", "del_phrase"); };
+    ins { PARSE_ATTR("text"); PASS(block, "text", "ins"); };
+    sup { PARSE_ATTR("text"); PASS(block, "text", "sup"); };
+    sup_phrase { PARSE_ATTR("text"); PASS(block, "text", "sup_phrase"); };
+    sub { PARSE_ATTR("text"); PASS(block, "text", "sub"); };
+    sub_phrase { PARSE_ATTR("text"); PASS(block, "text", "sub_phrase"); };
+    span { PARSE_ATTR("text"); PASS(block, "text", "span"); };
+    span_phrase { PARSE_ATTR("text"); PASS(block, "text", "span_phrase"); };
+    cite { PARSE_ATTR("text"); PASS(block, "text", "cite"); };
+    ignore => ignore;
+    snip { PASS(block, "text", "snip"); };
+    quote1 { PASS(block, "text", "quote1"); };
+    quote2 { PASS(block, "text", "quote2"); };
+    multi_paragraph_quote { PASS(block, "text", "multi_paragraph_quote"); };
+    
+    ellipsis { INLINE(block, "ellipsis"); };
+    emdash { INLINE(block, "emdash"); };
+    endash { INLINE(block, "endash"); };
+    arrow { INLINE(block, "arrow"); };
+    caps { INLINE(block, "caps"); };
+    acronym { INLINE(block, "acronym"); };
+    dim { INLINE(block, "dim"); };
+    trademark { INLINE(block, "trademark"); };
+    registered { INLINE(block, "registered"); };
+    copyright { INLINE(block, "copyright"); };
+    footno { PASS(block, "text", "footno"); };
+    entity { INLINE(block, "entity"); };
+    
+    script_tag { INLINE(block, "inline_html"); };
+    start_tag { INLINE(block, "inline_html"); };
+    end_tag { INLINE(block, "inline_html"); };
+    empty_tag { INLINE(block, "inline_html"); };
+    html_comment { INLINE(block, "inline_html"); };
+    
+    redcloth_version { INLINE(block, "inline_redcloth_version"); };
+    
+    other_phrase => esc;
+    PUNCT => esc;
+    space => esc;
+    
+    EOF;
+    
+  *|;
+
+}%%;

data/ext/redcloth_scan/redcloth_scan.c.rl

@@ -0,0 +1,237 @@
+/*
+ * redcloth_scan.c.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+#define redcloth_scan_c
+
+#include <ruby.h>
+#include "redcloth.h"
+
+VALUE mRedCloth, super_ParseError, super_RedCloth, super_HTML, super_LATEX;
+int SYM_escape_preformatted, SYM_escape_attributes;
+
+%%{
+
+  machine redcloth_scan;
+  include redcloth_common "redcloth_common.c.rl";
+
+  action extend { extend = rb_hash_aref(regs, ID2SYM(rb_intern("type"))); }
+
+  include redcloth_scan "redcloth_scan.rl";
+
+}%%
+
+%% write data nofinal;
+
+VALUE
+redcloth_transform(self, p, pe, refs)
+  VALUE self;
+  char *p, *pe;
+  VALUE refs;
+{
+  char *orig_p = p, *orig_pe = pe;
+  int cs, act, nest;
+  char *ts = NULL, *te = NULL, *reg = NULL, *bck = NULL, *eof = NULL;
+  VALUE html = rb_str_new2("");
+  VALUE table = rb_str_new2("");
+  VALUE block = rb_str_new2("");
+  VALUE regs; CLEAR_REGS()
+  
+  
+  VALUE list_layout = Qnil;
+  char *list_type = NULL;
+  VALUE list_index = rb_ary_new();
+  int list_continue = 0;
+  VALUE plain_block; SET_PLAIN_BLOCK("p");
+  VALUE extend = Qnil;
+  char listm[10] = "";
+  VALUE refs_found = rb_hash_new();
+  
+  %% write init;
+
+  %% write exec;
+
+  if (RSTRING_LEN(block) > 0)
+  {
+    ADD_BLOCK();
+  }
+
+  if ( NIL_P(refs) && rb_funcall(refs_found, rb_intern("empty?"), 0) == Qfalse ) {
+    return redcloth_transform(self, orig_p, orig_pe, refs_found);
+  } else {
+    rb_funcall(self, rb_intern("after_transform"), 1, html);
+    return html;
+  }
+}
+
+VALUE
+redcloth_transform2(self, str)
+  VALUE self, str;
+{
+  StringValue(str);
+  rb_funcall(self, rb_intern("before_transform"), 1, str);
+  return redcloth_transform(self, RSTRING_PTR(str), RSTRING_PTR(str) + RSTRING_LEN(str) + 1, Qnil);
+}
+
+/*
+ * Converts special characters into HTML entities.
+ */
+static VALUE
+redcloth_html_esc(int argc, VALUE* argv, VALUE self) //(self, str, level)
+{
+  VALUE str, level;
+  
+  rb_scan_args(argc, argv, "11", &str, &level);
+  
+  VALUE new_str = rb_str_new2("");
+  if (str == Qnil)
+    return new_str;
+    
+  StringValue(str);
+  
+  if (RSTRING_LEN(str) == 0)
+    return new_str;
+  
+  char *ts = RSTRING_PTR(str), *te = RSTRING_PTR(str) + RSTRING_LEN(str);
+  char *t = ts, *t2 = ts, *ch = NULL;
+  if (te <= ts) return;
+
+  while (t2 < te) {
+    ch = NULL;
+    
+    // normal + pre
+    switch (*t2)
+    {
+      case '&':  ch = "amp";    break;
+      case '>':  ch = "gt";     break;
+      case '<':  ch = "lt";     break;
+    }
+    
+    // normal (non-pre)
+    if (level != SYM_escape_preformatted) {
+      switch (*t2)
+      {
+        case '\n': ch = "br";     break;
+        case '"' : ch = "quot";   break;
+        case '\'': 
+          ch = (level == SYM_escape_attributes) ? "apos" : "squot";
+          break;
+      }
+    }
+    
+    if (ch != NULL)
+    {
+      if (t2 > t)
+        rb_str_cat(new_str, t, t2-t);
+      rb_str_concat(new_str, rb_funcall(self, rb_intern(ch), 1, rb_hash_new()));
+      t = t2 + 1;
+    }
+
+    t2++;
+  }
+  if (t2 > t)
+    rb_str_cat(new_str, t, t2-t);
+  
+  return new_str;
+}
+
+/*
+ * Converts special characters into LaTeX entities.
+ */
+static VALUE
+redcloth_latex_esc(VALUE self, VALUE str)
+{  
+  VALUE new_str = rb_str_new2("");
+  
+  if (str == Qnil)
+    return new_str;
+    
+  StringValue(str);
+  
+  if (RSTRING_LEN(str) == 0)
+    return new_str;
+  
+  char *ts = RSTRING_PTR(str), *te = RSTRING_PTR(str) + RSTRING_LEN(str);
+  char *t = ts, *t2 = ts, *ch = NULL;
+  if (te <= ts) return;
+
+  while (t2 < te) {
+    ch = NULL;
+    
+    switch (*t2) 
+    { 
+      case '{':  ch = "#123";   break;
+      case '}':  ch = "#125";   break;
+      case '\\': ch = "#92";    break;
+      case '#':  ch = "#35";    break;
+      case '$':  ch = "#36";    break;
+      case '%':  ch = "#37";    break;
+      case '&':  ch = "amp";    break;
+      case '_':  ch = "#95";    break;
+      case '^':  ch = "circ";   break;
+      case '~':  ch = "tilde";  break;
+      case '<':  ch = "lt";     break;
+      case '>':  ch = "gt";     break;
+      case '\n': ch = "#10";    break;
+    }
+
+    if (ch != NULL)
+    {
+      if (t2 > t)
+        rb_str_cat(new_str, t, t2-t);
+      VALUE opts = rb_hash_new();
+      rb_hash_aset(opts, ID2SYM(rb_intern("text")), rb_str_new2(ch));
+      rb_str_concat(new_str, rb_funcall(self, rb_intern("entity"), 1, opts));
+      t = t2 + 1;
+    }
+
+    t2++;
+  }
+  if (t2 > t)
+    rb_str_cat(new_str, t, t2-t);
+  
+  return new_str;
+}
+
+/*
+ * Transforms a Textile document with +formatter+
+ */
+static VALUE
+redcloth_to(self, formatter)
+  VALUE self, formatter;
+{
+  char *pe, *p;
+  int len = 0;
+  
+  rb_funcall(self, rb_intern("delete!"), 1, rb_str_new2("\r"));
+  VALUE working_copy = rb_obj_clone(self);
+  rb_extend_object(working_copy, formatter);
+  
+  VALUE working_copy_methods = rb_funcall(working_copy, rb_intern("methods"), 0);
+  VALUE class_instance_methods = rb_funcall(rb_obj_class(working_copy),rb_intern("instance_methods"), 0);
+  VALUE custom_tags = rb_funcall(working_copy_methods, rb_intern("-"), 1, class_instance_methods);
+  rb_iv_set(working_copy, "@custom_tags", custom_tags);
+  
+  
+  if (rb_funcall(working_copy, rb_intern("lite_mode"), 0) == Qtrue) {
+    return redcloth_inline2(working_copy, self, rb_hash_new());
+  } else {
+    return redcloth_transform2(working_copy, self);
+  }
+}
+
+void Init_redcloth_scan()
+{
+  mRedCloth = rb_define_module("RedCloth");
+  /* A Textile document that can be converted to other formats. See
+   the README for Textile syntax. */
+  super_RedCloth = rb_define_class_under(mRedCloth, "TextileDoc", rb_cString);
+  rb_define_method(super_RedCloth, "to", redcloth_to, 1);
+  super_ParseError = rb_define_class_under(super_RedCloth, "ParseError", rb_eException);
+  /* Escaping */
+  rb_define_method(super_RedCloth, "html_esc", redcloth_html_esc, -1);
+  rb_define_method(super_RedCloth, "latex_esc", redcloth_latex_esc, 1);
+  SYM_escape_preformatted   = ID2SYM(rb_intern("html_escape_preformatted"));
+  SYM_escape_attributes     = ID2SYM(rb_intern("html_escape_attributes"));
+}

data/ext/redcloth_scan/redcloth_scan.java.rl

@@ -0,0 +1,573 @@
+/*
+ * redcloth_scan.java.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Arity;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.util.ByteList;
+
+public class RedclothScanService implements BasicLibraryService {
+
+  public static class Base {
+
+    public void CLEAR_LIST() {
+      list_layout = runtime.newArray();
+    }
+    
+   public void LIST_ITEM() {
+     int aint = 0;
+     IRubyObject aval = ((RubyArray)list_index).entry(nest-1);
+     if(!aval.isNil()) { aint = RubyNumeric.fix2int(aval); }
+     if(list_type.equals("ol")) { 
+       ((RubyArray)list_index).store(nest-1, runtime.newFixnum(aint + 1));
+     }
+
+     if(nest > ((RubyArray)list_layout).getLength()) {
+       listm = list_type + "_open";       
+       if(list_continue == 1) {
+         list_continue = 0;
+         ((RubyHash)regs).aset(runtime.newSymbol("start"), ((RubyArray)list_index).entry(nest-1));
+       } else {
+         IRubyObject start = ((RubyHash)regs).aref(runtime.newSymbol("start"));
+         if(start.isNil()) {
+           ((RubyArray)list_index).store(nest-1, runtime.newFixnum(1));
+         } else {
+           IRubyObject start_num = start.callMethod(runtime.getCurrentContext(), "to_i");
+           ((RubyArray)list_index).store(nest-1, start_num);
+         }          
+       }
+       ((RubyHash)regs).aset(runtime.newSymbol("nest"), runtime.newFixnum(nest));
+       ((RubyString)html).append(self.callMethod(runtime.getCurrentContext(), listm, regs));
+       ((RubyArray)list_layout).store(nest-1, runtime.newString(list_type));
+       regs = RubyHash.newHash(runtime);
+       ASET("first", "true");
+     }
+     LIST_CLOSE();
+     ((RubyHash)regs).aset(runtime.newSymbol("nest"), ((RubyArray)list_layout).length());
+     ASET("type", "li_open");
+   }
+
+   public void LIST_CLOSE() {
+     while(nest < ((RubyArray)list_layout).getLength()) {
+       ((RubyHash)regs).aset(runtime.newSymbol("nest"), ((RubyArray)list_layout).length());
+       IRubyObject end_list = ((RubyArray)list_layout).pop(runtime.getCurrentContext());
+       if(!end_list.isNil()) {
+         String s = end_list.convertToString().toString();
+         listm = s + "_close";
+         ((RubyString)html).append(self.callMethod(runtime.getCurrentContext(), listm, regs));
+       }
+     }
+   }
+
+   public void TRANSFORM(String T) {
+     if(p > reg && reg >= ts) {
+       IRubyObject str = RedclothScanService.transform(self, data, reg, p-reg, refs);
+       ((RubyHash)regs).aset(runtime.newSymbol(T), str);
+     } else {
+       ((RubyHash)regs).aset(runtime.newSymbol(T), runtime.getNil());
+     } 
+   }
+
+    public IRubyObject red_pass(IRubyObject self, IRubyObject regs, IRubyObject ref, String meth, IRubyObject refs) {
+      IRubyObject txt = ((RubyHash)regs).aref(ref);
+      if(!txt.isNil()) {
+        ((RubyHash)regs).aset(ref, inline2(self, txt, refs));
+      }
+      return self.callMethod(self.getRuntime().getCurrentContext(), meth, regs);
+    }
+
+   
+    public void PASS(IRubyObject H, String A, String T) {
+      ((RubyString)H).append(red_pass(self, regs, runtime.newSymbol(A), T, refs));
+    }   
+
+    
+    public void STORE_LINK_ALIAS() {
+      ((RubyHash)refs_found).aset(((RubyHash)regs).aref(runtime.newSymbol("text")), ((RubyHash)regs).aref(runtime.newSymbol("href")));
+    }
+
+    public void STORE_URL(String T) {
+      if(p > reg && reg >= ts) {
+        boolean punct = true;
+        while(p > reg && punct) {
+          switch(data[p - 1]) {
+            case ')':
+              int tempP = p - 1;
+              int level = -1;
+              while(tempP > reg) {
+                switch(data[tempP - 1]) {
+                  case '(': ++level; break;
+                  case ')': --level; break;
+                }
+                --tempP;
+              }
+              if (level == 0) { punct = false; } else { --p; }
+              break;
+            case '!': case '"': case '#': case '$': case '%': case ']': case '[': case '&': case '\'':
+            case '*': case '+': case ',': case '-': case '.': case '(': case ':':
+            case ';': case '=': case '?': case '@': case '\\': case '^': case '_':
+            case '`': case '|': case '~': p--; break;
+            default: punct = false;
+          }
+        }
+        te = p;
+      }
+
+      STORE(T);
+
+      if(!refs.isNil() && refs.callMethod(runtime.getCurrentContext(), "has_key?", ((RubyHash)regs).aref(runtime.newSymbol(T))).isTrue()) {
+        ((RubyHash)regs).aset(runtime.newSymbol(T), ((RubyHash)refs).aref(((RubyHash)regs).aref(runtime.newSymbol(T))));
+      }
+    }
+
+    public void red_inc(IRubyObject regs, IRubyObject ref) {
+      int aint = 0;
+      IRubyObject aval = ((RubyHash)regs).aref(ref);
+      if(!aval.isNil()) {
+        aint = RubyNumeric.fix2int(aval);
+      }
+      ((RubyHash)regs).aset(ref, regs.getRuntime().newFixnum(aint+1));
+    }
+
+    public IRubyObject red_blockcode(IRubyObject self, IRubyObject regs, IRubyObject block) {
+      Ruby runtime = self.getRuntime();
+      IRubyObject btype = ((RubyHash)regs).aref(runtime.newSymbol("type"));
+      if(((RubyString)block).getByteList().realSize > 0) {
+        ((RubyHash)regs).aset(runtime.newSymbol("text"), block);
+        block = self.callMethod(runtime.getCurrentContext(), btype.asJavaString(), regs);
+      }
+      return block;
+    }
+
+    public IRubyObject red_block(IRubyObject self, IRubyObject regs, IRubyObject block, IRubyObject refs) {
+      Ruby runtime = self.getRuntime();
+      RubySymbol method;
+      IRubyObject sym_text = runtime.newSymbol("text");
+      IRubyObject btype = ((RubyHash)regs).aref(runtime.newSymbol("type"));
+      block = block.callMethod(runtime.getCurrentContext(), "strip");
+
+      if(!block.isNil() && !btype.isNil()) {
+        method = btype.convertToString().intern();
+
+        if(method == runtime.newSymbol("notextile")) {
+          ((RubyHash)regs).aset(sym_text, block);
+        } else {
+          ((RubyHash)regs).aset(sym_text, inline2(self, block, refs));
+        }
+
+        IRubyObject customTags = ((RubyObject)self).getInstanceVariable("@custom_tags");
+        if( ((RubyArray)customTags).includes(runtime.getCurrentContext(), btype) ) {
+          block = self.callMethod(runtime.getCurrentContext(), method.asJavaString(), regs);
+        } else {
+          IRubyObject fallback = ((RubyHash)regs).aref(runtime.newSymbol("fallback"));
+          if(!fallback.isNil()) {
+            ((RubyString)fallback).append(((RubyHash)regs).aref(sym_text));
+            regs = RubyHash.newHash(runtime);
+            ((RubyHash)regs).aset(sym_text, fallback);
+          }
+          block = self.callMethod(runtime.getCurrentContext(), "p", regs);
+        }
+      }
+
+      return block;
+    }
+
+    public void strCatEscaped(IRubyObject self, IRubyObject str, byte[] data, int ts, int te) {
+      IRubyObject sourceStr = RubyString.newString(self.getRuntime(), data, ts, te-ts);
+      IRubyObject escapedStr = self.callMethod(self.getRuntime().getCurrentContext(), "escape", sourceStr);
+      ((RubyString)str).concat(escapedStr);
+    }
+
+    public void strCatEscapedForPreformatted(IRubyObject self, IRubyObject str, byte[] data, int ts, int te) { 
+      IRubyObject sourceStr = RubyString.newString(self.getRuntime(), data, ts, te-ts);
+      IRubyObject escapedStr = self.callMethod(self.getRuntime().getCurrentContext(), "escape_pre", sourceStr);
+      ((RubyString)str).concat(escapedStr);
+    }
+
+    public void CLEAR(IRubyObject obj) {
+      if(block == obj) {
+        block = RubyString.newEmptyString(runtime);
+      } else if(html == obj) { 
+        html = RubyString.newEmptyString(runtime);
+      } else if(table == obj) {
+        table = RubyString.newEmptyString(runtime);
+      }
+    }
+
+    public void ADD_BLOCK() {
+      ((RubyString)html).append(red_block(self, regs, block, refs));
+      extend = runtime.getNil();
+      CLEAR(block);
+      CLEAR_REGS();      
+    }
+
+    public void CLEAR_REGS() {
+      regs = RubyHash.newHash(runtime);
+    }
+
+    public void RESET_REG() {
+      reg = -1;
+    }
+
+    public void CAT(IRubyObject H) {
+      ((RubyString)H).cat(data, ts, te-ts);
+    }
+
+    public void SET_PLAIN_BLOCK(String T) {
+      plain_block = runtime.newString(T);
+    }
+
+    public void RESET_TYPE() {
+      ((RubyHash)regs).aset(runtime.newSymbol("type"), plain_block);
+    }
+
+    public void INLINE(IRubyObject H, String T) {
+      ((RubyString)H).append(self.callMethod(runtime.getCurrentContext(), T, regs));
+    }
+
+    public void DONE(IRubyObject H) {
+      ((RubyString)html).append(H);
+      CLEAR(H);
+      CLEAR_REGS();
+    }
+
+    public void ADD_EXTENDED_BLOCK() {
+      ((RubyString)html).append(red_block(self, regs, block, refs));
+      CLEAR(block);
+    }
+
+    public void ADD_BLOCKCODE() {
+      ((RubyString)html).append(red_blockcode(self, regs, block));
+      CLEAR(block);
+      CLEAR_REGS();
+    }
+
+    public void ADD_EXTENDED_BLOCKCODE() {
+      ((RubyString)html).append(red_blockcode(self, regs, block));
+      CLEAR(block);
+    }
+
+    public void AINC(String T) {
+      red_inc(regs, runtime.newSymbol(T));
+    }
+
+    public void END_EXTENDED() {
+      extend = runtime.getNil();
+      CLEAR_REGS();
+    }
+
+    public boolean IS_NOT_EXTENDED() {
+      return extend.isNil();
+    }
+
+    public void ASET(String T, String V) {
+      ((RubyHash)regs).aset(runtime.newSymbol(T), runtime.newString(V));
+    }
+
+    public void STORE(String T) {
+      if(p > reg && reg >= ts) {
+      
+        IRubyObject str = RubyString.newString(runtime, data, reg, p-reg);
+        ((RubyHash)regs).aset(runtime.newSymbol(T), str);
+      } else {
+        ((RubyHash)regs).aset(runtime.newSymbol(T), runtime.getNil());
+      }
+    }
+
+    public void STORE_B(String T) {
+      if(p > bck && bck >= ts) {
+        IRubyObject str = RubyString.newString(runtime, data, bck, p-bck);
+        ((RubyHash)regs).aset(runtime.newSymbol(T), str);
+      } else {
+        ((RubyHash)regs).aset(runtime.newSymbol(T), runtime.getNil());
+      }
+    }
+
+    public IRubyObject self;
+    public byte[] data;
+    public int p, pe;
+    public IRubyObject refs;
+
+    public Ruby runtime;
+    public int orig_p, orig_pe;
+    public int cs, act, nest;
+    public int ts = -1;
+    public int te = -1;
+    public int reg = -1;
+    public int bck = -1;
+    public int eof = -1;
+
+    public IRubyObject html;
+    public IRubyObject table;
+    public IRubyObject block;
+    public IRubyObject regs;
+
+    public IRubyObject list_layout;
+    public String list_type = null;
+    public IRubyObject list_index;
+    public int list_continue = 0;
+    public IRubyObject plain_block;
+    public IRubyObject extend;
+    public String listm = "";
+    public IRubyObject refs_found;
+  }
+
+  private static class Transformer extends Base {
+%%{
+
+  machine redcloth_scan;
+  include redcloth_common "redcloth_common.java.rl";
+
+  action extend { extend = ((RubyHash)regs).aref(runtime.newSymbol("type")); }
+
+  include redcloth_scan "redcloth_scan.rl";
+
+}%%
+
+%% write data nofinal;
+
+    public Transformer(IRubyObject self, byte[] data, int p, int pe, IRubyObject refs) {
+      if(p+pe > data.length) {
+        throw new RuntimeException("BLAHAHA");
+      }
+      this.self = self;
+
+    // This is GROSS but necessary for EOF matching
+    this.data = new byte[pe+1];
+    System.arraycopy(data, p, this.data, 0, pe);
+    this.data[pe] = 0;
+
+    this.p = 0;
+    this.pe = pe+1;
+    this.eof = this.pe;
+    this.orig_p = 0;
+    this.orig_pe = this.pe;
+
+      this.refs = refs;
+      
+      runtime = self.getRuntime();
+
+      html = RubyString.newEmptyString(runtime);
+      table = RubyString.newEmptyString(runtime);
+      block = RubyString.newEmptyString(runtime);
+      CLEAR_REGS();
+
+      list_layout = runtime.getNil();
+      list_index = runtime.newArray();
+      SET_PLAIN_BLOCK("p");
+      extend = runtime.getNil();
+      refs_found = RubyHash.newHash(runtime);
+    }
+
+    public IRubyObject transform() {
+      %% write init;
+
+      %% write exec;
+
+      if(((RubyString)block).getByteList().realSize > 0) {
+        ADD_BLOCK();
+      }
+
+      if(refs.isNil() && !refs_found.callMethod(runtime.getCurrentContext(), "empty?").isTrue()) {
+        return RedclothScanService.transform(self, data, orig_p, orig_pe, refs_found);
+      } else {
+        self.callMethod(self.getRuntime().getCurrentContext(), "after_transform", html);
+        return html;
+      }
+    }
+  }
+
+  public static IRubyObject transform(IRubyObject self, byte[] data, int p, int pe, IRubyObject refs) {
+    return new Transformer(self, data, p, pe, refs).transform();
+  }
+  
+  public static IRubyObject inline2(IRubyObject workingCopy, IRubyObject self, IRubyObject refs) {
+    return RedclothInline.inline2(workingCopy, self, refs);
+  }
+
+  public static IRubyObject transform2(IRubyObject self, IRubyObject str) {
+    RubyString ss = str.convertToString();
+    self.callMethod(self.getRuntime().getCurrentContext(), "before_transform", ss);
+    return transform(self, ss.getByteList().bytes(), ss.getByteList().begin, ss.getByteList().realSize, self.getRuntime().getNil());
+  }
+
+  @JRubyMethod
+  public static IRubyObject to(IRubyObject self, IRubyObject formatter) {
+    Ruby runtime = self.getRuntime();
+    self.callMethod(runtime.getCurrentContext(), "delete!", runtime.newString("\r"));
+    IRubyObject workingCopy = self.rbClone();
+
+    ((RubyObject)workingCopy).extend(new IRubyObject[]{formatter});
+    
+    IRubyObject workingCopyMethods = workingCopy.callMethod(runtime.getCurrentContext(), "methods");
+    IRubyObject classInstanceMethods = workingCopy.getType().callMethod(runtime.getCurrentContext(), "instance_methods");
+    IRubyObject customTags = workingCopyMethods.callMethod(runtime.getCurrentContext(), "-", classInstanceMethods);
+    ((RubyObject)workingCopy).setInstanceVariable("@custom_tags", customTags);
+    
+    if(workingCopy.callMethod(runtime.getCurrentContext(), "lite_mode").isTrue()) { 
+      return inline2(workingCopy, self, RubyHash.newHash(runtime));
+    } else {
+      return transform2(workingCopy, self);
+    }
+  }
+
+  @JRubyMethod(rest=true)
+  public static IRubyObject html_esc(IRubyObject self, IRubyObject[] args) {
+    Ruby runtime = self.getRuntime();
+    IRubyObject str = runtime.getNil(), 
+                level = runtime.getNil();
+    if(Arity.checkArgumentCount(runtime, args, 1, 2) == 2) {
+      level = args[1];
+    }
+    str = args[0];
+
+    IRubyObject new_str = RubyString.newEmptyString(runtime);
+    if(str.isNil()) {
+      return new_str;
+    }
+
+    ByteList bl = str.convertToString().getByteList();
+
+    if(bl.realSize == 0) {
+      return new_str;
+    }
+
+    byte[] bytes = bl.bytes;
+    int ts = bl.begin;
+    int te = ts + bl.realSize;
+    int t = ts, t2 = ts;
+    String ch = null;
+
+    if(te <= ts) {
+      return new_str;
+    }
+  
+    while(t2 < te) {
+      ch = null;
+      // normal + pre
+      switch(bytes[t2]) {
+        case '&':  ch = "amp";    break;
+        case '>':  ch = "gt";     break;
+        case '<':  ch = "lt";     break;
+      }
+
+      // normal (non-pre)
+      if(level != runtime.newSymbol("html_escape_preformatted")) {
+        switch(bytes[t2]) {
+          case '\n': ch = "br";     break;
+          case '"' : ch = "quot";   break;
+          case '\'': 
+            ch = (level == runtime.newSymbol("html_escape_attributes")) ? "apos" : "squot";
+          break;
+        }
+      }
+
+      if(ch != null) {
+        if(t2 > t) {
+          ((RubyString)new_str).cat(bytes, t, t2-t);
+        }
+        ((RubyString)new_str).concat(self.callMethod(runtime.getCurrentContext(), ch, RubyHash.newHash(runtime)));
+        t = t2 + 1;
+      }
+
+      t2++;
+    }
+
+
+    if(t2 > t) {
+      ((RubyString)new_str).cat(bytes, t, t2-t);
+    }
+  
+    return new_str;
+  }
+
+  @JRubyMethod
+  public static IRubyObject latex_esc(IRubyObject self, IRubyObject str) {
+    Ruby runtime = self.getRuntime();
+    IRubyObject new_str = RubyString.newEmptyString(runtime);
+    
+    if(str.isNil()) {
+      return new_str;
+    }
+
+    ByteList bl = str.convertToString().getByteList();
+    
+    if(bl.realSize == 0) {
+      return new_str;
+    }
+  
+    byte[] bytes = bl.bytes;
+    int ts = bl.begin;
+    int te = ts + bl.realSize;
+    int t = ts;
+    int t2 = ts;
+    String ch = null;
+
+    while(t2 < te) {
+      ch = null;
+
+      switch(bytes[t2]) {
+        case '{':  ch = "#123";   break;
+        case '}':  ch = "#125";   break;
+        case '\\': ch = "#92";    break;
+        case '#':  ch = "#35";    break;
+        case '$':  ch = "#36";    break;
+        case '%':  ch = "#37";    break;
+        case '&':  ch = "amp";    break;
+        case '_':  ch = "#95";    break;
+        case '^':  ch = "circ";   break;
+        case '~':  ch = "tilde";  break;
+        case '<':  ch = "lt";     break;
+        case '>':  ch = "gt";     break;
+        case '\n': ch = "#10";    break;
+      }
+
+      if(ch != null) {
+        if(t2 > t) {
+          ((RubyString)new_str).cat(bytes, t, t2-t);
+        }
+        IRubyObject opts = RubyHash.newHash(runtime);
+        ((RubyHash)opts).aset(runtime.newSymbol("text"), runtime.newString(ch));
+        ((RubyString)new_str).concat(self.callMethod(runtime.getCurrentContext(), "entity", opts));
+        t = t2 + 1;
+      }
+
+      t2++;
+    }
+
+    if(t2 > t) {
+      ((RubyString)new_str).cat(bytes, t, t2-t);
+    }
+
+    return new_str;
+  }
+
+  public boolean basicLoad(final Ruby runtime) throws IOException {
+    Init_redcloth_scan(runtime);
+    return true;
+  }
+
+  public static void Init_redcloth_scan(Ruby runtime) {
+    RubyModule mRedCloth = runtime.defineModule("RedCloth");
+    RubyClass super_RedCloth = mRedCloth.defineClassUnder("TextileDoc", runtime.getString(), runtime.getString().getAllocator());
+    super_RedCloth.defineAnnotatedMethods(RedclothScanService.class);
+    super_RedCloth.defineClassUnder("ParseError",runtime.getClass("Exception"),runtime.getClass("Exception").getAllocator());
+  }
+}