pdf-reader 2.2.0 → 2.11.0

data/lib/pdf/reader/filter/depredict.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -6,8 +7,9 @@ class PDF::Reader
     # some filter implementations support preprocessing of the  data to
     # improve compression
     class Depredict
+
       def initialize(options = {})
-        @options = options || {}
+        @options = options
       end
 
       ################################################################################
@@ -34,7 +36,7 @@ class PDF::Reader
       ################################################################################
       def tiff_depredict(data)
         data        = data.unpack("C*")
-        unfiltered  = []
+        unfiltered  = ''
         bpc         = @options[:BitsPerComponent] || 8
         pixel_bits  = bpc * @options[:Colors]
         pixel_bytes = pixel_bits / 8
@@ -51,11 +53,11 @@ class PDF::Reader
             left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
             row_data[index] = (byte + left) % 256
           end
-          unfiltered += row_data
+          unfiltered += row_data.pack("C*")
           pos += line_len
         end
 
-        unfiltered.pack("C*")
+        unfiltered
       end
       ################################################################################
       def png_depredict(data)
@@ -67,7 +69,7 @@ class PDF::Reader
         scanline_length = (pixel_bytes * @options[:Columns]) + 1
         row = 0
         pixels = []
-        paeth, pa, pb, pc = nil
+        paeth, pa, pb, pc = 0, 0, 0, 0
         until data.empty? do
           row_data = data.slice! 0, scanline_length
           filter = row_data.shift
@@ -94,17 +96,17 @@ class PDF::Reader
               row_data[index] = (byte + ((left + upper)/2).floor) % 256
             end
           when 4 # Paeth
-            left = upper = upper_left = nil
+            left = upper = upper_left = 0
             row_data.each_with_index do |byte, index|
               col = index / pixel_bytes
 
-              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              left = index < pixel_bytes ? 0 : Integer(row_data[index - pixel_bytes])
               if row.zero?
                 upper = upper_left = 0
               else
-                upper = pixels[row-1][col][index % pixel_bytes]
+                upper = Integer(pixels[row-1][col][index % pixel_bytes])
                 upper_left = col.zero? ? 0 :
-                  pixels[row-1][col-1][index % pixel_bytes]
+                  Integer(pixels[row-1][col-1][index % pixel_bytes])
               end
 
               p = left + upper - upper_left
@@ -123,7 +125,7 @@ class PDF::Reader
               row_data[index] = (byte + paeth) % 256
             end
           else
-            raise ArgumentError, "Invalid filter algorithm #{filter}"
+            raise MalformedPDFError, "Invalid filter algorithm #{filter}"
           end
 
           s = []

data/lib/pdf/reader/filter/flate.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 
@@ -8,6 +9,10 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the Flate (zlib) stream filter
     class Flate
+
+      ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47  # Zlib::MAX_WBITS + 32
+      ZLIB_RAW_DEFLATE              = -15 # Zlib::MAX_WBITS * -1
+
       def initialize(options = {})
         @options = options
       end
@@ -15,25 +20,34 @@ class PDF::Reader
       ################################################################################
       # Decode the specified data with the Zlib compression algorithm
       def filter(data)
-        deflated = nil
+        deflated = zlib_inflate(data) || zlib_inflate(data[0, data.bytesize-1])
+
+        if deflated.nil?
+          raise MalformedPDFError,
+            "Error while inflating a compressed stream (no suitable inflation algorithm found)"
+        end
+        Depredict.new(@options).filter(deflated)
+      end
+
+      private
+
+      def zlib_inflate(data)
         begin
-          deflated = Zlib::Inflate.new.inflate(data)
-        rescue Zlib::DataError => e
+          return Zlib::Inflate.new(ZLIB_AUTO_DETECT_ZLIB_OR_GZIP).inflate(data)
+        rescue Zlib::Error
           # by default, Ruby's Zlib assumes the data it's inflating
