///|
priv struct DocumentScan {
pages : Array[PageScan]
diagnostics : Array[Diagnostic]
mut total_glyphs : Int32
mut page_count : Int32
mut blocked : Bool
mut syntax_error : Bool
}
///|
fn page_frame(
doc : Document,
page : @pdfpage.PdfPage,
raw : @syntax.PdfObject,
) -> PageFrame raise GuardError {
if field(raw, b"Annots") is Some(value) {
let resolved = doc.resolve(value)
if !(resolved is PdfNull) && !doc.array(resolved).is_empty() {
raise Unsupported("page annotations or widgets")
}
}
let media = doc.page_box(page.mediabox)
let crop = match field(page.rest, b"CropBox") {
Some(value) => doc.page_box(value)
None => media
}
let unit = match field(raw, b"UserUnit") {
Some(value) => doc.number(value)
None => 1.0
}
normalize_page(media, crop, doc.page_rotation(raw), unit)
}
///|
fn scan_page(
doc : Document,
side : String,
number : Int32,
ref_number : Int32,
page : @pdfpage.PdfPage,
glyph_budget : Int32,
) -> PageScan raise GuardError {
let raw = doc.resolve(@syntax.PdfObject::PdfIndirect(ref_number))
let frame = page_frame(doc, page, raw)
let output : PageScan = {
bounds: frame.bounds,
page_unit: frame.unit,
glyphs: [],
diagnostics: [],
blocked: false,
syntax_error: false,
}
let scope : ResourceScope = { resources: page.resources, fonts: Map([]), }
let scan : ContentScan = {
doc,
side,
page: number,
scope,
page_scope: scope,
output,
stack: [],
graphics: {
ctm: identity,
font: None,
size: 0,
spacing: 0,
scale: 1,
leading: 0,
rise: 0,
mode: 0,
},
in_text: false,
text: identity,
line: identity,
marked_depth: 0,
stream: None,
stream_index: 0,
decoded_offset: None,
glyph_budget,
page_transform: frame.transform,
form_path: [],
nested_error: Ref(None),
}
try {
let streams = doc.contents(raw)
if streams.length() > 256 {
raise Unsupported("too many page content streams")
}
for i, stream in streams {
scan.read_stream(stream, i)
}
scan.require_closed()
} catch {
error => {
output.blocked = true
let d = note(guard_code(error), side, guard_message(error), page=number)
output.diagnostics.push({
..d,
stream: Some(scan.nested_error.val.unwrap_or(scan.stream_site())),
})
}
}
output
}
///|
fn scan_document(bytes : Bytes, side : String) -> DocumentScan {
let output : DocumentScan = {
pages: [],
diagnostics: [],
total_glyphs: 0,
page_count: 0,
blocked: false,
syntax_error: false,
}
try {
let doc = read_document(bytes)
let pages = doc.pdf.pages_of_pagetree() catch {
PageRotationExpected(degrees) =>
raise Invalid(
"page Rotate must be an integer multiple of 90 (found \{degrees})",
)
_ => raise Invalid("cannot read the PDF page tree")
}
let page_numbers = doc.pdf.page_reference_numbers() catch {
_ => raise Invalid("cannot resolve PDF page objects")
}
output.page_count = pages.length()
if pages.length() > 128 {
raise Unsupported("PDF exceeds the 128-page limit")
}
if pages.is_empty() || pages.length() != page_numbers.length() {
raise Invalid("empty or inconsistent PDF page tree")
}
for i, page in pages {
let page_scan = scan_page(
doc,
side,
i + 1,
page_numbers[i],
page,
100_000 - output.total_glyphs,
) catch {
error =>
{
bounds: [],
page_unit: 1,
glyphs: [],
blocked: true,
syntax_error: false,
diagnostics: [
note(guard_code(error), side, guard_message(error), page=i + 1),
],
}
}
output.pages.push(page_scan)
output.diagnostics.append(page_scan.diagnostics)
output.total_glyphs += page_scan.glyphs.length()
output.blocked = output.blocked || page_scan.blocked
output.syntax_error = output.syntax_error || page_scan.syntax_error
}
} catch {
error => {
output.blocked = true
output.diagnostics.push(
note(guard_code(error), side, guard_message(error)),
)
}
}
output
}