bin/lilypython.py

   1 #!/usr/bin/python
   2
   3 #
   4 # lily-python.py --  implement general LilyPond-wide python stuff
   5 #
   6 # source file of the GNU LilyPond music typesetter
   7 #
   8 # (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
   9 #
  10
  11 import posix
  12 import pwd
  13 import regex
  14 import regsub
  15 from string import *
  16 from flower import *
  17 import sys
  18 import os
  19 import getopt
  20
  21
  22
  23
  24 version_re = regex.compile('\\version *\"\(.*\)\"')
  25 # now used as shell script in configure too!
  26 # make_assign_re = regex.compile('^\([A-Z_]*\) *= *\(.*\)$')
  27 make_assign_re = regex.compile('^\([A-Z_]*\)=\(.*\)$')
  28
  29 def version_tuple(file):
  30     lines = file.readlines()
  31
  32     mi = pa = mj = 0
  33     mp = ''
  34
  35     for l in lines:
  36         if make_assign_re.search(l) <> -1:
  37             nm = make_assign_re.group(1)
  38             val = make_assign_re.group(2)
  39 #           if nm == 'TOPLEVEL_MAJOR_VERSION':
  40             if nm == 'MAJOR_VERSION':
  41                 mj = atoi(val)
  42 #           elif nm == 'TOPLEVEL_MINOR_VERSION':
  43             elif nm == 'MINOR_VERSION':
  44                 mi = atoi(val)
  45 #           elif nm == 'TOPLEVEL_PATCH_LEVEL':
  46             elif nm == 'PATCH_LEVEL':
  47                 pa = atoi(val)
  48 #           elif nm == 'TOPLEVEL_MY_PATCH_LEVEL':
  49             elif nm == 'MY_PATCH_LEVEL':
  50                 mp = val
  51     return (mj,mi,pa,mp)
  52
  53 def next_version(tup):
  54     return (tup[0], tup[1], tup[2] + 1, tup[3]);
  55
  56 def prev_version(tup):
  57     t = tup
  58     if t[3]:
  59         return (tup[0], tup[1], tup[2], '');
  60     elif t[2] == 0 :
  61         return (tup[0], tup[1] -1, tup[2], '');
  62     else:
  63         return (tup[0], tup[1], tup[2] - 1, '');
  64
  65
  66 def dirname(v):
  67     return 'lilypond-' + version_tuple_to_str(v)
  68
  69 def tarball(v):
  70     return dirname(v)  + '.tar.gz'
  71
  72 def released_tarball(v):
  73     return lilydirs.release_dir + tarball(v)
  74
  75
  76 def tuple_to_list(tup):
  77     l=[]
  78     for x in tup:
  79         l.append[x]
  80     return l
  81
  82 def version_str_to_tuple(str):
  83     t = split(str, '.')
  84     try:
  85         mypatch = t[3]
  86     except IndexError:
  87         mypatch = ''
  88
  89     return (atoi(t[0]), atoi(t[1]), atoi(t[2]), mypatch)
  90
  91
  92
  93 def guess_mudela_version(filename):
  94     f = open (filename)
  95     lines = f.readlines()
  96     f.close()
  97     for l in lines:
  98         if version_re.search(l) <> -1:
  99             return version_re.group(1)
 100
 101     return ''
 102
 103 def version_tuple_to_str(tup):
 104     mypatch =''
 105     if tup[3]:
 106         mypatch = '.' + tup[3]
 107
 108     return ('%d.%d.%d' % tup[0:3]) + mypatch
 109
 110 class Lilydirs:
 111     def __init__(self):
 112         try:
 113             self.topdir = os.environ['LILYPOND_SOURCEDIR'] + '/'
 114
 115         except KeyError:
 116             print 'Please set LILYPOND_SOURCEDIR to the toplevel source, eg LILYPOND_SOURCEDIR=/home/foobar/lilypond-1.2.3/'
 117             sys.exit(1)
 118
 119         try:
 120             self.groupdir = os.environ['LILYPOND_GROUPDIR'] + '/'
 121         except KeyError:
 122             self.groupdir = self.topdir + '../'
 123
 124         self.release_dir = self.groupdir + '/releases/'
 125         self.patch_dir = self.groupdir + '/patches/'
 126
 127     def version_tuple(self):
 128         f = open (self.topdir + 'VERSION')
 129         v = version_tuple(f)
 130         f.close ()
 131         return v
 132
 133
 134
 135 lilydirs = Lilydirs()
 136
 137 if __name__ == '__main__':
 138     v= lilydirs.version_tuple()
 139     print v, prev_version(v), next_version(v)
 140     mv =  guess_mudela_version(lilydirs.topdir + 'init/symbol.ly')
 141     pv=(0,1,1,'jcn4')
 142     print version_tuple_to_str(pv), prev_version(pv), next_version(pv)
 143     print version_tuple_to_str((0,1,1,''))
 144     print mv, version_str_to_tuple(mv)
 145
 146
 147
 148 def dump_file(f, s):
 149     i = open(f, 'w')
 150     i.write(s)
 151     i.close ()
 152
 153 def gulp_file(f):
 154     i = open(f)
 155     i.seek (0, 2)
 156     len = i.tell ()
 157     i.seek (0,0)
 158     return i.read (len)
 159
 160
 161 header_regex = regex.compile('\\header[ \t\n]*{\([^}]*\)}')
 162 header_entry_regex = regex.compile('[\n\t ]*\([^\n\t ]+\)[\n\t ]*=[\n \t]*\([^;]+\)[\n \t]*;')
 163
 164 #
 165 # FIXME breaks on multiple strings.
 166 #
 167 def read_mudela_header (fn):
 168     s = gulp_file(fn)
 169     s = regsub.gsub('%.*$', '', s)
 170     s = regsub.gsub('\n', ' ', s)
 171
 172     dict = {}
 173     if header_regex.search(s) <> -1:
 174         h = header_regex.group(1)
 175     else:
 176         return dict
 177
 178     while regex.search('=', h) <> -1:
 179
 180         if header_entry_regex.search (h) == -1:
 181
 182             raise 'format error'
 183
 184         h = regsub.sub(header_entry_regex, '', h)
 185         left = header_entry_regex.group(1)
 186         right = header_entry_regex.group(2)
 187
 188         right = regsub.gsub('\([^\\]\)\"', '\\1', right)
 189         right = regsub.gsub('^"', '', right)
 190         left = regsub.gsub('\([^\\]\)\"', '', left)
 191         left = regsub.gsub('^"', '', left)
 192
 193         dict[left] = right
 194
 195     return dict
 196
 197
 198 #!/usr/bin/python
 199
 200 #
 201 # lily-python.py --  implement general LilyPond-wide python stuff
 202 #
 203 # source file of the GNU LilyPond music typesetter
 204 #
 205 # (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
 206 #
 207
 208 import posix
 209 import pwd
 210 import regex
 211 import regsub
 212 from string import *
 213 from flower import *
 214 import sys
 215 import os
 216 import getopt
 217
 218
 219
 220
 221 version_re = regex.compile('\\version *\"\(.*\)\"')
 222 # now used as shell script in configure too!
 223 # make_assign_re = regex.compile('^\([A-Z_]*\) *= *\(.*\)$')
 224 make_assign_re = regex.compile('^\([A-Z_]*\)=\(.*\)$')
 225
 226 def version_tuple(file):
 227     lines = file.readlines()
 228
 229     mi = pa = mj = 0
 230     mp = ''
 231
 232     for l in lines:
 233         if make_assign_re.search(l) <> -1:
 234             nm = make_assign_re.group(1)
 235             val = make_assign_re.group(2)
 236 #           if nm == 'TOPLEVEL_MAJOR_VERSION':
 237             if nm == 'MAJOR_VERSION':
 238                 mj = atoi(val)
 239 #           elif nm == 'TOPLEVEL_MINOR_VERSION':
 240             elif nm == 'MINOR_VERSION':
 241                 mi = atoi(val)
 242 #           elif nm == 'TOPLEVEL_PATCH_LEVEL':
 243             elif nm == 'PATCH_LEVEL':
 244                 pa = atoi(val)
 245 #           elif nm == 'TOPLEVEL_MY_PATCH_LEVEL':
 246             elif nm == 'MY_PATCH_LEVEL':
 247                 mp = val
 248     return (mj,mi,pa,mp)
 249
 250 def next_version(tup):
 251     return (tup[0], tup[1], tup[2] + 1, tup[3]);
 252
 253 def prev_version(tup):
 254     t = tup
 255     if t[3]:
 256         return (tup[0], tup[1], tup[2], '');
 257     elif t[2] == 0 :
 258         return (tup[0], tup[1] -1, tup[2], '');
 259     else:
 260         return (tup[0], tup[1], tup[2] - 1, '');
 261
 262
 263 def dirname(v):
 264     return 'lilypond-' + version_tuple_to_str(v)
 265
 266 def tarball(v):
 267     return dirname(v)  + '.tar.gz'
 268
 269 def released_tarball(v):
 270     return lilydirs.release_dir + tarball(v)
 271
 272
 273 def tuple_to_list(tup):
 274     l=[]
 275     for x in tup:
 276         l.append[x]
 277     return l
 278
 279 def version_str_to_tuple(str):
 280     t = split(str, '.')
 281     try:
 282         mypatch = t[3]
 283     except IndexError:
 284         mypatch = ''
 285
 286     return (atoi(t[0]), atoi(t[1]), atoi(t[2]), mypatch)
 287
 288
 289
 290 def guess_mudela_version(filename):
 291     f = open (filename)
 292     lines = f.readlines()
 293     f.close()
 294     for l in lines:
 295         if version_re.search(l) <> -1:
 296             return version_re.group(1)
 297
 298     return ''
 299
 300 def version_tuple_to_str(tup):
 301     mypatch =''
 302     if tup[3]:
 303         mypatch = '.' + tup[3]
 304
 305     return ('%d.%d.%d' % tup[0:3]) + mypatch
 306
 307 class Lilydirs:
 308     def __init__(self):
 309         try:
 310             self.topdir = os.environ['LILYPOND_SOURCEDIR'] + '/'
 311
 312         except KeyError:
 313             print 'Please set LILYPOND_SOURCEDIR to the toplevel source, eg LILYPOND_SOURCEDIR=/home/foobar/lilypond-1.2.3/'
 314             sys.exit(1)
 315
 316         try:
 317             self.groupdir = os.environ['LILYPOND_GROUPDIR'] + '/'
 318         except KeyError:
 319             self.groupdir = self.topdir + '../'
 320
 321         self.release_dir = self.groupdir + '/releases/'
 322         self.patch_dir = self.groupdir + '/patches/'
 323
 324     def version_tuple(self):
 325         f = open (self.topdir + 'VERSION')
 326         v = version_tuple(f)
 327         f.close ()
 328         return v
 329
 330
 331
 332 lilydirs = Lilydirs()
 333
 334 if __name__ == '__main__':
 335     v= lilydirs.version_tuple()
 336     print v, prev_version(v), next_version(v)
 337     mv =  guess_mudela_version(lilydirs.topdir + 'init/symbol.ly')
 338     pv=(0,1,1,'jcn4')
 339     print version_tuple_to_str(pv), prev_version(pv), next_version(pv)
 340     print version_tuple_to_str((0,1,1,''))
 341     print mv, version_str_to_tuple(mv)
 342
 343
 344
 345 def dump_file(f, s):
 346     i = open(f, 'w')
 347     i.write(s)
 348     i.close ()
 349
 350 def gulp_file(f):
 351     i = open(f)
 352     i.seek (0, 2)
 353     len = i.tell ()
 354     i.seek (0,0)
 355     return i.read (len)
 356
 357
 358 header_regex = regex.compile('\\header[ \t\n]*{\([^}]*\)}')
 359 header_entry_regex = regex.compile('[\n\t ]*\([^\n\t ]+\)[\n\t ]*=[\n \t]*\([^;]+\)[\n \t]*;')
 360
 361 #
 362 # FIXME breaks on multiple strings.
 363 #
 364 def read_mudela_header (fn):
 365     s = gulp_file(fn)
 366     s = regsub.gsub('%.*$', '', s)
 367     s = regsub.gsub('\n', ' ', s)
 368
 369     dict = {}
 370     if header_regex.search(s) <> -1:
 371         h = header_regex.group(1)
 372     else:
 373         return dict
 374
 375     while regex.search('=', h) <> -1:
 376
 377         if header_entry_regex.search (h) == -1:
 378
 379             raise 'format error'
 380
 381         h = regsub.sub(header_entry_regex, '', h)
 382         left = header_entry_regex.group(1)
 383         right = header_entry_regex.group(2)
 384
 385         right = regsub.gsub('\([^\\]\)\"', '\\1', right)
 386         right = regsub.gsub('^"', '', right)
 387         left = regsub.gsub('\([^\\]\)\"', '', left)
 388         left = regsub.gsub('^"', '', left)
 389
 390         dict[left] = right
 391
 392     return dict
 393
 394