lib/bb/utils.py

   1 # ex:ts=4:sw=4:sts=4:et
   2 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
   3 """
   4 BitBake Utility Functions
   5 """
   6
   7 # Copyright (C) 2004 Michael Lauer
   8 #
   9 # This program is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License version 2 as
  11 # published by the Free Software Foundation.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License along
  19 # with this program; if not, write to the Free Software Foundation, Inc.,
  20 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21
  22 digits = "0123456789"
  23 ascii_letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  24
  25 import re, fcntl, os
  26
  27 def explode_version(s):
  28     r = []
  29     alpha_regexp = re.compile('^([a-zA-Z]+)(.*)$')
  30     numeric_regexp = re.compile('^(\d+)(.*)$')
  31     while (s != ''):
  32         if s[0] in digits:
  33             m = numeric_regexp.match(s)
  34             r.append(int(m.group(1)))
  35             s = m.group(2)
  36             continue
  37         if s[0] in ascii_letters:
  38             m = alpha_regexp.match(s)
  39             r.append(m.group(1))
  40             s = m.group(2)
  41             continue
  42         s = s[1:]
  43     return r
  44
  45 def vercmp_part(a, b):
  46     va = explode_version(a)
  47     vb = explode_version(b)
  48     while True:
  49         if va == []:
  50             ca = None
  51         else:
  52             ca = va.pop(0)
  53         if vb == []:
  54             cb = None
  55         else:
  56             cb = vb.pop(0)
  57         if ca == None and cb == None:
  58             return 0
  59         if ca > cb:
  60             return 1
  61         if ca < cb:
  62             return -1
  63
  64 def vercmp(ta, tb):
  65     (ea, va, ra) = ta
  66     (eb, vb, rb) = tb
  67
  68     r = int(ea)-int(eb)
  69     if (r == 0):
  70         r = vercmp_part(va, vb)
  71     if (r == 0):
  72         r = vercmp_part(ra, rb)
  73     return r
  74
  75 def explode_deps(s):
  76     """
  77     Take an RDEPENDS style string of format:
  78     "DEPEND1 (optional version) DEPEND2 (optional version) ..."
  79     and return a list of dependencies.
  80     Version information is ignored.
  81     """
  82     r = []
  83     l = s.split()
  84     flag = False
  85     for i in l:
  86         if i[0] == '(':
  87             flag = True
  88             j = []
  89         if flag:
  90             j.append(i)
  91         else:
  92             r.append(i)
  93         if flag and i.endswith(')'):
  94             flag = False
  95             # Ignore version
  96             #r[-1] += ' ' + ' '.join(j)
  97     return r
  98
  99
 100
 101 def _print_trace(body, line):
 102     """
 103     Print the Environment of a Text Body
 104     """
 105     import bb
 106
 107     # print the environment of the method
 108     bb.msg.error(bb.msg.domain.Util, "Printing the environment of the function")
 109     min_line = max(1,line-4)
 110     max_line = min(line+4,len(body)-1)
 111     for i in range(min_line,max_line+1):
 112         bb.msg.error(bb.msg.domain.Util, "\t%.4d:%s" % (i, body[i-1]) )
 113
 114
 115 def better_compile(text, file, realfile):
 116     """
 117     A better compile method. This method
 118     will print  the offending lines.
 119     """
 120     try:
 121         return compile(text, file, "exec")
 122     except Exception, e:
 123         import bb,sys
 124
 125         # split the text into lines again
 126         body = text.split('\n')
 127         bb.msg.error(bb.msg.domain.Util, "Error in compiling: ", realfile)
 128         bb.msg.error(bb.msg.domain.Util, "The lines resulting into this error were:")
 129         bb.msg.error(bb.msg.domain.Util, "\t%d:%s:'%s'" % (e.lineno, e.__class__.__name__, body[e.lineno-1]))
 130
 131         _print_trace(body, e.lineno)
 132
 133         # exit now
 134         sys.exit(1)
 135
 136 def better_exec(code, context, text, realfile):
 137     """
 138     Similiar to better_compile, better_exec will
 139     print the lines that are responsible for the
 140     error.
 141     """
 142     import bb,sys
 143     try:
 144         exec code in context
 145     except:
 146         (t,value,tb) = sys.exc_info()
 147
 148         if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
 149             raise
 150
 151         # print the Header of the Error Message
 152         bb.msg.error(bb.msg.domain.Util, "Error in executing: ", realfile)
 153         bb.msg.error(bb.msg.domain.Util, "Exception:%s Message:%s" % (t,value) )
 154
 155         # let us find the line number now
 156         while tb.tb_next:
 157             tb = tb.tb_next
 158
 159         import traceback
 160         line = traceback.tb_lineno(tb)
 161
 162         _print_trace( text.split('\n'), line )
 163
 164         raise
 165
 166 def Enum(*names):
 167    """
 168    A simple class to give Enum support
 169    """
 170
 171    assert names, "Empty enums are not supported"
 172
 173    class EnumClass(object):
 174       __slots__ = names
 175       def __iter__(self):        return iter(constants)
 176       def __len__(self):         return len(constants)
 177       def __getitem__(self, i):  return constants[i]
 178       def __repr__(self):        return 'Enum' + str(names)
 179       def __str__(self):         return 'enum ' + str(constants)
 180
 181    class EnumValue(object):
 182       __slots__ = ('__value')
 183       def __init__(self, value): self.__value = value
 184       Value = property(lambda self: self.__value)
 185       EnumType = property(lambda self: EnumType)
 186       def __hash__(self):        return hash(self.__value)
 187       def __cmp__(self, other):
 188          # C fans might want to remove the following assertion
 189          # to make all enums comparable by ordinal value {;))
 190          assert self.EnumType is other.EnumType, "Only values from the same enum are comparable"
 191          return cmp(self.__value, other.__value)
 192       def __invert__(self):      return constants[maximum - self.__value]
 193       def __nonzero__(self):     return bool(self.__value)
 194       def __repr__(self):        return str(names[self.__value])
 195
 196    maximum = len(names) - 1
 197    constants = [None] * len(names)
 198    for i, each in enumerate(names):
 199       val = EnumValue(i)
 200       setattr(EnumClass, each, val)
 201       constants[i] = val
 202    constants = tuple(constants)
 203    EnumType = EnumClass()
 204    return EnumType
 205
 206 def lockfile(name):
 207     """
 208     Use the file fn as a lock file, return when the lock has been aquired.
 209     Returns a variable to pass to unlockfile().
 210     """
 211     while True:
 212         # If we leave the lockfiles lying around there is no problem
 213         # but we should clean up after ourselves. This gives potential
 214         # for races though. To work around this, when we aquire the lock
 215         # we check the file we locked was still the lock file on disk.
 216         # by comparing inode numbers. If they don't match or the lockfile
 217         # no longer exists, we start again.
 218
 219         # This implementation is unfair since the last person to request the
 220         # lock is the most likely to win it.
 221
 222         lf = open(name, "a+")
 223         fcntl.flock(lf.fileno(), fcntl.LOCK_EX)
 224         statinfo = os.fstat(lf.fileno())
 225         if os.path.exists(lf.name):
 226            statinfo2 = os.stat(lf.name)
 227            if statinfo.st_ino == statinfo2.st_ino:
 228                return lf
 229         # File no longer exists or changed, retry
 230         lf.close
 231
 232 def unlockfile(lf):
 233     """
 234     Unlock a file locked using lockfile()
 235     """
 236     os.unlink(lf.name)
 237     fcntl.flock(lf.fileno(), fcntl.LOCK_UN)
 238     lf.close
 239