public/browser
1
0
Fork 0
mirror of https://github.com/lightpanda-io/browser.git synced 2026-02-04 06:23:45 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

initial XML parsing support in DOMParser

Browse Source
This commit is contained in:
Halil Durak
2026-01-05 17:48:30 +03:00
parent 21d502b81f
commit 56d89895a8
6 changed files with 177 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/browser/parser/Parser.zig
View File

@@ -98,6 +98,29 @@ pub fn parse(self: *Parser, html: []const u8) void {
); );
} }
pub fn parseXML(self: *Parser, xml: []const u8) void {
h5e.xml5ever_parse_document(
xml.ptr,
xml.len,
&self.container,
self,
createElementCallback,
getDataCallback,
appendCallback,
parseErrorCallback,
popCallback,
createCommentCallback,
createProcessingInstruction,
appendDoctypeToDocument,
addAttrsIfMissingCallback,
getTemplateContentsCallback,
removeFromParentCallback,
reparentChildrenCallback,
appendBeforeSiblingCallback,
appendBasedOnParentNodeCallback,
);
}
pub fn parseFragment(self: *Parser, html: []const u8) void { pub fn parseFragment(self: *Parser, html: []const u8) void {
h5e.html5ever_parse_fragment( h5e.html5ever_parse_fragment(
html.ptr, html.ptr,

21
src/browser/parser/html5ever.zig
View File

@@ -171,3 +171,24 @@ pub const NodeOrText = extern struct {
text: []const u8, text: []const u8,
}; };
}; };
pub extern "c" fn xml5ever_parse_document(
html: [*c]const u8,
len: usize,
doc: *anyopaque,
ctx: *anyopaque,
createElementCallback: *const fn (ctx: *anyopaque, data: *anyopaque, QualName, AttributeIterator) callconv(.c) ?*anyopaque,
elemNameCallback: *const fn (node_ref: *anyopaque) callconv(.c) *anyopaque,
appendCallback: *const fn (ctx: *anyopaque, parent_ref: *anyopaque, NodeOrText) callconv(.c) void,
parseErrorCallback: *const fn (ctx: *anyopaque, StringSlice) callconv(.c) void,
popCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque) callconv(.c) void,
createCommentCallback: *const fn (ctx: *anyopaque, StringSlice) callconv(.c) ?*anyopaque,
createProcessingInstruction: *const fn (ctx: *anyopaque, StringSlice, StringSlice) callconv(.c) ?*anyopaque,
appendDoctypeToDocument: *const fn (ctx: *anyopaque, StringSlice, StringSlice, StringSlice) callconv(.c) void,
addAttrsIfMissingCallback: *const fn (ctx: *anyopaque, target_ref: *anyopaque, AttributeIterator) callconv(.c) void,
getTemplateContentsCallback: *const fn (ctx: *anyopaque, target_ref: *anyopaque) callconv(.c) ?*anyopaque,
removeFromParentCallback: *const fn (ctx: *anyopaque, target_ref: *anyopaque) callconv(.c) void,
reparentChildrenCallback: *const fn (ctx: *anyopaque, node_ref: *anyopaque, new_parent_ref: *anyopaque) callconv(.c) void,
appendBeforeSiblingCallback: *const fn (ctx: *anyopaque, sibling_ref: *anyopaque, NodeOrText) callconv(.c) void,
appendBasedOnParentNodeCallback: *const fn (ctx: *anyopaque, element_ref: *anyopaque, prev_element_ref: *anyopaque, NodeOrText) callconv(.c) void,
) void;

70
src/browser/webapi/DOMParser.zig
View File

