src/aubiopitch~.c: refix aubiopitch_tilde_del
[pd-aubio.git] / waflib / Context.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,imp,sys
6 from waflib import Utils,Errors,Logs
7 import waflib.Node
8 HEXVERSION=0x1070d00
9 WAFVERSION="1.7.13"
10 WAFREVISION="daa91dba4b881d86bc25eec90a3745ebaeece835"
11 ABI=98
12 DBFILE='.wafpickle-%s-%d-%d'%(sys.platform,sys.hexversion,ABI)
13 APPNAME='APPNAME'
14 VERSION='VERSION'
15 TOP='top'
16 OUT='out'
17 WSCRIPT_FILE='wscript'
18 launch_dir=''
19 run_dir=''
20 top_dir=''
21 out_dir=''
22 waf_dir=''
23 local_repo=''
24 remote_repo='http://waf.googlecode.com/git/'
25 remote_locs=['waflib/extras','waflib/Tools']
26 g_module=None
27 STDOUT=1
28 STDERR=-1
29 BOTH=0
30 classes=[]
31 def create_context(cmd_name,*k,**kw):
32         global classes
33         for x in classes:
34                 if x.cmd==cmd_name:
35                         return x(*k,**kw)
36         ctx=Context(*k,**kw)
37         ctx.fun=cmd_name
38         return ctx
39 class store_context(type):
40         def __init__(cls,name,bases,dict):
41                 super(store_context,cls).__init__(name,bases,dict)
42                 name=cls.__name__
43                 if name=='ctx'or name=='Context':
44                         return
45                 try:
46                         cls.cmd
47                 except AttributeError:
48                         raise Errors.WafError('Missing command for the context class %r (cmd)'%name)
49                 if not getattr(cls,'fun',None):
50                         cls.fun=cls.cmd
51                 global classes
52                 classes.insert(0,cls)
53 ctx=store_context('ctx',(object,),{})
54 class Context(ctx):
55         errors=Errors
56         tools={}
57         def __init__(self,**kw):
58                 try:
59                         rd=kw['run_dir']
60                 except KeyError:
61                         global run_dir
62                         rd=run_dir
63                 class node_class(waflib.Node.Node):
64                         pass
65                 self.node_class=node_class
66                 self.node_class.__module__="waflib.Node"
67                 self.node_class.__name__="Nod3"
68                 self.node_class.ctx=self
69                 self.root=self.node_class('',None)
70                 self.cur_script=None
71                 self.path=self.root.find_dir(rd)
72                 self.stack_path=[]
73                 self.exec_dict={'ctx':self,'conf':self,'bld':self,'opt':self}
74                 self.logger=None
75         def __hash__(self):
76                 return id(self)
77         def load(self,tool_list,*k,**kw):
78                 tools=Utils.to_list(tool_list)
79                 path=Utils.to_list(kw.get('tooldir',''))
80                 for t in tools:
81                         module=load_tool(t,path)
82                         fun=getattr(module,kw.get('name',self.fun),None)
83                         if fun:
84                                 fun(self)
85         def execute(self):
86                 global g_module
87                 self.recurse([os.path.dirname(g_module.root_path)])
88         def pre_recurse(self,node):
89                 self.stack_path.append(self.cur_script)
90                 self.cur_script=node
91                 self.path=node.parent
92         def post_recurse(self,node):
93                 self.cur_script=self.stack_path.pop()
94                 if self.cur_script:
95                         self.path=self.cur_script.parent
96         def recurse(self,dirs,name=None,mandatory=True,once=True):
97                 try:
98                         cache=self.recurse_cache
99                 except AttributeError:
100                         cache=self.recurse_cache={}
101                 for d in Utils.to_list(dirs):
102                         if not os.path.isabs(d):
103                                 d=os.path.join(self.path.abspath(),d)
104                         WSCRIPT=os.path.join(d,WSCRIPT_FILE)
105                         WSCRIPT_FUN=WSCRIPT+'_'+(name or self.fun)
106                         node=self.root.find_node(WSCRIPT_FUN)
107                         if node and(not once or node not in cache):
108                                 cache[node]=True
109                                 self.pre_recurse(node)
110                                 try:
111                                         function_code=node.read('rU')
112                                         exec(compile(function_code,node.abspath(),'exec'),self.exec_dict)
113                                 finally:
114                                         self.post_recurse(node)
115                         elif not node:
116                                 node=self.root.find_node(WSCRIPT)
117                                 tup=(node,name or self.fun)
118                                 if node and(not once or tup not in cache):
119                                         cache[tup]=True
120                                         self.pre_recurse(node)
121                                         try:
122                                                 wscript_module=load_module(node.abspath())
123                                                 user_function=getattr(wscript_module,(name or self.fun),None)
124                                                 if not user_function:
125                                                         if not mandatory:
126                                                                 continue
127                                                         raise Errors.WafError('No function %s defined in %s'%(name or self.fun,node.abspath()))
128                                                 user_function(self)
129                                         finally:
130                                                 self.post_recurse(node)
131                                 elif not node:
132                                         if not mandatory:
133                                                 continue
134                                         raise Errors.WafError('No wscript file in directory %s'%d)
135         def exec_command(self,cmd,**kw):
136                 subprocess=Utils.subprocess
137                 kw['shell']=isinstance(cmd,str)
138                 Logs.debug('runner: %r'%cmd)
139                 Logs.debug('runner_env: kw=%s'%kw)
140                 if self.logger:
141                         self.logger.info(cmd)
142                 if'stdout'not in kw:
143                         kw['stdout']=subprocess.PIPE
144                 if'stderr'not in kw:
145                         kw['stderr']=subprocess.PIPE
146                 try:
147                         if kw['stdout']or kw['stderr']:
148                                 p=subprocess.Popen(cmd,**kw)
149                                 (out,err)=p.communicate()
150                                 ret=p.returncode
151                         else:
152                                 out,err=(None,None)
153                                 ret=subprocess.Popen(cmd,**kw).wait()
154                 except Exception ,e:
155                         raise Errors.WafError('Execution failure: %s'%str(e),ex=e)
156                 if out:
157                         if not isinstance(out,str):
158                                 out=out.decode(sys.stdout.encoding or'iso8859-1')
159                         if self.logger:
160                                 self.logger.debug('out: %s'%out)
161                         else:
162                                 sys.stdout.write(out)
163                 if err:
164                         if not isinstance(err,str):
165                                 err=err.decode(sys.stdout.encoding or'iso8859-1')
166                         if self.logger:
167                                 self.logger.error('err: %s'%err)
168                         else:
169                                 sys.stderr.write(err)
170                 return ret
171         def cmd_and_log(self,cmd,**kw):
172                 subprocess=Utils.subprocess
173                 kw['shell']=isinstance(cmd,str)
174                 Logs.debug('runner: %r'%cmd)
175                 if'quiet'in kw:
176                         quiet=kw['quiet']
177                         del kw['quiet']
178                 else:
179                         quiet=None
180                 if'output'in kw:
181                         to_ret=kw['output']
182                         del kw['output']
183                 else:
184                         to_ret=STDOUT
185                 kw['stdout']=kw['stderr']=subprocess.PIPE
186                 if quiet is None:
187                         self.to_log(cmd)
188                 try:
189                         p=subprocess.Popen(cmd,**kw)
190                         (out,err)=p.communicate()
191                 except Exception ,e:
192                         raise Errors.WafError('Execution failure: %s'%str(e),ex=e)
193                 if not isinstance(out,str):
194                         out=out.decode(sys.stdout.encoding or'iso8859-1')
195                 if not isinstance(err,str):
196                         err=err.decode(sys.stdout.encoding or'iso8859-1')
197                 if out and quiet!=STDOUT and quiet!=BOTH:
198                         self.to_log('out: %s'%out)
199                 if err and quiet!=STDERR and quiet!=BOTH:
200                         self.to_log('err: %s'%err)
201                 if p.returncode:
202                         e=Errors.WafError('Command %r returned %r'%(cmd,p.returncode))
203                         e.returncode=p.returncode
204                         e.stderr=err
205                         e.stdout=out
206                         raise e
207                 if to_ret==BOTH:
208                         return(out,err)
209                 elif to_ret==STDERR:
210                         return err
211                 return out
212         def fatal(self,msg,ex=None):
213                 if self.logger:
214                         self.logger.info('from %s: %s'%(self.path.abspath(),msg))
215                 try:
216                         msg='%s\n(complete log in %s)'%(msg,self.logger.handlers[0].baseFilename)
217                 except Exception:
218                         pass
219                 raise self.errors.ConfigurationError(msg,ex=ex)
220         def to_log(self,msg):
221                 if not msg:
222                         return
223                 if self.logger:
224                         self.logger.info(msg)
225                 else:
226                         sys.stderr.write(str(msg))
227                         sys.stderr.flush()
228         def msg(self,msg,result,color=None):
229                 self.start_msg(msg)
230                 if not isinstance(color,str):
231                         color=result and'GREEN'or'YELLOW'
232                 self.end_msg(result,color)
233         def start_msg(self,msg):
234                 try:
235                         if self.in_msg:
236                                 self.in_msg+=1
237                                 return
238                 except AttributeError:
239                         self.in_msg=0
240                 self.in_msg+=1
241                 try:
242                         self.line_just=max(self.line_just,len(msg))
243                 except AttributeError:
244                         self.line_just=max(40,len(msg))
245                 for x in(self.line_just*'-',msg):
246                         self.to_log(x)
247                 Logs.pprint('NORMAL',"%s :"%msg.ljust(self.line_just),sep='')
248         def end_msg(self,result,color=None):
249                 self.in_msg-=1
250                 if self.in_msg:
251                         return
252                 defcolor='GREEN'
253                 if result==True:
254                         msg='ok'
255                 elif result==False:
256                         msg='not found'
257                         defcolor='YELLOW'
258                 else:
259                         msg=str(result)
260                 self.to_log(msg)
261                 Logs.pprint(color or defcolor,msg)
262         def load_special_tools(self,var,ban=[]):
263                 global waf_dir
264                 lst=self.root.find_node(waf_dir).find_node('waflib/extras').ant_glob(var)
265                 for x in lst:
266                         if not x.name in ban:
267                                 load_tool(x.name.replace('.py',''))
268 cache_modules={}
269 def load_module(path):
270         try:
271                 return cache_modules[path]
272         except KeyError:
273                 pass
274         module=imp.new_module(WSCRIPT_FILE)
275         try:
276                 code=Utils.readf(path,m='rU')
277         except(IOError,OSError):
278                 raise Errors.WafError('Could not read the file %r'%path)
279         module_dir=os.path.dirname(path)
280         sys.path.insert(0,module_dir)
281         exec(compile(code,path,'exec'),module.__dict__)
282         sys.path.remove(module_dir)
283         cache_modules[path]=module
284         return module
285 def load_tool(tool,tooldir=None):
286         if tool=='java':
287                 tool='javaw'
288         elif tool=='compiler_cc':
289                 tool='compiler_c'
290         else:
291                 tool=tool.replace('++','xx')
292         if tooldir:
293                 assert isinstance(tooldir,list)
294                 sys.path=tooldir+sys.path
295                 try:
296                         __import__(tool)
297                         ret=sys.modules[tool]
298                         Context.tools[tool]=ret
299                         return ret
300                 finally:
301                         for d in tooldir:
302                                 sys.path.remove(d)
303         else:
304                 global waf_dir
305                 try:
306                         os.stat(os.path.join(waf_dir,'waflib','extras',tool+'.py'))
307                 except OSError:
308                         try:
309                                 os.stat(os.path.join(waf_dir,'waflib','Tools',tool+'.py'))
310                         except OSError:
311                                 d=tool
312                         else:
313                                 d='waflib.Tools.%s'%tool
314                 else:
315                         d='waflib.extras.%s'%tool
316                 __import__(d)
317                 ret=sys.modules[d]
318                 Context.tools[tool]=ret
319                 return ret