home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / os2emxpath.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  10.1 KB  |  428 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Common pathname manipulations, OS/2 EMX version.
  5.  
  6. Instead of importing this module directly, import os and refer to this
  7. module as os.path.
  8. '''
  9. import os
  10. import stat
  11. __all__ = [
  12.     'normcase',
  13.     'isabs',
  14.     'join',
  15.     'splitdrive',
  16.     'split',
  17.     'splitext',
  18.     'basename',
  19.     'dirname',
  20.     'commonprefix',
  21.     'getsize',
  22.     'getmtime',
  23.     'getatime',
  24.     'getctime',
  25.     'islink',
  26.     'exists',
  27.     'isdir',
  28.     'isfile',
  29.     'ismount',
  30.     'walk',
  31.     'expanduser',
  32.     'expandvars',
  33.     'normpath',
  34.     'abspath',
  35.     'splitunc',
  36.     'curdir',
  37.     'pardir',
  38.     'sep',
  39.     'pathsep',
  40.     'defpath',
  41.     'altsep',
  42.     'extsep',
  43.     'devnull',
  44.     'realpath',
  45.     'supports_unicode_filenames']
  46. curdir = '.'
  47. pardir = '..'
  48. extsep = '.'
  49. sep = '/'
  50. altsep = '\\'
  51. pathsep = ';'
  52. defpath = '.;C:\\bin'
  53. devnull = 'nul'
  54.  
  55. def normcase(s):
  56.     '''Normalize case of pathname.
  57.  
  58.     Makes all characters lowercase and all altseps into seps.'''
  59.     return s.replace('\\', '/').lower()
  60.  
  61.  
  62. def isabs(s):
  63.     '''Test whether a path is absolute'''
  64.     s = splitdrive(s)[1]
  65.     if s != '':
  66.         pass
  67.     return s[:1] in '/\\'
  68.  
  69.  
  70. def join(a, *p):
  71.     '''Join two or more pathname components, inserting sep as needed'''
  72.     path = a
  73.     for b in p:
  74.         if isabs(b):
  75.             path = b
  76.             continue
  77.         if path == '' or path[-1:] in '/\\:':
  78.             path = path + b
  79.             continue
  80.         path = path + '/' + b
  81.     
  82.     return path
  83.  
  84.  
  85. def splitdrive(p):
  86.     '''Split a pathname into drive and path specifiers. Returns a 2-tuple
  87. "(drive,path)";  either part may be empty'''
  88.     if p[1:2] == ':':
  89.         return (p[0:2], p[2:])
  90.     
  91.     return ('', p)
  92.  
  93.  
  94. def splitunc(p):
  95.     """Split a pathname into UNC mount point and relative path specifiers.
  96.  
  97.     Return a 2-tuple (unc, rest); either part may be empty.
  98.     If unc is not empty, it has the form '//host/mount' (or similar
  99.     using backslashes).  unc+rest is always the input path.
  100.     Paths containing drive letters never have an UNC part.
  101.     """
  102.     if p[1:2] == ':':
  103.         return ('', p)
  104.     
  105.     firstTwo = p[0:2]
  106.     if firstTwo == '/' * 2 or firstTwo == '\\' * 2:
  107.         normp = normcase(p)
  108.         index = normp.find('/', 2)
  109.         if index == -1:
  110.             return ('', p)
  111.         
  112.         index = normp.find('/', index + 1)
  113.         if index == -1:
  114.             index = len(p)
  115.         
  116.         return (p[:index], p[index:])
  117.     
  118.     return ('', p)
  119.  
  120.  
  121. def split(p):
  122.     '''Split a pathname.
  123.  
  124.     Return tuple (head, tail) where tail is everything after the final slash.
  125.     Either part may be empty.'''
  126.     (d, p) = splitdrive(p)
  127.     i = len(p)
  128.     while i and p[i - 1] not in '/\\':
  129.         i = i - 1
  130.     head = p[:i]
  131.     tail = p[i:]
  132.     head2 = head
  133.     while head2 and head2[-1] in '/\\':
  134.         head2 = head2[:-1]
  135.     if not head2:
  136.         pass
  137.     head = head
  138.     return (d + head, tail)
  139.  
  140.  
  141. def splitext(p):
  142.     '''Split the extension from a pathname.
  143.  
  144.     Extension is everything from the last dot to the end.
  145.     Return (root, ext), either part may be empty.'''
  146.     (root, ext) = ('', '')
  147.     for c in p:
  148.         if c in [
  149.             '/',
  150.             '\\']:
  151.             root = root + ext + c
  152.             ext = ''
  153.             continue
  154.         if c == '.':
  155.             if ext:
  156.                 root = root + ext
  157.                 ext = c
  158.             else:
  159.                 ext = c
  160.         ext
  161.         if ext:
  162.             ext = ext + c
  163.             continue
  164.         root = root + c
  165.     
  166.     return (root, ext)
  167.  
  168.  
  169. def basename(p):
  170.     '''Returns the final component of a pathname'''
  171.     return split(p)[1]
  172.  
  173.  
  174. def dirname(p):
  175.     '''Returns the directory component of a pathname'''
  176.     return split(p)[0]
  177.  
  178.  
  179. def commonprefix(m):
  180.     '''Given a list of pathnames, returns the longest common leading component'''
  181.     if not m:
  182.         return ''
  183.     
  184.     prefix = m[0]
  185.     for item in m:
  186.         for i in range(len(prefix)):
  187.             if prefix[:i + 1] != item[:i + 1]:
  188.                 prefix = prefix[:i]
  189.                 if i == 0:
  190.                     return ''
  191.                 
  192.                 break
  193.                 continue
  194.         
  195.     
  196.     return prefix
  197.  
  198.  
  199. def getsize(filename):
  200.     '''Return the size of a file, reported by os.stat()'''
  201.     return os.stat(filename).st_size
  202.  
  203.  
  204. def getmtime(filename):
  205.     '''Return the last modification time of a file, reported by os.stat()'''
  206.     return os.stat(filename).st_mtime
  207.  
  208.  
  209. def getatime(filename):
  210.     '''Return the last access time of a file, reported by os.stat()'''
  211.     return os.stat(filename).st_atime
  212.  
  213.  
  214. def getctime(filename):
  215.     '''Return the creation time of a file, reported by os.stat().'''
  216.     return os.stat(filename).st_ctime
  217.  
  218.  
  219. def islink(path):
  220.     '''Test for symbolic link.  On OS/2 always returns false'''
  221.     return False
  222.  
  223.  
  224. def exists(path):
  225.     '''Test whether a path exists'''
  226.     
  227.     try:
  228.         st = os.stat(path)
  229.     except os.error:
  230.         return False
  231.  
  232.     return True
  233.  
  234. lexists = exists
  235.  
  236. def isdir(path):
  237.     '''Test whether a path is a directory'''
  238.     
  239.     try:
  240.         st = os.stat(path)
  241.     except os.error:
  242.         return False
  243.  
  244.     return stat.S_ISDIR(st.st_mode)
  245.  
  246.  
  247. def isfile(path):
  248.     '''Test whether a path is a regular file'''
  249.     
  250.     try:
  251.         st = os.stat(path)
  252.     except os.error:
  253.         return False
  254.  
  255.     return stat.S_ISREG(st.st_mode)
  256.  
  257.  
  258. def ismount(path):
  259.     '''Test whether a path is a mount point (defined as root of drive)'''
  260.     (unc, rest) = splitunc(path)
  261.     if unc:
  262.         return rest in ('', '/', '\\')
  263.     
  264.     p = splitdrive(path)[1]
  265.     if len(p) == 1:
  266.         pass
  267.     return p[0] in '/\\'
  268.  
  269.  
  270. def walk(top, func, arg):
  271.     '''Directory tree walk whth callback function.
  272.  
  273.     walk(top, func, arg) calls func(arg, d, files) for each directory d
  274.     in the tree rooted at top (including top itself); files is a list
  275.     of all the files and subdirs in directory d.'''
  276.     
  277.     try:
  278.         names = os.listdir(top)
  279.     except os.error:
  280.         return None
  281.  
  282.     func(arg, top, names)
  283.     exceptions = ('.', '..')
  284.     for name in names:
  285.         if name not in exceptions:
  286.             name = join(top, name)
  287.             if isdir(name):
  288.                 walk(name, func, arg)
  289.             
  290.         isdir(name)
  291.     
  292.  
  293.  
  294. def expanduser(path):
  295.     '''Expand ~ and ~user constructs.
  296.  
  297.     If user or $HOME is unknown, do nothing.'''
  298.     if path[:1] != '~':
  299.         return path
  300.     
  301.     i = 1
  302.     n = len(path)
  303.     while i < n and path[i] not in '/\\':
  304.         i = i + 1
  305.     if i == 1:
  306.         if 'HOME' in os.environ:
  307.             userhome = os.environ['HOME']
  308.         elif 'HOMEPATH' not in os.environ:
  309.             return path
  310.         else:
  311.             
  312.             try:
  313.                 drive = os.environ['HOMEDRIVE']
  314.             except KeyError:
  315.                 drive = ''
  316.  
  317.             userhome = join(drive, os.environ['HOMEPATH'])
  318.     else:
  319.         return path
  320.     return userhome + path[i:]
  321.  
  322.  
  323. def expandvars(path):
  324.     '''Expand shell variables of form $var and ${var}.
  325.  
  326.     Unknown variables are left unchanged.'''
  327.     if '$' not in path:
  328.         return path
  329.     
  330.     import string
  331.     varchars = string.letters + string.digits + '_-'
  332.     res = ''
  333.     index = 0
  334.     pathlen = len(path)
  335.     while index < pathlen:
  336.         c = path[index]
  337.         if c == "'":
  338.             path = path[index + 1:]
  339.             pathlen = len(path)
  340.             
  341.             try:
  342.                 index = path.index("'")
  343.                 res = res + "'" + path[:index + 1]
  344.             except ValueError:
  345.                 res = res + path
  346.                 index = pathlen - 1
  347.             except:
  348.                 None<EXCEPTION MATCH>ValueError
  349.             
  350.  
  351.         None<EXCEPTION MATCH>ValueError
  352.         if c == '$':
  353.             if path[index + 1:index + 2] == '$':
  354.                 res = res + c
  355.                 index = index + 1
  356.             elif path[index + 1:index + 2] == '{':
  357.                 path = path[index + 2:]
  358.                 pathlen = len(path)
  359.                 
  360.                 try:
  361.                     index = path.index('}')
  362.                     var = path[:index]
  363.                     if var in os.environ:
  364.                         res = res + os.environ[var]
  365.                 except ValueError:
  366.                     res = res + path
  367.                     index = pathlen - 1
  368.                 except:
  369.                     None<EXCEPTION MATCH>ValueError
  370.                 
  371.  
  372.             None<EXCEPTION MATCH>ValueError
  373.             var = ''
  374.             index = index + 1
  375.             c = path[index:index + 1]
  376.             while c != '' and c in varchars:
  377.                 var = var + c
  378.                 index = index + 1
  379.                 c = path[index:index + 1]
  380.             if var in os.environ:
  381.                 res = res + os.environ[var]
  382.             
  383.             if c != '':
  384.                 res = res + c
  385.             
  386.         else:
  387.             res = res + c
  388.         index = index + 1
  389.     return res
  390.  
  391.  
  392. def normpath(path):
  393.     '''Normalize path, eliminating double slashes, etc.'''
  394.     path = path.replace('\\', '/')
  395.     (prefix, path) = splitdrive(path)
  396.     while path[:1] == '/':
  397.         prefix = prefix + '/'
  398.         path = path[1:]
  399.     comps = path.split('/')
  400.     i = 0
  401.     while i < len(comps):
  402.         if comps[i] == '.':
  403.             del comps[i]
  404.             continue
  405.         if comps[i] == '..' and i > 0 and comps[i - 1] not in ('', '..'):
  406.             del comps[i - 1:i + 1]
  407.             i = i - 1
  408.             continue
  409.         if comps[i] == '' and i > 0 and comps[i - 1] != '':
  410.             del comps[i]
  411.             continue
  412.         i = i + 1
  413.     if not prefix and not comps:
  414.         comps.append('.')
  415.     
  416.     return prefix + '/'.join(comps)
  417.  
  418.  
  419. def abspath(path):
  420.     '''Return the absolute version of a path'''
  421.     if not isabs(path):
  422.         path = join(os.getcwd(), path)
  423.     
  424.     return normpath(path)
  425.  
  426. realpath = abspath
  427. supports_unicode_filenames = False
  428.