source: waflib/Node.py @ 926f0f6

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

waf: unpack
  • Property mode set to 100644
File size: 10.4 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,re,sys,shutil
6from waflib import Utils,Errors
7exclude_regs='''
8**/*~
9**/#*#
10**/.#*
11**/%*%
12**/._*
13**/CVS
14**/CVS/**
15**/.cvsignore
16**/SCCS
17**/SCCS/**
18**/vssver.scc
19**/.svn
20**/.svn/**
21**/BitKeeper
22**/.git
23**/.git/**
24**/.gitignore
25**/.bzr
26**/.bzrignore
27**/.bzr/**
28**/.hg
29**/.hg/**
30**/_MTN
31**/_MTN/**
32**/.arch-ids
33**/{arch}
34**/_darcs
35**/_darcs/**
36**/.DS_Store'''
37def split_path(path):
38        return path.split('/')
39def split_path_cygwin(path):
40        if path.startswith('//'):
41                ret=path.split('/')[2:]
42                ret[0]='/'+ret[0]
43                return ret
44        return path.split('/')
45re_sp=re.compile('[/\\\\]')
46def split_path_win32(path):
47        if path.startswith('\\\\'):
48                ret=re.split(re_sp,path)[2:]
49                ret[0]='\\'+ret[0]
50                return ret
51        return re.split(re_sp,path)
52if sys.platform=='cygwin':
53        split_path=split_path_cygwin
54elif Utils.is_win32:
55        split_path=split_path_win32
56class Node(object):
57        __slots__=('name','sig','children','parent','cache_abspath','cache_isdir','cache_sig')
58        def __init__(self,name,parent):
59                self.name=name
60                self.parent=parent
61                if parent:
62                        if name in parent.children:
63                                raise Errors.WafError('node %s exists in the parent files %r already'%(name,parent))
64                        parent.children[name]=self
65        def __setstate__(self,data):
66                self.name=data[0]
67                self.parent=data[1]
68                if data[2]is not None:
69                        self.children=data[2]
70                if data[3]is not None:
71                        self.sig=data[3]
72        def __getstate__(self):
73                return(self.name,self.parent,getattr(self,'children',None),getattr(self,'sig',None))
74        def __str__(self):
75                return self.name
76        def __repr__(self):
77                return self.abspath()
78        def __hash__(self):
79                return id(self)
80        def __eq__(self,node):
81                return id(self)==id(node)
82        def __copy__(self):
83                raise Errors.WafError('nodes are not supposed to be copied')
84        def read(self,flags='r',encoding='ISO8859-1'):
85                return Utils.readf(self.abspath(),flags,encoding)
86        def write(self,data,flags='w',encoding='ISO8859-1'):
87                Utils.writef(self.abspath(),data,flags,encoding)
88        def chmod(self,val):
89                os.chmod(self.abspath(),val)
90        def delete(self):
91                try:
92                        if getattr(self,'children',None):
93                                shutil.rmtree(self.abspath())
94                        else:
95                                os.unlink(self.abspath())
96                except OSError:
97                        pass
98                self.evict()
99        def evict(self):
100                del self.parent.children[self.name]
101        def suffix(self):
102                k=max(0,self.name.rfind('.'))
103                return self.name[k:]
104        def height(self):
105                d=self
106                val=-1
107                while d:
108                        d=d.parent
109                        val+=1
110                return val
111        def listdir(self):
112                lst=Utils.listdir(self.abspath())
113                lst.sort()
114                return lst
115        def mkdir(self):
116                if getattr(self,'cache_isdir',None):
117                        return
118                try:
119                        self.parent.mkdir()
120                except OSError:
121                        pass
122                if self.name:
123                        try:
124                                os.makedirs(self.abspath())
125                        except OSError:
126                                pass
127                        if not os.path.isdir(self.abspath()):
128                                raise Errors.WafError('Could not create the directory %s'%self.abspath())
129                        try:
130                                self.children
131                        except AttributeError:
132                                self.children={}
133                self.cache_isdir=True
134        def find_node(self,lst):
135                if isinstance(lst,str):
136                        lst=[x for x in split_path(lst)if x and x!='.']
137                cur=self
138                for x in lst:
139                        if x=='..':
140                                cur=cur.parent or cur
141                                continue
142                        try:
143                                ch=cur.children
144                        except AttributeError:
145                                cur.children={}
146                        else:
147                                try:
148                                        cur=cur.children[x]
149                                        continue
150                                except KeyError:
151                                        pass
152                        cur=self.__class__(x,cur)
153                        try:
154                                os.stat(cur.abspath())
155                        except OSError:
156                                cur.evict()
157                                return None
158                ret=cur
159                try:
160                        os.stat(ret.abspath())
161                except OSError:
162                        ret.evict()
163                        return None
164                try:
165                        while not getattr(cur.parent,'cache_isdir',None):
166                                cur=cur.parent
167                                cur.cache_isdir=True
168                except AttributeError:
169                        pass
170                return ret
171        def make_node(self,lst):
172                if isinstance(lst,str):
173                        lst=[x for x in split_path(lst)if x and x!='.']
174                cur=self
175                for x in lst:
176                        if x=='..':
177                                cur=cur.parent or cur
178                                continue
179                        if getattr(cur,'children',{}):
180                                if x in cur.children:
181                                        cur=cur.children[x]
182                                        continue
183                        else:
184                                cur.children={}
185                        cur=self.__class__(x,cur)
186                return cur
187        def search_node(self,lst):
188                if isinstance(lst,str):
189                        lst=[x for x in split_path(lst)if x and x!='.']
190                cur=self
191                for x in lst:
192                        if x=='..':
193                                cur=cur.parent or cur
194                        else:
195                                try:
196                                        cur=cur.children[x]
197                                except(AttributeError,KeyError):
198                                        return None
199                return cur
200        def path_from(self,node):
201                c1=self
202                c2=node
203                c1h=c1.height()
204                c2h=c2.height()
205                lst=[]
206                up=0
207                while c1h>c2h:
208                        lst.append(c1.name)
209                        c1=c1.parent
210                        c1h-=1
211                while c2h>c1h:
212                        up+=1
213                        c2=c2.parent
214                        c2h-=1
215                while id(c1)!=id(c2):
216                        lst.append(c1.name)
217                        up+=1
218                        c1=c1.parent
219                        c2=c2.parent
220                for i in range(up):
221                        lst.append('..')
222                lst.reverse()
223                return os.sep.join(lst)or'.'
224        def abspath(self):
225                try:
226                        return self.cache_abspath
227                except AttributeError:
228                        pass
229                if os.sep=='/':
230                        if not self.parent:
231                                val=os.sep
232                        elif not self.parent.name:
233                                val=os.sep+self.name
234                        else:
235                                val=self.parent.abspath()+os.sep+self.name
236                else:
237                        if not self.parent:
238                                val=''
239                        elif not self.parent.name:
240                                val=self.name+os.sep
241                        else:
242                                val=self.parent.abspath().rstrip(os.sep)+os.sep+self.name
243                self.cache_abspath=val
244                return val
245        def is_child_of(self,node):
246                p=self
247                diff=self.height()-node.height()
248                while diff>0:
249                        diff-=1
250                        p=p.parent
251                return id(p)==id(node)
252        def ant_iter(self,accept=None,maxdepth=25,pats=[],dir=False,src=True,remove=True):
253                dircont=self.listdir()
254                dircont.sort()
255                try:
256                        lst=set(self.children.keys())
257                except AttributeError:
258                        self.children={}
259                else:
260                        if remove:
261                                for x in lst-set(dircont):
262                                        self.children[x].evict()
263                for name in dircont:
264                        npats=accept(name,pats)
265                        if npats and npats[0]:
266                                accepted=[]in npats[0]
267                                node=self.make_node([name])
268                                isdir=os.path.isdir(node.abspath())
269                                if accepted:
270                                        if isdir:
271                                                if dir:
272                                                        yield node
273                                        else:
274                                                if src:
275                                                        yield node
276                                if getattr(node,'cache_isdir',None)or isdir:
277                                        node.cache_isdir=True
278                                        if maxdepth:
279                                                for k in node.ant_iter(accept=accept,maxdepth=maxdepth-1,pats=npats,dir=dir,src=src,remove=remove):
280                                                        yield k
281                raise StopIteration
282        def ant_glob(self,*k,**kw):
283                src=kw.get('src',True)
284                dir=kw.get('dir',False)
285                excl=kw.get('excl',exclude_regs)
286                incl=k and k[0]or kw.get('incl','**')
287                reflags=kw.get('ignorecase',0)and re.I
288                def to_pat(s):
289                        lst=Utils.to_list(s)
290                        ret=[]
291                        for x in lst:
292                                x=x.replace('\\','/').replace('//','/')
293                                if x.endswith('/'):
294                                        x+='**'
295                                lst2=x.split('/')
296                                accu=[]
297                                for k in lst2:
298                                        if k=='**':
299                                                accu.append(k)
300                                        else:
301                                                k=k.replace('.','[.]').replace('*','.*').replace('?','.').replace('+','\\+')
302                                                k='^%s$'%k
303                                                try:
304                                                        accu.append(re.compile(k,flags=reflags))
305                                                except Exception ,e:
306                                                        raise Errors.WafError("Invalid pattern: %s"%k,e)
307                                ret.append(accu)
308                        return ret
309                def filtre(name,nn):
310                        ret=[]
311                        for lst in nn:
312                                if not lst:
313                                        pass
314                                elif lst[0]=='**':
315                                        ret.append(lst)
316                                        if len(lst)>1:
317                                                if lst[1].match(name):
318                                                        ret.append(lst[2:])
319                                        else:
320                                                ret.append([])
321                                elif lst[0].match(name):
322                                        ret.append(lst[1:])
323                        return ret
324                def accept(name,pats):
325                        nacc=filtre(name,pats[0])
326                        nrej=filtre(name,pats[1])
327                        if[]in nrej:
328                                nacc=[]
329                        return[nacc,nrej]
330                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))]
331                if kw.get('flat',False):
332                        return' '.join([x.path_from(self)for x in ret])
333                return ret
334        def is_src(self):
335                cur=self
336                x=id(self.ctx.srcnode)
337                y=id(self.ctx.bldnode)
338                while cur.parent:
339                        if id(cur)==y:
340                                return False
341                        if id(cur)==x:
342                                return True
343                        cur=cur.parent
344                return False
345        def is_bld(self):
346                cur=self
347                y=id(self.ctx.bldnode)
348                while cur.parent:
349                        if id(cur)==y:
350                                return True
351                        cur=cur.parent
352                return False
353        def get_src(self):
354                cur=self
355                x=id(self.ctx.srcnode)
356                y=id(self.ctx.bldnode)
357                lst=[]
358                while cur.parent:
359                        if id(cur)==y:
360                                lst.reverse()
361                                return self.ctx.srcnode.make_node(lst)
362                        if id(cur)==x:
363                                return self
364                        lst.append(cur.name)
365                        cur=cur.parent
366                return self
367        def get_bld(self):
368                cur=self
369                x=id(self.ctx.srcnode)
370                y=id(self.ctx.bldnode)
371                lst=[]
372                while cur.parent:
373                        if id(cur)==y:
374                                return self
375                        if id(cur)==x:
376                                lst.reverse()
377                                return self.ctx.bldnode.make_node(lst)
378                        lst.append(cur.name)
379                        cur=cur.parent
380                lst.reverse()
381                if lst and Utils.is_win32 and len(lst[0])==2 and lst[0].endswith(':'):
382                        lst[0]=lst[0][0]
383                return self.ctx.bldnode.make_node(['__root__']+lst)
384        def find_resource(self,lst):
385                if isinstance(lst,str):
386                        lst=[x for x in split_path(lst)if x and x!='.']
387                node=self.get_bld().search_node(lst)
388                if not node:
389                        self=self.get_src()
390                        node=self.find_node(lst)
391                if node:
392                        if os.path.isdir(node.abspath()):
393                                return None
394                return node
395        def find_or_declare(self,lst):
396                if isinstance(lst,str):
397                        lst=[x for x in split_path(lst)if x and x!='.']
398                node=self.get_bld().search_node(lst)
399                if node:
400                        if not os.path.isfile(node.abspath()):
401                                node.sig=None
402                                node.parent.mkdir()
403                        return node
404                self=self.get_src()
405                node=self.find_node(lst)
406                if node:
407                        if not os.path.isfile(node.abspath()):
408                                node.sig=None
409                                node.parent.mkdir()
410                        return node
411                node=self.get_bld().make_node(lst)
412                node.parent.mkdir()
413                return node
414        def find_dir(self,lst):
415                if isinstance(lst,str):
416                        lst=[x for x in split_path(lst)if x and x!='.']
417                node=self.find_node(lst)
418                try:
419                        if not os.path.isdir(node.abspath()):
420                                return None
421                except(OSError,AttributeError):
422                        return None
423                return node
424        def change_ext(self,ext,ext_in=None):
425                name=self.name
426                if ext_in is None:
427                        k=name.rfind('.')
428                        if k>=0:
429                                name=name[:k]+ext
430                        else:
431                                name=name+ext
432                else:
433                        name=name[:-len(ext_in)]+ext
434                return self.parent.find_or_declare([name])
435        def nice_path(self,env=None):
436                return self.path_from(self.ctx.launch_node())
437        def bldpath(self):
438                return self.path_from(self.ctx.bldnode)
439        def srcpath(self):
440                return self.path_from(self.ctx.srcnode)
441        def relpath(self):
442                cur=self
443                x=id(self.ctx.bldnode)
444                while cur.parent:
445                        if id(cur)==x:
446                                return self.bldpath()
447                        cur=cur.parent
448                return self.srcpath()
449        def bld_dir(self):
450                return self.parent.bldpath()
451        def bld_base(self):
452                s=os.path.splitext(self.name)[0]
453                return self.bld_dir()+os.sep+s
454        def get_bld_sig(self):
455                try:
456                        return self.cache_sig
457                except AttributeError:
458                        pass
459                if not self.is_bld()or self.ctx.bldnode is self.ctx.srcnode:
460                        self.sig=Utils.h_file(self.abspath())
461                self.cache_sig=ret=self.sig
462                return ret
463        search=search_node
464pickle_lock=Utils.threading.Lock()
465class Nod3(Node):
466        pass
Note: See TracBrowser for help on using the repository browser.