combine_pdf 0.0.2

data/lib/combine_pdf/combine_pdf_basic_writer.rb

@@ -0,0 +1,110 @@
+# -*- encoding : utf-8 -*-
+########################################################
+## Thoughts from reading the ISO 32000-1:2008
+## this file is part of the CombinePDF library and the code
+## is subject to the same license.
+########################################################
+
+module CombinePDF
+
+	class PDFWriter
+
+		def initialize(media_box = [0.0, 0.0, 612.0, 792.0])
+			@content_stream = {}
+			@media_box = media_box
+		end
+
+		########################################################
+		## textbox
+		## - font_name: :font_name
+		## The PostScript names of 14 Type 1 fonts, known as the standard 14 fonts, are as follows:
+		## Times-Roman, Helvetica, Courier, Symbol, Times-Bold, Helvetica-Bold, Courier-Bold, ZapfDingbats, Times-Italic, Helvetica- Oblique, Courier-Oblique, Times-BoldItalic, Helvetica-BoldOblique, Courier-BoldOblique
+		## - text_color: [R, G, B]
+		## an array with three floats, each in a value between 0 to 1.
+		## First value is Red, second Green and last is Blue (RGB color system)
+		def add_text_box(text, args = {})
+			options = {
+				text_alignment: :center,
+				text_color: [1,1,1],
+				# text_stroke: nil,
+				font_name: :Helvetica,
+				font_type: :Type1,
+				font_object: nil,
+				font_size: 12,
+				border_color: nil,
+				border_width: nil,
+				border_radius: nil,
+				background_color: nil,
+				opacity: 1,
+				x: 0,
+				y: 0,
+				length: -1,
+				height: -1,
+			}
+			# create font object
+			font_object = { Type: :Font, Subtype: options[:font_type], BaseFont: options[:font_name]}
+			if options[:font_object].is_a?(Hash) && options[:font_object][:indirect_reference_id] && options[:font_object][:indirect_generation_number] && (options[:font_object][:is_reference_only] != true)
+				font_object = {is_reference_only: true, referenced_object: font_object}
+			end
+
+			# create resources object
+			font_name = ("MyFont" + rand(99) ).to_sym
+			resources_object = {Resources: {Font: { font_name => font_object }     }    }
+			# create box stream
+
+			# reset x,y by text alignment - x,y are calculated from the buttom left
+			# each unit (1) is 1/72 Inch
+			x = options[:x]
+			y = options[:y]
+			# create text stream
+			text_stream = ""
+			text_stream << "BT\n" # the Begine Text marker			
+			text_stream << PDFOperations._format_name_to_pdf(font_name) # Set font name
+			text_stream << " #{options[:font_size].to_f} Tf\n" # set font size and add font operator
+			text_stream << "#{options[:text_color][0]} #{options[:text_color][0]} #{options[:text_color][0]} rg\n" # sets the color state
+			text_stream << " #{options[:opacity].to_f} ca\n" # set opacity (alpha) for graphic state.
+			text_stream << "#{x} #{y} Td\n" # set location for text object
+			text_stream << PDFOperations._format_string_to_pdf(text) # insert the string in PDF format
+			text_stream << " Tj\n ET\n" # the Text object operator and the End Text marker
+		end
+
+		########################################################
+		## add_content_to_pages(pages = [], location = :above)
+		## pages - a page hash or an array of pages
+		## location - :above to place content over existing content or :below to place content under existing content
+		def add_content_to_pages(pages = [], location = :above)
+			if pages.is_a?(Array)
+				pages.each {|p| add_content_to_pages p, location}
+			elsif pages.is_a?(Hash)
+				#####
+				##add content stream to page
+			end
+		end
+		########################################################
+		## make_into_page()
+		## takes no arguments and returns the contents stream within a page (to be added as an indipendent page to the PDF object)
+		def make_into_page
+			{Type: :Page, }
+		end
+
+		########################################################
+		## to_pdf()
+		## prints out the content stream as raw PDF
+		## file_name - the name of the file to which to save the data (will be overwritten).
+		## if file_name is given, save to file.
+		def to_pdf( file_name = nil)
+			pdf = PDF.new
+			pdf << make_into_page
+			if file_name
+				pdf.save file_name
+			else
+				pdf.to_pdf
+			end
+		end
+
+	end
+	
+end
+
+
+

