Implement a C API for the tokenizer

kmcallister · kmcallister · commit cb98c0cb7008 · 2014-08-27T19:10:47.000-07:00
diff --git a/Makefile.in b/Makefile.in
@@ -38,6 +38,12 @@ $(LIB): $(CARGO_SOURCES)
 	(cd $(VPATH) && cargo build)
 	touch $(LIB)
 
+.PHONY: for_c
+for_c: libhtml5ever_for_c.a
+
+libhtml5ever_for_c.a: $(LIB) $(CARGO_SOURCES)
+	$(RUSTC_CMD) -o $@ --cfg for_c --crate-type staticlib $(VPATH)/src/lib.rs
+
 define DEF_EXAMPLE
 $(1): $$(VPATH)/examples/$(1).rs $$(LIB)
 	$$(RUSTC_CMD) $$<
diff --git a/capi/html5ever.h b/capi/html5ever.h
@@ -0,0 +1,48 @@
+// Copyright 2014 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#ifndef __HTML5EVER_H
+#define __HTML5EVER_H
+
+#include <stdlib.h>
+
+struct h5e_buf {
+    unsigned char *data;
+    size_t len;
+};
+
+struct h5e_buf h5e_buf_from_cstr(const char *str);
+
+struct h5e_token_ops {
+    void (*do_doctype)(void *user, struct h5e_buf name,
+        struct h5e_buf pub, struct h5e_buf sys, int force_quirks);
+    void (*do_start_tag)(void *user, struct h5e_buf name,
+        int self_closing, size_t num_attrs);
+    void (*do_tag_attr)(void *user, struct h5e_buf name, struct h5e_buf value);
+    void (*do_end_tag)(void *user, struct h5e_buf name);
+    void (*do_comment)(void *user, struct h5e_buf text);
+    void (*do_chars)(void *user, struct h5e_buf text);
+    void (*do_null_char)(void *user);
+    void (*do_eof)(void *user);
+    void (*do_error)(void *user, struct h5e_buf message);
+};
+
+struct h5e_token_sink {
+    struct h5e_token_ops *ops;
+    void *user;
+};
+
+struct h5e_tokenizer;
+
+struct h5e_tokenizer *h5e_tokenizer_new(struct h5e_token_sink *sink);
+void h5e_tokenizer_free(struct h5e_tokenizer *tok);
+void h5e_tokenizer_feed(struct h5e_tokenizer *tok, struct h5e_buf buf);
+void h5e_tokenizer_end(struct h5e_tokenizer *tok);
+
+#endif
diff --git a/examples/capi/tokenize.c b/examples/capi/tokenize.c
@@ -0,0 +1,74 @@
+// Copyright 2014 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#include <stdio.h>
+
+#include "html5ever.h"
+
+void put_str(const char *x) {
+    fputs(x, stdout);
+}
+
+void put_buf(struct h5e_buf text) {
+    fwrite(text.data, text.len, 1, stdout);
+}
+
+void do_chars(void *user, struct h5e_buf text) {
+    put_str("CHARS : ");
+    put_buf(text);
+    put_str("\n");
+}
+
+void do_start_tag(void *user, struct h5e_buf name, int self_closing, size_t num_attrs) {
+    put_str("TAG   : <");
+    put_buf(name);
+    if (self_closing) {
+        putchar('/');
+    }
+    put_str(">\n");
+}
+
+void do_tag_attr(void *user, struct h5e_buf name, struct h5e_buf value) {
+    put_str("  ATTR: ");
+    put_buf(name);
+    put_str("=\"");
+    put_buf(value);
+    put_str("\"\n");
+}
+
+void do_end_tag(void *user, struct h5e_buf name) {
+    put_str("TAG   : </");
+    put_buf(name);
+    put_str(">\n");
+}
+
+struct h5e_token_ops ops = {
+    .do_chars = do_chars,
+    .do_start_tag = do_start_tag,
+    .do_tag_attr = do_tag_attr,
+    .do_end_tag = do_end_tag,
+};
+
+struct h5e_token_sink sink = {
+    .ops = &ops,
+    .user = NULL,
+};
+
+int main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("Usage: %s 'HTML fragment'\n", argv[0]);
+        return 1;
+    }
+
+    struct h5e_tokenizer *tok = h5e_tokenizer_new(&sink);
+    h5e_tokenizer_feed(tok, h5e_buf_from_cstr(argv[1]));
+    h5e_tokenizer_end(tok);
+    h5e_tokenizer_free(tok);
+    return 0;
+}
diff --git a/src/for_c/common.rs b/src/for_c/common.rs
@@ -0,0 +1,81 @@
+// Copyright 2014 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::prelude::*;
+
+use core::slice::raw::buf_as_slice;
+use core::str::raw::from_utf8;
+use core::kinds::marker::ContravariantLifetime;
+
+use libc::{size_t, c_int, c_char, strlen};
+
+#[repr(C)]
+pub struct h5e_buf {
+    data: *const u8,
+    len: size_t,
+}
+
+impl h5e_buf {
+    pub fn null() -> h5e_buf {
+        h5e_buf {
+            data: RawPtr::null(),
+            len: 0,
+        }
+    }
+
+    pub unsafe fn with_slice<R>(&self, f: |&str| -> R) -> R {
+        buf_as_slice(self.data, self.len as uint,
+            |bytes| f(from_utf8(bytes)))
+    }
+}
+
+pub struct LifetimeBuf<'a> {
+    buf: h5e_buf,
+    marker: ContravariantLifetime<'a>,
+}
+
+impl<'a> LifetimeBuf<'a> {
+    pub fn from_str<T: Str>(x: &'a T) -> LifetimeBuf<'a> {
+        let x = x.as_slice();
+        LifetimeBuf {
+            buf: h5e_buf {
+                data: x.as_bytes().as_ptr(),
+                len: x.len() as size_t,
+            },
+            marker: ContravariantLifetime,
+        }
+    }
+
+    pub fn null() -> LifetimeBuf<'a> {
+        LifetimeBuf {
+            buf: h5e_buf::null(),
+            marker: ContravariantLifetime,
+        }
+    }
+
+    #[inline]
+    pub fn get(self) -> h5e_buf {
+        self.buf
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn h5e_buf_from_cstr(s: *const c_char) -> h5e_buf {
+    h5e_buf {
+        data: s as *const u8,
+        len: strlen(s),
+    }
+}
+
+pub fn c_bool(x: bool) -> c_int {
+    match x {
+        false => 0,
+        true => 1,
+    }
+}
diff --git a/src/for_c/tokenizer.rs b/src/for_c/tokenizer.rs
@@ -0,0 +1,139 @@
+// Copyright 2014 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(non_camel_case_types)]
+
+use core::prelude::*;
+
+use for_c::common::{LifetimeBuf, h5e_buf, c_bool};
+
+use tokenizer::{TokenSink, Token, Doctype, Tag, ParseError, DoctypeToken};
+use tokenizer::{CommentToken, CharacterTokens, NullCharacterToken};
+use tokenizer::{TagToken, StartTag, EndTag, EOFToken, Tokenizer};
+
+use core::mem;
+use core::default::Default;
+use alloc::boxed::Box;
+use collections::String;
+use libc::{c_void, c_int, size_t};
+
+#[repr(C)]
+pub struct h5e_token_ops {
+    do_doctype: extern "C" fn(user: *mut c_void, name: h5e_buf,
+        public: h5e_buf, system: h5e_buf, force_quirks: c_int),
+
+    do_start_tag: extern "C" fn(user: *mut c_void, name: h5e_buf,
+        self_closing: c_int, num_attrs: size_t),
+
+    do_tag_attr:      extern "C" fn(user: *mut c_void, name: h5e_buf, value: h5e_buf),
+    do_end_tag:       extern "C" fn(user: *mut c_void, name: h5e_buf),
+    do_comment:       extern "C" fn(user: *mut c_void, text: h5e_buf),
+    do_chars:         extern "C" fn(user: *mut c_void, text: h5e_buf),
+    do_null_char:     extern "C" fn(user: *mut c_void),
+    do_eof:           extern "C" fn(user: *mut c_void),
+    do_error:         extern "C" fn(user: *mut c_void, message: h5e_buf),
+}
+
+#[repr(C)]
+pub struct h5e_token_sink {
+    ops: *const h5e_token_ops,
+    user: *mut c_void,
+}
+
+impl TokenSink for h5e_token_sink {
+    fn process_token(&mut self, token: Token) {
+        macro_rules! call ( ($name:ident $(, $arg:expr)*) => (
+            unsafe {
+                if !((*self.ops).$name as *const ()).is_null() {
+                    ((*(self.ops)).$name)(self.user $(, $arg)*);
+                }
+            }
+        ))
+
+        fn opt_str_to_buf<'a>(s: &'a Option<String>) -> LifetimeBuf<'a> {
+            match *s {
+                None => LifetimeBuf::null(),
+                Some(ref s) => LifetimeBuf::from_str(s),
+            }
+        }
+
+        match token {
+            DoctypeToken(Doctype { name, public_id, system_id, force_quirks }) => {
+                let name = opt_str_to_buf(&name);
+                let public_id = opt_str_to_buf(&public_id);
+                let system_id = opt_str_to_buf(&system_id);
+                call!(do_doctype, name.get(), public_id.get(), system_id.get(),
+                    c_bool(force_quirks));
+            }
+
+            TagToken(Tag { kind, name, self_closing, attrs }) => {
+                let name = LifetimeBuf::from_str(&name);
+                match kind {
+                    StartTag => {
+                        call!(do_start_tag, name.get(), c_bool(self_closing),
+                            attrs.len() as size_t);
+                        for attr in attrs.move_iter() {
+                            let name = LifetimeBuf::from_str(&attr.name);
+                            let value = LifetimeBuf::from_str(&attr.value);
+                            call!(do_tag_attr, name.get(), value.get());
+                        }
+                    }
+                    EndTag => call!(do_end_tag, name.get()),
+                }
+            }
+
+            CommentToken(text) => {
+                let text = LifetimeBuf::from_str(&text);
+                call!(do_comment, text.get());
+            }
+
+            CharacterTokens(text) => {
+                let text = LifetimeBuf::from_str(&text);
+                call!(do_chars, text.get());
+            }
+
+            NullCharacterToken => call!(do_null_char),
+
+            EOFToken => call!(do_eof),
+
+            ParseError(msg) => {
+                let msg = LifetimeBuf::from_str(&msg);
+                call!(do_error, msg.get());
+            }
+        }
+    }
+}
+
+pub type h5e_tokenizer_ptr = *const ();
+
+#[no_mangle]
+pub unsafe extern "C" fn h5e_tokenizer_new(sink: *mut h5e_token_sink) -> h5e_tokenizer_ptr {
+    let tok: Box<Tokenizer<h5e_token_sink>>
+        = box Tokenizer::new(mem::transmute::<_, &mut h5e_token_sink>(sink),
+            Default::default());
+
+    mem::transmute(tok)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn h5e_tokenizer_free(tok: h5e_tokenizer_ptr) {
+    let _: Box<Tokenizer<h5e_token_sink>> = mem::transmute(tok);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn h5e_tokenizer_feed(tok: h5e_tokenizer_ptr, buf: h5e_buf) {
+    let tok: &mut Tokenizer<h5e_token_sink> = mem::transmute(tok);
+    tok.feed(buf.with_slice(|s| String::from_str(s)));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn h5e_tokenizer_end(tok: h5e_tokenizer_ptr) {
+    let tok: &mut Tokenizer<h5e_token_sink> = mem::transmute(tok);
+    tok.end();
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -26,6 +26,9 @@ extern crate core;
 #[phase(plugin, link)]
 extern crate std;
 
+#[cfg(for_c)]
+extern crate libc;
+
 #[phase(plugin, link)]
 extern crate collections;
 
@@ -84,6 +87,12 @@ pub mod sink {
 
 pub mod driver;
 
+#[cfg(for_c)]
+pub mod for_c {
+    pub mod common;
+    pub mod tokenizer;
+}
+
 /// A fake `std` module so that `deriving` and other macros will work.
 /// See rust-lang/rust#16803.
 #[cfg(for_c)]
