Update docos.

Fix static library build commands - remove archive before building it fresh.

.github/codeql.yml

@@ -0,0 +1,22 @@
+paths-ignore:
+  - testpdfio.c
+
+query-filters:
+  - exclude:
+      id: cpp/commented-out-code
+  - exclude:
+      id: cpp/toctou-race-condition
+  - exclude:
+      id: cpp/weak-cryptographic-algorithm
+  - exclude:
+      id: cpp/world-writable-file-creation
+  - exclude:
+      id: cpp/uncontrolled-allocation-size
+  - exclude:
+      id: cpp/path-injection
+  - exclude:
+      id: cpp/stack-address-escape
+  - exclude:
+      id: cpp/loop-variable-changed
+  - exclude:
+      id: cpp/long-switch

.github/workflows/build.yml

@@ -9,23 +9,26 @@ on:
 jobs:
   build-linux:
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: update build environment
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Update Build Environment
       run: sudo apt-get update --fix-missing -y
-    - name: install prerequisites
+    - name: Install Prerequisites
       run: sudo apt-get install -y cppcheck zlib1g-dev
-    - name: make
+    - name: Configure PDFio
+      run: ./configure --enable-debug --enable-sanitizer --enable-maintainer
+    - name: Build PDFio
       run: make "COMMONFLAGS=-g -fsanitize=address"
-    - name: test
+    - name: Test PDFio
       env:
         ASAN_OPTIONS: leak_check_at_exit=false
       run: make test
-    - name: clang static analyzer
+    - name: Run Clang Static Analyzer
       run: make CC=clang "GHA_ERROR=::error::" clang
-    - name: cppcheck
+    - name: Run cppcheck
       run: make "GHA_ERROR=::error::" cppcheck
 
   build-macos:
@@ -33,12 +36,15 @@ jobs:
     runs-on: macos-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: make
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Configure PDFio
+      run: ./configure --enable-debug --enable-sanitizer --enable-maintainer
+    - name: Build PDFio
       run: make "COMMONFLAGS=-g -fsanitize=address"
-    - name: test
+    - name: Test PDFio
       run: make test
-    - name: clang static analyzer
+    - name: Run Clang Static Analyzer
       run: make CC=clang "GHA_ERROR=::error::" clang
 
   build-windows:
@@ -46,10 +52,11 @@ jobs:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: setup-msbuild
+    - name: Checkout PDFio sources
+      uses: actions/checkout@v4
+    - name: Setup MSBuild
       uses: microsoft/setup-msbuild@v1.0.2
-    - name: nuget restore
+    - name: Nuget Restore
       run: nuget restore pdfio.sln
-    - name: msbuild
+    - name: Build PDFio
       run: msbuild pdfio.sln

.github/workflows/codeql.yml

@@ -0,0 +1,50 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: "46 3 * * 0"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ cpp ]
+
+    steps:
+      - name: Checkout PDFio sources
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Update Build Environment
+        run: sudo apt-get update --fix-missing -y
+
+      - name: Install Prerequisites
+        run: sudo apt-get install -y zlib1g-dev
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          config-file: ./.github/codeql.yml
+          queries: +security-and-quality
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{ matrix.language }}"

.github/workflows/coverity.yml

@@ -7,10 +7,11 @@ jobs:
     runs-on: ubuntu-latest
     environment: Coverity
     steps:
-      - uses: actions/checkout@v2
-      - name: update build environment
+      - name: Checkout PDFio sources
+        uses: actions/checkout@v4
+      - name: Update Build Environment
         run: sudo apt-get update --fix-missing -y
-      - name: install prerequisites
+      - name: Install Prerequisites
         run: sudo apt-get install -y zlib1g-dev
       - name: Download Coverity Build Tool
         run: |
@@ -20,11 +21,15 @@ jobs:
         env:
           TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
 
-      - name: Build with cov-build
+      - name: Configure PDFio
+        run: ./configure --enable-debug --enable-maintainer
+
+      - name: Build PDFio with cov-build
         run: |
           export PATH=`pwd`/cov-analysis-linux64/bin:$PATH
           cov-build --dir cov-int make
-      - name: Submit the result to Coverity Scan
+
+      - name: Submit the Result to Coverity Scan
         run: |
           tar czvf cov.tgz cov-int
           curl \

.gitignore

@@ -5,10 +5,18 @@
 *.so.1
 /.vs
 /afl-output
+/autom4te.cache
+/config.log
+/config.status
 /doc/pdfio.epub
+/Makefile
 /packages
+/pdfio.pc
 /pdfio.xcodeproj/xcshareddata
+/pdfio-*.tar.gz*
+/pdfio-*.zip*
 /pdfiototext
 /testpdfio
 /testpdfio-*.pdf
+/testttf
 /x64

.lgtm.yml

@@ -1,2 +0,0 @@
-queries:
-  - exclude: cpp/toctou-race-condition

CHANGES.md

@@ -2,9 +2,87 @@ Changes in PDFio
 ================
 
 
