docs: def _split_file(self, data=''):
          """
          Splits SAR output or SAR output file (in ASCII format) in order to
          extract info we need for it, in the format we want.
              :param data: Input data instead of file
              :type data: str.
              :return: ``List``-style of SAR file sections separated by
                  the type of info they contain (SAR file sections) without
                  parsing what is exactly what at this point
          """
  
          # Filename passed checks through __init__
          if ((self.__filename and os.access(self.__filename, os.R_OK))
                  or data != ''):
  
              fhandle = None
  
              if data == '':
                  try:
                      fhandle = os.open(self.__filename, os.O_RDONLY)
                  except OSError:
                      print(("Couldn't open file %s" % self.__filename))
                      fhandle = None
  
              if fhandle or data != '':
  
                  datalength = 0
                  
                  # Dealing with mmap difference on Windows and Linux
                  if platform.system() == 'Windows':
                      dataprot = mmap.ACCESS_READ
                  else:
                      dataprot = mmap.PROT_READ
  
                  if data != '':
                      fhandle = -1
                      datalength = len(data)
                      
                      if platform.system() == 'Windows':    
                          dataprot = mmap.ACCESS_READ | mmap.ACCESS_WRITE
                      else:
                          dataprot = mmap.PROT_READ | mmap.PROT_WRITE                    
  
                  try:
                      if platform.system() == 'Windows':
                          sarmap = mmap.mmap(
                              fhandle, length=datalength, access=dataprot
                          )
                      else:
                          sarmap = mmap.mmap(
                              fhandle, length=datalength, prot=dataprot
                          )
                      if data != '':
  
                          sarmap.write(data)
                          sarmap.flush()
                          sarmap.seek(0, os.SEEK_SET)
  
                  except (TypeError, IndexError):
                      if data == '':
                          os.close(fhandle)
                      traceback.print_exc()
                      # sys.exit(-1)
                      return False
  
                  # Here we'll store chunks of SAR file, unparsed
                  searchunks = []
                  oldchunkpos = 0
                  dlpos = sarmap.find('\n\n', 0)
                  size = 0
  
                  if data == '':
                      # We can do mmap.size() only on read-only mmaps
                      size = sarmap.size()
                  else:
                      # Otherwise, if data was passed to us,
                      # we measure its length
                      len(data)
  
                  # oldchunkpos = dlpos
  
                  while dlpos > -1:  # mmap.find() returns -1 on failure.
  
                      tempchunk = sarmap.read(dlpos - oldchunkpos)
                      searchunks.append(tempchunk.strip())
  
                      # We remember position, add 2 for 2 DD's
                      # (newspaces in production). We have to remember
                      # relative value
                      oldchunkpos += (dlpos - oldchunkpos) + 2
  
                      # We position to new place, to be behind \n\n
                      # we've looked for.
                      try:
                          sarmap.seek(2, os.SEEK_CUR)
                      except ValueError:
                          print(('Out of bounds (%s)!\n' % (sarmap.tell())))
                      # Now we repeat find.
                      dlpos = sarmap.find("\n\n")
  
                  # If it wasn't the end of file, we want last piece of it
                  if oldchunkpos < size:
                      tempchunk = sarmap[oldchunkpos:]
                      searchunks.append(tempchunk.strip())
  
                  sarmap.close()
  
              if fhandle != -1:
                  os.close(fhandle)
  
              if searchunks:
                  return searchunks
              else:
                  return False
  
          return False