source: waflib/Context.py @ 4320679

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+
Last change on this file since 4320679 was c101fe1, checked in by Paul Brossier <piem@piem.org>, 11 years ago

waf, waflib: update to 1.7.13
  • Property mode set to 100644
File size: 8.2 KB
Line 
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
5import os,imp,sys
6from waflib import Utils,Errors,Logs
7import waflib.Node
8HEXVERSION=0x1070d00
9WAFVERSION="1.7.13"
10WAFREVISION="daa91dba4b881d86bc25eec90a3745ebaeece835"
11ABI=98
12DBFILE='.wafpickle-%s-%d-%d'%(sys.platform,sys.hexversion,ABI)
13APPNAME='APPNAME'
14VERSION='VERSION'
15TOP='top'
16OUT='out'
17WSCRIPT_FILE='wscript'
18launch_dir=''
19run_dir=''
20top_dir=''
21out_dir=''
22waf_dir=''
23local_repo=''
24remote_repo='http://waf.googlecode.com/git/'
25remote_locs=['waflib/extras','waflib/Tools']
26g_module=None
27STDOUT=1
28STDERR=-1
29BOTH=0
30classes=[]
31def 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
39class 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)
53ctx=store_context('ctx',(object,),{})
54class 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',''))
268cache_modules={}
269def 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
285def 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
Note: See TracBrowser for help on using the repository browser.