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 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.



51
52
53
54
55
56
57
 
# File 'lib/hexapdf/parser.rb', line 51

def initialize(io, document)
  @io = io
  @tokenizer = Tokenizer.new(io)
  @document = document
  @object_stream_data = {}
  retrieve_pdf_header_offset_and_version
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



307
308
309
310
311
312
 
# File 'lib/hexapdf/parser.rb', line 307

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.



165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/hexapdf/parser.rb', line 165

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.



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/hexapdf/parser.rb', line 64

def load_object(xref_entry)
  obj, oid, gen, stream =
    case xref_entry.type
    when :in_use
      parse_indirect_object(xref_entry.pos)
    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)
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.



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/hexapdf/parser.rb', line 181

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



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
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
 
# File 'lib/hexapdf/parser.rb', line 93

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'.freeze
    raise_malformed("No valid object found", pos: offset)
  end

  if (tok = @tokenizer.peek_token) && tok.kind_of?(Tokenizer::Token) && tok == 'endobj'.freeze
    maybe_raise("No indirect object value between 'obj' and 'endobj'", pos: @tokenizer.pos)
    object = nil
  else
    object = @tokenizer.next_object
  end

  tok = @tokenizer.next_token

  if tok.kind_of?(Tokenizer::Token) && tok == 'stream'.freeze
    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
      raise_malformed("Keyword stream must be followed by LF or CR/LF", pos: @tokenizer.pos)
    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'.freeze
      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'.freeze
    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



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/hexapdf/parser.rb', line 214

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
      if xref.entry?(oid)
        next
      elsif type == 'n'.freeze
        if pos == 0 || gen > 65535
          maybe_raise("Invalid in use cross-reference entry in cross-reference section",
                      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 a #{trailer.class} instead of a dictionary ", pos: @tokenizer.pos)
  end

  [xref, trailer]
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



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
 
# File 'lib/hexapdf/parser.rb', line 269

def startxref_offset
  @io.seek(0, IO::SEEK_END)
  step_size = 1024
  pos = @io.pos
  eof_not_found = 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

  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) 


202
203
204
205
206
 
# File 'lib/hexapdf/parser.rb', line 202

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