-          # is RFC1951 deflated data, wrapped in a RFC1951 zlib container.
-          # If that fails, then use an undocumented 'feature' to attempt to inflate
-          # the data as a raw RFC1951 stream.
-          #
-          # See
-          # - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/243545
-          # - http://www.gzip.org/zlib/zlib_faq.html#faq38
-          deflated = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+          # is RFC1951 deflated data, wrapped in a RFC1950 zlib container. If that
+          # fails, swallow the exception and attempt to inflate the data as a raw
+          # RFC1951 stream.
         end
-        Depredict.new(@options).filter(deflated)
-      rescue Exception => e
-        # Oops, there was a problem inflating the stream
-        raise MalformedPDFError,
-          "Error occured while inflating a compressed stream (#{e.class.to_s}: #{e.to_s})"
+
+        begin
+          return Zlib::Inflate.new(ZLIB_RAW_DEFLATE).inflate(data)
+        rescue Zlib::Error
+          # swallow this one too, so we can try some other fallback options
+        end
+
+        nil
       end
     end
   end

data/lib/pdf/reader/filter/lzw.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 #
@@ -6,6 +7,7 @@ class PDF::Reader
   module Filter # :nodoc:
     # implementation of the LZW stream filter
     class Lzw
+
       def initialize(options = {})
         @options = options
       end

data/lib/pdf/reader/filter/null.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
-#
 class PDF::Reader
   module Filter # :nodoc:
     # implementation of the null stream filter

data/lib/pdf/reader/filter/run_length.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 #
@@ -6,6 +7,7 @@ class PDF::Reader # :nodoc:
   module Filter # :nodoc:
     # implementation of the run length stream filter
     class RunLength
+
       def initialize(options = {})
         @options = options
       end
@@ -20,19 +22,23 @@ class PDF::Reader # :nodoc:
           length = data.getbyte(pos)
           pos += 1
 
-          case
-          when length == 128
-            break
-          when length < 128
-            # When the length is < 128, we copy the following length+1 bytes
-            # literally.
-            out << data[pos, length + 1]
-            pos += length
-          else
-            # When the length is > 128, we copy the next byte (257 - length)
-            # times; i.e., "\xFA\x00" ([250, 0]) will expand to
-            # "\x00\x00\x00\x00\x00\x00\x00".
-            out << data[pos, 1] * (257 - length)
+          unless length.nil?
+            case
+              # nothing
+            when length == 128
+              break
+            when length < 128
+              # When the length is < 128, we copy the following length+1 bytes
+              # literally.
+              out << data[pos, length + 1]
+              pos += length
+            else
+              # When the length is > 128, we copy the next byte (257 - length)
+              # times; i.e., "\xFA\x00" ([250, 0]) will expand to
+              # "\x00\x00\x00\x00\x00\x00\x00".
+              previous_byte = data[pos, 1] || ""
+              out << previous_byte * (257 - length)
+            end
           end
 
           pos += 1

data/lib/pdf/reader/filter.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -41,17 +42,16 @@ class PDF::Reader
     # returned untouched. At this stage PDF::Reader has no need to decode images.
     #
     def self.with(name, options = {})
-      case name.to_sym
-      when :ASCII85Decode   then PDF::Reader::Filter::Ascii85.new(options)
-      when :ASCIIHexDecode  then PDF::Reader::Filter::AsciiHex.new(options)
-      when :CCITTFaxDecode  then PDF::Reader::Filter::Null.new(options)
-      when :DCTDecode       then PDF::Reader::Filter::Null.new(options)
-      when :FlateDecode     then PDF::Reader::Filter::Flate.new(options)
-      when :Fl              then PDF::Reader::Filter::Flate.new(options)
-      when :JBIG2Decode     then PDF::Reader::Filter::Null.new(options)
-      when :JPXDecode       then PDF::Reader::Filter::Null.new(options)
-      when :LZWDecode       then PDF::Reader::Filter::Lzw.new(options)
-      when :RunLengthDecode then PDF::Reader::Filter::RunLength.new(options)
+      case name
+      when :ASCII85Decode, :A85   then PDF::Reader::Filter::Ascii85.new(options)
+      when :ASCIIHexDecode, :AHx  then PDF::Reader::Filter::AsciiHex.new(options)
+      when :CCITTFaxDecode, :CCF  then PDF::Reader::Filter::Null.new(options)
+      when :DCTDecode, :DCT       then PDF::Reader::Filter::Null.new(options)
+      when :FlateDecode, :Fl      then PDF::Reader::Filter::Flate.new(options)
+      when :JBIG2Decode           then PDF::Reader::Filter::Null.new(options)
+      when :JPXDecode             then PDF::Reader::Filter::Null.new(options)
+      when :LZWDecode, :LZW       then PDF::Reader::Filter::Lzw.new(options)
+      when :RunLengthDecode, :RL  then PDF::Reader::Filter::RunLength.new(options)
       else
         raise UnsupportedFeatureError, "Unknown filter: #{name}"
       end