data/lib/combine_pdf/combine_pdf_decrypt.rb

@@ -0,0 +1,198 @@
+# -*- encoding : utf-8 -*-
+########################################################
+## Thoughts from reading the ISO 32000-1:2008
+## this file is part of the CombinePDF library and the code
+## is subject to the same license.
+########################################################
+
+module CombinePDF
+	class PDFDecrypt
+		
+		def initialize objects=[], root_doctionary = {}
+			@objects = objects
+			@encryption_dictionary = root_doctionary[:Encrypt]
+			raise "Cannot decrypt an encrypted file without an encryption dictionary!" unless @encryption_dictionary
+			@root_doctionary = root_doctionary
+			@padding_key = [ 0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41,
+							0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
+							0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80,
+							0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A ]
+			@key_crypt_first_iv_store = nil
+			@encryption_iv = nil
+			PDFOperations.change_references_to_actual_values @objects, @encryption_dictionary
+		end
+		def set_general_key(password = "")
+			# 1) make sure the initial key is 32 byte long (if no password, uses padding).
+			key = (password.bytes[0..32] + @padding_key)[0..31].pack('C*').force_encoding(Encoding::ASCII_8BIT)
+			# 2) add the value of the encryption dictionary’s O entry
+			key << @encryption_dictionary[:O].to_s
+			# 3) Convert the integer value of the P entry to a 32-bit unsigned binary number
+			# and pass these bytes low-order byte first
+			key << [@encryption_dictionary[:P]].pack('i')
+			# 4) Pass the first element of the file’s file identifier array
+			# (the value of the ID entry in the document’s trailer dictionary
+			key << @root_doctionary[:ID][0]
+			# # 4(a) (Security handlers of revision 4 or greater)
+			# # if document metadata is not being encrypted, add 4 bytes with the value 0xFFFFFFFF.
+			if @encryption_dictionary[:R] >= 4
+				unless @encryption_dictionary[:EncryptMetadata] == false #default is true and nil != false
+					key << "\x00\x00\x00\x00"
+				else
+					key << "\xFF\xFF\xFF\xFF"
+				end
+			end
+			# 5) pass everything as a MD5 hash
+			key = Digest::MD5.digest(key)
+			# 5(a) h) (Security handlers of revision 3 or greater) Do the following 50 times:
+			# Take the output from the previous MD5 hash and
+			# pass the first n bytes of the output as input into a new MD5 hash,
+			# where n is the number of bytes of the encryption key as defined by the value of
+			# the encryption dictionary’s Length entry.
+			if @encryption_dictionary[:R] >= 3
+				50.times do|i|
+					key = Digest::MD5.digest(key[0...@encryption_dictionary[:Length]])
+				end
+			end
+			# 6) Set the encryption key to the first n bytes of the output from the final MD5 hash,
+			# where n shall always be 5 for security handlers of revision 2 but,
+			# for security handlers of revision 3 or greater,
+			# shall depend on the value of the encryption dictionary’s Length entry.
+			if @encryption_dictionary[:R] >= 3
+				@key = key[0..(@encryption_dictionary[:Length]/8)]
+			else
+				@key = key[0..4]
+			end
+			@key
+		end
+		def decrypt
+			raise_encrypted_error @encryption_dictionary unless @encryption_dictionary[:Filter] == :Standard
+			@key = set_general_key
+			case @encryption_dictionary[:V]
+			when 1,2
+				warn "trying to decrypt with RC4."
+				# raise_encrypted_error
+				_perform_decrypt_proc_ @objects, self.method(:decrypt_RC4)
+			else
+				raise_encrypted_error
+			end
+			#rebuild stream lengths?
+			@objects
+		end
+		def decrypt_none(encrypted, encrypted_id, encrypted_generation, encrypted_filter)
+			"encrypted"
+		end
+		def decrypt_RC4(encrypted, encrypted_id, encrypted_generation, encrypted_filter)
+			## start decryption using padding strings
+			object_key = @key.dup
+			object_key << [encrypted_id].pack('i')[0..2]
+			object_key << [encrypted_generation].pack('i')[0..1]
+			# (0..2).each { |e| object_key << (encrypted_id >> e*8 & 0xFF ) }
+			# (0..1).each { |e| object_key << (encrypted_generation >> e*8 & 0xFF ) }
+			key_length = object_key.length < 16 ? object_key.length : 16
+			rc4 = RC4.new( Digest::MD5.digest(object_key)[(0...key_length)] )
+			rc4.decrypt(encrypted)
+		end
+		def decrypt_AES(encrypted, encrypted_id, encrypted_generation, encrypted_filter)
+			## extract encryption_iv if it wasn't extracted yet
+			unless @encryption_iv
+				@encryption_iv = encrypted[0..15].to_i
+				#raise "Tryed decrypting using AES and couldn't extract iv" if @encryption_iv == 0
+				@encryption_iv = 0.chr * 16
+				#encrypted = encrypted[16..-1]
+			end
+			## start decryption using padding strings
+			object_key = @key.dup
+			(0..2).each { |e| object_key << (encrypted_id >> e*8 & 0xFF ) }
+			(0..1).each { |e| object_key << (encrypted_generation >> e*8 & 0xFF ) }
+			object_key << "sAlT"
+			key_length = object_key.length < 16 ? object_key.length : 16
+			cipher = OpenSSL::Cipher::Cipher.new("aes-#{object_key.length << 3}-cbc").decrypt
+			cipher.padding = 0
+			(cipher.update(encrypted) + cipher.final).unpack("C*")
+		end
+		def _perform_decrypt_proc_ (object, decrypt_proc, encrypted_id = nil, encrypted_generation = nil, encrypted_filter = nil)
+			case
+			when object.is_a?(Array)
+				object.map! { |item| _perform_decrypt_proc_(item, decrypt_proc, encrypted_id, encrypted_generation, encrypted_filter) }
+			when object.is_a?(Hash)
+				encrypted_id ||= object[:indirect_reference_id]
+				encrypted_generation ||=  object[:indirect_generation_number]
+				encrypted_filter ||= object[:Filter]
+				if object[:raw_stream_content]
+					stream_length = object[:Length]
+					if stream_length.is_a?(Hash) && stream_length[:is_reference_only]
+						stream_length = PDFOperations.get_refernced_object( @objects, stream_length)[:indirect_without_dictionary]
+					end
+					actual_length = object[:raw_stream_content].length
+					warn "Stream registeded length was #{object[:Length].to_s} and the actual length was #{actual_length}." if actual_length < stream_length
+					length = [ stream_length, actual_length].min
+					object[:raw_stream_content] = decrypt_proc.call( (object[:raw_stream_content][0...length]), encrypted_id, encrypted_generation, encrypted_filter)
+				end
+				object.each {|k, v| object[k] = _perform_decrypt_proc_(v, decrypt_proc, encrypted_id, encrypted_generation, encrypted_filter) if k != :raw_stream_content && (v.is_a?(Hash) || v.is_a?(Array) || v.is_a?(String))} # assumes no decrypting is ever performed on keys
+			when object.is_a?(String)
+				return decrypt_proc.call(object, encrypted_id, encrypted_generation, encrypted_filter)
+			else
+				return object
+			end
+			
+		end
+
+		def raise_encrypted_error object = nil
+			object ||= @encryption_dictionary.to_s.split(',').join("\n")
+			warn "Data raising exception:\n #{object.to_s.split(',').join("\n")}"
+			raise "File is encrypted - not supported."			
+		end
+	end
+	#####################################################
+	## The following isn't my code!!!!
+	## It is subject to a different license and copyright.
+	## This was the code for the RC4 Gem,
+	## ... I had a bad internet connection so I ended up
+	## copying it from the web page I had in my cache.
+	## This wonderful work was done by Caige Nichols.
+	#####################################################
+
+	class RC4
+	  def initialize(str)
+	    begin
+	      raise SyntaxError, "RC4: Key supplied is blank"  if str.eql?('')
+
+	      @q1, @q2 = 0, 0
+	      @key = []
+	      str.each_byte { |elem| @key << elem } while @key.size < 256
+	      @key.slice!(256..@key.size-1) if @key.size >= 256
+	      @s = (0..255).to_a
+	      j = 0
+	      0.upto(255) do |i|
+	        j = (j + @s[i] + @key[i] ) % 256
+	        @s[i], @s[j] = @s[j], @s[i]
+	      end
+	    end
+	  end
+
+	  def encrypt!(text)
+	    process text
+	  end
+
+	  def encrypt(text)
+	    process text.dup
+	  end
+
+	  alias_method :decrypt, :encrypt
+
+	  private
+
+	  def process(text)
+	    text.unpack("C*").map { |c| c ^ round }.pack("C*")
+	  end
+
+	  def round
+	    @q1 = (@q1 + 1) % 256
+	    @q2 = (@q2 + @s[@q1]) % 256
+	    @s[@q1], @s[@q2] = @s[@q2], @s[@q1]
+	    @s[(@s[@q1]+@s[@q2]) % 256]
+	  end
+	end
+
+end
+

