mirror of
https://github.com/cookiengineer/audacity
synced 2025-12-19 23:21:33 +01:00
Unpack the waf scripts.
See http://lintian.debian.org/tags/source-contains-waf-binary.html for details.
This commit is contained in:
benjamin.drung@gmail.com
466
lib-src/lv2/lilv/waflib/Node.py
Normal file
466
lib-src/lv2/lilv/waflib/Node.py
Normal file
@@ -0,0 +1,466 @@
|
||||
#! /usr/bin/env python
|
||||
# encoding: utf-8
|
||||
# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
|
||||
|
||||
import os,re,sys,shutil
|
||||
from waflib import Utils,Errors
|
||||
exclude_regs='''
|
||||
**/*~
|
||||
**/#*#
|
||||
**/.#*
|
||||
**/%*%
|
||||
**/._*
|
||||
**/CVS
|
||||
**/CVS/**
|
||||
**/.cvsignore
|
||||
**/SCCS
|
||||
**/SCCS/**
|
||||
**/vssver.scc
|
||||
**/.svn
|
||||
**/.svn/**
|
||||
**/BitKeeper
|
||||
**/.git
|
||||
**/.git/**
|
||||
**/.gitignore
|
||||
**/.bzr
|
||||
**/.bzrignore
|
||||
**/.bzr/**
|
||||
**/.hg
|
||||
**/.hg/**
|
||||
**/_MTN
|
||||
**/_MTN/**
|
||||
**/.arch-ids
|
||||
**/{arch}
|
||||
**/_darcs
|
||||
**/_darcs/**
|
||||
**/.DS_Store'''
|
||||
def split_path(path):
|
||||
return path.split('/')
|
||||
def split_path_cygwin(path):
|
||||
if path.startswith('//'):
|
||||
ret=path.split('/')[2:]
|
||||
ret[0]='/'+ret[0]
|
||||
return ret
|
||||
return path.split('/')
|
||||
re_sp=re.compile('[/\\\\]')
|
||||
def split_path_win32(path):
|
||||
if path.startswith('\\\\'):
|
||||
ret=re.split(re_sp,path)[2:]
|
||||
ret[0]='\\'+ret[0]
|
||||
return ret
|
||||
return re.split(re_sp,path)
|
||||
if sys.platform=='cygwin':
|
||||
split_path=split_path_cygwin
|
||||
elif Utils.is_win32:
|
||||
split_path=split_path_win32
|
||||
class Node(object):
|
||||
__slots__=('name','sig','children','parent','cache_abspath','cache_isdir','cache_sig')
|
||||
def __init__(self,name,parent):
|
||||
self.name=name
|
||||
self.parent=parent
|
||||
if parent:
|
||||
if name in parent.children:
|
||||
raise Errors.WafError('node %s exists in the parent files %r already'%(name,parent))
|
||||
parent.children[name]=self
|
||||
def __setstate__(self,data):
|
||||
self.name=data[0]
|
||||
self.parent=data[1]
|
||||
if data[2]is not None:
|
||||
self.children=data[2]
|
||||
if data[3]is not None:
|
||||
self.sig=data[3]
|
||||
def __getstate__(self):
|
||||
return(self.name,self.parent,getattr(self,'children',None),getattr(self,'sig',None))
|
||||
def __str__(self):
|
||||
return self.name
|
||||
def __repr__(self):
|
||||
return self.abspath()
|
||||
def __hash__(self):
|
||||
return id(self)
|
||||
def __eq__(self,node):
|
||||
return id(self)==id(node)
|
||||
def __copy__(self):
|
||||
raise Errors.WafError('nodes are not supposed to be copied')
|
||||
def read(self,flags='r',encoding='ISO8859-1'):
|
||||
return Utils.readf(self.abspath(),flags,encoding)
|
||||
def write(self,data,flags='w',encoding='ISO8859-1'):
|
||||
Utils.writef(self.abspath(),data,flags,encoding)
|
||||
def chmod(self,val):
|
||||
os.chmod(self.abspath(),val)
|
||||
def delete(self):
|
||||
try:
|
||||
if getattr(self,'children',None):
|
||||
shutil.rmtree(self.abspath())
|
||||
else:
|
||||
os.unlink(self.abspath())
|
||||
except OSError:
|
||||
pass
|
||||
self.evict()
|
||||
def evict(self):
|
||||
del self.parent.children[self.name]
|
||||
def suffix(self):
|
||||
k=max(0,self.name.rfind('.'))
|
||||
return self.name[k:]
|
||||
def height(self):
|
||||
d=self
|
||||
val=-1
|
||||
while d:
|
||||
d=d.parent
|
||||
val+=1
|
||||
return val
|
||||
def listdir(self):
|
||||
lst=Utils.listdir(self.abspath())
|
||||
lst.sort()
|
||||
return lst
|
||||
def mkdir(self):
|
||||
if getattr(self,'cache_isdir',None):
|
||||
return
|
||||
try:
|
||||
self.parent.mkdir()
|
||||
except OSError:
|
||||
pass
|
||||
if self.name:
|
||||
try:
|
||||
os.makedirs(self.abspath())
|
||||
except OSError:
|
||||
pass
|
||||
if not os.path.isdir(self.abspath()):
|
||||
raise Errors.WafError('Could not create the directory %s'%self.abspath())
|
||||
try:
|
||||
self.children
|
||||
except AttributeError:
|
||||
self.children={}
|
||||
self.cache_isdir=True
|
||||
def find_node(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
cur=self
|
||||
for x in lst:
|
||||
if x=='..':
|
||||
cur=cur.parent or cur
|
||||
continue
|
||||
try:
|
||||
ch=cur.children
|
||||
except AttributeError:
|
||||
cur.children={}
|
||||
else:
|
||||
try:
|
||||
cur=cur.children[x]
|
||||
continue
|
||||
except KeyError:
|
||||
pass
|
||||
cur=self.__class__(x,cur)
|
||||
try:
|
||||
os.stat(cur.abspath())
|
||||
except OSError:
|
||||
cur.evict()
|
||||
return None
|
||||
ret=cur
|
||||
try:
|
||||
os.stat(ret.abspath())
|
||||
except OSError:
|
||||
ret.evict()
|
||||
return None
|
||||
try:
|
||||
while not getattr(cur.parent,'cache_isdir',None):
|
||||
cur=cur.parent
|
||||
cur.cache_isdir=True
|
||||
except AttributeError:
|
||||
pass
|
||||
return ret
|
||||
def make_node(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
cur=self
|
||||
for x in lst:
|
||||
if x=='..':
|
||||
cur=cur.parent or cur
|
||||
continue
|
||||
if getattr(cur,'children',{}):
|
||||
if x in cur.children:
|
||||
cur=cur.children[x]
|
||||
continue
|
||||
else:
|
||||
cur.children={}
|
||||
cur=self.__class__(x,cur)
|
||||
return cur
|
||||
def search_node(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
cur=self
|
||||
for x in lst:
|
||||
if x=='..':
|
||||
cur=cur.parent or cur
|
||||
else:
|
||||
try:
|
||||
cur=cur.children[x]
|
||||
except(AttributeError,KeyError):
|
||||
return None
|
||||
return cur
|
||||
def path_from(self,node):
|
||||
c1=self
|
||||
c2=node
|
||||
c1h=c1.height()
|
||||
c2h=c2.height()
|
||||
lst=[]
|
||||
up=0
|
||||
while c1h>c2h:
|
||||
lst.append(c1.name)
|
||||
c1=c1.parent
|
||||
c1h-=1
|
||||
while c2h>c1h:
|
||||
up+=1
|
||||
c2=c2.parent
|
||||
c2h-=1
|
||||
while id(c1)!=id(c2):
|
||||
lst.append(c1.name)
|
||||
up+=1
|
||||
c1=c1.parent
|
||||
c2=c2.parent
|
||||
for i in range(up):
|
||||
lst.append('..')
|
||||
lst.reverse()
|
||||
return os.sep.join(lst)or'.'
|
||||
def abspath(self):
|
||||
try:
|
||||
return self.cache_abspath
|
||||
except AttributeError:
|
||||
pass
|
||||
if os.sep=='/':
|
||||
if not self.parent:
|
||||
val=os.sep
|
||||
elif not self.parent.name:
|
||||
val=os.sep+self.name
|
||||
else:
|
||||
val=self.parent.abspath()+os.sep+self.name
|
||||
else:
|
||||
if not self.parent:
|
||||
val=''
|
||||
elif not self.parent.name:
|
||||
val=self.name+os.sep
|
||||
else:
|
||||
val=self.parent.abspath().rstrip(os.sep)+os.sep+self.name
|
||||
self.cache_abspath=val
|
||||
return val
|
||||
def is_child_of(self,node):
|
||||
p=self
|
||||
diff=self.height()-node.height()
|
||||
while diff>0:
|
||||
diff-=1
|
||||
p=p.parent
|
||||
return id(p)==id(node)
|
||||
def ant_iter(self,accept=None,maxdepth=25,pats=[],dir=False,src=True,remove=True):
|
||||
dircont=self.listdir()
|
||||
dircont.sort()
|
||||
try:
|
||||
lst=set(self.children.keys())
|
||||
except AttributeError:
|
||||
self.children={}
|
||||
else:
|
||||
if remove:
|
||||
for x in lst-set(dircont):
|
||||
self.children[x].evict()
|
||||
for name in dircont:
|
||||
npats=accept(name,pats)
|
||||
if npats and npats[0]:
|
||||
accepted=[]in npats[0]
|
||||
node=self.make_node([name])
|
||||
isdir=os.path.isdir(node.abspath())
|
||||
if accepted:
|
||||
if isdir:
|
||||
if dir:
|
||||
yield node
|
||||
else:
|
||||
if src:
|
||||
yield node
|
||||
if getattr(node,'cache_isdir',None)or isdir:
|
||||
node.cache_isdir=True
|
||||
if maxdepth:
|
||||
for k in node.ant_iter(accept=accept,maxdepth=maxdepth-1,pats=npats,dir=dir,src=src,remove=remove):
|
||||
yield k
|
||||
raise StopIteration
|
||||
def ant_glob(self,*k,**kw):
|
||||
src=kw.get('src',True)
|
||||
dir=kw.get('dir',False)
|
||||
excl=kw.get('excl',exclude_regs)
|
||||
incl=k and k[0]or kw.get('incl','**')
|
||||
reflags=kw.get('ignorecase',0)and re.I
|
||||
def to_pat(s):
|
||||
lst=Utils.to_list(s)
|
||||
ret=[]
|
||||
for x in lst:
|
||||
x=x.replace('\\','/').replace('//','/')
|
||||
if x.endswith('/'):
|
||||
x+='**'
|
||||
lst2=x.split('/')
|
||||
accu=[]
|
||||
for k in lst2:
|
||||
if k=='**':
|
||||
accu.append(k)
|
||||
else:
|
||||
k=k.replace('.','[.]').replace('*','.*').replace('?','.').replace('+','\\+')
|
||||
k='^%s$'%k
|
||||
try:
|
||||
accu.append(re.compile(k,flags=reflags))
|
||||
except Exception ,e:
|
||||
raise Errors.WafError("Invalid pattern: %s"%k,e)
|
||||
ret.append(accu)
|
||||
return ret
|
||||
def filtre(name,nn):
|
||||
ret=[]
|
||||
for lst in nn:
|
||||
if not lst:
|
||||
pass
|
||||
elif lst[0]=='**':
|
||||
ret.append(lst)
|
||||
if len(lst)>1:
|
||||
if lst[1].match(name):
|
||||
ret.append(lst[2:])
|
||||
else:
|
||||
ret.append([])
|
||||
elif lst[0].match(name):
|
||||
ret.append(lst[1:])
|
||||
return ret
|
||||
def accept(name,pats):
|
||||
nacc=filtre(name,pats[0])
|
||||
nrej=filtre(name,pats[1])
|
||||
if[]in nrej:
|
||||
nacc=[]
|
||||
return[nacc,nrej]
|
||||
ret=[x for x in self.ant_iter(accept=accept,pats=[to_pat(incl),to_pat(excl)],maxdepth=25,dir=dir,src=src,remove=kw.get('remove',True))]
|
||||
if kw.get('flat',False):
|
||||
return' '.join([x.path_from(self)for x in ret])
|
||||
return ret
|
||||
def is_src(self):
|
||||
cur=self
|
||||
x=id(self.ctx.srcnode)
|
||||
y=id(self.ctx.bldnode)
|
||||
while cur.parent:
|
||||
if id(cur)==y:
|
||||
return False
|
||||
if id(cur)==x:
|
||||
return True
|
||||
cur=cur.parent
|
||||
return False
|
||||
def is_bld(self):
|
||||
cur=self
|
||||
y=id(self.ctx.bldnode)
|
||||
while cur.parent:
|
||||
if id(cur)==y:
|
||||
return True
|
||||
cur=cur.parent
|
||||
return False
|
||||
def get_src(self):
|
||||
cur=self
|
||||
x=id(self.ctx.srcnode)
|
||||
y=id(self.ctx.bldnode)
|
||||
lst=[]
|
||||
while cur.parent:
|
||||
if id(cur)==y:
|
||||
lst.reverse()
|
||||
return self.ctx.srcnode.make_node(lst)
|
||||
if id(cur)==x:
|
||||
return self
|
||||
lst.append(cur.name)
|
||||
cur=cur.parent
|
||||
return self
|
||||
def get_bld(self):
|
||||
cur=self
|
||||
x=id(self.ctx.srcnode)
|
||||
y=id(self.ctx.bldnode)
|
||||
lst=[]
|
||||
while cur.parent:
|
||||
if id(cur)==y:
|
||||
return self
|
||||
if id(cur)==x:
|
||||
lst.reverse()
|
||||
return self.ctx.bldnode.make_node(lst)
|
||||
lst.append(cur.name)
|
||||
cur=cur.parent
|
||||
lst.reverse()
|
||||
if lst and Utils.is_win32 and len(lst[0])==2 and lst[0].endswith(':'):
|
||||
lst[0]=lst[0][0]
|
||||
return self.ctx.bldnode.make_node(['__root__']+lst)
|
||||
def find_resource(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
node=self.get_bld().search_node(lst)
|
||||
if not node:
|
||||
self=self.get_src()
|
||||
node=self.find_node(lst)
|
||||
if node:
|
||||
if os.path.isdir(node.abspath()):
|
||||
return None
|
||||
return node
|
||||
def find_or_declare(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
node=self.get_bld().search_node(lst)
|
||||
if node:
|
||||
if not os.path.isfile(node.abspath()):
|
||||
node.sig=None
|
||||
node.parent.mkdir()
|
||||
return node
|
||||
self=self.get_src()
|
||||
node=self.find_node(lst)
|
||||
if node:
|
||||
if not os.path.isfile(node.abspath()):
|
||||
node.sig=None
|
||||
node.parent.mkdir()
|
||||
return node
|
||||
node=self.get_bld().make_node(lst)
|
||||
node.parent.mkdir()
|
||||
return node
|
||||
def find_dir(self,lst):
|
||||
if isinstance(lst,str):
|
||||
lst=[x for x in split_path(lst)if x and x!='.']
|
||||
node=self.find_node(lst)
|
||||
try:
|
||||
if not os.path.isdir(node.abspath()):
|
||||
return None
|
||||
except(OSError,AttributeError):
|
||||
return None
|
||||
return node
|
||||
def change_ext(self,ext,ext_in=None):
|
||||
name=self.name
|
||||
if ext_in is None:
|
||||
k=name.rfind('.')
|
||||
if k>=0:
|
||||
name=name[:k]+ext
|
||||
else:
|
||||
name=name+ext
|
||||
else:
|
||||
name=name[:-len(ext_in)]+ext
|
||||
return self.parent.find_or_declare([name])
|
||||
def nice_path(self,env=None):
|
||||
return self.path_from(self.ctx.launch_node())
|
||||
def bldpath(self):
|
||||
return self.path_from(self.ctx.bldnode)
|
||||
def srcpath(self):
|
||||
return self.path_from(self.ctx.srcnode)
|
||||
def relpath(self):
|
||||
cur=self
|
||||
x=id(self.ctx.bldnode)
|
||||
while cur.parent:
|
||||
if id(cur)==x:
|
||||
return self.bldpath()
|
||||
cur=cur.parent
|
||||
return self.srcpath()
|
||||
def bld_dir(self):
|
||||
return self.parent.bldpath()
|
||||
def bld_base(self):
|
||||
s=os.path.splitext(self.name)[0]
|
||||
return self.bld_dir()+os.sep+s
|
||||
def get_bld_sig(self):
|
||||
try:
|
||||
return self.cache_sig
|
||||
except AttributeError:
|
||||
pass
|
||||
if not self.is_bld()or self.ctx.bldnode is self.ctx.srcnode:
|
||||
self.sig=Utils.h_file(self.abspath())
|
||||
self.cache_sig=ret=self.sig
|
||||
return ret
|
||||
search=search_node
|
||||
pickle_lock=Utils.threading.Lock()
|
||||
class Nod3(Node):
|
||||
pass
|
||||
Reference in New Issue
Block a user