Class: HexaPDF::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/hexapdf/parser.rb

Overview

Parses an IO stream according to PDF1.7 to get at the contained objects.

This class also contains higher-level methods for getting indirect objects and revisions.

See: PDF1.7 s7

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(io, document) ⇒ Parser

Creates a new parser for the given IO object.

PDF references are resolved using the associated Document object.



57
58
59
60
61
62
63
64
 
# File 'lib/hexapdf/parser.rb', line 57

def initialize(io, document)
  @io = io
  @tokenizer = Tokenizer.new(io)
  @document = document
  @object_stream_data = {}
  @reconstructed_revision = nil
  retrieve_pdf_header_offset_and_version
end

Instance Attribute Details

#io ⇒ Object (readonly)

The IO stream which is parsed.



52
53
54
 
# File 'lib/hexapdf/parser.rb', line 52

def io
  @io
end

Instance Method Details

#file_header_version ⇒ Object

Returns the PDF version number that is stored in the file header.

See: PDF1.7 s7.5.2



364
365
366
367
368
369
 
# File 'lib/hexapdf/parser.rb', line 364

def file_header_version
  unless @header_version
    raise_malformed("PDF file header is missing or corrupt", pos: 0)
  end
  @header_version
end

#load_compressed_object(xref_entry) ⇒ Object

Loads the compressed object identified by the cross-reference entry.



190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/hexapdf/parser.rb', line 190

def load_compressed_object(xref_entry)
  unless @object_stream_data.key?(xref_entry.objstm)
    obj = @document.object(xref_entry.objstm)
    unless obj.respond_to?(:parse_stream)
      raise_malformed("Object with oid=#{xref_entry.objstm} is not an object stream")
    end
    @object_stream_data[xref_entry.objstm] = obj.parse_stream
  end

  [*@object_stream_data[xref_entry.objstm].object_by_index(xref_entry.pos), xref_entry.gen, nil]
end

#load_object(xref_entry) ⇒ Object

Loads the indirect (potentially compressed) object specified by the given cross-reference entry.

For information about the xref_entry argument, have a look at HexaPDF::XRefSection and HexaPDF::XRefSection::Entry.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/hexapdf/parser.rb', line 71

def load_object(xref_entry)
  obj, oid, gen, stream =
    case xref_entry.type
    when :in_use
      if xref_entry.pos == 0 && xref_entry.oid != 0
        # Handle seen-in-the-wild objects with invalid offset 0
        maybe_raise("Indirect object (#{xref_entry.oid},#{xref_entry.gen}) has offset 0", pos: 0)
        [nil, xref_entry.oid, xref_entry.gen, nil]
      else
        parse_indirect_object(xref_entry.pos)
      end
    when :free
      [nil, xref_entry.oid, xref_entry.gen, nil]
    when :compressed
      load_compressed_object(xref_entry)
    else
      raise_malformed("Invalid cross-reference type '#{xref_entry.type}' encountered")
    end

  if xref_entry.oid != 0 && (oid != xref_entry.oid || gen != xref_entry.gen)
    raise_malformed("The oid,gen (#{oid},#{gen}) values of the indirect object don't match " \
                    "the values (#{xref_entry.oid},#{xref_entry.gen}) from the xref")
  end

  @document.wrap(obj, oid: oid, gen: gen, stream: stream)
rescue HexaPDF::MalformedPDFError
  reconstructed_revision.object(xref_entry)
end

#load_revision(pos) ⇒ Object

Loads a single revision whose cross-reference section/stream is located at the given position.

Returns an HexaPDF::XRefSection object and the accompanying trailer dictionary.



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/hexapdf/parser.rb', line 206

def load_revision(pos)
  if xref_section?(pos)
    xref_section, trailer = parse_xref_section_and_trailer(pos)
  else
    obj = load_object(XRefSection.in_use_entry(0, 0, pos))
    unless obj.respond_to?(:xref_section)
      raise_malformed("Object is not a cross-reference stream", pos: pos)
    end
    xref_section = obj.xref_section
    trailer = obj.trailer
    unless xref_section.entry?(obj.oid, obj.gen)
      maybe_raise("Cross-reference stream doesn't contain entry for itself", pos: pos)
      xref_section.add_in_use_entry(obj.oid, obj.gen, pos)
    end
  end
  xref_section.delete(0)
  [xref_section, trailer]
end

#parse_indirect_object(offset = nil) ⇒ Object

