waflib/Tools/javaw.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,re,tempfile,shutil
   6 from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node,Logs
   7 from waflib.Configure import conf
   8 from waflib.TaskGen import feature,before_method,after_method
   9 from waflib.Tools import ccroot
  10 ccroot.USELIB_VARS['javac']=set(['CLASSPATH','JAVACFLAGS'])
  11 SOURCE_RE='**/*.java'
  12 JAR_RE='**/*'
  13 class_check_source='''
  14 public class Test {
  15         public static void main(String[] argv) {
  16                 Class lib;
  17                 if (argv.length < 1) {
  18                         System.err.println("Missing argument");
  19                         System.exit(77);
  20                 }
  21                 try {
  22                         lib = Class.forName(argv[0]);
  23                 } catch (ClassNotFoundException e) {
  24                         System.err.println("ClassNotFoundException");
  25                         System.exit(1);
  26                 }
  27                 lib = null;
  28                 System.exit(0);
  29         }
  30 }
  31 '''
  32 @feature('javac')
  33 @before_method('process_source')
  34 def apply_java(self):
  35         Utils.def_attrs(self,jarname='',classpath='',sourcepath='.',srcdir='.',jar_mf_attributes={},jar_mf_classpath=[])
  36         nodes_lst=[]
  37         outdir=getattr(self,'outdir',None)
  38         if outdir:
  39                 if not isinstance(outdir,Node.Node):
  40                         outdir=self.path.get_bld().make_node(self.outdir)
  41         else:
  42                 outdir=self.path.get_bld()
  43         outdir.mkdir()
  44         self.outdir=outdir
  45         self.env['OUTDIR']=outdir.abspath()
  46         self.javac_task=tsk=self.create_task('javac')
  47         tmp=[]
  48         srcdir=getattr(self,'srcdir','')
  49         if isinstance(srcdir,Node.Node):
  50                 srcdir=[srcdir]
  51         for x in Utils.to_list(srcdir):
  52                 if isinstance(x,Node.Node):
  53                         y=x
  54                 else:
  55                         y=self.path.find_dir(x)
  56                         if not y:
  57                                 self.bld.fatal('Could not find the folder %s from %s'%(x,self.path))
  58                 tmp.append(y)
  59         tsk.srcdir=tmp
  60         if getattr(self,'compat',None):
  61                 tsk.env.append_value('JAVACFLAGS',['-source',self.compat])
  62         if hasattr(self,'sourcepath'):
  63                 fold=[isinstance(x,Node.Node)and x or self.path.find_dir(x)for x in self.to_list(self.sourcepath)]
  64                 names=os.pathsep.join([x.srcpath()for x in fold])
  65         else:
  66                 names=[x.srcpath()for x in tsk.srcdir]
  67         if names:
  68                 tsk.env.append_value('JAVACFLAGS',['-sourcepath',names])
  69 @feature('javac')
  70 @after_method('apply_java')
  71 def use_javac_files(self):
  72         lst=[]
  73         self.uselib=self.to_list(getattr(self,'uselib',[]))
  74         names=self.to_list(getattr(self,'use',[]))
  75         get=self.bld.get_tgen_by_name
  76         for x in names:
  77                 try:
  78                         y=get(x)
  79                 except Exception:
  80                         self.uselib.append(x)
  81                 else:
  82                         y.post()
  83                         lst.append(y.jar_task.outputs[0].abspath())
  84                         self.javac_task.set_run_after(y.jar_task)
  85         if lst:
  86                 self.env.append_value('CLASSPATH',lst)
  87 @feature('javac')
  88 @after_method('apply_java','propagate_uselib_vars','use_javac_files')
  89 def set_classpath(self):
  90         self.env.append_value('CLASSPATH',getattr(self,'classpath',[]))
  91         for x in self.tasks:
  92                 x.env.CLASSPATH=os.pathsep.join(self.env.CLASSPATH)+os.pathsep
  93 @feature('jar')
  94 @after_method('apply_java','use_javac_files')
  95 @before_method('process_source')
  96 def jar_files(self):
  97         destfile=getattr(self,'destfile','test.jar')
  98         jaropts=getattr(self,'jaropts',[])
  99         manifest=getattr(self,'manifest',None)
 100         basedir=getattr(self,'basedir',None)
 101         if basedir:
 102                 if not isinstance(self.basedir,Node.Node):
 103                         basedir=self.path.get_bld().make_node(basedir)
 104         else:
 105                 basedir=self.path.get_bld()
 106         if not basedir:
 107                 self.bld.fatal('Could not find the basedir %r for %r'%(self.basedir,self))
 108         self.jar_task=tsk=self.create_task('jar_create')
 109         if manifest:
 110                 jarcreate=getattr(self,'jarcreate','cfm')
 111                 node=self.path.find_node(manifest)
 112                 tsk.dep_nodes.append(node)
 113                 jaropts.insert(0,node.abspath())
 114         else:
 115                 jarcreate=getattr(self,'jarcreate','cf')
 116         if not isinstance(destfile,Node.Node):
 117                 destfile=self.path.find_or_declare(destfile)
 118         if not destfile:
 119                 self.bld.fatal('invalid destfile %r for %r'%(destfile,self))
 120         tsk.set_outputs(destfile)
 121         tsk.basedir=basedir
 122         jaropts.append('-C')
 123         jaropts.append(basedir.bldpath())
 124         jaropts.append('.')
 125         tsk.env['JAROPTS']=jaropts
 126         tsk.env['JARCREATE']=jarcreate
 127         if getattr(self,'javac_task',None):
 128                 tsk.set_run_after(self.javac_task)
 129 @feature('jar')
 130 @after_method('jar_files')
 131 def use_jar_files(self):
 132         lst=[]
 133         self.uselib=self.to_list(getattr(self,'uselib',[]))
 134         names=self.to_list(getattr(self,'use',[]))
 135         get=self.bld.get_tgen_by_name
 136         for x in names:
 137                 try:
 138                         y=get(x)
 139                 except Exception:
 140                         self.uselib.append(x)
 141                 else:
 142                         y.post()
 143                         self.jar_task.run_after.update(y.tasks)
 144 class jar_create(Task.Task):
 145         color='GREEN'
 146         run_str='${JAR} ${JARCREATE} ${TGT} ${JAROPTS}'
 147         def runnable_status(self):
 148                 for t in self.run_after:
 149                         if not t.hasrun:
 150                                 return Task.ASK_LATER
 151                 if not self.inputs:
 152                         global JAR_RE
 153                         try:
 154                                 self.inputs=[x for x in self.basedir.ant_glob(JAR_RE,remove=False)if id(x)!=id(self.outputs[0])]
 155                         except Exception:
 156                                 raise Errors.WafError('Could not find the basedir %r for %r'%(self.basedir,self))
 157                 return super(jar_create,self).runnable_status()
 158 class javac(Task.Task):
 159         color='BLUE'
 160         nocache=True
 161         vars=['CLASSPATH','JAVACFLAGS','JAVAC','OUTDIR']
 162         def runnable_status(self):
 163                 for t in self.run_after:
 164                         if not t.hasrun:
 165                                 return Task.ASK_LATER
 166                 if not self.inputs:
 167                         global SOURCE_RE
 168                         self.inputs=[]
 169                         for x in self.srcdir:
 170                                 self.inputs.extend(x.ant_glob(SOURCE_RE,remove=False))
 171                 return super(javac,self).runnable_status()
 172         def run(self):
 173                 env=self.env
 174                 gen=self.generator
 175                 bld=gen.bld
 176                 wd=bld.bldnode.abspath()
 177                 def to_list(xx):
 178                         if isinstance(xx,str):return[xx]
 179                         return xx
 180                 cmd=[]
 181                 cmd.extend(to_list(env['JAVAC']))
 182                 cmd.extend(['-classpath'])
 183                 cmd.extend(to_list(env['CLASSPATH']))
 184                 cmd.extend(['-d'])
 185                 cmd.extend(to_list(env['OUTDIR']))
 186                 cmd.extend(to_list(env['JAVACFLAGS']))
 187                 files=[a.path_from(bld.bldnode)for a in self.inputs]
 188                 tmp=None
 189                 try:
 190                         if len(str(files))+len(str(cmd))>8192:
 191                                 (fd,tmp)=tempfile.mkstemp(dir=bld.bldnode.abspath())
 192                                 try:
 193                                         os.write(fd,'\n'.join(files))
 194                                 finally:
 195                                         if tmp:
 196                                                 os.close(fd)
 197                                 if Logs.verbose:
 198                                         Logs.debug('runner: %r'%(cmd+files))
 199                                 cmd.append('@'+tmp)
 200                         else:
 201                                 cmd+=files
 202                         ret=self.exec_command(cmd,cwd=wd,env=env.env or None)
 203                 finally:
 204                         if tmp:
 205                                 os.remove(tmp)
 206                 return ret
 207         def post_run(self):
 208                 for n in self.generator.outdir.ant_glob('**/*.class'):
 209                         n.sig=Utils.h_file(n.abspath())
 210                 self.generator.bld.task_sigs[self.uid()]=self.cache_sig
 211 @feature('javadoc')
 212 @after_method('process_rule')
 213 def create_javadoc(self):
 214         tsk=self.create_task('javadoc')
 215         tsk.classpath=getattr(self,'classpath',[])
 216         self.javadoc_package=Utils.to_list(self.javadoc_package)
 217         if not isinstance(self.javadoc_output,Node.Node):
 218                 self.javadoc_output=self.bld.path.find_or_declare(self.javadoc_output)
 219 class javadoc(Task.Task):
 220         color='BLUE'
 221         def __str__(self):
 222                 return'%s: %s -> %s\n'%(self.__class__.__name__,self.generator.srcdir,self.generator.javadoc_output)
 223         def run(self):
 224                 env=self.env
 225                 bld=self.generator.bld
 226                 wd=bld.bldnode.abspath()
 227                 srcpath=self.generator.path.abspath()+os.sep+self.generator.srcdir
 228                 srcpath+=os.pathsep
 229                 srcpath+=self.generator.path.get_bld().abspath()+os.sep+self.generator.srcdir
 230                 classpath=env.CLASSPATH
 231                 classpath+=os.pathsep
 232                 classpath+=os.pathsep.join(self.classpath)
 233                 classpath="".join(classpath)
 234                 self.last_cmd=lst=[]
 235                 lst.extend(Utils.to_list(env['JAVADOC']))
 236                 lst.extend(['-d',self.generator.javadoc_output.abspath()])
 237                 lst.extend(['-sourcepath',srcpath])
 238                 lst.extend(['-classpath',classpath])
 239                 lst.extend(['-subpackages'])
 240                 lst.extend(self.generator.javadoc_package)
 241                 lst=[x for x in lst if x]
 242                 self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None,quiet=0)
 243         def post_run(self):
 244                 nodes=self.generator.javadoc_output.ant_glob('**')
 245                 for x in nodes:
 246                         x.sig=Utils.h_file(x.abspath())
 247                 self.generator.bld.task_sigs[self.uid()]=self.cache_sig
 248 def configure(self):
 249         java_path=self.environ['PATH'].split(os.pathsep)
 250         v=self.env
 251         if'JAVA_HOME'in self.environ:
 252                 java_path=[os.path.join(self.environ['JAVA_HOME'],'bin')]+java_path
 253                 self.env['JAVA_HOME']=[self.environ['JAVA_HOME']]
 254         for x in'javac java jar javadoc'.split():
 255                 self.find_program(x,var=x.upper(),path_list=java_path)
 256                 self.env[x.upper()]=self.cmd_to_list(self.env[x.upper()])
 257         if'CLASSPATH'in self.environ:
 258                 v['CLASSPATH']=self.environ['CLASSPATH']
 259         if not v['JAR']:self.fatal('jar is required for making java packages')
 260         if not v['JAVAC']:self.fatal('javac is required for compiling java classes')
 261         v['JARCREATE']='cf'
 262         v['JAVACFLAGS']=[]
 263 @conf
 264 def check_java_class(self,classname,with_classpath=None):
 265         javatestdir='.waf-javatest'
 266         classpath=javatestdir
 267         if self.env['CLASSPATH']:
 268                 classpath+=os.pathsep+self.env['CLASSPATH']
 269         if isinstance(with_classpath,str):
 270                 classpath+=os.pathsep+with_classpath
 271         shutil.rmtree(javatestdir,True)
 272         os.mkdir(javatestdir)
 273         Utils.writef(os.path.join(javatestdir,'Test.java'),class_check_source)
 274         self.exec_command(self.env['JAVAC']+[os.path.join(javatestdir,'Test.java')],shell=False)
 275         cmd=self.env['JAVA']+['-cp',classpath,'Test',classname]
 276         self.to_log("%s\n"%str(cmd))
 277         found=self.exec_command(cmd,shell=False)
 278         self.msg('Checking for java class %s'%classname,not found)
 279         shutil.rmtree(javatestdir,True)
 280         return found
 281 @conf
 282 def check_jni_headers(conf):
 283         if not conf.env.CC_NAME and not conf.env.CXX_NAME:
 284                 conf.fatal('load a compiler first (gcc, g++, ..)')
 285         if not conf.env.JAVA_HOME:
 286                 conf.fatal('set JAVA_HOME in the system environment')
 287         javaHome=conf.env['JAVA_HOME'][0]
 288         dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/include')
 289         if dir is None:
 290                 dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/../Headers')
 291         if dir is None:
 292                 conf.fatal('JAVA_HOME does not seem to be set properly')
 293         f=dir.ant_glob('**/(jni|jni_md).h')
 294         incDirs=[x.parent.abspath()for x in f]
 295         dir=conf.root.find_dir(conf.env.JAVA_HOME[0])
 296         f=dir.ant_glob('**/*jvm.(so|dll|dylib)')
 297         libDirs=[x.parent.abspath()for x in f]or[javaHome]
 298         f=dir.ant_glob('**/*jvm.(lib)')
 299         if f:
 300                 libDirs=[[x,y.parent.abspath()]for x in libDirs for y in f]
 301         for d in libDirs:
 302                 try:
 303                         conf.check(header_name='jni.h',define_name='HAVE_JNI_H',lib='jvm',libpath=d,includes=incDirs,uselib_store='JAVA',uselib='JAVA')
 304                 except Exception:
 305                         pass
 306                 else:
 307                         break
 308         else:
 309                 conf.fatal('could not find lib jvm in %r (see config.log)'%libDirs)