hpricot 0.8.2 → 0.8.3

data/ext/hpricot_scan/hpricot_scan.java.rl

@@ -137,62 +137,62 @@ public class HpricotScanService implements BasicLibraryService {
 
     // H_ATTR(target)
     public static IRubyObject hpricot_ele_set_target(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("target"), x);
+        H_ELE_GET_asHash(self, H_ELE_ATTR).fastASet(self.getRuntime().newSymbol("target"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_target(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("target"));
+        return H_ELE_GET_asHash(self, H_ELE_ATTR).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("target"));
     }
 
     // H_ATTR(encoding)
     public static IRubyObject hpricot_ele_set_encoding(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("encoding"), x);
+        ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("encoding"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_encoding(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("encoding"));
+        return ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("encoding"));
     }
 
     // H_ATTR(version)
     public static IRubyObject hpricot_ele_set_version(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("version"), x);
+        ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("version"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_version(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("version"));
+        return ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("version"));
     }
 
     // H_ATTR(standalone)
     public static IRubyObject hpricot_ele_set_standalone(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("standalone"), x);
+        ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("standalone"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_standalone(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("standalone"));
+        return ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("standalone"));
     }
 
     // H_ATTR(system_id)
     public static IRubyObject hpricot_ele_set_system_id(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("system_id"), x);
