source: waflib/Build.py @ 9e58e78

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

waf, waflib: update to 1.7.13
  • Property mode set to 100644
File size: 20.5 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,re,shutil
6try:
7        import cPickle
8except ImportError:
9        import pickle as cPickle
10from waflib import Runner,TaskGen,Utils,ConfigSet,Task,Logs,Options,Context,Errors
11import waflib.Node
12CACHE_DIR='c4che'
13CACHE_SUFFIX='_cache.py'
14INSTALL=1337
15UNINSTALL=-1337
16SAVED_ATTRS='root node_deps raw_deps task_sigs'.split()
17CFG_FILES='cfg_files'
18POST_AT_ONCE=0
19POST_LAZY=1
20POST_BOTH=2
21class 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[]
426class 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)
486class 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
588class 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)
635class 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,{})
660class 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)
686class 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
757BuildContext.store=Utils.nogc(BuildContext.store)
758BuildContext.restore=Utils.nogc(BuildContext.restore)
Note: See TracBrowser for help on using the repository browser.