public/browser
1
0
Fork 0
mirror of https://github.com/lightpanda-io/browser.git synced 2025-12-15 07:48:58 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Merge pull request #145 from lightpanda-io/libdom-rewrite-wrapper

Browse Source 
netsurf: rewrite wrapper.c in pure Zig
This commit is contained in:
Francis Bouvier
2024-01-08 16:32:51 +01:00
committed by GitHub
parent 18901ea72b 1c55269342
commit e40d80a370
8 changed files with 103 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
build.zig
View File

@@ -151,13 +151,4 @@ fn linkNetSurf(step: *std.build.LibExeObjStep) void {
step.addIncludePath(.{ .path = ns ++ lib ++ "/src" });
}
step.addIncludePath(.{ .path = ns ++ "/include" });
// wrapper
const flags = [_][]const u8{};
const files: [1][]const u8 = .{ns ++ "wrapper/wrapper.c"};
step.addCSourceFiles(.{
.files = &files,
.flags = &flags,
});
step.addIncludePath(.{ .path = ns ++ "wrapper" });
}

5
src/main.zig
View File

@@ -61,7 +61,10 @@ pub fn main() !void {
defer arena.deinit();
// document
doc = try parser.documentHTMLParseFromFileAlloc(arena.allocator(), "test.html");
const file = try std.fs.cwd().openFile("test.html", .{});
defer file.close();
doc = try parser.documentHTMLParseFromFile(file);
defer parser.documentHTMLClose(doc) catch |err| {
std.debug.print("documentHTMLClose error: {s}\n", .{@errorName(err)});
};

5
src/main_shell.zig
View File

@@ -42,7 +42,10 @@ pub fn main() !void {
defer arena.deinit();
// document
doc = try parser.documentHTMLParseFromFileAlloc(arena.allocator(), "test.html");
const file = try std.fs.cwd().openFile("test.html", .{});
defer file.close();
doc = try parser.documentHTMLParseFromFile(file);
defer parser.documentHTMLClose(doc) catch |err| {
std.debug.print("documentHTMLClose error: {s}\n", .{@errorName(err)});
};

115
src/netsurf.zig
View File

@@ -1,7 +1,8 @@
const std = @import("std");
const c = @cImport({
@cInclude("wrapper.h");
@cInclude("dom/dom.h");
@cInclude("dom/bindings/hubbub/parser.h");
});
// Vtable
@@ -1280,42 +1281,100 @@ fn documentHTMLVtable(doc_html: *DocumentHTML) c.dom_html_document_vtable {
return getVtable(c.dom_html_document_vtable, DocumentHTML, doc_html);
}
// documentHTMLParseFromFileAlloc parses the file.
// The allocator is required to create a null terminated string from filename.
// The buffer is freed by the function.
// The caller is responsible for closing the document.
pub fn documentHTMLParseFromFileAlloc(allocator: std.mem.Allocator, filename: []const u8) !*DocumentHTML {
const cstr = try allocator.dupeZ(u8, filename);
defer allocator.free(cstr);
const ParserError = error{
Reprocess,
EncodingChange,
Paused,
NoMemory,
BadParameter,
BadEncoding,
Invalid,
FileNotFound,
NeedData,
Unknown,
};
return documentHTMLParseFromFile(cstr);
const HubbubErr = c.hubbub_error;
fn parserErr(err: HubbubErr) ParserError!void {
return switch (err) {
c.HUBBUB_OK => {},
c.HUBBUB_REPROCESS => ParserError.Reprocess,
c.HUBBUB_ENCODINGCHANGE => ParserError.EncodingChange,
c.HUBBUB_PAUSED => ParserError.Paused,
c.HUBBUB_NOMEM => ParserError.NoMemory,
c.HUBBUB_BADPARM => ParserError.BadParameter,
c.HUBBUB_BADENCODING => ParserError.BadEncoding,
c.HUBBUB_INVALID => ParserError.Invalid,
c.HUBBUB_FILENOTFOUND => ParserError.FileNotFound,
c.HUBBUB_NEEDDATA => ParserError.NeedData,
c.HUBBUB_UNKNOWN => ParserError.Unknown,
else => unreachable,
};
}
// documentHTMLParseFromFile parses the given filename c string (ie. with 0 sentinel).
// documentHTMLParseFromFile parses the given HTML file.
// The caller is responsible for closing the document.
pub fn documentHTMLParseFromFile(filename: [:0]const u8) !*DocumentHTML {
// create a null terminated c string.
const doc = c.wr_create_doc_dom_from_file(filename.ptr);
if (doc == null) return error.ParserError;
pub fn documentHTMLParseFromFile(file: std.fs.File) !*DocumentHTML {
var parser: ?*c.dom_hubbub_parser = undefined;
var doc: ?*c.dom_document = undefined;
var err: c.hubbub_error = undefined;
var params = c.dom_hubbub_parser_params{
.enc = null,
.fix_enc = true,
.msg = null,
.script = null,
.enable_script = false,
.ctx = null,
.daf = null,
};
err = c.dom_hubbub_parser_create(&params, &parser, &doc);
try parserErr(err);
defer c.dom_hubbub_parser_destroy(parser);
var buffer: [1024]u8 = undefined;
var ln = buffer.len;
while (ln == buffer.len) {
ln = try file.readAll(&buffer);
err = c.dom_hubbub_parser_parse_chunk(parser, &buffer, ln);
try parserErr(err);
}
err = c.dom_hubbub_parser_completed(parser);
try parserErr(err);
return @as(*DocumentHTML, @ptrCast(doc.?));
}
// documentHTMLParseFromStrAlloc the given string.
// The allocator is required to create a null terminated string.
// The c string allocated is freed by the function.
// documentHTMLParseFromStr parses the given HTML string.
// The caller is responsible for closing the document.
pub fn documentHTMLParseFromStrAlloc(allocator: std.mem.Allocator, str: []const u8) !*DocumentHTML {
// create a null terminated c string.
const cstr = try allocator.dupeZ(u8, str);
defer allocator.free(cstr);
return documentHTMLParseFromStr(cstr);
}
pub fn documentHTMLParseFromStr(str: []const u8) ParserError!*DocumentHTML {
var parser: ?*c.dom_hubbub_parser = undefined;
var doc: ?*c.dom_document = undefined;
var err: c.hubbub_error = undefined;
var params = c.dom_hubbub_parser_params{
.enc = null,
.fix_enc = true,
.msg = null,
.script = null,
.enable_script = false,
.ctx = null,
.daf = null,
};
err = c.dom_hubbub_parser_create(&params, &parser, &doc);
try parserErr(err);
defer c.dom_hubbub_parser_destroy(parser);
err = c.dom_hubbub_parser_parse_chunk(parser, str, str.len);
try parserErr(err);
err = c.dom_hubbub_parser_completed(parser);
try parserErr(err);
// documentHTMLParseFromStr parses the given c string (ie. with 0 sentinel).
// The caller is responsible for closing the document.
pub fn documentHTMLParseFromStr(cstr: [:0]const u8) !*DocumentHTML {
const doc = c.wr_create_doc_dom_from_string(cstr.ptr);
if (doc == null) return error.ParserError;
return @as(*DocumentHTML, @ptrCast(doc.?));
}

5
src/run_tests.zig
View File

@@ -37,7 +37,10 @@ fn testExecFn(
try js_env.attachObject(try js_env.getGlobal(), "window", null);
// document
doc = try parser.documentHTMLParseFromFileAlloc(std.testing.allocator, "test.html");
const file = try std.fs.cwd().openFile("test.html", .{});
defer file.close();
doc = try parser.documentHTMLParseFromFile(file);
defer parser.documentHTMLClose(doc) catch |err| {
std.debug.print("documentHTMLClose error: {s}\n", .{@errorName(err)});
};

5
src/wpt/run.zig
View File

@@ -17,7 +17,10 @@ pub fn run(arena: *std.heap.ArenaAllocator, comptime apis: []jsruntime.API, comp
const alloc = arena.allocator();
// document
const html_doc = try parser.documentHTMLParseFromFileAlloc(alloc, f);
const file = try std.fs.cwd().openFile(f, .{});
defer file.close();
const html_doc = try parser.documentHTMLParseFromFile(file);
const doc = parser.documentHTMLToDocument(html_doc);
const dirname = fspath.dirname(f[dir.len..]) orelse unreachable;

127
vendor/netsurf/wrapper/wrapper.c vendored
View File

@@ -1,127 +0,0 @@
#include <stdio.h>
#include <string.h>
#include <dom/dom.h>
#include <dom/bindings/hubbub/parser.h>
/**
* Generate a LibDOM document DOM from an HTML string
*
* \param string The HTML string
* \return pointer to DOM document, or NULL on error
*/
dom_document *wr_create_doc_dom_from_string(const char *html)
{
dom_hubbub_parser *parser = NULL;
dom_hubbub_error error;
dom_hubbub_parser_params params;
dom_document *doc;
params.enc = NULL;
params.fix_enc = true;
params.enable_script = false;
params.msg = NULL;
params.script = NULL;
params.ctx = NULL;
params.daf = NULL;
/* Create Hubbub parser */
error = dom_hubbub_parser_create(&params, &parser, &doc);
if (error != DOM_HUBBUB_OK) {
printf("Can't create Hubbub Parser\n");
return NULL;
}
error = dom_hubbub_parser_parse_chunk(parser, html, strlen(html));
if (error != DOM_HUBBUB_OK) {
dom_hubbub_parser_destroy(parser);
printf("Parsing errors occur\n");
return NULL;
}
/* Done parsing file */
error = dom_hubbub_parser_completed(parser);
if (error != DOM_HUBBUB_OK) {
dom_hubbub_parser_destroy(parser);
printf("Parsing error when construct DOM\n");
return NULL;
}
/* Finished with parser */
dom_hubbub_parser_destroy(parser);
return doc;
}
/**
* Generate a LibDOM document DOM from an HTML file
*
* \param file The file path
* \return pointer to DOM document, or NULL on error
*/
dom_document *wr_create_doc_dom_from_file(const char *filename)
{
size_t buffer_size = 1024;
dom_hubbub_parser *parser = NULL;
FILE *handle;
int chunk_length;
dom_hubbub_error error;
dom_hubbub_parser_params params;
dom_document *doc;
unsigned char buffer[buffer_size];
params.enc = NULL;
params.fix_enc = true;
params.enable_script = false;
params.msg = NULL;
params.script = NULL;
params.ctx = NULL;
params.daf = NULL;
/* Create Hubbub parser */
error = dom_hubbub_parser_create(&params, &parser, &doc);
if (error != DOM_HUBBUB_OK) {
printf("Can't create Hubbub Parser\n");
return NULL;
}
/* Open input file */
handle = fopen(filename, "rb");
if (handle == NULL) {
dom_hubbub_parser_destroy(parser);
printf("Can't open test input file: %s\n", filename);
return NULL;
}
/* Parse input file in chunks */
chunk_length = buffer_size;
while (chunk_length == buffer_size) {
chunk_length = fread(buffer, 1, buffer_size, handle);
error = dom_hubbub_parser_parse_chunk(parser, buffer,
chunk_length);
if (error != DOM_HUBBUB_OK) {
dom_hubbub_parser_destroy(parser);
printf("Parsing errors occur\n");
return NULL;
}
}
/* Done parsing file */
error = dom_hubbub_parser_completed(parser);
if (error != DOM_HUBBUB_OK) {
dom_hubbub_parser_destroy(parser);
printf("Parsing error when construct DOM\n");
return NULL;
}
/* Finished with parser */
dom_hubbub_parser_destroy(parser);
/* Close input file */
if (fclose(handle) != 0) {
printf("Can't close test input file: %s\n", filename);
return NULL;
}
return doc;
}

9
vendor/netsurf/wrapper/wrapper.h vendored
View File

@@ -1,9 +0,0 @@
#ifndef wrapper_dom_h_
#define wrapper_dom_h_
#include <dom/dom.h>
dom_document *wr_create_doc_dom_from_string(const char *html);
dom_document *wr_create_doc_dom_from_file(const char *filename);
#endif /* wrapper_dom_h_ */