html_tokenizer 0.0.1

data/ext/html_tokenizer_ext/parser.h

@@ -0,0 +1,87 @@
+#pragma once
+#include "tokenizer.h"
+
+enum parser_context {
+  PARSER_NONE,
+  PARSER_SOLIDUS_OR_TAG_NAME,
+  PARSER_TAG_NAME,
+  PARSER_TAG,
+  PARSER_ATTRIBUTE_NAME,
+  PARSER_ATTRIBUTE_WHITESPACE_OR_EQUAL,
+  PARSER_ATTRIBUTE_WHITESPACE_OR_VALUE,
+  PARSER_ATTRIBUTE_QUOTED_VALUE,
+  PARSER_SPACE_AFTER_ATTRIBUTE,
+  PARSER_ATTRIBUTE_UNQUOTED_VALUE,
+  PARSER_TAG_END,
+  PARSER_COMMENT,
+  PARSER_CDATA,
+};
+
+struct parser_document_error_t {
+  char *message;
+  long unsigned int line_number;
+  long unsigned int column_number;
+};
+
+struct parser_document_t {
+  long unsigned int length;
+  char *data;
+  long unsigned int line_number;
+  long unsigned int column_number;
+};
+
+struct token_reference_t {
+  enum token_type type;
+  long unsigned int start;
+  long unsigned int length;
+  long unsigned int line_number;
+  long unsigned int column_number;
+};
+
+struct parser_tag_t {
+  struct token_reference_t name;
+  int self_closing;
+};
+
+struct parser_attribute_t {
+  struct token_reference_t name;
+  struct token_reference_t value;
+  int is_quoted;
+};
+
+struct parser_rawtext_t {
+  struct token_reference_t text;
+};
+
+struct parser_comment_t {
+  struct token_reference_t text;
+};
+
+struct parser_cdata_t {
+  struct token_reference_t text;
+};
+
+struct parser_t
+{
+  struct tokenizer_t tk;
+
+  struct parser_document_t doc;
+
+  size_t errors_count;
+  struct parser_document_error_t *errors;
+
+  enum parser_context context;
+  struct parser_tag_t tag;
+  struct parser_attribute_t attribute;
+  struct parser_rawtext_t rawtext;
+  struct parser_comment_t comment;
+  struct parser_cdata_t cdata;
+};
+
+void Init_html_tokenizer_parser(VALUE mHtmlTokenizer);
+
+extern const rb_data_type_t ht_parser_data_type;
+#define Parser_Get_Struct(obj, sval) TypedData_Get_Struct(obj, struct parser_t, &ht_parser_data_type, sval)
+
+#define PARSE_AGAIN return 1
+#define PARSE_DONE return 0

data/ext/html_tokenizer_ext/tokenizer.c

