adamh-hpricot 0.6.211 → 0.7.229

data/ext/hpricot_scan/hpricot_scan.rl

@@ -19,20 +19,26 @@ VALUE hpricot_css(VALUE, VALUE, VALUE, VALUE, VALUE);
 #define NO_WAY_SERIOUSLY "*** This should not happen, please send a bug report with the HTML you're parsing to why@whytheluckystiff.net.  So sorry!"
 
 static VALUE sym_xmldecl, sym_doctype, sym_procins, sym_stag, sym_etag, sym_emptytag, sym_comment,
-      sym_cdata, sym_text, sym_EMPTY, sym_CDATA;
+      sym_cdata, sym_name, sym_parent, sym_raw_attributes, sym_raw_string, sym_tagno,
+      sym_allowed, sym_text, sym_children, sym_EMPTY, sym_CDATA;
 static VALUE mHpricot, rb_eHpricotParseError;
-static VALUE cBaseEle, cBogusETag, cCData, cComment, cDoc, cDocType, cElem, cETag, cText,
+static VALUE cBogusETag, cCData, cComment, cDoc, cDocType, cElem, cText,
       cXMLDecl, cProcIns, symAllow, symDeny;
 static ID s_ElementContent;
 static ID s_downcase, s_new, s_parent, s_read, s_to_str;
-static ID iv_parent;
 static VALUE reProcInsParse;
 
-typedef struct {
-  int name;
-  VALUE tag, attr, etag, raw, EC;
-  VALUE parent, children;
-} hpricot_ele;
+#define H_ELE_TAG      0
+#define H_ELE_PARENT   1
+#define H_ELE_ATTR     2
+#define H_ELE_ETAG     3
+#define H_ELE_RAW      4
+#define H_ELE_EC       5
+#define H_ELE_HASH     6
+#define H_ELE_CHILDREN 7
+
+#define H_ELE_GET(ele, idx)      RSTRUCT_PTR(ele)[idx]
+#define H_ELE_SET(ele, idx, val) RSTRUCT_PTR(ele)[idx] = val
 
 #define OPT(opts, key) (!NIL_P(opts) && RTEST(rb_hash_aref(opts, ID2SYM(rb_intern("" # key)))))
 