Parses the indirect object at the specified offset.

This method is used by a PDF Document to load objects. It should not be used by any other object because invalid object positions lead to errors.

Returns an array containing [object, oid, gen, stream].

See: PDF1.7 s7.3.10, s7.3.8



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/hexapdf/parser.rb', line 108

def parse_indirect_object(offset = nil)
  @tokenizer.pos = offset + @header_offset if offset
  oid = @tokenizer.next_token
  gen = @tokenizer.next_token
  tok = @tokenizer.next_token
  unless oid.kind_of?(Integer) && gen.kind_of?(Integer) &&
      tok.kind_of?(Tokenizer::Token) && tok == 'obj'
    raise_malformed("No valid object found", pos: offset)
  end

  if (tok = @tokenizer.peek_token) && tok.kind_of?(Tokenizer::Token) && tok == 'endobj'
    maybe_raise("No indirect object value between 'obj' and 'endobj'", pos: @tokenizer.pos)
    object = nil
  else
    begin
      object = @tokenizer.next_object
    rescue MalformedPDFError
      # Handle often found invalid indirect object with missing whitespace after number
      maybe_raise("Invalid object value after 'obj'", pos: @tokenizer.pos,
                  force: !(tok.kind_of?(Tokenizer::Token) && tok =~ /\A\d+endobj\z/))
      object = tok.to_i
      @tokenizer.pos -= 6
    end
  end

  tok = @tokenizer.next_token

  if tok.kind_of?(Tokenizer::Token) && tok == 'stream'
    unless object.kind_of?(Hash)
      raise_malformed("A stream needs a dictionary, not a(n) #{object.class}", pos: offset)
    end
    tok1 = @tokenizer.next_byte
    tok2 = @tokenizer.next_byte if tok1 == 13 # 13=CR, 10=LF
    if tok1 != 10 && tok1 != 13
      tok2 = @tokenizer.next_byte
      maybe_raise("Keyword stream must be followed by LF or CR/LF", pos: @tokenizer.pos,
                  force: tok1 != 32 || (tok2 != 10 && tok2 != 13)) # 32=space
    elsif tok1 == 13 && tok2 != 10
      maybe_raise("Keyword stream must be followed by LF or CR/LF, not CR alone",
                  pos: @tokenizer.pos)
      @tokenizer.pos -= 1
    end

    # Note that getting :Length might move the IO pointer (when resolving references)
    pos = @tokenizer.pos
    length = if object[:Length].kind_of?(Integer)
               object[:Length]
             elsif object[:Length].kind_of?(Reference)
               @document.deref(object[:Length]).value
             else
               0
             end
    @tokenizer.pos = pos + length

    tok = @tokenizer.next_token
    unless tok.kind_of?(Tokenizer::Token) && tok == 'endstream'
      maybe_raise("Invalid stream length, keyword endstream not found", pos: @tokenizer.pos)
      @tokenizer.pos = pos
      if @tokenizer.scan_until(/(?=\n?endstream)/)
        length = @tokenizer.pos - pos
        tok = @tokenizer.next_token
      else
        raise_malformed("Stream content must be followed by keyword endstream",
                        pos: @tokenizer.pos)
      end
    end
    tok = @tokenizer.next_token

    object[:Length] = length
    stream = StreamData.new(@tokenizer.io, offset: pos, length: length,
                            filter: @document.unwrap(object[:Filter]),
                            decode_parms: @document.unwrap(object[:DecodeParms]))
  end

  unless tok.kind_of?(Tokenizer::Token) && tok == 'endobj'
    maybe_raise("Indirect object must be followed by keyword endobj", pos: @tokenizer.pos)
  end

  [object, oid, gen, stream]
end

#parse_xref_section_and_trailer(offset) ⇒ Object

Parses the cross-reference section at the given position and the following trailer and returns them as an array consisting of an HexaPDF::XRefSection instance and a hash.

This method can only parse cross-reference sections, not cross-reference streams!

See: PDF1.7 s7.5.4, s7.5.5; ADB1.7 sH.3-3.4.3



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/hexapdf/parser.rb', line 239

