← Back to branch summary

~voluntatefaber/beat-box/bug952329

« back to all changes in this revision

Viewing changes to .waf-1.6.2-ad4cc42bd7d347f7e283789e711b993f/waflib/Scripting.py

  • Committer: Scott Ringwelski
  • Date: 2011-02-10 21:30:53 UTC
  • Revision ID: sgringwe@mtu.edu-20110210213053-d3c7mnexeref3cwj
sexy icons, sexy waf

Show diffs side-by-side

added added

removed removed

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