src/aubiopitch~.c: refix aubiopitch_tilde_del
[pd-aubio.git] / waflib / Scripting.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,shlex,shutil,traceback,errno,sys,stat
6 from waflib import Utils,Configure,Logs,Options,ConfigSet,Context,Errors,Build,Node
7 build_dir_override=None
8 no_climb_commands=['configure']
9 default_cmd="build"
10 def waf_entry_point(current_directory,version,wafdir):
11         Logs.init_log()
12         if Context.WAFVERSION!=version:
13                 Logs.error('Waf script %r and library %r do not match (directory %r)'%(version,Context.WAFVERSION,wafdir))
14                 sys.exit(1)
15         if'--version'in sys.argv:
16                 Context.run_dir=current_directory
17                 ctx=Context.create_context('options')
18                 ctx.curdir=current_directory
19                 ctx.parse_args()
20                 sys.exit(0)
21         Context.waf_dir=wafdir
22         Context.launch_dir=current_directory
23         no_climb=os.environ.get('NOCLIMB',None)
24         if not no_climb:
25                 for k in no_climb_commands:
26                         if k in sys.argv:
27                                 no_climb=True
28                                 break
29         cur=current_directory
30         while cur:
31                 lst=os.listdir(cur)
32                 if Options.lockfile in lst:
33                         env=ConfigSet.ConfigSet()
34                         try:
35                                 env.load(os.path.join(cur,Options.lockfile))
36                                 ino=os.stat(cur)[stat.ST_INO]
37                         except Exception:
38                                 pass
39                         else:
40                                 for x in[env.run_dir,env.top_dir,env.out_dir]:
41                                         if Utils.is_win32:
42                                                 if cur==x:
43                                                         load=True
44                                                         break
45                                         else:
46                                                 try:
47                                                         ino2=os.stat(x)[stat.ST_INO]
48                                                 except OSError:
49                                                         pass
50                                                 else:
51                                                         if ino==ino2:
52                                                                 load=True
53                                                                 break
54                                 else:
55                                         Logs.warn('invalid lock file in %s'%cur)
56                                         load=False
57                                 if load:
58                                         Context.run_dir=env.run_dir
59                                         Context.top_dir=env.top_dir
60                                         Context.out_dir=env.out_dir
61                                         break
62                 if not Context.run_dir:
63                         if Context.WSCRIPT_FILE in lst:
64                                 Context.run_dir=cur
65                 next=os.path.dirname(cur)
66                 if next==cur:
67                         break
68                 cur=next
69                 if no_climb:
70                         break
71         if not Context.run_dir:
72                 if'-h'in sys.argv or'--help'in sys.argv:
73                         Logs.warn('No wscript file found: the help message may be incomplete')
74                         Context.run_dir=current_directory
75                         ctx=Context.create_context('options')
76                         ctx.curdir=current_directory
77                         ctx.parse_args()
78                         sys.exit(0)
79                 Logs.error('Waf: Run from a directory containing a file named %r'%Context.WSCRIPT_FILE)
80                 sys.exit(1)
81         try:
82                 os.chdir(Context.run_dir)
83         except OSError:
84                 Logs.error('Waf: The folder %r is unreadable'%Context.run_dir)
85                 sys.exit(1)
86         try:
87                 set_main_module(Context.run_dir+os.sep+Context.WSCRIPT_FILE)
88         except Errors.WafError ,e:
89                 Logs.pprint('RED',e.verbose_msg)
90                 Logs.error(str(e))
91                 sys.exit(1)
92         except Exception ,e:
93                 Logs.error('Waf: The wscript in %r is unreadable'%Context.run_dir,e)
94                 traceback.print_exc(file=sys.stdout)
95                 sys.exit(2)
96         try:
97                 run_commands()
98         except Errors.WafError ,e:
99                 if Logs.verbose>1:
100                         Logs.pprint('RED',e.verbose_msg)
101                 Logs.error(e.msg)
102                 sys.exit(1)
103         except SystemExit:
104                 raise
105         except Exception ,e:
106                 traceback.print_exc(file=sys.stdout)
107                 sys.exit(2)
108         except KeyboardInterrupt:
109                 Logs.pprint('RED','Interrupted')
110                 sys.exit(68)
111 def set_main_module(file_path):
112         Context.g_module=Context.load_module(file_path)
113         Context.g_module.root_path=file_path
114         def set_def(obj):
115                 name=obj.__name__
116                 if not name in Context.g_module.__dict__:
117                         setattr(Context.g_module,name,obj)
118         for k in[update,dist,distclean,distcheck,update]:
119                 set_def(k)
120         if not'init'in Context.g_module.__dict__:
121                 Context.g_module.init=Utils.nada
122         if not'shutdown'in Context.g_module.__dict__:
123                 Context.g_module.shutdown=Utils.nada
124         if not'options'in Context.g_module.__dict__:
125                 Context.g_module.options=Utils.nada
126 def parse_options():
127         Context.create_context('options').execute()
128         if not Options.commands:
129                 Options.commands=[default_cmd]
130         Options.commands=[x for x in Options.commands if x!='options']
131         Logs.verbose=Options.options.verbose
132         Logs.init_log()
133         if Options.options.zones:
134                 Logs.zones=Options.options.zones.split(',')
135                 if not Logs.verbose:
136                         Logs.verbose=1
137         elif Logs.verbose>0:
138                 Logs.zones=['runner']
139         if Logs.verbose>2:
140                 Logs.zones=['*']
141 def run_command(cmd_name):
142         ctx=Context.create_context(cmd_name)
143         ctx.log_timer=Utils.Timer()
144         ctx.options=Options.options
145         ctx.cmd=cmd_name
146         ctx.execute()
147         return ctx
148 def run_commands():
149         parse_options()
150         run_command('init')
151         while Options.commands:
152                 cmd_name=Options.commands.pop(0)
153                 ctx=run_command(cmd_name)
154                 Logs.info('%r finished successfully (%s)'%(cmd_name,str(ctx.log_timer)))
155         run_command('shutdown')
156 def _can_distclean(name):
157         for k in'.o .moc .exe'.split():
158                 if name.endswith(k):
159                         return True
160         return False
161 def distclean_dir(dirname):
162         for(root,dirs,files)in os.walk(dirname):
163                 for f in files:
164                         if _can_distclean(f):
165                                 fname=root+os.sep+f
166                                 try:
167                                         os.remove(fname)
168                                 except OSError:
169                                         Logs.warn('Could not remove %r'%fname)
170         for x in[Context.DBFILE,'config.log']:
171                 try:
172                         os.remove(x)
173                 except OSError:
174                         pass
175         try:
176                 shutil.rmtree('c4che')
177         except OSError:
178                 pass
179 def distclean(ctx):
180         '''removes the build directory'''
181         lst=os.listdir('.')
182         for f in lst:
183                 if f==Options.lockfile:
184                         try:
185                                 proj=ConfigSet.ConfigSet(f)
186                         except IOError:
187                                 Logs.warn('Could not read %r'%f)
188                                 continue
189                         if proj['out_dir']!=proj['top_dir']:
190                                 try:
191                                         shutil.rmtree(proj['out_dir'])
192                                 except IOError:
193                                         pass
194                                 except OSError ,e:
195                                         if e.errno!=errno.ENOENT:
196                                                 Logs.warn('project %r cannot be removed'%proj[Context.OUT])
197                         else:
198                                 distclean_dir(proj['out_dir'])
199                         for k in(proj['out_dir'],proj['top_dir'],proj['run_dir']):
200                                 try:
201                                         os.remove(os.path.join(k,Options.lockfile))
202                                 except OSError ,e:
203                                         if e.errno!=errno.ENOENT:
204                                                 Logs.warn('file %r cannot be removed'%f)
205                 if f.startswith('.waf')and not Options.commands:
206                         shutil.rmtree(f,ignore_errors=True)
207 class Dist(Context.Context):
208         '''creates an archive containing the project source code'''
209         cmd='dist'
210         fun='dist'
211         algo='tar.bz2'
212         ext_algo={}
213         def execute(self):
214                 self.recurse([os.path.dirname(Context.g_module.root_path)])
215                 self.archive()
216         def archive(self):
217                 import tarfile
218                 arch_name=self.get_arch_name()
219                 try:
220                         self.base_path
221                 except AttributeError:
222                         self.base_path=self.path
223                 node=self.base_path.make_node(arch_name)
224                 try:
225                         node.delete()
226                 except Exception:
227                         pass
228                 files=self.get_files()
229                 if self.algo.startswith('tar.'):
230                         tar=tarfile.open(arch_name,'w:'+self.algo.replace('tar.',''))
231                         for x in files:
232                                 self.add_tar_file(x,tar)
233                         tar.close()
234                 elif self.algo=='zip':
235                         import zipfile
236                         zip=zipfile.ZipFile(arch_name,'w',compression=zipfile.ZIP_DEFLATED)
237                         for x in files:
238                                 archive_name=self.get_base_name()+'/'+x.path_from(self.base_path)
239                                 zip.write(x.abspath(),archive_name,zipfile.ZIP_DEFLATED)
240                         zip.close()
241                 else:
242                         self.fatal('Valid algo types are tar.bz2, tar.gz or zip')
243                 try:
244                         from hashlib import sha1 as sha
245                 except ImportError:
246                         from sha import sha
247                 try:
248                         digest=" (sha=%r)"%sha(node.read()).hexdigest()
249                 except Exception:
250                         digest=''
251                 Logs.info('New archive created: %s%s'%(self.arch_name,digest))
252         def get_tar_path(self,node):
253                 return node.abspath()
254         def add_tar_file(self,x,tar):
255                 p=self.get_tar_path(x)
256                 tinfo=tar.gettarinfo(name=p,arcname=self.get_tar_prefix()+'/'+x.path_from(self.base_path))
257                 tinfo.uid=0
258                 tinfo.gid=0
259                 tinfo.uname='root'
260                 tinfo.gname='root'
261                 fu=None
262                 try:
263                         fu=open(p,'rb')
264                         tar.addfile(tinfo,fileobj=fu)
265                 finally:
266                         if fu:
267                                 fu.close()
268         def get_tar_prefix(self):
269                 try:
270                         return self.tar_prefix
271                 except AttributeError:
272                         return self.get_base_name()
273         def get_arch_name(self):
274                 try:
275                         self.arch_name
276                 except AttributeError:
277                         self.arch_name=self.get_base_name()+'.'+self.ext_algo.get(self.algo,self.algo)
278                 return self.arch_name
279         def get_base_name(self):
280                 try:
281                         self.base_name
282                 except AttributeError:
283                         appname=getattr(Context.g_module,Context.APPNAME,'noname')
284                         version=getattr(Context.g_module,Context.VERSION,'1.0')
285                         self.base_name=appname+'-'+version
286                 return self.base_name
287         def get_excl(self):
288                 try:
289                         return self.excl
290                 except AttributeError:
291                         self.excl=Node.exclude_regs+' **/waf-1.7.* **/.waf-1.7* **/waf3-1.7.* **/.waf3-1.7* **/*~ **/*.rej **/*.orig **/*.pyc **/*.pyo **/*.bak **/*.swp **/.lock-w*'
292                         nd=self.root.find_node(Context.out_dir)
293                         if nd:
294                                 self.excl+=' '+nd.path_from(self.base_path)
295                         return self.excl
296         def get_files(self):
297                 try:
298                         files=self.files
299                 except AttributeError:
300                         files=self.base_path.ant_glob('**/*',excl=self.get_excl())
301                 return files
302 def dist(ctx):
303         '''makes a tarball for redistributing the sources'''
304         pass
305 class DistCheck(Dist):
306         fun='distcheck'
307         cmd='distcheck'
308         def execute(self):
309                 self.recurse([os.path.dirname(Context.g_module.root_path)])
310                 self.archive()
311                 self.check()
312         def check(self):
313                 import tempfile,tarfile
314                 t=None
315                 try:
316                         t=tarfile.open(self.get_arch_name())
317                         for x in t:
318                                 t.extract(x)
319                 finally:
320                         if t:
321                                 t.close()
322                 cfg=[]
323                 if Options.options.distcheck_args:
324                         cfg=shlex.split(Options.options.distcheck_args)
325                 else:
326                         cfg=[x for x in sys.argv if x.startswith('-')]
327                 instdir=tempfile.mkdtemp('.inst',self.get_base_name())
328                 ret=Utils.subprocess.Popen([sys.executable,sys.argv[0],'configure','install','uninstall','--destdir='+instdir]+cfg,cwd=self.get_base_name()).wait()
329                 if ret:
330                         raise Errors.WafError('distcheck failed with code %i'%ret)
331                 if os.path.exists(instdir):
332                         raise Errors.WafError('distcheck succeeded, but files were left in %s'%instdir)
333                 shutil.rmtree(self.get_base_name())
334 def distcheck(ctx):
335         '''checks if the project compiles (tarball from 'dist')'''
336         pass
337 def update(ctx):
338         '''updates the plugins from the *waflib/extras* directory'''
339         lst=Options.options.files.split(',')
340         if not lst:
341                 lst=[x for x in Utils.listdir(Context.waf_dir+'/waflib/extras')if x.endswith('.py')]
342         for x in lst:
343                 tool=x.replace('.py','')
344                 try:
345                         Configure.download_tool(tool,force=True,ctx=ctx)
346                 except Errors.WafError:
347                         Logs.error('Could not find the tool %s in the remote repository'%x)
348 def autoconfigure(execute_method):
349         def execute(self):
350                 if not Configure.autoconfig:
351                         return execute_method(self)
352                 env=ConfigSet.ConfigSet()
353                 do_config=False
354                 try:
355                         env.load(os.path.join(Context.top_dir,Options.lockfile))
356                 except Exception:
357                         Logs.warn('Configuring the project')
358                         do_config=True
359                 else:
360                         if env.run_dir!=Context.run_dir:
361                                 do_config=True
362                         else:
363                                 h=0
364                                 for f in env['files']:
365                                         h=hash((h,Utils.readf(f,'rb')))
366                                 do_config=h!=env.hash
367                 if do_config:
368                         Options.commands.insert(0,self.cmd)
369                         Options.commands.insert(0,'configure')
370                         return
371                 return execute_method(self)
372         return execute
373 Build.BuildContext.execute=autoconfigure(Build.BuildContext.execute)