data/lib/combine_pdf/combine_pdf_filter.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+########################################################
+## Thoughts from reading the ISO 32000-1:2008
+## this file is part of the CombinePDF library and the code
+## is subject to the same license.
+########################################################
+
+module CombinePDF
+
+	module PDFFilter
+		module_function
+		
+		def deflate_object object = nil
+			false
+		end
+
+		def inflate_object object = nil, filter = :none
+			filter_array = object[:Filter]
+			if filter_array.is_a?(Hash) && filter_array[:is_reference_only]
+				filter_array = filter_array[:referenced_object]
+			end
+			if filter_array.is_a?(Symbol)
+				filter_array = [filter_array]
+			end
+			filter_array = [] if filter_array.nil?
+			params_array = object[:DecodeParms]
+			if params_array.is_a?(Hash) && params_array[:is_reference_only]
+				params_array = params_array[:referenced_object]
+			end
+			unless params_array.is_a?(Array)
+				params_array = [params_array]
+			end
+			while filter_array[0]
+				case filter_array[0]
+				when :FlateDecode
+					raise_unsupported_error params_array[0] unless params_array[0].nil?
+					if params_array[0] && params_array[0][:Predictor].to_i > 1
+						bits = params_array[0][:BitsPerComponent] || 8
+						predictor = params_array[0][:Predictor].to_i
+						columns = params_array[0][:Columns] || 1
+						if (2..9).include? params_array[0][:Predictor].to_i
+							####
+							# prepare TIFF group
+						elsif (10..15).include? params_array[0][:Predictor].to_i == 2
+							####
+							# prepare PNG group
+						end
+					else
+						object[:raw_stream_content] = Zlib::Inflate.inflate object[:raw_stream_content]
+						object[:Length] = object[:raw_stream_content].bytesize
+					end
+				when nil
+					true
+				else
+					return false
+				end
+				params_array.shift
+				filter_array.shift
+			end
+			object.delete(:Filter)
+			true
+		end
+		def raise_unsupported_error (object = {})
+			raise "Filter #{object} unsupported. couldn't deflate object"
+		end
+
+	end
+	
+end
+
+
+

