docling-parse 7.23.1__tar.gz → 7.24.0__tar.gz

{docling_parse-7.23.1 → docling_parse-7.24.0}/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [v7.24.0](https://github.com/docling-project/docling-parse/releases/tag/v7.24.0) - 2026-10-27
+
+### Feature
+
+* Report why a document failed to load, so a password is told from a damaged file ([#414](https://github.com/docling-project/docling-parse/issues/414)) ([`3317576`](https://github.com/docling-project/docling-parse/commit/33175762f5324d987e4d8bb01f191900c96a5cc2))
+
+### Fix
+
+* Resolve /CIDToGIDMap streams for CIDFontType2 glyph lookup ([#426](https://github.com/docling-project/docling-parse/issues/426)) ([`8099e94`](https://github.com/docling-project/docling-parse/commit/8099e94fe9a872fe2ceb63618ecbda5beb91e9da))
+* Decode image XObject samples only when a page draws them ([#425](https://github.com/docling-project/docling-parse/issues/425)) ([`341aea5`](https://github.com/docling-project/docling-parse/commit/341aea52ce999d266bd62d5bde625502e7c13ea7))
+
 ## [v7.23.1](https://github.com/docling-project/docling-parse/releases/tag/v7.23.1) - 2026-10-26
 
 ### Fix

{docling_parse-7.23.1 → docling_parse-7.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.23.1
+Version: 7.24.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.23.1 → docling_parse-7.24.0}/app/pybind_parse.cpp

@@ -848,6 +848,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
     Returns:
         List[str]: A list of keys for the currently loaded documents.)")
+
+    .def("take_load_error",
+	 [](docling::docling_parser &self, const std::string &key) -> std::map<std::string, std::string> {
+	   return self.take_load_error(key);
+	 },
+	 pybind11::arg("key"),
+	 R"(
+    Return and clear why the last load of `key` failed.
+
+    Parameters:
+        key (str): The key passed to the failed load call.
+
+    Returns:
+        dict[str, str]: {"category": ..., "message": ...}, or an empty dict when
+        no failure is recorded for the key. category is one of "password",
+        "damaged", "unsupported", "io" and "unknown"; message is the text of
+        the underlying (qpdf) error.)")
     
     .def("load_document",
 	 [](docling::docling_parser &self,
@@ -1116,6 +1133,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Returns:
         bool: True if the document was successfully loaded.)")
 
+    .def("take_load_error",
+         [](docling::docling_threaded_parser& self, const std::string& key) -> std::map<std::string, std::string> {
+           return self.take_load_error(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Return and clear why the last load of `key` failed.
+
+    Parameters:
+        key (str): The key passed to the failed load call.
+
+    Returns:
+        dict[str, str]: {"category": ..., "message": ...}, or an empty dict when
+        no failure is recorded for the key. category is one of "password",
+        "damaged", "unsupported", "io" and "unknown"; message is the text of
+        the underlying (qpdf) error.)")
+
     .def("load_document_from_bytesio",
          [](docling::docling_threaded_parser& self,
             const std::string& key,

{docling_parse-7.23.1 → docling_parse-7.24.0}/docling_parse/pdf_parser.py

@@ -3,7 +3,7 @@
 import hashlib
 import logging
 import math
-from enum import IntEnum
+from enum import Enum, IntEnum
 from io import BytesIO
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Union
@@ -77,6 +77,78 @@ from docling_parse.pdf_parsers import (  # type: ignore[import]
 _log = logging.getLogger(__name__)
 
 
+class PdfLoadErrorCategory(str, Enum):
+    """Why docling-parse could not load a document.
+
+    The values are the categories the native loader reports, see
+    `src/parse/qpdf/load_error.h`.
+    """
+
+    PASSWORD = "password"
+    """The document is encrypted and the password is missing or wrong."""
+    DAMAGED = "damaged"
+    """qpdf could not repair the file."""
+    UNSUPPORTED = "unsupported"
+    """The file uses a feature qpdf does not implement."""
+    IO = "io"
+    """The file is missing or unreadable."""
+    UNKNOWN = "unknown"
+
+
+class PdfLoadError(RuntimeError):
+    """docling-parse could not load a document.
+
+    A RuntimeError, so handlers written for the former generic error keep
+    working, and the message keeps its former prefix. `category` says what
+    went wrong; `detail` is the message of the underlying (qpdf) failure.
+    """
+
+    def __init__(
+        self,
+        key: str,
+        category: PdfLoadErrorCategory,
+        detail: str,
+        *,
+        reason: str | None = None,
+    ):
+        self.key = key
+        self.category = category
+        self.detail = detail
+
+        message = f"Failed to load document with key {key}"
+        description = reason or detail
+        if description:
+            message = f"{message}: {description}"
+        super().__init__(message)
+
+
+class PdfPasswordError(PdfLoadError):
+    """The document is encrypted and was opened without a valid password.
+
+    `password_supplied` tells whether the caller gave a (wrong) password or
+    none at all: qpdf reports both as the same invalid-password error.
+    """
+
+    def __init__(self, key: str, detail: str, *, password_supplied: bool):
+        self.password_supplied = password_supplied
+        if password_supplied:
+            reason = "the supplied password is incorrect"
+        else:
+            reason = "the document is encrypted and requires a password"
+        super().__init__(key, PdfLoadErrorCategory.PASSWORD, detail, reason=reason)
+
+
+def _load_error(native_parser, key: str, password: str | None) -> PdfLoadError:
+    """Build the exception for a failed load from the native parser's record."""
+    info = native_parser.take_load_error(key)
+    category = PdfLoadErrorCategory(info.get("category", PdfLoadErrorCategory.UNKNOWN))
+    detail = info.get("message", "")
+
+    if category is PdfLoadErrorCategory.PASSWORD:
+        return PdfPasswordError(key, detail, password_supplied=password is not None)
+    return PdfLoadError(key, category, detail)
+
+
 class PdfAnnotations(BaseModel):
     """PDF document annotations including form fields, language, metadata, and table of contents.
 
@@ -1004,7 +1076,14 @@ class DoclingPdfParser:
         decode_config: DecodeConfig | None = None,
         content_config: ContentConfig | None = None,
     ) -> PdfDocument:
+        """Load a document and return a handle to its pages.
 
+        Raises:
+            PdfPasswordError: The document is encrypted and `password` is
+                missing or wrong.
+            PdfLoadError: The document could not be loaded for another
+                reason; see its `category` and `detail`.
+        """
         if isinstance(path_or_stream, str):
             path_or_stream = Path(path_or_stream)
 
@@ -1048,7 +1127,7 @@ class DoclingPdfParser:
 
             return result_doc
         else:
-            raise RuntimeError(f"Failed to load document with key {key}")
+            raise _load_error(self.parser, key, password)
 
     def _load_document(
         self,
@@ -1571,6 +1650,12 @@ class DoclingThreadedPdfParser:
 
         Returns:
             str: The document key.
+
+        Raises:
+            PdfPasswordError: The document is encrypted and `password` is
+                missing or wrong.
+            PdfLoadError: The document could not be loaded for another
+                reason; see its `category` and `detail`.
         """
         if page_numbers is not None and page_range is not None:
             raise ValueError("page_numbers and page_range are mutually exclusive")
@@ -1608,7 +1693,7 @@ class DoclingThreadedPdfParser:
             )
 
         if not success:
-            raise RuntimeError(f"Failed to load document with key {key}")
+            raise _load_error(self._parser, key, password)
 
         self._page_counts[key] = self._parser.number_of_pages(key)
         self._scheduled_page_counts[key] = self._parser.scheduled_number_of_pages(key)

{docling_parse-7.23.1 → docling_parse-7.24.0}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.23.1
+Version: 7.24.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.23.1 → docling_parse-7.24.0}/docling_parse.egg-info/SOURCES.txt

@@ -612,6 +612,7 @@ src/parse/pdf_states/grph.h
 src/parse/pdf_states/shape.h
 src/parse/pdf_states/text.h
 src/parse/qpdf/annots.h
+src/parse/qpdf/load_error.h
 src/parse/qpdf/logger.h
 src/parse/qpdf/object.h
 src/parse/qpdf/outline.h
@@ -752,6 +753,7 @@ tests/test_unit_acroform_widgets.py
 tests/test_unit_actual_text.py
 tests/test_unit_bitmap_artifacts.py
 tests/test_unit_ccitt_images.py
+tests/test_unit_cid_to_gid_map.py
 tests/test_unit_cjk_fonts.py
 tests/test_unit_clipping.py
 tests/test_unit_cmap_encoding.py
@@ -769,6 +771,7 @@ tests/test_unit_invalid_font_metrics.py
 tests/test_unit_jbig2_masks.py
 tests/test_unit_jpeg_images.py
 tests/test_unit_load_failure.py
+tests/test_unit_load_failure_reason.py
 tests/test_unit_nul_mapping.py
 tests/test_unit_page_count.py
 tests/test_unit_patterns.py
@@ -778,6 +781,7 @@ tests/test_unit_shading.py
 tests/test_unit_shadings.py
 tests/test_unit_shape_boundary_origin.py
 tests/test_unit_shape_queries_page_frame.py
+tests/test_unit_shared_resource_images.py
 tests/test_unit_standard_font_widths.py
 tests/test_unit_stroke_curves.py
 tests/test_unit_text_render_modes.py

{docling_parse-7.23.1 → docling_parse-7.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.23.1"
+version = "7.24.0"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]

{docling_parse-7.23.1 → docling_parse-7.24.0}/src/parse/page_items/embedded_font_blob.h

@@ -32,7 +32,8 @@ namespace pdflib
                        bool is_cid_font,
                        bool cid_to_gid_identity,
                        bool uses_builtin_encoding,
-                       std::shared_ptr<const std::vector<uint8_t> > bytes);
+                       std::shared_ptr<const std::vector<uint8_t> > bytes,
+                       std::vector<uint16_t> code_to_gid_map);
 
     // Content-derived identity (FNV-1a over the decoded bytes + size).
     // PDF object ids are NOT used: they are only unique within one document,
@@ -53,6 +54,24 @@ namespace pdflib
     // /CIDToGIDMap is /Identity or absent
     bool get_cid_to_gid_identity() const { return cid_to_gid_identity; }
 
+    // True when a CID font's character codes address glyphs directly: an
+    // identity /CIDToGIDMap, or a /CIDToGIDMap stream whose CIDs the
+    // /Encoding CMap resolves.
+    bool has_code_to_gid() const
+    {
+      return is_cid_font and (cid_to_gid_identity or not code_to_gid_map.empty());
+    }
+
+    // Glyph index of a PDF character code under has_code_to_gid(). An
+    // identity map takes the code itself, as before (exact for
+    // Identity-H/V); an unmapped code gives GID 0.
+    uint32_t code_to_gid(int64_t code) const
+    {
+      if(cid_to_gid_identity) { return static_cast<uint32_t>(code); }
+      return (code >= 0 and static_cast<size_t>(code) < code_to_gid_map.size())
+        ? code_to_gid_map[static_cast<size_t>(code)] : 0;
+    }
+
     // True for a simple font that is symbolic (/FontDescriptor /Flags bit 3)
     // and has no /Encoding override: its PDF character codes address the
     // font program's builtin cmap directly (PDF 32000-1, 9.6.6.4). Shaping
@@ -83,6 +102,10 @@ namespace pdflib
     bool uses_builtin_encoding;
 
     std::shared_ptr<const std::vector<uint8_t> > bytes;
+
+    // /CIDToGIDMap stream composed with the /Encoding CMap (code -> GID);
+    // empty when the map is identity or absent, or its CIDs are unresolved
+    std::vector<uint16_t> code_to_gid_map;
   };
 
   inline embedded_font_blob::embedded_font_blob():
@@ -94,7 +117,8 @@ namespace pdflib
     is_cid_font(false),
     cid_to_gid_identity(false),
     uses_builtin_encoding(false),
-    bytes(nullptr)
+    bytes(nullptr),
+    code_to_gid_map()
   {}
 
   inline embedded_font_blob::embedded_font_blob(std::string cache_key_,
@@ -105,7 +129,8 @@ namespace pdflib
                                                 bool is_cid_font_,
                                                 bool cid_to_gid_identity_,
                                                 bool uses_builtin_encoding_,
-                                                std::shared_ptr<const std::vector<uint8_t> > bytes_):
+                                                std::shared_ptr<const std::vector<uint8_t> > bytes_,
+                                                std::vector<uint16_t> code_to_gid_map_):
     cache_key(std::move(cache_key_)),
     font_name(std::move(font_name_)),
     base_font(std::move(base_font_)),
@@ -114,7 +139,8 @@ namespace pdflib
     is_cid_font(is_cid_font_),
     cid_to_gid_identity(cid_to_gid_identity_),
     uses_builtin_encoding(uses_builtin_encoding_),
-    bytes(std::move(bytes_))
+    bytes(std::move(bytes_)),
+    code_to_gid_map(std::move(code_to_gid_map_))
   {}
 
   inline bool embedded_font_blob::has_bytes() const

{docling_parse-7.23.1 → docling_parse-7.24.0}/src/parse/pdf_decoders/document.h

@@ -11,8 +11,10 @@
 #include <qpdf/Buffer.hh>
 #include <qpdf/QPDFAcroFormDocumentHelper.hh>
 #include <qpdf/QPDF.hh>
+#include <qpdf/QPDFExc.hh>
 #include <qpdf/QPDFWriter.hh>
 
+#include <parse/qpdf/load_error.h>
 #include <parse/qpdf/logger.h>
 #include <parse/qpdf/page_integrity.h>
 
@@ -34,6 +36,12 @@ namespace pdflib
 
     std::string get_filename() { return filename; }
 
+    // Why the last process_document_* call returned false: a category
+    // from load_error and the message of the underlying failure. Both
+    // are empty while no load has failed.
+    const std::string& get_load_error_category() const { return load_error_category; }
+    const std::string& get_load_error_message() const { return load_error_message; }
+
     nlohmann::json get_annotations();
 
     nlohmann::json get_meta_xml();
@@ -83,6 +91,8 @@ namespace pdflib
     // object the file does not contain (docling-parse#374).
     void ensure_page_content_present(int page_number);
 
+    void record_load_error(const std::string& category, const std::string& message);
+
     void update_timings(pdf_timings& timings_, bool set_timer);
 
   private:
@@ -112,6 +122,9 @@ namespace pdflib
     // and read by the worker threads afterwards.
     bool qpdf_reported_damage;
 
+    std::string load_error_category;
+    std::string load_error_message;
+
     nlohmann::json json_annots;
     bool annots_loaded;
 
@@ -235,6 +248,7 @@ namespace pdflib
     std::ifstream ifs(fs_path, std::ios::binary | std::ios::ate);
     if(!ifs.is_open())
       {
+        record_load_error(load_error::IO, "could not open file: " + filename);
         LOG_S(ERROR) << "could not open file: " << filename;
         return false;
       }
@@ -245,6 +259,7 @@ namespace pdflib
     auto file_buffer = std::make_shared<std::string>(file_size, '\0');
     if(!ifs.read(file_buffer->data(), file_size))
       {
+        record_load_error(load_error::IO, "could not read file: " + filename);
         LOG_S(ERROR) << "could not read file: " << filename;
         return false;
       }
@@ -270,6 +285,9 @@ namespace pdflib
     buffer = _buffer;
     password = _password;
 
+    load_error_category.clear();
+    load_error_message.clear();
+
     LOG_S(INFO) << "start processing buffer of size " << buffer->size() << " by qpdf ...";
     
     utils::timer timer;
@@ -308,8 +326,16 @@ namespace pdflib
 	
         LOG_S(INFO) << "#-pages: " << number_of_pages;	
       }
+    catch(const QPDFExc & exc)
+      {
+        // qpdf says why: an invalid password, a file it could not repair, ...
+        record_load_error(load_error::category_of(exc.getErrorCode()), exc.what());
+        LOG_S(ERROR) << "could not process buffer by qpdf: " << exc.what();
+        return false;
+      }
     catch(const std::exception & exc)
       {
+        record_load_error(load_error::UNKNOWN, exc.what());
         LOG_S(ERROR) << "could not process buffer by qpdf: " << exc.what();
         return false;
       }
@@ -321,6 +347,13 @@ namespace pdflib
     return true;
   }
 
+  void pdf_decoder<DOCUMENT>::record_load_error(const std::string& category,
+                                                const std::string& message)
+  {
+    load_error_category = category;
+    load_error_message = message;
+  }
+
   std::pair<int, std::shared_ptr<std::string> > pdf_decoder<DOCUMENT>::get_thread_safe_page_buffer(
     int page_ind,
     bool keep_qpdf_warnings)

{docling_parse-7.23.1 → docling_parse-7.24.0}/src/parse/pdf_resources/page_font/font_cid.h

@@ -313,6 +313,8 @@ namespace pdflib
     // resource declared none.
     const std::vector<cmap_codespace_range>& get_codespaces() const;
 
+    const std::unordered_map<uint32_t, uint32_t>& get_code_to_cid() const { return cmap2cid; }
+
     void decode_cmap_resource(std::string filename,
                               std::string cid2code,
                               std::vector<std::string> columns);

{docling_parse-7.23.1 → docling_parse-7.24.0}/src/parse/pdf_resources/page_font.h

@@ -186,6 +186,7 @@ namespace pdflib
 
     embedded_font_format resolve_embedded_font_format() const;
     bool resolve_cid_to_gid_identity() const;
+    std::vector<uint16_t> resolve_code_to_gid_map() const;
     void build_embedded_font_blob();
     
     // Resolution of this font onto one of the built-in base fonts. See the
@@ -257,6 +258,10 @@ namespace pdflib
     bool               has_explicit_encoding; // true if encoding was found in PDF, false if defaulted
     bool               is_symbolic = false;   // /FontDescriptor /Flags bit 3 (PDF 32000-1 table 123)
 
+    // code -> CID of an embedded /Encoding CMap; left empty when the CMap
+    // inherits through usecmap, whose entries are not read
+    std::unordered_map<uint32_t, uint32_t> embedded_code_to_cid;
+
     font_subtype_name  subtype;
 
     std::string font_key;
@@ -1196,8 +1201,10 @@ namespace pdflib
     // An embedded CMap may inherit from a predefined one. Only its name is
     // available here, so the inherited codespace is reported rather than
     // silently assumed.
-    auto report_usecmap = [](const std::string& parent)
+    bool inherits = false;
+    auto report_usecmap = [&inherits](const std::string& parent)
     {
+      inherits = true;
       LOG_S(WARNING) << "embedded cmap inherits from " << parent
                      << ": the inherited entries are not applied";
     };
@@ -1220,6 +1227,11 @@ namespace pdflib
 
     LOG_S(INFO) << "embedded cmap: " << cmap_codespaces.size() << " codespace-range(s), "
                 << tables.code_to_cid.size() << " code-to-cid entries";
+
+    if(not inherits)
+      {
+        embedded_code_to_cid = std::move(tables.code_to_cid);
+      }
   }
 
   void pdf_resource<PAGE_FONT>::init_subtype()
@@ -1761,8 +1773,8 @@ namespace pdflib
         return false;
       }
 
-    // PDF spec: /CIDToGIDMap defaults to /Identity when absent. Any stream
-    // value means an explicit map that we do not resolve here.
+    // PDF spec: /CIDToGIDMap defaults to /Identity when absent. A stream is
+    // an explicit map, read by resolve_code_to_gid_map().
     QPDFObjectHandle value = qpdf_object::get_path(qpdf_desc_font, {"/CIDToGIDMap"});
     if(value.isNull())
       {
@@ -1773,6 +1785,83 @@ namespace pdflib
     return qpdf_object::get_name_or_string(value, name) and name == "/Identity";
   }
 
+  std::vector<uint16_t> pdf_resource<PAGE_FONT>::resolve_code_to_gid_map() const
+  {
+    std::vector<uint16_t> map;
+
+    // Only a CIDFontType2 (TrueType) program is addressed by GID through
+    // /CIDToGIDMap (ISO 32000-1, 9.7.4.2); CFF CIDFonts map through their
+    // own charset.
+    std::string desc_subtype;
+    QPDFObjectHandle value = qpdf_object::get_path(qpdf_desc_font, {"/CIDToGIDMap"});
+    if(subtype != TYPE_0 or not value.isStream() or
+       not qpdf_object::get_name_or_string(qpdf_desc_font, {"/Subtype"}, desc_subtype) or
+       desc_subtype != "/CIDFontType2")
+      {
+        return map;
+      }
+
+    try
+      {
+        auto buffer = value.getStreamData(qpdf_dl_all);
+        if(buffer)
+          {
+            // 2 bytes per CID, big-endian GID; CID n at bytes 2n..2n+1
+            const unsigned char* data = buffer->getBuffer();
+            map.resize(buffer->getSize() / 2);
+            for(size_t cid = 0; cid < map.size(); cid++)
+              {
+                map[cid] = static_cast<uint16_t>((data[2*cid] << 8) | data[2*cid + 1]);
+              }
+          }
+      }
+    catch(const std::exception& e)
+      {
+        LOG_S(WARNING) << "could not decode /CIDToGIDMap for font-key="
+                       << font_key << ": " << e.what();
+        map.clear();
+      }
+
+    // The renderer holds character codes, and the map is indexed by CID:
+    // compose it with the /Encoding CMap's code -> CID (9.7.6.2). Under
+    // Identity-H/V the code is the CID already.
+    if(map.empty() or encoding == IDENTITY_H or encoding == IDENTITY_V)
+      {
+        return map;
+      }
+
+    const std::unordered_map<uint32_t, uint32_t>* code_to_cid = nullptr;
+    if(encoding == CMAP_STREAM)
+      {
+        code_to_cid = &embedded_code_to_cid;
+      }
+    else if(encoding == CMAP_RESOURCES and cids.decode_cmap_resource(encoding_name))
+      {
+        code_to_cid = &cids.get(encoding_name).get_code_to_cid();
+      }
+
+    // Without a code -> CID table the map cannot be applied: an empty result
+    // keeps the Unicode-shaping path.
+    if(code_to_cid == nullptr)
+      {
+        return {};
+      }
+
+    // shortcut: codes above 0xFFFF (four-byte codespaces) are left unmapped
+    // and render through Unicode shaping; widen the table if one ever matters.
+    std::vector<uint16_t> code_to_gid;
+    for(const auto& [code, cid] : *code_to_cid)
+      {
+        if(code <= 0xFFFF and cid < map.size() and map[cid] != 0)
+          {
+            if(code >= code_to_gid.size()) { code_to_gid.resize(code + 1, 0); }
+            code_to_gid[code] = map[cid];
+          }
+      }
+
+    return code_to_gid;
+  }
+
   void pdf_resource<PAGE_FONT>::build_embedded_font_blob()
   {
     if(not font_program.found or
@@ -1813,7 +1902,8 @@ namespace pdflib
       subtype == TYPE_0,
       resolve_cid_to_gid_identity(),
       uses_builtin_encoding,
-      std::move(bytes));
+      std::move(bytes),
+      resolve_code_to_gid_map());
 
     LOG_S(INFO) << __FUNCTION__
                 << ": font-key=" << font_key
@@ -1824,6 +1914,7 @@ namespace pdflib
                 << " cache-key=" << font_blob->get_cache_key()
                 << " cid=" << font_blob->get_is_cid_font()
                 << " cid-to-gid-identity=" << font_blob->get_cid_to_gid_identity()
+                << " has-code-to-gid=" << font_blob->has_code_to_gid()
                 << " uses-builtin-encoding=" << font_blob->get_uses_builtin_encoding();
   }