+        ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("system_id"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_system_id(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("system_id"));
+        return ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("system_id"));
     }
 
     // H_ATTR(public_id)
     public static IRubyObject hpricot_ele_set_public_id(IRubyObject self, IRubyObject x) {
-        ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("public_id"), x);
+        ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).fastASet(self.getRuntime().newSymbol("public_id"), x);
         return self;
     }
 
     public static IRubyObject hpricot_ele_get_public_id(IRubyObject self) {
-        return ((RubyHash)H_ELE_GET(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("public_id"));
+        return ((RubyHash)H_ELE_GET_asHash(self, H_ELE_ATTR)).op_aref(self.getRuntime().getCurrentContext(), self.getRuntime().newSymbol("public_id"));
     }
 
     public static class Scanner {
@@ -950,7 +950,7 @@ public class HpricotScanService implements BasicLibraryService {
         }
     }
 
-    public final static String NO_WAY_SERIOUSLY = "*** This should not happen, please send a bug report with the HTML you're parsing to why@whytheluckystiff.net.  So sorry!";
+    public final static String NO_WAY_SERIOUSLY = "*** This should not happen, please file a bug report with the HTML you're parsing at http://github.com/hpricot/hpricot/issues.  So sorry!";
 
     public final static int H_ELE_TAG = 0;
     public final static int H_ELE_PARENT = 1;
@@ -965,6 +965,15 @@ public class HpricotScanService implements BasicLibraryService {
         return ((IRubyObject[])recv.dataGetStruct())[n];
     }
 
+    public static RubyHash H_ELE_GET_asHash(IRubyObject recv, int n) {
+        IRubyObject obj = ((IRubyObject[])recv.dataGetStruct())[n];
+        if(obj.isNil()) {
+            obj = RubyHash.newHash(recv.getRuntime());
+            ((IRubyObject[])recv.dataGetStruct())[n] = obj;
+        }
+        return (RubyHash)obj;
+    }
+
     public static IRubyObject H_ELE_SET(IRubyObject recv, int n, IRubyObject value) {
         ((IRubyObject[])recv.dataGetStruct())[n] = value;
         return value;

data/ext/hpricot_scan/hpricot_scan.rl

@@ -4,9 +4,15 @@
  * $Author: why $
  * $Date: 2006-05-08 22:03:50 -0600 (Mon, 08 May 2006) $
  *
- * Copyright (C) 2006 why the lucky stiff
+ * Copyright (C) 2006, 2010 why the lucky stiff
  */
 #include <ruby.h>
+#include <assert.h>
+
+struct hpricot_struct {
+  int len;
+  VALUE* ptr;
+};
 
 #ifndef RARRAY_LEN
 #define RARRAY_LEN(arr)  RARRAY(arr)->len
@@ -16,7 +22,7 @@
 
 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!"
+#define NO_WAY_SERIOUSLY "*** This should not happen, please file a bug report with the HTML you're parsing at http://github.com/hpricot/hpricot/issues.  So sorry!"
 
 static VALUE sym_xmldecl, sym_doctype, sym_procins, sym_stag, sym_etag, sym_emptytag, sym_comment,
       sym_cdata, sym_name, sym_parent, sym_raw_attributes, sym_raw_string, sym_tagno,
@@ -37,32 +43,49 @@ static VALUE reProcInsParse;
 #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 HSTRUCT_PTR(ele) ((struct hpricot_struct*)DATA_PTR(ele))->ptr
+
+#define H_ELE_GET(ele, idx)      HSTRUCT_PTR(ele)[idx]
+#define H_ELE_SET(ele, idx, val) HSTRUCT_PTR(ele)[idx] = val
 
 #define OPT(opts, key) (!NIL_P(opts) && RTEST(rb_hash_aref(opts, ID2SYM(rb_intern("" # key)))))
 
-#define ELE(N) \
-  if (te > ts || text == 1) { \
-    char *raw = NULL; \
-    int rawlen = 0; \
-    ele_open = 0; text = 0; \
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+# define ASSOCIATE_INDEX(s)  rb_enc_associate_index((s), encoding_index)
+# define ENCODING_INDEX     , encoding_index
+#else
+# define ASSOCIATE_INDEX(s)
+# define ENCODING_INDEX
+#endif
+
+#define ELE(N)                                                          \
+  if (te > ts || text == 1) {                                           \
+    char *raw = NULL;                                                   \
+    int rawlen = 0;                                                     \
+    ele_open = 0; text = 0;                                             \
     if (ts != 0 && sym_##N != sym_cdata && sym_##N != sym_text && sym_##N != sym_procins && sym_##N != sym_comment) { \
-      raw = ts; rawlen = te - ts; \
-    } \
-    if (rb_block_given_p()) { \
-      VALUE raw_string = Qnil; \
-      if (raw != NULL) raw_string = rb_str_new(raw, rawlen); \
-      rb_yield_tokens(sym_##N, tag, attr, Qnil, taint); \
-    } else \
-      rb_hpricot_token(S, sym_##N, tag, attr, raw, rawlen, taint); \
+      raw = ts; rawlen = te - ts;                                       \
+    }                                                                   \
+    if (rb_block_given_p()) {                                           \
+      VALUE raw_string = Qnil;                                          \
+      if (raw != NULL) {                                                \
+        raw_string = rb_str_new(raw, rawlen);                           \
+        ASSOCIATE_INDEX(raw_string);                                    \
+      }                                                                 \
+      rb_yield_tokens(sym_##N, tag, attr, Qnil, taint);                 \
+    } else                                                              \
+      rb_hpricot_token(S, sym_##N, tag, attr, raw, rawlen, taint ENCODING_INDEX); \
   }
 
-#define SET(N, E) \
-  if (mark_##N == NULL || E == mark_##N) \
-    N = rb_str_new2(""); \
-  else if (E > mark_##N) \
-    N = rb_str_new(mark_##N, E - mark_##N);
+#define SET(N, E)                               \
+  if (mark_##N == NULL || E == mark_##N) {      \
+    N = rb_str_new2("");                        \
+    ASSOCIATE_INDEX(N);                         \
+  } else if (E > mark_##N) {                    \
+    N = rb_str_new(mark_##N, E - mark_##N);     \
+    ASSOCIATE_INDEX(N);                         \
+  }
 
 #define CAT(N, E) if (NIL_P(N)) { SET(N, E); } else { rb_str_cat(N, mark_##N, E - mark_##N); }
 
@@ -119,7 +142,18 @@ static VALUE reProcInsParse;
   }
   action akey { SET(akey, p); }
   action xmlver { SET(aval, p); ATTR(ID2SYM(rb_intern("version")), aval); }
-  action xmlenc { SET(aval, p); ATTR(ID2SYM(rb_intern("encoding")), aval); }
+  action xmlenc {
+#ifdef HAVE_RUBY_ENCODING_H
+    if (mark_aval < p) {
+      char psave = *p;
+      *p = '\0';
+      encoding_index = rb_enc_find_index(mark_aval);
+      *p = psave;
+    }
+#endif
+    SET(aval, p);
+    ATTR(ID2SYM(rb_intern("encoding")), aval);
+  }
   action xmlsd  { SET(aval, p); ATTR(ID2SYM(rb_intern("standalone")), aval); }
   action pubid  { SET(aval, p); ATTR(ID2SYM(rb_intern("public_id")), aval); }
   action sysid  { SET(aval, p); ATTR(ID2SYM(rb_intern("system_id")), aval); }
@@ -132,7 +166,7 @@ static VALUE reProcInsParse;
   }
 
   action save_attr {
-    if (!S->xml)
+    if (!S->xml && !NIL_P(akey))
       akey = rb_funcall(akey, s_downcase, 0);
     ATTR(akey, aval);
   }
@@ -230,33 +264,41 @@ H_ATTR(standalone);
 H_ATTR(system_id);
 H_ATTR(public_id);
 
-#define H_ELE(klass) \
-  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); \
+#define H_ELE(klass)                                                    \
+  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)); \
-    } \
+      VALUE raw_str = rb_str_new(raw, rawlen);                          \
+      ASSOCIATE_INDEX(raw_str);                                         \
+      H_ELE_SET(ele, H_ELE_RAW, raw_str);                               \
+    }                                                                   \
   } 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); \
-  } \
+    if (klass == cBogusETag) {                                          \
+      H_ELE_SET(ele, H_ELE_TAG, tag);                                   \
+      if (raw != NULL) {                                                \
+        VALUE raw_str = rb_str_new(raw, rawlen);                        \
+        ASSOCIATE_INDEX(raw_str);                                       \
+        H_ELE_SET(ele, H_ELE_ATTR, raw_str);                            \
+      }                                                                 \
+    } 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);                                \
+          ASSOCIATE_INDEX(tag);                                         \
+        }                                                               \
+      }                                                                 \
+      H_ELE_SET(ele, H_ELE_TAG, tag);                                   \
+    }                                                                   \
+  } else {                                                              \
+    H_ELE_SET(ele, H_ELE_TAG, tag);                                     \
+  }                                                                     \
   S->last = ele
 
 //
