home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / pippy-0.6beta-src.tar.gz / pippy-0.6beta-src.tar / pippy-0.6beta-src / src / Lib / posixfile.py < prev    next >
Text File  |  2000-12-21  |  8KB  |  233 lines
  1. """Extended file operations available in POSIX.
  2.  
  3. f = posixfile.open(filename, [mode, [bufsize]])
  4.       will create a new posixfile object
  5.  
  6. f = posixfile.fileopen(fileobject)
  7.       will create a posixfile object from a builtin file object
  8.  
  9. f.file()
  10.       will return the original builtin file object
  11.  
  12. f.dup()
  13.       will return a new file object based on a new filedescriptor
  14.  
  15. f.dup2(fd)
  16.       will return a new file object based on the given filedescriptor
  17.  
  18. f.flags(mode)
  19.       will turn on the associated flag (merge)
  20.       mode can contain the following characters:
  21.  
  22.   (character representing a flag)
  23.       a       append only flag
  24.       c       close on exec flag
  25.       n       no delay flag
  26.       s       synchronization flag
  27.   (modifiers)
  28.       !       turn flags 'off' instead of default 'on'
  29.       =       copy flags 'as is' instead of default 'merge'
  30.       ?       return a string in which the characters represent the flags
  31.               that are set
  32.  
  33.       note: - the '!' and '=' modifiers are mutually exclusive.
  34.             - the '?' modifier will return the status of the flags after they
  35.               have been changed by other characters in the mode string
  36.  
  37. f.lock(mode [, len [, start [, whence]]])
  38.       will (un)lock a region
  39.       mode can contain the following characters:
  40.  
  41.   (character representing type of lock)
  42.       u       unlock
  43.       r       read lock
  44.       w       write lock
  45.   (modifiers)
  46.       |       wait until the lock can be granted
  47.       ?       return the first lock conflicting with the requested lock
  48.               or 'None' if there is no conflict. The lock returned is in the
  49.               format (mode, len, start, whence, pid) where mode is a
  50.               character representing the type of lock ('r' or 'w')
  51.  
  52.       note: - the '?' modifier prevents a region from being locked; it is
  53.               query only
  54. """
  55.  
  56. class _posixfile_:
  57.     """File wrapper class that provides extra POSIX file routines."""
  58.  
  59.     states = ['open', 'closed']
  60.  
  61.     #
  62.     # Internal routines
  63.     #
  64.     def __repr__(self):
  65.         file = self._file_
  66.         return "<%s posixfile '%s', mode '%s' at %s>" % \
  67.                 (self.states[file.closed], file.name, file.mode, \
  68.                  hex(id(self))[2:])
  69.  
  70.     def __del__(self):
  71.         self._file_.close()
  72.  
  73.     #
  74.     # Initialization routines
  75.     #
  76.     def open(self, name, mode='r', bufsize=-1):
  77.         import __builtin__
  78.         return self.fileopen(__builtin__.open(name, mode, bufsize))
  79.  
  80.     def fileopen(self, file):
  81.         if `type(file)` != "<type 'file'>":
  82.             raise TypeError, 'posixfile.fileopen() arg must be file object'
  83.         self._file_  = file
  84.         # Copy basic file methods
  85.         for method in file.__methods__:
  86.             setattr(self, method, getattr(file, method))
  87.         return self
  88.  
  89.     #
  90.     # New methods
  91.     #
  92.     def file(self):
  93.         return self._file_
  94.  
  95.     def dup(self):
  96.         import posix
  97.  
  98.         try: ignore = posix.fdopen
  99.         except: raise AttributeError, 'dup() method unavailable'
  100.  
  101.         return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
  102.  
  103.     def dup2(self, fd):
  104.         import posix
  105.  
  106.         try: ignore = posix.fdopen
  107.         except: raise AttributeError, 'dup() method unavailable'
  108.  
  109.         posix.dup2(self._file_.fileno(), fd)
  110.         return posix.fdopen(fd, self._file_.mode)
  111.  
  112.     def flags(self, *which):
  113.         import fcntl, FCNTL
  114.  
  115.         if which:
  116.             if len(which) > 1:
  117.                 raise TypeError, 'Too many arguments'
  118.             which = which[0]
  119.         else: which = '?'
  120.  
  121.         l_flags = 0
  122.         if 'n' in which: l_flags = l_flags | FCNTL.O_NDELAY
  123.         if 'a' in which: l_flags = l_flags | FCNTL.O_APPEND
  124.         if 's' in which: l_flags = l_flags | FCNTL.O_SYNC
  125.  
  126.         file = self._file_
  127.  
  128.         if '=' not in which:
  129.             cur_fl = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
  130.             if '!' in which: l_flags = cur_fl & ~ l_flags
  131.             else: l_flags = cur_fl | l_flags
  132.  
  133.         l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFL, l_flags)
  134.  
  135.         if 'c' in which:        
  136.             arg = ('!' not in which)    # 0 is don't, 1 is do close on exec
  137.             l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_SETFD, arg)
  138.  
  139.         if '?' in which:
  140.             which = ''                  # Return current flags
  141.             l_flags = fcntl.fcntl(file.fileno(), FCNTL.F_GETFL, 0)
  142.             if FCNTL.O_APPEND & l_flags: which = which + 'a'
  143.             if fcntl.fcntl(file.fileno(), FCNTL.F_GETFD, 0) & 1:
  144.                 which = which + 'c'
  145.             if FCNTL.O_NDELAY & l_flags: which = which + 'n'
  146.             if FCNTL.O_SYNC & l_flags: which = which + 's'
  147.             return which
  148.         
  149.     def lock(self, how, *args):
  150.         import struct, fcntl, FCNTL
  151.  
  152.         if 'w' in how: l_type = FCNTL.F_WRLCK
  153.         elif 'r' in how: l_type = FCNTL.F_RDLCK
  154.         elif 'u' in how: l_type = FCNTL.F_UNLCK
  155.         else: raise TypeError, 'no type of lock specified'
  156.  
  157.         if '|' in how: cmd = FCNTL.F_SETLKW
  158.         elif '?' in how: cmd = FCNTL.F_GETLK
  159.         else: cmd = FCNTL.F_SETLK
  160.  
  161.         l_whence = 0
  162.         l_start = 0
  163.         l_len = 0
  164.  
  165.         if len(args) == 1:
  166.             l_len = args[0]
  167.         elif len(args) == 2:
  168.             l_len, l_start = args
  169.         elif len(args) == 3:
  170.             l_len, l_start, l_whence = args
  171.         elif len(args) > 3:
  172.             raise TypeError, 'too many arguments'
  173.  
  174.         # Hack by davem@magnet.com to get locking to go on freebsd;
  175.         # additions for AIX by Vladimir.Marangozov@imag.fr
  176.         import sys, os
  177.         if sys.platform in ('netbsd1',
  178.                             'openbsd2',
  179.                             'freebsd2', 'freebsd3',
  180.                             'bsdos2', 'bsdos3', 'bsdos4'):
  181.             flock = struct.pack('lxxxxlxxxxlhh', \
  182.                   l_start, l_len, os.getpid(), l_type, l_whence) 
  183.         elif sys.platform in ['aix3', 'aix4']:
  184.             flock = struct.pack('hhlllii', \
  185.                   l_type, l_whence, l_start, l_len, 0, 0, 0)
  186.         else:
  187.             flock = struct.pack('hhllhh', \
  188.                   l_type, l_whence, l_start, l_len, 0, 0)
  189.  
  190.         flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
  191.  
  192.         if '?' in how:
  193.             if sys.platform in ('netbsd1',
  194.                                 'openbsd2',
  195.                                 'freebsd2', 'freebsd3',
  196.                                 'bsdos2', 'bsdos3', 'bsdos4'):
  197.                 l_start, l_len, l_pid, l_type, l_whence = \
  198.                     struct.unpack('lxxxxlxxxxlhh', flock)
  199.             elif sys.platform in ['aix3', 'aix4']:
  200.                 l_type, l_whence, l_start, l_len, l_sysid, l_pid, l_vfs = \
  201.                     struct.unpack('hhlllii', flock)
  202.             elif sys.platform == "linux2":
  203.                 l_type, l_whence, l_start, l_len, l_pid, l_sysid = \
  204.                     struct.unpack('hhllhh', flock)
  205.             else:
  206.                 l_type, l_whence, l_start, l_len, l_sysid, l_pid = \
  207.                     struct.unpack('hhllhh', flock)
  208.  
  209.             if l_type != FCNTL.F_UNLCK:
  210.                 if l_type == FCNTL.F_RDLCK:
  211.                     return 'r', l_len, l_start, l_whence, l_pid
  212.                 else:
  213.                     return 'w', l_len, l_start, l_whence, l_pid
  214.  
  215. def open(name, mode='r', bufsize=-1):
  216.     """Public routine to open a file as a posixfile object."""
  217.     return _posixfile_().open(name, mode, bufsize)
  218.  
  219. def fileopen(file):
  220.     """Public routine to get a posixfile object from a Python file object."""
  221.     return _posixfile_().fileopen(file)
  222.  
  223. #
  224. # Constants
  225. #
  226. SEEK_SET = 0
  227. SEEK_CUR = 1
  228. SEEK_END = 2
  229.  
  230. #
  231. # End of posixfile.py
  232. #
  233.