@@ -60,7 +66,7 @@ typedef struct {
 
 #define CAT(N, E) if (NIL_P(N)) { SET(N, E); } else { rb_str_cat(N, mark_##N, E - mark_##N); }
 
-#define SLIDE(N) if ( mark_##N > ts ) mark_##N = buf + (mark_##N - ts);
+#define SLIDE(N) if (mark_##N > ts) mark_##N = buf + (mark_##N - ts);
 
 #define ATTR(K, V) \
     if (!NIL_P(K)) { \
@@ -107,7 +113,7 @@ typedef struct {
   action tag { SET(tag, p); }
   action tagc { SET(tag, p-1); }
   action aval { SET(aval, p); }
-  action aunq { 
+  action aunq {
     if (*(p-1) == '"' || *(p-1) == '\'') { SET(aval, p-1); }
     else { SET(aval, p); }
   }
@@ -118,14 +124,16 @@ typedef struct {
   action pubid  { SET(aval, p); ATTR(ID2SYM(rb_intern("public_id")), aval); }
   action sysid  { SET(aval, p); ATTR(ID2SYM(rb_intern("system_id")), aval); }
 
-  action new_attr { 
+  action new_attr {
     akey = Qnil;
     aval = Qnil;
     mark_akey = NULL;
     mark_aval = NULL;
   }
 
-  action save_attr { 
+  action save_attr {
+    if (!S->xml)
+      akey = rb_funcall(akey, s_downcase, 0);
     ATTR(akey, aval);
   }
 
@@ -144,7 +152,7 @@ void rb_yield_tokens(VALUE sym, VALUE tag, VALUE attr, VALUE raw, int taint)
     raw = tag;
   }
   ary = rb_ary_new3(4, sym, tag, attr, raw);
-  if (taint) { 
+  if (taint) {
     OBJ_TAINT(ary);
     OBJ_TAINT(tag);
     OBJ_TAINT(attr);
@@ -153,6 +161,7 @@ void rb_yield_tokens(VALUE sym, VALUE tag, VALUE attr, VALUE raw, int taint)
   rb_yield(ary);
 }
 
+#ifndef RHASH_TBL
 /* rb_hash_lookup() is only in Ruby 1.8.7 */
 static VALUE
 our_rb_hash_lookup(VALUE hash, VALUE key)
@@ -165,17 +174,17 @@ our_rb_hash_lookup(VALUE hash, VALUE key)
 
   return val;
 }
+#define rb_hash_lookup our_rb_hash_lookup
+#endif
 
 static void
 rb_hpricot_add(VALUE focus, VALUE ele)
 {
-  hpricot_ele *he, *he2;
-  Data_Get_Struct(focus, hpricot_ele, he);
-  Data_Get_Struct(ele, hpricot_ele, he2);
-  if (NIL_P(he->children))
-    he->children = rb_ary_new();
-  rb_ary_push(he->children, ele);
-  he2->parent = focus;
+  VALUE children = H_ELE_GET(focus, H_ELE_CHILDREN);
+  if (NIL_P(children))
+    H_ELE_SET(focus, H_ELE_CHILDREN, (children = rb_ary_new2(1)));
+  rb_ary_push(children, ele);
+  H_ELE_SET(ele, H_ELE_PARENT, focus);
 }
 
 typedef struct {
@@ -186,102 +195,70 @@ typedef struct {
   unsigned char xml, strict, fixup;
 } hpricot_state;
 
-static void
-hpricot_ele_mark(hpricot_ele *he)
-{
-  rb_gc_mark(he->tag);
-  rb_gc_mark(he->attr);
-  rb_gc_mark(he->etag);
-  rb_gc_mark(he->raw);
-  rb_gc_mark(he->parent);
-  rb_gc_mark(he->children);
-}
-
-static void
-hpricot_ele_free(hpricot_ele *he)
-{
-  free(he);
-}
-
-#define H_PROP(prop) \
+#define H_PROP(prop, idx) \
   static VALUE hpricot_ele_set_##prop(VALUE self, VALUE x) { \
-    hpricot_ele *he; \
-    Data_Get_Struct(self, hpricot_ele, he); \
-    he->prop = x; \
+    H_ELE_SET(self, idx, x); \
     return self; \
   } \
+  static VALUE hpricot_ele_clear_##prop(VALUE self) { \
+    H_ELE_SET(self, idx, Qnil); \
+    return Qtrue; \
+  } \
   static VALUE hpricot_ele_get_##prop(VALUE self) { \
-    hpricot_ele *he; \
-    Data_Get_Struct(self, hpricot_ele, he); \
-    return he->prop; \
+    return H_ELE_GET(self, idx); \
   }
 
 #define H_ATTR(prop) \
   static VALUE hpricot_ele_set_##prop(VALUE self, VALUE x) { \
-    hpricot_ele *he; \
-    Data_Get_Struct(self, hpricot_ele, he); \
-    rb_hash_aset(he->attr, ID2SYM(rb_intern("" # prop)), x); \
+    rb_hash_aset(H_ELE_GET(self, H_ELE_ATTR), ID2SYM(rb_intern("" # prop)), x); \
     return self; \
   } \
   static VALUE hpricot_ele_get_##prop(VALUE self) { \
-    hpricot_ele *he; \
-    Data_Get_Struct(self, hpricot_ele, he); \
-    return rb_hash_aref(he->attr, ID2SYM(rb_intern("" # prop))); \
+    return rb_hash_aref(H_ELE_GET(self, H_ELE_ATTR), ID2SYM(rb_intern("" # prop))); \
   }
 
-H_PROP(tag);
-H_PROP(attr);
-H_PROP(etag);
-H_PROP(parent);
-H_PROP(children);
+H_PROP(name, H_ELE_TAG);
+H_PROP(raw, H_ELE_RAW);
+H_PROP(parent, H_ELE_PARENT);
+H_PROP(attr, H_ELE_ATTR);
+H_PROP(etag, H_ELE_ETAG);
+H_PROP(children, H_ELE_CHILDREN);
+H_ATTR(target);
 H_ATTR(encoding);
 H_ATTR(version);
 H_ATTR(standalone);
 H_ATTR(system_id);
 H_ATTR(public_id);
 
-static VALUE
-hpricot_ele_get_raw(VALUE self, VALUE x) {
-  hpricot_ele *he;
-  Data_Get_Struct(self, hpricot_ele, he);
-  return he->raw;
-}
-
-static VALUE
-hpricot_ele_clear_raw(VALUE self)
-{
-  hpricot_ele *he;
-  Data_Get_Struct(self, hpricot_ele, he);
-  he->raw = Qnil;
-  return Qtrue;
-}
-
 #define H_ELE(klass) \
-  hpricot_ele *he = ALLOC(hpricot_ele); \
-  he->name = 0; \
-  he->tag = tag; \
-  he->attr = attr; \
-  he->raw = Qnil; \
-  he->EC = ec; \
-  he->etag = he->parent = he->children = Qnil; \
-  if (raw != NULL && (sym == sym_emptytag || sym == sym_stag || sym == sym_etag || sym == sym_doctype)) { \
-    he->raw = rb_str_new(raw, rawlen); \
+  ele = rb_obj_alloc(klass); \
+  if (klass == cElem) { \
+    H_ELE_SET(ele, H_ELE_TAG, tag); \
+    H_ELE_SET(ele, H_ELE_ATTR, attr); \
+    H_ELE_SET(ele, H_ELE_EC, ec); \
+    if (raw != NULL && (sym == sym_emptytag || sym == sym_stag || sym == sym_doctype)) { \
+      H_ELE_SET(ele, H_ELE_RAW, rb_str_new(raw, rawlen)); \
+    } \
+  } else if (klass == cDocType || klass == cProcIns || klass == cXMLDecl || klass == cBogusETag) { \
+    if (klass == cBogusETag) { \
+      H_ELE_SET(ele, H_ELE_TAG, tag); \
+      if (raw != NULL) \
+        H_ELE_SET(ele, H_ELE_ATTR, rb_str_new(raw, rawlen)); \
+    } else { \
+      if (klass == cDocType) \
+        ATTR(ID2SYM(rb_intern("target")), tag); \
+      H_ELE_SET(ele, H_ELE_ATTR, attr); \
+      if (klass != cProcIns) { \
+        tag = Qnil; \
+        if (raw != NULL) tag = rb_str_new(raw, rawlen); \
+      } \
+      H_ELE_SET(ele, H_ELE_TAG, tag); \
+    } \
+  } else { \
+    H_ELE_SET(ele, H_ELE_TAG, tag); \
   } \
-  ele = Data_Wrap_Struct(klass, hpricot_ele_mark, hpricot_ele_free, he); \
   S->last = ele
 
-VALUE
-hpricot_ele_alloc(VALUE klass)
-{
-  VALUE ele;
-  hpricot_ele *he = ALLOC(hpricot_ele);
-  he->name = 0;
-  he->tag = he->attr = he->raw = he->EC = Qnil;
-  he->etag = he->parent = he->children = Qnil;
-  ele = Data_Wrap_Struct(klass, hpricot_ele_mark, hpricot_ele_free, he);
-  return ele;
-}
-
 //
 // the swift, compact parser logic.  most of the complicated stuff is done
 // in the lexer.  this step just pairs up the start and end tags.
@@ -295,22 +272,23 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
   // in html mode, fix up start tags incorrectly formed as empty tags
   //
   if (!S->xml) {
-    hpricot_ele *last;
-    Data_Get_Struct(S->focus, hpricot_ele, last);
-    if (last->EC == sym_CDATA &&
-       (sym != sym_procins && sym != sym_comment && sym != sym_cdata && sym != sym_text) &&
-      !(sym == sym_etag && rb_str_hash(tag) == last->name))
-    {
-      sym = sym_text;
-      tag = rb_str_new(raw, rawlen);
-    }
-
     if (sym == sym_emptytag || sym == sym_stag || sym == sym_etag) {
       ec = rb_hash_aref(S->EC, tag);
       if (NIL_P(ec)) {
         tag = rb_funcall(tag, s_downcase, 0);
         ec = rb_hash_aref(S->EC, tag);
       }
+    }
+
+    if (H_ELE_GET(S->focus, H_ELE_EC) == sym_CDATA &&
+       (sym != sym_procins && sym != sym_comment && sym != sym_cdata && sym != sym_text) &&
+      !(sym == sym_etag && INT2FIX(rb_str_hash(tag)) == H_ELE_GET(S->focus, H_ELE_HASH)))
+    {
+      sym = sym_text;
+      tag = rb_str_new(raw, rawlen);
+    }
+
+    if (!NIL_P(ec)) {
       if (sym == sym_emptytag) {
         if (ec != sym_EMPTY)
           sym = sym_stag;
@@ -322,19 +300,19 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
   }
 
   if (sym == sym_emptytag || sym == sym_stag) {
+    VALUE name = INT2FIX(rb_str_hash(tag));
     H_ELE(cElem);
-    he->name = rb_str_hash(tag);
+    H_ELE_SET(ele, H_ELE_HASH, name);
 
     if (!S->xml) {
       VALUE match = Qnil, e = S->focus;
       while (e != S->doc)
       {
-        hpricot_ele *hee;
-        Data_Get_Struct(e, hpricot_ele, hee);
+        VALUE hEC = H_ELE_GET(e, H_ELE_EC);
 
-        if (TYPE(hee->EC) == T_HASH)
+        if (TYPE(hEC) == T_HASH)
         {
-          VALUE has = our_rb_hash_lookup(hee->EC, INT2NUM(he->name));
+          VALUE has = rb_hash_lookup(hEC, name);
           if (has != Qnil) {
             if (has == Qtrue) {
               if (match == Qnil)
@@ -347,7 +325,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
           }
         }
 
-        e = hee->parent;
+        e = H_ELE_GET(e, H_ELE_PARENT);
       }
 
       if (match == Qnil)
@@ -369,8 +347,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
       }
     }
   } else if (sym == sym_etag) {
-    int name;
-    VALUE match = Qnil, e = S->focus;
+    VALUE name, match = Qnil, e = S->focus;
     if (S->strict) {
       if (NIL_P(rb_hash_aref(S->EC, tag))) {
         tag = rb_str_new2("div");
@@ -383,19 +360,16 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     //
     // (see also: the search above for fixups)
     //
-    name = rb_str_hash(tag);
+    name = INT2FIX(rb_str_hash(tag));
     while (e != S->doc)
     {
-      hpricot_ele *he;
-      Data_Get_Struct(e, hpricot_ele, he);
-
-      if (he->name == name)
+      if (H_ELE_GET(e, H_ELE_HASH) == name)
       {
         match = e;
         break;
       }
 
-      e = he->parent;
+      e = H_ELE_GET(e, H_ELE_PARENT);
     }
 
     if (NIL_P(match))
@@ -405,10 +379,11 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     }
     else
     {
-      H_ELE(cETag);
-      Data_Get_Struct(match, hpricot_ele, he);
-      he->etag = ele;
-      S->focus = he->parent;
+      VALUE ele = Qnil;
+      if (raw != NULL)
+        ele = rb_str_new(raw, rawlen);
+      H_ELE_SET(match, H_ELE_ETAG, ele);
+      S->focus = H_ELE_GET(match, H_ELE_PARENT);
       S->last = Qnil;
     }
   } else if (sym == sym_cdata) {
@@ -429,15 +404,13 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     tag = rb_reg_nth_match(1, match);
     attr = rb_reg_nth_match(2, match);
     {
-        H_ELE(cProcIns);
-        rb_hpricot_add(S->focus, ele);
+      H_ELE(cProcIns);
+      rb_hpricot_add(S->focus, ele);
     }
   } else if (sym == sym_text) {
     // TODO: add raw_string as well?
     if (!NIL_P(S->last) && RBASIC(S->last)->klass == cText) {
-      hpricot_ele *he;
-      Data_Get_Struct(S->last, hpricot_ele, he);
-      rb_str_append(he->tag, tag);
+      rb_str_append(H_ELE_GET(S->last, H_ELE_TAG), tag);
     } else {
       H_ELE(cText);
       rb_hpricot_add(S->focus, ele);
@@ -450,7 +423,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
 
 VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
 {
-  int cs, act, have = 0, nread = 0, curline = 1, text = 0;
+  int cs, act, have = 0, nread = 0, curline = 1, text = 0, io = 0;
   char *ts = 0, *te = 0, *buf = NULL, *eof = NULL;
 
   hpricot_state *S = NULL;
@@ -460,12 +433,13 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
   int done = 0, ele_open = 0, buffer_size = 0, taint = 0;
 
   rb_scan_args(argc, argv, "11", &port, &opts);
-  taint = OBJ_TAINTED( port );
-  if ( !rb_respond_to( port, s_read ) )
+  taint = OBJ_TAINTED(port);
+  io = rb_respond_to(port, s_read);
+  if (!io)
   {
-    if ( rb_respond_to( port, s_to_str ) )
+    if (rb_respond_to(port, s_to_str))
     {
-      port = rb_funcall( port, s_to_str, 0 );
+      port = rb_funcall(port, s_to_str, 0);
       StringValue(port);
     }
     else
@@ -479,11 +453,8 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
 
   if (!rb_block_given_p())
   {
-    hpricot_ele *he = ALLOC(hpricot_ele);
     S = ALLOC(hpricot_state);
-    MEMZERO(he, hpricot_ele, 1);
-    he->tag = he->attr = he->etag = he->parent = he->children = Qnil;
-    S->doc = Data_Wrap_Struct(cDoc, hpricot_ele_mark, hpricot_ele_free, he);
+    S->doc = rb_obj_alloc(cDoc);
     rb_gc_register_address(&S->doc);
     S->focus = S->doc;
     S->last = Qnil;
@@ -503,65 +474,68 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
       buffer_size = NUM2INT(bufsize);
     }
   }
-  buf = ALLOC_N(char, buffer_size);
+
+  if (io)
+    buf = ALLOC_N(char, buffer_size);
 
   %% write init;
-  
-  while ( !done ) {
+
+  while (!done) {
     VALUE str;
     char *p, *pe;
     int len, space = buffer_size - have, tokstart_diff, tokend_diff, mark_tag_diff, mark_akey_diff, mark_aval_diff;
 
-    if ( space == 0 ) {
-      /* We've used up the entire buffer storing an already-parsed token
-       * prefix that must be preserved.  Likely caused by super-long attributes.
-       * Increase buffer size and continue  */
-       tokstart_diff = ts - buf;
-       tokend_diff = te - buf;
-       mark_tag_diff = mark_tag - buf;
-       mark_akey_diff = mark_akey - buf;
-       mark_aval_diff = mark_aval - buf;
-
-       buffer_size += BUFSIZE;
-       REALLOC_N(buf, char, buffer_size);
-
-       space = buffer_size - have;
-
-       ts= buf + tokstart_diff;
-       te = buf + tokend_diff;
-       mark_tag = buf + mark_tag_diff;
-       mark_akey = buf + mark_akey_diff;
-       mark_aval = buf + mark_aval_diff;
-    }
-    p = buf + have;
-
-    if ( rb_respond_to( port, s_read ) )
+    if (io)
     {
+      if (space == 0) {
+        /* We've used up the entire buffer storing an already-parsed token
+         * prefix that must be preserved.  Likely caused by super-long attributes.
+         * Increase buffer size and continue  */
+         tokstart_diff = ts - buf;
+         tokend_diff = te - buf;
+         mark_tag_diff = mark_tag - buf;
+         mark_akey_diff = mark_akey - buf;
+         mark_aval_diff = mark_aval - buf;
+
+         buffer_size += BUFSIZE;
+         REALLOC_N(buf, char, buffer_size);
+
+         space = buffer_size - have;
+
+         ts = buf + tokstart_diff;
+         te = buf + tokend_diff;
+         mark_tag = buf + mark_tag_diff;
+         mark_akey = buf + mark_akey_diff;
+         mark_aval = buf + mark_aval_diff;
+      }
+      p = buf + have;
+
       str = rb_funcall(port, s_read, 1, INT2FIX(space));
       len = RSTRING_LEN(str);
       memcpy(p, StringValuePtr(str), len);
     }
     else
     {
-      len = RSTRING_LEN(port) - nread;
-      if (len > space) len = space;
-      memcpy(p, StringValuePtr(port) + nread, len);
+      p = RSTRING_PTR(port);
+      len = RSTRING_LEN(port) + 1;
+      done = 1;
     }
 
     nread += len;
 
     /* If this is the last buffer, tack on an EOF. */
-    if ( len < space ) {
+    if (io && len < space) {
       p[len++] = 0;
       done = 1;
     }
 
     pe = p + len;
     %% write exec;
-    
-    if ( cs == hpricot_scan_error ) {
-      free(buf);
-      if ( !NIL_P(tag) )
+
+    if (cs == hpricot_scan_error) {
+      if (buf != NULL)
+        free(buf);
+      if (!NIL_P(tag))
       {
         rb_raise(rb_eHpricotParseError, "parse error on element <%s>, starting on line %d.\n" NO_WAY_SERIOUSLY, RSTRING_PTR(tag), curline);
       }
@@ -570,8 +544,8 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eHpricotParseError, "parse error on line %d.\n" NO_WAY_SERIOUSLY, curline);
       }
     }
-    
-    if ( done && ele_open )
+
+    if (done && ele_open)
     {
       ele_open = 0;
       if (ts > 0) {
@@ -581,11 +555,11 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
       }
     }
 
-    if ( ts == 0 )
+    if (ts == 0)
     {
       have = 0;
       /* text nodes have no ts because each byte is parsed alone */
-      if ( mark_tag != NULL && text == 1 )
+      if (mark_tag != NULL && text == 1)
       {
         if (done)
         {
@@ -600,12 +574,15 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
           CAT(tag, p);
         }
       }
-      mark_tag = buf;
+      if (io)
+        mark_tag = buf;
+      else
+        mark_tag = RSTRING_PTR(port);
     }
-    else
+    else if (io)
     {
       have = pe - ts;
-      memmove( buf, ts, have );
+      memmove(buf, ts, have);
       SLIDE(tag);
       SLIDE(akey);
       SLIDE(aval);
@@ -613,7 +590,9 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
       ts = buf;
     }
   }
-  free(buf);
+
+  if (buf != NULL)
+    free(buf);
 
   if (S != NULL)
   {
@@ -626,66 +605,103 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
-void Init_hpricot_scan()
+static VALUE
+alloc_hpricot_struct(VALUE klass)
 {
-  mHpricot = rb_define_module("Hpricot");
-  rb_define_attr(rb_singleton_class(mHpricot), "buffer_size", 1, 1);
-  rb_define_singleton_method(mHpricot, "scan", hpricot_scan, -1);
-  rb_define_singleton_method(mHpricot, "css", hpricot_css, 3);
-  rb_eHpricotParseError = rb_define_class_under(mHpricot, "ParseError", rb_eStandardError);
+  VALUE size;
+  long n;
+  NEWOBJ(st, struct RStruct);
+  OBJSETUP(st, klass, T_STRUCT);
+
+  size = rb_struct_iv_get(klass, "__size__");
+  n = FIX2LONG(size);
+
+#ifndef RSTRUCT_EMBED_LEN_MAX
+  st->ptr = ALLOC_N(VALUE, n);
+  rb_mem_clear(st->ptr, n);
+  st->len = n;
+#else
+  if (0 < n && n <= RSTRUCT_EMBED_LEN_MAX) {
+    RBASIC(st)->flags &= ~RSTRUCT_EMBED_LEN_MASK;
+    RBASIC(st)->flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
+    rb_mem_clear(st->as.ary, n);
+  } else {
+    st->as.heap.ptr = ALLOC_N(VALUE, n);
+    rb_mem_clear(st->as.heap.ptr, n);
+    st->as.heap.len = n;
+  }
+#endif
 
-  cDoc = rb_define_class_under(mHpricot, "Doc", rb_cObject);
-  rb_define_alloc_func(cDoc, hpricot_ele_alloc);
-  rb_define_method(cDoc, "children", hpricot_ele_get_children, 0);
-  rb_define_method(cDoc, "children=", hpricot_ele_set_children, 1);
-
-  cBaseEle = rb_define_class_under(mHpricot, "BaseEle", rb_cObject);
-  rb_define_alloc_func(cBaseEle, hpricot_ele_alloc);
-  rb_define_method(cBaseEle, "raw_string", hpricot_ele_get_raw, 0);
-  rb_define_method(cBaseEle, "clear_raw", hpricot_ele_clear_raw, 0);
-  rb_define_method(cBaseEle, "parent", hpricot_ele_get_parent, 0);
-  rb_define_method(cBaseEle, "parent=", hpricot_ele_set_parent, 1);
-  cCData = rb_define_class_under(mHpricot, "CData", cBaseEle);
-  rb_define_method(cCData, "content", hpricot_ele_get_tag, 0);
-  rb_define_method(cCData, "content=", hpricot_ele_set_tag, 1);
-  cComment = rb_define_class_under(mHpricot, "Comment", cBaseEle);
-  rb_define_method(cComment, "content", hpricot_ele_get_tag, 0);
-  rb_define_method(cComment, "content=", hpricot_ele_set_tag, 1);
-  cDocType = rb_define_class_under(mHpricot, "DocType", cBaseEle);
-  rb_define_method(cDocType, "target", hpricot_ele_get_tag, 0);
-  rb_define_method(cDocType, "target=", hpricot_ele_set_tag, 1);
-  rb_define_method(cDocType, "public_id", hpricot_ele_get_public_id, 0);
-  rb_define_method(cDocType, "public_id=", hpricot_ele_set_public_id, 1);
-  rb_define_method(cDocType, "system_id", hpricot_ele_get_system_id, 0);
-  rb_define_method(cDocType, "system_id=", hpricot_ele_set_system_id, 1);
-  cElem = rb_define_class_under(mHpricot, "Elem", cBaseEle);
-  rb_define_method(cElem, "raw_attributes", hpricot_ele_get_attr, 0);
-  rb_define_method(cElem, "raw_attributes=", hpricot_ele_set_attr, 1);
-  rb_define_method(cElem, "children", hpricot_ele_get_children, 0);
-  rb_define_method(cElem, "children=", hpricot_ele_set_children, 1);
-  rb_define_method(cElem, "etag", hpricot_ele_get_etag, 0);
-  rb_define_method(cElem, "etag=", hpricot_ele_set_etag, 1);
-  rb_define_method(cElem, "name", hpricot_ele_get_tag, 0);
-  rb_define_method(cElem, "name=", hpricot_ele_set_tag, 1);
-  cETag = rb_define_class_under(mHpricot, "ETag", cBaseEle);
-  rb_define_method(cETag, "name", hpricot_ele_get_tag, 0);
-  rb_define_method(cETag, "name=", hpricot_ele_set_tag, 1);
-  cBogusETag = rb_define_class_under(mHpricot, "BogusETag", cETag);
-  cText = rb_define_class_under(mHpricot, "Text", cBaseEle);
-  rb_define_method(cText, "content", hpricot_ele_get_tag, 0);
-  rb_define_method(cText, "content=", hpricot_ele_set_tag, 1);
-  cXMLDecl = rb_define_class_under(mHpricot, "XMLDecl", cBaseEle);
-  rb_define_method(cXMLDecl, "encoding", hpricot_ele_get_encoding, 0);
-  rb_define_method(cXMLDecl, "encoding=", hpricot_ele_set_encoding, 1);
-  rb_define_method(cXMLDecl, "standalone", hpricot_ele_get_standalone, 0);
-  rb_define_method(cXMLDecl, "standalone=", hpricot_ele_set_standalone, 1);
-  rb_define_method(cXMLDecl, "version", hpricot_ele_get_version, 0);
-  rb_define_method(cXMLDecl, "version=", hpricot_ele_set_version, 1);
-  cProcIns = rb_define_class_under(mHpricot, "ProcIns", cBaseEle);
-  rb_define_method(cProcIns, "target", hpricot_ele_get_tag, 0);
-  rb_define_method(cProcIns, "target=", hpricot_ele_set_tag, 1);
-  rb_define_method(cProcIns, "content", hpricot_ele_get_attr, 0);
-  rb_define_method(cProcIns, "content=", hpricot_ele_set_attr, 1);
+  return (VALUE)st;
+}
+
+static VALUE hpricot_struct_ref0(VALUE obj) {return H_ELE_GET(obj, 0);}
+static VALUE hpricot_struct_ref1(VALUE obj) {return H_ELE_GET(obj, 1);}
+static VALUE hpricot_struct_ref2(VALUE obj) {return H_ELE_GET(obj, 2);}
+static VALUE hpricot_struct_ref3(VALUE obj) {return H_ELE_GET(obj, 3);}
+static VALUE hpricot_struct_ref4(VALUE obj) {return H_ELE_GET(obj, 4);}
+static VALUE hpricot_struct_ref5(VALUE obj) {return H_ELE_GET(obj, 5);}
+static VALUE hpricot_struct_ref6(VALUE obj) {return H_ELE_GET(obj, 6);}
+static VALUE hpricot_struct_ref7(VALUE obj) {return H_ELE_GET(obj, 7);}
+static VALUE hpricot_struct_ref8(VALUE obj) {return H_ELE_GET(obj, 8);}
+static VALUE hpricot_struct_ref9(VALUE obj) {return H_ELE_GET(obj, 9);}
+
+static VALUE (*ref_func[10])() = {
+  hpricot_struct_ref0,
+  hpricot_struct_ref1,
+  hpricot_struct_ref2,
+  hpricot_struct_ref3,
+  hpricot_struct_ref4,
+  hpricot_struct_ref5,
+  hpricot_struct_ref6,
+  hpricot_struct_ref7,
+  hpricot_struct_ref8,
+  hpricot_struct_ref9,
+};
+
+static VALUE hpricot_struct_set0(VALUE obj, VALUE val) {return H_ELE_SET(obj, 0, val);}
+static VALUE hpricot_struct_set1(VALUE obj, VALUE val) {return H_ELE_SET(obj, 1, val);}
+static VALUE hpricot_struct_set2(VALUE obj, VALUE val) {return H_ELE_SET(obj, 2, val);}
+static VALUE hpricot_struct_set3(VALUE obj, VALUE val) {return H_ELE_SET(obj, 3, val);}
+static VALUE hpricot_struct_set4(VALUE obj, VALUE val) {return H_ELE_SET(obj, 4, val);}
+static VALUE hpricot_struct_set5(VALUE obj, VALUE val) {return H_ELE_SET(obj, 5, val);}
+static VALUE hpricot_struct_set6(VALUE obj, VALUE val) {return H_ELE_SET(obj, 6, val);}
+static VALUE hpricot_struct_set7(VALUE obj, VALUE val) {return H_ELE_SET(obj, 7, val);}
+static VALUE hpricot_struct_set8(VALUE obj, VALUE val) {return H_ELE_SET(obj, 8, val);}
+static VALUE hpricot_struct_set9(VALUE obj, VALUE val) {return H_ELE_SET(obj, 9, val);}
+
+static VALUE (*set_func[10])() = {
+  hpricot_struct_set0,
+  hpricot_struct_set1,
+  hpricot_struct_set2,
+  hpricot_struct_set3,
+  hpricot_struct_set4,
+  hpricot_struct_set5,
+  hpricot_struct_set6,
+  hpricot_struct_set7,
+  hpricot_struct_set8,
+  hpricot_struct_set9,
+};
+
+static VALUE
+make_hpricot_struct(VALUE members)
+{
+  int i = 0;
+  VALUE klass = rb_class_new(rb_cObject);
+  rb_iv_set(klass, "__size__", INT2NUM(RARRAY_LEN(members)));
+  rb_define_alloc_func(klass, alloc_hpricot_struct);
+  rb_define_singleton_method(klass, "new", rb_class_new_instance, -1);
+  for (i = 0; i < RARRAY_LEN(members); i++) {
+    ID id = SYM2ID(RARRAY_PTR(members)[i]);
+    rb_define_method_id(klass, id, ref_func[i], 0);
+    rb_define_method_id(klass, rb_id_attrset(id), set_func[i], 1);
+  }
+  return klass;
+}
+
+void Init_hpricot_scan()
+{
+  VALUE structElem, structAttr, structBasic;
 
   s_ElementContent = rb_intern("ElementContent");
   symAllow = ID2SYM(rb_intern("allow"));
@@ -695,19 +711,78 @@ void Init_hpricot_scan()
   s_parent = rb_intern("parent");
   s_read = rb_intern("read");
   s_to_str = rb_intern("to_str");
-  iv_parent = rb_intern("parent");
   sym_xmldecl = ID2SYM(rb_intern("xmldecl"));
   sym_doctype = ID2SYM(rb_intern("doctype"));
   sym_procins = ID2SYM(rb_intern("procins"));
   sym_stag = ID2SYM(rb_intern("stag"));
   sym_etag = ID2SYM(rb_intern("etag"));
   sym_emptytag = ID2SYM(rb_intern("emptytag"));
+  sym_allowed = ID2SYM(rb_intern("allowed"));
+  sym_children = ID2SYM(rb_intern("children"));
   sym_comment = ID2SYM(rb_intern("comment"));
   sym_cdata = ID2SYM(rb_intern("cdata"));
+  sym_name = ID2SYM(rb_intern("name"));
+  sym_parent = ID2SYM(rb_intern("parent"));
+  sym_raw_attributes = ID2SYM(rb_intern("raw_attributes"));
+  sym_raw_string = ID2SYM(rb_intern("raw_string"));
+  sym_tagno = ID2SYM(rb_intern("tagno"));
   sym_text = ID2SYM(rb_intern("text"));
   sym_EMPTY = ID2SYM(rb_intern("EMPTY"));
   sym_CDATA = ID2SYM(rb_intern("CDATA"));
 
+  mHpricot = rb_define_module("Hpricot");
+  rb_define_attr(rb_singleton_class(mHpricot), "buffer_size", 1, 1);
+  rb_define_singleton_method(mHpricot, "scan", hpricot_scan, -1);
+  rb_define_singleton_method(mHpricot, "css", hpricot_css, 3);
+  rb_eHpricotParseError = rb_define_class_under(mHpricot, "ParseError", rb_eStandardError);
+
+  structElem = make_hpricot_struct(rb_ary_new3(8, sym_name, sym_parent,
+    sym_raw_attributes, sym_etag, sym_raw_string, sym_allowed,
+    sym_tagno, sym_children));
+  structAttr = make_hpricot_struct(rb_ary_new3(3, sym_name, sym_parent, sym_raw_attributes));
+  structBasic = make_hpricot_struct(rb_ary_new3(2, sym_name, sym_parent));
+
+  cDoc = rb_define_class_under(mHpricot, "Doc", structElem);
+  cCData = rb_define_class_under(mHpricot, "CData", structBasic);
+  rb_define_method(cCData, "content", hpricot_ele_get_name, 0);
+  rb_define_method(cCData, "content=", hpricot_ele_set_name, 1);
+  cComment = rb_define_class_under(mHpricot, "Comment", structBasic);
+  rb_define_method(cComment, "content", hpricot_ele_get_name, 0);
+  rb_define_method(cComment, "content=", hpricot_ele_set_name, 1);
+  cDocType = rb_define_class_under(mHpricot, "DocType", structAttr);
+  rb_define_method(cDocType, "raw_string", hpricot_ele_get_name, 0);
+  rb_define_method(cDocType, "clear_raw", hpricot_ele_clear_name, 0);
+  rb_define_method(cDocType, "target", hpricot_ele_get_target, 0);
+  rb_define_method(cDocType, "target=", hpricot_ele_set_target, 1);
+  rb_define_method(cDocType, "public_id", hpricot_ele_get_public_id, 0);
+  rb_define_method(cDocType, "public_id=", hpricot_ele_set_public_id, 1);
+  rb_define_method(cDocType, "system_id", hpricot_ele_get_system_id, 0);
+  rb_define_method(cDocType, "system_id=", hpricot_ele_set_system_id, 1);
+  cElem = rb_define_class_under(mHpricot, "Elem", structElem);
+  rb_define_method(cElem, "clear_raw", hpricot_ele_clear_raw, 0);
+  cBogusETag = rb_define_class_under(mHpricot, "BogusETag", structAttr);
+  rb_define_method(cBogusETag, "raw_string", hpricot_ele_get_attr, 0);
+  rb_define_method(cBogusETag, "clear_raw", hpricot_ele_clear_attr, 0);
+  cText = rb_define_class_under(mHpricot, "Text", structBasic);
+  rb_define_method(cText, "raw_string", hpricot_ele_get_name, 0);
+  rb_define_method(cText, "clear_raw", hpricot_ele_clear_name, 0);
+  rb_define_method(cText, "content", hpricot_ele_get_name, 0);
+  rb_define_method(cText, "content=", hpricot_ele_set_name, 1);
+  cXMLDecl = rb_define_class_under(mHpricot, "XMLDecl", structAttr);
+  rb_define_method(cXMLDecl, "raw_string", hpricot_ele_get_name, 0);
+  rb_define_method(cXMLDecl, "clear_raw", hpricot_ele_clear_name, 0);
+  rb_define_method(cXMLDecl, "encoding", hpricot_ele_get_encoding, 0);
+  rb_define_method(cXMLDecl, "encoding=", hpricot_ele_set_encoding, 1);
+  rb_define_method(cXMLDecl, "standalone", hpricot_ele_get_standalone, 0);
+  rb_define_method(cXMLDecl, "standalone=", hpricot_ele_set_standalone, 1);
+  rb_define_method(cXMLDecl, "version", hpricot_ele_get_version, 0);
+  rb_define_method(cXMLDecl, "version=", hpricot_ele_set_version, 1);
+  cProcIns = rb_define_class_under(mHpricot, "ProcIns", structAttr);
+  rb_define_method(cProcIns, "target", hpricot_ele_get_name, 0);
+  rb_define_method(cProcIns, "target=", hpricot_ele_set_name, 1);
+  rb_define_method(cProcIns, "content", hpricot_ele_get_attr, 0);
+  rb_define_method(cProcIns, "content=", hpricot_ele_set_attr, 1);
+
   rb_const_set(mHpricot, rb_intern("ProcInsParse"),
     reProcInsParse = rb_eval_string("/\\A<\\?(\\S+)\\s+(.+)/m"));
 }