data/lib/pdf/reader/font.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -42,6 +43,7 @@ class PDF::Reader
       @tounicode = nil
 
       extract_base_info(obj)
+      extract_type3_info(obj)
       extract_descriptor(obj)
       extract_descendants(obj)
       @width_calc = build_width_calculator
@@ -72,8 +74,44 @@ class PDF::Reader
       @cached_widths[code_point] ||= @width_calc.glyph_width(code_point)
     end
 
+    # In most cases glyph width is converted into text space with a simple divide by 1000.
+    #
+    # However, Type3 fonts provide their own FontMatrix that's used for the transformation.
+    #
+    def glyph_width_in_text_space(code_point)
+      glyph_width_in_glyph_space = glyph_width(code_point)
+
+      if @subtype == :Type3
+        x1, y1 = font_matrix_transform(0,0)
+        x2, y2 = font_matrix_transform(glyph_width_in_glyph_space, 0)
+        (x2 - x1).abs.round(2)
+      else
+        glyph_width_in_glyph_space / 1000.0
+      end
+    end
+
     private
 
+    # Only valid for Type3 fonts
+    def font_matrix_transform(x, y)
+      return x, y if @font_matrix.nil?
+
+      matrix = TransformationMatrix.new(
+        @font_matrix[0], @font_matrix[1],
+        @font_matrix[2], @font_matrix[3],
+        @font_matrix[4], @font_matrix[5],
+      )
+
+      if x == 0 && y == 0
+        [matrix.e, matrix.f]
+      else
+        [
+          (matrix.a * x) + (matrix.c * y) + (matrix.e),
+          (matrix.b * x) + (matrix.d * y) + (matrix.f)
+        ]
+      end
+    end
+
     def default_encoding(font_name)
       case font_name.to_s
       when "Symbol" then
@@ -97,7 +135,13 @@ class PDF::Reader
       elsif @subtype == :Type3
         PDF::Reader::WidthCalculator::TypeOneOrThree.new(self)
       elsif @subtype == :TrueType
-        PDF::Reader::WidthCalculator::TrueType.new(self)
+        if @font_descriptor
+          PDF::Reader::WidthCalculator::TrueType.new(self)
+        else
+          # A TrueType font that isn't embedded. Most readers look for a version on the
+          # local system and fallback to a substitute. For now, we go straight to a substitute
+          PDF::Reader::WidthCalculator::BuiltIn.new(self)
+        end
       elsif @subtype == :CIDFontType0 || @subtype == :CIDFontType2
         PDF::Reader::WidthCalculator::Composite.new(self)
       else
@@ -105,27 +149,47 @@ class PDF::Reader
       end
     end
 
-    def extract_base_info(obj)
-      @subtype  = @ohash.object(obj[:Subtype])
-      @basefont = @ohash.object(obj[:BaseFont])
-      if @ohash.object(obj[:Encoding])
-        @encoding = PDF::Reader::Encoding.new(@ohash.object(obj[:Encoding]))
+    def build_encoding(obj)
+      if obj[:Encoding].is_a?(Symbol)
+        # one of the standard encodings, referenced by name
+        # TODO pass in a standard shape, always a Hash
+        PDF::Reader::Encoding.new(obj[:Encoding])
+      elsif obj[:Encoding].is_a?(Hash) || obj[:Encoding].is_a?(PDF::Reader::Stream)
+        PDF::Reader::Encoding.new(obj[:Encoding])
+      elsif obj[:Encoding].nil?
+        default_encoding(@basefont)
       else
