stepmake/bin/packagepython.py

   1 #!/usr/bin/python
   2
   3 # packagepython.py --  implement general StepMake-wide python stuff
   4 #
   5 # source file of the GNU LilyPond music typesetter
   6 #
   7 # (c) 1997--1998 Han-Wen Nienhuys <hanwen@stack.nl>
   8 #                Jan Nieuwenhuizen <janneke@gnu.org>
   9
  10 import regex
  11 import regsub
  12 from string import *
  13 # from flower import *
  14 import sys
  15 import os
  16 import getopt
  17
  18 make_assign_re = regex.compile('^\([A-Z_]*\)=\(.*\)$')
  19
  20 def read_makefile (fn):
  21         file = open (fn)
  22         lines = file.readlines()
  23
  24         mi = pa = mj = 0
  25         mp = ''
  26
  27         make_dict = {}
  28         for l in lines:
  29                 if make_assign_re.search(l) <> -1:
  30                         nm = make_assign_re.group(1)
  31                         val = make_assign_re.group(2)
  32                         make_dict[nm] = val
  33         return make_dict
  34
  35 class Package:
  36         def __init__ (self, dirname):
  37                 dict = read_makefile (dirname + '/VERSION')
  38                 version_list = []
  39                 for x in [ 'MAJOR_VERSION', 'MINOR_VERSION',   'PATCH_LEVEL']:
  40                         version_list.append (atoi (dict[x]))
  41                 version_list.append (dict['MY_PATCH_LEVEL'])
  42                 self.topdir = dirname
  43                 self.groupdir = self.topdir + '/..'
  44                 self.patch_dir = self.groupdir + '/patches/'
  45                 self.release_dir = self.groupdir + '/releases/'
  46                 self.test_dir = self.groupdir + '/test/'
  47                 self.version =  tuple(version_list)
  48                 self.Name = dict['PACKAGE_NAME']
  49                 self.name = lower (self.Name)
  50                 if self.name == 'lilypond':
  51                         self.nickname = 'lelie'
  52                 else:
  53                         self.nickname = self.name
  54                 self.NAME = upper (self.Name)
  55
  56
  57 class Packager:
  58         def __init__ (self):
  59                 try:
  60                         m= os.environ['MAILADDRESS']
  61                 except KeyError:
  62                         m= '(address unknown)'
  63                 self.mail= m
  64
  65
  66 def full_version_tup(tup):
  67         t = [0,0,0,'']
  68         for i in range (4):
  69           try:
  70                   t[i] = tup[i]
  71           except IndexError:
  72                   break
  73         return tuple(t)
  74
  75 def split_my_patchlevel(str):
  76         return (regsub.sub('[0-9]*$', '', str),
  77                 atoi(regsub.sub('[^0-9]*', '', str)))
  78
  79
  80 def next_version(tup):
  81         l = list(full_version_tup (tup))
  82         t3name=t3num=''
  83         if l[3]:
  84                 (t3name,t3num)= split_my_patchlevel (l[3])
  85                 if t3num:
  86                         t3num = '%d' % (t3num + 1)
  87                 else:
  88                         t3num = t3name =''
  89         else:
  90                 l[2] = l[2] +1
  91
  92         return tuple(l[0:3] + [t3name +  t3num])
  93
  94 def prev_version(tup):
  95         l = list(full_version_tup (tup))
  96         t3name=t3num=''
  97         if l[3]:
  98                 (t3name,t3num)= split_my_patchlevel (l[3])
  99                 if t3num and t3num - 1 > 0:
 100                         t3num = '%d' %(t3num - 1)
 101                 else:
 102                         t3num = t3name =''
 103
 104         else:
 105                 l[2] = l[2] -1
 106
 107         return tuple(l[0:3] + [t3name +  t3num])
 108
 109 def version_tuple_to_str(tup):
 110         tup = full_version_tup (tup)
 111         if tup[3]:
 112                 my = '.' + tup[3]
 113         else:
 114                 my = ''
 115         return ('%d.%d.%d' % tup[0:3]) + my
 116
 117 def version_str_to_tuple(str):
 118         t = split(str, '.')
 119         try:
 120                 mypatch = t[3]
 121         except IndexError:
 122                 mypatch = ''
 123         return (atoi(t[0]), atoi(t[1]), atoi(t[2]), mypatch)
 124
 125 def version_compare (tupl, tupr):
 126         tupl = full_version_tup (tupl)
 127         tupr = full_version_tup (tupr)
 128         for i in (0,1,2):
 129                 if tupl[i] - tupr[i]: return tupl[i] - tupr[i]
 130         if tupl[3] and tupr[3]:
 131                 lname = regsub.sub('[0-9]*$', '', tupl[3])
 132                 lnum = atoi(regsub.sub('[^0-9]*', '', tupl[3]))
 133                 rname = regsub.sub('[0-9]*$', '', tupr[3])
 134                 rnum = atoi(regsub.sub('[^0-9]*', '', tupr[3]))
 135                 if lname != rname:
 136                         raise 'ambiguous'
 137                 return sign (lnum - rnum)
 138         if tupl[3]:
 139                 return 1
 140         else:
 141                 return -1
 142
 143
 144 if __name__ == '__main__':
 145         p = Package ('.')
 146         v=  p.version
 147         print v, prev_version(v), next_version(v)
 148         pv=(0,1,1,'jcn4')
 149         print version_tuple_to_str(pv), prev_version(pv), next_version(pv)
 150         print version_tuple_to_str((0,1,1,''))
 151         print full_version_tup ((0,1))
 152
 153
 154 def dump_file(f, s):
 155         i = open(f, 'w')
 156         i.write(s)
 157         i.close ()
 158
 159 def gulp_file(f):
 160         try:
 161                 i = open(f)
 162                 i.seek (0, 2)
 163                 n = i.tell ()
 164                 i.seek (0,0)
 165         except:
 166                 sys.stderr.write( 'can\'t open file %s\n ' % f)
 167                 return ''
 168         s = i.read (n)
 169         if len (s) <= 0:
 170                 sys.stderr.write( 'gulped empty file: %s\n'% f)
 171         return s
 172
 173