docs: def parse_export_directory(self, rva, size):
          """Parse the export directory.
          
          Given the RVA of the export directory, it will process all
          its entries.
          
          The exports will be made available through a list "exports"
          containing a tuple with the following elements:
              
              (ordinal, symbol_address, symbol_name)
          
          And also through a dictionary "exports_by_ordinal" whose keys
          will be the ordinals and the values tuples of the from:
              
              (symbol_address, symbol_name)
          
          The symbol addresses are relative, not absolute.
          """
          
          try:
              export_dir =  self.__unpack_data__(
                  self.__IMAGE_EXPORT_DIRECTORY_format__,
                  self.get_data( rva, Structure(self.__IMAGE_EXPORT_DIRECTORY_format__).sizeof() ),
                  file_offset = self.get_offset_from_rva(rva) )
          except PEFormatError:
              self.__warnings.append(
                  'Error parsing export directory at RVA: 0x%x' % ( rva ) )
              return
          
          if not export_dir:
              return
          
          # We keep track of the bytes left in the file and use it to set a upper
          # bound in the number of items that can be read from the different
          # arrays
          #
          def length_until_eof(rva):
              return len(self.__data__) - self.get_offset_from_rva(rva)
          
          try:
              address_of_names = self.get_data(
                  export_dir.AddressOfNames, min( length_until_eof(export_dir.AddressOfNames), export_dir.NumberOfNames*4))
              address_of_name_ordinals = self.get_data(
                  export_dir.AddressOfNameOrdinals, min( length_until_eof(export_dir.AddressOfNameOrdinals), export_dir.NumberOfNames*4) )
              address_of_functions = self.get_data(
                  export_dir.AddressOfFunctions, min( length_until_eof(export_dir.AddressOfFunctions), export_dir.NumberOfFunctions*4) )
          except PEFormatError:
              self.__warnings.append(
                  'Error parsing export directory at RVA: 0x%x' % ( rva ) )
              return
          
          exports = []
          
          max_failed_entries_before_giving_up = 10
          
          for i in xrange( min( export_dir.NumberOfNames, length_until_eof(export_dir.AddressOfNames)/4) ):
              
              symbol_name_address = self.get_dword_from_data(address_of_names, i)
  
              symbol_name = self.get_string_at_rva( symbol_name_address )
              try:
                  symbol_name_offset = self.get_offset_from_rva( symbol_name_address )
              except PEFormatError:
                  max_failed_entries_before_giving_up -= 1
                  if max_failed_entries_before_giving_up <= 0:
                      break
                  continue
              
              symbol_ordinal = self.get_word_from_data(
                  address_of_name_ordinals, i)
  
              
              if symbol_ordinal*4 < len(address_of_functions):
                  symbol_address = self.get_dword_from_data(
                      address_of_functions, symbol_ordinal)
              else:
                  # Corrupt? a bad pointer... we assume it's all
                  # useless, no exports
                  return None
  
              if symbol_address is None or symbol_address == 0:
                  continue
              
              # If the funcion's RVA points within the export directory
              # it will point to a string with the forwarded symbol's string
              # instead of pointing the the function start address.
              
              if symbol_address >= rva and symbol_address < rva+size:
                  forwarder_str = self.get_string_at_rva(symbol_address)
                  try:
                      forwarder_offset = self.get_offset_from_rva( symbol_address )
                  except PEFormatError:
                      continue
              else:
                  forwarder_str = None
                  forwarder_offset = None
              
              exports.append(
                  ExportData(
                      pe = self,
                      ordinal = export_dir.Base+symbol_ordinal,
                      ordinal_offset = self.get_offset_from_rva( export_dir.AddressOfNameOrdinals + 2*i ),
                      address = symbol_address,
                      address_offset = self.get_offset_from_rva( export_dir.AddressOfFunctions + 4*symbol_ordinal ),
                      name = symbol_name,
                      name_offset = symbol_name_offset,
                      forwarder = forwarder_str,
                      forwarder_offset = forwarder_offset ))
          
          ordinals = [exp.ordinal for exp in exports]
          
          max_failed_entries_before_giving_up = 10
          
          for idx in xrange( min(export_dir.NumberOfFunctions, length_until_eof(export_dir.AddressOfFunctions)/4) ):
              
              if not idx+export_dir.Base in ordinals:
                  try:
                      symbol_address = self.get_dword_from_data(
                          address_of_functions, idx)
                  except PEFormatError:
                      symbol_address = None
                  
                  if symbol_address is None:
                      max_failed_entries_before_giving_up -= 1
                      if max_failed_entries_before_giving_up <= 0:
                          break
                  
                  if symbol_address == 0:
                      continue
                  #
                  # Checking for forwarder again.
                  #
                  if symbol_address >= rva and symbol_address < rva+size:
                      forwarder_str = self.get_string_at_rva(symbol_address)
                  else:
                      forwarder_str = None
  
                  exports.append(
                      ExportData(
                          ordinal = export_dir.Base+idx,
                          address = symbol_address,
                          name = None,
                          forwarder = forwarder_str))
          
          return ExportDirData(
                  struct = export_dir,
                  symbols = exports)