///|
/// Byte spans are half open and relative to the decoded ToUnicode stream.
#derive(@json.ToJson)
pub struct CMapSpan {
operator : String
decoded_offset : Int32
decoded_end : Int32
value_offset : Int32?
range_index : Int32?
}
///|
pub extend CMapSpan with @json.ToJson::{to_json}
///|
priv struct Mapping {
scalars : Array[Int32]
rule : CMapSpan
}
///|
priv struct CMapIssue {
message : String
span : CMapSpan
declared : Int32?
observed : Int32?
unsupported : Bool
}
///|
priv struct CMap {
entries : Map[Int32, Mapping]
issues : Array[CMapIssue]
}
///|
priv suberror CMapError {
BadCMap(CMapIssue)
}
///|
fn cmap_error(
message : String,
start : Int32,
end : Int32,
operator : String,
unsupported~ : Bool = false,
) -> CMapError {
BadCMap({
message,
span: {
operator,
decoded_offset: start,
decoded_end: end,
value_offset: None,
range_index: None,
},
declared: None,
observed: None,
unsupported,
})
}
///|
priv struct CMapReader {
tokens : Array[Token]
mut at : Int32
size : Int32
}
///|
fn CMapReader::take(self : CMapReader, op : String) -> Token raise CMapError {
match self.tokens.get(self.at) {
Some(token) => {
self.at += 1
token
}
None =>
raise cmap_error("unterminated CMap block", self.size, self.size, op)
}
}
///|
fn CMapReader::hex(
self : CMapReader,
op : String,
) -> (Bytes, Token) raise CMapError {
let token = self.take(op)
match token.kind {
Hex(bytes) => (bytes, token)
_ =>
raise cmap_error(
"expected a hexadecimal string",
token.start,
token.end,
op,
)
}
}
///|
fn code_value(
bytes : Bytes,
token : Token,
op : String,
) -> Int32 raise CMapError {
if bytes.length() != 2 {
raise cmap_error(
"Identity-H CMap sources must contain two bytes",
token.start,
token.end,
op,
)
}
(bytes[0].to_int() << 8) | bytes[1].to_int()
}
///|
fn CMapReader::code(
self : CMapReader,
op : String,
) -> (Int32, Token) raise CMapError {
let (bytes, token) = self.hex(op)
(code_value(bytes, token, op), token)
}
///|
fn utf16_scalars(bytes : Bytes) -> Array[Int32]? {
if bytes.length() == 0 || bytes.length() % 2 != 0 {
return None
}
let scalars : Array[Int32] = []
let mut i = 0
while i < bytes.length() {
let high = (bytes[i].to_int() << 8) | bytes[i + 1].to_int()
i += 2
if high >= 0xD800 && high <= 0xDBFF {
if i + 1 >= bytes.length() {
return None
}
let low = (bytes[i].to_int() << 8) | bytes[i + 1].to_int()
if low < 0xDC00 || low > 0xDFFF {
return None
}
scalars.push(0x10000 + ((high - 0xD800) << 10) + low - 0xDC00)
i += 2
} else if high >= 0xDC00 && high <= 0xDFFF {
return None
} else {
scalars.push(high)
}
}
Some(scalars)
}
///|
fn parse_mapping(
bytes : Bytes,
token : Token,
op : String,
) -> Array[Int32] raise CMapError {
if bytes.length() > 256 {
raise cmap_error(
"ToUnicode destination exceeds the 256-byte limit",
token.start,
token.end,
op,
unsupported=true,
)
}
match utf16_scalars(bytes) {
Some(value) => value
None =>
raise cmap_error(
"destination is not a valid UTF-16BE sequence",
token.start,
token.end,
op,
)
}
}
///|
fn put_mapping(
mappings : Map[Int32, Mapping],
code : Int32,
scalars : Array[Int32],
rule : CMapSpan,
) -> Unit raise CMapError {
if mappings.contains(code) {
raise cmap_error(
"duplicate source code <\{display_hex(code, 4)}>",
rule.decoded_offset,
rule.decoded_end,
rule.operator,
)
}
mappings.set(code, { scalars, rule, })
}
///|
fn CMapReader::bfchar(
self : CMapReader,
mappings : Map[Int32, Mapping],
) -> Unit raise CMapError {
let op = "bfchar"
let (code, source) = self.code(op)
let (bytes, dest) = self.hex(op)
let scalars = parse_mapping(bytes, dest, op)
put_mapping(mappings, code, scalars, {
operator: op,
decoded_offset: source.start,
decoded_end: dest.end,
value_offset: Some(dest.start),
range_index: None,
})
}
///|
fn CMapReader::bfrange(
self : CMapReader,
mappings : Map[Int32, Mapping],
) -> Unit raise CMapError {
let op = "bfrange"
let (first, source) = self.code(op)
let (last, upper) = self.code(op)
if last < first {
raise cmap_error("descending source range", source.start, upper.end, op)
}
let target = self.take(op)
match target.kind {
Hex(start) => {
// The PDF ToUnicode integer form only increments the last destination
// byte. Reject overflow instead of letting it carry into the prefix.
let bytes = start.to_array()
if bytes.length() > 256 {
raise cmap_error(
"ToUnicode destination exceeds the 256-byte limit",
target.start,
target.end,
op,
unsupported=true,
)
}
if bytes.is_empty() ||
bytes[bytes.length() - 1].to_int() + last - first > 255 {
raise cmap_error(
"sequential bfrange destination overflows its final byte",
target.start,
target.end,
op,
)
}
for code in first..<=last {
let scalars = parse_mapping(Bytes::from_array(bytes), target, op)
put_mapping(mappings, code, scalars, {
operator: op,
decoded_offset: source.start,
decoded_end: target.end,
value_offset: Some(target.start),
range_index: Some(code - first),
})
if code != last {
let i = bytes.length() - 1
bytes[i] = (bytes[i].to_int() + 1).to_byte()
}
}
}
ArrayOpen => {
let values : Array[(Array[Int32], Token)] = Array(
capacity=last - first + 1,
)
for _ in first..<=last {
let (bytes, dest) = self.hex(op)
values.push((parse_mapping(bytes, dest, op), dest))
}
let end = self.take(op)
if !(end.kind is ArrayClose) {
raise cmap_error(
"bfrange array length does not match its source range",
source.start,
end.end,
op,
)
}
for i, value in values {
put_mapping(mappings, first + i, value.0, {
operator: op,
decoded_offset: source.start,
decoded_end: end.end,
value_offset: Some(value.1.start),
range_index: Some(i),
})
}
}
_ =>
raise cmap_error(
"expected a bfrange destination or array",
target.start,
target.end,
op,
)
}
}
///|
fn parse_cmap_tokens(reader : CMapReader, cmap : CMap) -> Unit raise CMapError {
let ranges : Array[(Int32, Int32)] = []
let mut started = false
let mut ended = false
while reader.at < reader.tokens.length() {
let index = reader.at
let token = reader.take("cmap")
let op = match token.kind {
Word(word) => word
_ => continue
}
match op {
"begincmap" => {
if started {
raise cmap_error(
"duplicate begincmap operator",
token.start,
token.end,
op,
)
}
started = true
}
"endcmap" => {
if !started || ended {
raise cmap_error(
"unexpected endcmap operator",
token.start,
token.end,
op,
)
}
ended = true
}
"begincodespacerange" | "beginbfchar" | "beginbfrange" => {
if !started || ended || index == 0 {
raise cmap_error(
"mapping block outside CMap body",
token.start,
token.end,
op,
)
}
let marker = reader.tokens[index - 1]
let declared = match marker.kind {
Integer(n) if n >= 0 && n <= 65536 => n
_ =>
raise cmap_error(
"missing or invalid CMap block count",
marker.start,
token.end,
op,
)
}
let end_op = match op {
"beginbfchar" => "endbfchar"
"beginbfrange" => "endbfrange"
_ => "endcodespacerange"
}
let mut actual = 0
while true {
let next = reader.take(op)
if next.kind is Word(word) && word == end_op {
if actual != declared {
if cmap.issues.length() >= 32 {
raise cmap_error(
"too many CMap block count errors",
marker.start,
token.end,
op,
)
}
cmap.issues.push({
message: "declared block count differs from actual entry count",
span: {
operator: op,
decoded_offset: marker.start,
decoded_end: token.end,
value_offset: None,
range_index: None,
},
declared: Some(declared),
observed: Some(actual),
unsupported: false,
})
}
break
}
reader.at -= 1
match op {
"beginbfchar" => reader.bfchar(cmap.entries)
"beginbfrange" => reader.bfrange(cmap.entries)
_ => {
let (lo, first) = reader.code(op)
let (hi, last) = reader.code(op)
if hi < lo ||
ranges.length() >= 64 ||
ranges.any(r => lo <= r.1 && hi >= r.0) {
raise cmap_error(
"invalid or overlapping codespace range",
first.start,
last.end,
op,
)
}
ranges.push((lo, hi))
}
}
actual += 1
}
}
"usecmap" =>
raise cmap_error(
"ToUnicode CMap inheritance is unsupported",
token.start,
token.end,
op,
unsupported=true,
)
"begincidchar"
| "begincidrange"
| "beginnotdefchar"
| "beginnotdefrange" =>
raise cmap_error(
"unsupported ToUnicode mapping operator",
token.start,
token.end,
op,
)
"endbfchar" | "endbfrange" | "endcodespacerange" =>
raise cmap_error(
"unexpected mapping block terminator",
token.start,
token.end,
op,
)
_ =>
if started &&
!ended &&
op != "def" &&
op != "dict" &&
op != "dup" &&
op != "begin" &&
op != "end" &&
op != "put" {
raise cmap_error(
"unsupported operator in the CMap body",
token.start,
token.end,
op,
unsupported=true,
)
}
}
}
if !started || !ended || ranges.is_empty() {
raise cmap_error(
"CMap must contain a body and a two-byte codespace",
0,
reader.size,
"cmap",
)
}
for code, mapping in cmap.entries {
if !ranges.any(r => r.0 <= code && code <= r.1) {
raise cmap_error(
"source code lies outside the codespace",
mapping.rule.decoded_offset,
mapping.rule.decoded_end,
mapping.rule.operator,
)
}
}
}
///|
fn parse_cmap(data : Bytes) -> CMap {
let result : CMap = { entries: Map([]), issues: [], }
let lexer : Lexer = { data, pos: 0, }
let tokens : Array[Token] = []
try {
while true {
lexer.skip_space()
let start = lexer.pos
let token = lexer.next(cmap=true) catch {
Invalid(message) | Unsupported(message) =>
raise cmap_error(message, start, lexer.pos, "cmap")
}
match token {
None => break
Some(t) => {
if tokens.length() >= 180_000 {
raise cmap_error(
"ToUnicode token limit exceeded",
t.start,
t.end,
"cmap",
unsupported=true,
)
}
if t.kind is Name(name) && name == b"WMode" {
// Some ToUnicode producers include WMode. Cardinality and
// horizontal semantics are verified before using the map.
match (lexer.next(cmap=true) catch { _ => None }) {
Some(m) if m.kind is Integer(0) => {
tokens.push(t)
tokens.push(m)
}
_ =>
raise cmap_error(
"only ToUnicode WMode 0 is supported",
t.start,
lexer.pos,
"cmap",
unsupported=true,
)
}
} else {
tokens.push(t)
}
}
}
}
parse_cmap_tokens({ tokens, at: 0, size: data.length(), }, result)
} catch {
BadCMap(problem) => result.issues.push(problem)
}
result
}