@@ -21,6 +21,7 @@ const std = @import("std");
const js = @import("../js/js.zig"); const js = @import("../js/js.zig");
const Page = @import("../Page.zig"); const Page = @import("../Page.zig");
const HTMLDocument = @import("HTMLDocument.zig"); const HTMLDocument = @import("HTMLDocument.zig");
const XMLDocument = @import("XMLDocument.zig");
const DOMParser = @This(); const DOMParser = @This();
@@ -28,34 +29,59 @@ pub fn init() DOMParser {
return .{}; return .{};
} }
pub fn parseFromString(self: *const DOMParser, html: []const u8, mime_type: []const u8, page: *Page) !*HTMLDocument { pub const HTMLDocumentOrXMLDocument = union(enum) {
_ = self; html_document: *HTMLDocument,
xml_document: *XMLDocument,
};
// For now, only support text/html pub fn parseFromString(
if (!std.mem.eql(u8, mime_type, "text/html")) { _: *const DOMParser,
return error.NotSupported; html: []const u8,
mime_type: []const u8,
page: *Page,
) !HTMLDocumentOrXMLDocument {
if (std.mem.eql(u8, mime_type, "text/html")) {
// Create a new HTMLDocument
const doc = try page._factory.document(HTMLDocument{
._proto = undefined,
});
var normalized = std.mem.trim(u8, html, &std.ascii.whitespace);
if (normalized.len == 0) {
normalized = "<html></html>";
}
// Parse HTML into the document
const Parser = @import("../parser/Parser.zig");
var parser = Parser.init(page.arena, doc.asNode(), page);
parser.parse(normalized);
if (parser.err) |pe| {
return pe.err;
}
return .{ .html_document = doc };
} }
// Create a new HTMLDocument if (std.mem.eql(u8, mime_type, "text/xml")) {
const doc = try page._factory.document(HTMLDocument{ // Create a new XMLDocument.
._proto = undefined, const doc = try page._factory.document(XMLDocument{
}); ._proto = undefined,
});
var normalized = std.mem.trim(u8, html, &std.ascii.whitespace); // Parse XML into XMLDocument.
if (normalized.len == 0) { const Parser = @import("../parser/Parser.zig");
normalized = "<html></html>"; var parser = Parser.init(page.arena, doc.asNode(), page);
parser.parseXML(html);
if (parser.err) |pe| {
return pe.err;
}
return .{ .xml_document = doc };
} }
// Parse HTML into the document return error.NotSupported;
const Parser = @import("../parser/Parser.zig");
var parser = Parser.init(page.arena, doc.asNode(), page);
parser.parse(normalized);
if (parser.err) |pe| {
return pe.err;
}
return doc;
} }
pub const JsApi = struct { pub const JsApi = struct {

11
src/html5ever/Cargo.lock generated
View File

@@ -72,6 +72,7 @@ dependencies = [
"tikv-jemalloc-ctl", "tikv-jemalloc-ctl",
"tikv-jemallocator", "tikv-jemallocator",
"typed-arena", "typed-arena",
"xml5ever",
] ]
[[package]] [[package]]
@@ -476,3 +477,13 @@ name = "windows_x86_64_msvc"
version = "0.52.6" version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "xml5ever"
version = "0.35.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee3f1e41afb31a75aef076563b0ad3ecc24f5bd9d12a72b132222664eb76b494"
dependencies = [
"log",
"markup5ever",
]

1
src/html5ever/Cargo.toml
View File

@@ -14,6 +14,7 @@ string_cache = "0.9.0"
typed-arena = "2.0.2" typed-arena = "2.0.2"
tikv-jemallocator = {version = "0.6.0", features = ["stats"]} tikv-jemallocator = {version = "0.6.0", features = ["stats"]}
tikv-jemalloc-ctl = {version = "0.6.0", features = ["stats"]} tikv-jemalloc-ctl = {version = "0.6.0", features = ["stats"]}
xml5ever = "0.35.0"
[profile.release] [profile.release]
lto = true lto = true

90
src/html5ever/lib.rs
View File

@@ -16,20 +16,20 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
mod types;
mod sink; mod sink;
mod types;
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
#[global_allocator] #[global_allocator]
static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc; static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
use types::*;
use std::cell::Cell; use std::cell::Cell;
use std::os::raw::{c_uchar, c_void}; use std::os::raw::{c_uchar, c_void};
use types::*;
use html5ever::{parse_document, parse_fragment, QualName, LocalName, ns, ParseOpts, Parser};
use html5ever::tendril::{TendrilSink, StrTendril};
use html5ever::interface::tree_builder::QuirksMode; use html5ever::interface::tree_builder::QuirksMode;
use html5ever::tendril::{StrTendril, TendrilSink};
use html5ever::{ns, parse_document, parse_fragment, LocalName, ParseOpts, Parser, QualName};
#[no_mangle] #[no_mangle]
pub extern "C" fn html5ever_parse_document( pub extern "C" fn html5ever_parse_document(
@@ -135,13 +135,14 @@ pub extern "C" fn html5ever_parse_fragment(
let bytes = unsafe { std::slice::from_raw_parts(html, len) }; let bytes = unsafe { std::slice::from_raw_parts(html, len) };
parse_fragment( parse_fragment(
sink, Default::default(), sink,
Default::default(),
QualName::new(None, ns!(html), LocalName::from("body")), QualName::new(None, ns!(html), LocalName::from("body")),
vec![], // attributes vec![], // attributes
false, // context_element_allows_scripting false, // context_element_allows_scripting
) )
.from_utf8() .from_utf8()
.one(bytes); .one(bytes);
} }
#[no_mangle] #[no_mangle]
@@ -182,15 +183,15 @@ pub struct Memory {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
#[no_mangle] #[no_mangle]
pub extern "C" fn html5ever_get_memory_usage() -> Memory { pub extern "C" fn html5ever_get_memory_usage() -> Memory {
use tikv_jemalloc_ctl::{stats, epoch}; use tikv_jemalloc_ctl::{epoch, stats};
// many statistics are cached and only updated when the epoch is advanced. // many statistics are cached and only updated when the epoch is advanced.
epoch::advance().unwrap(); epoch::advance().unwrap();
return Memory{ return Memory {
resident: stats::resident::read().unwrap(), resident: stats::resident::read().unwrap(),
allocated: stats::allocated::read().unwrap(), allocated: stats::allocated::read().unwrap(),
} };
} }
// Streaming parser API // Streaming parser API
@@ -225,9 +226,8 @@ pub extern "C" fn html5ever_streaming_parser_create(
// SAFETY: We're creating a self-referential structure here. // SAFETY: We're creating a self-referential structure here.
// The arena is stored in the StreamingParser and lives as long as the parser. // The arena is stored in the StreamingParser and lives as long as the parser.
// The sink contains a reference to the arena that's valid for the parser's lifetime. // The sink contains a reference to the arena that's valid for the parser's lifetime.
let arena_ref: &'static typed_arena::Arena<sink::ElementData> = unsafe { let arena_ref: &'static typed_arena::Arena<sink::ElementData> =
std::mem::transmute(arena.as_ref()) unsafe { std::mem::transmute(arena.as_ref()) };
};
let sink = sink::Sink { let sink = sink::Sink {
ctx: ctx, ctx: ctx,
@@ -281,7 +281,8 @@ pub extern "C" fn html5ever_streaming_parser_feed(
// Feed the chunk to the parser // Feed the chunk to the parser
// The Parser implements TendrilSink, so we can call process() on it // The Parser implements TendrilSink, so we can call process() on it
let parser = streaming_parser.parser let parser = streaming_parser
.parser
.downcast_mut::<Parser<sink::Sink>>() .downcast_mut::<Parser<sink::Sink>>()
.expect("Invalid parser type"); .expect("Invalid parser type");
@@ -304,7 +305,8 @@ pub extern "C" fn html5ever_streaming_parser_finish(parser_ptr: *mut c_void) {
let streaming_parser = unsafe { Box::from_raw(parser_ptr as *mut StreamingParser) }; let streaming_parser = unsafe { Box::from_raw(parser_ptr as *mut StreamingParser) };
// Extract and finish the parser // Extract and finish the parser
let parser = streaming_parser.parser let parser = streaming_parser
.parser
.downcast::<Parser<sink::Sink>>() .downcast::<Parser<sink::Sink>>()
.expect("Invalid parser type"); .expect("Invalid parser type");
@@ -326,3 +328,57 @@ pub extern "C" fn html5ever_streaming_parser_destroy(parser_ptr: *mut c_void) {
let _ = Box::from_raw(parser_ptr as *mut StreamingParser); let _ = Box::from_raw(parser_ptr as *mut StreamingParser);
} }
} }
#[no_mangle]
pub extern "C" fn xml5ever_parse_document(
xml: *mut c_uchar,
len: usize,
document: Ref,
ctx: Ref,
create_element_callback: CreateElementCallback,
get_data_callback: GetDataCallback,
append_callback: AppendCallback,
parse_error_callback: ParseErrorCallback,
pop_callback: PopCallback,
create_comment_callback: CreateCommentCallback,
create_processing_instruction: CreateProcessingInstruction,
append_doctype_to_document: AppendDoctypeToDocumentCallback,
add_attrs_if_missing_callback: AddAttrsIfMissingCallback,
get_template_contents_callback: GetTemplateContentsCallback,
remove_from_parent_callback: RemoveFromParentCallback,
reparent_children_callback: ReparentChildrenCallback,
append_before_sibling_callback: AppendBeforeSiblingCallback,
append_based_on_parent_node_callback: AppendBasedOnParentNodeCallback,
) -> () {
if xml.is_null() || len == 0 {
return ();
}
let arena = typed_arena::Arena::new();
let sink = sink::Sink {
ctx: ctx,
arena: &arena,
document: document,
quirks_mode: Cell::new(QuirksMode::NoQuirks),
pop_callback: pop_callback,
append_callback: append_callback,
get_data_callback: get_data_callback,
parse_error_callback: parse_error_callback,
create_element_callback: create_element_callback,
create_comment_callback: create_comment_callback,
create_processing_instruction: create_processing_instruction,
append_doctype_to_document: append_doctype_to_document,
add_attrs_if_missing_callback: add_attrs_if_missing_callback,
get_template_contents_callback: get_template_contents_callback,
remove_from_parent_callback: remove_from_parent_callback,
reparent_children_callback: reparent_children_callback,
append_before_sibling_callback: append_before_sibling_callback,
append_based_on_parent_node_callback: append_based_on_parent_node_callback,
};
let bytes = unsafe { std::slice::from_raw_parts(xml, len) };
xml5ever::driver::parse_document(sink, xml5ever::driver::XmlParseOpts::default())
.from_utf8()
.one(bytes);
}