data/lib/combine_pdf/combine_pdf_parser.rb

@@ -0,0 +1,315 @@
+# -*- encoding : utf-8 -*-
+########################################################
+## Thoughts from reading the ISO 32000-1:2008
+## this file is part of the CombinePDF library and the code
+## is subject to the same license.
+########################################################
+module CombinePDF
+
+	########################################################
+	## This is the Parser class.
+	## It takes PDF data and parses it, returning an array
+	## of data.
+	## That array can be used to initialize a PDF object.
+	## The Parser class doesn't involve itself with the
+	## file version.
+	########################################################
+
+	class PDFParser
+		# LITERAL_STRING_REPLACEMENT_HASH = {
+		# 	110 => 10, # "\\n".bytes = [92, 110]  "\n".ord = 10
+		# 	114 => 13, #r
+		# 	116 => 9, #t
+		# 	98 => 8, #b 
+		# 	102 => 255, #f
+		# 	40 => 40, #(
+		# 	41 => 41, #)
+		# 	92 => 92 #\
+		# 	}
+		attr_reader :parsed, :version, :info_object, :root_object
+		def initialize (string)
+			raise TypeError, "couldn't parse and data, expecting type String" unless string.is_a? String
+			@string_to_parse = string.force_encoding(Encoding::ASCII_8BIT)
+			@literal_strings = []
+			@hex_strings = []
+			@streams = []
+			@parsed = []
+			@root_object = {}
+			@info_object = {}
+			@version = nil
+			@scanner = nil
+		end
+
+		def parse
+			return @parsed unless @parsed.empty?
+			@scanner = StringScanner.new @string_to_parse
+			@scanner.pos = 0
+			if @scanner.scan /\%PDF\-[\d\-\.]+/
+				@version = @scanner.matched.scan(/[\d\.]+/)[0].to_f
+			end
+
+			warn "Starting to parse PDF data."
+			@parsed = _parse_
+
+			if @root_object == {}
+				xref_streams = @parsed.select {|obj| obj.is_a?(Hash) && obj[:Type] == :XRef}
+				xref_streams.each do |xref_dictionary|
+					@root_object.merge! xref_dictionary
+				end
+			end
+			raise "root is unknown - cannot determine if file is Encrypted" if @root_object == {}
+			warn "Injecting actual values into root object: #{@root_object}."
+			PDFOperations.change_references_to_actual_values @parsed, @root_object
+
+			if @root_object[:Encrypt]
+				warn "PDF is Encrypted! Attempting to unencrypt - not yet fully supported."
+				decryptor = PDFDecrypt.new @parsed, @root_object
+				decryptor.decrypt
+				#do we really need to apply to @parsed? No, there is no need.
+			end
+			if @version >= 1.5 # code placement for object streams
+				## search for objects streams
+				object_streams = @parsed.select {|obj| obj.is_a?(Hash) && obj[:Type] == :ObjStm}
+				unless object_streams.empty?
+					warn "PDF 1.5 Object streams found - they are not fully supported! attempting to extract objects."
+					
+					object_streams.each do |o|
+						warn "Attempting #{o.select {|k,v| k != :raw_stream_content}}"
+						## un-encode (using the correct filter) the object streams
+						PDFFilter.inflate_object o 
+						## extract objects from stream to top level arry @parsed
+						@scanner = StringScanner.new o[:raw_stream_content]
+						stream_data = _parse_
+						id_array = []
+						while stream_data[0].is_a? Fixnum
+							id_array << stream_data.shift
+							stream_data.shift
+						end
+						while stream_data[0].is_a? Hash
+							stream_data[0][:indirect_reference_id] = id_array.shift
+							stream_data[0][:indirect_generation_number] = 0
+							@parsed << stream_data.shift
+						end
+					end
+					# ## remove object streams
+					@parsed.reject! {|obj| object_streams << obj if obj.is_a?(Hash) && obj[:Type] == :ObjStm}
+					# ## remove XREF dictionaries
+					@parsed.reject! {|obj| object_streams << obj if obj.is_a?(Hash) && obj[:Type] == :XRef}
+				end
+			end
+			PDFOperations.change_references_to_actual_values @parsed, @root_object
+			@info_object = @root_object[:Info]
+			if @info_object && @info_object.is_a?(Hash)
+				@parsed.delete @info_object
+				PDFOperations.change_references_to_actual_values @parsed, @info_object
+				PRIVATE_HASH_KEYS.each {|key| @info_object.delete key}
+			else
+				@info_object = {}
+			end
+			warn "setting parsed collection and returning collection."
+			@parsed
+		end
+
+		protected
+		
+		def _parse_
+			out = []
+			str = ''
+			# warn "Scaning for objects, starting at #{@scanner.pos}: #{@scanner.peek(10)}"
+			while @scanner.rest? do
+				case
+				##########################################
+				## parse an Array
+				##########################################
+				when @scanner.scan(/\[/)
+					out << _parse_
+				##########################################
+				## parse a Dictionary
+				##########################################
+				when @scanner.scan(/<</)
+					data = _parse_
+					obj = {}
+					obj[data.shift] = data.shift while data[0]
+					out << obj
+				##########################################
+				## return content of array or dictionary
+				##########################################
+				when @scanner.scan(/\]/), @scanner.scan(/>>/)
+					return out
+				##########################################
+				## parse a Stream
+				##########################################
+				when @scanner.scan(/stream[\r]?[\n]/)
+					str = @scanner.scan_until(/endstream/)
+					# need to remove end of stream
+					if out.last.is_a? Hash
+						out.last[:raw_stream_content] = str[0...-10] #cuts only one EON char (\n or \r)
+						# out.last[:raw_stream_content] = str.gsub(/[\n\r]?[\n\r]?endstream/, "")
+					else
+						warn "Stream not attached to dictionary!"
+						out << str[0...-10].force_encoding(Encoding::ASCII_8BIT)
+					end
+				##########################################
+				## parse an Object after finished
+				##########################################
+				when str = @scanner.scan(/endobj/)
+					# warn "Proccessing Object"
+					#what to do when this is an object?
+					if out.last.is_a? Hash
+						out << out.pop.merge({indirect_generation_number: out.pop, indirect_reference_id: out.pop})
+					else
+						out << {indirect_without_dictionary: out.pop, indirect_generation_number: out.pop, indirect_reference_id: out.pop}
+					end
+				##########################################
+				## parse a Hex String
+				##########################################
+				when str = @scanner.scan(/<[0-9a-f]+>/)
+					# warn "Found a hex string"
+					out << [str[1..-2]].pack('H*')
+				##########################################
+				## parse a Literal String
+				##########################################
+				when @scanner.scan(/\(/)
+					# warn "Found a literal string"
+					str = ''
+					count = 1
+					while count > 0 && @scanner.rest? do
+						str += @scanner.scan_until(/[\(\)]/).to_s
+						seperator_count = 0
+						seperator_count += 1 while str[-2-seperator_count] == "\\"
+
+						case str[-1]
+						when '('
+							## The following solution fails when (string ends with this sign: \\)
+
+							count += 1 unless seperator_count.odd?
+						when ')'
+							count -= 1 unless seperator_count.odd?
+						else
+							warn "Unknown error parsing string at #{@scanner.pos}!"
+							cout = 0 # error
+						end
+					end
+					# The PDF formatted string is: str[0..-2]
+					# now staring to convert to regular string
+					str_bytes = str[0..-2].bytes
+					str = []
+					until str_bytes.empty?
+						case str_bytes[0]
+						when 13 # eol - \r
+							# An end-of-line marker appearing within a literal string without a preceding REVERSE SOLIDUS
+							# shall be treated as a byte value of (0Ah),
+							# irrespective of whether the end-of-line marker was a CARRIAGE RETURN (0Dh), a LINE FEED (0Ah), or both.
+							str_bytes.shift
+							str_bytes.shift if str_bytes[0] == 10
+							str << 10
+						when 10 # eol - \n
+							# An end-of-line marker appearing within a literal string without a preceding REVERSE SOLIDUS
+							# shall be treated as a byte value of (0Ah),
+							# irrespective of whether the end-of-line marker was a CARRIAGE RETURN (0Dh), a LINE FEED (0Ah), or both.
+							str_bytes.shift
+							str_bytes.shift if str_bytes[0] == 13
+							str << 10
+						when 92 # "\\".ord == 92
+							str_bytes.shift
+							rep = str_bytes.shift
+							case rep
+							when 110 #n
+								str << 10 #new line
+							when 114 #r
+								str << 13 # CR
+							when 116 #t
+								str << 9 #tab
+							when 98 #b
+								str << 8
+							when 102 #f
+								str << 255
+							when 48..57 #decimal notation for byte?
+								rep = rep.chr
+								rep += str_bytes.shift.chr if str_bytes[0].between?(48,57)
+								rep += str_bytes.shift.chr if str_bytes[0].between?(48,57) && ((rep + str_bytes[0].chr).to_i <= 255)
+								str << rep.to_i
+							when 10 # new line, ignore
+								str_bytes.shift if str_bytes[0] == 13
+								true
+							when 13 # new line (or double notation for new line), ignore
+								str_bytes.shift if str_bytes[0] == 10
+								true
+							else
+								str << rep
+							end
+						else
+							str << str_bytes.shift
+						end
+					end
+					out << str.pack('C*')
+				##########################################
+				## Parse a comment
+				##########################################
+				when str = @scanner.scan(/\%/)
+					#is a comment, skip until new line
+					@scanner.skip_until /[\n\r]+/
+				##########################################
+				## Parse a Name
+				##########################################
+				# old, probably working version: when str = @scanner.scan(/\/[\#\w\d\.\+\-\\\?\,]+/)
+				# I don't know how to write the /[\x21-\x7e___subtract_certain_hex_values_here____]+/
+				# all allowed regular caracters between ! and ~ : /[\x21-\x24\x26\x27\x2a-\x2e\x30-\x3b\x3d\x3f-\x5a\x5c\x5e-\x7a\x7c\x7e]+
+				# all characters that aren't white space or special: /[^\x00\x09\x0a\x0c\x0d\x20\x28\x29\x3c\x3e\x5b\x5d\x7b\x7d\x2f\x25]+
+			when str = @scanner.scan(/\/[^\x00\x09\x0a\x0c\x0d\x20\x28\x29\x3c\x3e\x5b\x5d\x7b\x7d\x2f\x25]+/)
+					out << ( str[1..-1].gsub(/\#[0-9a-fA-F]{2}/) {|a| a[1..2].hex.chr } ).to_sym
+				##########################################
+				## Parse a Number
+				##########################################
+				when str = @scanner.scan(/[\+\-\.\d]+/)
+					str.match(/\./) ? (out << str.to_f) : (out << str.to_i)
+				##########################################
+				## Parse an Object Reference
+				##########################################
+				when @scanner.scan(/R/)
+					out << { is_reference_only: true, indirect_generation_number: out.pop, indirect_reference_id: out.pop}
+				##########################################
+				## Parse Bool - true and after false
+				##########################################
+				when @scanner.scan(/true/)
+					out << true
+				when @scanner.scan(/false/)
+					out << false
+				##########################################
+				## Parse NULL - null
+				##########################################
+				when @scanner.scan(/null/)
+					out << nil
+				##########################################
+				## XREF - check for encryption... anything else?
+				##########################################
+				when @scanner.scan(/xref/)
+					##########
+					## get root object to check for encryption
+					@scanner.scan_until(/(trailer)|(\%EOF)/)
+
+					if @scanner.matched[-1] == 'r'
+						if @scanner.skip_until(/<</)
+							data = _parse_
+							@root_object = {}
+							@root_object[data.shift] = data.shift while data[0]						
+						end
+						##########
+						## skip untill end of segment, maked by %%EOF
+						@scanner.skip_until(/\%\%EOF/)
+					end
+					
+				when @scanner.scan(/[\s]+/) , @scanner.scan(/obj[\s]*/)
+					# do nothing
+					# warn "White Space, do nothing"
+					nil
+				else
+					# always advance 
+					# warn "Advnacing for unknown reason..."
+					@scanner.pos = @scanner.pos + 1
+				end
+			end
+			out
+		end
+	end
+end