src/aubiopitch~.c: refix aubiopitch_tilde_del
[pd-aubio.git] / waflib / TaskGen.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 copy,re,os
6 from waflib import Task,Utils,Logs,Errors,ConfigSet,Node
7 feats=Utils.defaultdict(set)
8 class task_gen(object):
9         mappings={}
10         prec=Utils.defaultdict(list)
11         def __init__(self,*k,**kw):
12                 self.source=''
13                 self.target=''
14                 self.meths=[]
15                 self.prec=Utils.defaultdict(list)
16                 self.mappings={}
17                 self.features=[]
18                 self.tasks=[]
19                 if not'bld'in kw:
20                         self.env=ConfigSet.ConfigSet()
21                         self.idx=0
22                         self.path=None
23                 else:
24                         self.bld=kw['bld']
25                         self.env=self.bld.env.derive()
26                         self.path=self.bld.path
27                         try:
28                                 self.idx=self.bld.idx[id(self.path)]=self.bld.idx.get(id(self.path),0)+1
29                         except AttributeError:
30                                 self.bld.idx={}
31                                 self.idx=self.bld.idx[id(self.path)]=1
32                 for key,val in kw.items():
33                         setattr(self,key,val)
34         def __str__(self):
35                 return"<task_gen %r declared in %s>"%(self.name,self.path.abspath())
36         def __repr__(self):
37                 lst=[]
38                 for x in self.__dict__.keys():
39                         if x not in['env','bld','compiled_tasks','tasks']:
40                                 lst.append("%s=%s"%(x,repr(getattr(self,x))))
41                 return"bld(%s) in %s"%(", ".join(lst),self.path.abspath())
42         def get_name(self):
43                 try:
44                         return self._name
45                 except AttributeError:
46                         if isinstance(self.target,list):
47                                 lst=[str(x)for x in self.target]
48                                 name=self._name=','.join(lst)
49                         else:
50                                 name=self._name=str(self.target)
51                         return name
52         def set_name(self,name):
53                 self._name=name
54         name=property(get_name,set_name)
55         def to_list(self,val):
56                 if isinstance(val,str):return val.split()
57                 else:return val
58         def post(self):
59                 if getattr(self,'posted',None):
60                         return False
61                 self.posted=True
62                 keys=set(self.meths)
63                 self.features=Utils.to_list(self.features)
64                 for x in self.features+['*']:
65                         st=feats[x]
66                         if not st:
67                                 if not x in Task.classes:
68                                         Logs.warn('feature %r does not exist - bind at least one method to it'%x)
69                         keys.update(list(st))
70                 prec={}
71                 prec_tbl=self.prec or task_gen.prec
72                 for x in prec_tbl:
73                         if x in keys:
74                                 prec[x]=prec_tbl[x]
75                 tmp=[]
76                 for a in keys:
77                         for x in prec.values():
78                                 if a in x:break
79                         else:
80                                 tmp.append(a)
81                 tmp.sort()
82                 out=[]
83                 while tmp:
84                         e=tmp.pop()
85                         if e in keys:out.append(e)
86                         try:
87                                 nlst=prec[e]
88                         except KeyError:
89                                 pass
90                         else:
91                                 del prec[e]
92                                 for x in nlst:
93                                         for y in prec:
94                                                 if x in prec[y]:
95                                                         break
96                                         else:
97                                                 tmp.append(x)
98                 if prec:
99                         raise Errors.WafError('Cycle detected in the method execution %r'%prec)
100                 out.reverse()
101                 self.meths=out
102                 Logs.debug('task_gen: posting %s %d'%(self,id(self)))
103                 for x in out:
104                         try:
105                                 v=getattr(self,x)
106                         except AttributeError:
107                                 raise Errors.WafError('%r is not a valid task generator method'%x)
108                         Logs.debug('task_gen: -> %s (%d)'%(x,id(self)))
109                         v()
110                 Logs.debug('task_gen: posted %s'%self.name)
111                 return True
112         def get_hook(self,node):
113                 name=node.name
114                 for k in self.mappings:
115                         if name.endswith(k):
116                                 return self.mappings[k]
117                 for k in task_gen.mappings:
118                         if name.endswith(k):
119                                 return task_gen.mappings[k]
120                 raise Errors.WafError("File %r has no mapping in %r (did you forget to load a waf tool?)"%(node,task_gen.mappings.keys()))
121         def create_task(self,name,src=None,tgt=None):
122                 task=Task.classes[name](env=self.env.derive(),generator=self)
123                 if src:
124                         task.set_inputs(src)
125                 if tgt:
126                         task.set_outputs(tgt)
127                 self.tasks.append(task)
128                 return task
129         def clone(self,env):
130                 newobj=self.bld()
131                 for x in self.__dict__:
132                         if x in['env','bld']:
133                                 continue
134                         elif x in['path','features']:
135                                 setattr(newobj,x,getattr(self,x))
136                         else:
137                                 setattr(newobj,x,copy.copy(getattr(self,x)))
138                 newobj.posted=False
139                 if isinstance(env,str):
140                         newobj.env=self.bld.all_envs[env].derive()
141                 else:
142                         newobj.env=env.derive()
143                 return newobj
144 def declare_chain(name='',rule=None,reentrant=None,color='BLUE',ext_in=[],ext_out=[],before=[],after=[],decider=None,scan=None,install_path=None,shell=False):
145         ext_in=Utils.to_list(ext_in)
146         ext_out=Utils.to_list(ext_out)
147         if not name:
148                 name=rule
149         cls=Task.task_factory(name,rule,color=color,ext_in=ext_in,ext_out=ext_out,before=before,after=after,scan=scan,shell=shell)
150         def x_file(self,node):
151                 ext=decider and decider(self,node)or cls.ext_out
152                 if ext_in:
153                         _ext_in=ext_in[0]
154                 tsk=self.create_task(name,node)
155                 cnt=0
156                 keys=list(self.mappings.keys())+list(self.__class__.mappings.keys())
157                 for x in ext:
158                         k=node.change_ext(x,ext_in=_ext_in)
159                         tsk.outputs.append(k)
160                         if reentrant!=None:
161                                 if cnt<int(reentrant):
162                                         self.source.append(k)
163                         else:
164                                 for y in keys:
165                                         if k.name.endswith(y):
166                                                 self.source.append(k)
167                                                 break
168                         cnt+=1
169                 if install_path:
170                         self.bld.install_files(install_path,tsk.outputs)
171                 return tsk
172         for x in cls.ext_in:
173                 task_gen.mappings[x]=x_file
174         return x_file
175 def taskgen_method(func):
176         setattr(task_gen,func.__name__,func)
177         return func
178 def feature(*k):
179         def deco(func):
180                 setattr(task_gen,func.__name__,func)
181                 for name in k:
182                         feats[name].update([func.__name__])
183                 return func
184         return deco
185 def before_method(*k):
186         def deco(func):
187                 setattr(task_gen,func.__name__,func)
188                 for fun_name in k:
189                         if not func.__name__ in task_gen.prec[fun_name]:
190                                 task_gen.prec[fun_name].append(func.__name__)
191                 return func
192         return deco
193 before=before_method
194 def after_method(*k):
195         def deco(func):
196                 setattr(task_gen,func.__name__,func)
197                 for fun_name in k:
198                         if not fun_name in task_gen.prec[func.__name__]:
199                                 task_gen.prec[func.__name__].append(fun_name)
200                 return func
201         return deco
202 after=after_method
203 def extension(*k):
204         def deco(func):
205                 setattr(task_gen,func.__name__,func)
206                 for x in k:
207                         task_gen.mappings[x]=func
208                 return func
209         return deco
210 @taskgen_method
211 def to_nodes(self,lst,path=None):
212         tmp=[]
213         path=path or self.path
214         find=path.find_resource
215         if isinstance(lst,self.path.__class__):
216                 lst=[lst]
217         for x in Utils.to_list(lst):
218                 if isinstance(x,str):
219                         node=find(x)
220                 else:
221                         node=x
222                 if not node:
223                         raise Errors.WafError("source not found: %r in %r"%(x,self))
224                 tmp.append(node)
225         return tmp
226 @feature('*')
227 def process_source(self):
228         self.source=self.to_nodes(getattr(self,'source',[]))
229         for node in self.source:
230                 self.get_hook(node)(self,node)
231 @feature('*')
232 @before_method('process_source')
233 def process_rule(self):
234         if not getattr(self,'rule',None):
235                 return
236         name=str(getattr(self,'name',None)or self.target or getattr(self.rule,'__name__',self.rule))
237         try:
238                 cache=self.bld.cache_rule_attr
239         except AttributeError:
240                 cache=self.bld.cache_rule_attr={}
241         cls=None
242         if getattr(self,'cache_rule','True'):
243                 try:
244                         cls=cache[(name,self.rule)]
245                 except KeyError:
246                         pass
247         if not cls:
248                 cls=Task.task_factory(name,self.rule,getattr(self,'vars',[]),shell=getattr(self,'shell',True),color=getattr(self,'color','BLUE'),scan=getattr(self,'scan',None))
249                 if getattr(self,'scan',None):
250                         cls.scan=self.scan
251                 elif getattr(self,'deps',None):
252                         def scan(self):
253                                 nodes=[]
254                                 for x in self.generator.to_list(getattr(self.generator,'deps',None)):
255                                         node=self.generator.path.find_resource(x)
256                                         if not node:
257                                                 self.generator.bld.fatal('Could not find %r (was it declared?)'%x)
258                                         nodes.append(node)
259                                 return[nodes,[]]
260                         cls.scan=scan
261                 if getattr(self,'update_outputs',None):
262                         Task.update_outputs(cls)
263                 if getattr(self,'always',None):
264                         Task.always_run(cls)
265                 for x in['after','before','ext_in','ext_out']:
266                         setattr(cls,x,getattr(self,x,[]))
267                 if getattr(self,'cache_rule','True'):
268                         cache[(name,self.rule)]=cls
269         tsk=self.create_task(name)
270         if getattr(self,'target',None):
271                 if isinstance(self.target,str):
272                         self.target=self.target.split()
273                 if not isinstance(self.target,list):
274                         self.target=[self.target]
275                 for x in self.target:
276                         if isinstance(x,str):
277                                 tsk.outputs.append(self.path.find_or_declare(x))
278                         else:
279                                 x.parent.mkdir()
280                                 tsk.outputs.append(x)
281                 if getattr(self,'install_path',None):
282                         self.bld.install_files(self.install_path,tsk.outputs)
283         if getattr(self,'source',None):
284                 tsk.inputs=self.to_nodes(self.source)
285                 self.source=[]
286         if getattr(self,'cwd',None):
287                 tsk.cwd=self.cwd
288 @feature('seq')
289 def sequence_order(self):
290         if self.meths and self.meths[-1]!='sequence_order':
291                 self.meths.append('sequence_order')
292                 return
293         if getattr(self,'seq_start',None):
294                 return
295         if getattr(self.bld,'prev',None):
296                 self.bld.prev.post()
297                 for x in self.bld.prev.tasks:
298                         for y in self.tasks:
299                                 y.set_run_after(x)
300         self.bld.prev=self
301 re_m4=re.compile('@(\w+)@',re.M)
302 class subst_pc(Task.Task):
303         def run(self):
304                 if getattr(self.generator,'is_copy',None):
305                         self.outputs[0].write(self.inputs[0].read('rb'),'wb')
306                         if getattr(self.generator,'chmod',None):
307                                 os.chmod(self.outputs[0].abspath(),self.generator.chmod)
308                         return None
309                 if getattr(self.generator,'fun',None):
310                         self.generator.fun(self)
311                 code=self.inputs[0].read(encoding=getattr(self.generator,'encoding','ISO8859-1'))
312                 if getattr(self.generator,'subst_fun',None):
313                         code=self.generator.subst_fun(self,code)
314                         if code:
315                                 self.outputs[0].write(code,encoding=getattr(self.generator,'encoding','ISO8859-1'))
316                         return
317                 code=code.replace('%','%%')
318                 lst=[]
319                 def repl(match):
320                         g=match.group
321                         if g(1):
322                                 lst.append(g(1))
323                                 return"%%(%s)s"%g(1)
324                         return''
325                 code=re_m4.sub(repl,code)
326                 try:
327                         d=self.generator.dct
328                 except AttributeError:
329                         d={}
330                         for x in lst:
331                                 tmp=getattr(self.generator,x,'')or self.env.get_flat(x)or self.env.get_flat(x.upper())
332                                 d[x]=str(tmp)
333                 code=code%d
334                 self.outputs[0].write(code,encoding=getattr(self.generator,'encoding','ISO8859-1'))
335                 self.generator.bld.raw_deps[self.uid()]=self.dep_vars=lst
336                 try:delattr(self,'cache_sig')
337                 except AttributeError:pass
338                 if getattr(self.generator,'chmod',None):
339                         os.chmod(self.outputs[0].abspath(),self.generator.chmod)
340         def sig_vars(self):
341                 bld=self.generator.bld
342                 env=self.env
343                 upd=self.m.update
344                 if getattr(self.generator,'fun',None):
345                         upd(Utils.h_fun(self.generator.fun))
346                 if getattr(self.generator,'subst_fun',None):
347                         upd(Utils.h_fun(self.generator.subst_fun))
348                 vars=self.generator.bld.raw_deps.get(self.uid(),[])
349                 act_sig=bld.hash_env_vars(env,vars)
350                 upd(act_sig)
351                 lst=[getattr(self.generator,x,'')for x in vars]
352                 upd(Utils.h_list(lst))
353                 return self.m.digest()
354 @extension('.pc.in')
355 def add_pcfile(self,node):
356         tsk=self.create_task('subst_pc',node,node.change_ext('.pc','.pc.in'))
357         self.bld.install_files(getattr(self,'install_path','${LIBDIR}/pkgconfig/'),tsk.outputs)
358 class subst(subst_pc):
359         pass
360 @feature('subst')
361 @before_method('process_source','process_rule')
362 def process_subst(self):
363         src=Utils.to_list(getattr(self,'source',[]))
364         if isinstance(src,Node.Node):
365                 src=[src]
366         tgt=Utils.to_list(getattr(self,'target',[]))
367         if isinstance(tgt,Node.Node):
368                 tgt=[tgt]
369         if len(src)!=len(tgt):
370                 raise Errors.WafError('invalid number of source/target for %r'%self)
371         for x,y in zip(src,tgt):
372                 if not x or not y:
373                         raise Errors.WafError('null source or target for %r'%self)
374                 a,b=None,None
375                 if isinstance(x,str)and isinstance(y,str)and x==y:
376                         a=self.path.find_node(x)
377                         b=self.path.get_bld().make_node(y)
378                         if not os.path.isfile(b.abspath()):
379                                 b.sig=None
380                                 b.parent.mkdir()
381                 else:
382                         if isinstance(x,str):
383                                 a=self.path.find_resource(x)
384                         elif isinstance(x,Node.Node):
385                                 a=x
386                         if isinstance(y,str):
387                                 b=self.path.find_or_declare(y)
388                         elif isinstance(y,Node.Node):
389                                 b=y
390                 if not a:
391                         raise Errors.WafError('cound not find %r for %r'%(x,self))
392                 has_constraints=False
393                 tsk=self.create_task('subst',a,b)
394                 for k in('after','before','ext_in','ext_out'):
395                         val=getattr(self,k,None)
396                         if val:
397                                 has_constraints=True
398                                 setattr(tsk,k,val)
399                 if not has_constraints and b.name.endswith('.h'):
400                         tsk.before=[k for k in('c','cxx')if k in Task.classes]
401                 inst_to=getattr(self,'install_path',None)
402                 if inst_to:
403                         self.bld.install_files(inst_to,b,chmod=getattr(self,'chmod',Utils.O644))
404         self.source=[]