waflib/Configure.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,sys,time
   6 from waflib import ConfigSet,Utils,Options,Logs,Context,Build,Errors
   7 try:
   8         from urllib import request
   9 except ImportError:
  10         from urllib import urlopen
  11 else:
  12         urlopen=request.urlopen
  13 BREAK='break'
  14 CONTINUE='continue'
  15 WAF_CONFIG_LOG='config.log'
  16 autoconfig=False
  17 conf_template='''# project %(app)s configured on %(now)s by
  18 # waf %(wafver)s (abi %(abi)s, python %(pyver)x on %(systype)s)
  19 # using %(args)s
  20 #'''
  21 def download_check(node):
  22         pass
  23 def download_tool(tool,force=False,ctx=None):
  24         for x in Utils.to_list(Context.remote_repo):
  25                 for sub in Utils.to_list(Context.remote_locs):
  26                         url='/'.join((x,sub,tool+'.py'))
  27                         try:
  28                                 web=urlopen(url)
  29                                 try:
  30                                         if web.getcode()!=200:
  31                                                 continue
  32                                 except AttributeError:
  33                                         pass
  34                         except Exception:
  35                                 continue
  36                         else:
  37                                 tmp=ctx.root.make_node(os.sep.join((Context.waf_dir,'waflib','extras',tool+'.py')))
  38                                 tmp.write(web.read(),'wb')
  39                                 Logs.warn('Downloaded %s from %s'%(tool,url))
  40                                 download_check(tmp)
  41                                 try:
  42                                         module=Context.load_tool(tool)
  43                                 except Exception:
  44                                         Logs.warn('The tool %s from %s is unusable'%(tool,url))
  45                                         try:
  46                                                 tmp.delete()
  47                                         except Exception:
  48                                                 pass
  49                                         continue
  50                                 return module
  51         raise Errors.WafError('Could not load the Waf tool')
  52 class ConfigurationContext(Context.Context):
  53         '''configures the project'''
  54         cmd='configure'
  55         error_handlers=[]
  56         def __init__(self,**kw):
  57                 super(ConfigurationContext,self).__init__(**kw)
  58                 self.environ=dict(os.environ)
  59                 self.all_envs={}
  60                 self.top_dir=None
  61                 self.out_dir=None
  62                 self.tools=[]
  63                 self.hash=0
  64                 self.files=[]
  65                 self.tool_cache=[]
  66                 self.setenv('')
  67         def setenv(self,name,env=None):
  68                 if name not in self.all_envs or env:
  69                         if not env:
  70                                 env=ConfigSet.ConfigSet()
  71                                 self.prepare_env(env)
  72                         else:
  73                                 env=env.derive()
  74                         self.all_envs[name]=env
  75                 self.variant=name
  76         def get_env(self):
  77                 return self.all_envs[self.variant]
  78         def set_env(self,val):
  79                 self.all_envs[self.variant]=val
  80         env=property(get_env,set_env)
  81         def init_dirs(self):
  82                 top=self.top_dir
  83                 if not top:
  84                         top=Options.options.top
  85                 if not top:
  86                         top=getattr(Context.g_module,Context.TOP,None)
  87                 if not top:
  88                         top=self.path.abspath()
  89                 top=os.path.abspath(top)
  90                 self.srcnode=(os.path.isabs(top)and self.root or self.path).find_dir(top)
  91                 assert(self.srcnode)
  92                 out=self.out_dir
  93                 if not out:
  94                         out=Options.options.out
  95                 if not out:
  96                         out=getattr(Context.g_module,Context.OUT,None)
  97                 if not out:
  98                         out=Options.lockfile.replace('.lock-waf_%s_'%sys.platform,'').replace('.lock-waf','')
  99                 self.bldnode=(os.path.isabs(out)and self.root or self.path).make_node(out)
 100                 self.bldnode.mkdir()
 101                 if not os.path.isdir(self.bldnode.abspath()):
 102                         conf.fatal('Could not create the build directory %s'%self.bldnode.abspath())
 103         def execute(self):
 104                 self.init_dirs()
 105                 self.cachedir=self.bldnode.make_node(Build.CACHE_DIR)
 106                 self.cachedir.mkdir()
 107                 path=os.path.join(self.bldnode.abspath(),WAF_CONFIG_LOG)
 108                 self.logger=Logs.make_logger(path,'cfg')
 109                 app=getattr(Context.g_module,'APPNAME','')
 110                 if app:
 111                         ver=getattr(Context.g_module,'VERSION','')
 112                         if ver:
 113                                 app="%s (%s)"%(app,ver)
 114                 now=time.ctime()
 115                 pyver=sys.hexversion
 116                 systype=sys.platform
 117                 args=" ".join(sys.argv)
 118                 wafver=Context.WAFVERSION
 119                 abi=Context.ABI
 120                 self.to_log(conf_template%vars())
 121                 self.msg('Setting top to',self.srcnode.abspath())
 122                 self.msg('Setting out to',self.bldnode.abspath())
 123                 if id(self.srcnode)==id(self.bldnode):
 124                         Logs.warn('Setting top == out (remember to use "update_outputs")')
 125                 elif id(self.path)!=id(self.srcnode):
 126                         if self.srcnode.is_child_of(self.path):
 127                                 Logs.warn('Are you certain that you do not want to set top="." ?')
 128                 super(ConfigurationContext,self).execute()
 129                 self.store()
 130                 Context.top_dir=self.srcnode.abspath()
 131                 Context.out_dir=self.bldnode.abspath()
 132                 env=ConfigSet.ConfigSet()
 133                 env['argv']=sys.argv
 134                 env['options']=Options.options.__dict__
 135                 env.run_dir=Context.run_dir
 136                 env.top_dir=Context.top_dir
 137                 env.out_dir=Context.out_dir
 138                 env['hash']=self.hash
 139                 env['files']=self.files
 140                 env['environ']=dict(self.environ)
 141                 if not self.env.NO_LOCK_IN_RUN:
 142                         env.store(Context.run_dir+os.sep+Options.lockfile)
 143                 if not self.env.NO_LOCK_IN_TOP:
 144                         env.store(Context.top_dir+os.sep+Options.lockfile)
 145                 if not self.env.NO_LOCK_IN_OUT:
 146                         env.store(Context.out_dir+os.sep+Options.lockfile)
 147         def prepare_env(self,env):
 148                 if not env.PREFIX:
 149                         if Options.options.prefix or Utils.is_win32:
 150                                 env.PREFIX=os.path.abspath(os.path.expanduser(Options.options.prefix))
 151                         else:
 152                                 env.PREFIX=''
 153                 if not env.BINDIR:
 154                         env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env)
 155                 if not env.LIBDIR:
 156                         env.LIBDIR=Utils.subst_vars('${PREFIX}/lib',env)
 157         def store(self):
 158                 n=self.cachedir.make_node('build.config.py')
 159                 n.write('version = 0x%x\ntools = %r\n'%(Context.HEXVERSION,self.tools))
 160                 if not self.all_envs:
 161                         self.fatal('nothing to store in the configuration context!')
 162                 for key in self.all_envs:
 163                         tmpenv=self.all_envs[key]
 164                         tmpenv.store(os.path.join(self.cachedir.abspath(),key+Build.CACHE_SUFFIX))
 165         def load(self,input,tooldir=None,funs=None,download=True):
 166                 tools=Utils.to_list(input)
 167                 if tooldir:tooldir=Utils.to_list(tooldir)
 168                 for tool in tools:
 169                         mag=(tool,id(self.env),funs)
 170                         if mag in self.tool_cache:
 171                                 self.to_log('(tool %s is already loaded, skipping)'%tool)
 172                                 continue
 173                         self.tool_cache.append(mag)
 174                         module=None
 175                         try:
 176                                 module=Context.load_tool(tool,tooldir)
 177                         except ImportError ,e:
 178                                 if Options.options.download:
 179                                         module=download_tool(tool,ctx=self)
 180                                         if not module:
 181                                                 self.fatal('Could not load the Waf tool %r or download a suitable replacement from the repository (sys.path %r)\n%s'%(tool,sys.path,e))
 182                                 else:
 183                                         self.fatal('Could not load the Waf tool %r from %r (try the --download option?):\n%s'%(tool,sys.path,e))
 184                         except Exception ,e:
 185                                 self.to_log('imp %r (%r & %r)'%(tool,tooldir,funs))
 186                                 self.to_log(Utils.ex_stack())
 187                                 raise
 188                         if funs is not None:
 189                                 self.eval_rules(funs)
 190                         else:
 191                                 func=getattr(module,'configure',None)
 192                                 if func:
 193                                         if type(func)is type(Utils.readf):func(self)
 194                                         else:self.eval_rules(func)
 195                         self.tools.append({'tool':tool,'tooldir':tooldir,'funs':funs})
 196         def post_recurse(self,node):
 197                 super(ConfigurationContext,self).post_recurse(node)
 198                 self.hash=hash((self.hash,node.read('rb')))
 199                 self.files.append(node.abspath())
 200         def eval_rules(self,rules):
 201                 self.rules=Utils.to_list(rules)
 202                 for x in self.rules:
 203                         f=getattr(self,x)
 204                         if not f:self.fatal("No such method '%s'."%x)
 205                         try:
 206                                 f()
 207                         except Exception ,e:
 208                                 ret=self.err_handler(x,e)
 209                                 if ret==BREAK:
 210                                         break
 211                                 elif ret==CONTINUE:
 212                                         continue
 213                                 else:
 214                                         raise
 215         def err_handler(self,fun,error):
 216                 pass
 217 def conf(f):
 218         def fun(*k,**kw):
 219                 mandatory=True
 220                 if'mandatory'in kw:
 221                         mandatory=kw['mandatory']
 222                         del kw['mandatory']
 223                 try:
 224                         return f(*k,**kw)
 225                 except Errors.ConfigurationError:
 226                         if mandatory:
 227                                 raise
 228         setattr(ConfigurationContext,f.__name__,fun)
 229         setattr(Build.BuildContext,f.__name__,fun)
 230         return f
 231 @conf
 232 def add_os_flags(self,var,dest=None):
 233         try:self.env.append_value(dest or var,shlex.split(self.environ[var]))
 234         except KeyError:pass
 235 @conf
 236 def cmd_to_list(self,cmd):
 237         if isinstance(cmd,str)and cmd.find(' '):
 238                 try:
 239                         os.stat(cmd)
 240                 except OSError:
 241                         return shlex.split(cmd)
 242                 else:
 243                         return[cmd]
 244         return cmd
 245 @conf
 246 def check_waf_version(self,mini='1.6.99',maxi='1.8.0'):
 247         self.start_msg('Checking for waf version in %s-%s'%(str(mini),str(maxi)))
 248         ver=Context.HEXVERSION
 249         if Utils.num2ver(mini)>ver:
 250                 self.fatal('waf version should be at least %r (%r found)'%(Utils.num2ver(mini),ver))
 251         if Utils.num2ver(maxi)<ver:
 252                 self.fatal('waf version should be at most %r (%r found)'%(Utils.num2ver(maxi),ver))
 253         self.end_msg('ok')
 254 @conf
 255 def find_file(self,filename,path_list=[]):
 256         for n in Utils.to_list(filename):
 257                 for d in Utils.to_list(path_list):
 258                         p=os.path.join(d,n)
 259                         if os.path.exists(p):
 260                                 return p
 261         self.fatal('Could not find %r'%filename)
 262 @conf
 263 def find_program(self,filename,**kw):
 264         exts=kw.get('exts',Utils.is_win32 and'.exe,.com,.bat,.cmd'or',.sh,.pl,.py')
 265         environ=kw.get('environ',os.environ)
 266         ret=''
 267         filename=Utils.to_list(filename)
 268         var=kw.get('var','')
 269         if not var:
 270                 var=filename[0].upper()
 271         if self.env[var]:
 272                 ret=self.env[var]
 273         elif var in environ:
 274                 ret=environ[var]
 275         path_list=kw.get('path_list','')
 276         if not ret:
 277                 if path_list:
 278                         path_list=Utils.to_list(path_list)
 279                 else:
 280                         path_list=environ.get('PATH','').split(os.pathsep)
 281                 if not isinstance(filename,list):
 282                         filename=[filename]
 283                 for a in exts.split(','):
 284                         if ret:
 285                                 break
 286                         for b in filename:
 287                                 if ret:
 288                                         break
 289                                 for c in path_list:
 290                                         if ret:
 291                                                 break
 292                                         x=os.path.expanduser(os.path.join(c,b+a))
 293                                         if os.path.isfile(x):
 294                                                 ret=x
 295         if not ret and Utils.winreg:
 296                 ret=Utils.get_registry_app_path(Utils.winreg.HKEY_CURRENT_USER,filename)
 297         if not ret and Utils.winreg:
 298                 ret=Utils.get_registry_app_path(Utils.winreg.HKEY_LOCAL_MACHINE,filename)
 299         self.msg('Checking for program '+','.join(filename),ret or False)
 300         self.to_log('find program=%r paths=%r var=%r -> %r'%(filename,path_list,var,ret))
 301         if not ret:
 302                 self.fatal(kw.get('errmsg','')or'Could not find the program %s'%','.join(filename))
 303         if var:
 304                 self.env[var]=ret
 305         return ret
 306 @conf
 307 def find_perl_program(self,filename,path_list=[],var=None,environ=None,exts=''):
 308         try:
 309                 app=self.find_program(filename,path_list=path_list,var=var,environ=environ,exts=exts)
 310         except Exception:
 311                 self.find_program('perl',var='PERL')
 312                 app=self.find_file(filename,os.environ['PATH'].split(os.pathsep))
 313                 if not app:
 314                         raise
 315                 if var:
 316                         self.env[var]=Utils.to_list(self.env['PERL'])+[app]
 317         self.msg('Checking for %r'%filename,app)