summaryrefslogtreecommitdiff
path: root/waflib/Node.py
diff options
context:
space:
mode:
Diffstat (limited to 'waflib/Node.py')
-rw-r--r--waflib/Node.py478
1 files changed, 478 insertions, 0 deletions
diff --git a/waflib/Node.py b/waflib/Node.py
new file mode 100644
index 0000000..dc979d6
--- /dev/null
+++ b/waflib/Node.py
@@ -0,0 +1,478 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! https://waf.io/book/index.html#_obtaining_the_waf_file
+
+import os,re,sys,shutil
+from waflib import Utils,Errors
+exclude_regs='''
+**/*~
+**/#*#
+**/.#*
+**/%*%
+**/._*
+**/*.swp
+**/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/**
+**/.intlcache
+**/.DS_Store'''
+def ant_matcher(s,ignorecase):
+ reflags=re.I if ignorecase else 0
+ ret=[]
+ for x in Utils.to_list(s):
+ x=x.replace('\\','/').replace('//','/')
+ if x.endswith('/'):
+ x+='**'
+ accu=[]
+ for k in x.split('/'):
+ if k=='**':
+ accu.append(k)
+ else:
+ k=k.replace('.','[.]').replace('*','.*').replace('?','.').replace('+','\\+')
+ k='^%s$'%k
+ try:
+ exp=re.compile(k,flags=reflags)
+ except Exception as e:
+ raise Errors.WafError('Invalid pattern: %s'%k,e)
+ else:
+ accu.append(exp)
+ ret.append(accu)
+ return ret
+def ant_sub_filter(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 ant_sub_matcher(name,pats):
+ nacc=ant_sub_filter(name,pats[0])
+ nrej=ant_sub_filter(name,pats[1])
+ if[]in nrej:
+ nacc=[]
+ return[nacc,nrej]
+class Node(object):
+ dict_class=dict
+ __slots__=('name','parent','children','cache_abspath','cache_isdir')
+ 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=self.dict_class(data[2])
+ def __getstate__(self):
+ return(self.name,self.parent,getattr(self,'children',None))
+ def __str__(self):
+ return self.abspath()
+ def __repr__(self):
+ return self.abspath()
+ def __copy__(self):
+ raise Errors.WafError('nodes are not supposed to be copied')
+ def read(self,flags='r',encoding='latin-1'):
+ return Utils.readf(self.abspath(),flags,encoding)
+ def write(self,data,flags='w',encoding='latin-1'):
+ Utils.writef(self.abspath(),data,flags,encoding)
+ def read_json(self,convert=True,encoding='utf-8'):
+ import json
+ object_pairs_hook=None
+ if convert and sys.hexversion<0x3000000:
+ try:
+ _type=unicode
+ except NameError:
+ _type=str
+ def convert(value):
+ if isinstance(value,list):
+ return[convert(element)for element in value]
+ elif isinstance(value,_type):
+ return str(value)
+ else:
+ return value
+ def object_pairs(pairs):
+ return dict((str(pair[0]),convert(pair[1]))for pair in pairs)
+ object_pairs_hook=object_pairs
+ return json.loads(self.read(encoding=encoding),object_pairs_hook=object_pairs_hook)
+ def write_json(self,data,pretty=True):
+ import json
+ indent=2
+ separators=(',',': ')
+ sort_keys=pretty
+ newline=os.linesep
+ if not pretty:
+ indent=None
+ separators=(',',':')
+ newline=''
+ output=json.dumps(data,indent=indent,separators=separators,sort_keys=sort_keys)+newline
+ self.write(output,encoding='utf-8')
+ def exists(self):
+ return os.path.exists(self.abspath())
+ def isdir(self):
+ return os.path.isdir(self.abspath())
+ def chmod(self,val):
+ os.chmod(self.abspath(),val)
+ def delete(self,evict=True):
+ try:
+ try:
+ if os.path.isdir(self.abspath()):
+ shutil.rmtree(self.abspath())
+ else:
+ os.remove(self.abspath())
+ except OSError:
+ if os.path.exists(self.abspath()):
+ raise
+ finally:
+ if evict:
+ 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 self.isdir():
+ return
+ try:
+ self.parent.mkdir()
+ except OSError:
+ pass
+ if self.name:
+ try:
+ os.makedirs(self.abspath())
+ except OSError:
+ pass
+ if not self.isdir():
+ raise Errors.WafError('Could not create the directory %r'%self)
+ try:
+ self.children
+ except AttributeError:
+ self.children=self.dict_class()
+ def find_node(self,lst):
+ if isinstance(lst,str):
+ lst=[x for x in Utils.split_path(lst)if x and x!='.']
+ if lst and lst[0].startswith('\\\\')and not self.parent:
+ node=self.ctx.root.make_node(lst[0])
+ node.cache_isdir=True
+ return node.find_node(lst[1:])
+ cur=self
+ for x in lst:
+ if x=='..':
+ cur=cur.parent or cur
+ continue
+ try:
+ ch=cur.children
+ except AttributeError:
+ cur.children=self.dict_class()
+ else:
+ try:
+ cur=ch[x]
+ continue
+ except KeyError:
+ pass
+ cur=self.__class__(x,cur)
+ if not cur.exists():
+ cur.evict()
+ return None
+ if not cur.exists():
+ cur.evict()
+ return None
+ return cur
+ def make_node(self,lst):
+ if isinstance(lst,str):
+ lst=[x for x in Utils.split_path(lst)if x and x!='.']
+ cur=self
+ for x in lst:
+ if x=='..':
+ cur=cur.parent or cur
+ continue
+ try:
+ cur=cur.children[x]
+ except AttributeError:
+ cur.children=self.dict_class()
+ except KeyError:
+ pass
+ else:
+ continue
+ cur=self.__class__(x,cur)
+ return cur
+ def search_node(self,lst):
+ if isinstance(lst,str):
+ lst=[x for x in Utils.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 not c1 is c2:
+ lst.append(c1.name)
+ up+=1
+ c1=c1.parent
+ c2=c2.parent
+ if c1.parent:
+ lst.extend(['..']*up)
+ lst.reverse()
+ return os.sep.join(lst)or'.'
+ else:
+ return self.abspath()
+ def abspath(self):
+ try:
+ return self.cache_abspath
+ except AttributeError:
+ pass
+ 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
+ self.cache_abspath=val
+ return val
+ if Utils.is_win32:
+ def abspath(self):
+ try:
+ return self.cache_abspath
+ except AttributeError:
+ pass
+ 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 p is node
+ def ant_iter(self,accept=None,maxdepth=25,pats=[],dir=False,src=True,remove=True,quiet=False):
+ dircont=self.listdir()
+ dircont.sort()
+ try:
+ lst=set(self.children.keys())
+ except AttributeError:
+ self.children=self.dict_class()
+ 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=node.isdir()
+ if accepted:
+ if isdir:
+ if dir:
+ yield node
+ elif src:
+ yield node
+ if 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,quiet=quiet):
+ yield k
+ def ant_glob(self,*k,**kw):
+ src=kw.get('src',True)
+ dir=kw.get('dir')
+ excl=kw.get('excl',exclude_regs)
+ incl=k and k[0]or kw.get('incl','**')
+ remove=kw.get('remove',True)
+ maxdepth=kw.get('maxdepth',25)
+ ignorecase=kw.get('ignorecase',False)
+ quiet=kw.get('quiet',False)
+ pats=(ant_matcher(incl,ignorecase),ant_matcher(excl,ignorecase))
+ if kw.get('generator'):
+ return Utils.lazy_generator(self.ant_iter,(ant_sub_matcher,maxdepth,pats,dir,src,remove,quiet))
+ it=self.ant_iter(ant_sub_matcher,maxdepth,pats,dir,src,remove,quiet)
+ if kw.get('flat'):
+ return' '.join(x.path_from(self)for x in it)
+ return list(it)
+ def is_src(self):
+ cur=self
+ x=self.ctx.srcnode
+ y=self.ctx.bldnode
+ while cur.parent:
+ if cur is y:
+ return False
+ if cur is x:
+ return True
+ cur=cur.parent
+ return False
+ def is_bld(self):
+ cur=self
+ y=self.ctx.bldnode
+ while cur.parent:
+ if cur is y:
+ return True
+ cur=cur.parent
+ return False
+ def get_src(self):
+ cur=self
+ x=self.ctx.srcnode
+ y=self.ctx.bldnode
+ lst=[]
+ while cur.parent:
+ if cur is y:
+ lst.reverse()
+ return x.make_node(lst)
+ if cur is x:
+ return self
+ lst.append(cur.name)
+ cur=cur.parent
+ return self
+ def get_bld(self):
+ cur=self
+ x=self.ctx.srcnode
+ y=self.ctx.bldnode
+ lst=[]
+ while cur.parent:
+ if cur is y:
+ return self
+ if cur is 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 Utils.split_path(lst)if x and x!='.']
+ node=self.get_bld().search_node(lst)
+ if not node:
+ node=self.get_src().find_node(lst)
+ if node and node.isdir():
+ return None
+ return node
+ def find_or_declare(self,lst):
+ if isinstance(lst,str)and os.path.isabs(lst):
+ node=self.ctx.root.make_node(lst)
+ else:
+ 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 Utils.split_path(lst)if x and x!='.']
+ node=self.find_node(lst)
+ if node and not node.isdir():
+ 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 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=self.ctx.bldnode
+ while cur.parent:
+ if cur is x:
+ return self.bldpath()
+ cur=cur.parent
+ return self.srcpath()
+ def bld_dir(self):
+ return self.parent.bldpath()
+ def h_file(self):
+ return Utils.h_file(self.abspath())
+ def get_bld_sig(self):
+ try:
+ cache=self.ctx.cache_sig
+ except AttributeError:
+ cache=self.ctx.cache_sig={}
+ try:
+ ret=cache[self]
+ except KeyError:
+ p=self.abspath()
+ try:
+ ret=cache[self]=self.h_file()
+ except EnvironmentError:
+ if self.isdir():
+ st=os.stat(p)
+ ret=cache[self]=Utils.h_list([p,st.st_ino,st.st_mode])
+ return ret
+ raise
+ return ret
+pickle_lock=Utils.threading.Lock()
+class Nod3(Node):
+ pass
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-31 20:41:55 +0000