-        @encoding = default_encoding(@basefont)
+        raise MalformedPDFError, "Unexpected type for Encoding (#{obj[:Encoding].class})"
       end
-      @widths   = @ohash.object(obj[:Widths]) || []
-      @first_char = @ohash.object(obj[:FirstChar])
-      @last_char = @ohash.object(obj[:LastChar])
+    end
+
+    def extract_base_info(obj)
+      @subtype  = @ohash.deref_name(obj[:Subtype])
+      @basefont = @ohash.deref_name(obj[:BaseFont])
+      @encoding = build_encoding(obj)
+      @widths   = @ohash.deref_array_of_numbers(obj[:Widths]) || []
+      @first_char = @ohash.deref_integer(obj[:FirstChar])
+      @last_char = @ohash.deref_integer(obj[:LastChar])
 
       # CID Fonts are not required to have a W or DW entry, if they don't exist,
       # the default cid width = 1000, see Section 9.7.4.1 PDF 32000-1:2008 pp 269
-      @cid_widths         = @ohash.object(obj[:W])  || []
-      @cid_default_width  = @ohash.object(obj[:DW]) || 1000
+      @cid_widths         = @ohash.deref_array(obj[:W])  || []
+      @cid_default_width  = @ohash.deref_number(obj[:DW]) || 1000
 
       if obj[:ToUnicode]
         # ToUnicode is optional for Type1 and Type3
-        stream = @ohash.object(obj[:ToUnicode])
-        @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+        stream = @ohash.deref_stream(obj[:ToUnicode])
+        if stream
+          @tounicode = PDF::Reader::CMap.new(stream.unfiltered_data)
+        end
+      end
+    end
+
+    def extract_type3_info(obj)
+      if @subtype == :Type3
+        @font_matrix = @ohash.deref_array_of_numbers(obj[:FontMatrix]) || [
+          0.001, 0, 0, 0.001, 0, 0
+        ]
       end
     end
 
@@ -133,7 +197,7 @@ class PDF::Reader
       if obj[:FontDescriptor]
         # create a font descriptor object if we can, in other words, unless this is
         # a CID Font
-        fd = @ohash.object(obj[:FontDescriptor])
+        fd = @ohash.deref_hash(obj[:FontDescriptor])
         @font_descriptor = PDF::Reader::FontDescriptor.new(@ohash, fd)
       else
         @font_descriptor = nil
@@ -141,14 +205,17 @@ class PDF::Reader
     end
 
     def extract_descendants(obj)
-      return unless obj[:DescendantFonts]
       # per PDF 32000-1:2008 pp. 280 :DescendentFonts is:
       # A one-element array specifying the CIDFont dictionary that is the
       # descendant of this Type 0 font.
-      descendants = @ohash.object(obj[:DescendantFonts])
-      @descendantfonts = descendants.map { |desc|
-        PDF::Reader::Font.new(@ohash, @ohash.object(desc))
-      }
+      if obj[:DescendantFonts]
+        descendants = @ohash.deref_array(obj[:DescendantFonts])
+        @descendantfonts = descendants.map { |desc|
+          PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc))
+        }
+      else
+        @descendantfonts = []
+      end
     end
 
     def to_utf8_via_cmap(params)
@@ -162,9 +229,7 @@ class PDF::Reader
           @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
         }.flatten.pack("U*")
       when Array
