tiny.pdf.Document

1pub const Document = struct {2    document_allocator: std.mem.Allocator,3    arena_state: alloc_arena.Arena,4    filter_storage: *filter.Storage,5    bytes: []const u8,6    table: xref.Table,7    containers: std.AutoHashMapUnmanaged(u32, Container),8    fonts: std.AutoHashMapUnmanaged(u32, *const font.Font),910    pub fn init(11        document_allocator: std.mem.Allocator,12        filter_storage: *filter.Storage,13        bytes: []const u8,14    ) DocumentError!Document {15        var arena_state = alloc_arena.Arena.init(document_allocator);16        errdefer arena_state.deinit();17        var table = try xref.parse(18            document_allocator,19            arena_state.allocator(),20            filter_storage,21            bytes,22        );23        errdefer table.deinit(document_allocator);24        return .{25            .document_allocator = document_allocator,26            .arena_state = arena_state,27            .filter_storage = filter_storage,28            .bytes = bytes,29            .table = table,30            .containers = .empty,31            .fonts = .empty,32        };33    }3435    pub fn deinit(self: *Document) void {36        self.fonts.deinit(self.document_allocator);37        self.containers.deinit(self.document_allocator);38        self.table.deinit(self.document_allocator);39        self.arena_state.deinit();40    }4142    pub fn objectValue(self: *Document, reference: object.Reference) DocumentError!object.Value {43        return ObjectAccess.init(self).objectValue(reference);44    }4546    pub fn objectStream(self: *Document, reference: object.Reference) DocumentError!Stream {47        return ObjectAccess.init(self).objectStream(reference);48    }4950    pub fn resolve(self: *Document, value: object.Value) DocumentError!object.Value {51        return ObjectAccess.init(self).resolve(value);52    }5354    pub fn decodeStream(self: *Document, stream: Stream) DocumentError![]u8 {55        return ObjectAccess.init(self).decodeStream(stream);56    }5758    pub fn pagesAppend(self: *Document, list_allocator: std.mem.Allocator, pages: *std.ArrayList(Page)) DocumentError!void {59        const catalog = switch (try self.objectValue(self.table.root)) {60            .dict => |dict| dict,61            else => return error.NotADictionary,62        };63        const pages_value = catalog.get("Pages") orelse return error.MissingPages;64        const pages_ref = switch (pages_value) {65            .reference => |reference| reference,66            else => return error.MissingPages,67        };68        try self.walkPages(list_allocator, pages, pages_ref, null, 0);69    }7071    fn walkPages(self: *Document, list_allocator: std.mem.Allocator, pages: *std.ArrayList(Page), reference: object.Reference, inherited: ?object.Dict, depth: usize) DocumentError!void {72        if (depth > 64) return error.ResolveDepth;73        const node = switch (try self.objectValue(reference)) {74            .dict => |dict| dict,75            else => return error.NotADictionary,76        };77        const kind = node.get("Type") orelse return error.NotADictionary;78        const kind_name = switch (kind) {79            .name => |name| name,80            else => return error.NotADictionary,81        };82        const resources: ?object.Dict = blk: {83            const value = node.get("Resources") orelse break :blk inherited;84            break :blk switch (try self.resolve(value)) {85                .dict => |dict| dict,86                else => inherited,87            };88        };89        if (std.mem.eql(u8, kind_name, "Pages")) {90            const kids = node.get("Kids") orelse return;91            const items = switch (try self.resolve(kids)) {92                .array => |array| array,93                else => return,94            };95            for (items) |item| {96                switch (item) {97                    .reference => |kid| try self.walkPages(list_allocator, pages, kid, resources, depth + 1),98                    else => {},99                }100            }101            return;102        }103        if (!std.mem.eql(u8, kind_name, "Page")) return;104        const arena = self.arena_state.allocator();105        var refs: std.ArrayList(object.Reference) = .empty;106        if (node.get("Contents")) |contents| {107            switch (contents) {108                .reference => |stream_ref| refs.append(arena, stream_ref) catch return error.OutOfMemory,109                .array => |items| {110                    for (items) |item| {111                        switch (item) {112                            .reference => |stream_ref| refs.append(arena, stream_ref) catch return error.OutOfMemory,113                            else => {},114                        }115                    }116                },117                else => {},118            }119        }120        const owned = refs.toOwnedSlice(arena) catch return error.OutOfMemory;121        pages.append(list_allocator, .{ .contents = owned, .resources = resources }) catch return error.OutOfMemory;122    }123124    pub fn fontSetAlloc(self: *Document, resources: ?object.Dict) DocumentError!font.Set {125        const resources_dict = resources orelse return .{};126        const fonts_value = resources_dict.get("Font") orelse return .{};127        const fonts_dict = switch (try self.resolve(fonts_value)) {128            .dict => |dict| dict,129            else => return .{},130        };131        const arena = self.arena_state.allocator();132        const entries = arena.alloc(font.Entry, fonts_dict.entries.len) catch return error.OutOfMemory;133        var count: usize = 0;134        for (fonts_dict.entries) |entry| {135            switch (entry.value) {136                .reference => |reference| {137                    entries[count] = .{ .name = entry.key, .font = try self.loadFont(reference) };138                    count += 1;139                },140                else => {},141            }142        }143        return .{ .entries = entries[0..count] };144    }145146    fn loadFont(self: *Document, reference: object.Reference) DocumentError!*const font.Font {147        if (self.fonts.get(reference.number)) |cached| return cached;148        const arena = self.arena_state.allocator();149        const created = arena.create(font.Font) catch return error.OutOfMemory;150        created.* = .{ .map = self.fontMapAlloc(reference) catch |err| switch (err) {151            error.OutOfMemory => return error.OutOfMemory,152            else => null,153        } };154        self.fonts.put(self.document_allocator, reference.number, created) catch return error.OutOfMemory;155        return created;156    }157158    fn fontMapAlloc(self: *Document, reference: object.Reference) DocumentError!?cmap.Map {159        const dict = switch (try self.objectValue(reference)) {160            .dict => |dict| dict,161            else => return null,162        };163        const to_unicode = dict.get("ToUnicode") orelse return null;164        const stream_ref = switch (to_unicode) {165            .reference => |stream_ref| stream_ref,166            else => return null,167        };168        const stream = try self.objectStream(stream_ref);169        const arena = self.arena_state.allocator();170        const decoded = try self.decodeStream(stream);171        defer self.filter_storage.reset();172        return cmap.parseAlloc(arena, decoded) catch |err| switch (err) {173            error.OutOfMemory => return error.OutOfMemory,174            error.BadCMap => null,175        };176    }177};

1pub const Document = @import("document.zig").Document;