-v1.0.1 (Month DD, YYYY)
+v1.2.0 (January 24, 2024)
+-------------------------
+
+- Now use autoconf to configure the PDFio sources (Issue #54)
+- Added `pdfioFileCreateNumberObj` and `pdfioFileCreateStringObj` functions
+  (Issue #14)
+- Added `pdfioContentTextMeasure` function (Issue #17)
+- Added `pdfioContentTextNewLineShow` and `pdfioContentTextNewLineShowf`
+  functions (Issue #24)
+- Renamed `pdfioContentTextNextLine` to `pdfioContentTextNewLine`.
+- Updated the maximum number of object streams in a single file from 4096 to
+  8192 (Issue #58)
+- Updated the token reading code to protect against some obvious abuses of the
+  PDF format.
+- Updated the xref reading code to protect against loops.
+- Updated the object handling code to use a binary insertion algorithm -
+  provides a significant (~800x) improvement in open times.
+- Fixed handling of encrypted PDFs with per-object file IDs (Issue #42)
+- Fixed handling of of trailer dictionaries that started immediately after the
+  "trailer" keyword (Issue #58)
+- Fixed handling of invalid, but common, PDF files with a generation number of
+  65536 in the xref table (Issue #59)
+
+
+v1.1.4 (December 3, 2023)
+-------------------------
+
+- Fixed detection of encrypted strings that are too short (Issue #52)
+- Fixed a TrueType CMAP decoding bug.
+- Fixed a text rendering issue for Asian text.
+- Added a ToUnicode map for Unicode text to support text copying.
+
+
+v1.1.3 (November 15, 2023)
+--------------------------
+
+- Fixed Unicode font support (Issue #16)
+- Fixed missing initializer for 40-bit RC4 encryption (Issue #51)
+
+
+v1.1.2 (October 10, 2023)
+-------------------------
+
+- Updated `pdfioContentSetDashPattern` to support setting a solid (0 length)
+  dash pattern (Issue #41)
+- Fixed an issue with broken PDF files containing extra CR and/or LF separators
+  after the object stream token (Issue #40)
+- Fixed an issue with PDF files produced by Crystal Reports (Issue #45)
+- Fixed an issue with PDF files produced by Microsoft Reporting Services
+  (Issue #46)
+- Fixed support for compound filters where the filter array consists of a
+  single named filter (Issue #47)
+- Fixed builds on Windows - needed windows.h header for temporary files
+  (Issue #48)
+
+
+v1.1.1 (March 20, 2023)
 -----------------------
 
+- CVE-2023-28428: Fixed a potential denial-of-service with corrupt PDF files.
+- Fixed a few build issues.
+
+
+v1.1.0 (February 6, 2023)
+-------------------------
+
+- CVE-2023-24808: Fixed a potential denial-of-service with corrupt PDF files.
+- Added `pdfioFileCreateTemporary` function (Issue #29)
+- Added `pdfioDictIterateKeys` function (Issue #31)
+- Added `pdfioContentPathEnd` function.
+- Added protection against opening multiple streams in the same file at the
+  same time.
+- Documentation updates (Issue #37)
+- Fixed "install-shared" target (Issue #32)
+- Fixed `pdfioFileGet...` metadata APIs (Issue #33)
+- Fixed `pdfioContentMatrixRotate` function.
+
+
+v1.0.1 (March 2, 2022)
+----------------------
+
 - Added missing `pdfioPageGetNumStreams` and `pdfioPageOpenStream` functions.
 - Added demo pdfiototext utility.
 - Fixed bug in `pdfioStreamGetToken`.

CONTRIBUTING.md

@@ -43,14 +43,17 @@ Contents
 Build System
 ------------
 
-The build system uses a simple POSIX makefile to build a static or shared
-library.  To improve portability, makefiles *must not* make use of features
-unique to GNU make.  See the [Makefile Guidelines](#makefile-guidelines) section
-for a description of the allowed make features and makefile guidelines.
+The build system uses [GNU autoconf][AUTOCONF] to create a simple POSIX makefile
+to build static and/or shared libraries.  To improve portability, makefiles
+*must not* make use of features unique to GNU make.  See the
+[Makefile Guidelines](#makefile-guidelines) section for a description of the
+allowed make features and makefile guidelines.
 
 An Xcode project is provided for macOS/iOS developers, and a Visual Studio
 solution and projects for Windows developers.
 
+[AUTOCONF]: https://www.gnu.org/software/autoconf/
+
 
 Version Numbering
 -----------------
@@ -118,7 +121,7 @@ the source file and the copyright and licensing notice:
     //
     // Description of file contents.
     //
-    // Copyright YYYY by AUTHOR.
+    // Copyright © YYYY by AUTHOR.
     //
     // Licensed under Apache License v2.0.  See the file "LICENSE" for more
     // information.
@@ -330,7 +333,7 @@ typedef, for example:
 
 All constant names are uppercase with underscores between words, e.g.,
 `PDFIO_THIS_CONSTANT`, `PDFIO_THAT_CONSTANT`, etc.  Constants begin with the
-"PDFio\_" prefix to avoid conflicts with system constants.  Private constants
+"PDFIO\_" prefix to avoid conflicts with system constants.  Private constants
 start with an underscore, e.g., `_PDFIO_THIS_CONSTANT`,
 `_PDFIO_THAT_CONSTANT`, etc.
 
@@ -369,17 +372,19 @@ extensions MUST NOT be used.
 The following variables are defined in the makefile:
 
 - `AR`; the static library archiver command,
-- `ARFLAGS`; options for the static library archiver command,
+- `ARFLAGS`; options for the static library archiver,
 - `CC`; the C compiler command,
-- `CFLAGS`; options for the C compiler command,
+- `CFLAGS`; options for the C compiler,
 - `CODESIGN_IDENTITY`: the code signing identity,
-- `COMMONFLAGS`; common compiler optimization options,
+- `CPPFLAGS`; options for the C preprocessor,
 - `DESTDIR`/`DSTROOT`: the destination root directory when installing.
 - `DSO`; the shared library building command,
 - `DSOFLAGS`; options for the shared library building command,
-- `DSONAME`: the root name of the shared library
 - `LDFLAGS`; options for the linker,
+- `LIBPDFIO`: the name of the primary (shared or static) library
+- `LIBPDFIO_STATIC`: the name of the secondary (static) library
 - `LIBS`; libraries for all programs,
+- `OPTIM`; common compiler optimization options,
 - `prefix`; the installation prefix directory,
 - `RANLIB`; the static library indexing command,
 - `SHELL`; the sh (POSIX shell) command,
@@ -388,11 +393,7 @@ The following variables are defined in the makefile:
 The following standard targets are defined in the makefile:
 
 - `all`; creates the static library and unit test program.
-- `all-shared`; creates a shared library appropriate for the local system.
 - `clean`; removes all target programs libraries, documentation files, and
   object files,
-- `debug`: creates a clean build of the static library and unit test program
-  with debug printfs and the clang address sanitizer enabled.
 - `install`; installs all distribution files in their corresponding locations.
-- `install-shared`; same as `install` but also installs the shared library.
 - `test`; runs the unit test program, building it as needed.

Makefile

@@ -1,209 +0,0 @@
-#
-# Makefile for PDFio.
-#
-# Copyright © 2021-2022 by Michael R Sweet.
-#
-# Licensed under Apache License v2.0.  See the file "LICENSE" for more
-# information.
-#
-
-# POSIX makefile
-.POSIX:
-
-# Variables...
-AR		=	ar
-ARFLAGS		=	cr
-CC		=	cc
-CFLAGS		=
-CODESIGN_IDENTITY =	Developer ID
-COMMONFLAGS	=	-Os -g
-#COMMONFLAGS	=	-O0 -g -fsanitize=address
-CPPFLAGS	=	'-DPDFIO_VERSION="$(VERSION)"'
-DESTDIR		=	$(DSTROOT)
-DSO		=	cc
-DSOFLAGS	=
-DSONAME		=
-LDFLAGS		=
-LIBS		=	-lm -lz
-RANLIB		=	ranlib
-VERSION		=	1.0.1
-prefix		=	/usr/local
-
-
-# Base rules
-.SUFFIXES:	.c .h .o
-.c.o:
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(COMMONFLAGS) -c $<
-
-
-# Files
-PUBHEADERS	=	\
-			pdfio.h \
-			pdfio-content.h
-PUBOBJS		=	\
-			pdfio-aes.o \
-			pdfio-array.o \
-			pdfio-common.o \
-			pdfio-content.o \
-			pdfio-crypto.o \
-			pdfio-dict.o \
-			pdfio-file.o \
-			pdfio-md5.o \
-			pdfio-object.o \
-			pdfio-page.o \
-			pdfio-rc4.o \
-			pdfio-sha256.o \
-			pdfio-stream.o \
-			pdfio-string.o \
-			pdfio-token.o \
-			pdfio-value.o
-LIBOBJS		=	\
-			$(PUBOBJS) \
-			ttf.o
-OBJS		=	\
-			$(LIBOBJS) \
-			pdfiototext.o \
-			testpdfio.o
-TARGETS		=	\
-			$(DSONAME) \
-			libpdfio.a \
-			pdfiototext \
-			testpdfio
-
-
-# Make everything
-all:		$(TARGETS)
-
-all-shared:
-	if test `uname` = Darwin; then \
-		$(MAKE) DSONAME="libpdfio.1.dylib" -$(MAKEFLAGS) all; \
-	else \
-		$(MAKE) COMMONFLAGS="-g -Os -fPIC" DSONAME="libpdfio.so.1" -$(MAKEFLAGS) all; \
-	fi
-
-debug:
-	$(MAKE) -$(MAKEFLAGS) COMMONFLAGS="-g -fsanitize=address -DDEBUG=1" clean all
-
-macos:
-	$(MAKE) -$(MAKEFLAGS) COMMONFLAGS="-Os -mmacosx-version-min=10.14 -arch x86_64 -arch arm64" clean all
-
-
-# Clean everything
-clean:
-	rm -f $(TARGETS) $(OBJS)
-
-
-# Install everything
-install:	$(TARGETS)
-	-mkdir -p $(DESTDIR)$(prefix)/include
-	cp $(PUBHEADERS) $(DESTDIR)$(prefix)/include
-	-mkdir -p $(DESTDIR)$(prefix)/lib
-	cp libpdfio.a $(DESTDIR)$(prefix)/lib
-	$(RANLIB) $(DESTDIR)$(prefix)/lib/libpdfio.a
-	if test "x$(DSONAME)" = xlibpdfio.so.1; then \
-		cp $(DSONAME) $(DESTDIR)$(prefix)/lib; \
-		ln -sf libpdfio.so.1 $(DESTDIR)$(prefix)/lib/libpdfio.so; \
-	elif test "x$(DSONAME)" = xlibpdfio.1.dylib; then \
-		cp $(DSONAME) $(DESTDIR)$(prefix)/lib; \
-		codesign -s "$(CODESIGN_IDENTITY)" -o runtime --timestamp $(DESTDIR)$(prefix)/lib/libpdfio.1.dylib; \
-		ln -sf libpdfio.1.dylib $(DESTDIR)$(prefix)/lib/libpdfio.dylib; \
-	fi
-	-mkdir -p $(DESTDIR)$(prefix)/lib/pkgconfig
-	echo 'prefix="$(prefix)"' >$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	echo 'Version: $(VERSION)' >>$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	cat pdfio.pc.in >>$(DESTDIR)$(prefix)/lib/pkgconfig/pdfio.pc
-	-mkdir -p $(DESTDIR)$(prefix)/share/doc/pdfio
-	cp doc/pdfio.html doc/pdfio-512.png LICENSE NOTICE $(DESTDIR)$(prefix)/share/doc/pdfio
-	-mkdir -p $(DESTDIR)$(prefix)/share/man/man3
-	cp doc/pdfio.3 $(DESTDIR)$(prefix)/share/man/man3
-
-install-shared:
-	if test `uname` = Darwin; then \
-		$(MAKE) DSONAME="libpdfio.1.dylib" -$(MAKEFLAGS) install; \
-	else
-		$(MAKE) DSONAME="libpdfio.so.1" -$(MAKEFLAGS) install; \
-	fi
-
-
-# Test everything
-test:	testpdfio
-	./testpdfio
-
-valgrind:	testpdfio
-	valgrind --leak-check=full ./testpdfio
-
-
-# pdfio library
-libpdfio.a:		$(LIBOBJS)
-	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
-	$(RANLIB) $@
-
-libpdfio.so.1:		$(LIBOBJS)
-	$(CC) $(DSOFLAGS) $(COMMONFLAGS) -shared -o $@ -Wl,-soname,$@ $(LIBOBJS) $(LIBS)
-
-libpdfio.1.dylib:	$(LIBOBJS)
-	$(CC) $(DSOFLAGS) $(COMMONFLAGS) -dynamiclib -o $@ -install_name $(prefix)/lib/$@ -current_version $(VERSION) -compatibility_version 1.0 $(LIBOBJS) $(LIBS)
-
-
-# pdfio1.def (Windows DLL exports file...)
-#
-# I'd love to use __declspec(dllexport) but MS puts it before the function
-# declaration instead of after like everyone else, and it breaks Codedoc and
-# other tools I rely on...
-pdfio1.def: $(LIBOBJS) Makefile
-	echo Generating $@...
-	echo "LIBRARY pdfio1" >$@
-	echo "VERSION 1.0" >>$@
-	echo "EXPORTS" >>$@
-	nm $(LIBOBJS) 2>/dev/null | grep "T _" | awk '{print $$3}' | \
-		grep -v '^_ttf' | sed -e '1,$$s/^_//' | sort >>$@
-
-
-# pdfio text extraction (demo, doesn't handle a lot of things yet)
-pdfiototext:		pdfiototext.o libpdfio.a
-	$(CC) $(LDFLAGS) $(COMMONFLAGS) -o $@ pdfiototext.o libpdfio.a $(LIBS)
-
-
-# pdfio test program
-testpdfio:		testpdfio.o libpdfio.a
-	$(CC) $(LDFLAGS) $(COMMONFLAGS) -o $@ testpdfio.o libpdfio.a $(LIBS)
-
-
-# Dependencies
-$(OBJS):		pdfio.h pdfio-private.h Makefile
-pdfio-content.o:	pdfio-content.h ttf.h
-ttf.o:			ttf.h
-
-# Make documentation using Codedoc <https://www.msweet.org/codedoc>
-DOCFLAGS	=	\
-			--author "Michael R Sweet" \
-			--copyright "Copyright (c) 2021-2022 by Michael R Sweet" \
-			--docversion $(VERSION)
-
-.PHONY: doc
-doc:
-	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(VERSION)" $(PUBHEADERS) $(PUBOBJS:.o=.c) --body doc/pdfio.md --coverimage doc/pdfio-512.png pdfio.xml >doc/pdfio.html
-	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(VERSION)" --body doc/pdfio.md --coverimage doc/pdfio-epub.png pdfio.xml --epub doc/pdfio.epub
-	codedoc $(DOCFLAGS) --title "pdf read/write library" --man pdfio --section 3 --body doc/pdfio.md pdfio.xml >doc/pdfio.3
-	rm -f pdfio.xml
-
-
-# Fuzz-test the library <>
-.PHONY: afl
-afl:
-	$(MAKE) -$(MAKEFLAGS) CC="afl-clang-fast" COMMONFLAGS="-g" clean all
-	test afl-output || rm -rf afl-output
-	afl-fuzz -x afl-pdf.dict -i afl-input -o afl-output -V 600 -e pdf -t 5000 ./testpdfio @@
-
-
-# Analyze code with the Clang static analyzer <https://clang-analyzer.llvm.org>
-clang:
-	clang $(CPPFLAGS) --analyze $(OBJS:.o=.c) 2>clang.log
-	rm -rf $(OBJS:.o=.plist)
-	test -s clang.log && (echo "$(GHA_ERROR)Clang detected issues."; echo ""; cat clang.log; exit 1) || exit 0
-
-
-# Analyze code using Cppcheck <http://cppcheck.sourceforge.net>
-cppcheck:
-	cppcheck $(CPPFLAGS) --template=gcc --addon=cert.py --suppressions-list=.cppcheck $(OBJS:.o=.c) 2>cppcheck.log
-	test -s cppcheck.log && (echo "$(GHA_ERROR)Cppcheck detected issues."; echo ""; cat cppcheck.log; exit 1) || exit 0

Makefile.in

@@ -0,0 +1,260 @@
+#
+# Makefile for PDFio.
+#
+# Copyright © 2021-2023 by Michael R Sweet.
+#
+# Licensed under Apache License v2.0.  See the file "LICENSE" for more
+# information.
+#
+
+# POSIX makefile
+.POSIX:
+
+
+# Build silently
+.SILENT:
+
+
+# Version number...
+PDFIO_VERSION		=	@PDFIO_VERSION@
+PDFIO_VERSION_MAJOR	=	@PDFIO_VERSION_MAJOR@
+PDFIO_VERSION_MINOR	=	@PDFIO_VERSION_MINOR@
+
+
+# Programs and options...
+AR		=	@AR@
+ARFLAGS		=	@ARFLAGS@
+CC		=	@CC@
+CFLAGS		=	@CFLAGS@ $(CPPFLAGS) $(OPTIM) $(WARNINGS)
+CODE_SIGN	=	@CODE_SIGN@
+CODESIGN_IDENTITY =	-
+CPPFLAGS	=	@CPPFLAGS@
+CSFLAGS		=	-s "$(CODESIGN_IDENTITY)" @CSFLAGS@ --timestamp
+DSOFLAGS	=	@DSOFLAGS@ $(CFLAGS)
+INSTALL		=	@INSTALL@
+LDFLAGS		=	@LDFLAGS@ $(OPTIM)
+LIBS		=	@LIBS@ -lm
+LN		=	@LN@
+OPTIM		=	@OPTIM@
+RANLIB		=	@RANLIB@
+RM		=	@RM@ -f
+RMDIR		=	@RMDIR@
+SHELL		=	/bin/sh
+WARNINGS	=	@WARNINGS@
+
+
+# Targets
+LIBPDFIO	=	@LIBPDFIO@
+LIBPDFIO_STATIC	=	@LIBPDFIO_STATIC@
+
+
+# Directories...
+bindir		=	@bindir@
+datadir		=	@datadir@
+datarootdir	=	@datarootdir@
+exec_prefix	=	@exec_prefix@
+includedir	=	@includedir@
+infodir		=	@infodir@
+libdir		=	@libdir@
+libexecdir	=	@libexecdir@
+localstatedir	=	@localstatedir@
+mandir		=	@mandir@
+oldincludedir	=	@oldincludedir@
+prefix		=	@prefix@
+sbindir		=	@sbindir@
+sharedstatedir	=	@sharedstatedir@
+srcdir		=	@srcdir@
+sysconfdir	=	@sysconfdir@
+top_srcdir	=	@top_srcdir@
+
+BUILDROOT	=	$(DSTROOT)$(RPM_BUILD_ROOT)$(DESTDIR)
+
+
+# Build commands...
+.SUFFIXES:	.c .h .o
+.c.o:
+	echo Compiling $<...
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+
+# Files
+PUBHEADERS	=	\
+			pdfio.h \
+			pdfio-content.h
+PUBOBJS		=	\
+			pdfio-aes.o \
+			pdfio-array.o \
+			pdfio-common.o \
+			pdfio-content.o \
+			pdfio-crypto.o \
+			pdfio-dict.o \
+			pdfio-file.o \
+			pdfio-md5.o \
+			pdfio-object.o \
+			pdfio-page.o \
+			pdfio-rc4.o \
+			pdfio-sha256.o \
+			pdfio-stream.o \
+			pdfio-string.o \
+			pdfio-token.o \
+			pdfio-value.o
+LIBOBJS		=	\
+			$(PUBOBJS) \
+			ttf.o
+OBJS		=	\
+			$(LIBOBJS) \
+			pdfiototext.o \
+			testpdfio.o \
+			testttf.o
+TARGETS		=	\
+			$(LIBPDFIO) \
+			$(LIBPDFIO_STATIC) \
+			pdfiototext \
+			testpdfio \
+			testttf
+
+
+# Make everything
+all:		$(TARGETS)
+
+
+# Clean everything
+clean:
+	rm -f $(TARGETS) $(OBJS)
+
+
+# Install everything
+install:	$(TARGETS)
+	echo Installing header files to $(BUILDROOT)$(includedir)...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(includedir)
+	for file in $(PUBHEADERS); do \
+		$(INSTALL) -c -m 644 $$file $(BUILDROOT)$(includedir); \
+	done
+	echo Installing library files to $(BUILDROOT)$(libdir)...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(libdir)
+	if test "x$(LIBPDFIO_STATIC)" != x; then \
+		$(INSTALL) -c -m 644 $(LIBPDFIO_STATIC) $(BUILDROOT)$(libdir); \
+		$(RANLIB) $(BUILDROOT)$(libdir)/$(LIBPDFIO_STATIC); \
+	fi
+	if test "x$(LIBPDFIO)" = xlibpdfio.so.1; then \
+		$(INSTALL) -c -m 755 libpdfio.so.1 $(BUILDROOT)$(libdir); \
+		ln -sf libpdfio.so.1 $(BUILDROOT)$(libdir)/libpdfio.so; \
+	elif test "x$(LIBPDFIO)" = xlibpdfio.1.dylib; then \
+		$(INSTALL) -c -m 755 libpdfio.1.dylib $(BUILDROOT)$(libdir); \
+		codesign -s "$(CODESIGN_IDENTITY)" -o runtime --timestamp $(BUILDROOT)$(libdir)/libpdfio.1.dylib; \
+		ln -sf libpdfio.1.dylib $(BUILDROOT)$(libdir)/libpdfio.dylib; \
+	else \
+		$(INSTALL) -c -m 644 $(LIBPDFIO) $(BUILDROOT)$(libdir); \
+		$(RANLIB) $(BUILDROOT)$(libdir)/$(LIBPDFIO); \
+	fi
+	echo Installing pkg-config files to $(BUILDROOT)$(libdir)/pkgconfig...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(libdir)/pkgconfig
+	$(INSTALL) -c -m 644 pdfio.pc $(BUILDROOT)$(libdir)/pkgconfig
+	echo Installing documentation to $(BUILDROOT)$(datadir)/doc/pdfio...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(datadir)/doc/pdfio
+	for file in doc/pdfio.html doc/pdfio-512.png LICENSE NOTICE; do \
+		$(INSTALL) -c -m 644  $$file $(BUILDROOT)$(datadir)/doc/pdfio; \
+	done
+	echo Installing man page to $(BUILDROOT)$(mandir)/man3...
+	$(INSTALL) -d -m 755 $(BUILDROOT)$(mandir)/man3
+	$(INSTALL) -c -m 644 doc/pdfio.3 $(BUILDROOT)$(mandir)/man3
+
+
+# Test everything
+test:	testpdfio testttf
+	./testttf 2>test.log
+	./testpdfio 2>test.log
+
+valgrind:	testpdfio
+	valgrind --leak-check=full ./testpdfio
+
+
+# pdfio library
+libpdfio.a:		$(LIBOBJS)
+	echo Archiving $@...
+	$(RM) $@
+	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
+	$(RANLIB) $@
+
+libpdfio.so.1:		$(LIBOBJS)
+	echo Linking $@...
+	$(CC) $(DSOFLAGS) -shared -o $@ -Wl,-soname,$@ $(LIBOBJS) $(LIBS)
+
+libpdfio.1.dylib:	$(LIBOBJS)
+	echo Linking $@...
+	$(CC) $(DSOFLAGS) -dynamiclib -o $@ -install_name $(libdir)/$@ -current_version $(PDFIO_VERSION_MAJOR).$(PDFIO_VERSION_MINOR) -compatibility_version 1.0 $(LIBOBJS) $(LIBS)
+
+
+# pdfio1.def (Windows DLL exports file...)
+#
+# I'd love to use __declspec(dllexport) but MS puts it before the function
+# declaration instead of after like everyone else, and it breaks Codedoc and
+# other tools I rely on...
+pdfio1.def: $(LIBOBJS) Makefile
+	echo Generating $@...
+	echo "LIBRARY pdfio1" >$@
+	echo "VERSION $(PDFIO_VERSION_MAJOR).$(PDFIO_VERSION_MINOR)" >>$@
+	echo "EXPORTS" >>$@
+	nm $(LIBOBJS) 2>/dev/null | grep "T _" | awk '{print $$3}' | \
+		grep -v '^_ttf' | sed -e '1,$$s/^_//' | sort >>$@
+
+
+# pdfio text extraction (demo, doesn't handle a lot of things yet)
+pdfiototext:		pdfiototext.o libpdfio.a
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ pdfiototext.o libpdfio.a $(LIBS)
+
+
+# pdfio test program
+testpdfio:		testpdfio.o libpdfio.a
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ testpdfio.o libpdfio.a $(LIBS)
+
+
+# TTF test program
+testttf:	ttf.o testttf.o
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o testttf ttf.o testttf.o $(LIBS)
+
+
+# Dependencies
+$(OBJS):		pdfio.h pdfio-private.h Makefile
+pdfio-content.o:	pdfio-content.h ttf.h
+testttf.o:		ttf.h
+ttf.o:			ttf.h
+
+
+# Make documentation using Codedoc <https://www.msweet.org/codedoc>
+DOCFLAGS	=	\
+			--author "Michael R Sweet" \
+			--copyright "Copyright (c) 2021-2024 by Michael R Sweet" \
+			--docversion $(PDFIO_VERSION)
+
+.PHONY: doc
+doc:
+	echo Generating documentation...
+	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(PDFIO_VERSION)" $(PUBHEADERS) $(PUBOBJS:.o=.c) --body doc/pdfio.md --coverimage doc/pdfio-512.png pdfio.xml >doc/pdfio.html
+	codedoc $(DOCFLAGS) --title "PDFio Programming Manual v$(PDFIO_VERSION)" --body doc/pdfio.md --coverimage doc/pdfio-epub.png pdfio.xml --epub doc/pdfio.epub
+	codedoc $(DOCFLAGS) --title "pdf read/write library" --man pdfio --section 3 --body doc/pdfio.md pdfio.xml >doc/pdfio.3
+	rm -f pdfio.xml
+
+
+# Fuzz-test the library <https://lcamtuf.coredump.cx/afl/>
+.PHONY: afl
+afl:
+	$(MAKE) -$(MAKEFLAGS) CC="afl-clang-fast" COMMONFLAGS="-g" clean all
+	test afl-output || rm -rf afl-output
+	afl-fuzz -x afl-pdf.dict -i afl-input -o afl-output -V 600 -e pdf -t 5000 ./testpdfio @@
+
+
+# Analyze code with the Clang static analyzer <https://clang-analyzer.llvm.org>
+clang:
+	clang $(CPPFLAGS) --analyze $(OBJS:.o=.c) 2>clang.log
+	rm -rf $(OBJS:.o=.plist)
+	test -s clang.log && (echo "$(GHA_ERROR)Clang detected issues."; echo ""; cat clang.log; exit 1) || exit 0
+
+
+# Analyze code using Cppcheck <http://cppcheck.sourceforge.net>
+cppcheck:
+	cppcheck $(CPPFLAGS) --template=gcc --addon=cert.py --suppressions-list=.cppcheck $(OBJS:.o=.c) 2>cppcheck.log
+	test -s cppcheck.log && (echo "$(GHA_ERROR)Cppcheck detected issues."; echo ""; cat cppcheck.log; exit 1) || exit 0

NOTICE

@@ -1,6 +1,6 @@
 PDFio - PDF Read/Write Library
 
-Copyright © 2021 by Michael R Sweet.
+Copyright © 2021-2024 by Michael R Sweet.
 
 (Optional) Exceptions to the Apache 2.0 License:
 ================================================

README.md

@@ -3,10 +3,8 @@ pdfio - PDF Read/Write Library
 
 ![Version](https://img.shields.io/github/v/release/michaelrsweet/pdfio?include_prereleases)
 ![Apache 2.0](https://img.shields.io/github/license/michaelrsweet/pdfio)
-[![Build](https://github.com/michaelrsweet/pdfio/workflows/Build/badge.svg)](https://github.com/michaelrsweet/pdfio/actions/workflows/build.yml)
+[![Build Status](https://img.shields.io/github/workflow/status/michaelrsweet/pdfio/Build)](https://github.com/michaelrsweet/pdfio/actions/workflows/build.yml)
 [![Coverity Scan Status](https://img.shields.io/coverity/scan/22385.svg)](https://scan.coverity.com/projects/michaelrsweet-pdfio)
-[![LGTM Grade](https://img.shields.io/lgtm/grade/cpp/github/michaelrsweet/pdfio)](https://lgtm.com/projects/g/michaelrsweet/pdfio/context:cpp)
-[![LGTM Alerts](https://img.shields.io/lgtm/alerts/github/michaelrsweet/pdfio)](https://lgtm.com/projects/g/michaelrsweet/pdfio/)
 
 PDFio is a simple C library for reading and writing PDF files.  The primary
 goals of PDFio are:
@@ -30,7 +28,7 @@ PDFio requires the following to build the software:
 
 - A C99 compiler such as Clang, GCC, or MS Visual C
 - A POSIX-compliant `make` program
-- ZLIB (<https://www.zlib.net>) 1.0 or higher
+- ZLIB (<https://www.zlib.net>) 1.1 or higher
 
 IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 
@@ -38,15 +36,27 @@ IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 Documentation
 -------------
 
-See the man page (`pdfio.3`), frequently ask questions (`FAQ.md`), and full HTML
-documentation (`pdfio.html`) for information on using PDFio.
+See the man page (`pdfio.3`) and full HTML documentation (`pdfio.html`) for
+information on using PDFio.
 
 
-Installing pdfio
+Installing PDFio
 ----------------
 
-PDFio comes with a portable makefile that will work on any POSIX-compliant
-system with ZLIB installed.  To make it, run:
+PDFio uses a configure script on Unix systems to generate a makefile:
+
+    ./configure
+
+If you want a shared library, run:
+
+    ./configure --enable-shared
+
+The default installation location is "/usr/local".  Pass the `--prefix` option
+to make to install it to another location:
+
+    ./configure --prefix=/some/other/directory
+
+Once configured, run the following to make the library:
 
     make all
 
@@ -56,45 +66,7 @@ To test it, run:
 
 To install it, run:
 
-    make install
-
-If you want a shared library, run:
-
-    make all-shared
-    make install-shared
-
-The default installation location is "/usr/local".  Pass the `prefix` variable
-to make to install it to another location:
-
-    make install prefix=/some/other/directory
-
-The makefile installs the pdfio header to "${prefix}/include", the library to
-"${prefix}/lib", the `pkg-config` file to "${prefix}/lib/pkgconfig", the man
-page to "${prefix}/share/man/man3", and the documentation to
-"${prefix}/share/doc/pdfio".
-
-The makefile supports the following variables that can be specified in the make
-command or as environment variables:
-
-- `AR`: the library archiver (default "ar")
-- `ARFLAGS`: options for the library archiver (default "cr")
-- `CC`: the C compiler (default "cc")
-- `CFLAGS`: options for the C compiler (default "")
-- `CODESIGN_IDENTITY`: the identity to use when code signing the shared library
-  on macOS (default "Developer ID")
-- `COMMONFLAGS`: options for the C compiler and linker (typically architecture
-  and optimization options, default is "-Os -g")
-- `CPPFLAGS`: options for the C preprocessor (default "")
-- `DESTDIR` and `DSTROOT`: specifies a root directory when installing
-  (default is "", specify only one)
-- `DSOFLAGS`: options for the C compiler when linking the shared library
-  (default "")
-- `LDFLAGS`: options for the C compiler when linking the test programs
-  (default "")
-- `LIBS`: library options when linking the test programs (default "-lz")
-- `RANLIB`: program that generates a table-of-contents in a library
-  (default "ranlib")
-- `prefix`: specifies the installation directory (default "/usr/local")
+    sudo make install
 
 
 Visual Studio Project
@@ -113,15 +85,11 @@ generates a static library that will be installed under "/usr/local" with:
 
     sudo xcodebuild install
 
-You can reproduce this with the makefile using:
-
-    sudo make COMMONFLAGS="-Os -mmacosx-version-min=10.14 -arch x86_64 -arch arm64" install
-
 
 Legal Stuff
 -----------
 
-PDFio is Copyright © 2021 by Michael R Sweet.
+PDFio is Copyright © 2021-2024 by Michael R Sweet.
 
 This software is licensed under the Apache License Version 2.0 with an
 (optional) exception to allow linking against GPL2/LGPL2 software.  See the

SECURITY.md

@@ -5,6 +5,25 @@ This file describes how security issues are reported and handled, and what the
 expectations are for security issues reported to this project.
 
 
+Reporting a Security Bug
+------------------------
+
+For the purposes of this project, a security bug is a software defect that
+allows a *local or remote user* to gain unauthorized access or privileges on the
+host computer or to cause the software to crash.  Such defects should be
+reported to the project security advisory page at
+<https://github.com/michaelrsweet/pdfio/security/advisories>.
+
+Alternately, security bugs can be reported to "security AT msweet.org" using the
+PGP public key below.  Expect a response within 5 business days.  Any proposed
+embargo date should be at least 30 days and no more than 90 days in the future.
+
+> *Note:* If you've found a software defect that allows a *program* to gain
+> unauthorized access or privileges on the host computer or causes the program
+> to crash, that defect should be reported as an ordinary project issue at
+> <https://github.com/michaelrsweet/pdfio/issues>.
+
+
 Responsible Disclosure
 ----------------------
 
@@ -35,7 +54,7 @@ starting at 0.  A feature release has a "PATCH" value of 0, for example:
     1.1.0
     2.0.0
 
-Beta releases and release candidates are *not* prodution releases and use
+Beta releases and release candidates are *not* production releases and use
 semantic version numbers of the form:
 
     MAJOR.MINORbNUMBER
@@ -50,14 +69,6 @@ example:
     1.0rc1
 
 
-Reporting a Vulnerability
--------------------------
-
-Report all security issues to "security AT msweet.org".  Expect a response
-within 5 business days.  Any proposed embargo date should be at least 30 days
-and no more than 90 days in the future.
-
-
 PGP Public Key
 --------------
 

configure.ac

@@ -0,0 +1,273 @@
+dnl
+dnl Configuration script for PDFio
+dnl
+dnl Copyright © 2023-2024 by Michael R Sweet
+dnl
+dnl Licensed under Apache License v2.0.  See the file "LICENSE" for more
+dnl information.
+dnl
+
+dnl ***********************************************************************
+dnl
+dnl Note: Using autoheader or automake on this project will break the PDFio
+dnl build system.  Use "autoconf -f" to regenerate the configure script if
+dnl you make changes to this file.
+dnl
+dnl ***********************************************************************
+
+
+dnl We need at least autoconf 2.70 for --runstatedir...
+AC_PREREQ([2.70])
+
+
+dnl Package name and version...
+AC_INIT([pdfio], [1.2.0], [https://github.com/michaelrsweet/pdfio/issues], [pdfio], [https://www.msweet.org/pdfio])
+
+PDFIO_VERSION="AC_PACKAGE_VERSION"
+PDFIO_VERSION_MAJOR="`echo AC_PACKAGE_VERSION | awk -F. '{print $1}'`"
+PDFIO_VERSION_MINOR="`echo AC_PACKAGE_VERSION | awk -F. '{printf("%d\n",$2);}'`"
+AC_SUBST([PDFIO_VERSION])
+AC_SUBST([PDFIO_VERSION_MAJOR])
+AC_SUBST([PDFIO_VERSION_MINOR])
+
+
+dnl This line is provided to ensure that you don't run the autoheader program
+dnl against this project.  Doing so is completely unsupported and WILL cause
+dnl problems!
+AH_TOP([#error "Somebody ran autoheader on this project which is unsupported and WILL cause problems."])
+
+
+dnl Get the build and host platforms and split the host_os value
+AC_CANONICAL_BUILD
+AC_CANONICAL_HOST
+
+[host_os_name="$(echo $host_os | sed -e '1,$s/[0-9.]*$//g')"]
+[host_os_version="$(echo $host_os | sed -e '1,$s/^[^0-9.]*//g' | awk -F. '{print $1 $2}')"]
+# Linux often does not yield an OS version we can use...
+AS_IF([test "x$host_os_version" = x], [
+    host_os_version="0"
+])
+
+
+dnl Compiler options...
+CFLAGS="${CFLAGS:=}"
+CPPFLAGS="${CPPFLAGS:=}"
+DSOFLAGS="${DSOFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+LIBS="${LIBS:=}"
+OPTIM="${OPTIM:=}"
+
+AC_SUBST([DSOFLAGS])
+AC_SUBST([OPTIM])
+
+
+dnl Standard programs...
+AC_PROG_CC
+AC_PROG_RANLIB
+AC_PATH_PROG([AR], [ar])
+AC_PATH_PROGS([CODE_SIGN], [codesign true])
+AC_PATH_PROG([MKDIR], [mkdir])
+AC_PATH_PROG([RM], [rm])
+AC_PATH_PROG([RMDIR], [rmdir])
+AC_PATH_PROG([LN], [ln])
+
+
+dnl Figure out the correct "ar" command flags...
+AS_IF([test "$ac_cv_prog_ranlib" = ":"], [
+    ARFLAGS="crs"
+], [
+    ARFLAGS="cr"
+])
+AC_SUBST([ARFLAGS])
+
+
+dnl install-sh
+AC_MSG_CHECKING([for install-sh script])
+INSTALL="$(pwd)/install-sh"
+AC_SUBST([INSTALL])
+AC_MSG_RESULT([using $INSTALL])
+
+
+dnl Check for pkg-config, which is used for some other tests later on...
+AC_PATH_TOOL([PKGCONFIG], [pkg-config])
+
+PKGCONFIG_CFLAGS="-I\${includedir}"
+PKGCONFIG_LIBS="-L\${libdir} -lpdfio"
+PKGCONFIG_LIBS_PRIVATE="-lm"
+PKGCONFIG_REQUIRES="zlib"
+AC_SUBST([PKGCONFIG_CFLAGS])
+AC_SUBST([PKGCONFIG_LIBS])
+AC_SUBST([PKGCONFIG_LIBS_PRIVATE])
+AC_SUBST([PKGCONFIG_REQUIRES])
+
+
+dnl ZLIB
+AC_MSG_CHECKING([for zlib via pkg-config])
+AS_IF([$PKGCONFIG --exists zlib], [
+    AC_MSG_RESULT([yes])
+    CPPFLAGS="$($PKGCONFIG --cflags zlib) $CPPFLAGS"
+    LIBS="$($PKGCONFIG --libs zlib) $LIBS"
+],[
+    AC_MSG_RESULT([no])
+    AC_CHECK_HEADER([zlib.h])
+    AC_CHECK_LIB([z], [inflateCopy])
+
+    AS_IF([test x$ac_cv_header_zlib_h != xyes -o x$ac_cv_lib_z_inflateCopy != xyes], [
+	AC_MSG_ERROR([Sorry, this software requires zlib 1.1 or higher.])
+    ])
+
+    PKGCONFIG_REQUIRES=""
+    PKGCONFIG_LIBS_PRIVATE="-lz $PKGCONFIG_LIBS_PRIVATE"
+])
+
+
+dnl Library target...
+AC_ARG_ENABLE([static], AS_HELP_STRING([--disable-static], [do not install static library]))
+AC_ARG_ENABLE([shared], AS_HELP_STRING([--enable-shared], [install shared library]))
+
+AS_IF([test x$enable_shared = xyes], [
+    AS_IF([test "$host_os_name" = darwin], [
+	LIBPDFIO="libpdfio.1.dylib"
+    ], [
+	LIBPDFIO="libpdfio.so.1"
+    ])
+
+    AS_IF([test x$enable_static != xno], [
+        LIBPDFIO_STATIC="libpdfio.a"
+    ], [
+	LIBPDFIO_STATIC=""
+    ])
+], [
+    LIBPDFIO="libpdfio.a"
+    LIBPDFIO_STATIC=""
+    PKGCONFIG_LIBS="$PKGCONFIG_LIBS $PKGCONFIG_LIBS_PRIVATE"
+    PKGCONFIG_LIBS_PRIVATE=""
+])
+
+AC_SUBST([LIBPDFIO])
+AC_SUBST([LIBPDFIO_STATIC])
+
+
+dnl Extra compiler options...
+AC_ARG_ENABLE([debug], AS_HELP_STRING([--enable-debug], [turn on debugging, default=no]))
+AC_ARG_ENABLE([maintainer], AS_HELP_STRING([--enable-maintainer], [turn on maintainer mode, default=no]))
+AC_ARG_ENABLE([sanitizer], AS_HELP_STRING([--enable-sanitizer], [build with AddressSanitizer, default=no]))
+
+AS_IF([test x$enable_debug = xyes], [
+    OPTIM="$OPTIM -g"
+    CSFLAGS=""
+], [
+    OPTIM="$OPTIM -g -Os"
+    CSFLAGS="-o runtime"
+])
+
+AC_SUBST([CSFLAGS])
+
+WARNINGS=""
+AC_SUBST([WARNINGS])
+
+AS_IF([test -n "$GCC"], [
+    AS_IF([test x$enable_sanitizer = xyes], [
+	# Use -fsanitize=address with debugging...
+	OPTIM="$OPTIM -fsanitize=address"
+    ], [
+	# Otherwise use the Fortify enhancements to catch any unbounded
+	# string operations...
+	CPPFLAGS="$CPPFLAGS -D_FORTIFY_SOURCE=2"
+    ])
+
+    dnl Show all standard warnings + unused variables when compiling...
+    WARNINGS="-Wall -Wunused"
+
+    dnl Drop some not-useful/unreliable warnings...
+    for warning in char-subscripts format-truncation format-y2k switch unused-result; do
+	AC_MSG_CHECKING([whether compiler supports -Wno-$warning])
+
+	OLDCFLAGS="$CFLAGS"
+	CFLAGS="$CFLAGS -Wno-$warning -Werror"
+
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [
+	    AC_MSG_RESULT(yes)
+	    WARNINGS="$WARNINGS -Wno-$warning"
+        ], [
+	    AC_MSG_RESULT(no)
+	])
+
+	CFLAGS="$OLDCFLAGS"
+    done
+
+    dnl Maintainer mode enables -Werror...
+    AS_IF([test x$enable_maintainer = xyes], [
+	WARNINGS="$WARNINGS -Werror -Wno-error=deprecated"
+    ])
+
+    dnl See if PIE options are supported...
+    AC_MSG_CHECKING(whether compiler supports -fPIE)
+    OLDCFLAGS="$CFLAGS"
+    AS_CASE(["$host_os_name"],
+    [darwin*], [
+	CFLAGS="$CFLAGS -fPIC -fPIE -Wl,-pie"
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[
+	    OLDCFLAGS="-fPIC $OLDCFLAGS"
+	    LDFLAGS="-fPIE -Wl,-pie $LDFLAGS"
+	    AC_MSG_RESULT(yes)
+	],[
+	    AC_MSG_RESULT(no)
+	])
+    ], [*], [
+	CFLAGS="$CFLAGS -fPIC -fPIE -pie"
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[
+	    OLDCFLAGS="-fPIC $OLDCFLAGS"
+	    LDFLAGS="-fPIE -pie $LDFLAGS"
+	    AC_MSG_RESULT(yes)
+	],[
+	    AC_MSG_RESULT(no)
+	])
+    ])
+    CFLAGS="$OLDCFLAGS"
+
+    dnl OS-specific compiler options...
+    AC_MSG_CHECKING([for OS-specific compiler options])
+    AS_CASE(["$host_os_name"], [linux*], [
+    	# Make sure we get the full set of 64-bit Linux APIs from the headers...
+	CPPFLAGS="$CPPFLAGS -D__USE_MISC -D_GNU_SOURCE -D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64"
+
+	# Mark read-only sections as relocatable to random addresses...
+	LDFLAGS="$LDFLAGS -Wl,-z,relro,-z,now"
+
+        AC_MSG_RESULT([-D__USE_MISC -D_GNU_SOURCE -D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64 -Wl,-z,relro,-z,now])
+    ], [darwin*], [
+        # When not building for debug, target macOS 11 or later, "universal"
+        # binaries when possible...
+        AS_IF([echo "$CPPFLAGS $CFLAGS $LDFLAGS $OPTIM" | grep -q "\\-arch "], [
+            # Don't add architecture/min-version flags if they are already present
+            AC_MSG_RESULT([none])
+        ], [echo "$CPPFLAGS $CFLAGS $LDFLAGS $OPTIM" | grep -q "\\-mmacosx-version-"], [
+            # Don't add architecture/min-version flags if they are already present
+            AC_MSG_RESULT([none])
+        ], [test "$host_os_version" -ge 200 -a x$enable_debug != xyes], [
+	    # macOS 11.0 and higher support the Apple Silicon (arm64) CPUs
+	    OPTIM="$OPTIM -mmacosx-version-min=11.0 -arch x86_64 -arch arm64"
+            AC_MSG_RESULT([-mmacosx-version-min=11.0 -arch x86_64 -arch arm64])
+	], [
+	    # Don't add architecture/min-version flags if debug enabled
+            AC_MSG_RESULT([none])
+	])
+    ], [*], [
+        AC_MSG_RESULT([none])
+    ])
+])
+
+
+dnl Extra linker options...
+AC_ARG_WITH([dsoflags], AS_HELP_STRING([--with-dsoflags=...], [Specify additional DSOFLAGS]), [
+    DSOFLAGS="$withval $DSOFLAGS"
+])
+AC_ARG_WITH([ldflags], AS_HELP_STRING([--with-ldflags=...], [Specify additional LDFLAGS]), [
+    LDFLAGS="$withval $LDFLAGS"
+])
+
+
+dnl Generate the Makefile and pkg-config file...
+AC_CONFIG_FILES([Makefile pdfio.pc])
+AC_OUTPUT

doc/pdfio.3

@@ -1,4 +1,4 @@
-.TH pdfio 3 "pdf read/write library" "2022-03-02" "pdf read/write library"
+.TH pdfio 3 "pdf read/write library" "2024-01-24" "pdf read/write library"
 .SH NAME
 pdfio \- pdf read/write library
 .SH Introduction
@@ -34,7 +34,7 @@ PDFio is
 .I not
  concerned with rendering or viewing a PDF file, although a PDF RIP or viewer could be written using it.
 .PP
-PDFio is Copyright \[co] 2021\-2022 by Michael R Sweet and is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GPL2/LGPL2 software. See the files "LICENSE" and "NOTICE" for more information.
+PDFio is Copyright \[co] 2021\-2024 by Michael R Sweet and is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GPL2/LGPL2 software. See the files "LICENSE" and "NOTICE" for more information.
 .SS Requirements
 .PP
 PDFio requires the following to build the software:
@@ -46,6 +46,10 @@ A C99 compiler such as Clang, GCC, or MS Visual C
 .PP
 A POSIX\-compliant make program
 
+.IP \(bu 5
+.PP
+A POSIX\-compliant sh program
+
 .IP \(bu 5
 .PP
 ZLIB (https://www.zlib.net) 1.0 or higher
@@ -55,10 +59,11 @@ ZLIB (https://www.zlib.net) 1.0 or higher
 IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 .SS Installing pdfio
 .PP
-PDFio comes with a portable makefile that will work on any POSIX\-compliant system with ZLIB installed. To make it, run:
+PDFio comes with a configure script that creates a portable makefile that will work on any POSIX\-compliant system with ZLIB installed. To make it, run:
 .nf
 
-    make all
+    \./configure
+    make
 .fi
 .PP
 To test it, run:
@@ -70,78 +75,28 @@ To test it, run:
 To install it, run:
 .nf
 
-    make install
+    sudo make install
 .fi
 .PP
 If you want a shared library, run:
 .nf
 
-    make all\-shared
-    make install\-shared
+    \./configure \-\-enable\-shared
+    make
+    sudo make install
 .fi
 .PP
-The default installation location is "/usr/local". Pass the prefix variable to make to install it to another location:
+The default installation location is "/usr/local". Pass the \-\-prefix option to make to install it to another location:
 .nf
 
-    make install prefix=/some/other/directory
+    \./configure \-\-prefix=/some/other/directory
 .fi
 .PP
-The makefile installs the pdfio header to "${prefix}/include", the library to "${prefix}/lib", the pkg\-config file to "${prefix}/lib/pkgconfig", the man page to "${prefix}/share/man/man3", and the documentation to "${prefix}/share/doc/pdfio".
-.PP
-The makefile supports the following variables that can be specified in the make command or as environment variables:
-.IP \(bu 5
-.PP
-AR: the library archiver (default "ar")
-
-.IP \(bu 5
-.PP
-ARFLAGS: options for the library archiver (default "cr")
-
-.IP \(bu 5
-.PP
-CC: the C compiler (default "cc")
-
-.IP \(bu 5
-.PP
-CFLAGS: options for the C compiler (default "")
-
-.IP \(bu 5
-.PP
-CODESIGN_IDENTITY: the identity to use when code signing the shared library on macOS (default "Developer ID")
-
-.IP \(bu 5
-.PP
-COMMONFLAGS: options for the C compiler and linker (typically architecture and optimization options, default is "\-Os \-g")
-
-.IP \(bu 5
-.PP
-CPPFLAGS: options for the C preprocessor (default "")
-
-.IP \(bu 5
-.PP
-DESTDIR and DSTROOT: specifies a root directory when installing (default is "", specify only one)
-
-.IP \(bu 5
-.PP
-DSOFLAGS: options for the C compiler when linking the shared library (default "")
-
-.IP \(bu 5
-.PP
-LDFLAGS: options for the C compiler when linking the test programs (default "")
-
-.IP \(bu 5
-.PP
-LIBS: library options when linking the test programs (default "\-lz")
-
-.IP \(bu 5
-.PP
-RANLIB: program that generates a table\-of\-contents in a library (default "ranlib")
-
-.IP \(bu 5
-.PP
-prefix: specifies the installation directory (default "/usr/local")
-
+Other configure options can be found using the \-\-help option:
+.nf
 
+    \./configure \-\-help
+.fi
 .SS Visual Studio Project
 .PP
 The Visual Studio solution ("pdfio.sln") is provided for Windows developers and generates both a static library and DLL.
@@ -152,12 +107,6 @@ There is also an Xcode project ("pdfio.xcodeproj") you can use on macOS which ge
 
     sudo xcodebuild install
 .fi
-.PP
-You can reproduce this with the makefile using:
-.nf
-
-    sudo make macos install
-.fi
 .SS Detecting PDFio
 .PP
 PDFio can be detected using the pkg\-config command, for example:
@@ -218,10 +167,25 @@ pdfio_stream_t: An object stream
 You open an existing PDF file using the pdfioFileOpen function:
 .nf
 
-    pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", error_cb, error_data);
+    pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", password_cb, password_data,
+                                      error_cb, error_data);
 .fi
 .PP
-where the three arguments to the function are the filename ("myinputfile.pdf"), an optional error callback function (error_cb), and an optional pointer value for the error callback function (error_data). The error callback is called for both errors and warnings and accepts the pdfio_file_t pointer, a message string, and the callback pointer value, for example:
+where the five arguments to the function are the filename ("myinputfile.pdf"), an optional password callback function (password_cb) and data pointer value (password_data), and an optional error callback function (error_cb) and data pointer value (error_data). The password callback is called for encrypted PDF files that are not using the default password, for example:
+.nf
+
+    const char *
+    password_cb(void *data, const char *filename)
+    {
+      (void)data;     // This callback doesn't use the data pointer
+      (void)filename; // This callback doesn't use the filename
+    
+      // Return a password string for the file...
+      return ("Password42");
+    }
+.fi
+.PP
+The error callback is called for both errors and warnings and accepts the pdfio_file_t pointer, a message string, and the callback pointer value, for example:
 .nf
 
     bool
@@ -400,7 +364,7 @@ The PDF content helper functions provide additional functions for writing specif
 When you are done writing the stream, call pdfioStreamCLose to close both the stream and the object.
 .SS PDF Content Helper Functions
 .PP
-PDFio includes many helper functions for embedding or writing specific kinds of content to a PDF file. These functions can be roughly grouped into ??? categories:
+PDFio includes many helper functions for embedding or writing specific kinds of content to a PDF file. These functions can be roughly grouped into five categories:
 .IP \(bu 5
 .PP
 Color Space Functions
@@ -552,6 +516,7 @@ will embed an OpenSans Regular TrueType font using the Windows CP1252 subset of
 will embed the NotoSansJP Regular OpenType font with full support for Unicode.
 .PP
 Note: Not all fonts support Unicode.
+
 .PP
 Image Object Functions
 .PP
@@ -799,7 +764,15 @@ pdfioContentTextMoveTo moves within the current line in a text block
 
 .IP \(bu 5
 .PP
-pdfioContentTextNextLine moves to the beginning of the next line in a text block
+pdfioContentTextNewLine moves to the beginning of the next line in a text block
+
+.IP \(bu 5
+.PP
+pdfioContentTextNewLineShow moves to the beginning of the next line in a text block and shows literal text with optional word and character spacing
+
+.IP \(bu 5
+.PP
+pdfioContentTextNewLineShowf moves to the beginning of the next line in a text block and shows formatted text with optional word and character spacing
 
 .IP \(bu 5
 .PP
@@ -839,7 +812,7 @@ PDFIO_ENCRYPTION_AES_128
 .TP 5
 PDFIO_ENCRYPTION_AES_256
 .br
-256-bit AES encryption (PDF 2.0)
+256-bit AES encryption (PDF 2.0) 
 .TP 5
 PDFIO_ENCRYPTION_NONE
 .br
@@ -1357,7 +1330,7 @@ bool  pdfioContentFillAndStroke (
 .fi
 .SS pdfioContentMatrixConcat
 Concatenate a matrix to the current graphics
-state.
+                               state.
 .PP
 .nf
 bool  pdfioContentMatrixConcat (
@@ -1440,6 +1413,14 @@ bool  pdfioContentPathCurve23 (
     double y3
 );
 .fi
+.SS pdfioContentPathEnd
+Clear the current path.
+.PP
+.nf
+bool  pdfioContentPathEnd (
+    pdfio_stream_t *st
+);
+.fi
 .SS pdfioContentPathLineTo
 Add a straight line to the current path.
 .PP
@@ -1499,6 +1480,9 @@ bool  pdfioContentSetDashPattern (
     double off
 );
 .fi
+.PP
+This function sets the stroke pattern when drawing lines.  If "on" and "off"
+are 0, a solid line is drawn.
 .SS pdfioContentSetFillColorDeviceCMYK
 Set device CMYK fill color.
 .PP
@@ -1763,6 +1747,20 @@ bool  pdfioContentTextEnd (
     pdfio_stream_t *st
 );
 .fi
+.SS pdfioContentTextMeasure
+Measure a text string and return its width.
+.PP
+.nf
+double  pdfioContentTextMeasure (
+    pdfio_obj_t *font,
+    const char *s,
+    double size
+);
+.fi
+.PP
+This function measures the given text string "s" and returns its width based
+on "size". The text string must always use the UTF-8 (Unicode) encoding but
+any control characters (such as newlines) are ignored.
 .SS pdfioContentTextMoveLine
 Move to the next line and offset.
 .PP
@@ -1783,14 +1781,49 @@ bool  pdfioContentTextMoveTo (
     double ty
 );
 .fi
-.SS pdfioContentTextNextLine
+.SS pdfioContentTextNewLine
 Move to the next line.
 .PP
 .nf
-bool  pdfioContentTextNextLine (
+bool  pdfioContentTextNewLine (
     pdfio_stream_t *st
 );
 .fi
+.SS pdfioContentTextNewLineShow
+Move to the next line and show text.
+.PP
+.nf
+bool  pdfioContentTextNewLineShow (
+    pdfio_stream_t *st,
+    double ws,
+    double cs,
+    bool unicode,
+    const char *s
+);
+.fi
+.PP
+This function moves to the next line and then shows some text with optional
+word and character spacing in a PDF content stream. The "unicode" argument
+specifies that the current font maps to full Unicode.  The "s" argument
+specifies a UTF-8 encoded string.
+.SS pdfioContentTextNewLineShowf
+Show formatted text.
+.PP
+.nf
+bool  pdfioContentTextNewLineShowf (
+    pdfio_stream_t *st,
+    double ws,
+    double cs,
+    bool unicode,
+    const char *format,
+    ...
+);
+.fi
+.PP
+This function moves to the next line and shows some formatted text with
+optional word and character spacing in a PDF content stream. The "unicode"
+argument specifies that the current font maps to full Unicode.  The "format"
+argument specifies a UTF-8 encoded \fBprintf\fR-style format string.
 .SS pdfioContentTextShow
 Show text.
 .PP
@@ -1950,6 +1983,32 @@ pdfio_valtype_t  pdfioDictGetType (
     const char *key
 );
 .fi
+.SS pdfioDictIterateKeys
+Iterate the keys in a dictionary.
+.PP
+.nf
+void pdfioDictIterateKeys (
+    pdfio_dict_t *dict,
+    pdfio_dict_cb_t cb,
+    void *cb_data
+);
+.fi
+.PP
+This function iterates the keys in a dictionary, calling the supplied
+function "cb":
+.PP
+.nf
+    bool
+    my_dict_cb(pdfio_dict_t *dict, const char *key, void *cb_data)
+    {
+    ... "key" contains the dictionary key ...
+    ... return true to continue or false to stop ...
+    }
+
+.fi
+
+The iteration continues as long as the callback returns \fBtrue\fR or all keys
+have been iterated.
 .SS pdfioDictSetArray
 Set a key array in a dictionary.
 .PP
@@ -2239,6 +2298,18 @@ Note: Currently PNG support is limited to grayscale, RGB, or indexed files
 without interlacing or alpha.  Transparency (masking) based on color/index
 .IP 5
 is supported.
+.SS pdfioFileCreateNumberObj
+Create a new object in a PDF file containing a number.
+.PP
+.nf
+pdfio_obj_t * pdfioFileCreateNumberObj (
+    pdfio_file_t *pdf,
+    double number
+);
+.fi
+.PP
+This function creates a new object with a number value in a PDF file.
+You must call \fIpdfioObjClose\fR to write the object to the file.
 .SS pdfioFileCreateObj
 Create a new object in a PDF file.
 .PP
@@ -2272,10 +2343,11 @@ written:
     ssize_t
     output_cb(void *output_ctx, const void *buffer, size_t bytes)
     {
-    // Write buffer to output and return the number of bytes written
+      // Write buffer to output and return the number of bytes written
     }
 
 .fi
+
 The "version" argument specifies the PDF version number for the file or
 \fBNULL\fR for the default ("2.0").
 .PP
@@ -2302,6 +2374,32 @@ pdfio_stream_t * pdfioFileCreatePage (
     pdfio_dict_t *dict
 );
 .fi
+.SS pdfioFileCreateStringObj
+Create a new object in a PDF file containing a string.
+.PP
+.nf
+pdfio_obj_t * pdfioFileCreateStringObj (
+    pdfio_file_t *pdf,
+    const char *string
+);
+.fi
+.PP
+This function creates a new object with a string value in a PDF file.
+You must call \fIpdfioObjClose\fR to write the object to the file.
+.SS pdfioFileCreateTemporary
+
+.PP
+.nf
+pdfio_file_t * pdfioFileCreateTemporary (
+    char *buffer,
+    size_t bufsize,
+    const char *version,
+    pdfio_rect_t *media_box,
+    pdfio_rect_t *crop_box,
+    pdfio_error_cb_t error_cb,
+    void *error_data
+);
+.fi
 .SS pdfioFileFindObj
 Find an object using its object number.
 .PP
@@ -2569,7 +2667,7 @@ double  pdfioImageGetWidth (
 .fi
 .SS pdfioObjClose
 Close an object, writing any data as needed to the PDF
-file.
+                    file.
 .PP
 .nf
 bool  pdfioObjClose (
@@ -2755,6 +2853,13 @@ bool  pdfioStreamGetToken (
     size_t bufsize
 );
 .fi
+.PP
+This function reads a single PDF token from a stream.  Operator tokens,
+boolean values, and numbers are returned as-is in the provided string buffer.
+String values start with the opening parenthesis ('(') but have all escaping
+resolved and the terminating parenthesis removed.  Hexadecimal string values
+start with the opening angle bracket ('<') and have all whitespace and the
+terminating angle bracket removed.
 .SS pdfioStreamPeek
 Peek at data in a stream.
 .PP
@@ -2875,6 +2980,12 @@ Standard color spaces
 .nf
 typedef enum pdfio_cs_e pdfio_cs_t;
 .fi
+.SS pdfio_dict_cb_t
+Dictionary iterator callback
+.PP
+.nf
+typedef bool(*)(pdfio_dict_t *dict, const char *key, void *cb_data) pdfio_dict_cb_t;
+.fi
 .SS pdfio_dict_t
 Key/value dictionary
 .PP
@@ -2971,15 +3082,9 @@ PDF value types
 .nf
 typedef enum pdfio_valtype_e pdfio_valtype_t;
 .fi
-.SS state_t[4][4]
-4x4 AES state table
-.PP
-.nf
-typedef uint8_t state_t[4][4];
-.fi
 .SH AUTHOR
 .PP
 Michael R Sweet
 .SH COPYRIGHT
 .PP
-Copyright (c) 2021-2022 by Michael R Sweet
+Copyright (c) 2021-2024 by Michael R Sweet

doc/pdfio.html

@@ -1,13 +1,13 @@
 <!DOCTYPE html>
 <html lang="en-US">
 <head>
-<title>PDFio Programming Manual v1.0.1</title>
+<title>PDFio Programming Manual v1.2.0</title>
 <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
 <meta name="generator" content="codedoc v3.7">
 <meta name="author" content="Michael R Sweet">
 <meta name="language" content="en-US">
-<meta name="copyright" content="Copyright © 2021-2022 by Michael R Sweet">
-<meta name="version" content="1.0.1">
+<meta name="copyright" content="Copyright © 2021-2024 by Michael R Sweet">
+<meta name="version" content="1.2.0">
 <style type="text/css"><!--
 body {
   background: white;
@@ -245,9 +245,9 @@ span.string {
 <body>
 <div class="header">
 <p><img class="title" src="pdfio-512.png"></p>
-<h1 class="title">PDFio Programming Manual v1.0.1</h1>
+<h1 class="title">PDFio Programming Manual v1.2.0</h1>
 <p>Michael R Sweet</p>
-<p>Copyright © 2021-2022 by Michael R Sweet</p>
+<p>Copyright © 2021-2024 by Michael R Sweet</p>
 </div>
 <div class="contents">
 <h2 class="title">Contents</h2>
@@ -307,6 +307,7 @@ span.string {
 <li><a href="#pdfioContentPathCurve">pdfioContentPathCurve</a></li>
 <li><a href="#pdfioContentPathCurve13">pdfioContentPathCurve13</a></li>
 <li><a href="#pdfioContentPathCurve23">pdfioContentPathCurve23</a></li>
+<li><a href="#pdfioContentPathEnd">pdfioContentPathEnd</a></li>
 <li><a href="#pdfioContentPathLineTo">pdfioContentPathLineTo</a></li>
 <li><a href="#pdfioContentPathMoveTo">pdfioContentPathMoveTo</a></li>
 <li><a href="#pdfioContentPathRect">pdfioContentPathRect</a></li>
@@ -341,9 +342,12 @@ span.string {
 <li><a href="#pdfioContentStroke">pdfioContentStroke</a></li>
 <li><a href="#pdfioContentTextBegin">pdfioContentTextBegin</a></li>
 <li><a href="#pdfioContentTextEnd">pdfioContentTextEnd</a></li>
+<li><a href="#pdfioContentTextMeasure">pdfioContentTextMeasure</a></li>
 <li><a href="#pdfioContentTextMoveLine">pdfioContentTextMoveLine</a></li>
 <li><a href="#pdfioContentTextMoveTo">pdfioContentTextMoveTo</a></li>
-<li><a href="#pdfioContentTextNextLine">pdfioContentTextNextLine</a></li>
+<li><a href="#pdfioContentTextNewLine">pdfioContentTextNewLine</a></li>
+<li><a href="#pdfioContentTextNewLineShow">pdfioContentTextNewLineShow</a></li>
+<li><a href="#pdfioContentTextNewLineShowf">pdfioContentTextNewLineShowf</a></li>
 <li><a href="#pdfioContentTextShow">pdfioContentTextShow</a></li>
 <li><a href="#pdfioContentTextShowJustified">pdfioContentTextShowJustified</a></li>
 <li><a href="#pdfioContentTextShowf">pdfioContentTextShowf</a></li>
@@ -360,6 +364,7 @@ span.string {
 <li><a href="#pdfioDictGetRect">pdfioDictGetRect</a></li>
 <li><a href="#pdfioDictGetString">pdfioDictGetString</a></li>
 <li><a href="#pdfioDictGetType">pdfioDictGetType</a></li>
+<li><a href="#pdfioDictIterateKeys">pdfioDictIterateKeys</a></li>
 <li><a href="#pdfioDictSetArray">pdfioDictSetArray</a></li>
 <li><a href="#pdfioDictSetBinary">pdfioDictSetBinary</a></li>
 <li><a href="#pdfioDictSetBoolean">pdfioDictSetBoolean</a></li>
@@ -380,9 +385,12 @@ span.string {
 <li><a href="#pdfioFileCreateICCObjFromFile">pdfioFileCreateICCObjFromFile</a></li>
 <li><a href="#pdfioFileCreateImageObjFromData">pdfioFileCreateImageObjFromData</a></li>
 <li><a href="#pdfioFileCreateImageObjFromFile">pdfioFileCreateImageObjFromFile</a></li>
+<li><a href="#pdfioFileCreateNumberObj">pdfioFileCreateNumberObj</a></li>
 <li><a href="#pdfioFileCreateObj">pdfioFileCreateObj</a></li>
 <li><a href="#pdfioFileCreateOutput">pdfioFileCreateOutput</a></li>
 <li><a href="#pdfioFileCreatePage">pdfioFileCreatePage</a></li>
+<li><a href="#pdfioFileCreateStringObj">pdfioFileCreateStringObj</a></li>
+<li><a href="#pdfioFileCreateTemporary">pdfioFileCreateTemporary</a></li>
 <li><a href="#pdfioFileFindObj">pdfioFileFindObj</a></li>
 <li><a href="#pdfioFileGetAuthor">pdfioFileGetAuthor</a></li>
 <li><a href="#pdfioFileGetCreationDate">pdfioFileGetCreationDate</a></li>
@@ -442,6 +450,7 @@ span.string {
 <li><a href="#TYPES">Data Types</a><ul class="subcontents">
 <li><a href="#pdfio_array_t">pdfio_array_t</a></li>
 <li><a href="#pdfio_cs_t">pdfio_cs_t</a></li>
+<li><a href="#pdfio_dict_cb_t">pdfio_dict_cb_t</a></li>
 <li><a href="#pdfio_dict_t">pdfio_dict_t</a></li>
 <li><a href="#pdfio_encryption_t">pdfio_encryption_t</a></li>
 <li><a href="#pdfio_error_cb_t">pdfio_error_cb_t</a></li>
@@ -458,7 +467,6 @@ span.string {
 <li><a href="#pdfio_stream_t">pdfio_stream_t</a></li>
 <li><a href="#pdfio_textrendering_t">pdfio_textrendering_t</a></li>
 <li><a href="#pdfio_valtype_t">pdfio_valtype_t</a></li>
-<li><a href="#state_t[4][4]">state_t[4][4]</a></li>
 </ul></li>
 <li><a href="#STRUCTURES">Structures</a><ul class="subcontents">
 <li><a href="#pdfio_rect_s">pdfio_rect_s</a></li>
@@ -493,7 +501,7 @@ span.string {
 </li>
 </ul>
 <p>PDFio is <em>not</em> concerned with rendering or viewing a PDF file, although a PDF RIP or viewer could be written using it.</p>
-<p>PDFio is Copyright © 2021-2022 by Michael R Sweet and is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GPL2/LGPL2 software. See the files &quot;LICENSE&quot; and &quot;NOTICE&quot; for more information.</p>
+<p>PDFio is Copyright © 2021-2024 by Michael R Sweet and is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GPL2/LGPL2 software. See the files &quot;LICENSE&quot; and &quot;NOTICE&quot; for more information.</p>
 <h3 class="title" id="requirements">Requirements</h3>
 <p>PDFio requires the following to build the software:</p>
 <ul>
@@ -501,66 +509,40 @@ span.string {
 </li>
 <li><p>A POSIX-compliant <code>make</code> program</p>
 </li>
+<li><p>A POSIX-compliant <code>sh</code> program</p>
+</li>
 <li><p>ZLIB (<a href="https://www.zlib.net">https://www.zlib.net</a>) 1.0 or higher</p>
 </li>
 </ul>
 <p>IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.</p>
 <h3 class="title" id="installing-pdfio">Installing pdfio</h3>
-<p>PDFio comes with a portable makefile that will work on any POSIX-compliant system with ZLIB installed. To make it, run:</p>
-<pre><code>make all
+<p>PDFio comes with a configure script that creates a portable makefile that will work on any POSIX-compliant system with ZLIB installed. To make it, run:</p>
+<pre><code>./configure
+make
 </code></pre>
 <p>To test it, run:</p>
 <pre><code>make test
 </code></pre>
 <p>To install it, run:</p>
-<pre><code>make install
+<pre><code>sudo make install
 </code></pre>
 <p>If you want a shared library, run:</p>
-<pre><code>make all-shared
-make install-shared
+<pre><code>./configure --enable-shared
+make
+sudo make install
 </code></pre>
-<p>The default installation location is &quot;/usr/local&quot;. Pass the <code>prefix</code> variable to make to install it to another location:</p>
-<pre><code>make install prefix=/some/other/directory
+<p>The default installation location is &quot;/usr/local&quot;. Pass the <code>--prefix</code> option to make to install it to another location:</p>
+<pre><code>./configure --prefix=/some/other/directory
+</code></pre>
+<p>Other configure options can be found using the <code>--help</code> option:</p>
+<pre><code>./configure --help
 </code></pre>
-<p>The makefile installs the pdfio header to &quot;${prefix}/include&quot;, the library to &quot;${prefix}/lib&quot;, the <code>pkg-config</code> file to &quot;${prefix}/lib/pkgconfig&quot;, the man page to &quot;${prefix}/share/man/man3&quot;, and the documentation to &quot;${prefix}/share/doc/pdfio&quot;.</p>
-<p>The makefile supports the following variables that can be specified in the make command or as environment variables:</p>
-<ul>
-<li><p><code>AR</code>: the library archiver (default &quot;ar&quot;)</p>
-</li>
-<li><p><code>ARFLAGS</code>: options for the library archiver (default &quot;cr&quot;)</p>
-</li>
-<li><p><code>CC</code>: the C compiler (default &quot;cc&quot;)</p>
-</li>
-<li><p><code>CFLAGS</code>: options for the C compiler (default &quot;&quot;)</p>
-</li>
-<li><p><code>CODESIGN_IDENTITY</code>: the identity to use when code signing the shared library on macOS (default &quot;Developer ID&quot;)</p>
-</li>
-<li><p><code>COMMONFLAGS</code>: options for the C compiler and linker (typically architecture and optimization options, default is &quot;-Os -g&quot;)</p>
-</li>
-<li><p><code>CPPFLAGS</code>: options for the C preprocessor (default &quot;&quot;)</p>
-</li>
-<li><p><code>DESTDIR</code> and <code>DSTROOT</code>: specifies a root directory when installing (default is &quot;&quot;, specify only one)</p>
-</li>
-<li><p><code>DSOFLAGS</code>: options for the C compiler when linking the shared library (default &quot;&quot;)</p>
-</li>
-<li><p><code>LDFLAGS</code>: options for the C compiler when linking the test programs (default &quot;&quot;)</p>
-</li>
-<li><p><code>LIBS</code>: library options when linking the test programs (default &quot;-lz&quot;)</p>
-</li>
-<li><p><code>RANLIB</code>: program that generates a table-of-contents in a library (default &quot;ranlib&quot;)</p>
-</li>
-<li><p><code>prefix</code>: specifies the installation directory (default &quot;/usr/local&quot;)</p>
-</li>
-</ul>
 <h3 class="title" id="visual-studio-project">Visual Studio Project</h3>
 <p>The Visual Studio solution (&quot;pdfio.sln&quot;) is provided for Windows developers and generates both a static library and DLL.</p>
 <h3 class="title" id="xcode-project">Xcode Project</h3>
 <p>There is also an Xcode project (&quot;pdfio.xcodeproj&quot;) you can use on macOS which generates a static library that will be installed under &quot;/usr/local&quot; with:</p>
 <pre><code>sudo xcodebuild install
 </code></pre>
-<p>You can reproduce this with the makefile using:</p>
-<pre><code>sudo make macos install
-</code></pre>
 <h3 class="title" id="detecting-pdfio">Detecting PDFio</h3>
 <p>PDFio can be detected using the <code>pkg-config</code> command, for example:</p>
 <pre><code>if pkg-config --exists pdfio; then
@@ -595,9 +577,21 @@ LIBS    +=      `pkg-config --libs pdfio`
 </ul>
 <h3 class="title" id="reading-pdf-files">Reading PDF Files</h3>
 <p>You open an existing PDF file using the <a href="#pdfioFileOpen"><code>pdfioFileOpen</code></a> function:</p>
-<pre><code class="language-c">pdfio_file_t *pdf = pdfioFileOpen(<span class="string">&quot;myinputfile.pdf&quot;</span>, error_cb, error_data);
+<pre><code class="language-c">pdfio_file_t *pdf = pdfioFileOpen(<span class="string">&quot;myinputfile.pdf&quot;</span>, password_cb, password_data,
+                                  error_cb, error_data);
 </code></pre>
-<p>where the three arguments to the function are the filename (&quot;myinputfile.pdf&quot;), an optional error callback function (<code>error_cb</code>), and an optional pointer value for the error callback function (<code>error_data</code>). The error callback is called for both errors and warnings and accepts the <code>pdfio_file_t</code> pointer, a message string, and the callback pointer value, for example:</p>
+<p>where the five arguments to the function are the filename (&quot;myinputfile.pdf&quot;), an optional password callback function (<code>password_cb</code>) and data pointer value (<code>password_data</code>), and an optional error callback function (<code>error_cb</code>) and data pointer value (<code>error_data</code>). The password callback is called for encrypted PDF files that are not using the default password, for example:</p>
+<pre><code class="language-c"><span class="reserved">const</span> <span class="reserved">char</span> *
+password_cb(<span class="reserved">void</span> *data, <span class="reserved">const</span> <span class="reserved">char</span> *filename)
+{
+  (<span class="reserved">void</span>)data;     <span class="comment">// This callback doesn't use the data pointer</span>
+  (<span class="reserved">void</span>)filename; <span class="comment">// This callback doesn't use the filename</span>
+
+  <span class="comment">// Return a password string for the file...</span>
+  <span class="reserved">return</span> (<span class="string">&quot;Password42&quot;</span>);
+}
+</code></pre>
+<p>The error callback is called for both errors and warnings and accepts the <code>pdfio_file_t</code> pointer, a message string, and the callback pointer value, for example:</p>
 <pre><code class="language-c"><span class="reserved">bool</span>
 error_cb(pdfio_file_t *pdf, <span class="reserved">const</span> <span class="reserved">char</span> *message, <span class="reserved">void</span> *data)
 {
@@ -710,7 +704,7 @@ pdfio_stream_t *st = pdfioFileCreatePage(pdf, dict);
 <p>The <a href="#pdf-content-helper-functions">PDF content helper functions</a> provide additional functions for writing specific PDF page stream commands.</p>
 <p>When you are done writing the stream, call <a href="#pdfioStreamCLose"><code>pdfioStreamCLose</code></a> to close both the stream and the object.</p>
 <h3 class="title" id="pdf-content-helper-functions">PDF Content Helper Functions</h3>
-<p>PDFio includes many helper functions for embedding or writing specific kinds of content to a PDF file. These functions can be roughly grouped into ??? categories:</p>
+<p>PDFio includes many helper functions for embedding or writing specific kinds of content to a PDF file. These functions can be roughly grouped into five categories:</p>
 <ul>
 <li><p><a href="#color-space-functions">Color Space Functions</a></p>
 </li>
@@ -796,7 +790,9 @@ pdfio_obj_t *arial = pdfioFileCreateFontObjFromFile(pdf, <span class="string">&q
 pdfio_obj_t *arial = pdfioFileCreateFontObjFromFile(pdf, <span class="string">&quot;NotoSansJP-Regular.otf&quot;</span>, <span class="reserved">true</span>);
 </code></pre>
 <p>will embed the NotoSansJP Regular OpenType font with full support for Unicode.</p>
+<blockquote>
 <p>Note: Not all fonts support Unicode.</p>
+</blockquote>
 <h4 id="image-object-functions">Image Object Functions</h4>
 <p>PDF supports images with many different color spaces and bit depths with optional transparency. PDFio provides two helper functions for creating image objects that can be referenced in page streams. The first function is <a href="#pdfioFileCreateImageObjFromData"><code>pdfioFileCreateImageObjFromData</code></a> which creates an image object from data in memory, for example:</p>
 <pre><code class="language-c">pdfio_file_t *pdf = pdfioFileCreate(...);
@@ -927,7 +923,11 @@ pdfio_obj_t *img = pdfioFileCreateImageObjFromFile(pdf, <span class="string">&qu
 </li>
 <li><p><a href="#pdfioContentTextMoveTo"><code>pdfioContentTextMoveTo</code></a> moves within the current line in a text block</p>
 </li>
-<li><p><a href="#pdfioContentTextNextLine"><code>pdfioContentTextNextLine</code></a> moves to the beginning of the next line in a text block</p>
+<li><p><a href="#pdfioContentTextNewLine"><code>pdfioContentTextNewLine</code></a> moves to the beginning of the next line in a text block</p>
+</li>
+<li><p><a href="#pdfioContentTextNewLineShow"><code>pdfioContentTextNewLineShow</code></a> moves to the beginning of the next line in a text block and shows literal text with optional word and character spacing</p>
+</li>
+<li><p><a href="#pdfioContentTextNewLineShowf"><code>pdfioContentTextNewLineShowf</code></a> moves to the beginning of the next line in a text block and shows formatted text with optional word and character spacing</p>
 </li>
 <li><p><a href="#pdfioContentTextShow"><code>pdfioContentTextShow</code></a> draws a literal string in a text block</p>
 </li>
@@ -1384,7 +1384,7 @@ bool pdfioContentFillAndStroke(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st,
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
 <h3 class="function"><a id="pdfioContentMatrixConcat">pdfioContentMatrixConcat</a></h3>
 <p class="description">Concatenate a matrix to the current graphics
-state.</p>
+                               state.</p>
 <p class="code">
 bool pdfioContentMatrixConcat(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, pdfio_matrix_t m);</p>
 <h4 class="parameters">Parameters</h4>
@@ -1511,6 +1511,17 @@ bool pdfioContentPathCurve23(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, d
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h3 class="function"><a id="pdfioContentPathEnd">pdfioContentPathEnd</a></h3>
+<p class="description">Clear the current path.</p>
+<p class="code">
+bool pdfioContentPathEnd(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>st</th>
+<td class="description">Stream</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description"><code>true</code> on success, <code>false</code> on failure</p>
 <h3 class="function"><a id="pdfioContentPathLineTo">pdfioContentPathLineTo</a></h3>
 <p class="description">Add a straight line to the current path.</p>
 <p class="code">
@@ -1599,6 +1610,9 @@ bool pdfioContentSetDashPattern(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function sets the stroke pattern when drawing lines.  If &quot;on&quot; and &quot;off&quot;
+are 0, a solid line is drawn.</p>
 <h3 class="function"><a id="pdfioContentSetFillColorDeviceCMYK">pdfioContentSetFillColorDeviceCMYK</a></h3>
 <p class="description">Set device CMYK fill color.</p>
 <p class="code">
@@ -1987,6 +2001,25 @@ bool pdfioContentTextEnd(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st);</p>
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h3 class="function"><a id="pdfioContentTextMeasure">pdfioContentTextMeasure</a></h3>
+<p class="description">Measure a text string and return its width.</p>
+<p class="code">
+double pdfioContentTextMeasure(<a href="#pdfio_obj_t">pdfio_obj_t</a> *font, const char *s, double size);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>font</th>
+<td class="description">Font object created by <a href="#pdfioFileCreateFontObjFromFile"><code>pdfioFileCreateFontObjFromFile</code></a></td></tr>
+<tr><th>s</th>
+<td class="description">UTF-8 string</td></tr>
+<tr><th>size</th>
+<td class="description">Font size/height</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description">Width</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function measures the given text string &quot;s&quot; and returns its width based
+on &quot;size&quot;. The text string must always use the UTF-8 (Unicode) encoding but
+any control characters (such as newlines) are ignored.</p>
 <h3 class="function"><a id="pdfioContentTextMoveLine">pdfioContentTextMoveLine</a></h3>
 <p class="description">Move to the next line and offset.</p>
 <p class="code">
@@ -2017,10 +2050,10 @@ bool pdfioContentTextMoveTo(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, do
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
-<h3 class="function"><a id="pdfioContentTextNextLine">pdfioContentTextNextLine</a></h3>
+<h3 class="function"><a id="pdfioContentTextNewLine">pdfioContentTextNewLine</a></h3>
 <p class="description">Move to the next line.</p>
 <p class="code">
-bool pdfioContentTextNextLine(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st);</p>
+bool pdfioContentTextNewLine(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st);</p>
 <h4 class="parameters">Parameters</h4>
 <table class="list"><tbody>
 <tr><th>st</th>
@@ -2028,6 +2061,56 @@ bool pdfioContentTextNextLine(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st);
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h3 class="function"><a id="pdfioContentTextNewLineShow">pdfioContentTextNewLineShow</a></h3>
+<p class="description">Move to the next line and show text.</p>
+<p class="code">
+bool pdfioContentTextNewLineShow(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, double ws, double cs, bool unicode, const char *s);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>st</th>
+<td class="description">Stream</td></tr>
+<tr><th>ws</th>
+<td class="description">Word spacing or <code>0.0</code> for none</td></tr>
+<tr><th>cs</th>
+<td class="description">Character spacing or <code>0.0</code> for none</td></tr>
+<tr><th>unicode</th>
+<td class="description">Unicode text?</td></tr>
+<tr><th>s</th>
+<td class="description">String to show</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function moves to the next line and then shows some text with optional
+word and character spacing in a PDF content stream. The &quot;unicode&quot; argument
+specifies that the current font maps to full Unicode.  The &quot;s&quot; argument
+specifies a UTF-8 encoded string.</p>
+<h3 class="function"><a id="pdfioContentTextNewLineShowf">pdfioContentTextNewLineShowf</a></h3>
+<p class="description">Show formatted text.</p>
+<p class="code">
+bool pdfioContentTextNewLineShowf(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, double ws, double cs, bool unicode, const char *format, ...);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>st</th>
+<td class="description">Stream</td></tr>
+<tr><th>ws</th>
+<td class="description">Word spacing or <code>0.0</code> for none</td></tr>
+<tr><th>cs</th>
+<td class="description">Character spacing or <code>0.0</code> for none</td></tr>
+<tr><th>unicode</th>
+<td class="description">Unicode text?</td></tr>
+<tr><th>format</th>
+<td class="description"><code>printf</code>-style format string</td></tr>
+<tr><th>...</th>
+<td class="description">Additional arguments as needed</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description"><code>true</code> on success, <code>false</code> on failure</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function moves to the next line and shows some formatted text with
+optional word and character spacing in a PDF content stream. The &quot;unicode&quot;
+argument specifies that the current font maps to full Unicode.  The &quot;format&quot;
+argument specifies a UTF-8 encoded <code>printf</code>-style format string.</p>
 <h3 class="function"><a id="pdfioContentTextShow">pdfioContentTextShow</a></h3>
 <p class="description">Show text.</p>
 <p class="code">
@@ -2087,9 +2170,9 @@ bool pdfioContentTextShowf(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, boo
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description">Show formatted text.</p>
-<p class="discussion">This function shows some text in a PDF content stream. The &quot;unicode&quot; argument
-specifies that the current font maps to full Unicode.  The &quot;format&quot; argument
-specifies a UTF-8 encoded <code>printf</code>-style format string.</p>
+<p class="discussion">This function shows some formatted text in a PDF content stream. The
+&quot;unicode&quot; argument specifies that the current font maps to full Unicode.
+The &quot;format&quot; argument specifies a UTF-8 encoded <code>printf</code>-style format string.</p>
 <h3 class="function"><a id="pdfioDictCopy">pdfioDictCopy</a></h3>
 <p class="description">Copy a dictionary to a PDF file.</p>
 <p class="code">
@@ -2261,6 +2344,34 @@ const char *pdfioDictGetString(<a href="#pdfio_dict_t">pdfio_dict_t</a> *dict, c
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description">Value type</p>
+<h3 class="function"><a id="pdfioDictIterateKeys">pdfioDictIterateKeys</a></h3>
+<p class="description">Iterate the keys in a dictionary.</p>
+<p class="code">
+void pdfioDictIterateKeys(<a href="#pdfio_dict_t">pdfio_dict_t</a> *dict, <a href="#pdfio_dict_cb_t">pdfio_dict_cb_t</a> cb, void *cb_data);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>dict</th>
+<td class="description">Dictionary</td></tr>
+<tr><th>cb</th>
+<td class="description">Callback function</td></tr>
+<tr><th>cb_data</th>
+<td class="description">Callback data</td></tr>
+</tbody></table>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function iterates the keys in a dictionary, calling the supplied
+function &quot;cb&quot;:
+
+<pre>
+bool
+my_dict_cb(pdfio_dict_t *dict, const char *key, void *cb_data)
+{
+... &quot;key&quot; contains the dictionary key ...
+... return true to continue or false to stop ...
+}
+</pre>
+
+The iteration continues as long as the callback returns <code>true</code> or all keys
+have been iterated.</p>
 <h3 class="function"><a id="pdfioDictSetArray">pdfioDictSetArray</a></h3>
 <p class="description">Set a key array in a dictionary.</p>
 <p class="code">
@@ -2653,6 +2764,22 @@ image on the page.<br>
 Note: Currently PNG support is limited to grayscale, RGB, or indexed files
 without interlacing or alpha.  Transparency (masking) based on color/index
 is supported.</blockquote>
+<h3 class="function"><a id="pdfioFileCreateNumberObj">pdfioFileCreateNumberObj</a></h3>
+<p class="description">Create a new object in a PDF file containing a number.</p>
+<p class="code">
+<a href="#pdfio_obj_t">pdfio_obj_t</a> *pdfioFileCreateNumberObj(<a href="#pdfio_file_t">pdfio_file_t</a> *pdf, double number);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>pdf</th>
+<td class="description">PDF file</td></tr>
+<tr><th>number</th>
+<td class="description">Number value</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description">New object</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function creates a new object with a number value in a PDF file.
+You must call <a href="#pdfioObjClose"><code>pdfioObjClose</code></a> to write the object to the file.</p>
 <h3 class="function"><a id="pdfioFileCreateObj">pdfioFileCreateObj</a></h3>
 <p class="description">Create a new object in a PDF file.</p>
 <p class="code">
@@ -2699,9 +2826,10 @@ written:
 ssize_t
 output_cb(void *output_ctx, const void *buffer, size_t bytes)
 {
-// Write buffer to output and return the number of bytes written
+  // Write buffer to output and return the number of bytes written
 }
 </pre>
+
 The &quot;version&quot; argument specifies the PDF version number for the file or
 <code>NULL</code> for the default (&quot;2.0&quot;).<br>
 <br>
@@ -2730,6 +2858,51 @@ stored as indirect object references.</blockquote>
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description">Contents stream</p>
+<h3 class="function"><a id="pdfioFileCreateStringObj">pdfioFileCreateStringObj</a></h3>
+<p class="description">Create a new object in a PDF file containing a string.</p>
+<p class="code">
+<a href="#pdfio_obj_t">pdfio_obj_t</a> *pdfioFileCreateStringObj(<a href="#pdfio_file_t">pdfio_file_t</a> *pdf, const char *string);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>pdf</th>
+<td class="description">PDF file</td></tr>
+<tr><th>string</th>
+<td class="description">String</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description">New object</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function creates a new object with a string value in a PDF file.
+You must call <a href="#pdfioObjClose"><code>pdfioObjClose</code></a> to write the object to the file.</p>
+<h3 class="function"><a id="pdfioFileCreateTemporary">pdfioFileCreateTemporary</a></h3>
+<p class="description"></p>
+<p class="code">
+<a href="#pdfio_file_t">pdfio_file_t</a> *pdfioFileCreateTemporary(char *buffer, size_t bufsize, const char *version, <a href="#pdfio_rect_t">pdfio_rect_t</a> *media_box, <a href="#pdfio_rect_t">pdfio_rect_t</a> *crop_box, <a href="#pdfio_error_cb_t">pdfio_error_cb_t</a> error_cb, void *error_data);</p>
+<h4 class="parameters">Parameters</h4>
+<table class="list"><tbody>
+<tr><th>buffer</th>
+<td class="description">Filename buffer</td></tr>
+<tr><th>bufsize</th>
+<td class="description">Size of filename buffer</td></tr>
+<tr><th>version</th>
+<td class="description">PDF version number or <code>NULL</code> for default (2.0)</td></tr>
+<tr><th>media_box</th>
+<td class="description">Default MediaBox for pages</td></tr>
+<tr><th>crop_box</th>
+<td class="description">Default CropBox for pages</td></tr>
+<tr><th>error_cb</th>
+<td class="description">Error callback or <code>NULL</code> for default</td></tr>
+<tr><th>error_data</th>
+<td class="description">Error callback data, if any</td></tr>
+</tbody></table>
+<h4 class="returnvalue">Return Value</h4>
+<p class="description">Create a temporary PDF file.</p>
+<p class="discussion">This function creates a PDF file with a unique filename in the current
+temporary directory.  The temporary file is stored in the string &quot;buffer&quot; an
+will have a &quot;.pdf&quot; extension.  Otherwise, this function works the same as
+the <a href="#pdfioFileCreate"><code>pdfioFileCreate</code></a> function.
+
+</p>
 <h3 class="function"><a id="pdfioFileFindObj">pdfioFileFindObj</a></h3>
 <p class="description">Find an object using its object number.</p>
 <p class="code">
@@ -3081,7 +3254,7 @@ double pdfioImageGetWidth(<a href="#pdfio_obj_t">pdfio_obj_t</a> *obj);</p>
 <p class="description">Width in columns</p>
 <h3 class="function"><a id="pdfioObjClose">pdfioObjClose</a></h3>
 <p class="description">Close an object, writing any data as needed to the PDF
-file.</p>
+                    file.</p>
 <p class="code">
 bool pdfioObjClose(<a href="#pdfio_obj_t">pdfio_obj_t</a> *obj);</p>
 <h4 class="parameters">Parameters</h4>
@@ -3342,6 +3515,13 @@ bool pdfioStreamGetToken(<a href="#pdfio_stream_t">pdfio_stream_t</a> *st, char
 </tbody></table>
 <h4 class="returnvalue">Return Value</h4>
 <p class="description"><code>true</code> on success, <code>false</code> on EOF</p>
+<h4 class="discussion">Discussion</h4>
+<p class="discussion">This function reads a single PDF token from a stream.  Operator tokens,
+boolean values, and numbers are returned as-is in the provided string buffer.
+String values start with the opening parenthesis ('(') but have all escaping
+resolved and the terminating parenthesis removed.  Hexadecimal string values
+start with the opening angle bracket ('&lt;') and have all whitespace and the
+terminating angle bracket removed.</p>
 <h3 class="function"><a id="pdfioStreamPeek">pdfioStreamPeek</a></h3>
 <p class="description">Peek at data in a stream.</p>
 <p class="code">
@@ -3484,6 +3664,11 @@ typedef struct _pdfio_array_s pdfio_array_t;
 <p class="code">
 typedef enum <a href="#pdfio_cs_e">pdfio_cs_e</a> pdfio_cs_t;
 </p>
+<h3 class="typedef"><a id="pdfio_dict_cb_t">pdfio_dict_cb_t</a></h3>
+<p class="description">Dictionary iterator callback</p>
+<p class="code">
+typedef bool (*pdfio_dict_cb_t)(<a href="#pdfio_dict_t">pdfio_dict_t</a> *dict, const char *key, void *cb_data);
+</p>
 <h3 class="typedef"><a id="pdfio_dict_t">pdfio_dict_t</a></h3>
 <p class="description">Key/value dictionary</p>
 <p class="code">
@@ -3564,11 +3749,6 @@ typedef enum <a href="#pdfio_textrendering_e">pdfio_textrendering_e</a> pdfio_te
 <p class="code">
 typedef enum <a href="#pdfio_valtype_e">pdfio_valtype_e</a> pdfio_valtype_t;
 </p>
-<h3 class="typedef"><a id="state_t[4][4]">state_t[4][4]</a></h3>
-<p class="description">4x4 AES state table</p>
-<p class="code">
-typedef uint8_t state_t[4][4];
-</p>
 <h2 class="title"><a id="STRUCTURES">Structures</a></h2>
 <h3 class="struct"><a id="pdfio_rect_s">pdfio_rect_s</a></h3>
 <p class="description">PDF rectangle</p>
@@ -3603,7 +3783,6 @@ typedef uint8_t state_t[4][4];
 <h4 class="constants">Constants</h4>
 <table class="list"><tbody>
 <tr><th>PDFIO_ENCRYPTION_AES_128 </th><td class="description">128-bit AES encryption (PDF 1.6)</td></tr>
-<tr><th>PDFIO_ENCRYPTION_AES_256 </th><td class="description">256-bit AES encryption (PDF 2.0)</td></tr>
 <tr><th>PDFIO_ENCRYPTION_NONE </th><td class="description">No encryption</td></tr>
 <tr><th>PDFIO_ENCRYPTION_RC4_128 </th><td class="description">128-bit RC4 encryption (PDF 1.4)</td></tr>
 <tr><th>PDFIO_ENCRYPTION_RC4_40 </th><td class="description">40-bit RC4 encryption (PDF 1.3)</td></tr>

doc/pdfio.md

@@ -15,7 +15,7 @@ goals of pdfio are:
 PDFio is *not* concerned with rendering or viewing a PDF file, although a PDF
 RIP or viewer could be written using it.
 
-PDFio is Copyright © 2021-2022 by Michael R Sweet and is licensed under the
+PDFio is Copyright © 2021-2024 by Michael R Sweet and is licensed under the
 Apache License Version 2.0 with an (optional) exception to allow linking against
 GPL2/LGPL2 software.  See the files "LICENSE" and "NOTICE" for more information.
 
@@ -27,6 +27,7 @@ PDFio requires the following to build the software:
 
 - A C99 compiler such as Clang, GCC, or MS Visual C
 - A POSIX-compliant `make` program
+- A POSIX-compliant `sh` program
 - ZLIB (<https://www.zlib.net>) 1.0 or higher
 
 IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
@@ -35,10 +36,11 @@ IDE files for Xcode (macOS/iOS) and Visual Studio (Windows) are also provided.
 Installing pdfio
 ----------------
 
-PDFio comes with a portable makefile that will work on any POSIX-compliant
-system with ZLIB installed.  To make it, run:
+PDFio comes with a configure script that creates a portable makefile that will
+work on any POSIX-compliant system with ZLIB installed.  To make it, run:
 
-    make all
+    ./configure
+    make
 
 To test it, run:
 
@@ -46,45 +48,22 @@ To test it, run:
 
 To install it, run:
 
-    make install
+    sudo make install
 
 If you want a shared library, run:
 
-    make all-shared
-    make install-shared
+    ./configure --enable-shared
+    make
+    sudo make install
 
-The default installation location is "/usr/local".  Pass the `prefix` variable
+The default installation location is "/usr/local".  Pass the `--prefix` option
 to make to install it to another location:
 
-    make install prefix=/some/other/directory
+    ./configure --prefix=/some/other/directory
 
-The makefile installs the pdfio header to "${prefix}/include", the library to
-"${prefix}/lib", the `pkg-config` file to "${prefix}/lib/pkgconfig", the man
-page to "${prefix}/share/man/man3", and the documentation to
-"${prefix}/share/doc/pdfio".
+Other configure options can be found using the `--help` option:
 
-The makefile supports the following variables that can be specified in the make
-command or as environment variables:
-
-- `AR`: the library archiver (default "ar")
-- `ARFLAGS`: options for the library archiver (default "cr")
-- `CC`: the C compiler (default "cc")
-- `CFLAGS`: options for the C compiler (default "")
-- `CODESIGN_IDENTITY`: the identity to use when code signing the shared library
-  on macOS (default "Developer ID")
-- `COMMONFLAGS`: options for the C compiler and linker (typically architecture
-  and optimization options, default is "-Os -g")
-- `CPPFLAGS`: options for the C preprocessor (default "")
-- `DESTDIR` and `DSTROOT`: specifies a root directory when installing
-  (default is "", specify only one)
-- `DSOFLAGS`: options for the C compiler when linking the shared library
-  (default "")
-- `LDFLAGS`: options for the C compiler when linking the test programs
-  (default "")
-- `LIBS`: library options when linking the test programs (default "-lz")
-- `RANLIB`: program that generates a table-of-contents in a library
-  (default "ranlib")
-- `prefix`: specifies the installation directory (default "/usr/local")
+    ./configure --help
 
 
 Visual Studio Project
@@ -102,10 +81,6 @@ generates a static library that will be installed under "/usr/local" with:
 
     sudo xcodebuild install
 
-You can reproduce this with the makefile using:
-
-    sudo make macos install
-
 
 Detecting PDFio
 ---------------
@@ -163,15 +138,32 @@ Reading PDF Files
 You open an existing PDF file using the [`pdfioFileOpen`](@@) function:
 
 ```c
-pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", error_cb, error_data);
+pdfio_file_t *pdf = pdfioFileOpen("myinputfile.pdf", password_cb, password_data,
+                                  error_cb, error_data);
 
 ```
 
-where the three arguments to the function are the filename ("myinputfile.pdf"),
-an optional error callback function (`error_cb`), and an optional pointer value
-for the error callback function (`error_data`).  The error callback is called
-for both errors and warnings and accepts the `pdfio_file_t` pointer, a message
-string, and the callback pointer value, for example:
+where the five arguments to the function are the filename ("myinputfile.pdf"),
+an optional password callback function (`password_cb`) and data pointer value
+(`password_data`), and an optional error callback function (`error_cb`) and data
+pointer value (`error_data`).  The password callback is called for encrypted PDF
+files that are not using the default password, for example:
+
+```c
+const char *
+password_cb(void *data, const char *filename)
+{
+  (void)data;     // This callback doesn't use the data pointer
+  (void)filename; // This callback doesn't use the filename
+
+  // Return a password string for the file...
+  return ("Password42");
+}
+```
+
+The error callback is called for both errors and warnings and accepts the
+`pdfio_file_t` pointer, a message string, and the callback pointer value, for
+example:
 
 ```c
 bool
@@ -361,7 +353,7 @@ PDF Content Helper Functions
 ----------------------------
 
 PDFio includes many helper functions for embedding or writing specific kinds of
-content to a PDF file.  These functions can be roughly grouped into ???
+content to a PDF file.  These functions can be roughly grouped into five
 categories:
 
 - [Color Space Functions](@)
@@ -455,7 +447,7 @@ pdfio_obj_t *arial = pdfioFileCreateFontObjFromFile(pdf, "NotoSansJP-Regular.otf
 
 will embed the NotoSansJP Regular OpenType font with full support for Unicode.
 
-Note: Not all fonts support Unicode.
+> Note: Not all fonts support Unicode.
 
 
 ### Image Object Functions
@@ -584,8 +576,12 @@ escaping, as needed:
 - [`pdfioContentTextMoveLine`](@@) moves to the next line with an offset in a
   text block
 - [`pdfioContentTextMoveTo`](@@) moves within the current line in a text block
-- [`pdfioContentTextNextLine`](@@) moves to the beginning of the next line in a
+- [`pdfioContentTextNewLine`](@@) moves to the beginning of the next line in a
   text block
+- [`pdfioContentTextNewLineShow`](@@) moves to the beginning of the next line in a
+  text block and shows literal text with optional word and character spacing
+- [`pdfioContentTextNewLineShowf`](@@) moves to the beginning of the next line in a
+  text block and shows formatted text with optional word and character spacing
 - [`pdfioContentTextShow`](@@) draws a literal string in a text block
 - [`pdfioContentTextShowf`](@@) draws a formatted string in a text block
 - [`pdfioContentTextShowJustified`](@@) draws an array of literal strings with

install-sh

@@ -0,0 +1,232 @@
+#!/bin/sh
+#
+# Install a program, script, or datafile.
+#
+# Copyright 2008-2012 by Apple Inc.
+#
+# This script is not compatible with BSD (or any other) install program, as it
+# allows owner and group changes to fail with a warning and makes sure that the
+# destination directory permissions are as specified - BSD install and the
+# original X11 install script did not change permissions of existing
+# directories.  It also does not support the transform options since CUPS does
+# not use them...
+#
+# Original script from X11R5 (mit/util/scripts/install.sh)
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+
+# set DOITPROG to echo to test this script
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+# Force umask to 022...
+umask 022
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+gzipprog="${GZIPPROG-gzip}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+gzipcp() {
+	# gzipcp from to
+	$gzipprog -9 <"$1" >"$2"
+}
+
+while [ x"$1" != x ]; do
+	case $1 in
+		-c)
+		instcmd="$cpprog"
+		shift
+		continue
+		;;
+
+		-d)
+		dir_arg=true
+		shift
+		continue
+		;;
+
+		-m)
+		chmodcmd="$chmodprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-o)
+		chowncmd="$chownprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-g)
+		chgrpcmd="$chgrpprog $2"
+		shift
+		shift
+		continue
+		;;
+
+		-s)
+		stripcmd="$stripprog"
+		shift
+		continue
+		;;
+
+		-z)
+		instcmd="gzipcp"
+		shift
+		continue
+		;;
+
+		*)
+		if [ x"$src" = x ]; then
+			src="$1"
+		else
+			dst="$1"
+		fi
+		shift
+		continue
+		;;
+	esac
+done
+
+if [ x"$src" = x ]; then
+	echo "install-sh: No input file specified"
+	exit 1
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst="$src"
+	src=""
+
+	if [ -d "$dst" ]; then
+		instcmd=:
+	else
+		instcmd=$mkdirprog
+	fi
+else
+	# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+	# might cause directories to be created, which would be especially bad
+	# if $src (and thus $dsttmp) contains '*'.
+	if [ ! -f "$src" -a ! -d "$src" ]; then
+		echo "install: $src does not exist"
+		exit 1
+	fi
+
+	if [ x"$dst" = x ]; then
+		echo "install: No destination specified"
+		exit 1
+	fi
+
+	# If destination is a directory, append the input filename.
+	if [ -d "$dst" ]; then
+		dst="$dst/`basename $src`"
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir="`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`"
+
+# Make sure that the destination directory exists.
+# This part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+	defaultIFS='
+	'
+	IFS="${IFS-${defaultIFS}}"
+
+	oIFS="${IFS}"
+	# Some sh's can't handle IFS=/ for some reason.
+	IFS='%'
+	set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+	IFS="${oIFS}"
+
+	pathcomp=''
+
+	while [ $# -ne 0 ] ; do
+		pathcomp="${pathcomp}${1}"
+		shift
+
+		if [ ! -d "${pathcomp}" ]; then $doit $mkdirprog "${pathcomp}"; fi
+
+		pathcomp="${pathcomp}/"
+	done
+fi
+
+if [ x"$dir_arg" != x ]; then
+	# Make a directory...
+	$doit $instcmd $dst || exit 1
+
+	# Allow chown/chgrp to fail, but log a warning
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst || echo "warning: Unable to change owner of $dst!"; fi
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst || echo "warning: Unable to change group of $dst!"; fi
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst || exit 1; fi
+else
+	# Install a file...
+	dstfile="`basename $dst`"
+
+	# Check the destination file - for libraries just use the "-x" option
+	# to strip...
+	case "$dstfile" in
+		*.a | *.dylib | *.sl | *.sl.* | *.so | *.so.*)
+			stripopt="-x"
+			;;
+		*)
+			stripopt=""
+			;;
+	esac
+
+	# Make a temp file name in the proper directory.
+	dsttmp="$dstdir/#inst.$$#"
+
+	# Move or copy the file name to the temp name
+	$doit $instcmd $src $dsttmp || exit 1
+
+	# Update permissions and strip as needed, then move to the final name.
+	# If the chmod, strip, rm, or mv commands fail, remove the installed
+	# file...
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $stripopt "$dsttmp" || echo "warning: Unable to strip $dst!"; fi
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dsttmp" || echo "warning: Unable to change owner of $dst!"; fi
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dsttmp" || echo "warning: Unable to change group of $dst!"; fi
+
+	trap "rm -f ${dsttmp}" 0 &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dsttmp"; fi &&
+	$doit $rmcmd -f "$dstdir/$dstfile" &&
+	$doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
+fi
+
+exit 0

pdfio-aes.c

@@ -10,10 +10,6 @@
 // (<https://github.com/kokke/tiny-AES-c>)
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -21,7 +17,7 @@
 // Local types...
 //
 
-typedef uint8_t state_t[4][4];		// 4x4 AES state table
+typedef uint8_t state_t[4][4];		// 4x4 AES state table @private@
 
 
 //

pdfio-array.c

@@ -7,10 +7,6 @@
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -331,6 +327,30 @@ pdfioArrayCreate(pdfio_file_t *pdf)	// I - PDF file
 }
 
 
+//
+// '_pdfioArrayDecrypt()' - Decrypt values in an array.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioArrayDecrypt(pdfio_file_t  *pdf,	// I - PDF file
+                   pdfio_obj_t   *obj,	// I - Object
+                   pdfio_array_t *a,	// I - Array
+                   size_t        depth)	// I - Depth
+{
+  size_t		i;		// Looping var
+  _pdfio_value_t	*v;		// Current value
+
+
+  for (i = a->num_values, v = a->values; i > 0; i --, v ++)
+  {
+    if (!_pdfioValueDecrypt(pdf, obj, v, depth))
+      return (false);
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioArrayDebug()' - Print the contents of an array.
 //

pdfio-common.c

@@ -1,16 +1,12 @@
 //
 // Common support functions for pdfio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -38,6 +34,8 @@ _pdfioFileConsume(pdfio_file_t *pdf,	// I - PDF file
   else if (_pdfioFileSeek(pdf, (off_t)bytes, SEEK_CUR) < 0)
     return (false);
 
+  PDFIO_DEBUG("_pdfioFileConsume: pos=%ld\n", (long)(pdf->bufpos + pdf->bufptr - pdf->buffer));
+
   return (true);
 }
 
@@ -143,7 +141,7 @@ _pdfioFileGets(pdfio_file_t *pdf,	// I - PDF file
 	*bufend = buffer + bufsize - 1;	// Pointer to end of buffer
 
 
-  PDFIO_DEBUG("_pdfioFileGets(pdf=%p, buffer=%p, bufsize=%lu) bufpos=%ld, buffer=%p, bufptr=%p, bufend=%p\n", pdf, buffer, (unsigned long)bufsize, (long)pdf->bufpos, pdf->buffer, pdf->bufptr, pdf->bufend);
+  PDFIO_DEBUG("_pdfioFileGets(pdf=%p, buffer=%p, bufsize=%lu) bufpos=%ld, buffer=%p, bufptr=%p, bufend=%p, offset=%lu\n", pdf, buffer, (unsigned long)bufsize, (long)pdf->bufpos, pdf->buffer, pdf->bufptr, pdf->bufend, (unsigned long)(pdf->bufpos + (pdf->bufptr - pdf->buffer)));
 
   while (!eol)
   {
@@ -358,12 +356,12 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
                off_t        offset,	// I - Offset
                int          whence)	// I - Offset base
 {
-  PDFIO_DEBUG("_pdfioFileSeek(pdf=%p, offset=%ld, whence=%d)\n", pdf, (long)offset, whence);
+  PDFIO_DEBUG("_pdfioFileSeek(pdf=%p, offset=%ld, whence=%d) pdf->bufpos=%lu\n", pdf, (long)offset, whence, (unsigned long)(pdf ? pdf->bufpos : 0));
 
   // Adjust offset for relative seeks...
   if (whence == SEEK_CUR)
   {
-    offset += pdf->bufpos;
+    offset += pdf->bufpos + (pdf->bufptr - pdf->buffer);
     whence = SEEK_SET;
   }
 
@@ -373,9 +371,9 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
     if (whence != SEEK_END && offset >= pdf->bufpos && offset < (pdf->bufpos + pdf->bufend - pdf->buffer))
     {
       // Yes, seek within existing buffer...
-      pdf->bufptr = pdf->buffer + offset - pdf->bufpos;
+      pdf->bufptr = pdf->buffer + (offset - pdf->bufpos);
       PDFIO_DEBUG("_pdfioFileSeek: Seek within buffer, bufpos=%ld.\n", (long)pdf->bufpos);
-      PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p, bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufend);
+      PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p(<%02X%02X...>), bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufptr[0] & 255, pdf->bufptr[1] & 255, pdf->bufend);
       return (offset);
     }
 
@@ -406,7 +404,7 @@ _pdfioFileSeek(pdfio_file_t *pdf,	// I - PDF file
     return (-1);
   }
 
-  PDFIO_DEBUG("_pdfioFileSeek: Reset bufpos=%ld.\n", (long)pdf->bufpos);
+  PDFIO_DEBUG("_pdfioFileSeek: Reset bufpos=%ld, offset=%lu.\n", (long)pdf->bufpos, (unsigned long)offset);
   PDFIO_DEBUG("_pdfioFileSeek: buffer=%p, bufptr=%p, bufend=%p\n", pdf->buffer, pdf->bufptr, pdf->bufend);
 
   pdf->bufpos = offset;
@@ -525,7 +523,7 @@ read_buffer(pdfio_file_t *pdf,		// I - PDF file
   return (rbytes);
 }
 
-  
+
 //
 // 'write_buffer()' - Write a buffer to a PDF file.
 //

pdfio-content.c

@@ -1,16 +1,12 @@
 //
 // Content helper functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 #include "pdfio-content.h"
 #include "ttf.h"
@@ -489,8 +485,11 @@ pdfioContentMatrixRotate(
     pdfio_stream_t *st,			// I - Stream
     double         degrees)		// I - Rotation angle in degrees counter-clockwise
 {
-  double dcos = cos(degrees / M_PI);	// Cosine
-  double dsin = sin(degrees / M_PI);	// Sine
+  double dcos = cos(M_PI * degrees / 180.0);
+					// Cosine
+  double dsin = sin(M_PI * degrees / 180.0);
+					// Sine
+
 
   return (pdfioStreamPrintf(st, "%g %g %g %g 0 0 cm\n", dcos, -dsin, dsin, dcos));
 }
@@ -586,6 +585,17 @@ pdfioContentPathCurve23(
 }
 
 
+//
+// 'pdfioContentPathEnd()' - Clear the current path.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentPathEnd(pdfio_stream_t *st)	// I - Stream
+{
+  return (pdfioStreamPuts(st, "n\n"));
+}
+
+
 //
 // 'pdfioContentPathLineTo()' - Add a straight line to the current path.
 //
@@ -656,6 +666,9 @@ pdfioContentSave(pdfio_stream_t *st)	// I - Stream
 //
 // 'pdfioContentSetDashPattern()' - Set the stroke pattern.
 //
+// This function sets the stroke pattern when drawing lines.  If "on" and "off"
+// are 0, a solid line is drawn.
+//
 
 bool					// O - `true` on success, `false` on failure
 pdfioContentSetDashPattern(
@@ -664,7 +677,12 @@ pdfioContentSetDashPattern(
     double         on,			// I - On length
     double         off)			// I - Off length
 {
-  return (pdfioStreamPrintf(st, "[%g %g] %g d\n", on, off, phase));
+  if (on <= 0.0 && off <= 0.0)
+    return (pdfioStreamPrintf(st, "[] %g d\n", phase));
+  else if (fabs(on - off) < 0.001)
+    return (pdfioStreamPrintf(st, "[%g] %g d\n", on, phase));
+  else
+    return (pdfioStreamPrintf(st, "[%g %g] %g d\n", on, off, phase));
 }
 
 
@@ -1042,6 +1060,104 @@ pdfioContentTextEnd(pdfio_stream_t *st)	// I - Stream
 }
 
 
+//
+// 'pdfioContentTextMeasure()' - Measure a text string and return its width.
+//
+// This function measures the given text string "s" and returns its width based
+// on "size". The text string must always use the UTF-8 (Unicode) encoding but
+// any control characters (such as newlines) are ignored.
+//
+
+double					// O - Width
+pdfioContentTextMeasure(
+    pdfio_obj_t *font,			// I - Font object created by @link pdfioFileCreateFontObjFromFile@
+    const char  *s,			// I - UTF-8 string
+    double      size)			// I - Font size/height
+{
+  const char	*subtype;		// Font sub-type
+  ttf_t		*ttf = (ttf_t *)_pdfioObjGetExtension(font);
+					// TrueType font data
+  ttf_rect_t	extents;		// Text extents
+  int		ch;			// Unicode character
+  char		temp[1024],		// Temporary string
+		*tempptr;		// Pointer into temporary string
+
+
+  if ((subtype = pdfioObjGetSubtype(font)) == NULL || strcmp(subtype, "Type0"))
+  {
+    // Map non-CP1282 characters to '?', everything else as-is...
+    tempptr = temp;
+
+    while (*s && tempptr < (temp + sizeof(temp) - 3))
+    {
+      if ((*s & 0xe0) == 0xc0)
+      {
+	// Two-byte UTF-8
+        ch = ((s[0] & 0x1f) << 6) | (s[1] & 0x3f);
+	s += 2;
+      }
+      else if ((*s & 0xf0) == 0xe0)
+      {
+	// Three-byte UTF-8
+        ch = ((s[0] & 0x0f) << 12) | ((s[1] & 0x3f) << 6) | (s[2] & 0x3f);
+	s += 3;
+      }
+      else if ((*s & 0xf8) == 0xf0)
+      {
+	// Four-byte UTF-8
+        ch = ((s[0] & 0x07) << 18) | ((s[1] & 0x3f) << 12) | ((s[2] & 0x3f) << 6) | (s[3] & 0x3f);
+	s += 4;
+      }
+      else
+      {
+	ch = *s++;
+      }
+
+      if (ch > 255)
+      {
+	// Try mapping from Unicode to CP1252...
+	size_t i;			// Looping var
+
+	for (i = 0; i < (sizeof(_pdfio_cp1252) / sizeof(_pdfio_cp1252[0])); i ++)
+	{
+	  if (ch == _pdfio_cp1252[i])
+	    break;
+	}
+
+	if (i >= (sizeof(_pdfio_cp1252) / sizeof(_pdfio_cp1252[0])))
+	  ch = '?';			// Unsupported chars map to ?
+      }
+
+      if (ch < 128)
+      {
+        // ASCII
+	*tempptr++ = (char)ch;
+      }
+      else if (ch < 2048)
+      {
+        // 2-byte UTF-8
+        *tempptr++ = (char)(0xc0 | ((ch >> 6) & 0x1f));
+        *tempptr++ = (char)(0x80 | (ch & 0x3f));
+      }
+      else
+      {
+        // 3-byte UTF-8
+        *tempptr++ = (char)(0xe0 | ((ch >> 12) & 0x0f));
+        *tempptr++ = (char)(0x80 | ((ch >> 6) & 0x3f));
+        *tempptr++ = (char)(0x80 | (ch & 0x3f));
+      }
+    }
+
+    *tempptr = '\0';
+    s        = temp;
+  }
+
+  ttfGetExtents(ttf, (float)size, s, &extents);
+
+  return (extents.right - extents.left);
+}
+
+
 //
 // 'pdfioContentTextMoveLine()' - Move to the next line and offset.
 //
@@ -1071,7 +1187,21 @@ pdfioContentTextMoveTo(
 
 
 //
-// 'pdfioContentTextNextLine()' - Move to the next line.
+// 'pdfioContentTextNewLine()' - Move to the next line.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLine(
+    pdfio_stream_t *st)			// I - Stream
+{
+  return (pdfioStreamPuts(st, "T*\n"));
+}
+
+
+//
+// 'pdfioContentTextNextLine()' - Legacy function name preserved for binary compatibility.
+//
+// @private@
 //
 
 bool					// O - `true` on success, `false` on failure
@@ -1082,6 +1212,86 @@ pdfioContentTextNextLine(
 }
 
 
+//
+// 'pdfioContentTextNewLineShow()' - Move to the next line and show text.
+//
+// This function moves to the next line and then shows some text with optional
+// word and character spacing in a PDF content stream. The "unicode" argument
+// specifies that the current font maps to full Unicode.  The "s" argument
+// specifies a UTF-8 encoded string.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLineShow(
+    pdfio_stream_t *st,			// I - Stream
+    double         ws,			// I - Word spacing or `0.0` for none
+    double         cs,			// I - Character spacing or `0.0` for none
+    bool           unicode,		// I - Unicode text?
+    const char     *s)			// I - String to show
+{
+  bool	newline = false;		// New line?
+  char	op;				// Text operator
+
+
+  // Write word and/or character spacing as needed...
+  if (ws > 0.0 || cs > 0.0)
+  {
+    // Use " operator to show text with word and character spacing...
+    if (!pdfioStreamPrintf(st, "%g %g", ws, cs))
+      return (false);
+
+    op = '\"';
+  }
+  else
+  {
+    // Use ' operator to show text with the defaults...
+    op = '\'';
+  }
+
+  // Write the string...
+  if (!write_string(st, unicode, s, &newline))
+    return (false);
+
+  // Draw it...
+  if (newline)
+    return (pdfioStreamPrintf(st, "%c T*\n", op));
+  else
+    return (pdfioStreamPrintf(st, "%c\n", op));
+}
+
+
+//
+// 'pdfioContentTextNewLineShowf()' - Show formatted text.
+//
+// This function moves to the next line and shows some formatted text with
+// optional word and character spacing in a PDF content stream. The "unicode"
+// argument specifies that the current font maps to full Unicode.  The "format"
+// argument specifies a UTF-8 encoded `printf`-style format string.
+//
+
+bool					// O - `true` on success, `false` on failure
+pdfioContentTextNewLineShowf(
+    pdfio_stream_t *st,			// I - Stream
+    double         ws,			// I - Word spacing or `0.0` for none
+    double         cs,			// I - Character spacing or `0.0` for none
+    bool           unicode,		// I - Unicode text?
+    const char     *format,		// I - `printf`-style format string
+    ...)				// I - Additional arguments as needed
+{
+  char		buffer[8192];		// Text buffer
+  va_list	ap;			// Argument pointer
+
+
+  // Format the string...
+  va_start(ap, format);
+  vsnprintf(buffer, sizeof(buffer), format, ap);
+  va_end(ap);
+
+  // Show it...
+  return (pdfioContentTextNewLineShow(st, ws, cs, unicode, buffer));
+}
+
+
 //
 // 'pdfioContentTextShow()' - Show text.
 //
@@ -1114,9 +1324,9 @@ pdfioContentTextShow(
 //
 // 'pdfioContentTextShowf()' - Show formatted text.
 //
-// This function shows some text in a PDF content stream. The "unicode" argument
-// specifies that the current font maps to full Unicode.  The "format" argument
-// specifies a UTF-8 encoded `printf`-style format string.
+// This function shows some formatted text in a PDF content stream. The
+// "unicode" argument specifies that the current font maps to full Unicode.
+// The "format" argument specifies a UTF-8 encoded `printf`-style format string.
 //
 
 bool
@@ -1267,13 +1477,13 @@ pdfioFileCreateFontObjFromFile(
   pdfio_dict_t	*dict,			// Font dictionary
 		*desc,			// Font descriptor
 		*file;			// Font file dictionary
-  pdfio_obj_t	*obj,			// Font object
+  pdfio_obj_t	*obj = NULL,		// Font object
 		*desc_obj,		// Font descriptor object
 		*file_obj;		// Font file object
   const char	*basefont;		// Base font name
   pdfio_array_t	*bbox;			// Font bounding box array
   pdfio_stream_t *st;			// Font stream
-  int		fd;			// File
+  int		fd = -1;		// File
   unsigned char	buffer[16384];		// Read buffer
   ssize_t	bytes;			// Bytes read
 
@@ -1302,48 +1512,32 @@ pdfioFileCreateFontObjFromFile(
 
   // Create the font file dictionary and object...
   if ((file = pdfioDictCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   pdfioDictSetName(file, "Filter", "FlateDecode");
 
   if ((file_obj = pdfioFileCreateObj(pdf, file)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   if ((st = pdfioObjCreateStream(file_obj, PDFIO_FILTER_FLATE)) == NULL)
-  {
-    ttfDelete(font);
-    close(fd);
-    return (NULL);
-  }
+    goto done;
 
   while ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
   {
     if (!pdfioStreamWrite(st, buffer, (size_t)bytes))
     {
-      ttfDelete(font);
-      close(fd);
       pdfioStreamClose(st);
-      return (NULL);
+      goto done;
     }
   }
 
   close(fd);
+  fd = -1;
   pdfioStreamClose(st);
 
   // Create the font descriptor dictionary and object...
   if ((bbox = pdfioArrayCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   ttfGetBounds(font, &bounds);
 
@@ -1353,10 +1547,7 @@ pdfioFileCreateFontObjFromFile(
   pdfioArrayAppendNumber(bbox, bounds.top);
 
   if ((desc = pdfioDictCreate(pdf)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   basefont = pdfioStringCreate(pdf, ttfGetPostScriptName(font));
 
@@ -1375,59 +1566,70 @@ pdfioFileCreateFontObjFromFile(
   pdfioDictSetNumber(desc, "StemV", ttfGetWeight(font) / 4 + 25);
 
   if ((desc_obj = pdfioFileCreateObj(pdf, desc)) == NULL)
-  {
-    ttfDelete(font);
-    return (NULL);
-  }
+    goto done;
 
   pdfioObjClose(desc_obj);
 
   if (unicode)
   {
     // Unicode (CID) font...
-    pdfio_dict_t	*cid2gid;	// CIDToGIDMap dictionary
-    pdfio_obj_t		*cid2gid_obj;	// CIDToGIDMap object
+    pdfio_dict_t	*cid2gid,	// CIDToGIDMap dictionary
+			*to_unicode;	// ToUnicode dictionary
+    pdfio_obj_t		*cid2gid_obj,	// CIDToGIDMap object
+			*to_unicode_obj;// ToUnicode object
     size_t		i,		// Looping var
+			start,		// Start character
 			num_cmap;	// Number of CMap entries
     const int		*cmap;		// CMap entries
+    int			min_glyph,	// First glyph
+			max_glyph;	// Last glyph
+    unsigned short	glyphs[65536];	// Glyph to Unicode mapping
     unsigned char	*bufptr,	// Pointer into buffer
 			*bufend;	// End of buffer
     pdfio_dict_t	*type2;		// CIDFontType2 font dictionary
     pdfio_obj_t		*type2_obj;	// CIDFontType2 font object
     pdfio_array_t	*descendants;	// Decendant font list
     pdfio_dict_t	*sidict;	// CIDSystemInfo dictionary
+    pdfio_array_t	*w_array,	// Width array
+			*temp_array;	// Temporary width sub-array
+    int			w0, w1;		// Widths
+
+    // Create a CIDSystemInfo mapping to Adobe UCS2 v0 (Unicode)
+    if ((sidict = pdfioDictCreate(pdf)) == NULL)
+      goto done;
+
+    pdfioDictSetString(sidict, "Registry", "Adobe");
+    pdfioDictSetString(sidict, "Ordering", "Identity");
+    pdfioDictSetNumber(sidict, "Supplement", 0);
 
     // Create a CIDToGIDMap object for the Unicode font...
     if ((cid2gid = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
 #ifndef DEBUG
     pdfioDictSetName(cid2gid, "Filter", "FlateDecode");
 #endif // !DEBUG
 
     if ((cid2gid_obj = pdfioFileCreateObj(pdf, cid2gid)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
 #ifdef DEBUG
     if ((st = pdfioObjCreateStream(cid2gid_obj, PDFIO_FILTER_NONE)) == NULL)
 #else
     if ((st = pdfioObjCreateStream(cid2gid_obj, PDFIO_FILTER_FLATE)) == NULL)
 #endif // DEBUG
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
-    cmap = ttfGetCMap(font, &num_cmap);
+    cmap      = ttfGetCMap(font, &num_cmap);
+    min_glyph = 65536;
+    max_glyph = 0;
+    memset(glyphs, 0, sizeof(glyphs));
+
+    PDFIO_DEBUG("pdfioFileCreateFontObjFromFile: num_cmap=%u\n", (unsigned)num_cmap);
 
     for (i = 0, bufptr = buffer, bufend = buffer + sizeof(buffer); i < num_cmap; i ++)
     {
+      PDFIO_DEBUG("pdfioFileCreateFontObjFromFile: cmap[%u]=%d\n", (unsigned)i, cmap[i]);
       if (cmap[i] < 0)
       {
         // Map undefined glyph to .notdef...
@@ -1439,6 +1641,12 @@ pdfioFileCreateFontObjFromFile(
         // Map to specified glyph...
         *bufptr++ = (unsigned char)(cmap[i] >> 8);
         *bufptr++ = (unsigned char)(cmap[i] & 255);
+
+        glyphs[cmap[i]] = (unsigned short)i;
+        if (cmap[i] < min_glyph)
+          min_glyph = cmap[i];
+        if (cmap[i] > max_glyph)
+          max_glyph = cmap[i];
       }
 
       if (bufptr >= bufend)
@@ -1447,8 +1655,7 @@ pdfioFileCreateFontObjFromFile(
         if (!pdfioStreamWrite(st, buffer, (size_t)(bufptr - buffer)))
         {
 	  pdfioStreamClose(st);
-          ttfDelete(font);
-          return (NULL);
+	  goto done;
         }
 
         bufptr = buffer;
@@ -1461,30 +1668,102 @@ pdfioFileCreateFontObjFromFile(
       if (!pdfioStreamWrite(st, buffer, (size_t)(bufptr - buffer)))
       {
 	pdfioStreamClose(st);
-	ttfDelete(font);
-	return (NULL);
+	goto done;
       }
     }
 
     pdfioStreamClose(st);
 
+    // ToUnicode mapping object
+    to_unicode = pdfioDictCreate(pdf);
+    pdfioDictSetName(to_unicode, "Type", "CMap");
+    pdfioDictSetName(to_unicode, "CMapName", "Adobe-Identity-UCS2");
+    pdfioDictSetDict(to_unicode, "CIDSystemInfo", sidict);
+
+#ifndef DEBUG
+    pdfioDictSetName(to_unicode, "Filter", "FlateDecode");
+#endif // !DEBUG
+
+    if ((to_unicode_obj = pdfioFileCreateObj(pdf, to_unicode)) == NULL)
+      goto done;
+
+#ifdef DEBUG
+    if ((st = pdfioObjCreateStream(to_unicode_obj, PDFIO_FILTER_NONE)) == NULL)
+#else
+    if ((st = pdfioObjCreateStream(to_unicode_obj, PDFIO_FILTER_FLATE)) == NULL)
+#endif // DEBUG
+      goto done;
+
+    pdfioStreamPuts(st,
+		    "stream\n"
+		    "/CIDInit /ProcSet findresource begin\n"
+		    "12 dict begin\n"
+		    "begincmap\n"
+		    "/CIDSystemInfo<<\n"
+		    "/Registry (Adobe)\n"
+		    "/Ordering (UCS2)\n"
+		    "/Supplement 0\n"
+		    ">> def\n"
+		    "/CMapName /Adobe-Identity-UCS2 def\n"
+		    "/CMapType 2 def\n"
+		    "1 begincodespacerange\n"
+		    "<0000> <FFFF>\n"
+		    "endcodespacerange\n"
+		    "1 beginbfrange\n"
+		    "<0000> <FFFF> <0000>\n"
+                    "endbfrange\n"
+                    "endcmap\n"
+                    "CMapName currentdict /CMap defineresource pop\n"
+                    "end\n"
+                    "end\n");
+
+    pdfioStreamClose(st);
+
     // Create a CIDFontType2 dictionary for the Unicode font...
     if ((type2 = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
-    if ((sidict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+    // Width array
+    if ((w_array = pdfioArrayCreate(pdf)) == NULL)
+      goto done;
 
-    // CIDSystemInfo mapping to Adobe UCS2 v0 (Unicode)
-    pdfioDictSetString(sidict, "Registry", "Adobe");
-    pdfioDictSetString(sidict, "Ordering", "Identity");
-    pdfioDictSetNumber(sidict, "Supplement", 0);
+    for (start = 0, w0 = ttfGetWidth(font, 0), w1 = 0, i = 1; i < 65536; start = i, w0 = w1, i ++)
+    {
+      while (i < 65536 && (w1 = ttfGetWidth(font, (int)i)) == w0)
+        i ++;
+
+      if ((i - start) > 1)
+      {
+        // Encode a repeating sequence...
+        pdfioArrayAppendNumber(w_array, start);
+        pdfioArrayAppendNumber(w_array, i - 1);
+        pdfioArrayAppendNumber(w_array, w0);
+      }
+      else
+      {
+        // Encode a non-repeating sequence...
+        pdfioArrayAppendNumber(w_array, start);
+
+        if ((temp_array = pdfioArrayCreate(pdf)) == NULL)
+	  goto done;
+
+        pdfioArrayAppendNumber(temp_array, w0);
+        for (w0 = w1, i ++; i < 65536; w0 = w1, i ++)
+        {
+          if ((w1 = ttfGetWidth(font, (int)i)) == w0 && i < 65535)
+            break;
+
+	  pdfioArrayAppendNumber(temp_array, w0);
+        }
+
+        if (i == 65536)
+	  pdfioArrayAppendNumber(temp_array, w0);
+	else
+	  i --;
+
+        pdfioArrayAppendArray(w_array, temp_array);
+      }
+    }
 
     // Then the dictionary for the CID base font...
     pdfioDictSetName(type2, "Type", "Font");
@@ -1493,56 +1772,41 @@ pdfioFileCreateFontObjFromFile(
     pdfioDictSetDict(type2, "CIDSystemInfo", sidict);
     pdfioDictSetObj(type2, "CIDToGIDMap", cid2gid_obj);
     pdfioDictSetObj(type2, "FontDescriptor", desc_obj);
+    pdfioDictSetArray(type2, "W", w_array);
 
     if ((type2_obj = pdfioFileCreateObj(pdf, type2)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioObjClose(type2_obj);
 
     // Create a Type 0 font object...
     if ((descendants = pdfioArrayCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioArrayAppendObj(descendants, type2_obj);
 
     if ((dict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioDictSetName(dict, "Type", "Font");
     pdfioDictSetName(dict, "Subtype", "Type0");
     pdfioDictSetName(dict, "BaseFont", basefont);
     pdfioDictSetArray(dict, "DescendantFonts", descendants);
     pdfioDictSetName(dict, "Encoding", "Identity-H");
+    pdfioDictSetObj(dict, "ToUnicode", to_unicode_obj);
 
-    if ((obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-      return (NULL);
-
-    pdfioObjClose(obj);
+    if ((obj = pdfioFileCreateObj(pdf, dict)) != NULL)
+      pdfioObjClose(obj);
   }
   else
   {
     // Simple (CP1282 or custom encoding) 8-bit font...
     if (ttfGetMaxChar(font) >= 255 && !pdf->cp1252_obj && !create_cp1252(pdf))
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     // Create a TrueType font object...
     if ((dict = pdfioDictCreate(pdf)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
+      goto done;
 
     pdfioDictSetName(dict, "Type", "Font");
     pdfioDictSetName(dict, "Subtype", "TrueType");
@@ -1552,16 +1816,16 @@ pdfioFileCreateFontObjFromFile(
 
     pdfioDictSetObj(dict, "FontDescriptor", desc_obj);
 
-    if ((obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-    {
-      ttfDelete(font);
-      return (NULL);
-    }
-
-    pdfioObjClose(obj);
+    if ((obj = pdfioFileCreateObj(pdf, dict)) != NULL)
+      pdfioObjClose(obj);
   }
 
-  ttfDelete(font);
+  done:
+
+  if (fd >= 0)
+    close(fd);
+
+  _pdfioObjSetExtension(obj, font, (_pdfio_extfree_t)ttfDelete);
 
   return (obj);
 }

pdfio-content.h

@@ -1,7 +1,7 @@
 //
 // Public content header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,18 +9,7 @@
 
 #ifndef PDFIO_CONTENT_H
 #  define PDFIO_CONTENT_H
-
-//
-// Include necessary headers...
-//
-
 #  include "pdfio.h"
-
-
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 extern "C" {
 #  endif // __cplusplus
@@ -91,6 +80,7 @@ extern bool		pdfioContentPathClose(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve(pdfio_stream_t *st, double x1, double y1, double x2, double y2, double x3, double y3) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve13(pdfio_stream_t *st, double x1, double y1, double x3, double y3) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathCurve23(pdfio_stream_t *st, double x2, double y2, double x3, double y3) _PDFIO_PUBLIC;
+extern bool		pdfioContentPathEnd(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathLineTo(pdfio_stream_t *st, double x, double y) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathMoveTo(pdfio_stream_t *st, double x, double y) _PDFIO_PUBLIC;
 extern bool		pdfioContentPathRect(pdfio_stream_t *st, double x, double y, double width, double height) _PDFIO_PUBLIC;
@@ -125,8 +115,12 @@ extern bool		pdfioContentSetTextXScaling(pdfio_stream_t *st, double percent) _PD
 extern bool		pdfioContentStroke(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextBegin(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextEnd(pdfio_stream_t *st) _PDFIO_PUBLIC;
+extern double		pdfioContentTextMeasure(pdfio_obj_t *font, const char *s, double size) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextMoveLine(pdfio_stream_t *st, double tx, double ty) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextMoveTo(pdfio_stream_t *st, double tx, double ty) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLine(pdfio_stream_t *st) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLineShow(pdfio_stream_t *st, double ws, double cs, bool unicode, const char *s) _PDFIO_PUBLIC;
+extern bool		pdfioContentTextNewLineShowf(pdfio_stream_t *st, double ws, double cs, bool unicode, const char *format, ...) _PDFIO_PUBLIC _PDFIO_FORMAT(5,6);
 extern bool		pdfioContentTextNextLine(pdfio_stream_t *st) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextShow(pdfio_stream_t *st, bool unicode, const char *s) _PDFIO_PUBLIC;
 extern bool		pdfioContentTextShowf(pdfio_stream_t *st, bool unicode, const char *format, ...) _PDFIO_PUBLIC _PDFIO_FORMAT(3,4);
@@ -150,10 +144,6 @@ extern bool		pdfioPageDictAddFont(pdfio_dict_t *dict, const char *name, pdfio_ob
 extern bool		pdfioPageDictAddImage(pdfio_dict_t *dict, const char *name, pdfio_obj_t *obj) _PDFIO_PUBLIC;
 
 
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus

pdfio-crypto.c

@@ -1,16 +1,12 @@
 //
 // Cryptographic support functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 #if _WIN32
 #  include <windows.h>
@@ -403,16 +399,23 @@ _pdfioCryptoMakeRandom(uint8_t *buffer,	// I - Buffer
 //
 
 _pdfio_crypto_cb_t			// O  - Decryption callback or `NULL` for none
- _pdfioCryptoMakeReader(
+_pdfioCryptoMakeReader(
      pdfio_file_t        *pdf,		// I  - PDF file
      pdfio_obj_t         *obj,		// I  - PDF object
      _pdfio_crypto_ctx_t *ctx,		// I  - Pointer to crypto context
      uint8_t             *iv,		// I  - Buffer for initialization vector
      size_t              *ivlen)	// IO - Size of initialization vector
 {
-  uint8_t	data[21];		/* Key data */
-  _pdfio_md5_t	md5;			/* MD5 state */
-  uint8_t	digest[16];		/* MD5 digest value */
+  uint8_t	data[21];		// Key data
+  _pdfio_md5_t	md5;			// MD5 state
+  uint8_t	digest[16];		// MD5 digest value
+#if PDFIO_OBJ_CRYPT
+  pdfio_array_t	*id_array;		// Object ID array
+  unsigned char	*id_value;		// Object ID value
+  size_t	id_len;			// Length of object ID
+  uint8_t	temp_key[16];		// File key for object
+#endif // PDFIO_OBJ_CRYPT
+  uint8_t	*file_key;		// Computed file key to use
 
 
   PDFIO_DEBUG("_pdfioCryptoMakeReader(pdf=%p, obj=%p(%d), ctx=%p, iv=%p, ivlen=%p(%d))\n", pdf, obj, (int)obj->number, ctx, iv, ivlen, (int)*ivlen);
@@ -424,6 +427,59 @@ _pdfio_crypto_cb_t			// O  - Decryption callback or `NULL` for none
     return (NULL);
   }
 
+#if PDFIO_OBJ_CRYPT
+  if ((id_array = pdfioDictGetArray(pdfioObjGetDict(obj), "ID")) != NULL)
+  {
+    // Object has its own ID that will get used for encryption...
+    _pdfio_md5_t md5;			// MD5 context
+    uint8_t	file_digest[16];	// MD5 digest of file ID and pad
+    uint8_t	user_pad[32],		// Padded user password
+		own_user_key[32],	// Calculated user key
+		pdf_user_key[32];	// Decrypted user key
+
+    PDFIO_DEBUG("_pdfioCryptoMakeReader: Per-object file ID.\n");
+
+    if ((id_value = pdfioArrayGetBinary(id_array, 0, &id_len)) == NULL)
+    {
+      *ivlen = 0;
+      return (NULL);
+    }
+
+    _pdfioCryptoMD5Init(&md5);
+    _pdfioCryptoMD5Append(&md5, pdf_passpad, 32);
+    _pdfioCryptoMD5Append(&md5, id_value, id_len);
+    _pdfioCryptoMD5Finish(&md5, file_digest);
+
+    make_owner_key(pdf->encryption, pdf->password, pdf->owner_key, user_pad);
+    make_file_key(pdf->encryption, pdf->permissions, id_value, id_len, user_pad, pdf->owner_key, temp_key);
+    make_user_key(id_value, id_len, own_user_key);
+
+    if (memcmp(own_user_key, pdf->user_key, sizeof(own_user_key)))
+    {
+      PDFIO_DEBUG("_pdfioCryptoMakeReader: Not user password, trying owner password.\n");
+
+      make_file_key(pdf->encryption, pdf->permissions, id_value, id_len, pdf->password, pdf->owner_key, temp_key);
+      make_user_key(id_value, id_len, own_user_key);
+
+      memcpy(pdf_user_key, pdf->user_key, sizeof(pdf_user_key));
+      decrypt_user_key(pdf->encryption, temp_key, pdf_user_key);
+
+      if (memcmp(pdf->password, pdf_user_key, 32) && memcmp(own_user_key, pdf_user_key, 16))
+      {
+	*ivlen = 0;
+	return (NULL);
+      }
+    }
+
+    file_key = temp_key;
+  }
+  else
+#endif // PDFIO_OBJ_CRYPT
+  {
+    // Use the default file key...
+    file_key = pdf->file_key;
+  }
+
   switch (pdf->encryption)
   {
     default :
@@ -432,7 +488,7 @@ _pdfio_crypto_cb_t			// O  - Decryption callback or `NULL` for none
 
     case PDFIO_ENCRYPTION_RC4_40 :
 	// Copy the key data for the MD5 hash.
-	memcpy(data, pdf->file_key, sizeof(pdf->file_key));
+	memcpy(data, file_key, 16);
 	data[16] = (uint8_t)obj->number;
 	data[17] = (uint8_t)(obj->number >> 8);
 	data[18] = (uint8_t)(obj->number >> 16);
@@ -446,12 +502,20 @@ _pdfio_crypto_cb_t			// O  - Decryption callback or `NULL` for none
 
         // Initialize the RC4 context using 40 bits of the digest...
 	_pdfioCryptoRC4Init(&ctx->rc4, digest, 5);
+	*ivlen = 0;
 	return ((_pdfio_crypto_cb_t)_pdfioCryptoRC4Crypt);
 
-    case PDFIO_ENCRYPTION_RC4_128 :
     case PDFIO_ENCRYPTION_AES_128 :
+        if (*ivlen < 16)
+        {
+          *ivlen = 0;
+          _pdfioFileError(pdf, "Value too short for AES encryption.");
+          return (NULL);
+        }
+
+    case PDFIO_ENCRYPTION_RC4_128 :
 	// Copy the key data for the MD5 hash.
-	memcpy(data, pdf->file_key, sizeof(pdf->file_key));
+	memcpy(data, file_key, 16);
 	data[16] = (uint8_t)obj->number;
 	data[17] = (uint8_t)(obj->number >> 8);
 	data[18] = (uint8_t)(obj->number >> 16);
@@ -487,7 +551,7 @@ _pdfio_crypto_cb_t			// O  - Decryption callback or `NULL` for none
 //
 
 _pdfio_crypto_cb_t			// O  - Encryption callback or `NULL` for none
- _pdfioCryptoMakeWriter(
+_pdfioCryptoMakeWriter(
      pdfio_file_t        *pdf,		// I  - PDF file
      pdfio_obj_t         *obj,		// I  - PDF object
      _pdfio_crypto_ctx_t *ctx,		// I  - Pointer to crypto context
@@ -592,6 +656,8 @@ _pdfioCryptoUnlock(
   revision = (int)pdfioDictGetNumber(encrypt_dict, "R");
   length   = (int)pdfioDictGetNumber(encrypt_dict, "Length");
 
+  PDFIO_DEBUG("_pdfioCryptoUnlock: handler=%p(%s), version=%d, revision=%d, length=%d\n", (void *)handler, handler ? handler : "(null)", version, revision, length);
+
   if (!handler || strcmp(handler, "Standard"))
   {
     _pdfioFileError(pdf, "Unsupported security handler '%s'.", handler ? handler : "(null)");
@@ -640,6 +706,8 @@ _pdfioCryptoUnlock(
     }
     else
     {
+      PDFIO_DEBUG("_pdfioCryptoUnlock: CFM=\"%s\"\n", cfm);
+
       if (length < 40 || length > 128)
 	length = 128;			// Default to 128 bits
 
@@ -765,17 +833,16 @@ _pdfioCryptoUnlock(
       {
         // Matches!
         memcpy(pdf->file_key, file_key, sizeof(pdf->file_key));
+        memcpy(pdf->password, pad, sizeof(pdf->password));
+
         return (true);
       }
 
-     /*
-      * Not the owner password, try the user password...
-      */
-
+      // Not the owner password, try the user password...
       make_file_key(pdf->encryption, pdf->permissions, file_id, file_idlen, pad, pdf->owner_key, file_key);
       PDFIO_DEBUG("_pdfioCryptoUnlock: Fuse=%02X%02X%02X%02X...%02X%02X%02X%02X\n", file_key[0], file_key[1], file_key[2], file_key[3], file_key[12], file_key[13], file_key[14], file_key[15]);
 
-      make_user_key(file_id, file_idlen, user_key);
+      make_user_key(file_id, file_idlen, own_user_key);
 
       memcpy(pdf_user_key, pdf->user_key, sizeof(pdf_user_key));
       decrypt_user_key(pdf->encryption, file_key, pdf_user_key);
@@ -783,10 +850,12 @@ _pdfioCryptoUnlock(
       PDFIO_DEBUG("_pdfioCryptoUnlock: Uuse=%02X%02X%02X%02X...%02X%02X%02X%02X\n", user_key[0], user_key[1], user_key[2], user_key[3], user_key[28], user_key[29], user_key[30], user_key[31]);
       PDFIO_DEBUG("_pdfioCryptoUnlock: Updf=%02X%02X%02X%02X...%02X%02X%02X%02X\n", pdf_user_key[0], pdf_user_key[1], pdf_user_key[2], pdf_user_key[3], pdf_user_key[28], pdf_user_key[29], pdf_user_key[30], pdf_user_key[31]);
 
-      if (!memcmp(pad, pdf_user_key, 32) || !memcmp(user_key, pdf_user_key, 16))
+      if (!memcmp(pad, pdf_user_key, 32) || !memcmp(own_user_key, pdf_user_key, 16))
       {
         // Matches!
         memcpy(pdf->file_key, file_key, sizeof(pdf->file_key));
+        memcpy(pdf->password, pad, sizeof(pdf->password));
+
         return (true);
       }
     }

pdfio-dict.c

@@ -1,16 +1,12 @@
 //
 // PDF dictionary functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -162,6 +158,30 @@ pdfioDictCreate(pdfio_file_t *pdf)	// I - PDF file
 }
 
 
+//
+// '_pdfioDictDecrypt()' - Decrypt the values in a dictionary.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioDictDecrypt(pdfio_file_t *pdf,	// I - PDF file
+                  pdfio_obj_t  *obj,	// I - Object
+                  pdfio_dict_t *dict,	// I - Dictionary
+                  size_t       depth)	// I - Depth
+{
+  size_t	i;			// Looping var
+  _pdfio_pair_t	*pair;			// Current pair
+
+
+  for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
+  {
+    if (strcmp(pair->key, "ID") && !_pdfioValueDecrypt(pdf, obj, &pair->value, depth + 1))
+      return (false);
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioDictDebug()' - Dump a dictionary to stderr.
 //
@@ -464,6 +484,47 @@ _pdfioDictGetValue(pdfio_dict_t *dict,	// I - Dictionary
 }
 
 
+//
+// 'pdfioDictIterateKeys()' - Iterate the keys in a dictionary.
+//
+// This function iterates the keys in a dictionary, calling the supplied
+// function "cb":
+//
+// ```
+// bool
+// my_dict_cb(pdfio_dict_t *dict, const char *key, void *cb_data)
+// {
+// ... "key" contains the dictionary key ...
+// ... return true to continue or false to stop ...
+// }
+// ```
+//
+// The iteration continues as long as the callback returns `true` or all keys
+// have been iterated.
+//
+
+void
+pdfioDictIterateKeys(
+    pdfio_dict_t    *dict,		// I - Dictionary
+    pdfio_dict_cb_t cb,			// I - Callback function
+    void            *cb_data)		// I - Callback data
+{
+  size_t	i;			// Looping var
+  _pdfio_pair_t	*pair;			// Current pair
+
+
+  // Range check input...
+  if (!dict || !cb)
+    return;
+
+  for (i = dict->num_pairs, pair = dict->pairs; i > 0; i --, pair ++)
+  {
+    if (!(cb)(dict, pair->key, cb_data))
+      break;
+  }
+}
+
+
 //
 // '_pdfioDictRead()' - Read a dictionary from a PDF file.
 //
@@ -481,7 +542,7 @@ _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
   _pdfio_value_t	value;		// Dictionary value
 
 
-  PDFIO_DEBUG("_pdfioDictRead(pdf=%p)\n", pdf);
+  PDFIO_DEBUG("_pdfioDictRead(pdf=%p, obj=%p, tb=%p, depth=%lu)\n", pdf, obj, tb, (unsigned long)depth);
 
   // Create a dictionary and start reading...
   if ((dict = pdfioDictCreate(pdf)) == NULL)
@@ -493,6 +554,7 @@ _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
     if (!strcmp(key, ">>"))
     {
       // End of dictionary...
+      PDFIO_DEBUG("_pdfioDictRead: Returning dictionary value...\n");
       return (dict);
     }
     else if (key[0] != '/')
@@ -500,18 +562,25 @@ _pdfioDictRead(pdfio_file_t   *pdf,	// I - PDF file
       _pdfioFileError(pdf, "Invalid dictionary contents.");
       break;
     }
+    else if (_pdfioDictGetValue(dict, key + 1))
+    {
+      _pdfioFileError(pdf, "Duplicate dictionary key '%s'.", key + 1);
+      return (NULL);
+    }
 
     // Then get the next value...
+    PDFIO_DEBUG("_pdfioDictRead: Reading value for '%s'.\n", key + 1);
+
     if (!_pdfioValueRead(pdf, obj, tb, &value, depth))
     {
-      _pdfioFileError(pdf, "Missing value for dictionary key.");
+      _pdfioFileError(pdf, "Missing value for dictionary key '%s'.", key + 1);
       break;
     }
 
     if (!_pdfioDictSetValue(dict, pdfioStringCreate(pdf, key + 1), &value))
       break;
 
-//    PDFIO_DEBUG("_pdfioDictRead: Set %s.\n", key);
+    PDFIO_DEBUG("_pdfioDictRead: Set %s.\n", key);
   }
 
   // Dictionary is invalid - pdfioFileClose will free the memory, return NULL
@@ -707,7 +776,7 @@ pdfioDictSetNull(pdfio_dict_t *dict,	// I - Dictionary
 bool					// O - `true` on success, `false` on failure
 pdfioDictSetNumber(pdfio_dict_t  *dict,	// I - Dictionary
                    const char    *key,	// I - Key
-                   double         value)	// I - Value
+                   double        value)	// I - Value
 {
   _pdfio_value_t temp;			// New value
 
@@ -891,9 +960,9 @@ _pdfioDictSetValue(
 
 #ifdef DEBUG
   PDFIO_DEBUG("_pdfioDictSetValue(%p): %lu pairs\n", (void *)dict, (unsigned long)dict->num_pairs);
-  PDFIO_DEBUG("_pdfioDictSetValue(%p): ", (void *)dict);
-  PDFIO_DEBUG_DICT(dict);
-  PDFIO_DEBUG("\n");
+//  PDFIO_DEBUG("_pdfioDictSetValue(%p): ", (void *)dict);
+//  PDFIO_DEBUG_DICT(dict);
+//  PDFIO_DEBUG("\n");
 #endif // DEBUG
 
   return (true);

pdfio-file.c

@@ -1,16 +1,12 @@
 //
 // PDF file functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 #ifndef O_BINARY
 #  define O_BINARY 0
@@ -23,7 +19,7 @@
 
 static pdfio_obj_t	*add_obj(pdfio_file_t *pdf, size_t number, unsigned short generation, off_t offset);
 static int		compare_objmaps(_pdfio_objmap_t *a, _pdfio_objmap_t *b);
-static int		compare_objs(pdfio_obj_t **a, pdfio_obj_t **b);
+static const char	*get_info_string(pdfio_file_t *pdf, const char *key);
 static bool		load_obj_stream(pdfio_obj_t *obj);
 static bool		load_pages(pdfio_file_t *pdf, pdfio_obj_t *obj, size_t depth);
 static bool		load_xref(pdfio_file_t *pdf, off_t xref_offset, pdfio_password_cb_t password_cb, void *password_data);
@@ -264,46 +260,26 @@ pdfioFileCreate(
 
   // Write a standard PDF header...
   if (!_pdfioFilePrintf(pdf, "%%PDF-%s\n%%\342\343\317\323\n", version))
-  {
-    pdfioFileClose(pdf);
-    unlink(filename);
-    return (NULL);
-  }
+    goto error;
 
   // Create the pages object...
   if ((dict = pdfioDictCreate(pdf)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    unlink(filename);
-    return (NULL);
-  }
+    goto error;
 
   pdfioDictSetName(dict, "Type", "Pages");
 
   if ((pdf->pages_obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    unlink(filename);
-    return (NULL);
-  }
+    goto error;
 
   // Create the info object...
   if ((info_dict = pdfioDictCreate(pdf)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    unlink(filename);
-    return (NULL);
-  }
+    goto error;
 
   pdfioDictSetDate(info_dict, "CreationDate", time(NULL));
   pdfioDictSetString(info_dict, "Producer", "pdfio/" PDFIO_VERSION);
 
   if ((pdf->info_obj = pdfioFileCreateObj(pdf, info_dict)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    unlink(filename);
-    return (NULL);
-  }
+    goto error;
 
   // Create random file ID values...
   _pdfioCryptoMakeRandom(id_value, sizeof(id_value));
@@ -315,6 +291,15 @@ pdfioFileCreate(
   }
 
   return (pdf);
+
+  // Common error handling code...
+  error:
+
+  pdfioFileClose(pdf);
+
+  unlink(filename);
+
+  return (NULL);
 }
 
 
@@ -344,6 +329,32 @@ pdfioFileCreateArrayObj(
 }
 
 
+//
+// 'pdfioFileCreateNumberObj()' - Create a new object in a PDF file containing a number.
+//
+// This function creates a new object with a number value in a PDF file.
+// You must call @link pdfioObjClose@ to write the object to the file.
+//
+
+pdfio_obj_t *				// O - New object
+pdfioFileCreateNumberObj(
+    pdfio_file_t *pdf,			// I - PDF file
+    double       number)		// I - Number value
+{
+  _pdfio_value_t	value;		// Object value
+
+
+  // Range check input...
+  if (!pdf)
+    return (NULL);
+
+  value.type         = PDFIO_VALTYPE_NUMBER;
+  value.value.number = number;
+
+  return (_pdfioFileCreateObj(pdf, NULL, &value));
+}
+
+
 //
 // 'pdfioFileCreateObj()' - Create a new object in a PDF file.
 //
@@ -535,41 +546,26 @@ pdfioFileCreateOutput(
 
   // Write a standard PDF header...
   if (!_pdfioFilePrintf(pdf, "%%PDF-%s\n%%\342\343\317\323\n", version))
-  {
-    pdfioFileClose(pdf);
-    return (NULL);
-  }
+    goto error;
 
   // Create the pages object...
   if ((dict = pdfioDictCreate(pdf)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    return (NULL);
-  }
+    goto error;
 
   pdfioDictSetName(dict, "Type", "Pages");
 
   if ((pdf->pages_obj = pdfioFileCreateObj(pdf, dict)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    return (NULL);
-  }
+    goto error;
 
   // Create the info object...
   if ((info_dict = pdfioDictCreate(pdf)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    return (NULL);
-  }
+    goto error;
 
   pdfioDictSetDate(info_dict, "CreationDate", time(NULL));
   pdfioDictSetString(info_dict, "Producer", "pdfio/" PDFIO_VERSION);
 
   if ((pdf->info_obj = pdfioFileCreateObj(pdf, info_dict)) == NULL)
-  {
-    pdfioFileClose(pdf);
-    return (NULL);
-  }
+    goto error;
 
   // Create random file ID values...
   _pdfioCryptoMakeRandom(id_value, sizeof(id_value));
@@ -581,6 +577,13 @@ pdfioFileCreateOutput(
   }
 
   return (pdf);
+
+  // Common error handling code...
+  error:
+
+  pdfioFileClose(pdf);
+
+  return (NULL);
 }
 
 
@@ -657,6 +660,220 @@ pdfioFileCreatePage(pdfio_file_t *pdf,	// I - PDF file
 }
 
 
+//
+// 'pdfioFileCreateStringObj()' - Create a new object in a PDF file containing a string.
+//
+// This function creates a new object with a string value in a PDF file.
+// You must call @link pdfioObjClose@ to write the object to the file.
+//
+
+pdfio_obj_t *				// O - New object
+pdfioFileCreateStringObj(
+    pdfio_file_t *pdf,			// I - PDF file
+    const char   *string)		// I - String
+{
+  _pdfio_value_t	value;		// Object value
+
+
+  // Range check input...
+  if (!pdf)
+    return (NULL);
+
+  value.type         = PDFIO_VALTYPE_STRING;
+  value.value.string = string;
+
+  return (_pdfioFileCreateObj(pdf, NULL, &value));
+}
+
+
+//
+// 'pdfioFileCreateTemporary()' - Create a temporary PDF file.
+//
+// This function creates a PDF file with a unique filename in the current
+// temporary directory.  The temporary file is stored in the string "buffer" an
+// will have a ".pdf" extension.  Otherwise, this function works the same as
+// the @link pdfioFileCreate@ function.
+//
+// @since PDFio v1.1@
+//
+
+pdfio_file_t *
+pdfioFileCreateTemporary(
+    char             *buffer,		// I - Filename buffer
+    size_t           bufsize,		// I - Size of filename buffer
+    const char       *version,		// I - PDF version number or `NULL` for default (2.0)
+    pdfio_rect_t     *media_box,	// I - Default MediaBox for pages
+    pdfio_rect_t     *crop_box,		// I - Default CropBox for pages
+    pdfio_error_cb_t error_cb,		// I - Error callback or `NULL` for default
+    void             *error_data)	// I - Error callback data, if any
+{
+  pdfio_file_t	*pdf;			// PDF file
+  pdfio_dict_t	*dict;			// Dictionary for pages object
+  pdfio_dict_t	*info_dict;		// Dictionary for information object
+  unsigned char	id_value[16];		// File ID value
+  int		i;			// Looping var
+  const char	*tmpdir;		// Temporary directory
+#if _WIN32 || defined(__APPLE__)
+  char		tmppath[256];		// Temporary directory path
+#endif // _WIN32 || __APPLE__
+  unsigned	tmpnum;			// Temporary filename number
+
+
+  // Range check input...
+  if (!buffer || bufsize < 32)
+  {
+    if (buffer)
+      *buffer = '\0';
+    return (NULL);
+  }
+
+  if (!version)
+    version = "2.0";
+
+  if (!error_cb)
+  {
+    error_cb   = _pdfioFileDefaultError;
+    error_data = NULL;
+  }
+
+  // Allocate a PDF file structure...
+  if ((pdf = (pdfio_file_t *)calloc(1, sizeof(pdfio_file_t))) == NULL)
+  {
+    pdfio_file_t temp;			// Dummy file
+    char	message[8192];		// Message string
+
+    temp.filename = (char *)"temporary.pdf";
+    snprintf(message, sizeof(message), "Unable to allocate memory for PDF file - %s", strerror(errno));
+    (error_cb)(&temp, message, error_data);
+
+    *buffer = '\0';
+
+    return (NULL);
+  }
+
+  // Create the file...
+#if _WIN32
+  if ((tmpdir = getenv("TEMP")) == NULL)
+  {
+    GetTempPathA(sizeof(tmppath), tmppath);
+    tmpdir = tmppath;
+  }
+
+#elif defined(__APPLE__)
+  if ((tmpdir = getenv("TMPDIR")) != NULL && access(tmpdir, W_OK))
+    tmpdir = NULL;
+
+  if (!tmpdir)
+  {
+    // Grab the per-process temporary directory for sandboxed apps...
+#  ifdef _CS_DARWIN_USER_TEMP_DIR
+    if (confstr(_CS_DARWIN_USER_TEMP_DIR, tmppath, sizeof(tmppath)))
+      tmpdir = tmppath;
+    else
+#  endif // _CS_DARWIN_USER_TEMP_DIR
+      tmpdir = "/private/tmp";
+  }
+
+#else
+  if ((tmpdir = getenv("TMPDIR")) == NULL || access(tmpdir, W_OK))
+    tmpdir = "/tmp";
+#endif // _WIN32
+
+  for (i = 0; i < 1000; i ++)
+  {
+    _pdfioCryptoMakeRandom((uint8_t *)&tmpnum, sizeof(tmpnum));
+    snprintf(buffer, bufsize, "%s/%08x.pdf", tmpdir, tmpnum);
+    if ((pdf->fd = open(buffer, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC | O_EXCL, 0666)) >= 0)
+      break;
+  }
+
+  pdf->filename = strdup(buffer);
+
+  if (i >= 1000)
+  {
+    _pdfioFileError(pdf, "Unable to create file - %s", strerror(errno));
+    free(pdf->filename);
+    free(pdf);
+    *buffer = '\0';
+    return (NULL);
+  }
+
+  pdf->version     = strdup(version);
+  pdf->mode        = _PDFIO_MODE_WRITE;
+  pdf->error_cb    = error_cb;
+  pdf->error_data  = error_data;
+  pdf->permissions = PDFIO_PERMISSION_ALL;
+  pdf->bufptr      = pdf->buffer;
+  pdf->bufend      = pdf->buffer + sizeof(pdf->buffer);
+
+  if (media_box)
+  {
+    pdf->media_box = *media_box;
+  }
+  else
+  {
+    // Default to "universal" size (intersection of A4 and US Letter)
+    pdf->media_box.x2 = 210.0 * 72.0f / 25.4f;
+    pdf->media_box.y2 = 11.0f * 72.0f;
+  }
+
+  if (crop_box)
+  {
+    pdf->crop_box = *crop_box;
+  }
+  else
+  {
+    // Default to "universal" size (intersection of A4 and US Letter)
+    pdf->crop_box.x2 = 210.0 * 72.0f / 25.4f;
+    pdf->crop_box.y2 = 11.0f * 72.0f;
+  }
+
+  // Write a standard PDF header...
+  if (!_pdfioFilePrintf(pdf, "%%PDF-%s\n%%\342\343\317\323\n", version))
+    goto error;
+
+  // Create the pages object...
+  if ((dict = pdfioDictCreate(pdf)) == NULL)
+    goto error;
+
+  pdfioDictSetName(dict, "Type", "Pages");
+
+  if ((pdf->pages_obj = pdfioFileCreateObj(pdf, dict)) == NULL)
+    goto error;
+
+  // Create the info object...
+  if ((info_dict = pdfioDictCreate(pdf)) == NULL)
+    goto error;
+
+  pdfioDictSetDate(info_dict, "CreationDate", time(NULL));
+  pdfioDictSetString(info_dict, "Producer", "pdfio/" PDFIO_VERSION);
+
+  if ((pdf->info_obj = pdfioFileCreateObj(pdf, info_dict)) == NULL)
+    goto error;
+
+  // Create random file ID values...
+  _pdfioCryptoMakeRandom(id_value, sizeof(id_value));
+
+  if ((pdf->id_array = pdfioArrayCreate(pdf)) != NULL)
+  {
+    pdfioArrayAppendBinary(pdf->id_array, id_value, sizeof(id_value));
+    pdfioArrayAppendBinary(pdf->id_array, id_value, sizeof(id_value));
+  }
+
+  return (pdf);
+
+  // Common error handling code...
+  error:
+
+  pdfioFileClose(pdf);
+
+  unlink(buffer);
+  *buffer = '\0';
+
+  return (NULL);
+}
+
+
 //
 // '_pdfioFileFindMappedObj()' - Find a mapped object.
 //
@@ -698,21 +915,57 @@ pdfioFileFindObj(
     pdfio_file_t *pdf,			// I - PDF file
     size_t       number)		// I - Object number (1 to N)
 {
-  pdfio_obj_t	key,			// Search key
-		*keyptr,		// Pointer to key
-		**match;		// Pointer to match
+  size_t	left,			// Left object
+		right,			// Right object
+		current;		// Current object
 
 
-  if (pdf->num_objs > 0)
+  PDFIO_DEBUG("pdfioFileFindObj(pdf=%p, number=%lu) alloc_objs=%lu, num_objs=%lu, objs=%p\n", (void *)pdf, (unsigned long)number, (unsigned long)(pdf ? pdf->alloc_objs : 0), (unsigned long)(pdf ? pdf->num_objs : 0), (void *)(pdf ? pdf->objs : NULL));
+
+  // Range check input...
+  if (!pdf || pdf->num_objs == 0 || number < 1)
+    return (NULL);
+
+  // Do a binary search for the object...
+  if ((current = number - 1) >= pdf->num_objs)
+    current = pdf->num_objs / 2;
+
+  PDFIO_DEBUG("pdfioFileFindObj: objs[current=%lu]=%p\n", (unsigned long)current, (void *)pdf->objs[current]);
+
+  if (number == pdf->objs[current]->number)
   {
-    key.number = number;
-    keyptr     = &key;
-    match      = (pdfio_obj_t **)bsearch(&keyptr, pdf->objs, pdf->num_objs, sizeof(pdfio_obj_t *), (int (*)(const void *, const void *))compare_objs);
-
-    return (match ? *match : NULL);
+    // Fast match...
+    return (pdf->objs[current]);
+  }
+  else if (number < pdf->objs[current]->number)
+  {
+    left  = 0;
+    right = current;
+  }
+  else
+  {
+    left  = current;
+    right = pdf->num_objs - 1;
   }
 
-  return (NULL);
+  while ((right - left) > 1)
+  {
+    current = (left + right) / 2;
+
+    if (number == pdf->objs[current]->number)
+      return (pdf->objs[current]);
+    else if (number < pdf->objs[current]->number)
+      right = current;
+    else
+      left = current;
+  }
+
+  if (number == pdf->objs[left]->number)
+    return (pdf->objs[left]);
+  else if (number == pdf->objs[right]->number)
+    return (pdf->objs[right]);
+  else
+    return (NULL);
 }
 
 
@@ -723,7 +976,7 @@ pdfioFileFindObj(
 const char *				// O - Author or `NULL` for none
 pdfioFileGetAuthor(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Author") : NULL);
+  return (get_info_string(pdf, "Author"));
 }
 
 
@@ -735,7 +988,7 @@ time_t					// O - Creation date or `0` for none
 pdfioFileGetCreationDate(
     pdfio_file_t *pdf)			// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetDate(pdf->info_obj->value.value.dict, "CreationDate") : 0);
+  return (pdf && pdf->info_obj ? pdfioDictGetDate(pdfioObjGetDict(pdf->info_obj), "CreationDate") : 0);
 }
 
 
@@ -746,7 +999,7 @@ pdfioFileGetCreationDate(
 const char *				// O - Creator string or `NULL` for none
 pdfioFileGetCreator(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Creator") : NULL);
+  return (get_info_string(pdf, "Creator"));
 }
 
 
@@ -768,7 +1021,7 @@ pdfioFileGetID(pdfio_file_t *pdf)	// I - PDF file
 const char *				// O - Keywords string or `NULL` for none
 pdfioFileGetKeywords(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Keywords") : NULL);
+  return (get_info_string(pdf, "Keywords"));
 }
 
 
@@ -872,7 +1125,7 @@ pdfioFileGetPermissions(
 const char *				// O - Producer string or `NULL` for none
 pdfioFileGetProducer(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Producer") : NULL);
+  return (get_info_string(pdf, "Producer"));
 }
 
 
@@ -883,7 +1136,7 @@ pdfioFileGetProducer(pdfio_file_t *pdf)	// I - PDF file
 const char *				// O - Subject or `NULL` for none
 pdfioFileGetSubject(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Subject") : NULL);
+  return (get_info_string(pdf, "Subject"));
 }
 
 
@@ -894,7 +1147,7 @@ pdfioFileGetSubject(pdfio_file_t *pdf)	// I - PDF file
 const char *				// O - Title or `NULL` for none
 pdfioFileGetTitle(pdfio_file_t *pdf)	// I - PDF file
 {
-  return (pdf && pdf->info_obj ? pdfioDictGetString(pdf->info_obj->value.value.dict, "Title") : NULL);
+  return (get_info_string(pdf, "Title"));
 }
 
 
@@ -936,8 +1189,10 @@ pdfioFileOpen(
     void                *error_data)	// I - Error callback data, if any
 {
   pdfio_file_t	*pdf;			// PDF file
-  char		line[1024],		// Line from file
-		*ptr;			// Pointer into line
+  char		line[1025],		// Line from file
+		*ptr,			// Pointer into line
+		*end;			// End of line
+  ssize_t	bytes;			// Bytes read
   off_t		xref_offset;		// Offset to xref table
 
 
@@ -992,21 +1247,29 @@ pdfioFileOpen(
   // Copy the version number...
   pdf->version = strdup(line + 5);
 
-  // Grab the last 32 characters of the file to find the start of the xref table...
-  if (_pdfioFileSeek(pdf, -32, SEEK_END) < 0)
+  // Grab the last 1k of the file to find the start of the xref table...
+  if (_pdfioFileSeek(pdf, -1024, SEEK_END) < 0)
   {
     _pdfioFileError(pdf, "Unable to read startxref data.");
     goto error;
   }
 
-  if (_pdfioFileRead(pdf, line, 32) < 32)
+  if ((bytes = _pdfioFileRead(pdf, line, sizeof(line) - 1)) < 1)
   {
     _pdfioFileError(pdf, "Unable to read startxref data.");
     goto error;
   }
-  line[32] = '\0';
 
-  if ((ptr = strstr(line, "startxref")) == NULL)
+  line[bytes] = '\0';
+  end = line + bytes - 9;
+
+  for (ptr = line; ptr < end; ptr ++)
+  {
+    if (!memcmp(ptr, "startxref", 9))
+      break;
+  }
+
+  if (ptr >= end)
   {
     _pdfioFileError(pdf, "Unable to find start of xref table.");
     goto error;
@@ -1157,6 +1420,9 @@ add_obj(pdfio_file_t   *pdf,		// I - PDF file
 	off_t          offset)		// I - Offset in file
 {
   pdfio_obj_t	*obj;			// Object
+  size_t	left,			// Left object
+		right,			// Right object
+		current;		// Current object (center)
 
 
   // Allocate memory for the object...
@@ -1182,18 +1448,63 @@ add_obj(pdfio_file_t   *pdf,		// I - PDF file
     pdf->alloc_objs += 32;
   }
 
-  pdf->objs[pdf->num_objs ++] = obj;
-
   obj->pdf        = pdf;
   obj->number     = number;
   obj->generation = generation;
   obj->offset     = offset;
 
-  PDFIO_DEBUG("add_obj: obj=%p, ->pdf=%p, ->number=%lu\n", obj, pdf, (unsigned long)obj->number);
+  PDFIO_DEBUG("add_obj: obj=%p, ->pdf=%p, ->number=%lu, ->offset=%lu\n", obj, pdf, (unsigned long)obj->number, (unsigned long)offset);
 
-  // Re-sort object array as needed...
-  if (pdf->num_objs > 1 && pdf->objs[pdf->num_objs - 2]->number > number)
-    qsort(pdf->objs, pdf->num_objs, sizeof(pdfio_obj_t *), (int (*)(const void *, const void *))compare_objs);
+  // Insert object into array as needed...
+  if (pdf->num_objs == 0 || obj->number > pdf->objs[pdf->num_objs - 1]->number)
+  {
+    // Append object...
+    PDFIO_DEBUG("add_obj: Appending at %lu\n", (unsigned long)pdf->num_objs);
+
+    pdf->objs[pdf->num_objs] = obj;
+    pdf->last_obj            = pdf->num_objs;
+  }
+  else
+  {
+    // Insert object...
+    if (obj->number < pdf->objs[pdf->last_obj]->number)
+    {
+      left  = 0;
+      right = pdf->last_obj;
+    }
+    else
+    {
+      left  = pdf->last_obj;
+      right = pdf->num_objs - 1;
+    }
+
+    while ((right - left) > 1)
+    {
+      current = (left + right) / 2;
+
+      if (obj->number < pdf->objs[current]->number)
+        right = current;
+      else
+        left = current;
+    }
+
+    if (obj->number < pdf->objs[left]->number)
+      current = left;
+    else if (obj->number < pdf->objs[right]->number)
+      current = right;
+    else
+      current = right;
+
+    PDFIO_DEBUG("add_obj: Inserting at %lu\n", (unsigned long)current);
+
+    if (current < pdf->num_objs)
+      memmove(pdf->objs + current + 1, pdf->objs + current, (pdf->num_objs - current) * sizeof(pdfio_obj_t *));
+
+    pdf->objs[current] = obj;
+    pdf->last_obj      = current;
+  }
+
+  pdf->num_objs ++;
 
   return (obj);
 }
@@ -1221,19 +1532,47 @@ compare_objmaps(_pdfio_objmap_t *a,	// I - First object map
 
 
 //
-// 'compare_objs()' - Compare the object numbers of two objects.
+// 'get_info_string()' - Get a string value from the Info dictionary.
+//
+// This function also handles converting binary strings to C strings, which
+// occur in encrypted PDF files.
 //
 
-static int				// O - Result of comparison
-compare_objs(pdfio_obj_t **a,		// I - First object
-             pdfio_obj_t **b)		// I - Second object
+static const char *			// O - String or `NULL` if not found
+get_info_string(pdfio_file_t *pdf,	// I - PDF file
+                const char   *key)	// I - Dictionary key
 {
-  if ((*a)->number < (*b)->number)
-    return (-1);
-  else if ((*a)->number == (*b)->number)
-    return (0);
+  pdfio_dict_t	*dict;			// Info dictionary
+  _pdfio_value_t *value;		// Value
+
+  // Range check input...
+  if (!pdf || !pdf->info_obj || (dict = pdfioObjGetDict(pdf->info_obj)) == NULL || (value = _pdfioDictGetValue(dict, key)) == NULL)
+    return (NULL);
+
+  // If we already have a value, return it...
+  if (value->type == PDFIO_VALTYPE_NAME || value->type == PDFIO_VALTYPE_STRING)
+  {
+    return (value->value.string);
+  }
+  else if (value->type == PDFIO_VALTYPE_BINARY && value->value.binary.datalen < 4096)
+  {
+    // Convert binary string to regular string...
+    char	temp[4096];		// Temporary string
+
+    memcpy(temp, value->value.binary.data, value->value.binary.datalen);
+    temp[value->value.binary.datalen] = '\0';
+
+    free(value->value.binary.data);
+    value->type         = PDFIO_VALTYPE_STRING;
+    value->value.string = pdfioStringCreate(pdf, temp);
+
+    return (value->value.string);
+  }
   else
-    return (1);
+  {
+    // Something else that is not a string...
+    return (NULL);
+  }
 }
 
 
@@ -1299,6 +1638,7 @@ load_obj_stream(pdfio_obj_t *obj)	// I - Object to load
 
     // Skip offset
     _pdfioTokenGet(&tb, buffer, sizeof(buffer));
+    PDFIO_DEBUG("load_obj_stream: %ld at offset %s\n", (long)number, buffer);
   }
 
   if (!buffer[0])
@@ -1463,7 +1803,7 @@ load_xref(
       pdfio_stream_t	*st;		// Stream
       unsigned char	buffer[32];	// Read buffer
       size_t		num_sobjs = 0,	// Number of object streams
-			sobjs[4096];	// Object streams to load
+			sobjs[8192];	// Object streams to load
       pdfio_obj_t	*current;	// Current object
 
       if ((number = strtoimax(line, &ptr, 10)) < 1)
@@ -1472,7 +1812,7 @@ load_xref(
 	return (false);
       }
 
-      if ((generation = (int)strtol(ptr, &ptr, 10)) < 0 || generation > 65535)
+      if ((generation = (int)strtol(ptr, &ptr, 10)) < 0 || (generation > 65535 && number != 0))
       {
 	_pdfioFileError(pdf, "Bad xref table header '%s'.", line);
 	return (false);
@@ -1522,6 +1862,10 @@ load_xref(
         return (false);
       }
 
+      PDFIO_DEBUG("load_xref: tb.bufptr=%p, tb.bufend=%p, tb.bufptr[0]=0x%02x, tb.bufptr[0]=0x%02x\n", tb.bufptr, tb.bufend, tb.bufptr[0], tb.bufptr[1]);
+      if (tb.bufptr && tb.bufptr < tb.bufend && (tb.bufptr[0] == 0x0d || tb.bufptr[0] == 0x0a))
+	tb.bufptr ++;			// Skip trailing CR or LF after token
+
       _pdfioTokenFlush(&tb);
 
       obj->stream_offset = _pdfioFileTell(pdf);
@@ -1544,9 +1888,9 @@ load_xref(
       w_2     = w[0];
       w_3     = w[0] + w[1];
 
-      if (w[1] == 0 || w[2] > 2 || w[0] > sizeof(buffer) || w[1] > sizeof(buffer) || w[2] > sizeof(buffer) || w_total > sizeof(buffer))
+      if (w[1] == 0 || w[2] > 4 || w[0] > sizeof(buffer) || w[1] > sizeof(buffer) || w[2] > sizeof(buffer) || w_total > sizeof(buffer))
       {
-	_pdfioFileError(pdf, "Cross-reference stream has invalid W key.");
+	_pdfioFileError(pdf, "Cross-reference stream has invalid W key [%u %u %u].", (unsigned)w[0], (unsigned)w[1], (unsigned)w[2]);
 	return (false);
       }
 
@@ -1586,9 +1930,11 @@ load_xref(
 	    }
 	  }
 
+          // Offset
 	  for (i = 1, offset = buffer[w_2]; i < w[1]; i ++)
 	    offset = (offset << 8) | buffer[w_2 + i];
 
+          // Generation number
 	  switch (w[2])
 	  {
 	    default :
@@ -1600,6 +1946,19 @@ load_xref(
 	    case 2 :
 		generation = (buffer[w_3] << 8) | buffer[w_3 + 1];
 		break;
+	    case 3 :
+	        // Issue #46: Stupid Microsoft PDF generator using 3 bytes to
+	        // encode 16-bit generation numbers == 0 (probably a lazy coder
+	        // stuffing things into an array of 64-bit unsigned integers)
+		generation = (buffer[w_3] << 16) | (buffer[w_3 + 1] << 8) | buffer[w_3 + 2];
+		if (generation > 65535)
+		  generation = 65535;
+		break;
+	    case 4 : // Even stupider :)
+		generation = (buffer[w_3] << 24) | (buffer[w_3 + 1] << 16) | (buffer[w_3 + 2] << 8) | buffer[w_3 + 3];
+		if (generation > 65535)
+		  generation = 65535;
+		break;
 	  }
 
 	  // Create a placeholder for the object in memory...
@@ -1631,8 +1990,18 @@ load_xref(
 		break;
 	    }
 
-	    if (i >= num_sobjs && num_sobjs < (sizeof(sobjs) / sizeof(sobjs[0])))
-	      sobjs[num_sobjs ++] = (size_t)offset;
+	    if (i >= num_sobjs)
+	    {
+	      if (num_sobjs < (sizeof(sobjs) / sizeof(sobjs[0])))
+	      {
+		sobjs[num_sobjs ++] = (size_t)offset;
+	      }
+	      else
+	      {
+		_pdfioFileError(pdf, "Too many object streams.");
+	        return (false);
+	      }
+	    }
 	  }
 	  else if (!current)
 	  {
@@ -1680,15 +2049,35 @@ load_xref(
 	}
       }
     }
-    else if (!strcmp(line, "xref"))
+    else if (!strncmp(line, "xref", 4) && (!line[4] || isspace(line[4] & 255)))
     {
       // Read the xref tables
+      off_t trailer_offset = _pdfioFileTell(pdf);
+					// Offset of current line
+
+      PDFIO_DEBUG("load_xref: Reading xref table starting at offset %lu\n", (unsigned long)trailer_offset);
       while (_pdfioFileGets(pdf, line, sizeof(line)))
       {
-	if (!strcmp(line, "trailer"))
+        PDFIO_DEBUG("load_xref: '%s' at offset %lu\n", line, (unsigned long)trailer_offset);
+
+	if (!strncmp(line, "trailer", 7) && (!line[7] || isspace(line[7] & 255)))
+	{
+	  if (line[7])
+	  {
+	    // Probably the start of the trailer dictionary, rewind the file so
+	    // we can read it...
+	    _pdfioFileSeek(pdf, trailer_offset + 7, SEEK_SET);
+	  }
+
 	  break;
-	else if (!line[0])
-	  continue;
+	}
+	else
+	{
+	  trailer_offset = _pdfioFileTell(pdf);
+
+          if (!line[0])
+	    continue;
+	}
 
 	if (sscanf(line, "%jd%jd", &number, &num_objects) != 2)
 	{
@@ -1719,7 +2108,7 @@ load_xref(
 	    return (false);
 	  }
 
-	  if ((generation = (int)strtol(ptr, &ptr, 10)) < 0 || generation > 65535)
+	  if ((generation = (int)strtol(ptr, &ptr, 10)) < 0 || (generation > 65535 && offset != 0))
 	  {
 	    _pdfioFileError(pdf, "Malformed xref table entry '%s'.", line);
 	    return (false);
@@ -1748,9 +2137,11 @@ load_xref(
 	  if (!add_obj(pdf, (size_t)number, (unsigned short)generation, offset))
 	    return (false);
 	}
+
+	trailer_offset = _pdfioFileTell(pdf);
       }
 
-      if (strcmp(line, "trailer"))
+      if (strncmp(line, "trailer", 7))
       {
 	_pdfioFileError(pdf, "Missing trailer.");
 	return (false);
@@ -1769,6 +2160,8 @@ load_xref(
 	return (false);
       }
 
+      PDFIO_DEBUG("load_xref: Got trailer dict.\n");
+
       _pdfioTokenFlush(&tb);
 
       if (!pdf->trailer_dict)
@@ -1796,8 +2189,19 @@ load_xref(
     PDFIO_DEBUG_VALUE(&trailer);
     PDFIO_DEBUG("\n");
 
-    if ((xref_offset = (off_t)pdfioDictGetNumber(trailer.value.dict, "Prev")) <= 0)
+    off_t new_offset = (off_t)pdfioDictGetNumber(trailer.value.dict, "Prev");
+
+    if (new_offset <= 0)
+    {
       done = true;
+    }
+    else if (new_offset == xref_offset)
+    {
+      _pdfioFileError(pdf, "Recursive xref table.");
+      return (false);
+    }
+
+    xref_offset = new_offset;
   }
 
   // Once we have all of the xref tables loaded, get the important objects and

pdfio-object.c

@@ -1,16 +1,12 @@
 //
 // PDF object functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -33,8 +29,14 @@ pdfioObjClose(pdfio_obj_t *obj)		// I - Object
   if (!obj)
     return (false);
 
+  // Clear the current object pointer...
+  obj->pdf->current_obj = NULL;
+
   if (obj->pdf->mode != _PDFIO_MODE_WRITE)
-    return (true);			// Nothing to do when reading
+  {
+    // Nothing to do when reading
+    return (true);
+  }
 
   // Write what remains for the object...
   if (!obj->offset)
@@ -165,6 +167,12 @@ pdfioObjCreateStream(
     return (NULL);
   }
 
+  if (obj->pdf->current_obj)
+  {
+    _pdfioFileError(obj->pdf, "Another object (%u) is already open.", (unsigned)obj->pdf->current_obj->number);
+    return (NULL);
+  }
+
   // Write the header...
   if (!_pdfioDictGetValue(obj->value.value.dict, "Length"))
   {
@@ -193,7 +201,8 @@ pdfioObjCreateStream(
   if (!_pdfioFilePuts(obj->pdf, "stream\n"))
     return (NULL);
 
-  obj->stream_offset = _pdfioFileTell(obj->pdf);
+  obj->stream_offset    = _pdfioFileTell(obj->pdf);
+  obj->pdf->current_obj = obj;
 
   // Return the new stream...
   return (_pdfioStreamCreate(obj, length_obj, filter));
@@ -208,8 +217,13 @@ void
 _pdfioObjDelete(pdfio_obj_t *obj)	// I - Object
 {
   if (obj)
+  {
     pdfioStreamClose(obj->stream);
 
+    if (obj->datafree)
+      (obj->datafree)(obj->data);
+  }
+
   free(obj);
 }
 
@@ -254,6 +268,17 @@ pdfioObjGetDict(pdfio_obj_t *obj)	// I - Object
 }
 
 
+//
+// '_pdfioObjGetExtension()' - Get the extension pointer for an object.
+//
+
+void *					// O - Extension data
+_pdfioObjGetExtension(pdfio_obj_t *obj)	// I - Object
+{
+  return (obj->data);
+}
+
+
 //
 // 'pdfioObjGetGeneration()' - Get the object's generation number.
 //
@@ -407,6 +432,9 @@ _pdfioObjLoad(pdfio_obj_t *obj)		// I - Object
   }
 
   ptr += 3;
+  while (*ptr && isspace(*ptr & 255))
+    ptr ++;
+
   _pdfioFileConsume(obj->pdf, (size_t)(ptr - line));
 
   // Then grab the object value...
@@ -425,15 +453,29 @@ _pdfioObjLoad(pdfio_obj_t *obj)		// I - Object
     return (false);
   }
 
+  PDFIO_DEBUG("_pdfioObjLoad: tb.bufptr=%p, tb.bufend=%p, tb.bufptr[0]=0x%02x, tb.bufptr[1]=0x%02x\n", tb.bufptr, tb.bufend, tb.bufptr[0], tb.bufptr[1]);
+
   _pdfioTokenFlush(&tb);
 
   if (!strcmp(line, "stream"))
   {
-    // Yes, save its location...
+    // Yes, this is an embedded stream so save its location...
     obj->stream_offset = _pdfioFileTell(obj->pdf);
     PDFIO_DEBUG("_pdfioObjLoad: stream_offset=%lu.\n", (unsigned long)obj->stream_offset);
   }
 
+  // Decrypt as needed...
+  if (obj->pdf->encryption)
+  {
+    PDFIO_DEBUG("_pdfioObjLoad: Decrypting value...\n");
+
+    if (!_pdfioValueDecrypt(obj->pdf, obj, &obj->value, 0))
+    {
+      PDFIO_DEBUG("_pdfioObjLoad: Failed to decrypt.\n");
+      return (false);
+    }
+  }
+
   PDFIO_DEBUG("_pdfioObjLoad: ");
   PDFIO_DEBUG_VALUE(&obj->value);
   PDFIO_DEBUG("\n");
@@ -454,6 +496,12 @@ pdfioObjOpenStream(pdfio_obj_t *obj,	// I - Object
   if (!obj)
     return (NULL);
 
+  if (obj->pdf->current_obj)
+  {
+    _pdfioFileError(obj->pdf, "Another object (%u) is already open.", (unsigned)obj->pdf->current_obj->number);
+    return (NULL);
+  }
+
   // Make sure we've loaded the object dictionary...
   if (!obj->value.type)
   {
@@ -466,10 +514,27 @@ pdfioObjOpenStream(pdfio_obj_t *obj,	// I - Object
     return (NULL);
 
   // Open the stream...
+  obj->pdf->current_obj = obj;
+
   return (_pdfioStreamOpen(obj, decode));
 }
 
 
+//
+// '_pdfioObjSetExtension()' - Set extension data for an object.
+//
+
+void
+_pdfioObjSetExtension(
+    pdfio_obj_t      *obj,		// I - Object
+    void             *data,		// I - Data
+    _pdfio_extfree_t datafree)		// I - Free function
+{
+  obj->data     = data;
+  obj->datafree = datafree;
+}
+
+
 //
 // 'write_obj_header()' - Write the object header...
 //

pdfio-page.c

@@ -7,10 +7,6 @@
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 

pdfio-private.h

@@ -1,7 +1,7 @@
 //
 // Private header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,41 +9,22 @@
 
 #ifndef PDFIO_PRIVATE_H
 #  define PDFIO_PRIVATE_H
-
-//
-// Include necessary headers...
-//
-
 #  ifdef _WIN32
-/*
- * Disable bogus VS warnings/errors...
- */
-
-#    define _CRT_SECURE_NO_WARNINGS
+#    define _CRT_SECURE_NO_WARNINGS	// Disable bogus VS warnings/errors...
 #  endif // _WIN32
-
 #  include "pdfio.h"
 #  include <stdarg.h>
 #  include <stdint.h>
 #  include <string.h>
+#  include <ctype.h>
 #  include <errno.h>
 #  include <inttypes.h>
 #  include <fcntl.h>
 #  ifdef _WIN32
 #    include <io.h>
 #    include <direct.h>
-
-/*
- * Microsoft renames the POSIX functions to _name, and introduces
- * a broken compatibility layer using the original names.  As a result,
- * random crashes can occur when, for example, strdup() allocates memory
- * from a different heap than used by malloc() and free().
- *
- * To avoid moronic problems like this, we #define the POSIX function
- * names to the corresponding non-standard Microsoft names.
- */
-
-#    define access	_access
+#    include <windows.h> // GetTempPathA
+#    define access	_access		// Map standard POSIX/C99 names
 #    define close	_close
 #    define fileno	_fileno
 #    define lseek	_lseek
@@ -56,25 +37,18 @@
 #    define unlink	_unlink
 #    define vsnprintf	_vsnprintf
 #    define write	_write
-
-/*
- * Map various parameters for POSIX...
- */
-
-#    define F_OK	00
+#    define F_OK	00		// POSIX parameters/flags
 #    define W_OK	02
 #    define R_OK	04
-#    define O_RDONLY	_O_RDONLY
+#    define O_RDONLY	_O_RDONLY	// Map standard POSIX open flags
 #    define O_WRONLY	_O_WRONLY
 #    define O_CREAT	_O_CREAT
 #    define O_TRUNC	_O_TRUNC
 #    define O_BINARY	_O_BINARY
 #  else // !_WIN32
 #    include <unistd.h>
-#    define O_BINARY	0
+#    define O_BINARY	0		// Map Windows-specific open flag
 #  endif // _WIN32
-#  include <string.h>
-#  include <ctype.h>
 #  include <zlib.h>
 
 
@@ -118,6 +92,9 @@
 
 #  define PDFIO_MAX_DEPTH	32	// Maximum nesting depth for values
 
+typedef void (*_pdfio_extfree_t)(void *);
+					// Extension data free function
+
 typedef enum _pdfio_mode_e		// Read/write mode
 {
   _PDFIO_MODE_READ,			// Read a PDF file
@@ -260,7 +237,8 @@ struct _pdfio_file_s			// PDF file structure
   pdfio_permission_t permissions;	// Access permissions (encrypted PDF files)
   uint8_t	file_key[16],		// File encryption key
 		owner_key[32],		// Owner encryption key
-		user_key[32];		// User encryption key
+		user_key[32],		// User encryption key
+		password[32];		// Padded password
   size_t	file_keylen,		// Length of file encryption key
 		owner_keylen,		// Length of owner encryption key
 		user_keylen;		// Length of user encryption key
@@ -288,8 +266,10 @@ struct _pdfio_file_s			// PDF file structure
 		alloc_dicts;		// Allocated dictionaries
   pdfio_dict_t	**dicts;		// Dictionaries
   size_t	num_objs,		// Number of objects
-		alloc_objs;		// Allocated objects
-  pdfio_obj_t	**objs;			// Objects
+		alloc_objs,		// Allocated objects
+		last_obj;		// Last object added
+  pdfio_obj_t	**objs,			// Objects
+		*current_obj;		// Current object being written/read
   size_t	num_objmaps,		// Number of object maps
 		alloc_objmaps;		// Allocated object maps
   _pdfio_objmap_t *objmaps;		// Object maps
@@ -312,6 +292,8 @@ struct _pdfio_obj_s			// Object
   size_t	stream_length;		// Length of stream, if any
   _pdfio_value_t value;			// Dictionary/number/etc. value
   pdfio_stream_t *stream;		// Open stream, if any
+  void		*data;			// Extension data, if any
+  _pdfio_extfree_t datafree;		// Free callback for extension data
 };
 
 struct _pdfio_stream_s			// Stream
@@ -340,6 +322,7 @@ struct _pdfio_stream_s			// Stream
 // Functions...
 //
 
+extern bool		_pdfioArrayDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, pdfio_array_t *a, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioArrayDebug(pdfio_array_t *a, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioArrayDelete(pdfio_array_t *a) _PDFIO_INTERNAL;
 extern _pdfio_value_t	*_pdfioArrayGetValue(pdfio_array_t *a, size_t n) _PDFIO_INTERNAL;
@@ -364,6 +347,7 @@ extern void		_pdfioCryptoSHA256Finish(_pdfio_sha256_t *ctx, uint8_t *Message_Dig
 extern bool		_pdfioCryptoUnlock(pdfio_file_t *pdf, pdfio_password_cb_t password_cb, void *password_data) _PDFIO_INTERNAL;
 
 extern void		_pdfioDictClear(pdfio_dict_t *dict, const char *key) _PDFIO_INTERNAL;
+extern bool		_pdfioDictDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, pdfio_dict_t *dict, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioDictDebug(pdfio_dict_t *dict, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioDictDelete(pdfio_dict_t *dict) _PDFIO_INTERNAL;
 extern _pdfio_value_t	*_pdfioDictGetValue(pdfio_dict_t *dict, const char *key) _PDFIO_INTERNAL;
@@ -390,7 +374,9 @@ extern off_t		_pdfioFileTell(pdfio_file_t *pdf) _PDFIO_INTERNAL;
 extern bool		_pdfioFileWrite(pdfio_file_t *pdf, const void *buffer, size_t bytes) _PDFIO_INTERNAL;
 
 extern void		_pdfioObjDelete(pdfio_obj_t *obj) _PDFIO_INTERNAL;
+extern void		*_pdfioObjGetExtension(pdfio_obj_t *obj) _PDFIO_INTERNAL;
 extern bool		_pdfioObjLoad(pdfio_obj_t *obj) _PDFIO_INTERNAL;
+extern void		_pdfioObjSetExtension(pdfio_obj_t *obj, void *data, _pdfio_extfree_t datafree) _PDFIO_INTERNAL;
 
 extern pdfio_stream_t	*_pdfioStreamCreate(pdfio_obj_t *obj, pdfio_obj_t *length_obj, pdfio_filter_t compression) _PDFIO_INTERNAL;
 extern pdfio_stream_t	*_pdfioStreamOpen(pdfio_obj_t *obj, bool decode) _PDFIO_INTERNAL;
@@ -405,9 +391,11 @@ extern void		_pdfioTokenPush(_pdfio_token_t *tb, const char *token) _PDFIO_INTER
 extern bool		_pdfioTokenRead(_pdfio_token_t *tb, char *buffer, size_t bufsize);
 
 extern _pdfio_value_t	*_pdfioValueCopy(pdfio_file_t *pdfdst, _pdfio_value_t *vdst, pdfio_file_t *pdfsrc, _pdfio_value_t *vsrc) _PDFIO_INTERNAL;
+extern bool		_pdfioValueDecrypt(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_value_t *v, size_t depth) _PDFIO_INTERNAL;
 extern void		_pdfioValueDebug(_pdfio_value_t *v, FILE *fp) _PDFIO_INTERNAL;
 extern void		_pdfioValueDelete(_pdfio_value_t *v) _PDFIO_INTERNAL;
 extern _pdfio_value_t	*_pdfioValueRead(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_token_t *ts, _pdfio_value_t *v, size_t depth) _PDFIO_INTERNAL;
 extern bool		_pdfioValueWrite(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_value_t *v, off_t *length) _PDFIO_INTERNAL;
 
+
 #endif // !PDFIO_PRIVATE_H

pdfio-sha256.c

@@ -1,7 +1,7 @@
 //
 // SHA-256 functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 // Copyright © 2011 IETF Trust and the persons identified as authors of the
 // code.  All rights reserved.
 //
@@ -217,7 +217,7 @@ _pdfioCryptoSHA256Append(_pdfio_sha256_t *context, const uint8_t *message_array,
  */
 void
 _pdfioCryptoSHA256Finish(_pdfio_sha256_t *context,
-                 uint8_t Message_Digest[SHA256HashSize])
+                 uint8_t *Message_Digest)
 {
   SHA224_256ResultN(context, Message_Digest, SHA256HashSize);
 }

pdfio-stream.c

@@ -1,16 +1,12 @@
 //
 // PDF stream functions for PDFio.
 //
-// Copyright © 2021-2022 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -174,6 +170,8 @@ pdfioStreamClose(pdfio_stream_t *st)	// I - Stream
 
   done:
 
+  st->pdf->current_obj = NULL;
+
   free(st->prbuffer);
   free(st->psbuffer);
   free(st);
@@ -364,6 +362,13 @@ pdfioStreamConsume(pdfio_stream_t *st,	// I - Stream
 //
 // 'pdfioStreamGetToken()' - Read a single PDF token from a stream.
 //
+// This function reads a single PDF token from a stream.  Operator tokens,
+// boolean values, and numbers are returned as-is in the provided string buffer.
+// String values start with the opening parenthesis ('(') but have all escaping
+// resolved and the terminating parenthesis removed.  Hexadecimal string values
+// start with the opening angle bracket ('<') and have all whitespace and the
+// terminating angle bracket removed.
+//
 
 bool					// O - `true` on success, `false` on EOF
 pdfioStreamGetToken(
@@ -443,6 +448,7 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
       return (NULL);
     }
 
+    PDFIO_DEBUG("_pdfioStreamOpen: ivlen=%d\n", (int)ivlen);
     if (ivlen > 0)
       _pdfioFileConsume(st->pdf, ivlen);
 
@@ -455,11 +461,19 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
     // Try to decode/decompress the contents of this object...
     const char	*filter = pdfioDictGetName(dict, "Filter");
 					// Filter value
+    pdfio_array_t *fa = pdfioDictGetArray(dict, "Filter");
+					// Filter array
+
+    if (!filter && fa && pdfioArrayGetSize(fa) == 1)
+    {
+      // Support single-valued arrays...
+      filter = pdfioArrayGetName(fa, 0);
+    }
 
     if (!filter)
     {
       // No single filter name, do we have a compound filter?
-      if (pdfioDictGetArray(dict, "Filter"))
+      if (fa)
       {
 	// TODO: Implement compound filters...
 	_pdfioFileError(st->pdf, "Unsupported compound stream filter.");
@@ -550,6 +564,7 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
       else
         st->predictor = _PDFIO_PREDICTOR_NONE;
 
+      PDFIO_DEBUG("_pdfioStreamOpen: pos=%ld\n", (long)_pdfioFileTell(st->pdf));
       if (sizeof(st->cbuffer) > st->remaining)
 	rbytes = _pdfioFileRead(st->pdf, st->cbuffer, st->remaining);
       else
@@ -570,12 +585,6 @@ _pdfioStreamOpen(pdfio_obj_t *obj,	// I - Object
       st->flate.next_in  = (Bytef *)st->cbuffer;
       st->flate.avail_in = (uInt)rbytes;
 
-      if (st->cbuffer[0] == 0x0a)
-      {
-        st->flate.next_in ++;		// Skip newline
-        st->flate.avail_in --;
-      }
-
       PDFIO_DEBUG("_pdfioStreamOpen: avail_in=%u, cbuffer=<%02X%02X%02X%02X%02X%02X%02X%02X...>\n", st->flate.avail_in, st->cbuffer[0], st->cbuffer[1], st->cbuffer[2], st->cbuffer[3], st->cbuffer[4], st->cbuffer[5], st->cbuffer[6], st->cbuffer[7]);
 
       if ((status = inflateInit(&(st->flate))) != Z_OK)
@@ -999,6 +1008,7 @@ stream_read(pdfio_stream_t *st,		// I - Stream
             size_t         bytes)	// I - Number of bytes to read
 {
   ssize_t	rbytes;			// Bytes read
+  uInt		avail_in, avail_out;	// Previous flate values
 
 
   if (st->filter == PDFIO_FILTER_NONE)
@@ -1051,9 +1061,17 @@ stream_read(pdfio_stream_t *st,		// I - Stream
       st->flate.next_out  = (Bytef *)buffer;
       st->flate.avail_out = (uInt)bytes;
 
+      avail_in  = st->flate.avail_in;
+      avail_out = st->flate.avail_out;
+
       if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
       {
-	_pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	_pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
+	return (-1);
+      }
+      else if (avail_in == st->flate.avail_in && avail_out == st->flate.avail_out)
+      {
+	_pdfioFileError(st->pdf, "Corrupt stream data.");
 	return (-1);
       }
 
@@ -1104,12 +1122,15 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 	  st->flate.avail_in = (uInt)rbytes;
 	}
 
+        avail_in  = st->flate.avail_in;
+        avail_out = st->flate.avail_out;
+
 	if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
 	{
-	  _pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	  _pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
 	  return (-1);
 	}
-	else if (status == Z_STREAM_END)
+	else if (status == Z_STREAM_END || (avail_in == st->flate.avail_in && avail_out == st->flate.avail_out))
 	  break;
       }
 
@@ -1171,12 +1192,15 @@ stream_read(pdfio_stream_t *st,		// I - Stream
 	  st->flate.avail_in = (uInt)rbytes;
 	}
 
+        avail_in  = st->flate.avail_in;
+        avail_out = st->flate.avail_out;
+
 	if ((status = inflate(&(st->flate), Z_NO_FLUSH)) < Z_OK)
 	{
-	  _pdfioFileError(st->pdf, "Unable to decompress stream data: %s", zstrerror(status));
+	  _pdfioFileError(st->pdf, "Unable to decompress stream data for object %ld: %s", (long)st->obj->number, zstrerror(status));
 	  return (-1);
 	}
-	else if (status == Z_STREAM_END)
+	else if (status == Z_STREAM_END || (avail_in == st->flate.avail_in && avail_out == st->flate.avail_out))
 	  break;
       }
 

pdfio-string.c

@@ -7,10 +7,6 @@
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 

pdfio-token.c

@@ -1,16 +1,12 @@
 //
 // PDF token parsing functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #include "pdfio-private.h"
 
 
@@ -129,9 +125,20 @@ _pdfioTokenGet(_pdfio_token_t *tb,	// I - Token buffer/stack
   if (tb->num_tokens > 0)
   {
     // Yes, return it...
+    size_t len;				// Length of token
+
     tb->num_tokens --;
-    strncpy(buffer, tb->tokens[tb->num_tokens], bufsize - 1);
-    buffer[bufsize - 1] = '\0';
+
+    if ((len = strlen(tb->tokens[tb->num_tokens])) > (bufsize - 1))
+    {
+      // Value too large...
+      PDFIO_DEBUG("_pdfioTokenGet(tb=%p, buffer=%p, bufsize=%u): Token '%s' from stack too large.\n", tb, buffer, (unsigned)bufsize, tb->tokens[tb->num_tokens]);
+      *buffer = '\0';
+      return (false);
+    }
+
+    memcpy(buffer, tb->tokens[tb->num_tokens], len);
+    buffer[len] = '\0';
 
     PDFIO_DEBUG("_pdfioTokenGet(tb=%p, buffer=%p, bufsize=%u): Popping '%s' from stack.\n", tb, buffer, (unsigned)bufsize, buffer);
 
@@ -201,9 +208,10 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	*bufend,			// End of buffer
 	state = '\0';			// Current state
   bool	saw_nul = false;		// Did we see a nul character?
+  size_t count = 0;			// Number of whitespace/comment bytes
+
 
 
-  //
   // "state" is:
   //
   // - '\0' for idle
@@ -222,21 +230,45 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
   // Skip leading whitespace...
   while ((ch = get_char(tb)) != EOF)
   {
+    count ++;
+
     if (ch == '%')
     {
       // Skip comment
+      PDFIO_DEBUG("_pdfioTokenRead: Skipping comment...\n");
       while ((ch = get_char(tb)) != EOF)
       {
+        count ++;
+
 	if (ch == '\n' || ch == '\r')
+	{
 	  break;
+	}
+	else if (count > 2048)
+	{
+	  _pdfioFileError(tb->pdf, "Comment too long.");
+	  *bufptr = '\0';
+	  return (false);
+	}
       }
     }
     else if (!isspace(ch))
+    {
       break;
+    }
+    else if (count > 2048)
+    {
+      _pdfioFileError(tb->pdf, "Too much whitespace.");
+      *bufptr = '\0';
+      return (false);
+    }
   }
 
   if (ch == EOF)
+  {
+    *bufptr = '\0';
     return (false);
+  }
 
   // Check for delimiters...
   if (strchr(PDFIO_DELIM_CHARS, ch) != NULL)
@@ -256,6 +288,8 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
     *bufptr++ = (char)ch;
   }
 
+  PDFIO_DEBUG("_pdfioTokenRead: state='%c'\n", state);
+
   switch (state)
   {
     case '(' : // Literal string
@@ -347,6 +381,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
@@ -354,6 +389,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	if (ch != ')')
 	{
 	  _pdfioFileError(tb->pdf, "Unterminated string literal.");
+	  *bufptr = '\0';
 	  return (false);
 	}
 
@@ -373,6 +409,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
           {
 	    // Out of space...
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
           }
 
@@ -406,9 +443,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space...
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
+
+	if (ch == '\r')
+	{
+	  // Look for a trailing LF
+	  if ((ch = get_char(tb)) != EOF && ch != '\n')
+	    tb->bufptr --;
+	}
 	break;
 
     case 'N' : // number
@@ -417,6 +462,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  if (!isdigit(ch) && ch != '.')
 	  {
 	    // End of number...
+	    PDFIO_DEBUG("_pdfioTokenRead: End of number with ch=0x%02x\n", ch);
 	    tb->bufptr --;
 	    break;
 	  }
@@ -429,6 +475,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space...
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
@@ -455,12 +502,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	      if (!isxdigit(tch & 255))
 	      {
 		_pdfioFileError(tb->pdf, "Bad # escape in name.");
+		*bufptr = '\0';
 		return (false);
 	      }
 	      else if (isdigit(tch))
+	      {
 		ch = ((ch & 255) << 4) | (tch - '0');
+	      }
 	      else
+	      {
 		ch = ((ch & 255) << 4) | (tolower(tch) - 'a' + 10);
+	      }
 	    }
 	  }
 
@@ -472,9 +524,17 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  {
 	    // Out of space
 	    _pdfioFileError(tb->pdf, "Token too large.");
+	    *bufptr = '\0';
 	    return (false);
 	  }
 	}
+
+	if (bufptr == (buffer + 1))
+	{
+	  _pdfioFileError(tb->pdf, "Empty name.");
+	  *bufptr = '\0';
+	  return (false);
+	}
 	break;
 
     case '<' : // Potential hex string
@@ -484,12 +544,22 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	  *bufptr++ = (char)ch;
 	  break;
 	}
+	else if (ch == '>')
+	{
+	  // Issue #46: Empty hex string from Microsoft PDF generator; treat as
+	  // empty literal string...
+	  *buffer = '(';
+	  break;
+	}
 	else if (!isspace(ch & 255) && !isxdigit(ch & 255))
 	{
 	  _pdfioFileError(tb->pdf, "Syntax error: '<%c'", ch);
+	  *bufptr = '\0';
 	  return (false);
 	}
 
+        count = 0;
+
         do
 	{
 	  if (isxdigit(ch))
@@ -498,25 +568,39 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	    {
 	      // Hex digit
 	      *bufptr++ = (char)ch;
+	      count = 0;
 	    }
 	    else
 	    {
 	      // Too large
 	      _pdfioFileError(tb->pdf, "Token too large.");
+	      *bufptr = '\0';
 	      return (false);
 	    }
 	  }
 	  else if (!isspace(ch))
 	  {
 	    _pdfioFileError(tb->pdf, "Invalid hex string character '%c'.", ch);
+	    *bufptr = '\0';
 	    return (false);
 	  }
+	  else
+	  {
+	    count ++;
+	    if (count > 2048)
+	    {
+	      _pdfioFileError(tb->pdf, "Too much whitespace.");
+	      *bufptr = '\0';
+	      return (false);
+	    }
+	  }
 	}
 	while ((ch = get_char(tb)) != EOF && ch != '>');
 
 	if (ch == EOF)
 	{
 	  _pdfioFileError(tb->pdf, "Unterminated hex string.");
+	  *bufptr = '\0';
 	  return (false);
 	}
 	break;
@@ -529,6 +613,7 @@ _pdfioTokenRead(_pdfio_token_t *tb,	// I - Token buffer/stack
 	else
 	{
 	  _pdfioFileError(tb->pdf, "Syntax error: '>%c'.", ch);
+	  *bufptr = '\0';
 	  return (false);
 	}
 	break;

pdfio-value.c

@@ -1,17 +1,20 @@
 //
 // PDF value functions for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
+#include "pdfio-private.h"
+
+
 //
-// Include necessary headers...
+// Local functions...
 //
 
-#include "pdfio-private.h"
+static time_t	get_date_time(const char *s);
 
 
 //
@@ -109,6 +112,101 @@ _pdfioValueCopy(pdfio_file_t   *pdfdst,	// I - Destination PDF file
 }
 
 
+//
+// '_pdfioValueDecrypt()' - Decrypt a value.
+//
+
+bool					// O - `true` on success, `false` on error
+_pdfioValueDecrypt(pdfio_file_t   *pdf,	// I - PDF file
+                   pdfio_obj_t    *obj,	// I - Object
+                   _pdfio_value_t *v,	// I - Value
+                   size_t         depth)// I - Depth
+{
+  _pdfio_crypto_ctx_t	ctx;		// Decryption context
+  _pdfio_crypto_cb_t	cb;		// Decryption callback
+  size_t		ivlen;		// Number of initialization vector bytes
+  uint8_t		temp[32768];	// Temporary buffer for decryption
+  size_t		templen;	// Number of actual data bytes
+  time_t		timeval;	// Date/time value
+
+
+  if (depth > PDFIO_MAX_DEPTH)
+  {
+    _pdfioFileError(pdf, "Value too deep.");
+    return (false);
+  }
+
+  switch (v->type)
+  {
+    default :
+        // Do nothing
+        break;
+
+    case PDFIO_VALTYPE_ARRAY :
+        return (_pdfioArrayDecrypt(pdf, obj, v->value.array, depth + 1));
+        break;
+
+    case PDFIO_VALTYPE_DICT :
+        return (_pdfioDictDecrypt(pdf, obj, v->value.dict, depth + 1));
+        break;
+
+    case PDFIO_VALTYPE_BINARY :
+	// Decrypt the binary string...
+	if (v->value.binary.datalen > (sizeof(temp) - 32))
+	{
+	  _pdfioFileError(pdf, "Unable to read encrypted binary string - too long.");
+	  return (false);
+	}
+
+	ivlen = v->value.binary.datalen;
+	if ((cb = _pdfioCryptoMakeReader(pdf, obj, &ctx, v->value.binary.data, &ivlen)) == NULL)
+	  return (false);
+
+	templen = (cb)(&ctx, temp, v->value.binary.data + ivlen, v->value.binary.datalen - ivlen);
+
+	// Copy the decrypted string back to the value and adjust the length...
+	memcpy(v->value.binary.data, temp, templen);
+
+	if (pdf->encryption >= PDFIO_ENCRYPTION_AES_128)
+	  v->value.binary.datalen = templen - temp[templen - 1];
+	else
+	  v->value.binary.datalen = templen;
+	break;
+
+    case PDFIO_VALTYPE_STRING :
+        // Decrypt regular string...
+        templen = strlen(v->value.string);
+	if (templen > (sizeof(temp) - 33))
+	{
+	  _pdfioFileError(pdf, "Unable to read encrypted string - too long.");
+	  return (false);
+	}
+
+	ivlen = templen;
+	if ((cb = _pdfioCryptoMakeReader(pdf, obj, &ctx, (uint8_t *)v->value.string, &ivlen)) == NULL)
+	  return (false);
+
+	templen = (cb)(&ctx, temp, (uint8_t *)v->value.string + ivlen, templen - ivlen);
+	temp[templen] = '\0';
+
+        if ((timeval = get_date_time((char *)temp)) != 0)
+        {
+          // Change the type to date...
+          v->type       = PDFIO_VALTYPE_DATE;
+          v->value.date = timeval;
+        }
+        else
+        {
+          // Copy the decrypted string back to the value...
+	  v->value.string = pdfioStringCreate(pdf, (char *)temp);
+	}
+        break;
+  }
+
+  return (true);
+}
+
+
 //
 // '_pdfioValueDebug()' - Print the contents of a value.
 //
@@ -200,6 +298,7 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
                 size_t         depth)	// I - Depth of value
 {
   char		token[32768];		// Token buffer
+  time_t	timeval;		// Date/time value
 #ifdef DEBUG
   static const char * const valtypes[] =
   {
@@ -219,7 +318,6 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
 
 
   PDFIO_DEBUG("_pdfioValueRead(pdf=%p, obj=%p, v=%p)\n", pdf, obj, v);
-  (void)obj; // TODO: Implement decryption
 
   if (!_pdfioTokenGet(tb, token, sizeof(token)))
     return (NULL);
@@ -250,72 +348,10 @@ _pdfioValueRead(pdfio_file_t   *pdf,	// I - PDF file
     if ((v->value.dict = _pdfioDictRead(pdf, obj, tb, depth + 1)) == NULL)
       return (NULL);
   }
-  else if (!strncmp(token, "(D:", 3))
+  else if (!strncmp(token, "(D:", 3) && (timeval = get_date_time(token + 1)) != 0)
   {
-    // Possible date value of the form:
-    //
-    //   (D:YYYYMMDDhhmmssZ)
-    //   (D:YYYYMMDDhhmmss+HH'mm)
-    //   (D:YYYYMMDDhhmmss-HH'mm)
-    //
-    int		i;			// Looping var
-    struct tm	dateval;		// Date value
-    int		offset;			// Date offset
-
-    for (i = 3; i < 17; i ++)
-    {
-      if (!isdigit(token[i] & 255))
-        break;
-    }
-
-    if (i >= 17)
-    {
-      if (token[i] == 'Z')
-      {
-        i ++;
-      }
-      else if (token[i] == '-' || token[i] == '+')
-      {
-        if (isdigit(token[i + 1] & 255) && isdigit(token[i + 2] & 255) && token[i + 3] == '\'' && isdigit(token[i + 4] & 255) && isdigit(token[i + 5] & 255))
-        {
-          i += 6;
-          if (token[i] == '\'')
-            i ++;
-	}
-      }
-    }
-    if (token[i])
-    {
-      // Just a string...
-      v->type         = PDFIO_VALTYPE_STRING;
-      v->value.string = pdfioStringCreate(pdf, token + 1);
-    }
-    else
-    {
-      // Date value...
-      memset(&dateval, 0, sizeof(dateval));
-
-      dateval.tm_year = (token[3] - '0') * 1000 + (token[4] - '0') * 100 + (token[5] - '0') * 10 + token[6] - '0' - 1900;
-      dateval.tm_mon  = (token[7] - '0') * 10 + token[8] - '0' - 1;
-      dateval.tm_mday = (token[9] - '0') * 10 + token[10] - '0';
-      dateval.tm_hour = (token[11] - '0') * 10 + token[12] - '0';
-      dateval.tm_min  = (token[13] - '0') * 10 + token[14] - '0';
-      dateval.tm_sec  = (token[15] - '0') * 10 + token[16] - '0';
-
-      if (token[17] == 'Z')
-      {
-        offset = 0;
-      }
-      else
-      {
-        offset = (token[18] - '0') * 600 + (token[19] - '0') * 60 + (token[20] - '0') * 10 + token[21] - '0';
-        if (token[17] == '-')
-          offset = -offset;
-      }
-
-      v->type       = PDFIO_VALTYPE_DATE;
-      v->value.date = mktime(&dateval) + offset;
-    }
+    v->type       = PDFIO_VALTYPE_DATE;
+    v->value.date = timeval;
   }
   else if (token[0] == '(')
   {
@@ -702,3 +738,76 @@ _pdfioValueWrite(pdfio_file_t   *pdf,	// I - PDF file
 
   return (false);
 }
+
+
+//
+// 'get_date_time()' - Convert PDF date/time value to time_t.
+//
+
+static time_t				// O - Time in seconds
+get_date_time(const char *s)		// I - PDF date/time value
+{
+  int		i;			// Looping var
+  struct tm	dateval;		// Date value
+  int		offset;			// Date offset
+
+
+  // Possible date value of the form:
+  //
+  //   (D:YYYYMMDDhhmmssZ)
+  //   (D:YYYYMMDDhhmmss+HH'mm)
+  //   (D:YYYYMMDDhhmmss-HH'mm)
+  //
+
+  for (i = 2; i < 16; i ++)
+  {
+    if (!isdigit(s[i] & 255) || !s[i])
+      break;
+  }
+
+  if (i >= 16)
+  {
+    if (s[i] == 'Z')
+    {
+      i ++;
+    }
+    else if (s[i] == '-' || s[i] == '+')
+    {
+      if (isdigit(s[i + 1] & 255) && isdigit(s[i + 2] & 255) && s[i + 3] == '\'' && isdigit(s[i + 4] & 255) && isdigit(s[i + 5] & 255))
+      {
+	i += 6;
+	if (s[i] == '\'')
+	  i ++;
+      }
+    }
+  }
+
+  if (s[i])
+  {
+    // Just a string...
+    return (0);
+  }
+
+  // Date value...
+  memset(&dateval, 0, sizeof(dateval));
+
+  dateval.tm_year = (s[2] - '0') * 1000 + (s[3] - '0') * 100 + (s[4] - '0') * 10 + s[5] - '0' - 1900;
+  dateval.tm_mon  = (s[6] - '0') * 10 + s[7] - '0' - 1;
+  dateval.tm_mday = (s[8] - '0') * 10 + s[9] - '0';
+  dateval.tm_hour = (s[10] - '0') * 10 + s[11] - '0';
+  dateval.tm_min  = (s[12] - '0') * 10 + s[13] - '0';
+  dateval.tm_sec  = (s[14] - '0') * 10 + s[15] - '0';
+
+  if (s[16] == 'Z')
+  {
+    offset = 0;
+  }
+  else
+  {
+    offset = (s[17] - '0') * 600 + (s[18] - '0') * 60 + (s[19] - '0') * 10 + s[20] - '0';
+    if (s[16] == '-')
+      offset = -offset;
+  }
+
+  return (mktime(&dateval) + offset);
+}

pdfio.h

@@ -1,7 +1,7 @@
 //
 // Public header file for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -9,27 +9,23 @@
 
 #ifndef PDFIO_H
 #  define PDFIO_H
-
-//
-// Include necessary headers...
-//
-
 #  include <stdio.h>
 #  include <stdlib.h>
 #  include <stdbool.h>
 #  include <sys/types.h>
 #  include <time.h>
-
-
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 extern "C" {
 #  endif // __cplusplus
 
 
+//
+// Version number...
+//
+
+#  define PDFIO_VERSION		"1.2.0"
+
+
 //
 // Visibility and other annotations...
 //
@@ -37,9 +33,11 @@ extern "C" {
 #  if defined(__has_extension) || defined(__GNUC__)
 #    define _PDFIO_PUBLIC	__attribute__ ((visibility("default")))
 #    define _PDFIO_FORMAT(a,b)	__attribute__ ((__format__(__printf__, a,b)))
+#    define _PDFIO_DEPRECATED	__attribute__ ((deprecated)) _PDFIO_PUBLIC
 #  else
 #    define _PDFIO_PUBLIC
 #    define _PDFIO_FORMAT(a,b)
+#    define _PDFIO_DEPRECATED
 #  endif // __has_extension || __GNUC__
 
 
@@ -55,6 +53,8 @@ typedef struct _pdfio_array_s pdfio_array_t;
 					// Array of PDF values
 typedef struct _pdfio_dict_s pdfio_dict_t;
 					// Key/value dictionary
+typedef bool (*pdfio_dict_cb_t)(pdfio_dict_t *dict, const char *key, void *cb_data);
+					// Dictionary iterator callback
 typedef struct _pdfio_file_s pdfio_file_t;
 					// PDF file
 typedef bool (*pdfio_error_cb_t)(pdfio_file_t *pdf, const char *message, void *data);
@@ -65,7 +65,7 @@ typedef enum pdfio_encryption_e		// PDF encryption modes
   PDFIO_ENCRYPTION_RC4_40,		// 40-bit RC4 encryption (PDF 1.3)
   PDFIO_ENCRYPTION_RC4_128,		// 128-bit RC4 encryption (PDF 1.4)
   PDFIO_ENCRYPTION_AES_128,		// 128-bit AES encryption (PDF 1.6)
-  PDFIO_ENCRYPTION_AES_256		// 256-bit AES encryption (PDF 2.0)
+  PDFIO_ENCRYPTION_AES_256		// 256-bit AES encryption (PDF 2.0) @exclude all@
 } pdfio_encryption_t;
 typedef enum pdfio_filter_e		// Compression/decompression filters for streams
 {
@@ -165,6 +165,7 @@ extern pdfio_obj_t	*pdfioDictGetObj(pdfio_dict_t *dict, const char *key) _PDFIO_
 extern pdfio_rect_t	*pdfioDictGetRect(pdfio_dict_t *dict, const char *key, pdfio_rect_t *rect) _PDFIO_PUBLIC;
 extern const char	*pdfioDictGetString(pdfio_dict_t *dict, const char *key) _PDFIO_PUBLIC;
 extern pdfio_valtype_t	pdfioDictGetType(pdfio_dict_t *dict, const char *key) _PDFIO_PUBLIC;
+extern void		pdfioDictIterateKeys(pdfio_dict_t *dict, pdfio_dict_cb_t cb, void *cb_data) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetArray(pdfio_dict_t *dict, const char *key, pdfio_array_t *value) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetBinary(pdfio_dict_t *dict, const char *key, const unsigned char *value, size_t valuelen) _PDFIO_PUBLIC;
 extern bool		pdfioDictSetBoolean(pdfio_dict_t *dict, const char *key, bool value) _PDFIO_PUBLIC;
@@ -181,10 +182,13 @@ extern bool		pdfioDictSetStringf(pdfio_dict_t *dict, const char *key, const char
 extern bool		pdfioFileClose(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern pdfio_file_t	*pdfioFileCreate(const char *filename, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileCreateArrayObj(pdfio_file_t *pdf, pdfio_array_t *array) _PDFIO_PUBLIC;
+extern pdfio_obj_t	*pdfioFileCreateNumberObj(pdfio_file_t *pdf, double number) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileCreateObj(pdfio_file_t *pdf, pdfio_dict_t *dict) _PDFIO_PUBLIC;
 extern pdfio_file_t	*pdfioFileCreateOutput(pdfio_output_cb_t output_cb, void *output_ctx, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 // TODO: Add number, array, string, etc. versions of pdfioFileCreateObject?
 extern pdfio_stream_t	*pdfioFileCreatePage(pdfio_file_t *pdf, pdfio_dict_t *dict) _PDFIO_PUBLIC;
+extern pdfio_obj_t	*pdfioFileCreateStringObj(pdfio_file_t *pdf, const char *s) _PDFIO_PUBLIC;
+extern pdfio_file_t	*pdfioFileCreateTemporary(char *buffer, size_t bufsize, const char *version, pdfio_rect_t *media_box, pdfio_rect_t *crop_box, pdfio_error_cb_t error_cb, void *error_data) _PDFIO_PUBLIC;
 extern pdfio_obj_t	*pdfioFileFindObj(pdfio_file_t *pdf, size_t number) _PDFIO_PUBLIC;
 extern const char	*pdfioFileGetAuthor(pdfio_file_t *pdf) _PDFIO_PUBLIC;
 extern time_t		pdfioFileGetCreationDate(pdfio_file_t *pdf) _PDFIO_PUBLIC;
@@ -240,10 +244,6 @@ extern char		*pdfioStringCreate(pdfio_file_t *pdf, const char *s)  _PDFIO_PUBLIC
 extern char		*pdfioStringCreatef(pdfio_file_t *pdf, const char *format, ...) _PDFIO_FORMAT(2,3) _PDFIO_PUBLIC;
 
 
-//
-// C++ magic...
-//
-
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus

pdfio.pc.in

@@ -1,6 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
 Name: pdfio
 Description: PDF read/write library
+Version: @PDFIO_VERSION@
 URL: https://www.msweet.org/pdfio
-Requires: zlib >= 1.0
-Libs: -L${prefix}/lib -lpdfio -lm
-Cflags: -I${prefix}/include
+Requires: @PKGCONFIG_REQUIRES@
+Libs: @PKGCONFIG_LIBS@
+Libs.private: @PKGCONFIG_LIBS_PRIVATE@
+Cflags: @PKGCONFIG_CFLAGS@

pdfio.vcxproj

@@ -87,7 +87,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0.1";WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -101,7 +101,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0.1";WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -115,7 +115,7 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0.1";_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>
@@ -130,7 +130,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>PDFIO_VERSION="1.0.1";NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
     </ClCompile>
     <Link>

pdfio.xcodeproj/project.pbxproj

@@ -372,7 +372,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1.0.1;
+				CURRENT_PROJECT_VERSION = 1.1.2;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -381,7 +381,6 @@
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"$(inherited)",
 					"DEBUG=1",
-					"'PDFIO_VERSION=\"$(CURRENT_PROJECT_VERSION)\"'",
 				);
 				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -397,7 +396,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -450,7 +449,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1.0.1;
+				CURRENT_PROJECT_VERSION = 1.1.2;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_NS_ASSERTIONS = NO;
@@ -459,7 +458,6 @@
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"$(inherited)",
-					"'PDFIO_VERSION=\"$(CURRENT_PROJECT_VERSION)\"'",
 				);
 				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -475,7 +473,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				RUN_CLANG_STATIC_ANALYZER = YES;
@@ -515,7 +513,7 @@
 				ENABLE_HARDENED_RUNTIME = YES;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				PRODUCT_BUNDLE_IDENTIFIER = org.msweet.testpdfio;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -529,7 +527,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				DEVELOPMENT_TEAM = "";
 				ENABLE_HARDENED_RUNTIME = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.14;
+				MACOSX_DEPLOYMENT_TARGET = 11.0;
 				PRODUCT_BUNDLE_IDENTIFIER = org.msweet.testpdfio;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";

pdfio1.def

@@ -1,5 +1,5 @@
 LIBRARY pdfio1
-VERSION 1.0
+VERSION 1.2
 EXPORTS
 _pdfioArrayDebug
 _pdfioArrayDelete
@@ -47,7 +47,9 @@ _pdfioFileSeek
 _pdfioFileTell
 _pdfioFileWrite
 _pdfioObjDelete
+_pdfioObjGetExtension
 _pdfioObjLoad
+_pdfioObjSetExtension
 _pdfioStreamCreate
 _pdfioStreamOpen
 _pdfioStringIsAllocated
@@ -101,6 +103,7 @@ pdfioContentPathClose
 pdfioContentPathCurve
 pdfioContentPathCurve13
 pdfioContentPathCurve23
+pdfioContentPathEnd
 pdfioContentPathLineTo
 pdfioContentPathMoveTo
 pdfioContentPathRect
@@ -135,8 +138,12 @@ pdfioContentSetTextXScaling
 pdfioContentStroke
 pdfioContentTextBegin
 pdfioContentTextEnd
+pdfioContentTextMeasure
 pdfioContentTextMoveLine
 pdfioContentTextMoveTo
+pdfioContentTextNewLine
+pdfioContentTextNewLineShow
+pdfioContentTextNewLineShowf
 pdfioContentTextNextLine
 pdfioContentTextShow
 pdfioContentTextShowJustified
@@ -154,6 +161,7 @@ pdfioDictGetObj
 pdfioDictGetRect
 pdfioDictGetString
 pdfioDictGetType
+pdfioDictIterateKeys
 pdfioDictSetArray
 pdfioDictSetBinary
 pdfioDictSetBoolean
@@ -174,9 +182,12 @@ pdfioFileCreateFontObjFromFile
 pdfioFileCreateICCObjFromFile
 pdfioFileCreateImageObjFromData
 pdfioFileCreateImageObjFromFile
+pdfioFileCreateNumberObj
 pdfioFileCreateObj
 pdfioFileCreateOutput
 pdfioFileCreatePage
+pdfioFileCreateStringObj
+pdfioFileCreateTemporary
 pdfioFileFindObj
 pdfioFileGetAuthor
 pdfioFileGetCreationDate

pdfio_native.nuspec

@@ -3,7 +3,7 @@
     <metadata>
         <id>pdfio_native</id>
         <title>PDFio Library for VS2019+</title>
-        <version>1.0.1</version>
+        <version>1.2.0</version>
         <authors>Michael R Sweet</authors>
         <owners>michaelrsweet</owners>
         <projectUrl>https://github.com/michaelrsweet/pappl</projectUrl>
@@ -13,10 +13,10 @@
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
         <description>PDFio Library for VS2019+</description>
         <summary>PDFio is a simple C library for reading and writing PDF files. PDFio is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GNU GPL2-only software.</summary>
-        <copyright>Copyright © 2019-2022 by Michael R Sweet</copyright>
+        <copyright>Copyright © 2019-2024 by Michael R Sweet</copyright>
         <tags>pdf file native</tags>
 	<dependencies>
-	    <dependency id="pdfio_native.redist" version="1.0.1" />
+	    <dependency id="pdfio_native.redist" version="1.2.0" />
 	    <dependency id="zlib_native.redist" version="1.2.11" />
 	</dependencies>
     </metadata>

pdfio_native.redist.nuspec

@@ -3,7 +3,7 @@
     <metadata>
         <id>pdfio_native.redist</id>
         <title>PDFio Library for VS2019+</title>
-        <version>1.0.1</version>
+        <version>1.2.0</version>
         <authors>Michael R Sweet</authors>
         <owners>michaelrsweet</owners>
         <projectUrl>https://github.com/michaelrsweet/pappl</projectUrl>
@@ -13,8 +13,11 @@
         <requireLicenseAcceptance>false</requireLicenseAcceptance>
         <description>PDFio Library for VS2019+</description>
         <summary>PDFio is a simple C library for reading and writing PDF files. This package provides the redistributable content for the PDFio library. PDFio is licensed under the Apache License Version 2.0 with an (optional) exception to allow linking against GNU GPL2-only software.</summary>
-        <copyright>Copyright © 2019-2022 by Michael R Sweet</copyright>
+        <copyright>Copyright © 2019-2024 by Michael R Sweet</copyright>
         <tags>pdf file native</tags>
+	<dependencies>
+	    <dependency id="zlib_native.redist" version="1.2.11" />
+	</dependencies>
     </metadata>
     <files>
         <file src="doc\pdfio-128.png" target="build\native" />

testpdfio.c

@@ -1,7 +1,7 @@
 //
 // Test program for PDFio.
 //
-// Copyright © 2021 by Michael R Sweet.
+// Copyright © 2021-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -10,11 +10,7 @@
 //
 //   ./testpdfio
 //
-//   ./testpdfio FILENAME [OBJECT-NUMBER] [FILENAME [OBJECT-NUMBER]] ...
-//
-
-//
-// Include necessary headers...
+//   ./testpdfio [--verbose] FILENAME [OBJECT-NUMBER] [FILENAME [OBJECT-NUMBER]] ...
 //
 
 #include "pdfio-private.h"
@@ -34,6 +30,7 @@ static int	do_test_file(const char *filename, int objnum, bool verbose);
 static int	do_unit_tests(void);
 static int	draw_image(pdfio_stream_t *st, const char *name, double x, double y, double w, double h, const char *label);
 static bool	error_cb(pdfio_file_t *pdf, const char *message, bool *error);
+static bool	iterate_cb(pdfio_dict_t *dict, const char *key, void *cb_data);
 static ssize_t	output_cb(int *fd, const void *buffer, size_t bytes);
 static const char *password_cb(void *data, const char *filename);
 static int	read_unit_file(const char *filename, size_t num_pages, size_t first_image, bool is_output);
@@ -43,7 +40,7 @@ static int	verify_image(pdfio_file_t *pdf, size_t number);
 static int	write_alpha_test(pdfio_file_t *pdf, int number, pdfio_obj_t *font);
 static int	write_color_patch(pdfio_stream_t *st, bool device);
 static int	write_color_test(pdfio_file_t *pdf, int number, pdfio_obj_t *font);
-static int	write_font_test(pdfio_file_t *pdf, int number, pdfio_obj_t *font, bool unicode);
+static int	write_font_test(pdfio_file_t *pdf, int number, pdfio_obj_t *font, const char *textfontfile, bool unicode);
 static int	write_header_footer(pdfio_stream_t *st, const char *title, int number);
 static pdfio_obj_t *write_image_object(pdfio_file_t *pdf, _pdfio_predictor_t predictor);
 static int	write_images_test(pdfio_file_t *pdf, int number, pdfio_obj_t *font);
@@ -405,7 +402,7 @@ do_test_file(const char *filename,	// I - PDF filename
 
       filter = pdfioDictGetName(dict, "Filter");
 
-      if ((st = pdfioObjOpenStream(obj, (filter && !strcmp(filter, "FlateDecode")) ? PDFIO_FILTER_FLATE : PDFIO_FILTER_NONE)) == NULL)
+      if ((st = pdfioObjOpenStream(obj, filter && !strcmp(filter, "FlateDecode"))) == NULL)
       {
         _pdfioValueDebug(&obj->value, stdout);
 	putchar('\n');
@@ -454,7 +451,7 @@ do_test_file(const char *filename,	// I - PDF filename
 	      }
 	    }
 
-	    printf("    Page #%d is %gx%g.\n", (int)n + 1, media_box.x2, media_box.y2);
+	    printf("    Page #%d (obj %d) is %gx%g.\n", (int)n + 1, (int)pdfioObjGetNumber(obj), media_box.x2, media_box.y2);
 	  }
 	}
 
@@ -506,6 +503,9 @@ do_unit_tests(void)
   _pdfio_value_t	value;		// Value
   size_t		first_image,	// First image object
 			num_pages;	// Number of pages written
+  char			temppdf[1024];	// Temporary PDF file
+  pdfio_dict_t		*dict;		// Test dictionary
+  int			count = 0;	// Number of key/value pairs
   static const char	*complex_dict =	// Complex dictionary value
     "<</Annots 5457 0 R/Contents 5469 0 R/CropBox[0 0 595.4 842]/Group 725 0 R"
     "/MediaBox[0 0 595.4 842]/Parent 23513 0 R/Resources<</ColorSpace<<"
@@ -967,6 +967,41 @@ do_unit_tests(void)
 
   // TODO: Test for known values in this test file.
 
+  // Test dictionary APIs
+  fputs("pdfioDictCreate: ", stdout);
+  if ((dict = pdfioDictCreate(inpdf)) != NULL)
+  {
+    puts("PASS");
+
+    fputs("pdfioDictSet*: ", stdout);
+    if (pdfioDictSetBoolean(dict, "Boolean", true) && pdfioDictSetName(dict, "Name", "Name") && pdfioDictSetNumber(dict, "Number", 42.0) && pdfioDictSetString(dict, "String", "String"))
+    {
+      puts("PASS");
+    }
+    else
+    {
+      puts("FAIL");
+      return (1);
+    }
+
+    fputs("pdfioDictIterateKeys: ", stdout);
+    pdfioDictIterateKeys(dict, iterate_cb, &count);
+    if (count == 4)
+    {
+      puts("PASS");
+    }
+    else
+    {
+      printf("FAIL (got %d, expected 4)\n", count);
+      return (1);
+    }
+  }
+  else
+  {
+    puts("FAIL");
+    return (1);
+  }
+
   // Test the value parsers for edge cases...
   fputs("_pdfioValueRead(complex_dict): ", stdout);
   s = complex_dict;
@@ -1107,6 +1142,18 @@ do_unit_tests(void)
   if (read_unit_file("testpdfio-aesp.pdf", num_pages, first_image, false))
     return (1);
 
+  fputs("pdfioFileCreateTemporary: ", stdout);
+  if ((outpdf = pdfioFileCreateTemporary(temppdf, sizeof(temppdf), NULL, NULL, NULL, (pdfio_error_cb_t)error_cb, &error)) != NULL)
+    printf("PASS (%s)\n", temppdf);
+  else
+    return (1);
+
+  if (write_unit_file(inpdf, outpdf, &num_pages, &first_image))
+    return (1);
+
+  if (read_unit_file(temppdf, num_pages, first_image, false))
+    return (1);
+
   pdfioFileClose(inpdf);
 
   return (0);
@@ -1199,6 +1246,27 @@ error_cb(pdfio_file_t *pdf,		// I  - PDF file
 }
 
 
+//
+// 'iterate_cb()' - Test pdfioDictIterateKeys function.
+//
+
+static bool				// O - `true` to continue, `false` to stop
+iterate_cb(pdfio_dict_t *dict,		// I - Dictionary
+           const char   *key,		// I - Key
+           void         *cb_data)	// I - Callback data
+{
+  int	*count = (int *)cb_data;	// Pointer to counter
+
+
+  if (!dict || !key || !cb_data)
+    return (false);
+
+  (*count)++;
+
+  return (true);
+}
+
+
 //
 // 'output_cb()' - Write output to a file.
 //
@@ -1238,6 +1306,7 @@ read_unit_file(const char *filename,	// I - File to read
 {
   pdfio_file_t	*pdf;			// PDF file
   size_t	i;			// Looping var
+  const char	*s;			// String
   bool		error = false;		// Error callback data
 
 
@@ -1248,6 +1317,87 @@ read_unit_file(const char *filename,	// I - File to read
   else
     return (1);
 
+  // Verify metadata...
+  fputs("pdfioFileGetAuthor: ", stdout);
+  if ((s = pdfioFileGetAuthor(pdf)) != NULL && !strcmp(s, "Michael R Sweet"))
+  {
+    puts("PASS");
+  }
+  else if (s)
+  {
+    printf("FAIL (got '%s', expected 'Michael R Sweet')\n", s);
+    return (1);
+  }
+  else
+  {
+    puts("FAIL (got NULL, expected 'Michael R Sweet')");
+    return (1);
+  }
+
+  fputs("pdfioFileGetCreator: ", stdout);
+  if ((s = pdfioFileGetCreator(pdf)) != NULL && !strcmp(s, "testpdfio"))
+  {
+    puts("PASS");
+  }
+  else if (s)
+  {
+    printf("FAIL (got '%s', expected 'testpdfio')\n", s);
+    return (1);
+  }
+  else
+  {
+    puts("FAIL (got NULL, expected 'testpdfio')");
+    return (1);
+  }
+
+  fputs("pdfioFileGetKeywords: ", stdout);
+  if ((s = pdfioFileGetKeywords(pdf)) != NULL && !strcmp(s, "one fish,two fish,red fish,blue fish"))
+  {
+    puts("PASS");
+  }
+  else if (s)
+  {
+    printf("FAIL (got '%s', expected 'one fish,two fish,red fish,blue fish')\n", s);
+    return (1);
+  }
+  else
+  {
+    puts("FAIL (got NULL, expected 'one fish,two fish,red fish,blue fish')");
+    return (1);
+  }
+
+  fputs("pdfioFileGetSubject: ", stdout);
+  if ((s = pdfioFileGetSubject(pdf)) != NULL && !strcmp(s, "Unit test document"))
+  {
+    puts("PASS");
+  }
+  else if (s)
+  {
+    printf("FAIL (got '%s', expected 'Unit test document')\n", s);
+    return (1);
+  }
+  else
+  {
+    puts("FAIL (got NULL, expected 'Unit test document')");
+    return (1);
+  }
+
+  fputs("pdfioFileGetTitle: ", stdout);
+  if ((s = pdfioFileGetTitle(pdf)) != NULL && !strcmp(s, "Test Document"))
+  {
+    puts("PASS");
+  }
+  else if (s)
+  {
+    printf("FAIL (got '%s', expected 'Test Document')\n", s);
+    return (1);
+  }
+  else
+  {
+    puts("FAIL (got NULL, expected 'Test Document')");
+    return (1);
+  }
+
   // Verify the number of pages is the same...
   fputs("pdfioFileGetNumPages: ", stdout);
   if (num_pages == pdfioFileGetNumPages(pdf))
@@ -2075,14 +2225,20 @@ write_color_test(pdfio_file_t *pdf,	// I - PDF file
 //
 
 static int				// O - 1 on failure, 0 on success
-write_font_test(pdfio_file_t *pdf,	// I - PDF file
-                int          number,	// I - Page number
-		pdfio_obj_t  *font,	// I - Page number font
-		bool         unicode)	// I - Use Unicode font?
+write_font_test(
+    pdfio_file_t *pdf,			// I - PDF file
+    int          number,		// I - Page number
+    pdfio_obj_t  *font,			// I - Page number font
+    const char   *textfontfile,		// I - Text font file
+    bool         unicode)		// I - Use Unicode font?
 {
   pdfio_dict_t		*dict;		// Page dictionary
   pdfio_stream_t	*st;		// Page contents stream
-  pdfio_obj_t		*opensans;	// OpenSans-Regular font
+  pdfio_obj_t		*textfont;	// Text font
+  char			title[256],	// Page title
+			textname[256],	// Name of text font
+			*ptr;		// Pointer into name
+  double		width;		// Text width
   int			i;		// Looping var
   static const char * const welcomes[] =// "Welcome" in many languages
   {
@@ -2233,28 +2389,16 @@ write_font_test(pdfio_file_t *pdf,	// I - PDF file
     "Märr-ŋamathirri",
     "Ẹ ku abọ",
     "Kíimak 'oolal",
-    "Ngiyakwemukela"
+    "Ngiyakwemukela",
+    "いらっしゃいませ"
   };
 
 
-#if 0
-  if (unicode)
-  {
-    fputs("pdfioFileCreateFontObjFromFile(NotoSansJP-Regular.otf): ", stdout);
-    if ((opensans = pdfioFileCreateFontObjFromFile(pdf, "testfiles/NotoSansJP-Regular.otf", true)) != NULL)
-      puts("PASS");
-    else
-      return (1);
-  }
+  printf("pdfioFileCreateFontObjFromFile(%s): ", textfontfile);
+  if ((textfont = pdfioFileCreateFontObjFromFile(pdf, textfontfile, unicode)) != NULL)
+    puts("PASS");
   else
-#endif // 0
-  {
-    fputs("pdfioFileCreateFontObjFromFile(OpenSans-Regular.ttf): ", stdout);
-    if ((opensans = pdfioFileCreateFontObjFromFile(pdf, "testfiles/OpenSans-Regular.ttf", unicode)) != NULL)
-      puts("PASS");
-    else
-      return (1);
-  }
+    return (1);
 
   fputs("pdfioDictCreate: ", stdout);
   if ((dict = pdfioDictCreate(pdf)) != NULL)
@@ -2269,7 +2413,7 @@ write_font_test(pdfio_file_t *pdf,	// I - PDF file
     return (1);
 
   fputs("pdfioPageDictAddFont(F2): ", stdout);
-  if (pdfioPageDictAddFont(dict, "F2", opensans))
+  if (pdfioPageDictAddFont(dict, "F2", textfont))
     puts("PASS");
   else
     return (1);
@@ -2281,7 +2425,21 @@ write_font_test(pdfio_file_t *pdf,	// I - PDF file
   else
     return (1);
 
-  if (write_header_footer(st, unicode ? "Unicode TrueType Font Test" : "CP1252 TrueType Font Test", number))
+  if ((ptr = strrchr(textfontfile, '/')) != NULL)
+    strncpy(textname, ptr + 1, sizeof(textname) - 1);
+  else
+    strncpy(textname, textfontfile, sizeof(textname) - 1);
+
+  textname[sizeof(textname) - 1] = '\0';
+  if ((ptr = strrchr(textname, '.')) != NULL)
+    *ptr = '\0';
+
+  if (unicode)
+    snprintf(title, sizeof(title), "Unicode %s Font Test", textname);
+  else
+    snprintf(title, sizeof(title), "CP1252 %s Font Test", textname);
+
+  if (write_header_footer(st, title, number))
     goto error;
 
   fputs("pdfioContentTextBegin(): ", stdout);
@@ -2302,8 +2460,8 @@ write_font_test(pdfio_file_t *pdf,	// I - PDF file
   else
     goto error;
 
-  fputs("pdfioContentTextMoveTo(36.0, 702.0): ", stdout);
-  if (pdfioContentTextMoveTo(st, 36.0, 702.0))
+  fputs("pdfioContentTextMoveTo(198.0, 702.0): ", stdout);
+  if (pdfioContentTextMoveTo(st, 198.0, 702.0))
     puts("PASS");
   else
     return (1);
@@ -2312,18 +2470,36 @@ write_font_test(pdfio_file_t *pdf,	// I - PDF file
   {
     if (i > 0 && (i % 50) == 0)
     {
-      fputs("pdfioContentTextMoveTo(200.0, 600.0): ", stdout);
-      if (pdfioContentTextMoveTo(st, 200.0, 600.0))
+      fputs("pdfioContentTextMoveTo(162.0, 600.0): ", stdout);
+      if (pdfioContentTextMoveTo(st, 162.0, 600.0))
 	puts("PASS");
       else
 	return (1);
     }
 
+    printf("pdfioContentTextMeasure(\"%s\"): ", welcomes[i]);
+    if ((width = pdfioContentTextMeasure(textfont, welcomes[i], 10.0)) >= 0.0)
+      puts("PASS");
+    else
+      return (1);
+
+    printf("pdfioContextTextMoveTo(%g, 0.0): ", -width);
+    if (pdfioContentTextMoveTo(st, -width, 0.0))
+      puts("PASS");
+    else
+      return (1);
+
     printf("pdfioContentTextShowf(\"%s\"): ", welcomes[i]);
     if (pdfioContentTextShowf(st, unicode, "%s\n", welcomes[i]))
       puts("PASS");
     else
       return (1);
+
+    printf("pdfioContextTextMoveTo(%g, 0.0): ", width);
+    if (pdfioContentTextMoveTo(st, width, 0.0))
+      puts("PASS");
+    else
+      return (1);
   }
 
   fputs("pdfioContentTextEnd(): ", stdout);
@@ -3167,13 +3343,13 @@ write_unit_file(
   // Create some image objects...
   fputs("pdfioFileCreateImageObjFromFile(\"testfiles/color.jpg\"): ", stdout);
   if ((color_jpg = pdfioFileCreateImageObjFromFile(outpdf, "testfiles/color.jpg", true)) != NULL)
-    puts("PASS");
+    printf("PASS (%u)\n", (unsigned)pdfioObjGetNumber(color_jpg));
   else
     return (1);
 
   fputs("pdfioFileCreateImageObjFromFile(\"testfiles/gray.jpg\"): ", stdout);
   if ((gray_jpg = pdfioFileCreateImageObjFromFile(outpdf, "testfiles/gray.jpg", true)) != NULL)
-    puts("PASS");
+    printf("PASS (%u)\n", (unsigned)pdfioObjGetNumber(gray_jpg));
   else
     return (1);
 
@@ -3236,14 +3412,17 @@ write_unit_file(
     return (1);
 
   // Test TrueType fonts...
-  if (write_font_test(outpdf, 9, helvetica, false))
+  if (write_font_test(outpdf, 9, helvetica, "testfiles/OpenSans-Regular.ttf", false))
     return (1);
 
-  if (write_font_test(outpdf, 10, helvetica, true))
+  if (write_font_test(outpdf, 10, helvetica, "testfiles/OpenSans-Regular.ttf", true))
+    return (1);
+
+  if (write_font_test(outpdf, 11, helvetica, "testfiles/NotoSansJP-Regular.otf", true))
     return (1);
 
   // Print this text file...
-  if (write_text_test(outpdf, 11, helvetica, "README.md"))
+  if (write_text_test(outpdf, 12, helvetica, "README.md"))
     return (1);
 
   fputs("pdfioFileGetNumPages: ", stdout);

testttf.c

@@ -0,0 +1,304 @@
+//
+// Unit test program for TTF library
+//
+//     https://github.com/michaelrsweet/ttf
+//
+// Copyright © 2018-2023 by Michael R Sweet.
+//
+// Licensed under Apache License v2.0.  See the file "LICENSE" for more
+// information.
+//
+// Usage:
+//
+//   ./testttf [FILENAME]
+//
+
+#include <stdio.h>
+#include "ttf.h"
+
+
+//
+// Local functions...
+//
+
+static void	error_cb(void *data, const char *message);
+static int	test_font(const char *filename);
+
+
+//
+// 'main()' - Main entry for unit tests.
+//
+
+int					// O - Exit status
+main(int  argc,				// I - Number of command-line arguments
+     char *argv[])			// I - Command-line arguments
+{
+  int		i;			// Looping var
+  int		errors = 0;		// Number of errors
+
+
+  if (argc > 1)
+  {
+    for (i = 1; i < argc; i ++)
+      errors += test_font(argv[i]);
+  }
+  else
+  {
+    // Test with the bundled TrueType files...
+    errors += test_font("testfiles/OpenSans-Bold.ttf");
+    errors += test_font("testfiles/OpenSans-Regular.ttf");
+    errors += test_font("testfiles/NotoSansJP-Regular.otf");
+  }
+
+  if (!errors)
+    puts("\nALL TESTS PASSED");
+  else
+    printf("\n%d TEST(S) FAILED\n", errors);
+
+  return (errors);
+}
+
+
+//
+// 'error_cb()' - Error callback.
+//
+
+static void
+error_cb(void       *data,		// I - User data (not used)
+         const char *message)		// I - Message string
+{
+  fprintf(stderr, "FAIL (%s)\n", message);
+}
+
+
+//
+// 'test_font()' - Test a font file.
+//
+
+static int				// O - Number of errors
+test_font(const char *filename)		// I - Font filename
+{
+  int		i,			// Looping var
+		errors = 0;		// Number of errors
+  ttf_t		*font;			// Font
+  const char	*value;			// Font (string) value
+  int		intvalue;		// Font (integer) value
+  float		realvalue;		// Font (real) value
+  ttf_rect_t	bounds;			// Bounds
+  ttf_rect_t	extents;		// Extents
+  size_t	num_fonts;		// Number of fonts
+  ttf_style_t	style;			// Font style
+  ttf_weight_t	weight;			// Font weight
+  static const char * const stretches[] =
+  {					// Font stretch strings
+    "TTF_STRETCH_NORMAL",		// normal
+    "TTF_STRETCH_ULTRA_CONDENSED",	// ultra-condensed
+    "TTF_STRETCH_EXTRA_CONDENSED",	// extra-condensed
+    "TTF_STRETCH_CONDENSED",		// condensed
+    "TTF_STRETCH_SEMI_CONDENSED",	// semi-condensed
+    "TTF_STRETCH_SEMI_EXPANDED",	// semi-expanded
+    "TTF_STRETCH_EXPANDED",		// expanded
+    "TTF_STRETCH_EXTRA_EXPANDED",	// extra-expanded
+    "TTF_STRETCH_ULTRA_EXPANDED"	// ultra-expanded
+  };
+  static const char * const strings[] =	// Test strings
+  {
+    "Hello, World!",			// English
+    "مرحبا بالعالم!",			// Arabic
+    "Bonjour le monde!",		// French
+    "Γειά σου Κόσμε!",			// Greek
+    "שלום עולם!",			// Hebrew
+    "Привет мир!",			// Russian
+    "こんにちは世界！"			// Japanese
+  };
+  static const char * const styles[] =	// Font style names
+  {
+    "TTF_STYLE_NORMAL",
+    "TTF_STYLE_ITALIC",
+    "TTF_STYLE_OBLIQUE"
+  };
+
+
+  printf("ttfCreate(\"%s\"): ", filename);
+  if ((font = ttfCreate(filename, 0, error_cb, NULL)) != NULL)
+    puts("PASS");
+  else
+    errors ++;
+
+  fputs("ttfGetAscent: ", stdout);
+  if ((intvalue = ttfGetAscent(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetBounds: ", stdout);
+  if (ttfGetBounds(font, &bounds))
+  {
+    printf("PASS (%g %g %g %g)\n", bounds.left, bounds.bottom, bounds.right, bounds.top);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetCapHeight: ", stdout);
+  if ((intvalue = ttfGetCapHeight(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetCopyright: ", stdout);
+  if ((value = ttfGetCopyright(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("WARNING (no copyright found)");
+  }
+
+  for (i = 0; i < (int)(sizeof(strings) / sizeof(strings[0])); i ++)
+  {
+    printf("ttfGetExtents(\"%s\"): ", strings[i]);
+    if (ttfGetExtents(font, 12.0f, strings[i], &extents))
+    {
+      printf("PASS (%.1f %.1f %.1f %.1f)\n", extents.left, extents.bottom, extents.right, extents.top);
+    }
+    else
+    {
+      puts("FAIL");
+      errors ++;
+    }
+  }
+
+  fputs("ttfGetFamily: ", stdout);
+  if ((value = ttfGetFamily(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetItalicAngle: ", stdout);
+  if ((realvalue = ttfGetItalicAngle(font)) >= -180.0 && realvalue <= 180.0)
+  {
+    printf("PASS (%g)\n", realvalue);
+  }
+  else
+  {
+    printf("FAIL (%g)\n", realvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetNumFonts: ", stdout);
+  if ((num_fonts = ttfGetNumFonts(font)) > 0)
+  {
+    printf("PASS (%u)\n", (unsigned)num_fonts);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetPostScriptName: ", stdout);
+  if ((value = ttfGetPostScriptName(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetStretch: ", stdout);
+  if ((intvalue = (int)ttfGetStretch(font)) >= TTF_STRETCH_NORMAL && intvalue <= TTF_STRETCH_ULTRA_EXPANDED)
+  {
+    printf("PASS (%s)\n", stretches[intvalue]);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetStyle: ", stdout);
+  if ((style = ttfGetStyle(font)) >= TTF_STYLE_NORMAL && style <= TTF_STYLE_ITALIC)
+  {
+    printf("PASS (%s)\n", styles[style]);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetVersion: ", stdout);
+  if ((value = ttfGetVersion(font)) != NULL)
+  {
+    printf("PASS (%s)\n", value);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetWeight: ", stdout);
+  if ((weight = ttfGetWeight(font)) >= 0)
+  {
+    printf("PASS (%u)\n", (unsigned)weight);
+  }
+  else
+  {
+    puts("FAIL");
+    errors ++;
+  }
+
+  fputs("ttfGetWidth(' '): ", stdout);
+  if ((intvalue = ttfGetWidth(font, ' ')) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfGetXHeight: ", stdout);
+  if ((intvalue = ttfGetXHeight(font)) > 0)
+  {
+    printf("PASS (%d)\n", intvalue);
+  }
+  else
+  {
+    printf("FAIL (%d)\n", intvalue);
+    errors ++;
+  }
+
+  fputs("ttfIsFixedPitch: ", stdout);
+  if (ttfIsFixedPitch(font))
+    puts("PASS (true)");
+  else
+    puts("PASS (false)");
+
+  ttfDelete(font);
+
+  return (errors);
+}

ttf.c

@@ -3,16 +3,12 @@
 //
 //     https://github.com/michaelrsweet/ttf
 //
-// Copyright © 2018-2021 by Michael R Sweet.
+// Copyright © 2018-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
 //
 
-//
-// Include necessary headers...
-//
-
 #ifdef _WIN32
 #  define _CRT_SECURE_NO_WARNINGS
 #endif // _WIN32
@@ -75,7 +71,7 @@ typedef __int64 ssize_t;		// POSIX type not present on Windows...
 
 
 //
-// DEBUG is typically defined for debug builds.  TTF_DEBUG maps to printf when
+// DEBUG is typically defined for debug builds.  TTF_DEBUG maps to fprintf when
 // DEBUG is defined and is a no-op otherwise...
 //
 
@@ -420,7 +416,7 @@ ttfCreate(const char   *filename,	// I - Filename
   if (read_os_2(font, &os_2))
   {
     // Copy key values from OS/2 table...
-    static const ttf_stretch_t widths[] =
+    static const ttf_stretch_t stretches[] =
     {
       TTF_STRETCH_ULTRA_CONDENSED,	// ultra-condensed
       TTF_STRETCH_EXTRA_CONDENSED,	// extra-condensed
@@ -433,8 +429,8 @@ ttfCreate(const char   *filename,	// I - Filename
       TTF_STRETCH_ULTRA_EXPANDED	// ultra-expanded
     };
 
-    if (os_2.usWidthClass >= 1 && os_2.usWidthClass <= (int)(sizeof(widths) / sizeof(widths[0])))
-      font->stretch = widths[os_2.usWidthClass - 1];
+    if (os_2.usWidthClass >= 1 && os_2.usWidthClass <= (int)(sizeof(stretches) / sizeof(stretches[0])))
+      font->stretch = stretches[os_2.usWidthClass - 1];
 
     font->weight     = (short)os_2.usWeightClass;
     font->cap_height = os_2.sCapHeight;
@@ -452,7 +448,7 @@ ttfCreate(const char   *filename,	// I - Filename
     font->cap_height = font->ascent;
 
   if (font->x_height == 0)
-    font->x_height   = 3 * font->ascent / 5;
+    font->x_height = 3 * font->ascent / 5;
 
   // Build a sparse glyph widths table...
   font->min_char = -1;
@@ -481,6 +477,11 @@ ttfCreate(const char   *filename,	// I - Filename
       else
 	font->widths[bin][i & 255] = widths[glyph];
     }
+
+#ifdef DEBUG
+    if (i >= ' ' && i < 127 && font->widths[0])
+      TTF_DEBUG("ttfCreate: width['%c']=%d(%d)\n", (char)i, font->widths[0][i].width, font->widths[0][i].left_bearing);
+#endif // DEBUG
   }
 
   // Cleanup and return the font...
@@ -737,17 +738,6 @@ ttfGetFamily(ttf_t *font)		// I - Font
 }
 
 
-//
-// 'ttfIsFixedPitch()' - Determine whether a font is fixedpitch.
-//
-
-bool					// O - `true` if fixed pitch, `false` otherwise
-ttfIsFixedPitch(ttf_t *font)		// I - Font
-{
-  return (font ? font->is_fixed : false);
-}
-
-
 //
 // 'ttfGetItalicAngle()' - Get the italic angle.
 //
@@ -856,13 +846,14 @@ int					// O - Width in 1000ths
 ttfGetWidth(ttf_t *font,		// I - Font
             int   ch)			// I - Unicode character
 {
-  int	bin = ch >> 8;			// Bin in widths array
+  int	bin =  ch >> 8;			// Bin in widths array
 
 
   // Range check input...
   if (!font || ch < ' ' || ch == 0x7f)
     return (0);
-  else if (font->widths[bin])
+
+  if (font->widths[bin])
     return ((int)(1000.0f * font->widths[bin][ch & 255].width / font->units));
   else if (font->widths[0])		// .notdef
     return ((int)(1000.0f * font->widths[0][0].width / font->units));
@@ -882,6 +873,17 @@ ttfGetXHeight(ttf_t *font)		// I - Font
 }
 
 
+//
+// 'ttfIsFixedPitch()' - Determine whether a font is fixedpitch.
+//
+
+bool					// O - `true` if fixed pitch, `false` otherwise
+ttfIsFixedPitch(ttf_t *font)		// I - Font
+{
+  return (font ? font->is_fixed : false);
+}
+
+
 //
 // 'copy_name()' - Copy a name string from a font.
 //
@@ -1280,7 +1282,7 @@ read_cmap(ttf_t *font)			// I - Font
 
           // Based on the end code of the segent table, allocate space for the
           // uncompressed cmap table...
-          segCount --;			// Last segment is not used (sigh)
+//          segCount --;			// Last segment is not used (sigh)
 
 	  font->num_cmap = segments[segCount - 1].endCode + 1;
 	  font->cmap     = cmapptr = (int *)malloc(font->num_cmap * sizeof(int));
@@ -1305,17 +1307,18 @@ read_cmap(ttf_t *font)			// I - Font
               {
                 // Use an "obscure indexing trick" (words from the spec, not
                 // mine) to look up the glyph index...
-                temp = segment->idRangeOffset / 2 + ch - segment->startCode + seg - segCount - 1;
+                temp = (int)(segment->idRangeOffset / 2 - segCount + (ch - segment->startCode) + (segment - segments));
 
-                if (temp < 0 || temp >= numGlyphIdArray || !glyphIdArray[temp])
+                TTF_DEBUG("read_cmap: ch=%d, temp=%d\n", ch, temp);
+                if (temp < 0 || temp >= numGlyphIdArray)
                   glyph = -1;
 		else
-		  glyph = ((glyphIdArray[temp] + segment->idDelta) & 65535) - 1;
+		  glyph = (glyphIdArray[temp] + segment->idDelta) & 65535;
               }
               else
               {
                 // Just use idDelta to compute a glyph index...
-                glyph = ((ch + segment->idDelta) & 65535) - 1;
+                glyph = (ch + segment->idDelta) & 65535;
 	      }
 
 	      cmapptr[ch] = glyph;
@@ -1582,6 +1585,8 @@ read_hmtx(ttf_t           *font,	// I - Font
   {
     widths[i].width        = (short)read_ushort(font);
     widths[i].left_bearing = (short)read_short(font);
+
+    TTF_DEBUG("read_hmtx: widths[%d].width=%d, .left_bearing=%d\n", i, widths[i].width, widths[i].left_bearing);
   }
 
   return (widths);

ttf.h

@@ -3,7 +3,7 @@
 //
 //     https://github.com/michaelrsweet/ttf
 //
-// Copyright © 2018-2021 by Michael R Sweet.
+// Copyright © 2018-2023 by Michael R Sweet.
 //
 // Licensed under Apache License v2.0.  See the file "LICENSE" for more
 // information.
@@ -11,17 +11,11 @@
 
 #ifndef TTF_H
 #  define TTF_H
-
-//
-// Include necessary headers...
-//
-
 #  include <stdbool.h>
 #  include <sys/types.h>
-
 #  ifdef __cplusplus
 extern "C" {
-#  endif //
+#  endif // __cplusplus
 
 
 //
@@ -89,8 +83,8 @@ extern ttf_t		*ttfCreate(const char *filename, size_t idx, ttf_err_cb_t err_cb,
 extern void		ttfDelete(ttf_t *font);
 extern int		ttfGetAscent(ttf_t *font);
 extern ttf_rect_t	*ttfGetBounds(ttf_t *font, ttf_rect_t *bounds);
-extern int		ttfGetCapHeight(ttf_t *font);
 extern const int	*ttfGetCMap(ttf_t *font, size_t *num_cmap);
+extern int		ttfGetCapHeight(ttf_t *font);
 extern const char	*ttfGetCopyright(ttf_t *font);
 extern int		ttfGetDescent(ttf_t *font);
 extern ttf_rect_t	*ttfGetExtents(ttf_t *font, float size, const char *s, ttf_rect_t *extents);
@@ -112,5 +106,4 @@ extern bool		ttfIsFixedPitch(ttf_t *font);
 #  ifdef __cplusplus
 }
 #  endif // __cplusplus
-
 #endif // !TTF_H