@@ -264,7 +306,12 @@ H_ATTR(public_id);
 // in the lexer.  this step just pairs up the start and end tags.
 //
 void
-rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw, int rawlen, int taint)
+rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr,
+                 char *raw, int rawlen, int taint
+#ifdef HAVE_RUBY_ENCODING_H
+                 , int encoding_index
+#endif
+)
 {
   VALUE ele, ec = Qnil;
 
@@ -286,6 +333,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     {
       sym = sym_text;
       tag = rb_str_new(raw, rawlen);
+      ASSOCIATE_INDEX(tag);
     }
 
     if (!NIL_P(ec)) {
@@ -351,6 +399,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     if (S->strict) {
       if (NIL_P(rb_hash_aref(S->EC, tag))) {
         tag = rb_str_new2("div");
+        ASSOCIATE_INDEX(tag);
       }
     }
 
@@ -380,8 +429,10 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     else
     {
       VALUE ele = Qnil;
-      if (raw != NULL)
+      if (raw != NULL) {
         ele = rb_str_new(raw, rawlen);
+        ASSOCIATE_INDEX(ele);
+      }
       H_ELE_SET(match, H_ELE_ETAG, ele);
       S->focus = H_ELE_GET(match, H_ELE_PARENT);
       S->last = Qnil;
@@ -395,8 +446,13 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
   } else if (sym == sym_doctype) {
     H_ELE(cDocType);
     if (S->strict) {
-      rb_hash_aset(attr, ID2SYM(rb_intern("system_id")), rb_str_new2("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"));
-      rb_hash_aset(attr, ID2SYM(rb_intern("public_id")), rb_str_new2("-//W3C//DTD XHTML 1.0 Strict//EN"));
+      VALUE id;
+      id = rb_str_new2("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
+      ASSOCIATE_INDEX(id);
+      rb_hash_aset(attr, ID2SYM(rb_intern("system_id")), id);
+      id = rb_str_new2("-//W3C//DTD XHTML 1.0 Strict//EN");
+      ASSOCIATE_INDEX(id);
+      rb_hash_aset(attr, ID2SYM(rb_intern("public_id")), id);
     }
     rb_hpricot_add(S->focus, ele);
   } else if (sym == sym_procins) {
@@ -409,7 +465,7 @@ rb_hpricot_token(hpricot_state *S, VALUE sym, VALUE tag, VALUE attr, char *raw,
     }
   } else if (sym == sym_text) {
     // TODO: add raw_string as well?
-    if (!NIL_P(S->last) && RBASIC(S->last)->klass == cText) {
+    if (!NIL_P(S->last) && RTEST(rb_obj_is_instance_of(S->last, cText))) {
       rb_str_append(H_ELE_GET(S->last, H_ELE_TAG), tag);
     } else {
       H_ELE(cText);
@@ -431,6 +487,9 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
   VALUE attr = Qnil, tag = Qnil, akey = Qnil, aval = Qnil, bufsize = Qnil;
   char *mark_tag = 0, *mark_akey = 0, *mark_aval = 0;
   int done = 0, ele_open = 0, buffer_size = 0, taint = 0;
+#ifdef HAVE_RUBY_ENCODING_H
+  int encoding_index = rb_enc_to_index(rb_default_external_encoding());
+#endif
 
   rb_scan_args(argc, argv, "11", &port, &opts);
   taint = OBJ_TAINTED(port);
@@ -605,34 +664,68 @@ VALUE hpricot_scan(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+void hstruct_mark(void* ptr) {
+  struct hpricot_struct* st = (struct hpricot_struct*)ptr;
+  int i;
+
+  for(i = 0; i < st->len; i++) {
+    rb_gc_mark(st->ptr[i]);
+  }
+}
+
+void hstruct_free(void* ptr) {
+  struct hpricot_struct* st = (struct hpricot_struct*)ptr;
+
+  free(st->ptr);
+  free(st);
+}
+
 static VALUE
-alloc_hpricot_struct(VALUE klass)
+alloc_hpricot_struct8(VALUE klass)
 {
-  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
+  VALUE obj;
+  struct hpricot_struct* st;
 
-  return (VALUE)st;
+  obj = Data_Make_Struct(klass, struct hpricot_struct, hstruct_mark, hstruct_free, st);
+
+  st->len = 8;
+  st->ptr = ALLOC_N(VALUE, 8);
+
+  rb_mem_clear(st->ptr, 8);
+
+  return obj;
+}
+
+static VALUE
+alloc_hpricot_struct2(VALUE klass)
+{
+  VALUE obj;
+  struct hpricot_struct* st;
+
+  obj = Data_Make_Struct(klass, struct hpricot_struct, hstruct_mark, hstruct_free, st);
+
+  st->len = 2;
+  st->ptr = ALLOC_N(VALUE, 2);
+
+  rb_mem_clear(st->ptr, 2);
+
+  return obj;
+}
+
+static VALUE
+alloc_hpricot_struct3(VALUE klass)
+{
+  VALUE obj;
+  struct hpricot_struct* st;
+
+  obj = Data_Make_Struct(klass, struct hpricot_struct, hstruct_mark, hstruct_free, st);
+
+  st->len = 3;
+  st->ptr = ALLOC_N(VALUE, 3);
+
+  rb_mem_clear(st->ptr, 3);
+
+  return obj;
 }
 
 static VALUE hpricot_struct_ref0(VALUE obj) {return H_ELE_GET(obj, 0);}
@@ -684,17 +777,28 @@ static VALUE (*set_func[10])() = {
 };
 
 static VALUE
-make_hpricot_struct(VALUE members)
+make_hpricot_struct(VALUE members, VALUE (*alloc)(VALUE klass))
 {
   int i = 0;
+  char attr_set[128];
+
   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);
+  rb_define_alloc_func(klass, alloc);
+
+  int len = RARRAY_LEN(members);
+  assert(len < 10);
+
+  for (i = 0; i < len; i++) {
+    ID id = SYM2ID(rb_ary_entry(members, i));
+    const char* name = rb_id2name(id);
+    int len = strlen(name);
+
+    memcpy(attr_set, name, strlen(name));
+    attr_set[len] = '=';
+    attr_set[len+1] = 0;
+
+    rb_define_method(klass, name, ref_func[i], 0);
+    rb_define_method(klass, attr_set, set_func[i], 1);
   }
   return klass;
 }
@@ -738,9 +842,13 @@ void Init_hpricot_scan()
 
   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));
+    sym_tagno, sym_children), alloc_hpricot_struct8);
+  structAttr = make_hpricot_struct(
+      rb_ary_new3(3, sym_name, sym_parent, sym_raw_attributes),
+      alloc_hpricot_struct3);
+  structBasic = make_hpricot_struct(
+      rb_ary_new3(2, sym_name, sym_parent),
+      alloc_hpricot_struct2);
 
   cDoc = rb_define_class_under(mHpricot, "Doc", structElem);
   cCData = rb_define_class_under(mHpricot, "CData", structBasic);