-        params.collect { |param| to_utf8_via_cmap(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_cmap(param) }.join("")
       end
     end
 
@@ -179,9 +244,7 @@ class PDF::Reader
       when String
         encoding.to_utf8(params)
       when Array
-        params.collect { |param| to_utf8_via_encoding(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_encoding(param) }.join("")
       end
     end
 

data/lib/pdf/reader/font_descriptor.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'ttfunk'
@@ -14,22 +15,23 @@ class PDF::Reader
                 :x_height, :font_flags
 
     def initialize(ohash, fd_hash)
-      @ascent                = ohash.object(fd_hash[:Ascent])    || 0
-      @descent               = ohash.object(fd_hash[:Descent])   || 0
-      @missing_width         = ohash.object(fd_hash[:MissingWidth]) || 0
-      @font_bounding_box     = ohash.object(fd_hash[:FontBBox])  || [0,0,0,0]
-      @avg_width             = ohash.object(fd_hash[:AvgWidth])  || 0
-      @cap_height            = ohash.object(fd_hash[:CapHeight]) || 0
-      @font_flags            = ohash.object(fd_hash[:Flags])     || 0
-      @italic_angle          = ohash.object(fd_hash[:ItalicAngle])
-      @font_name             = ohash.object(fd_hash[:FontName]).to_s
-      @leading               = ohash.object(fd_hash[:Leading])   || 0
-      @max_width             = ohash.object(fd_hash[:MaxWidth])  || 0
-      @stem_v                = ohash.object(fd_hash[:StemV])
-      @x_height              = ohash.object(fd_hash[:XHeight])
-      @font_stretch          = ohash.object(fd_hash[:FontStretch]) || :Normal
-      @font_weight           = ohash.object(fd_hash[:FontWeight])  || 400
-      @font_family           = ohash.object(fd_hash[:FontFamily])
+      # TODO change these to typed derefs
+      @ascent                = ohash.deref_number(fd_hash[:Ascent])    || 0
+      @descent               = ohash.deref_number(fd_hash[:Descent])   || 0
+      @missing_width         = ohash.deref_number(fd_hash[:MissingWidth]) || 0
+      @font_bounding_box     = ohash.deref_array_of_numbers(fd_hash[:FontBBox])  || [0,0,0,0]
+      @avg_width             = ohash.deref_number(fd_hash[:AvgWidth])  || 0
+      @cap_height            = ohash.deref_number(fd_hash[:CapHeight]) || 0
+      @font_flags            = ohash.deref_integer(fd_hash[:Flags])     || 0
+      @italic_angle          = ohash.deref_number(fd_hash[:ItalicAngle])
+      @font_name             = ohash.deref_name(fd_hash[:FontName]).to_s
+      @leading               = ohash.deref_number(fd_hash[:Leading])   || 0
+      @max_width             = ohash.deref_number(fd_hash[:MaxWidth])  || 0
+      @stem_v                = ohash.deref_number(fd_hash[:StemV])
+      @x_height              = ohash.deref_number(fd_hash[:XHeight])
+      @font_stretch          = ohash.deref_name(fd_hash[:FontStretch]) || :Normal
+      @font_weight           = ohash.deref_number(fd_hash[:FontWeight])  || 400
+      @font_family           = ohash.deref_string(fd_hash[:FontFamily])
 
       # A FontDescriptor may have an embedded font program in FontFile
       # (Type 1 Font Program), FontFile2 (TrueType font program), or
@@ -39,7 +41,7 @@ class PDF::Reader
       # 2) CIDFontType0C: Type 0 Font Program in Compact Font Format
       # 3) OpenType:      OpenType Font Program
       # see Section 9.9, PDF 32000-1:2008, pp 288-292
-      @font_program_stream = ohash.object(fd_hash[:FontFile2])
+      @font_program_stream = ohash.deref_stream(fd_hash[:FontFile2])
       #TODO handle FontFile and FontFile3
 
       @is_ttf = true if @font_program_stream
@@ -54,7 +56,9 @@ class PDF::Reader
         end
         char_metric = ttf_program_stream.horizontal_metrics.metrics[glyph_id]
         if char_metric
-          return char_metric.advance_width
+          char_metric.advance_width
+        else
+          0
         end
       end
     end

data/lib/pdf/reader/form_xobject.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'digest/md5'
@@ -14,15 +15,24 @@ module PDF
     # This behaves and looks much like a limited PDF::Reader::Page class.
     #
     class FormXObject
-      include ResourceMethods
+      extend Forwardable
 
       attr_reader :xobject
 
+      def_delegators :resources, :color_spaces
+      def_delegators :resources, :fonts
+      def_delegators :resources, :graphic_states
+      def_delegators :resources, :patterns
+      def_delegators :resources, :procedure_sets
+      def_delegators :resources, :properties
+      def_delegators :resources, :shadings
+      def_delegators :resources, :xobjects
+
       def initialize(page, xobject, options = {})
         @page    = page
         @objects = page.objects
         @cache   = options[:cache] || {}
-        @xobject = @objects.deref(xobject)
+        @xobject = @objects.deref_stream(xobject)
       end
 
       # return a hash of fonts used on this form.
@@ -33,9 +43,9 @@ module PDF
       # to most available metrics for each font.
       #
       def font_objects
-        raw_fonts = @objects.deref(resources[:Font] || {})
+        raw_fonts = @objects.deref_hash(fonts)
         ::Hash[raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
+          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font) || {})]
         }]
       end
 
