oga 0.1.1-java

data/ext/c/lexer.h

@@ -0,0 +1,8 @@
+#ifndef LIBOGA_XML_LEXER_H
+#define LIBOGA_XML_LEXER_H
+
+#include "liboga.h"
+
+extern void Init_liboga_xml_lexer();
+
+#endif

data/ext/c/lexer.rl

@@ -0,0 +1,121 @@
+#include "lexer.h"
+
+/*
+The following two macros allow the Ragel grammar to use generic function calls
+without relying on the setup of the C or Java lexer. Using these macros we can
+also pass along `self` to the callback functions without having to hard-code
+this in to the Ragel grammar.
+
+In the C lexer we don't need the `data` variable (since this is pulled in based
+on `ts` and `te`) so the macro ignores this argument.
+*/
+
+#define callback(name, data, encoding, start, stop) \
+    liboga_xml_lexer_callback(self, name, encoding, start, stop);
+
+#define callback_simple(name) \
+    liboga_xml_lexer_callback_simple(self, name);
+
+#define oga_ivar_get(owner, name) \
+    rb_ivar_get(owner, rb_intern(name))
+
+#define oga_ivar_set(owner, name, value) \
+    rb_ivar_set(owner, rb_intern(name), value)
+
+%%machine c_lexer;
+
+/**
+ * Calls a method defined in the Ruby side of the lexer. The String value is
+ * created based on the values of `ts` and `te` and uses the encoding specified
+ * in `encoding`.
+ *
+ * @example
+ *  rb_encoding *encoding = rb_enc_get(...);
+ *  liboga_xml_lexer_callback(self, "on_string", encoding, ts, te);
+ */
+void liboga_xml_lexer_callback(
+    VALUE self,
+    const char *name,
+    rb_encoding *encoding,
+    const char *ts,
+    const char *te
+)
+{
+    VALUE value  = rb_enc_str_new(ts, te - ts, encoding);
+    VALUE method = rb_intern(name);
+
+    rb_funcall(self, method, 1, value);
+}
+
+/**
+ * Calls a method defined in the Ruby side of the lexer without passing it any
+ * arguments.
+ *
+ * @example
+ *  liboga_xml_lexer_callback_simple(self, "on_cdata_start");
+ */
+void liboga_xml_lexer_callback_simple(VALUE self, const char *name)
+{
+    VALUE method = rb_intern(name);
+
+    rb_funcall(self, method, 0);
+}
+
+%% write data;
+
+/**
+ * Lexes the String specifies as the method argument. Token values have the
+ * same encoding as the input value.
+ *
+ * This method keeps track of an internal state using the instance variables
+ * `@act` and `@cs`.
+ */
+VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
+{
+    /* Make sure that all data passed back to Ruby has the proper encoding. */
+    rb_encoding *encoding = rb_enc_get(data_block);
+
+    char *data_str_val = StringValuePtr(data_block);
+
+    const char *p    = data_str_val;
+    const char *pe   = data_str_val + strlen(data_str_val);
+    const char *eof  = pe;
+    const char *ts   = 0;
+    const char *te   = 0;
+    const char *mark = 0;
+
+    int act = NUM2INT(oga_ivar_get(self, "@act"));
+    int cs  = NUM2INT(oga_ivar_get(self, "@cs"));
+
+    %% write exec;
+
+    oga_ivar_set(self, "@act", INT2NUM(act));
+    oga_ivar_set(self, "@cs", INT2NUM(cs));
+
+    return Qnil;
+}
+
+/**
+ * Resets the internal state of the lexer.
+ */
+VALUE oga_xml_lexer_reset(VALUE self)
+{
+    oga_ivar_set(self, "@act", INT2NUM(0));
+    oga_ivar_set(self, "@cs", INT2NUM(c_lexer_start));
+
+    return Qnil;
+}
+
+%%{
+    include base_lexer "base_lexer.rl";
+}%%
+
+void Init_liboga_xml_lexer()
+{
+    VALUE mOga   = rb_const_get(rb_cObject, rb_intern("Oga"));
+    VALUE mXML   = rb_const_get(mOga, rb_intern("XML"));
+    VALUE cLexer = rb_define_class_under(mXML, "Lexer", rb_cObject);
+
+    rb_define_method(cLexer, "advance_native", oga_xml_lexer_advance, 1);
+    rb_define_method(cLexer, "reset_native", oga_xml_lexer_reset, 0);
+}

