source: waflib/Utils.py @ 074b41b

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+
Last change on this file since 074b41b was 0fa325b, checked in by Paul Brossier <piem@piem.org>, 11 years ago

waf: unpack
  • Property mode set to 100644
File size: 8.9 KB
Line 
1#! /usr/bin/env python
2# encoding: utf-8
3# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
4
5import os,sys,errno,traceback,inspect,re,shutil,datetime,gc
6import subprocess
7try:
8        from collections import deque
9except ImportError:
10        class deque(list):
11                def popleft(self):
12                        return self.pop(0)
13try:
14        import _winreg as winreg
15except ImportError:
16        try:
17                import winreg
18        except ImportError:
19                winreg=None
20from waflib import Errors
21try:
22        from collections import UserDict
23except ImportError:
24        from UserDict import UserDict
25try:
26        from hashlib import md5
27except ImportError:
28        try:
29                from md5 import md5
30        except ImportError:
31                pass
32try:
33        import threading
34except ImportError:
35        class threading(object):
36                pass
37        class Lock(object):
38                def acquire(self):
39                        pass
40                def release(self):
41                        pass
42        threading.Lock=threading.Thread=Lock
43else:
44        run_old=threading.Thread.run
45        def run(*args,**kwargs):
46                try:
47                        run_old(*args,**kwargs)
48                except(KeyboardInterrupt,SystemExit):
49                        raise
50                except Exception:
51                        sys.excepthook(*sys.exc_info())
52        threading.Thread.run=run
53SIG_NIL='iluvcuteoverload'
54O644=420
55O755=493
56rot_chr=['\\','|','/','-']
57rot_idx=0
58try:
59        from collections import defaultdict
60except ImportError:
61        class defaultdict(dict):
62                def __init__(self,default_factory):
63                        super(defaultdict,self).__init__()
64                        self.default_factory=default_factory
65                def __getitem__(self,key):
66                        try:
67                                return super(defaultdict,self).__getitem__(key)
68                        except KeyError:
69                                value=self.default_factory()
70                                self[key]=value
71                                return value
72is_win32=sys.platform in('win32','cli')
73indicator='\x1b[K%s%s%s\r'
74if is_win32 and'NOCOLOR'in os.environ:
75        indicator='%s%s%s\r'
76def readf(fname,m='r',encoding='ISO8859-1'):
77        if sys.hexversion>0x3000000 and not'b'in m:
78                m+='b'
79                f=open(fname,m)
80                try:
81                        txt=f.read()
82                finally:
83                        f.close()
84                txt=txt.decode(encoding)
85        else:
86                f=open(fname,m)
87                try:
88                        txt=f.read()
89                finally:
90                        f.close()
91        return txt
92def writef(fname,data,m='w',encoding='ISO8859-1'):
93        if sys.hexversion>0x3000000 and not'b'in m:
94                data=data.encode(encoding)
95                m+='b'
96        f=open(fname,m)
97        try:
98                f.write(data)
99        finally:
100                f.close()
101def h_file(fname):
102        f=open(fname,'rb')
103        m=md5()
104        try:
105                while fname:
106                        fname=f.read(200000)
107                        m.update(fname)
108        finally:
109                f.close()
110        return m.digest()
111if hasattr(os,'O_NOINHERIT'):
112        def readf_win32(f,m='r',encoding='ISO8859-1'):
113                flags=os.O_NOINHERIT|os.O_RDONLY
114                if'b'in m:
115                        flags|=os.O_BINARY
116                if'+'in m:
117                        flags|=os.O_RDWR
118                try:
119                        fd=os.open(f,flags)
120                except OSError:
121                        raise IOError('Cannot read from %r'%f)
122                if sys.hexversion>0x3000000 and not'b'in m:
123                        m+='b'
124                        f=os.fdopen(fd,m)
125                        try:
126                                txt=f.read()
127                        finally:
128                                f.close()
129                        txt=txt.decode(encoding)
130                else:
131                        f=os.fdopen(fd,m)
132                        try:
133                                txt=f.read()
134                        finally:
135                                f.close()
136                return txt
137        def writef_win32(f,data,m='w',encoding='ISO8859-1'):
138                if sys.hexversion>0x3000000 and not'b'in m:
139                        data=data.encode(encoding)
140                        m+='b'
141                flags=os.O_CREAT|os.O_TRUNC|os.O_WRONLY|os.O_NOINHERIT
142                if'b'in m:
143                        flags|=os.O_BINARY
144                if'+'in m:
145                        flags|=os.O_RDWR
146                try:
147                        fd=os.open(f,flags)
148                except OSError:
149                        raise IOError('Cannot write to %r'%f)
150                f=os.fdopen(fd,m)
151                try:
152                        f.write(data)
153                finally:
154                        f.close()
155        def h_file_win32(fname):
156                try:
157                        fd=os.open(fname,os.O_BINARY|os.O_RDONLY|os.O_NOINHERIT)
158                except OSError:
159                        raise IOError('Cannot read from %r'%fname)
160                f=os.fdopen(fd,'rb')
161                m=md5()
162                try:
163                        while fname:
164                                fname=f.read(200000)
165                                m.update(fname)
166                finally:
167                        f.close()
168                return m.digest()
169        readf_old=readf
170        writef_old=writef
171        h_file_old=h_file
172        readf=readf_win32
173        writef=writef_win32
174        h_file=h_file_win32
175try:
176        x=''.encode('hex')
177except LookupError:
178        import binascii
179        def to_hex(s):
180                ret=binascii.hexlify(s)
181                if not isinstance(ret,str):
182                        ret=ret.decode('utf-8')
183                return ret
184else:
185        def to_hex(s):
186                return s.encode('hex')
187to_hex.__doc__="""
188Return the hexadecimal representation of a string
189
190:param s: string to convert
191:type s: string
192"""
193listdir=os.listdir
194if is_win32:
195        def listdir_win32(s):
196                if not s:
197                        try:
198                                import ctypes
199                        except ImportError:
200                                return[x+':\\'for x in list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')]
201                        else:
202                                dlen=4
203                                maxdrives=26
204                                buf=ctypes.create_string_buffer(maxdrives*dlen)
205                                ndrives=ctypes.windll.kernel32.GetLogicalDriveStringsA(maxdrives*dlen,ctypes.byref(buf))
206                                return[str(buf.raw[4*i:4*i+2].decode('ascii'))for i in range(int(ndrives/dlen))]
207                if len(s)==2 and s[1]==":":
208                        s+=os.sep
209                if not os.path.isdir(s):
210                        e=OSError('%s is not a directory'%s)
211                        e.errno=errno.ENOENT
212                        raise e
213                return os.listdir(s)
214        listdir=listdir_win32
215def num2ver(ver):
216        if isinstance(ver,str):
217                ver=tuple(ver.split('.'))
218        if isinstance(ver,tuple):
219                ret=0
220                for i in range(4):
221                        if i<len(ver):
222                                ret+=256**(3-i)*int(ver[i])
223                return ret
224        return ver
225def ex_stack():
226        exc_type,exc_value,tb=sys.exc_info()
227        exc_lines=traceback.format_exception(exc_type,exc_value,tb)
228        return''.join(exc_lines)
229def to_list(sth):
230        if isinstance(sth,str):
231                return sth.split()
232        else:
233                return sth
234re_nl=re.compile('\r*\n',re.M)
235def str_to_dict(txt):
236        tbl={}
237        lines=re_nl.split(txt)
238        for x in lines:
239                x=x.strip()
240                if not x or x.startswith('#')or x.find('=')<0:
241                        continue
242                tmp=x.split('=')
243                tbl[tmp[0].strip()]='='.join(tmp[1:]).strip()
244        return tbl
245def split_path(path):
246        return path.split('/')
247def split_path_cygwin(path):
248        if path.startswith('//'):
249                ret=path.split('/')[2:]
250                ret[0]='/'+ret[0]
251                return ret
252        return path.split('/')
253re_sp=re.compile('[/\\\\]')
254def split_path_win32(path):
255        if path.startswith('\\\\'):
256                ret=re.split(re_sp,path)[2:]
257                ret[0]='\\'+ret[0]
258                return ret
259        return re.split(re_sp,path)
260if sys.platform=='cygwin':
261        split_path=split_path_cygwin
262elif is_win32:
263        split_path=split_path_win32
264split_path.__doc__="""
265Split a path by / or \\. This function is not like os.path.split
266
267:type  path: string
268:param path: path to split
269:return:     list of strings
270"""
271def check_dir(path):
272        if not os.path.isdir(path):
273                try:
274                        os.makedirs(path)
275                except OSError ,e:
276                        if not os.path.isdir(path):
277                                raise Errors.WafError('Cannot create the folder %r'%path,ex=e)
278def def_attrs(cls,**kw):
279        for k,v in kw.items():
280                if not hasattr(cls,k):
281                        setattr(cls,k,v)
282def quote_define_name(s):
283        fu=re.compile("[^a-zA-Z0-9]").sub("_",s)
284        fu=fu.upper()
285        return fu
286def h_list(lst):
287        m=md5()
288        m.update(str(lst))
289        return m.digest()
290def h_fun(fun):
291        try:
292                return fun.code
293        except AttributeError:
294                try:
295                        h=inspect.getsource(fun)
296                except IOError:
297                        h="nocode"
298                try:
299                        fun.code=h
300                except AttributeError:
301                        pass
302                return h
303reg_subst=re.compile(r"(\\\\)|(\$\$)|\$\{([^}]+)\}")
304def subst_vars(expr,params):
305        def repl_var(m):
306                if m.group(1):
307                        return'\\'
308                if m.group(2):
309                        return'$'
310                try:
311                        return params.get_flat(m.group(3))
312                except AttributeError:
313                        return params[m.group(3)]
314        return reg_subst.sub(repl_var,expr)
315def destos_to_binfmt(key):
316        if key=='darwin':
317                return'mac-o'
318        elif key in('win32','cygwin','uwin','msys'):
319                return'pe'
320        return'elf'
321def unversioned_sys_platform():
322        s=sys.platform
323        if s=='java':
324                from java.lang import System
325                s=System.getProperty('os.name')
326                if s=='Mac OS X':
327                        return'darwin'
328                elif s.startswith('Windows '):
329                        return'win32'
330                elif s=='OS/2':
331                        return'os2'
332                elif s=='HP-UX':
333                        return'hpux'
334                elif s in('SunOS','Solaris'):
335                        return'sunos'
336                else:s=s.lower()
337        if s=='powerpc':
338                return'darwin'
339        if s=='win32'or s.endswith('os2')and s!='sunos2':return s
340        return re.split('\d+$',s)[0]
341def nada(*k,**kw):
342        pass
343class Timer(object):
344        def __init__(self):
345                self.start_time=datetime.datetime.utcnow()
346        def __str__(self):
347                delta=datetime.datetime.utcnow()-self.start_time
348                days=int(delta.days)
349                hours=delta.seconds//3600
350                minutes=(delta.seconds-hours*3600)//60
351                seconds=delta.seconds-hours*3600-minutes*60+float(delta.microseconds)/1000/1000
352                result=''
353                if days:
354                        result+='%dd'%days
355                if days or hours:
356                        result+='%dh'%hours
357                if days or hours or minutes:
358                        result+='%dm'%minutes
359                return'%s%.3fs'%(result,seconds)
360if is_win32:
361        old=shutil.copy2
362        def copy2(src,dst):
363                old(src,dst)
364                shutil.copystat(src,dst)
365        setattr(shutil,'copy2',copy2)
366if os.name=='java':
367        try:
368                gc.disable()
369                gc.enable()
370        except NotImplementedError:
371                gc.disable=gc.enable
372def read_la_file(path):
373        sp=re.compile(r'^([^=]+)=\'(.*)\'$')
374        dc={}
375        for line in readf(path).splitlines():
376                try:
377                        _,left,right,_=sp.split(line.strip())
378                        dc[left]=right
379                except ValueError:
380                        pass
381        return dc
382def nogc(fun):
383        def f(*k,**kw):
384                try:
385                        gc.disable()
386                        ret=fun(*k,**kw)
387                finally:
388                        gc.enable()
389                return ret
390        f.__doc__=fun.__doc__
391        return f
392def run_once(fun):
393        cache={}
394        def wrap(k):
395                try:
396                        return cache[k]
397                except KeyError:
398                        ret=fun(k)
399                        cache[k]=ret
400                        return ret
401        wrap.__cache__=cache
402        return wrap
403def get_registry_app_path(key,filename):
404        if not winreg:
405                return None
406        try:
407                result=winreg.QueryValue(key,"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\%s.exe"%filename[0])
408        except WindowsError:
409                pass
410        else:
411                if os.path.isfile(result):
412                        return result
Note: See TracBrowser for help on using the repository browser.