def parse_xref_section_and_trailer(offset)
  @tokenizer.pos = offset + @header_offset
  token = @tokenizer.next_token
  unless token.kind_of?(Tokenizer::Token) && token == 'xref'
    raise_malformed("Xref section doesn't start with keyword xref", pos: @tokenizer.pos)
  end

  xref = XRefSection.new
  start = @tokenizer.next_token
  while start.kind_of?(Integer)
    number_of_entries = @tokenizer.next_token
    unless number_of_entries.kind_of?(Integer)
      raise_malformed("Invalid cross-reference subsection start", pos: @tokenizer.pos)
    end

    @tokenizer.skip_whitespace
    start.upto(start + number_of_entries - 1) do |oid|
      pos, gen, type = @tokenizer.next_xref_entry do |matched_size|
        maybe_raise("Invalid cross-reference entry", pos: @tokenizer.pos,
                    force: !matched_size)
      end
      if xref.entry?(oid)
        next
      elsif type == 'n'
        if pos == 0 || gen > 65535
          maybe_raise("Invalid in use cross-reference entry",
                      pos: @tokenizer.pos)
          xref.add_free_entry(oid, gen)
        else
          xref.add_in_use_entry(oid, gen, pos)
        end
      else
        xref.add_free_entry(oid, gen)
      end
    end
    start = @tokenizer.next_token
  end

  unless start.kind_of?(Tokenizer::Token) && start == 'trailer'
    raise_malformed("Trailer doesn't start with keyword trailer", pos: @tokenizer.pos)
  end

  trailer = @tokenizer.next_object
  unless trailer.kind_of?(Hash)
    raise_malformed("Trailer is #{trailer.class} instead of dictionary ", pos: @tokenizer.pos)
  end

  unless trailer[:Prev] || xref.max_oid == 0 || xref.entry?(0)
    first_entry = xref[xref.oids[0]]
    test_entry = xref[xref.oids[-1]]
    @tokenizer.pos = test_entry.pos + @header_offset
    test_oid = @tokenizer.next_token
    first_oid = first_entry.oid

    force_failure = !first_entry.free? || first_entry.gen != 65535 ||
      !test_oid.kind_of?(Integer) || xref.oids[-1] - test_oid != first_oid
    maybe_raise("Main cross-reference section has invalid numbering",
                pos: offset + @header_offset, force: force_failure)

    new_xref = XRefSection.new
    xref.oids.each do |oid|
      entry = xref[oid]
      entry.oid -= first_oid
      new_xref.send(:[]=, entry.oid, entry.gen, entry)
    end
    xref = new_xref
  end

  [xref, trailer]
end

#reconstructed_revision ⇒ Object

Returns the reconstructed revision.



357
358
359
 
# File 'lib/hexapdf/parser.rb', line 357

def reconstructed_revision
  @reconstructed_revision ||= reconstruct_revision
end

#startxref_offset ⇒ Object

Returns the offset of the main cross-reference section/stream.

Implementation note: Normally, the %%EOF marker has to be on the last line, however, Adobe viewers relax this restriction and so do we.

If strict parsing is disabled, the whole file is searched for the offset.

See: PDF1.7 s7.5.5, ADB1.7 sH.3-3.4.4



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/hexapdf/parser.rb', line 318

def startxref_offset
  return @startxref_offset if defined?(@startxref_offset)

  @io.seek(0, IO::SEEK_END)
  step_size = 1024
  pos = @io.pos
  eof_not_found = pos == 0
  startxref_missing = false

  while pos != 0
    @io.pos = [pos - step_size, 0].max
    pos = @io.pos
    lines = @io.read(step_size + 40).split(/[\r\n]+/)

    eof_index = lines.rindex {|l| l.strip == '%%EOF' }
    unless eof_index
      eof_not_found = true
      next
    end
    unless eof_index >= 2 && lines[eof_index - 2].strip == "startxref"
      startxref_missing = true
      next
    end

    break # we found the startxref offset
  end

  if eof_not_found
    maybe_raise("PDF file trailer with end-of-file marker not found", pos: pos,
                force: !eof_index)
  elsif startxref_missing
    maybe_raise("PDF file trailer is missing startxref keyword", pos: pos,
                force: eof_index < 2 || lines[eof_index - 2].strip != "startxref")
  end

  @startxref_offset = lines[eof_index - 1].to_i
end

#xref_section?(offset) ⇒ Boolean

Looks at the given offset and returns true if there is a cross-reference section at that position.

Returns:

  • (Boolean) 


227
228
229
230
231
 
# File 'lib/hexapdf/parser.rb', line 227

def xref_section?(offset)
  @tokenizer.pos = offset + @header_offset
  token = @tokenizer.peek_token
  token.kind_of?(Tokenizer::Token) && token == 'xref'
end