data/ext/c/liboga.c

@@ -0,0 +1,6 @@
+#include "liboga.h"
+
+void Init_liboga()
+{
+    Init_liboga_xml_lexer();
+}

data/ext/c/liboga.h

@@ -0,0 +1,11 @@
+#ifndef LIBOGA_H
+#define LIBOGA_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include "lexer.h"
+
+void Init_liboga();
+
+#endif

data/ext/java/Liboga.java

@@ -0,0 +1,14 @@
+package org.liboga;
+
+import org.jruby.Ruby;
+
+public class Liboga
+{
+    /**
+     * Bootstraps the JRuby extension.
+     */
+    public static void load(final Ruby runtime)
+    {
+        org.liboga.xml.Lexer.load(runtime);
+    }
+}

data/ext/java/org/liboga/xml/Lexer.java

@@ -0,0 +1,829 @@
+
+// line 1 "ext/java/org/liboga/xml/Lexer.rl"
+package org.liboga.xml;
+
+
+// line 4 "ext/java/org/liboga/xml/Lexer.rl"
+
+import java.io.IOException;
+
+import org.jcodings.Encoding;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyFixnum;
+import org.jruby.util.ByteList;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Lexer support class for JRuby.
+ *
+ * The Lexer class contains the raw Ragel loop and calls back in to Ruby land
+ * whenever a Ragel action is needed similar to the C extension setup.
+ *
+ * This class requires Ruby land to first define the `Oga::XML` namespace.
+ */
+@JRubyClass(name="Oga::XML::Lexer", parent="Object")
+public class Lexer extends RubyObject
+{
+    /**
+     * The current Ruby runtime.
+     */
+    private Ruby runtime;
+
+    
+// line 43 "ext/java/org/liboga/xml/Lexer.java"
+private static byte[] init__java_lexer_actions_0()
+{
+	return new byte [] {
+	    0,    1,    0,    1,    1,    1,    3,    1,    4,    1,    5,    1,
+	    6,    1,    7,    1,   10,    1,   11,    1,   12,    1,   13,    1,
+	   14,    1,   15,    1,   16,    1,   17,    1,   18,    1,   19,    1,
+	   20,    1,   21,    1,   22,    1,   23,    1,   24,    1,   25,    1,
+	   26,    1,   27,    1,   28,    1,   29,    1,   30,    1,   32,    1,
+	   33,    1,   34,    1,   37,    1,   38,    1,   39,    1,   40,    1,
+	   41,    1,   42,    1,   43,    1,   44,    1,   45,    1,   46,    2,
+	    1,    2,    2,    4,    8,    2,    4,    9,    2,    4,   35,    2,
+	    4,   36,    3,    4,    0,   31
+	};
+}
+
+private static final byte _java_lexer_actions[] = init__java_lexer_actions_0();
+
+
+private static short[] init__java_lexer_key_offsets_0()
+{
+	return new short [] {
+	    0,    0,    4,    5,    6,    7,    9,   11,   13,   15,   17,   19,
+	   21,   23,   24,   25,   26,   27,   28,   29,   30,   31,   33,   41,
+	   51,   60,   61,   62,   62,   63,   64,   65,   66,   67,   68,   69,
+	   70,   81,   83,   91,  100,  109,  110,  111,  127,  135,  144,  153,
+	  162,  171,  180,  189,  198,  207,  216,  225,  236,  237,  238,  246,
+	  247,  255,  264,  281,  290,  291,  292
+	};
+}
+
+private static final short _java_lexer_key_offsets[] = init__java_lexer_key_offsets_0();
+
+
+private static char[] init__java_lexer_trans_keys_0()
+{
+	return new char [] {
+	   45,   68,   91,  100,   45,   45,   45,   45,   62,   79,  111,   67,
+	   99,   84,  116,   89,  121,   80,  112,   69,  101,    9,   32,   67,
+	   68,   65,   84,   65,   91,   93,   93,   62,   93,   45,   95,   48,
+	   57,   65,   90,   97,  122,   45,   58,   62,   95,   48,   57,   65,
+	   90,   97,  122,   45,   95,  120,   48,   57,   65,   90,   97,  122,
+	   34,   39,   93,   34,   39,   10,   34,   39,   62,   60,   33,   45,
+	   47,   63,   95,   48,   57,   65,   90,   97,  122,    9,   32,   45,
+	   95,   48,   57,   65,   90,   97,  122,   45,   95,  109,   48,   57,
+	   65,   90,   97,  122,   45,   95,  108,   48,   57,   65,   90,   97,
+	  122,   63,   62,    9,   32,   34,   39,   45,   62,   80,   83,   91,
+	   95,   48,   57,   65,   90,   97,  122,   45,   95,   48,   57,   65,
+	   90,   97,  122,   45,   85,   95,   48,   57,   65,   90,   97,  122,
+	   45,   66,   95,   48,   57,   65,   90,   97,  122,   45,   76,   95,
+	   48,   57,   65,   90,   97,  122,   45,   73,   95,   48,   57,   65,
+	   90,   97,  122,   45,   67,   95,   48,   57,   65,   90,   97,  122,
+	   45,   89,   95,   48,   57,   65,   90,   97,  122,   45,   83,   95,
+	   48,   57,   65,   90,   97,  122,   45,   84,   95,   48,   57,   65,
+	   90,   97,  122,   45,   69,   95,   48,   57,   65,   90,   97,  122,
+	   45,   77,   95,   48,   57,   65,   90,   97,  122,   34,   39,   45,
+	   63,   95,   48,   57,   65,   90,   97,  122,   34,   39,   45,   95,
+	   48,   57,   65,   90,   97,  122,   62,   45,   95,   48,   57,   65,
+	   90,   97,  122,   45,   58,   95,   48,   57,   65,   90,   97,  122,
+	    9,   10,   13,   32,   34,   39,   45,   47,   61,   62,   95,   48,
+	   57,   65,   90,   97,  122,   45,   58,   95,   48,   57,   65,   90,
+	   97,  122,   60,   60,   33,   45,   60,   63,   95,   47,   57,   65,
+	   90,   97,  122,    0
+	};
+}
+
+private static final char _java_lexer_trans_keys[] = init__java_lexer_trans_keys_0();
+
+
+private static byte[] init__java_lexer_single_lengths_0()
+{
+	return new byte [] {
+	    0,    4,    1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
+	    2,    1,    1,    1,    1,    1,    1,    1,    1,    2,    2,    4,
+	    3,    1,    1,    0,    1,    1,    1,    1,    1,    1,    1,    1,
+	    5,    2,    2,    3,    3,    1,    1,   10,    2,    3,    3,    3,
+	    3,    3,    3,    3,    3,    3,    3,    5,    1,    1,    2,    1,
+	    2,    3,   11,    3,    1,    1,    5
+	};
+}
+
+private static final byte _java_lexer_single_lengths[] = init__java_lexer_single_lengths_0();
+
+
+private static byte[] init__java_lexer_range_lengths_0()
+{
+	return new byte [] {
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    3,    3,
+	    3,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    3,    0,    3,    3,    3,    0,    0,    3,    3,    3,    3,    3,
+	    3,    3,    3,    3,    3,    3,    3,    3,    0,    0,    3,    0,
+	    3,    3,    3,    3,    0,    0,    3
+	};
+}
+
+private static final byte _java_lexer_range_lengths[] = init__java_lexer_range_lengths_0();
+
+
+private static short[] init__java_lexer_index_offsets_0()
+{
+	return new short [] {
+	    0,    0,    5,    7,    9,   11,   14,   17,   20,   23,   26,   29,
+	   32,   35,   37,   39,   41,   43,   45,   47,   49,   51,   54,   60,
+	   68,   75,   77,   79,   80,   82,   84,   86,   88,   90,   92,   94,
+	   96,  105,  108,  114,  121,  128,  130,  132,  146,  152,  159,  166,
+	  173,  180,  187,  194,  201,  208,  215,  222,  231,  233,  235,  241,
+	  243,  249,  256,  271,  278,  280,  282
+	};
+}
+
+private static final short _java_lexer_index_offsets[] = init__java_lexer_index_offsets_0();
+
+
+private static byte[] init__java_lexer_indicies_0()
+{
+	return new byte [] {
+	    1,    2,    3,    2,    0,    4,    0,    5,    4,    6,    4,    6,
+	    7,    4,    8,    8,    0,    9,    9,    0,   10,   10,    0,   11,
+	   11,    0,   12,   12,    0,   13,   13,    0,   14,   14,    0,   15,
+	    0,   16,    0,   17,    0,   18,    0,   19,    0,   20,    0,   21,
+	   20,   22,   20,   23,   22,   20,   24,   24,   24,   24,   24,    0,
+	   24,   25,   26,   24,   24,   24,   24,    0,   27,   27,   28,   27,
+	   27,   27,    0,   30,   29,   30,   31,   32,   33,   32,   36,   35,
+	   36,   37,   38,   39,   41,   40,   41,   42,   43,   39,   45,   44,
+	   47,   48,   25,   49,   48,   48,   48,   48,   46,   14,   14,   50,
+	   27,   27,   27,   27,   27,   51,   27,   27,   53,   27,   27,   27,
+	   52,   27,   27,   54,   27,   27,   27,   52,   56,   55,   58,   57,
+	   59,   59,   29,   31,   60,   61,   62,   63,   64,   60,   60,   60,
+	   60,   39,   60,   60,   60,   60,   60,   65,   60,   67,   60,   60,
+	   60,   60,   66,   60,   68,   60,   60,   60,   60,   66,   60,   69,
+	   60,   60,   60,   60,   66,   60,   70,   60,   60,   60,   60,   66,
+	   60,   71,   60,   60,   60,   60,   66,   60,   72,   60,   60,   60,
+	   60,   66,   60,   73,   60,   60,   60,   60,   66,   60,   74,   60,
+	   60,   60,   60,   66,   60,   75,   60,   60,   60,   60,   66,   60,
+	   71,   60,   60,   60,   60,   66,   77,   78,   79,   80,   79,   79,
+	   79,   79,   76,   36,   35,   36,   37,   79,   79,   79,   79,   79,
+	   82,   83,   81,   84,   84,   84,   84,   84,   39,   84,   86,   84,
+	   84,   84,   84,   85,   87,   38,   88,   87,   40,   42,   89,   90,
+	   87,   91,   89,   89,   89,   89,   39,   89,   93,   89,   89,   89,
+	   89,   92,   95,   94,   95,   94,   98,   98,   95,   98,   98,   98,
+	   98,   98,   94,    0
+	};
+}
+
+private static final byte _java_lexer_indicies[] = init__java_lexer_indicies_0();
+
+
+private static byte[] init__java_lexer_trans_targs_0()
+{
+	return new byte [] {
+	   35,    2,    6,   13,    3,    4,    5,   35,    7,    8,    9,   10,
+	   11,   12,   37,   14,   15,   16,   17,   18,   19,   20,   21,   35,
+	   23,   22,   35,   38,   39,   25,   43,   26,   28,   43,   55,   29,
+	   55,   30,   62,    0,   32,   62,   33,   62,   35,   36,   35,    1,
+	   35,   24,   35,   35,   35,   40,   38,   41,   42,   41,   41,   43,
+	   44,   43,   45,   50,   27,   43,   43,   46,   47,   48,   49,   44,
+	   51,   52,   53,   54,   55,   56,   57,   58,   59,   55,   55,   55,
+	   61,   60,   60,   62,   31,   63,   34,   62,   62,   62,   65,   66,
+	   64,   64,   64
+	};
+}
+
+private static final byte _java_lexer_trans_targs[] = init__java_lexer_trans_targs_0();
+
+
+private static byte[] init__java_lexer_trans_actions_0()
+{
+	return new byte [] {
+	   79,    0,    0,    0,    0,    0,    0,   63,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   65,
+	    0,    0,   69,   95,    0,    0,   17,    0,    0,   15,   37,    0,
+	   29,    0,   45,    0,    0,   49,    0,   53,   71,    7,   77,    0,
+	   67,    0,   73,   81,   75,    0,   92,   11,    0,   13,    9,   19,
+	   89,   21,    0,    0,    0,   25,   23,    0,    0,    0,    0,   86,
+	    0,    0,    0,    0,   31,    7,    7,    0,    0,   35,   33,   27,
+	    0,   41,   39,   43,    0,    0,    0,   51,   55,   47,   98,    1,
+	   61,   59,   57
+	};
+}
+
+private static final byte _java_lexer_trans_actions[] = init__java_lexer_trans_actions_0();
+
+
+private static byte[] init__java_lexer_to_state_actions_0()
+{
+	return new byte [] {
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    3,
+	    0,    0,    0,    0,    0,    3,    0,    3,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    3,    0,    0,    0,    0,
+	    3,    0,    3,    0,   83,    0,    0
+	};
+}
+
+private static final byte _java_lexer_to_state_actions[] = init__java_lexer_to_state_actions_0();
+
+
+private static byte[] init__java_lexer_from_state_actions_0()
+{
+	return new byte [] {
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    5,
+	    0,    0,    0,    0,    0,    5,    0,    5,    0,    0,    0,    0,
+	    0,    0,    0,    0,    0,    0,    0,    5,    0,    0,    0,    0,
+	    5,    0,    5,    0,    5,    0,    0
+	};
+}
+
+private static final byte _java_lexer_from_state_actions[] = init__java_lexer_from_state_actions_0();
+
+
+private static short[] init__java_lexer_eof_trans_0()
+{
+	return new short [] {
+	    0,    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+	    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+	    1,    0,    0,    0,    0,   35,   35,    0,    0,    0,    0,    0,
+	   47,   51,   52,   53,   53,    0,   58,    0,   66,   67,   67,   67,
+	   67,   67,   67,   67,   67,   67,   67,    0,   82,   82,   83,   82,
+	    0,   86,    0,   93,    0,   97,   98
+	};
+}
+
+private static final short _java_lexer_eof_trans[] = init__java_lexer_eof_trans_0();
+
+
+static final int java_lexer_start = 35;
+static final int java_lexer_first_final = 35;
+static final int java_lexer_error = 0;
+
+static final int java_lexer_en_proc_ins_body = 41;
+static final int java_lexer_en_doctype = 43;
+static final int java_lexer_en_xml_decl = 55;
+static final int java_lexer_en_element_name = 60;
+static final int java_lexer_en_element_head = 62;
+static final int java_lexer_en_text = 64;
+static final int java_lexer_en_main = 35;
+
+
+// line 39 "ext/java/org/liboga/xml/Lexer.rl"
+
+    /* Used by Ragel to keep track of the current state. */
+    int act;
+    int cs;
+
+    /**
+     * Sets up the current class in the Ruby runtime.
+     */
+    public static void load(Ruby runtime)
+    {
+        RubyModule xml = (RubyModule) runtime.getModule("Oga")
+            .getConstant("XML");
+
+        RubyClass lexer = xml.defineClassUnder(
+            "Lexer",
+            runtime.getObject(),
+            ALLOCATOR
+        );
+
+        lexer.defineAnnotatedMethods(Lexer.class);
+    }
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator()
+    {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass)
+        {
+            return new org.liboga.xml.Lexer(runtime, klass);
+        }
+    };
+
+    public Lexer(Ruby runtime, RubyClass klass)
+    {
+        super(runtime, klass);
+
+        this.runtime = runtime;
+    }
+
+    /**
+     * Runs the bulk of the Ragel loop and calls back in to Ruby.
+     *
+     * This method pulls its data in from the instance variable `@data`. The
+     * Ruby side of the Lexer class should set this variable to a String in its
+     * constructor method. Encodings are passed along to make sure that token
+     * values share the same encoding as the input.
+     *
+     * This method always returns nil.
+     */
+    @JRubyMethod
+    public IRubyObject advance_native(ThreadContext context, RubyString rb_str)
+    {
+        Encoding encoding = rb_str.getEncoding();
+
+        byte[] data = rb_str.getBytes();
+
+        int ts   = 0;
+        int te   = 0;
+        int p    = 0;
+        int mark = 0;
+        int pe   = data.length;
+        int eof  = data.length;
+
+        
+// line 348 "ext/java/org/liboga/xml/Lexer.java"
+	{
+	int _klen;
+	int _trans = 0;
+	int _acts;
+	int _nacts;
+	int _keys;
+	int _goto_targ = 0;
+
+	_goto: while (true) {
+	switch ( _goto_targ ) {
+	case 0:
+	if ( p == pe ) {
+		_goto_targ = 4;
+		continue _goto;
+	}
+	if ( ( this.cs) == 0 ) {
+		_goto_targ = 5;
+		continue _goto;
+	}
+case 1:
+	_acts = _java_lexer_from_state_actions[( this.cs)];
+	_nacts = (int) _java_lexer_actions[_acts++];
+	while ( _nacts-- > 0 ) {
+		switch ( _java_lexer_actions[_acts++] ) {
+	case 3:
+// line 1 "NONE"
+	{ts = p;}
+	break;
+// line 377 "ext/java/org/liboga/xml/Lexer.java"
+		}
+	}
+
+	_match: do {
+	_keys = _java_lexer_key_offsets[( this.cs)];
+	_trans = _java_lexer_index_offsets[( this.cs)];
+	_klen = _java_lexer_single_lengths[( this.cs)];
+	if ( _klen > 0 ) {
+		int _lower = _keys;
+		int _mid;
+		int _upper = _keys + _klen - 1;
+		while (true) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + ((_upper-_lower) >> 1);
+			if ( data[p] < _java_lexer_trans_keys[_mid] )
+				_upper = _mid - 1;
+			else if ( data[p] > _java_lexer_trans_keys[_mid] )
+				_lower = _mid + 1;
+			else {
+				_trans += (_mid - _keys);
+				break _match;
+			}
+		}
+		_keys += _klen;
+		_trans += _klen;
+	}
+
+	_klen = _java_lexer_range_lengths[( this.cs)];
+	if ( _klen > 0 ) {
+		int _lower = _keys;
+		int _mid;
+		int _upper = _keys + (_klen<<1) - 2;
+		while (true) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + (((_upper-_lower) >> 1) & ~1);
+			if ( data[p] < _java_lexer_trans_keys[_mid] )
+				_upper = _mid - 2;
+			else if ( data[p] > _java_lexer_trans_keys[_mid+1] )
+				_lower = _mid + 2;
+			else {
+				_trans += ((_mid - _keys)>>1);
+				break _match;
+			}
+		}
+		_trans += _klen;
+	}
+	} while (false);
+
+	_trans = _java_lexer_indicies[_trans];
+case 3:
+	( this.cs) = _java_lexer_trans_targs[_trans];
+
+	if ( _java_lexer_trans_actions[_trans] != 0 ) {
+		_acts = _java_lexer_trans_actions[_trans];
+		_nacts = (int) _java_lexer_actions[_acts++];
+		while ( _nacts-- > 0 )
+	{
+			switch ( _java_lexer_actions[_acts++] )
+			{
+	case 0:
+// line 296 "ext/ragel/base_lexer.rl"
+	{ mark = p; }
+	break;
+	case 4:
+// line 1 "NONE"
+	{te = p+1;}
+	break;
+	case 5:
+// line 100 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback("on_text", data, encoding, mark, ts);
+            callback_simple("on_proc_ins_end");
+
+            ( this.cs) = 35;
+        }}
+	break;
+	case 6:
+// line 107 "ext/ragel/base_lexer.rl"
+	{te = p+1;}
+	break;
+	case 7:
+// line 107 "ext/ragel/base_lexer.rl"
+	{te = p;p--;}
+	break;
+	case 8:
+// line 148 "ext/ragel/base_lexer.rl"
+	{( this.act) = 3;}
+	break;
+	case 9:
+// line 165 "ext/ragel/base_lexer.rl"
+	{( this.act) = 7;}
+	break;
+	case 10:
+// line 154 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback("on_doctype_inline", data, encoding, ts + 1, te - 1);
+        }}
+	break;
+	case 11:
+// line 124 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback("on_string", data, encoding, ts + 1, te - 1);
+    }}
+	break;
+	case 12:
+// line 163 "ext/ragel/base_lexer.rl"
+	{te = p+1;}
+	break;
+	case 13:
+// line 169 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback_simple("on_doctype_end");
+            ( this.cs) = 35;
+        }}
+	break;
+	case 14:
+// line 165 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+            callback("on_doctype_name", data, encoding, ts, te);
+        }}
+	break;
+	case 15:
+// line 1 "NONE"
+	{	switch( ( this.act) ) {
+	case 3:
+	{{p = ((te))-1;}
+            callback("on_doctype_type", data, encoding, ts, te);
+        }
+	break;
+	case 7:
+	{{p = ((te))-1;}
+            callback("on_doctype_name", data, encoding, ts, te);
+        }
+	break;
+	}
+	}
+	break;
+	case 16:
+// line 189 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback_simple("on_xml_decl_end");
+            ( this.cs) = 35;
+        }}
+	break;
+	case 17:
+// line 124 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback("on_string", data, encoding, ts + 1, te - 1);
+    }}
+	break;
+	case 18:
+// line 201 "ext/ragel/base_lexer.rl"
+	{te = p+1;}
+	break;
+	case 19:
+// line 195 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+            callback("on_attribute", data, encoding, ts, te);
+        }}
+	break;
+	case 20:
+// line 201 "ext/ragel/base_lexer.rl"
+	{te = p;p--;}
+	break;
+	case 21:
+// line 201 "ext/ragel/base_lexer.rl"
+	{{p = ((te))-1;}}
+	break;
+	case 22:
+// line 228 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback("on_element_ns", data, encoding, ts, te - 1);
+        }}
+	break;
+	case 23:
+// line 232 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+            callback("on_element_name", data, encoding, ts, te);
+            ( this.cs) = 62;
+        }}
+	break;
+	case 24:
+// line 241 "ext/ragel/base_lexer.rl"
+	{te = p+1;}
+	break;
+	case 25:
+// line 243 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback_simple("advance_line");
+        }}
+	break;
+	case 26:
+// line 248 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback("on_attribute_ns", data, encoding, ts, te - 1);
+        }}
+	break;
+	case 27:
+// line 124 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback("on_string", data, encoding, ts + 1, te - 1);
+    }}
+	break;
+	case 28:
+// line 260 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback_simple("on_element_open_end");
+            ( this.cs) = 35;
+        }}
+	break;
+	case 29:
+// line 266 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback_simple("on_element_end");
+            ( this.cs) = 35;
+        }}
+	break;
+	case 30:
+// line 252 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+            callback("on_attribute", data, encoding, ts, te);
+        }}
+	break;
+	case 31:
+// line 306 "ext/ragel/base_lexer.rl"
+	{( this.act) = 23;}
+	break;
+	case 32:
+// line 296 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+            callback("on_text", data, encoding, ts, mark);
+
+            p    = mark - 1;
+            mark = 0;
+
+            ( this.cs) = 35;
+        }}
+	break;
+	case 33:
+// line 306 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+            callback("on_text", data, encoding, ts, te);
+            ( this.cs) = 35;
+        }}
+	break;
+	case 34:
+// line 1 "NONE"
+	{	switch( ( this.act) ) {
+	case 0:
+	{{( this.cs) = 0; _goto_targ = 2; if (true) continue _goto;}}
+	break;
+	case 23:
+	{{p = ((te))-1;}
+            callback("on_text", data, encoding, ts, te);
+            ( this.cs) = 35;
+        }
+	break;
+	}
+	}
+	break;
+	case 35:
+// line 182 "ext/ragel/base_lexer.rl"
+	{( this.act) = 25;}
+	break;
+	case 36:
+// line 90 "ext/ragel/base_lexer.rl"
+	{( this.act) = 28;}
+	break;
+	case 37:
+// line 56 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback("on_comment", data, encoding, ts + 4, te - 3);
+    }}
+	break;
+	case 38:
+// line 72 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback("on_cdata", data, encoding, ts + 9, te - 3);
+    }}
+	break;
+	case 39:
+// line 216 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback_simple("on_element_start");
+        p--;
+        ( this.cs) = 60;
+    }}
+	break;
+	case 40:
+// line 222 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        callback_simple("on_element_end");
+    }}
+	break;
+	case 41:
+// line 280 "ext/ragel/base_lexer.rl"
+	{te = p+1;{
+        p--;
+        ( this.cs) = 64;
+    }}
+	break;
+	case 42:
+// line 140 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+        callback_simple("on_doctype_start");
+        ( this.cs) = 43;
+    }}
+	break;
+	case 43:
+// line 90 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+        callback_simple("on_proc_ins_start");
+        callback("on_proc_ins_name", data, encoding, ts + 2, te);
+
+        mark = te;
+
+        ( this.cs) = 41;
+    }}
+	break;
+	case 44:
+// line 280 "ext/ragel/base_lexer.rl"
+	{te = p;p--;{
+        p--;
+        ( this.cs) = 64;
+    }}
+	break;
+	case 45:
+// line 280 "ext/ragel/base_lexer.rl"
+	{{p = ((te))-1;}{
+        p--;
+        ( this.cs) = 64;
+    }}
+	break;
+	case 46:
+// line 1 "NONE"
+	{	switch( ( this.act) ) {
+	case 25:
+	{{p = ((te))-1;}
+        callback_simple("on_xml_decl_start");
+        ( this.cs) = 55;
+    }
+	break;
+	case 28:
+	{{p = ((te))-1;}
+        callback_simple("on_proc_ins_start");
+        callback("on_proc_ins_name", data, encoding, ts + 2, te);
+
+        mark = te;
+
+        ( this.cs) = 41;
+    }
+	break;
+	}
+	}
+	break;
+// line 737 "ext/java/org/liboga/xml/Lexer.java"
+			}
+		}
+	}
+
+case 2:
+	_acts = _java_lexer_to_state_actions[( this.cs)];
+	_nacts = (int) _java_lexer_actions[_acts++];
+	while ( _nacts-- > 0 ) {
+		switch ( _java_lexer_actions[_acts++] ) {
+	case 1:
+// line 1 "NONE"
+	{ts = -1;}
+	break;
+	case 2:
+// line 1 "NONE"
+	{( this.act) = 0;}
+	break;
+// line 755 "ext/java/org/liboga/xml/Lexer.java"
+		}
+	}
+
+	if ( ( this.cs) == 0 ) {
+		_goto_targ = 5;
+		continue _goto;
+	}
+	if ( ++p != pe ) {
+		_goto_targ = 1;
+		continue _goto;
+	}
+case 4:
+	if ( p == eof )
+	{
+	if ( _java_lexer_eof_trans[( this.cs)] > 0 ) {
+		_trans = _java_lexer_eof_trans[( this.cs)] - 1;
+		_goto_targ = 3;
+		continue _goto;
+	}
+	}
+
+case 5:
+	}
+	break; }
+	}
+
+// line 101 "ext/java/org/liboga/xml/Lexer.rl"
+
+        return context.nil;
+    }
+
+    /**
+     * Resets the internal state of the lexer.
+     */
+    @JRubyMethod
+    public IRubyObject reset_native(ThreadContext context)
+    {
+        this.act = 0;
+        this.cs  = java_lexer_start;
+
+        return context.nil;
+    }
+
+    /**
+     * Calls back in to Ruby land passing the current token value along.
+     *
+     * This method calls back in to Ruby land based on the method name
+     * specified in `name`. The Ruby callback should take one argument. This
+     * argument will be a String containing the value of the current token.
+     */
+    public void callback(String name, byte[] data, Encoding enc, int ts, int te)
+    {
+        ByteList bytelist = new ByteList(data, ts, te - ts, enc, true);
+
+        RubyString value = this.runtime.newString(bytelist);
+
+        ThreadContext context = this.runtime.getCurrentContext();
+
+        this.callMethod(context, name, value);
+    }
+
+    /**
+     * Calls back in to Ruby land without passing any arguments.
+     */
+    public void callback_simple(String name)
+    {
+        ThreadContext context = this.runtime.getCurrentContext();
+
+        this.callMethod(context, name);
+    }
+}
+
+
+// line 151 "ext/java/org/liboga/xml/Lexer.rl"
+