docs: def open(self, _file, target=DEFAULT_TARGET):
          """
          Open the existing file for reading.
  
          @param _file : A filename of file descriptor.
          @param target: A user-specific BFD target name.
  
          @return : None
          """
          # Close any existing BFD structure instance. 
          self.close()
  
          #
          # STEP 1. Open the BFD pointer.
          #
          # Determine if the user passed a file-descriptor or a _file and
          # proceed accordingly.
          if type(_file) is FileType:
              # The user specified a file descriptor.
              filename = _file.name
  
              if islink(filename):
                  raise BfdException("Symlinks file-descriptors are not valid")
                      
              try:
                  self._ptr = _bfd.fdopenr(filename, target, dup(_file.fileno()))
              except Exception, err:
                  raise BfdException(
                      "Unable to open file-descriptor %s : %s" % (filename, err))
  
          elif type(_file) is StringType:
              # The user spcified a filaname so first check if file exists.
              filename = _file
              try:
                  with open(_file): pass
              except IOError:
                  raise BfdException("File %s does not exist." % filename)
  
              #
              # Proceed to open the specified file and create a new BFD.
              #
              try:
                  self._ptr = _bfd.openr(filename, target)
              except (TypeError, IOError), err:
                  raise BfdException(
                      "Unable to open file %s : %s" % (filename, err))
  
          elif type(_file) is IntType:
              # The user specified an already-open BFD pointer so we avoid any
              # further open operation and move on to file format recognition.
              self._ptr = _file
  
          else:
              raise BfdException(
                  "Invalid file type specified for open operation (%r)" % _file)
  
          #
          # STEP 2. Determine file format of the BFD.
          #
          # Now that the BFD is open we'll proceed to determine its file format.
          # We'll use the objdump logic to determine it and raise an error in
          # case we were unable to get it right.
          #
          try:
              # Type opening it as an archieve and if it success then check
              # subfiles.
              if _bfd.check_format(self._ptr, BfdFormat.ARCHIVE):
                  # Set current format and store the inner file list.
                  self.file_format = BfdFormat.ARCHIVE
  
                  self.__populate_archive_files()
              else:
                  # DO NOT USE bfd_check_format_matches() becuase its not tested.
                  # An implementation example if on objdump.c at function
                  # display_bfd().
                  if _bfd.check_format(self._ptr, BfdFormat.OBJECT):
                      self.file_format = BfdFormat.OBJECT
  
                  elif _bfd.check_format(self._ptr, BfdFormat.CORE):
                      self.file_format = BfdFormat.CORE
  
                  else:
                      pass
                      raise BfdException(_bfd.get_last_error_message())
  
          except TypeError, err:
              raise BfdException(
                  "Unable to initialize file format : %s" % err)
  
          #
          # STEP 3. Extract inner sections and symbolic information.
          #
          if self._ptr is not None:
              # If the file is a valid BFD file format but not an archive then
              # get its sections and symbolic information (if any).
              if self.file_format in [BfdFormat.OBJECT, BfdFormat.CORE]:
                  self.__populate_sections()
                  self.__populate_symbols()