@@ -45,6 +55,9 @@ module PDF
       # See the comments on PDF::Reader::Page#walk for more detail.
       #
       def walk(*receivers)
+        receivers = receivers.map { |receiver|
+          ValidatingReceiver.new(receiver)
+        }
         content_stream(receivers, raw_content)
       end
 
@@ -60,7 +73,7 @@ module PDF
       # Returns the resources that accompany this form.
       #
       def resources
-        @resources ||= @objects.deref(@xobject.hash[:Resources]) || {}
+        @resources ||= Resources.new(@objects, @objects.deref_hash(@xobject.hash[:Resources]) || {})
       end
 
       def callback(receivers, name, params=[])

data/lib/pdf/reader/glyph_hash.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -32,10 +33,18 @@ class PDF::Reader
   #
   class GlyphHash # :nodoc:
     def initialize
+      @@by_codepoint_cache ||= nil
+      @@by_name_cache ||= nil
+
       # only parse the glyph list once, and cache the results (for performance)
-      adobe = @@cache ||= load_adobe_glyph_mapping
-      @by_name      = adobe.first
-      @by_codepoint = adobe.last
+      if @@by_codepoint_cache != nil && @@by_name_cache != nil
+        @by_name      = @@by_name_cache
+        @by_codepoint = @@by_codepoint_cache
+      else
+        by_name, by_codepoint = load_adobe_glyph_mapping
+        @by_name      = @@by_name_cache ||= by_name
+        @by_codepoint = @@by_codepoint_cache ||= by_codepoint
+      end
     end
 
     # attempt to convert a PDF Name to a unicode codepoint. Returns nil
@@ -103,24 +112,30 @@ class PDF::Reader
 
     # returns a hash that maps glyph names to unicode codepoints. The mapping is based on
     # a text file supplied by Adobe at:
-    # http://www.adobe.com/devnet/opentype/archives/glyphlist.txt
+    # https://github.com/adobe-type-tools/agl-aglfn
     def load_adobe_glyph_mapping
       keyed_by_name      = {}
       keyed_by_codepoint = {}
 
-      File.open(File.dirname(__FILE__) + "/glyphlist.txt", "r:BINARY") do |f|
-        f.each do |l|
-          _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
-          if name && code
-            cp = "0x#{code}".hex
-            keyed_by_name[name.to_sym]   = cp
-            keyed_by_codepoint[cp]     ||= []
-            keyed_by_codepoint[cp]     << name.to_sym
+      paths = [
+        File.dirname(__FILE__) + "/glyphlist.txt",
+        File.dirname(__FILE__) + "/glyphlist-zapfdingbats.txt",
+      ]
+      paths.each do |path|
+        File.open(path, "r:BINARY") do |f|
+          f.each do |l|
+            _m, name, code = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
+            if name && code
+              cp = "0x#{code}".hex
+              keyed_by_name[name.to_sym]   = cp
+              keyed_by_codepoint[cp]     ||= []
+              keyed_by_codepoint[cp]     << name.to_sym
+            end
           end
         end
       end
 
-      [keyed_by_name.freeze, keyed_by_codepoint.freeze]
+      return keyed_by_name.freeze, keyed_by_codepoint.freeze
     end
 
   end