src/aubiopitch~.c: refix aubiopitch_tilde_del
[pd-aubio.git] / waflib / Build.py
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
5 import os,sys,errno,re,shutil
6 try:
7         import cPickle
8 except ImportError:
9         import pickle as cPickle
10 from waflib import Runner,TaskGen,Utils,ConfigSet,Task,Logs,Options,Context,Errors
11 import waflib.Node
12 CACHE_DIR='c4che'
13 CACHE_SUFFIX='_cache.py'
14 INSTALL=1337
15 UNINSTALL=-1337
16 SAVED_ATTRS='root node_deps raw_deps task_sigs'.split()
17 CFG_FILES='cfg_files'
18 POST_AT_ONCE=0
19 POST_LAZY=1
20 POST_BOTH=2
21 class BuildContext(Context.Context):
22         '''executes the build'''
23         cmd='build'
24         variant=''
25         def __init__(self,**kw):
26                 super(BuildContext,self).__init__(**kw)
27                 self.is_install=0
28                 self.top_dir=kw.get('top_dir',Context.top_dir)
29                 self.run_dir=kw.get('run_dir',Context.run_dir)
30                 self.post_mode=POST_AT_ONCE
31                 self.out_dir=kw.get('out_dir',Context.out_dir)
32                 self.cache_dir=kw.get('cache_dir',None)
33                 if not self.cache_dir:
34                         self.cache_dir=self.out_dir+os.sep+CACHE_DIR
35                 self.all_envs={}
36                 self.task_sigs={}
37                 self.node_deps={}
38                 self.raw_deps={}
39                 self.cache_dir_contents={}
40                 self.task_gen_cache_names={}
41                 self.launch_dir=Context.launch_dir
42                 self.jobs=Options.options.jobs
43                 self.targets=Options.options.targets
44                 self.keep=Options.options.keep
45                 self.cache_global=Options.cache_global
46                 self.nocache=Options.options.nocache
47                 self.progress_bar=Options.options.progress_bar
48                 self.deps_man=Utils.defaultdict(list)
49                 self.current_group=0
50                 self.groups=[]
51                 self.group_names={}
52         def get_variant_dir(self):
53                 if not self.variant:
54                         return self.out_dir
55                 return os.path.join(self.out_dir,self.variant)
56         variant_dir=property(get_variant_dir,None)
57         def __call__(self,*k,**kw):
58                 kw['bld']=self
59                 ret=TaskGen.task_gen(*k,**kw)
60                 self.task_gen_cache_names={}
61                 self.add_to_group(ret,group=kw.get('group',None))
62                 return ret
63         def rule(self,*k,**kw):
64                 def f(rule):
65                         ret=self(*k,**kw)
66                         ret.rule=rule
67                         return ret
68                 return f
69         def __copy__(self):
70                 raise Errors.WafError('build contexts are not supposed to be copied')
71         def install_files(self,*k,**kw):
72                 pass
73         def install_as(self,*k,**kw):
74                 pass
75         def symlink_as(self,*k,**kw):
76                 pass
77         def load_envs(self):
78                 node=self.root.find_node(self.cache_dir)
79                 if not node:
80                         raise Errors.WafError('The project was not configured: run "waf configure" first!')
81                 lst=node.ant_glob('**/*%s'%CACHE_SUFFIX,quiet=True)
82                 if not lst:
83                         raise Errors.WafError('The cache directory is empty: reconfigure the project')
84                 for x in lst:
85                         name=x.path_from(node).replace(CACHE_SUFFIX,'').replace('\\','/')
86                         env=ConfigSet.ConfigSet(x.abspath())
87                         self.all_envs[name]=env
88                         for f in env[CFG_FILES]:
89                                 newnode=self.root.find_resource(f)
90                                 try:
91                                         h=Utils.h_file(newnode.abspath())
92                                 except(IOError,AttributeError):
93                                         Logs.error('cannot find %r'%f)
94                                         h=Utils.SIG_NIL
95                                 newnode.sig=h
96         def init_dirs(self):
97                 if not(os.path.isabs(self.top_dir)and os.path.isabs(self.out_dir)):
98                         raise Errors.WafError('The project was not configured: run "waf configure" first!')
99                 self.path=self.srcnode=self.root.find_dir(self.top_dir)
100                 self.bldnode=self.root.make_node(self.variant_dir)
101                 self.bldnode.mkdir()
102         def execute(self):
103                 self.restore()
104                 if not self.all_envs:
105                         self.load_envs()
106                 self.execute_build()
107         def execute_build(self):
108                 Logs.info("Waf: Entering directory `%s'"%self.variant_dir)
109                 self.recurse([self.run_dir])
110                 self.pre_build()
111                 self.timer=Utils.Timer()
112                 if self.progress_bar:
113                         sys.stderr.write(Logs.colors.cursor_off)
114                 try:
115                         self.compile()
116                 finally:
117                         if self.progress_bar==1:
118                                 c=len(self.returned_tasks)or 1
119                                 self.to_log(self.progress_line(c,c,Logs.colors.BLUE,Logs.colors.NORMAL))
120                                 print('')
121                                 sys.stdout.flush()
122                                 sys.stderr.write(Logs.colors.cursor_on)
123                         Logs.info("Waf: Leaving directory `%s'"%self.variant_dir)
124                 self.post_build()
125         def restore(self):
126                 try:
127                         env=ConfigSet.ConfigSet(os.path.join(self.cache_dir,'build.config.py'))
128                 except(IOError,OSError):
129                         pass
130                 else:
131                         if env['version']<Context.HEXVERSION:
132                                 raise Errors.WafError('Version mismatch! reconfigure the project')
133                         for t in env['tools']:
134                                 self.setup(**t)
135                 dbfn=os.path.join(self.variant_dir,Context.DBFILE)
136                 try:
137                         data=Utils.readf(dbfn,'rb')
138                 except(IOError,EOFError):
139                         Logs.debug('build: Could not load the build cache %s (missing)'%dbfn)
140                 else:
141                         try:
142                                 waflib.Node.pickle_lock.acquire()
143                                 waflib.Node.Nod3=self.node_class
144                                 try:
145                                         data=cPickle.loads(data)
146                                 except Exception ,e:
147                                         Logs.debug('build: Could not pickle the build cache %s: %r'%(dbfn,e))
148                                 else:
149                                         for x in SAVED_ATTRS:
150                                                 setattr(self,x,data[x])
151                         finally:
152                                 waflib.Node.pickle_lock.release()
153                 self.init_dirs()
154         def store(self):
155                 data={}
156                 for x in SAVED_ATTRS:
157                         data[x]=getattr(self,x)
158                 db=os.path.join(self.variant_dir,Context.DBFILE)
159                 try:
160                         waflib.Node.pickle_lock.acquire()
161                         waflib.Node.Nod3=self.node_class
162                         x=cPickle.dumps(data,-1)
163                 finally:
164                         waflib.Node.pickle_lock.release()
165                 Utils.writef(db+'.tmp',x,m='wb')
166                 try:
167                         st=os.stat(db)
168                         os.remove(db)
169                         if not Utils.is_win32:
170                                 os.chown(db+'.tmp',st.st_uid,st.st_gid)
171                 except(AttributeError,OSError):
172                         pass
173                 os.rename(db+'.tmp',db)
174         def compile(self):
175                 Logs.debug('build: compile()')
176                 self.producer=Runner.Parallel(self,self.jobs)
177                 self.producer.biter=self.get_build_iterator()
178                 self.returned_tasks=[]
179                 try:
180                         self.producer.start()
181                 except KeyboardInterrupt:
182                         self.store()
183                         raise
184                 else:
185                         if self.producer.dirty:
186                                 self.store()
187                 if self.producer.error:
188                         raise Errors.BuildError(self.producer.error)
189         def setup(self,tool,tooldir=None,funs=None):
190                 if isinstance(tool,list):
191                         for i in tool:self.setup(i,tooldir)
192                         return
193                 module=Context.load_tool(tool,tooldir)
194                 if hasattr(module,"setup"):module.setup(self)
195         def get_env(self):
196                 try:
197                         return self.all_envs[self.variant]
198                 except KeyError:
199                         return self.all_envs['']
200         def set_env(self,val):
201                 self.all_envs[self.variant]=val
202         env=property(get_env,set_env)
203         def add_manual_dependency(self,path,value):
204                 if path is None:
205                         raise ValueError('Invalid input')
206                 if isinstance(path,waflib.Node.Node):
207                         node=path
208                 elif os.path.isabs(path):
209                         node=self.root.find_resource(path)
210                 else:
211                         node=self.path.find_resource(path)
212                 if isinstance(value,list):
213                         self.deps_man[id(node)].extend(value)
214                 else:
215                         self.deps_man[id(node)].append(value)
216         def launch_node(self):
217                 try:
218                         return self.p_ln
219                 except AttributeError:
220                         self.p_ln=self.root.find_dir(self.launch_dir)
221                         return self.p_ln
222         def hash_env_vars(self,env,vars_lst):
223                 if not env.table:
224                         env=env.parent
225                         if not env:
226                                 return Utils.SIG_NIL
227                 idx=str(id(env))+str(vars_lst)
228                 try:
229                         cache=self.cache_env
230                 except AttributeError:
231                         cache=self.cache_env={}
232                 else:
233                         try:
234                                 return self.cache_env[idx]
235                         except KeyError:
236                                 pass
237                 lst=[env[a]for a in vars_lst]
238                 ret=Utils.h_list(lst)
239                 Logs.debug('envhash: %s %r',Utils.to_hex(ret),lst)
240                 cache[idx]=ret
241                 return ret
242         def get_tgen_by_name(self,name):
243                 cache=self.task_gen_cache_names
244                 if not cache:
245                         for g in self.groups:
246                                 for tg in g:
247                                         try:
248                                                 cache[tg.name]=tg
249                                         except AttributeError:
250                                                 pass
251                 try:
252                         return cache[name]
253                 except KeyError:
254                         raise Errors.WafError('Could not find a task generator for the name %r'%name)
255         def progress_line(self,state,total,col1,col2):
256                 n=len(str(total))
257                 Utils.rot_idx+=1
258                 ind=Utils.rot_chr[Utils.rot_idx%4]
259                 pc=(100.*state)/total
260                 eta=str(self.timer)
261                 fs="[%%%dd/%%%dd][%%s%%2d%%%%%%s][%s]["%(n,n,ind)
262                 left=fs%(state,total,col1,pc,col2)
263                 right='][%s%s%s]'%(col1,eta,col2)
264                 cols=Logs.get_term_cols()-len(left)-len(right)+2*len(col1)+2*len(col2)
265                 if cols<7:cols=7
266                 ratio=((cols*state)//total)-1
267                 bar=('='*ratio+'>').ljust(cols)
268                 msg=Utils.indicator%(left,bar,right)
269                 return msg
270         def declare_chain(self,*k,**kw):
271                 return TaskGen.declare_chain(*k,**kw)
272         def pre_build(self):
273                 for m in getattr(self,'pre_funs',[]):
274                         m(self)
275         def post_build(self):
276                 for m in getattr(self,'post_funs',[]):
277                         m(self)
278         def add_pre_fun(self,meth):
279                 try:
280                         self.pre_funs.append(meth)
281                 except AttributeError:
282                         self.pre_funs=[meth]
283         def add_post_fun(self,meth):
284                 try:
285                         self.post_funs.append(meth)
286                 except AttributeError:
287                         self.post_funs=[meth]
288         def get_group(self,x):
289                 if not self.groups:
290                         self.add_group()
291                 if x is None:
292                         return self.groups[self.current_group]
293                 if x in self.group_names:
294                         return self.group_names[x]
295                 return self.groups[x]
296         def add_to_group(self,tgen,group=None):
297                 assert(isinstance(tgen,TaskGen.task_gen)or isinstance(tgen,Task.TaskBase))
298                 tgen.bld=self
299                 self.get_group(group).append(tgen)
300         def get_group_name(self,g):
301                 if not isinstance(g,list):
302                         g=self.groups[g]
303                 for x in self.group_names:
304                         if id(self.group_names[x])==id(g):
305                                 return x
306                 return''
307         def get_group_idx(self,tg):
308                 se=id(tg)
309                 for i in range(len(self.groups)):
310                         for t in self.groups[i]:
311                                 if id(t)==se:
312                                         return i
313                 return None
314         def add_group(self,name=None,move=True):
315                 if name and name in self.group_names:
316                         Logs.error('add_group: name %s already present'%name)
317                 g=[]
318                 self.group_names[name]=g
319                 self.groups.append(g)
320                 if move:
321                         self.current_group=len(self.groups)-1
322         def set_group(self,idx):
323                 if isinstance(idx,str):
324                         g=self.group_names[idx]
325                         for i in range(len(self.groups)):
326                                 if id(g)==id(self.groups[i]):
327                                         self.current_group=i
328                 else:
329                         self.current_group=idx
330         def total(self):
331                 total=0
332                 for group in self.groups:
333                         for tg in group:
334                                 try:
335                                         total+=len(tg.tasks)
336                                 except AttributeError:
337                                         total+=1
338                 return total
339         def get_targets(self):
340                 to_post=[]
341                 min_grp=0
342                 for name in self.targets.split(','):
343                         tg=self.get_tgen_by_name(name)
344                         if not tg:
345                                 raise Errors.WafError('target %r does not exist'%name)
346                         m=self.get_group_idx(tg)
347                         if m>min_grp:
348                                 min_grp=m
349                                 to_post=[tg]
350                         elif m==min_grp:
351                                 to_post.append(tg)
352                 return(min_grp,to_post)
353         def get_all_task_gen(self):
354                 lst=[]
355                 for g in self.groups:
356                         lst.extend(g)
357                 return lst
358         def post_group(self):
359                 if self.targets=='*':
360                         for tg in self.groups[self.cur]:
361                                 try:
362                                         f=tg.post
363                                 except AttributeError:
364                                         pass
365                                 else:
366                                         f()
367                 elif self.targets:
368                         if self.cur<self._min_grp:
369                                 for tg in self.groups[self.cur]:
370                                         try:
371                                                 f=tg.post
372                                         except AttributeError:
373                                                 pass
374                                         else:
375                                                 f()
376                         else:
377                                 for tg in self._exact_tg:
378                                         tg.post()
379                 else:
380                         ln=self.launch_node()
381                         if ln.is_child_of(self.bldnode):
382                                 Logs.warn('Building from the build directory, forcing --targets=*')
383                                 ln=self.srcnode
384                         elif not ln.is_child_of(self.srcnode):
385                                 Logs.warn('CWD %s is not under %s, forcing --targets=* (run distclean?)'%(ln.abspath(),self.srcnode.abspath()))
386                                 ln=self.srcnode
387                         for tg in self.groups[self.cur]:
388                                 try:
389                                         f=tg.post
390                                 except AttributeError:
391                                         pass
392                                 else:
393                                         if tg.path.is_child_of(ln):
394                                                 f()
395         def get_tasks_group(self,idx):
396                 tasks=[]
397                 for tg in self.groups[idx]:
398                         try:
399                                 tasks.extend(tg.tasks)
400                         except AttributeError:
401                                 tasks.append(tg)
402                 return tasks
403         def get_build_iterator(self):
404                 self.cur=0
405                 if self.targets and self.targets!='*':
406                         (self._min_grp,self._exact_tg)=self.get_targets()
407                 global lazy_post
408                 if self.post_mode!=POST_LAZY:
409                         while self.cur<len(self.groups):
410                                 self.post_group()
411                                 self.cur+=1
412                         self.cur=0
413                 while self.cur<len(self.groups):
414                         if self.post_mode!=POST_AT_ONCE:
415                                 self.post_group()
416                         tasks=self.get_tasks_group(self.cur)
417                         Task.set_file_constraints(tasks)
418                         Task.set_precedence_constraints(tasks)
419                         self.cur_tasks=tasks
420                         self.cur+=1
421                         if not tasks:
422                                 continue
423                         yield tasks
424                 while 1:
425                         yield[]
426 class inst(Task.Task):
427         color='CYAN'
428         def uid(self):
429                 lst=[self.dest,self.path]+self.source
430                 return Utils.h_list(repr(lst))
431         def post(self):
432                 buf=[]
433                 for x in self.source:
434                         if isinstance(x,waflib.Node.Node):
435                                 y=x
436                         else:
437                                 y=self.path.find_resource(x)
438                                 if not y:
439                                         if Logs.verbose:
440                                                 Logs.warn('Could not find %s immediately (may cause broken builds)'%x)
441                                         idx=self.generator.bld.get_group_idx(self)
442                                         for tg in self.generator.bld.groups[idx]:
443                                                 if not isinstance(tg,inst)and id(tg)!=id(self):
444                                                         tg.post()
445                                                 y=self.path.find_resource(x)
446                                                 if y:
447                                                         break
448                                         else:
449                                                 raise Errors.WafError('Could not find %r in %r'%(x,self.path))
450                         buf.append(y)
451                 self.inputs=buf
452         def runnable_status(self):
453                 ret=super(inst,self).runnable_status()
454                 if ret==Task.SKIP_ME:
455                         return Task.RUN_ME
456                 return ret
457         def __str__(self):
458                 return''
459         def run(self):
460                 return self.generator.exec_task()
461         def get_install_path(self,destdir=True):
462                 dest=Utils.subst_vars(self.dest,self.env)
463                 dest=dest.replace('/',os.sep)
464                 if destdir and Options.options.destdir:
465                         dest=os.path.join(Options.options.destdir,os.path.splitdrive(dest)[1].lstrip(os.sep))
466                 return dest
467         def exec_install_files(self):
468                 destpath=self.get_install_path()
469                 if not destpath:
470                         raise Errors.WafError('unknown installation path %r'%self.generator)
471                 for x,y in zip(self.source,self.inputs):
472                         if self.relative_trick:
473                                 destfile=os.path.join(destpath,y.path_from(self.path))
474                         else:
475                                 destfile=os.path.join(destpath,y.name)
476                         self.generator.bld.do_install(y.abspath(),destfile,self.chmod)
477         def exec_install_as(self):
478                 destfile=self.get_install_path()
479                 self.generator.bld.do_install(self.inputs[0].abspath(),destfile,self.chmod)
480         def exec_symlink_as(self):
481                 destfile=self.get_install_path()
482                 src=self.link
483                 if self.relative_trick:
484                         src=os.path.relpath(src,os.path.dirname(destfile))
485                 self.generator.bld.do_link(src,destfile)
486 class InstallContext(BuildContext):
487         '''installs the targets on the system'''
488         cmd='install'
489         def __init__(self,**kw):
490                 super(InstallContext,self).__init__(**kw)
491                 self.uninstall=[]
492                 self.is_install=INSTALL
493         def do_install(self,src,tgt,chmod=Utils.O644):
494                 d,_=os.path.split(tgt)
495                 if not d:
496                         raise Errors.WafError('Invalid installation given %r->%r'%(src,tgt))
497                 Utils.check_dir(d)
498                 srclbl=src.replace(self.srcnode.abspath()+os.sep,'')
499                 if not Options.options.force:
500                         try:
501                                 st1=os.stat(tgt)
502                                 st2=os.stat(src)
503                         except OSError:
504                                 pass
505                         else:
506                                 if st1.st_mtime+2>=st2.st_mtime and st1.st_size==st2.st_size:
507                                         if not self.progress_bar:
508                                                 Logs.info('- install %s (from %s)'%(tgt,srclbl))
509                                         return False
510                 if not self.progress_bar:
511                         Logs.info('+ install %s (from %s)'%(tgt,srclbl))
512                 try:
513                         os.remove(tgt)
514                 except OSError:
515                         pass
516                 try:
517                         shutil.copy2(src,tgt)
518                         os.chmod(tgt,chmod)
519                 except IOError:
520                         try:
521                                 os.stat(src)
522                         except(OSError,IOError):
523                                 Logs.error('File %r does not exist'%src)
524                         raise Errors.WafError('Could not install the file %r'%tgt)
525         def do_link(self,src,tgt):
526                 d,_=os.path.split(tgt)
527                 Utils.check_dir(d)
528                 link=False
529                 if not os.path.islink(tgt):
530                         link=True
531                 elif os.readlink(tgt)!=src:
532                         link=True
533                 if link:
534                         try:os.remove(tgt)
535                         except OSError:pass
536                         if not self.progress_bar:
537                                 Logs.info('+ symlink %s (to %s)'%(tgt,src))
538                         os.symlink(src,tgt)
539                 else:
540                         if not self.progress_bar:
541                                 Logs.info('- symlink %s (to %s)'%(tgt,src))
542         def run_task_now(self,tsk,postpone):
543                 tsk.post()
544                 if not postpone:
545                         if tsk.runnable_status()==Task.ASK_LATER:
546                                 raise self.WafError('cannot post the task %r'%tsk)
547                         tsk.run()
548         def install_files(self,dest,files,env=None,chmod=Utils.O644,relative_trick=False,cwd=None,add=True,postpone=True):
549                 tsk=inst(env=env or self.env)
550                 tsk.bld=self
551                 tsk.path=cwd or self.path
552                 tsk.chmod=chmod
553                 if isinstance(files,waflib.Node.Node):
554                         tsk.source=[files]
555                 else:
556                         tsk.source=Utils.to_list(files)
557                 tsk.dest=dest
558                 tsk.exec_task=tsk.exec_install_files
559                 tsk.relative_trick=relative_trick
560                 if add:self.add_to_group(tsk)
561                 self.run_task_now(tsk,postpone)
562                 return tsk
563         def install_as(self,dest,srcfile,env=None,chmod=Utils.O644,cwd=None,add=True,postpone=True):
564                 tsk=inst(env=env or self.env)
565                 tsk.bld=self
566                 tsk.path=cwd or self.path
567                 tsk.chmod=chmod
568                 tsk.source=[srcfile]
569                 tsk.dest=dest
570                 tsk.exec_task=tsk.exec_install_as
571                 if add:self.add_to_group(tsk)
572                 self.run_task_now(tsk,postpone)
573                 return tsk
574         def symlink_as(self,dest,src,env=None,cwd=None,add=True,postpone=True,relative_trick=False):
575                 if Utils.is_win32:
576                         return
577                 tsk=inst(env=env or self.env)
578                 tsk.bld=self
579                 tsk.dest=dest
580                 tsk.path=cwd or self.path
581                 tsk.source=[]
582                 tsk.link=src
583                 tsk.relative_trick=relative_trick
584                 tsk.exec_task=tsk.exec_symlink_as
585                 if add:self.add_to_group(tsk)
586                 self.run_task_now(tsk,postpone)
587                 return tsk
588 class UninstallContext(InstallContext):
589         '''removes the targets installed'''
590         cmd='uninstall'
591         def __init__(self,**kw):
592                 super(UninstallContext,self).__init__(**kw)
593                 self.is_install=UNINSTALL
594         def do_install(self,src,tgt,chmod=Utils.O644):
595                 if not self.progress_bar:
596                         Logs.info('- remove %s'%tgt)
597                 self.uninstall.append(tgt)
598                 try:
599                         os.remove(tgt)
600                 except OSError ,e:
601                         if e.errno!=errno.ENOENT:
602                                 if not getattr(self,'uninstall_error',None):
603                                         self.uninstall_error=True
604                                         Logs.warn('build: some files could not be uninstalled (retry with -vv to list them)')
605                                 if Logs.verbose>1:
606                                         Logs.warn('Could not remove %s (error code %r)'%(e.filename,e.errno))
607                 while tgt:
608                         tgt=os.path.dirname(tgt)
609                         try:
610                                 os.rmdir(tgt)
611                         except OSError:
612                                 break
613         def do_link(self,src,tgt):
614                 try:
615                         if not self.progress_bar:
616                                 Logs.info('- remove %s'%tgt)
617                         os.remove(tgt)
618                 except OSError:
619                         pass
620                 while tgt:
621                         tgt=os.path.dirname(tgt)
622                         try:
623                                 os.rmdir(tgt)
624                         except OSError:
625                                 break
626         def execute(self):
627                 try:
628                         def runnable_status(self):
629                                 return Task.SKIP_ME
630                         setattr(Task.Task,'runnable_status_back',Task.Task.runnable_status)
631                         setattr(Task.Task,'runnable_status',runnable_status)
632                         super(UninstallContext,self).execute()
633                 finally:
634                         setattr(Task.Task,'runnable_status',Task.Task.runnable_status_back)
635 class CleanContext(BuildContext):
636         '''cleans the project'''
637         cmd='clean'
638         def execute(self):
639                 self.restore()
640                 if not self.all_envs:
641                         self.load_envs()
642                 self.recurse([self.run_dir])
643                 try:
644                         self.clean()
645                 finally:
646                         self.store()
647         def clean(self):
648                 Logs.debug('build: clean called')
649                 if self.bldnode!=self.srcnode:
650                         lst=[]
651                         for e in self.all_envs.values():
652                                 lst.extend(self.root.find_or_declare(f)for f in e[CFG_FILES])
653                         for n in self.bldnode.ant_glob('**/*',excl='.lock* *conf_check_*/** config.log c4che/*',quiet=True):
654                                 if n in lst:
655                                         continue
656                                 n.delete()
657                 self.root.children={}
658                 for v in'node_deps task_sigs raw_deps'.split():
659                         setattr(self,v,{})
660 class ListContext(BuildContext):
661         '''lists the targets to execute'''
662         cmd='list'
663         def execute(self):
664                 self.restore()
665                 if not self.all_envs:
666                         self.load_envs()
667                 self.recurse([self.run_dir])
668                 self.pre_build()
669                 self.timer=Utils.Timer()
670                 for g in self.groups:
671                         for tg in g:
672                                 try:
673                                         f=tg.post
674                                 except AttributeError:
675                                         pass
676                                 else:
677                                         f()
678                 try:
679                         self.get_tgen_by_name('')
680                 except Exception:
681                         pass
682                 lst=list(self.task_gen_cache_names.keys())
683                 lst.sort()
684                 for k in lst:
685                         Logs.pprint('GREEN',k)
686 class StepContext(BuildContext):
687         '''executes tasks in a step-by-step fashion, for debugging'''
688         cmd='step'
689         def __init__(self,**kw):
690                 super(StepContext,self).__init__(**kw)
691                 self.files=Options.options.files
692         def compile(self):
693                 if not self.files:
694                         Logs.warn('Add a pattern for the debug build, for example "waf step --files=main.c,app"')
695                         BuildContext.compile(self)
696                         return
697                 targets=None
698                 if self.targets and self.targets!='*':
699                         targets=self.targets.split(',')
700                 for g in self.groups:
701                         for tg in g:
702                                 if targets and tg.name not in targets:
703                                         continue
704                                 try:
705                                         f=tg.post
706                                 except AttributeError:
707                                         pass
708                                 else:
709                                         f()
710                         for pat in self.files.split(','):
711                                 matcher=self.get_matcher(pat)
712                                 for tg in g:
713                                         if isinstance(tg,Task.TaskBase):
714                                                 lst=[tg]
715                                         else:
716                                                 lst=tg.tasks
717                                         for tsk in lst:
718                                                 do_exec=False
719                                                 for node in getattr(tsk,'inputs',[]):
720                                                         if matcher(node,output=False):
721                                                                 do_exec=True
722                                                                 break
723                                                 for node in getattr(tsk,'outputs',[]):
724                                                         if matcher(node,output=True):
725                                                                 do_exec=True
726                                                                 break
727                                                 if do_exec:
728                                                         ret=tsk.run()
729                                                         Logs.info('%s -> exit %r'%(str(tsk),ret))
730         def get_matcher(self,pat):
731                 inn=True
732                 out=True
733                 if pat.startswith('in:'):
734                         out=False
735                         pat=pat.replace('in:','')
736                 elif pat.startswith('out:'):
737                         inn=False
738                         pat=pat.replace('out:','')
739                 anode=self.root.find_node(pat)
740                 pattern=None
741                 if not anode:
742                         if not pat.startswith('^'):
743                                 pat='^.+?%s'%pat
744                         if not pat.endswith('$'):
745                                 pat='%s$'%pat
746                         pattern=re.compile(pat)
747                 def match(node,output):
748                         if output==True and not out:
749                                 return False
750                         if output==False and not inn:
751                                 return False
752                         if anode:
753                                 return anode==node
754                         else:
755                                 return pattern.match(node.abspath())
756                 return match
757 BuildContext.store=Utils.nogc(BuildContext.store)
758 BuildContext.restore=Utils.nogc(BuildContext.restore)