@@ -0,0 +1,682 @@
+#include <ruby.h>
+#include "html_tokenizer.h"
+#include "tokenizer.h"
+
+static VALUE cTokenizer = Qnil;
+
+static void tokenizer_mark(void *ptr)
+{}
+
+static void tokenizer_free(void *ptr)
+{
+  struct tokenizer_t *tk = ptr;
+  if(tk) {
+    if(tk->current_tag) {
+      DBG_PRINT("tk=%p xfree(tk->current_tag) %p", tk, tk->current_tag);
+      xfree(tk->current_tag);
+      tk->current_tag = NULL;
+    }
+    if(tk->scan.string) {
+      DBG_PRINT("tk=%p xfree(tk->scan.string) %p", tk, tk->scan.string);
+      xfree(tk->scan.string);
+      tk->scan.string = NULL;
+    }
+    DBG_PRINT("tk=%p xfree(tk)", tk);
+    xfree(tk);
+  }
+}
+
+static size_t tokenizer_memsize(const void *ptr)
+{
+  return ptr ? sizeof(struct tokenizer_t) : 0;
+}
+
+const rb_data_type_t ht_tokenizer_data_type = {
+  "ht_tokenizer_data_type",
+  { tokenizer_mark, tokenizer_free, tokenizer_memsize, },
+#if defined(RUBY_TYPED_FREE_IMMEDIATELY)
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+static VALUE tokenizer_allocate(VALUE klass)
+{
+  VALUE obj;
+  struct tokenizer_t *tokenizer = NULL;
+
+  obj = TypedData_Make_Struct(klass, struct tokenizer_t, &ht_tokenizer_data_type, tokenizer);
+  DBG_PRINT("tk=%p allocate", tokenizer);
+
+  memset((void *)&tokenizer->context, TOKENIZER_NONE, sizeof(struct tokenizer_t));
+
+  return obj;
+}
+
+void tokenizer_init(struct tokenizer_t *tk)
+{
+  tk->current_context = 0;
+  tk->context[0] = TOKENIZER_HTML;
+
+  tk->scan.string = NULL;
+  tk->scan.cursor = 0;
+  tk->scan.length = 0;
+
+  tk->attribute_value_start = 0;
+  tk->found_attribute = 0;
+  tk->current_tag = NULL;
+  tk->is_closing_tag = 0;
+  tk->last_token = TOKEN_NONE;
+  tk->callback_data = NULL;
+  tk->f_callback = NULL;
+
+  return;
+}
+
+VALUE token_type_to_symbol(enum token_type type)
+{
+  switch(type) {
+  case TOKEN_NONE:
+    return ID2SYM(rb_intern("none"));
+  case TOKEN_TEXT:
+    return ID2SYM(rb_intern("text"));
+  case TOKEN_WHITESPACE:
+    return ID2SYM(rb_intern("whitespace"));
+  case TOKEN_COMMENT_START:
+    return ID2SYM(rb_intern("comment_start"));
+  case TOKEN_COMMENT_END:
+    return ID2SYM(rb_intern("comment_end"));
+  case TOKEN_TAG_NAME:
+    return ID2SYM(rb_intern("tag_name"));
+  case TOKEN_TAG_START:
+    return ID2SYM(rb_intern("tag_start"));
+  case TOKEN_TAG_END:
+    return ID2SYM(rb_intern("tag_end"));
+  case TOKEN_ATTRIBUTE_NAME:
+    return ID2SYM(rb_intern("attribute_name"));
+  case TOKEN_ATTRIBUTE_QUOTED_VALUE_START:
+    return ID2SYM(rb_intern("attribute_quoted_value_start"));
+  case TOKEN_ATTRIBUTE_QUOTED_VALUE:
+    return ID2SYM(rb_intern("attribute_quoted_value"));
+  case TOKEN_ATTRIBUTE_QUOTED_VALUE_END:
+    return ID2SYM(rb_intern("attribute_quoted_value_end"));
+  case TOKEN_ATTRIBUTE_UNQUOTED_VALUE:
+    return ID2SYM(rb_intern("attribute_unquoted_value"));
+  case TOKEN_CDATA_START:
+    return ID2SYM(rb_intern("cdata_start"));
+  case TOKEN_CDATA_END:
+    return ID2SYM(rb_intern("cdata_end"));
+  case TOKEN_SOLIDUS:
+    return ID2SYM(rb_intern("solidus"));
+  case TOKEN_EQUAL:
+    return ID2SYM(rb_intern("equal"));
+  case TOKEN_MALFORMED:
+    return ID2SYM(rb_intern("malformed"));
+  }
+  return Qnil;
+}
+
+static void tokenizer_yield_tag(struct tokenizer_t *tk, enum token_type type, long unsigned int length, void *data)
+{
+  tk->last_token = type;
+  rb_yield_values(3, token_type_to_symbol(type), INT2NUM(tk->scan.cursor), INT2NUM(tk->scan.cursor + length));
+}
+
+static void tokenizer_callback(struct tokenizer_t *tk, enum token_type type, long unsigned int length)
+{
+  if(tk->f_callback)
+    tk->f_callback(tk, type, length, tk->callback_data);
+  tk->scan.cursor += length;
+}
+
+static VALUE tokenizer_initialize_method(VALUE self)
+{
+  struct tokenizer_t *tk = NULL;
+
+  Tokenizer_Get_Struct(self, tk);
+  DBG_PRINT("tk=%p initialize", tk);
+
+  tokenizer_init(tk);
+  tk->f_callback = tokenizer_yield_tag;
+
+  return Qnil;
+}
+
+static inline int eos(struct scan_t *scan)
+{
+  return scan->cursor >= scan->length;
+}
+
+static inline long unsigned int length_remaining(struct scan_t *scan)
+{
+  return scan->length - scan->cursor;
+}
+
+static inline void push_context(struct tokenizer_t *tk, enum tokenizer_context ctx)
+{
+  tk->context[++tk->current_context] = ctx;
+}
+
+static inline void pop_context(struct tokenizer_t *tk)
+{
+  tk->context[tk->current_context--] = TOKENIZER_NONE;
+}
+
+static int is_text(struct scan_t *scan, long unsigned int *length)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(scan->string[i] == '<')
+      break;
+  }
+  return *length != 0;
+}
+
+static inline int is_comment_start(struct scan_t *scan)
+{
+  return (length_remaining(scan) >= 4) &&
+    !strncmp((const char *)&scan->string[scan->cursor], "<!--", 4);
+}
+
+static inline int is_doctype(struct scan_t *scan)
+{
+  return (length_remaining(scan) >= 9) &&
+    !strncasecmp((const char *)&scan->string[scan->cursor], "<!DOCTYPE", 9);
+}
+
+static inline int is_cdata_start(struct scan_t *scan)
+{
+  return (length_remaining(scan) >= 9) &&
+    !strncasecmp((const char *)&scan->string[scan->cursor], "<![CDATA[", 9);
+}
+
+static inline int is_char(struct scan_t *scan, const char c)
+{
+  return (length_remaining(scan) >= 1) && (scan->string[scan->cursor] == c);
+}
+
+static inline int is_alnum(const char c)
+{
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
+}
+
+static int is_tag_start(struct scan_t *scan, long unsigned int *length,
+  int *closing_tag, const char **tag_name, long unsigned int *tag_name_length)
+{
+  long unsigned int i, start;
+
+  if(scan->string[scan->cursor] != '<')
+    return 0;
+
+  *length = 1;
+
+  if(scan->string[scan->cursor+1] == '/') {
+    *closing_tag = 1;
+    (*length)++;
+  } else {
+    *closing_tag = 0;
+  }
+
+  *tag_name = &scan->string[scan->cursor + (*length)];
+  start = *length;
+  for(i = scan->cursor + (*length);i < scan->length; i++, (*length)++) {
+    if(!is_alnum(scan->string[i]) && scan->string[i] != ':')
+      break;
+  }
+
+  *tag_name_length = *length - start;
+  return 1;
+}
+
+static int is_tag_name(struct scan_t *scan, const char **tag_name, unsigned long int *tag_name_length)
+{
+  long unsigned int i;
+
+  *tag_name_length = 0;
+  *tag_name = &scan->string[scan->cursor];
+  for(i = scan->cursor;i < scan->length; i++, (*tag_name_length)++) {
+    if(scan->string[i] == ' ' || scan->string[i] == '\t' ||
+        scan->string[i] == '\r' || scan->string[i] == '\n' ||
+        scan->string[i] == '>' || scan->string[i] == '/')
+      break;
+  }
+
+  return *tag_name_length != 0;
+}
+
+static int is_whitespace(struct scan_t *scan, unsigned long int *length)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(scan->string[i] != ' ' && scan->string[i] != '\t' &&
+        scan->string[i] != '\r' && scan->string[i] != '\n')
+      break;
+  }
+  return *length != 0;
+}
+
+static int is_attribute_name(struct scan_t *scan, unsigned long int *length)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(!is_alnum(scan->string[i]) && scan->string[i] != ':' &&
+        scan->string[i] != '-' && scan->string[i] != '_' &&
+        scan->string[i] != '.')
+      break;
+  }
+  return *length != 0;
+}
+
+static int is_unquoted_value(struct scan_t *scan, unsigned long int *length)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(scan->string[i] == ' ' || scan->string[i] == '\r' ||
+        scan->string[i] == '\n' || scan->string[i] == '\t' ||
+        scan->string[i] == '>')
+      break;
+  }
+  return *length != 0;
+}
+
+static int is_attribute_string(struct scan_t *scan, unsigned long int *length, const char attribute_value_start)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(scan->string[i] == attribute_value_start)
+      break;
+  }
+  return *length != 0;
+}
+
+static int is_comment_end(struct scan_t *scan, unsigned long int *length, const char **end)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(i < (scan->length - 2) && scan->string[i] == '-' && scan->string[i+1] == '-' &&
+        scan->string[i+2] == '>') {
+      *end = &scan->string[i];
+      break;
+    }
+  }
+  return *length != 0;
+}
+
+static int is_cdata_end(struct scan_t *scan, unsigned long int *length, const char **end)
+{
+  long unsigned int i;
+
+  *length = 0;
+  for(i = scan->cursor;i < scan->length; i++, (*length)++) {
+    if(i < (scan->length-2) && scan->string[i] == ']' && scan->string[i+1] == ']' &&
+        scan->string[i+2] == '>') {
+      *end = &scan->string[i];
+      break;
+    }
+  }
+  return *length != 0;
+}
+
+static int scan_html(struct tokenizer_t *tk)
+{
+  long unsigned int length = 0;
+
+  if(is_char(&tk->scan, '<')) {
+    push_context(tk, TOKENIZER_OPEN_TAG);
+    return 1;
+  }
+  else if(is_text(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_TEXT, length);
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_open_tag(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+
+  if(is_comment_start(&tk->scan)) {
+    tokenizer_callback(tk, TOKEN_COMMENT_START, 4);
+    pop_context(tk); // back to html
+    push_context(tk, TOKENIZER_COMMENT);
+    return 1;
+  }
+  else if(is_doctype(&tk->scan)) {
+    tokenizer_callback(tk, TOKEN_TAG_START, 1);
+    tokenizer_callback(tk, TOKEN_TAG_NAME, 8);
+    return 1;
+  }
+  else if(is_cdata_start(&tk->scan)) {
+    tokenizer_callback(tk, TOKEN_CDATA_START, 9);
+    pop_context(tk); // back to html
+    push_context(tk, TOKENIZER_CDATA);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '<')) {
+    tokenizer_callback(tk, TOKEN_TAG_START, 1);
+    push_context(tk, TOKENIZER_SOLIDUS_OR_TAG_NAME);
+    return 1;
+  }
+  else if(is_whitespace(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_WHITESPACE, length);
+    return 1;
+  }
+  else if(is_attribute_name(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_NAME, length);
+    push_context(tk, TOKENIZER_ATTRIBUTE_NAME);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '\'') || is_char(&tk->scan, '"')) {
+    push_context(tk, TOKENIZER_ATTRIBUTE_VALUE);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '=')) {
+    tokenizer_callback(tk, TOKEN_EQUAL, 1);
+    push_context(tk, TOKENIZER_ATTRIBUTE_VALUE);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '/')) {
+    tokenizer_callback(tk, TOKEN_SOLIDUS, 1);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '>')) {
+    tokenizer_callback(tk, TOKEN_TAG_END, 1);
+    pop_context(tk); // pop tag context
+
+    if(tk->current_tag && !tk->is_closing_tag) {
+      if(!strcasecmp("title", tk->current_tag) ||
+          !strcasecmp("textarea", tk->current_tag)) {
+        push_context(tk, TOKENIZER_RCDATA);
+        return 1;
+      }
+      else if(!strcasecmp("style", tk->current_tag) ||
+          !strcasecmp("xmp", tk->current_tag) || !strcasecmp("iframe", tk->current_tag) ||
+          !strcasecmp("noembed", tk->current_tag) || !strcasecmp("noframes", tk->current_tag) ||
+          !strcasecmp("listing", tk->current_tag)) {
+        push_context(tk, TOKENIZER_RAWTEXT);
+        return 1;
+      }
+      else if(!strcasecmp("script", tk->current_tag)) {
+        push_context(tk, TOKENIZER_SCRIPT_DATA);
+        return 1;
+      }
+      else if(!strcasecmp("plaintext", tk->current_tag)) {
+        push_context(tk, TOKENIZER_PLAINTEXT);
+        return 1;
+      }
+    }
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_solidus_or_tag_name(struct tokenizer_t *tk)
+{
+  if(tk->current_tag)
+    tk->current_tag[0] = '\0';
+
+  if(is_char(&tk->scan, '/')) {
+    tk->is_closing_tag = 1;
+    tokenizer_callback(tk, TOKEN_SOLIDUS, 1);
+  }
+  else {
+    tk->is_closing_tag = 0;
+  }
+
+  pop_context(tk);
+  push_context(tk, TOKENIZER_TAG_NAME);
+  return 1;
+}
+
+static int scan_tag_name(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0, tag_name_length = 0;
+  const char *tag_name = NULL;
+  void *old;
+
+  if(is_tag_name(&tk->scan, &tag_name, &tag_name_length)) {
+    length = (tk->current_tag ? strlen(tk->current_tag) : 0);
+    old = tk->current_tag;
+    REALLOC_N(tk->current_tag, char, length + tag_name_length + 1);
+    DBG_PRINT("tk=%p realloc(tk->current_tag) %p -> %p length=%lu", tk, old,
+      tk->current_tag,  length + tag_name_length + 1);
+    tk->current_tag[length] = 0;
+
+    strncat(tk->current_tag, tag_name, tag_name_length);
+
+    tokenizer_callback(tk, TOKEN_TAG_NAME, tag_name_length);
+    return 1;
+  }
+
+  pop_context(tk); // back to open_tag
+  return 1;
+}
+
+static int scan_attribute_name(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+
+  if(is_attribute_name(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_NAME, length);
+    return 1;
+  }
+
+  pop_context(tk); // back to open tag
+  return 1;
+}
+
+static int scan_attribute_value(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+
+  if(is_whitespace(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_WHITESPACE, length);
+    return 1;
+  }
+  else if(is_char(&tk->scan, '\'') || is_char(&tk->scan, '"')) {
+    tk->attribute_value_start = tk->scan.string[tk->scan.cursor];
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_QUOTED_VALUE_START, 1);
+    pop_context(tk); // back to open tag
+    push_context(tk, TOKENIZER_ATTRIBUTE_QUOTED);
+    return 1;
+  }
+
+  pop_context(tk); // back to open tag
+  push_context(tk, TOKENIZER_ATTRIBUTE_UNQUOTED);
+  return 1;
+}
+
+static int scan_attribute_unquoted(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+
+  if(is_unquoted_value(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_UNQUOTED_VALUE, length);
+    return 1;
+  }
+
+  pop_context(tk); // back to open tag
+  return 1;
+}
+
+static int scan_attribute_quoted(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+
+  if(is_char(&tk->scan, tk->attribute_value_start)) {
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_QUOTED_VALUE_END, 1);
+    pop_context(tk); // back to open tag
+    return 1;
+  }
+  else if(is_attribute_string(&tk->scan, &length, tk->attribute_value_start)) {
+    tokenizer_callback(tk, TOKEN_ATTRIBUTE_QUOTED_VALUE, length);
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_comment(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+  const char *comment_end = NULL;
+
+  if(is_comment_end(&tk->scan, &length, &comment_end)) {
+    tokenizer_callback(tk, TOKEN_TEXT, length);
+    if(comment_end) {
+      tokenizer_callback(tk, TOKEN_COMMENT_END, 3);
+      pop_context(tk); // back to document
+    }
+    return 1;
+  }
+  else {
+    tokenizer_callback(tk, TOKEN_TEXT, length_remaining(&tk->scan));
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_cdata(struct tokenizer_t *tk)
+{
+  unsigned long int length = 0;
+  const char *cdata_end = NULL;
+
+  if(is_cdata_end(&tk->scan, &length, &cdata_end)) {
+    tokenizer_callback(tk, TOKEN_TEXT, length);
+    if(cdata_end)
+      tokenizer_callback(tk, TOKEN_CDATA_END, 3);
+    return 1;
+  }
+  else {
+    tokenizer_callback(tk, TOKEN_TEXT, length_remaining(&tk->scan));
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_rawtext(struct tokenizer_t *tk)
+{
+  long unsigned int length = 0, tag_name_length = 0;
+  const char *tag_name = NULL;
+  int closing_tag = 0;
+
+  if(is_tag_start(&tk->scan, &length, &closing_tag, &tag_name, &tag_name_length)) {
+    if(closing_tag && tk->current_tag && !strncasecmp((const char *)tag_name, tk->current_tag, tag_name_length)) {
+      pop_context(tk);
+    } else {
+      tokenizer_callback(tk, TOKEN_TEXT, length);
+    }
+    return 1;
+  }
+  else if(is_text(&tk->scan, &length)) {
+    tokenizer_callback(tk, TOKEN_TEXT, length);
+    return 1;
+  }
+  else {
+    tokenizer_callback(tk, TOKEN_TEXT, length_remaining(&tk->scan));
+    return 1;
+  }
+  return 0;
+}
+
+static int scan_plaintext(struct tokenizer_t *tk)
+{
+  tokenizer_callback(tk, TOKEN_TEXT, length_remaining(&tk->scan));
+  return 1;
+}
+
+static int scan_once(struct tokenizer_t *tk)
+{
+  switch(tk->context[tk->current_context]) {
+  case TOKENIZER_NONE:
+    break;
+  case TOKENIZER_HTML:
+    return scan_html(tk);
+  case TOKENIZER_OPEN_TAG:
+    return scan_open_tag(tk);
+  case TOKENIZER_SOLIDUS_OR_TAG_NAME:
+    return scan_solidus_or_tag_name(tk);
+  case TOKENIZER_TAG_NAME:
+    return scan_tag_name(tk);
+  case TOKENIZER_COMMENT:
+    return scan_comment(tk);
+  case TOKENIZER_CDATA:
+    return scan_cdata(tk);
+  case TOKENIZER_RCDATA:
+  case TOKENIZER_RAWTEXT:
+  case TOKENIZER_SCRIPT_DATA:
+    /* we don't consume character references so all
+      of these states are effectively the same */
+    return scan_rawtext(tk);
+  case TOKENIZER_PLAINTEXT:
+    return scan_plaintext(tk);
+  case TOKENIZER_ATTRIBUTE_NAME:
+    return scan_attribute_name(tk);
+  case TOKENIZER_ATTRIBUTE_VALUE:
+    return scan_attribute_value(tk);
+  case TOKENIZER_ATTRIBUTE_UNQUOTED:
+    return scan_attribute_unquoted(tk);
+  case TOKENIZER_ATTRIBUTE_QUOTED:
+    return scan_attribute_quoted(tk);
+  }
+  return 0;
+}
+
+void tokenizer_scan_all(struct tokenizer_t *tk)
+{
+  while(!eos(&tk->scan) && scan_once(tk)) {}
+  if(!eos(&tk->scan)) {
+    tokenizer_callback(tk, TOKEN_MALFORMED, length_remaining(&tk->scan));
+  }
+  return;
+}
+
+static VALUE tokenizer_tokenize_method(VALUE self, VALUE source)
+{
+  struct tokenizer_t *tk = NULL;
+  char *c_source;
+  char *old;
+
+  if(NIL_P(source))
+    return Qnil;
+
+  Check_Type(source, T_STRING);
+  Tokenizer_Get_Struct(self, tk);
+
+  c_source = StringValueCStr(source);
+  tk->scan.cursor = 0;
+  tk->scan.length = strlen(c_source);
+
+  old = tk->scan.string;
+  REALLOC_N(tk->scan.string, char, tk->scan.length+1);
+  DBG_PRINT("tk=%p realloc(tk->scan.string) %p -> %p length=%lu", tk, old,
+    tk->scan.string,  tk->scan.length+1);
+  strncpy(tk->scan.string, c_source, tk->scan.length);
+
+  tokenizer_scan_all(tk);
+
+  DBG_PRINT("tk=%p xfree(tk->scan.string) 0x%p", tk, tk->scan.string);
+  xfree(tk->scan.string);
+  tk->scan.string = NULL;
+
+  return Qtrue;
+}
+
+void Init_html_tokenizer_tokenizer(VALUE mHtmlTokenizer)
+{
+  cTokenizer = rb_define_class_under(mHtmlTokenizer, "Tokenizer", rb_cObject);
+  rb_define_alloc_func(cTokenizer, tokenizer_allocate);
+  rb_define_method(cTokenizer, "initialize", tokenizer_initialize_method, 0);
+  rb_define_method(cTokenizer, "tokenize", tokenizer_tokenize_method, 1);
+}