← Back to branch summary

~ubuntu-branches/ubuntu/raring/glmark2/raring

« back to all changes in this revision

Viewing changes to waflib/TaskGen.py

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo
  • Date: 2012-08-21 15:38:09 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120821153809-bwux72bat8qp2n5v
Tags: 2012.08-0ubuntu1
https://launchpad.net/bugs/1039736
https://launchpad.net/bugs/842279
* New upstream release 2012.08 (LP: #1039736)
  - Avoid crashing if gl used is not >= 2.0 (LP: #842279)
* Bumping dh compatibility level to v9
* debian/control:
  - Update Standards-Version to 3.9.3.
  - Add libjpeg-dev build dependency.
  - Use libegl1-x11-dev as an build-dep alternative instead of libegl1-dev.
  - Update description of glmark2-data binary package.
* debian/copyright:
  - Refresh copyright based on the current upstrem version
* debian/rules:
  - Clean compiled python code from unpacked waflib/ directory, as
    described in http://wiki.debian.org/UnpackWaf

Show diffs side-by-side

added added

removed removed

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