mirror of
https://github.com/cookiengineer/audacity
synced 2025-12-16 17:41:14 +01:00
Update local LV2 libraries to latest versions
lilv-0.24.6 lv2-1.16.0 serd-0.30.2 sord-0.16.4 sratom-0.6.4 suil-0.10.6
This commit is contained in:
Leland Lucius
@@ -1,16 +1,126 @@
|
||||
#! /usr/bin/env python
|
||||
#!/usr/bin/env python
|
||||
# encoding: utf-8
|
||||
# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
|
||||
# Thomas Nagy, 2006-2018 (ita)
|
||||
|
||||
import os,re,tempfile,shutil
|
||||
from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node,Logs
|
||||
"""
|
||||
Java support
|
||||
|
||||
Javac is one of the few compilers that behaves very badly:
|
||||
|
||||
#. it outputs files where it wants to (-d is only for the package root)
|
||||
|
||||
#. it recompiles files silently behind your back
|
||||
|
||||
#. it outputs an undefined amount of files (inner classes)
|
||||
|
||||
Remember that the compilation can be performed using Jython[1] rather than regular Python. Instead of
|
||||
running one of the following commands::
|
||||
|
||||
./waf configure
|
||||
python waf configure
|
||||
|
||||
You would have to run::
|
||||
|
||||
java -jar /path/to/jython.jar waf configure
|
||||
|
||||
[1] http://www.jython.org/
|
||||
|
||||
Usage
|
||||
=====
|
||||
|
||||
Load the "java" tool.
|
||||
|
||||
def configure(conf):
|
||||
conf.load('java')
|
||||
|
||||
Java tools will be autodetected and eventually, if present, the quite
|
||||
standard JAVA_HOME environment variable will be used. The also standard
|
||||
CLASSPATH variable is used for library searching.
|
||||
|
||||
In configuration phase checks can be done on the system environment, for
|
||||
example to check if a class is known in the classpath::
|
||||
|
||||
conf.check_java_class('java.io.FileOutputStream')
|
||||
|
||||
or if the system supports JNI applications building::
|
||||
|
||||
conf.check_jni_headers()
|
||||
|
||||
|
||||
The java tool supports compiling java code, creating jar files and
|
||||
creating javadoc documentation. This can be either done separately or
|
||||
together in a single definition. For example to manage them separately::
|
||||
|
||||
bld(features = 'javac',
|
||||
srcdir = 'src',
|
||||
compat = '1.7',
|
||||
use = 'animals',
|
||||
name = 'cats-src',
|
||||
)
|
||||
|
||||
bld(features = 'jar',
|
||||
basedir = '.',
|
||||
destfile = '../cats.jar',
|
||||
name = 'cats',
|
||||
use = 'cats-src'
|
||||
)
|
||||
|
||||
|
||||
Or together by defining all the needed attributes::
|
||||
|
||||
bld(features = 'javac jar javadoc',
|
||||
srcdir = 'src/', # folder containing the sources to compile
|
||||
outdir = 'src', # folder where to output the classes (in the build directory)
|
||||
compat = '1.6', # java compatibility version number
|
||||
classpath = ['.', '..'],
|
||||
|
||||
# jar
|
||||
basedir = 'src', # folder containing the classes and other files to package (must match outdir)
|
||||
destfile = 'foo.jar', # do not put the destfile in the folder of the java classes!
|
||||
use = 'NNN',
|
||||
jaropts = ['-C', 'default/src/', '.'], # can be used to give files
|
||||
manifest = 'src/Manifest.mf', # Manifest file to include
|
||||
|
||||
# javadoc
|
||||
javadoc_package = ['com.meow' , 'com.meow.truc.bar', 'com.meow.truc.foo'],
|
||||
javadoc_output = 'javadoc',
|
||||
)
|
||||
|
||||
External jar dependencies can be mapped to a standard waf "use" dependency by
|
||||
setting an environment variable with a CLASSPATH prefix in the configuration,
|
||||
for example::
|
||||
|
||||
conf.env.CLASSPATH_NNN = ['aaaa.jar', 'bbbb.jar']
|
||||
|
||||
and then NNN can be freely used in rules as::
|
||||
|
||||
use = 'NNN',
|
||||
|
||||
In the java tool the dependencies via use are not transitive by default, as
|
||||
this necessity depends on the code. To enable recursive dependency scanning
|
||||
use on a specific rule:
|
||||
|
||||
recurse_use = True
|
||||
|
||||
Or build-wise by setting RECURSE_JAVA:
|
||||
|
||||
bld.env.RECURSE_JAVA = True
|
||||
|
||||
Unit tests can be integrated in the waf unit test environment using the javatest extra.
|
||||
"""
|
||||
|
||||
import os, shutil
|
||||
from waflib import Task, Utils, Errors, Node
|
||||
from waflib.Configure import conf
|
||||
from waflib.TaskGen import feature,before_method,after_method
|
||||
from waflib.TaskGen import feature, before_method, after_method, taskgen_method
|
||||
|
||||
from waflib.Tools import ccroot
|
||||
ccroot.USELIB_VARS['javac']=set(['CLASSPATH','JAVACFLAGS'])
|
||||
SOURCE_RE='**/*.java'
|
||||
JAR_RE='**/*'
|
||||
class_check_source='''
|
||||
ccroot.USELIB_VARS['javac'] = set(['CLASSPATH', 'JAVACFLAGS'])
|
||||
|
||||
SOURCE_RE = '**/*.java'
|
||||
JAR_RE = '**/*'
|
||||
|
||||
class_check_source = '''
|
||||
public class Test {
|
||||
public static void main(String[] argv) {
|
||||
Class lib;
|
||||
@@ -29,281 +139,455 @@ public class Test {
|
||||
}
|
||||
}
|
||||
'''
|
||||
|
||||
@feature('javac')
|
||||
@before_method('process_source')
|
||||
def apply_java(self):
|
||||
Utils.def_attrs(self,jarname='',classpath='',sourcepath='.',srcdir='.',jar_mf_attributes={},jar_mf_classpath=[])
|
||||
nodes_lst=[]
|
||||
outdir=getattr(self,'outdir',None)
|
||||
"""
|
||||
Create a javac task for compiling *.java files*. There can be
|
||||
only one javac task by task generator.
|
||||
"""
|
||||
Utils.def_attrs(self, jarname='', classpath='',
|
||||
sourcepath='.', srcdir='.',
|
||||
jar_mf_attributes={}, jar_mf_classpath=[])
|
||||
|
||||
outdir = getattr(self, 'outdir', None)
|
||||
if outdir:
|
||||
if not isinstance(outdir,Node.Node):
|
||||
outdir=self.path.get_bld().make_node(self.outdir)
|
||||
if not isinstance(outdir, Node.Node):
|
||||
outdir = self.path.get_bld().make_node(self.outdir)
|
||||
else:
|
||||
outdir=self.path.get_bld()
|
||||
outdir = self.path.get_bld()
|
||||
outdir.mkdir()
|
||||
self.outdir=outdir
|
||||
self.env['OUTDIR']=outdir.abspath()
|
||||
self.javac_task=tsk=self.create_task('javac')
|
||||
tmp=[]
|
||||
srcdir=getattr(self,'srcdir','')
|
||||
if isinstance(srcdir,Node.Node):
|
||||
srcdir=[srcdir]
|
||||
self.outdir = outdir
|
||||
self.env.OUTDIR = outdir.abspath()
|
||||
|
||||
self.javac_task = tsk = self.create_task('javac')
|
||||
tmp = []
|
||||
|
||||
srcdir = getattr(self, 'srcdir', '')
|
||||
if isinstance(srcdir, Node.Node):
|
||||
srcdir = [srcdir]
|
||||
for x in Utils.to_list(srcdir):
|
||||
if isinstance(x,Node.Node):
|
||||
y=x
|
||||
if isinstance(x, Node.Node):
|
||||
y = x
|
||||
else:
|
||||
y=self.path.find_dir(x)
|
||||
y = self.path.find_dir(x)
|
||||
if not y:
|
||||
self.bld.fatal('Could not find the folder %s from %s'%(x,self.path))
|
||||
self.bld.fatal('Could not find the folder %s from %s' % (x, self.path))
|
||||
tmp.append(y)
|
||||
tsk.srcdir=tmp
|
||||
if getattr(self,'compat',None):
|
||||
tsk.env.append_value('JAVACFLAGS',['-source',self.compat])
|
||||
if hasattr(self,'sourcepath'):
|
||||
fold=[isinstance(x,Node.Node)and x or self.path.find_dir(x)for x in self.to_list(self.sourcepath)]
|
||||
names=os.pathsep.join([x.srcpath()for x in fold])
|
||||
|
||||
tsk.srcdir = tmp
|
||||
|
||||
if getattr(self, 'compat', None):
|
||||
tsk.env.append_value('JAVACFLAGS', ['-source', str(self.compat)])
|
||||
|
||||
if hasattr(self, 'sourcepath'):
|
||||
fold = [isinstance(x, Node.Node) and x or self.path.find_dir(x) for x in self.to_list(self.sourcepath)]
|
||||
names = os.pathsep.join([x.srcpath() for x in fold])
|
||||
else:
|
||||
names=[x.srcpath()for x in tsk.srcdir]
|
||||
names = [x.srcpath() for x in tsk.srcdir]
|
||||
|
||||
if names:
|
||||
tsk.env.append_value('JAVACFLAGS',['-sourcepath',names])
|
||||
tsk.env.append_value('JAVACFLAGS', ['-sourcepath', names])
|
||||
|
||||
|
||||
@taskgen_method
|
||||
def java_use_rec(self, name, **kw):
|
||||
"""
|
||||
Processes recursively the *use* attribute for each referred java compilation
|
||||
"""
|
||||
if name in self.tmp_use_seen:
|
||||
return
|
||||
|
||||
self.tmp_use_seen.append(name)
|
||||
|
||||
try:
|
||||
y = self.bld.get_tgen_by_name(name)
|
||||
except Errors.WafError:
|
||||
self.uselib.append(name)
|
||||
return
|
||||
else:
|
||||
y.post()
|
||||
# Add generated JAR name for CLASSPATH. Task ordering (set_run_after)
|
||||
# is already guaranteed by ordering done between the single tasks
|
||||
if hasattr(y, 'jar_task'):
|
||||
self.use_lst.append(y.jar_task.outputs[0].abspath())
|
||||
else:
|
||||
if hasattr(y,'outdir'):
|
||||
self.use_lst.append(y.outdir.abspath())
|
||||
else:
|
||||
self.use_lst.append(y.path.get_bld().abspath())
|
||||
|
||||
for x in self.to_list(getattr(y, 'use', [])):
|
||||
self.java_use_rec(x)
|
||||
|
||||
@feature('javac')
|
||||
@before_method('propagate_uselib_vars')
|
||||
@after_method('apply_java')
|
||||
def use_javac_files(self):
|
||||
lst=[]
|
||||
self.uselib=self.to_list(getattr(self,'uselib',[]))
|
||||
names=self.to_list(getattr(self,'use',[]))
|
||||
get=self.bld.get_tgen_by_name
|
||||
"""
|
||||
Processes the *use* attribute referring to other java compilations
|
||||
"""
|
||||
self.use_lst = []
|
||||
self.tmp_use_seen = []
|
||||
self.uselib = self.to_list(getattr(self, 'uselib', []))
|
||||
names = self.to_list(getattr(self, 'use', []))
|
||||
get = self.bld.get_tgen_by_name
|
||||
for x in names:
|
||||
try:
|
||||
y=get(x)
|
||||
except Exception:
|
||||
tg = get(x)
|
||||
except Errors.WafError:
|
||||
self.uselib.append(x)
|
||||
else:
|
||||
y.post()
|
||||
lst.append(y.jar_task.outputs[0].abspath())
|
||||
self.javac_task.set_run_after(y.jar_task)
|
||||
if lst:
|
||||
self.env.append_value('CLASSPATH',lst)
|
||||
tg.post()
|
||||
if hasattr(tg, 'jar_task'):
|
||||
self.use_lst.append(tg.jar_task.outputs[0].abspath())
|
||||
self.javac_task.set_run_after(tg.jar_task)
|
||||
self.javac_task.dep_nodes.extend(tg.jar_task.outputs)
|
||||
else:
|
||||
if hasattr(tg, 'outdir'):
|
||||
base_node = tg.outdir
|
||||
else:
|
||||
base_node = tg.path.get_bld()
|
||||
|
||||
self.use_lst.append(base_node.abspath())
|
||||
self.javac_task.dep_nodes.extend([x for x in base_node.ant_glob(JAR_RE, remove=False, quiet=True)])
|
||||
|
||||
for tsk in tg.tasks:
|
||||
self.javac_task.set_run_after(tsk)
|
||||
|
||||
# If recurse use scan is enabled recursively add use attribute for each used one
|
||||
if getattr(self, 'recurse_use', False) or self.bld.env.RECURSE_JAVA:
|
||||
self.java_use_rec(x)
|
||||
|
||||
self.env.append_value('CLASSPATH', self.use_lst)
|
||||
|
||||
@feature('javac')
|
||||
@after_method('apply_java','propagate_uselib_vars','use_javac_files')
|
||||
@after_method('apply_java', 'propagate_uselib_vars', 'use_javac_files')
|
||||
def set_classpath(self):
|
||||
self.env.append_value('CLASSPATH',getattr(self,'classpath',[]))
|
||||
"""
|
||||
Sets the CLASSPATH value on the *javac* task previously created.
|
||||
"""
|
||||
if getattr(self, 'classpath', None):
|
||||
self.env.append_unique('CLASSPATH', getattr(self, 'classpath', []))
|
||||
for x in self.tasks:
|
||||
x.env.CLASSPATH=os.pathsep.join(self.env.CLASSPATH)+os.pathsep
|
||||
x.env.CLASSPATH = os.pathsep.join(self.env.CLASSPATH) + os.pathsep
|
||||
|
||||
@feature('jar')
|
||||
@after_method('apply_java','use_javac_files')
|
||||
@after_method('apply_java', 'use_javac_files')
|
||||
@before_method('process_source')
|
||||
def jar_files(self):
|
||||
destfile=getattr(self,'destfile','test.jar')
|
||||
jaropts=getattr(self,'jaropts',[])
|
||||
manifest=getattr(self,'manifest',None)
|
||||
basedir=getattr(self,'basedir',None)
|
||||
"""
|
||||
Creates a jar task (one maximum per task generator)
|
||||
"""
|
||||
destfile = getattr(self, 'destfile', 'test.jar')
|
||||
jaropts = getattr(self, 'jaropts', [])
|
||||
manifest = getattr(self, 'manifest', None)
|
||||
|
||||
basedir = getattr(self, 'basedir', None)
|
||||
if basedir:
|
||||
if not isinstance(self.basedir,Node.Node):
|
||||
basedir=self.path.get_bld().make_node(basedir)
|
||||
if not isinstance(self.basedir, Node.Node):
|
||||
basedir = self.path.get_bld().make_node(basedir)
|
||||
else:
|
||||
basedir=self.path.get_bld()
|
||||
basedir = self.path.get_bld()
|
||||
if not basedir:
|
||||
self.bld.fatal('Could not find the basedir %r for %r'%(self.basedir,self))
|
||||
self.jar_task=tsk=self.create_task('jar_create')
|
||||
self.bld.fatal('Could not find the basedir %r for %r' % (self.basedir, self))
|
||||
|
||||
self.jar_task = tsk = self.create_task('jar_create')
|
||||
if manifest:
|
||||
jarcreate=getattr(self,'jarcreate','cfm')
|
||||
node=self.path.find_node(manifest)
|
||||
jarcreate = getattr(self, 'jarcreate', 'cfm')
|
||||
if not isinstance(manifest,Node.Node):
|
||||
node = self.path.find_resource(manifest)
|
||||
else:
|
||||
node = manifest
|
||||
if not node:
|
||||
self.bld.fatal('invalid manifest file %r for %r' % (manifest, self))
|
||||
tsk.dep_nodes.append(node)
|
||||
jaropts.insert(0,node.abspath())
|
||||
jaropts.insert(0, node.abspath())
|
||||
else:
|
||||
jarcreate=getattr(self,'jarcreate','cf')
|
||||
if not isinstance(destfile,Node.Node):
|
||||
destfile=self.path.find_or_declare(destfile)
|
||||
jarcreate = getattr(self, 'jarcreate', 'cf')
|
||||
if not isinstance(destfile, Node.Node):
|
||||
destfile = self.path.find_or_declare(destfile)
|
||||
if not destfile:
|
||||
self.bld.fatal('invalid destfile %r for %r'%(destfile,self))
|
||||
self.bld.fatal('invalid destfile %r for %r' % (destfile, self))
|
||||
tsk.set_outputs(destfile)
|
||||
tsk.basedir=basedir
|
||||
tsk.basedir = basedir
|
||||
|
||||
jaropts.append('-C')
|
||||
jaropts.append(basedir.bldpath())
|
||||
jaropts.append('.')
|
||||
tsk.env['JAROPTS']=jaropts
|
||||
tsk.env['JARCREATE']=jarcreate
|
||||
if getattr(self,'javac_task',None):
|
||||
|
||||
tsk.env.JAROPTS = jaropts
|
||||
tsk.env.JARCREATE = jarcreate
|
||||
|
||||
if getattr(self, 'javac_task', None):
|
||||
tsk.set_run_after(self.javac_task)
|
||||
|
||||
@feature('jar')
|
||||
@after_method('jar_files')
|
||||
def use_jar_files(self):
|
||||
lst=[]
|
||||
self.uselib=self.to_list(getattr(self,'uselib',[]))
|
||||
names=self.to_list(getattr(self,'use',[]))
|
||||
get=self.bld.get_tgen_by_name
|
||||
"""
|
||||
Processes the *use* attribute to set the build order on the
|
||||
tasks created by another task generator.
|
||||
"""
|
||||
self.uselib = self.to_list(getattr(self, 'uselib', []))
|
||||
names = self.to_list(getattr(self, 'use', []))
|
||||
get = self.bld.get_tgen_by_name
|
||||
for x in names:
|
||||
try:
|
||||
y=get(x)
|
||||
except Exception:
|
||||
y = get(x)
|
||||
except Errors.WafError:
|
||||
self.uselib.append(x)
|
||||
else:
|
||||
y.post()
|
||||
self.jar_task.run_after.update(y.tasks)
|
||||
class jar_create(Task.Task):
|
||||
color='GREEN'
|
||||
run_str='${JAR} ${JARCREATE} ${TGT} ${JAROPTS}'
|
||||
def runnable_status(self):
|
||||
for t in self.run_after:
|
||||
if not t.hasrun:
|
||||
return Task.ASK_LATER
|
||||
if not self.inputs:
|
||||
global JAR_RE
|
||||
try:
|
||||
self.inputs=[x for x in self.basedir.ant_glob(JAR_RE,remove=False)if id(x)!=id(self.outputs[0])]
|
||||
except Exception:
|
||||
raise Errors.WafError('Could not find the basedir %r for %r'%(self.basedir,self))
|
||||
return super(jar_create,self).runnable_status()
|
||||
class javac(Task.Task):
|
||||
color='BLUE'
|
||||
nocache=True
|
||||
vars=['CLASSPATH','JAVACFLAGS','JAVAC','OUTDIR']
|
||||
def runnable_status(self):
|
||||
for t in self.run_after:
|
||||
if not t.hasrun:
|
||||
return Task.ASK_LATER
|
||||
if not self.inputs:
|
||||
global SOURCE_RE
|
||||
self.inputs=[]
|
||||
for x in self.srcdir:
|
||||
self.inputs.extend(x.ant_glob(SOURCE_RE,remove=False))
|
||||
return super(javac,self).runnable_status()
|
||||
def run(self):
|
||||
env=self.env
|
||||
gen=self.generator
|
||||
bld=gen.bld
|
||||
wd=bld.bldnode.abspath()
|
||||
def to_list(xx):
|
||||
if isinstance(xx,str):return[xx]
|
||||
return xx
|
||||
cmd=[]
|
||||
cmd.extend(to_list(env['JAVAC']))
|
||||
cmd.extend(['-classpath'])
|
||||
cmd.extend(to_list(env['CLASSPATH']))
|
||||
cmd.extend(['-d'])
|
||||
cmd.extend(to_list(env['OUTDIR']))
|
||||
cmd.extend(to_list(env['JAVACFLAGS']))
|
||||
files=[a.path_from(bld.bldnode)for a in self.inputs]
|
||||
tmp=None
|
||||
try:
|
||||
if len(str(files))+len(str(cmd))>8192:
|
||||
(fd,tmp)=tempfile.mkstemp(dir=bld.bldnode.abspath())
|
||||
try:
|
||||
os.write(fd,'\n'.join(files))
|
||||
finally:
|
||||
if tmp:
|
||||
os.close(fd)
|
||||
if Logs.verbose:
|
||||
Logs.debug('runner: %r'%(cmd+files))
|
||||
cmd.append('@'+tmp)
|
||||
|
||||
class JTask(Task.Task):
|
||||
"""
|
||||
Base class for java and jar tasks; provides functionality to run long commands
|
||||
"""
|
||||
def split_argfile(self, cmd):
|
||||
inline = [cmd[0]]
|
||||
infile = []
|
||||
for x in cmd[1:]:
|
||||
# jar and javac do not want -J flags in @file
|
||||
if x.startswith('-J'):
|
||||
inline.append(x)
|
||||
else:
|
||||
cmd+=files
|
||||
ret=self.exec_command(cmd,cwd=wd,env=env.env or None)
|
||||
finally:
|
||||
if tmp:
|
||||
os.remove(tmp)
|
||||
return ret
|
||||
infile.append(self.quote_flag(x))
|
||||
return (inline, infile)
|
||||
|
||||
class jar_create(JTask):
|
||||
"""
|
||||
Creates a jar file
|
||||
"""
|
||||
color = 'GREEN'
|
||||
run_str = '${JAR} ${JARCREATE} ${TGT} ${JAROPTS}'
|
||||
|
||||
def runnable_status(self):
|
||||
"""
|
||||
Wait for dependent tasks to be executed, then read the
|
||||
files to update the list of inputs.
|
||||
"""
|
||||
for t in self.run_after:
|
||||
if not t.hasrun:
|
||||
return Task.ASK_LATER
|
||||
if not self.inputs:
|
||||
try:
|
||||
self.inputs = [x for x in self.basedir.ant_glob(JAR_RE, remove=False, quiet=True) if id(x) != id(self.outputs[0])]
|
||||
except Exception:
|
||||
raise Errors.WafError('Could not find the basedir %r for %r' % (self.basedir, self))
|
||||
return super(jar_create, self).runnable_status()
|
||||
|
||||
class javac(JTask):
|
||||
"""
|
||||
Compiles java files
|
||||
"""
|
||||
color = 'BLUE'
|
||||
run_str = '${JAVAC} -classpath ${CLASSPATH} -d ${OUTDIR} ${JAVACFLAGS} ${SRC}'
|
||||
vars = ['CLASSPATH', 'JAVACFLAGS', 'JAVAC', 'OUTDIR']
|
||||
"""
|
||||
The javac task will be executed again if the variables CLASSPATH, JAVACFLAGS, JAVAC or OUTDIR change.
|
||||
"""
|
||||
def uid(self):
|
||||
"""Identify java tasks by input&output folder"""
|
||||
lst = [self.__class__.__name__, self.generator.outdir.abspath()]
|
||||
for x in self.srcdir:
|
||||
lst.append(x.abspath())
|
||||
return Utils.h_list(lst)
|
||||
|
||||
def runnable_status(self):
|
||||
"""
|
||||
Waits for dependent tasks to be complete, then read the file system to find the input nodes.
|
||||
"""
|
||||
for t in self.run_after:
|
||||
if not t.hasrun:
|
||||
return Task.ASK_LATER
|
||||
|
||||
if not self.inputs:
|
||||
self.inputs = []
|
||||
for x in self.srcdir:
|
||||
if x.exists():
|
||||
self.inputs.extend(x.ant_glob(SOURCE_RE, remove=False, quiet=True))
|
||||
return super(javac, self).runnable_status()
|
||||
|
||||
def post_run(self):
|
||||
for n in self.generator.outdir.ant_glob('**/*.class'):
|
||||
n.sig=Utils.h_file(n.abspath())
|
||||
self.generator.bld.task_sigs[self.uid()]=self.cache_sig
|
||||
"""
|
||||
List class files created
|
||||
"""
|
||||
for node in self.generator.outdir.ant_glob('**/*.class', quiet=True):
|
||||
self.generator.bld.node_sigs[node] = self.uid()
|
||||
self.generator.bld.task_sigs[self.uid()] = self.cache_sig
|
||||
|
||||
@feature('javadoc')
|
||||
@after_method('process_rule')
|
||||
def create_javadoc(self):
|
||||
tsk=self.create_task('javadoc')
|
||||
tsk.classpath=getattr(self,'classpath',[])
|
||||
self.javadoc_package=Utils.to_list(self.javadoc_package)
|
||||
if not isinstance(self.javadoc_output,Node.Node):
|
||||
self.javadoc_output=self.bld.path.find_or_declare(self.javadoc_output)
|
||||
"""
|
||||
Creates a javadoc task (feature 'javadoc')
|
||||
"""
|
||||
tsk = self.create_task('javadoc')
|
||||
tsk.classpath = getattr(self, 'classpath', [])
|
||||
self.javadoc_package = Utils.to_list(self.javadoc_package)
|
||||
if not isinstance(self.javadoc_output, Node.Node):
|
||||
self.javadoc_output = self.bld.path.find_or_declare(self.javadoc_output)
|
||||
|
||||
class javadoc(Task.Task):
|
||||
color='BLUE'
|
||||
"""
|
||||
Builds java documentation
|
||||
"""
|
||||
color = 'BLUE'
|
||||
|
||||
def __str__(self):
|
||||
return'%s: %s -> %s\n'%(self.__class__.__name__,self.generator.srcdir,self.generator.javadoc_output)
|
||||
return '%s: %s -> %s\n' % (self.__class__.__name__, self.generator.srcdir, self.generator.javadoc_output)
|
||||
|
||||
def run(self):
|
||||
env=self.env
|
||||
bld=self.generator.bld
|
||||
wd=bld.bldnode.abspath()
|
||||
srcpath=self.generator.path.abspath()+os.sep+self.generator.srcdir
|
||||
srcpath+=os.pathsep
|
||||
srcpath+=self.generator.path.get_bld().abspath()+os.sep+self.generator.srcdir
|
||||
classpath=env.CLASSPATH
|
||||
classpath+=os.pathsep
|
||||
classpath+=os.pathsep.join(self.classpath)
|
||||
classpath="".join(classpath)
|
||||
self.last_cmd=lst=[]
|
||||
lst.extend(Utils.to_list(env['JAVADOC']))
|
||||
lst.extend(['-d',self.generator.javadoc_output.abspath()])
|
||||
lst.extend(['-sourcepath',srcpath])
|
||||
lst.extend(['-classpath',classpath])
|
||||
env = self.env
|
||||
bld = self.generator.bld
|
||||
wd = bld.bldnode
|
||||
|
||||
#add src node + bld node (for generated java code)
|
||||
srcpath = self.generator.path.abspath() + os.sep + self.generator.srcdir
|
||||
srcpath += os.pathsep
|
||||
srcpath += self.generator.path.get_bld().abspath() + os.sep + self.generator.srcdir
|
||||
|
||||
classpath = env.CLASSPATH
|
||||
classpath += os.pathsep
|
||||
classpath += os.pathsep.join(self.classpath)
|
||||
classpath = "".join(classpath)
|
||||
|
||||
self.last_cmd = lst = []
|
||||
lst.extend(Utils.to_list(env.JAVADOC))
|
||||
lst.extend(['-d', self.generator.javadoc_output.abspath()])
|
||||
lst.extend(['-sourcepath', srcpath])
|
||||
lst.extend(['-classpath', classpath])
|
||||
lst.extend(['-subpackages'])
|
||||
lst.extend(self.generator.javadoc_package)
|
||||
lst=[x for x in lst if x]
|
||||
self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None,quiet=0)
|
||||
lst = [x for x in lst if x]
|
||||
|
||||
self.generator.bld.cmd_and_log(lst, cwd=wd, env=env.env or None, quiet=0)
|
||||
|
||||
def post_run(self):
|
||||
nodes=self.generator.javadoc_output.ant_glob('**')
|
||||
for x in nodes:
|
||||
x.sig=Utils.h_file(x.abspath())
|
||||
self.generator.bld.task_sigs[self.uid()]=self.cache_sig
|
||||
nodes = self.generator.javadoc_output.ant_glob('**', quiet=True)
|
||||
for node in nodes:
|
||||
self.generator.bld.node_sigs[node] = self.uid()
|
||||
self.generator.bld.task_sigs[self.uid()] = self.cache_sig
|
||||
|
||||
def configure(self):
|
||||
java_path=self.environ['PATH'].split(os.pathsep)
|
||||
v=self.env
|
||||
if'JAVA_HOME'in self.environ:
|
||||
java_path=[os.path.join(self.environ['JAVA_HOME'],'bin')]+java_path
|
||||
self.env['JAVA_HOME']=[self.environ['JAVA_HOME']]
|
||||
for x in'javac java jar javadoc'.split():
|
||||
self.find_program(x,var=x.upper(),path_list=java_path)
|
||||
self.env[x.upper()]=self.cmd_to_list(self.env[x.upper()])
|
||||
if'CLASSPATH'in self.environ:
|
||||
v['CLASSPATH']=self.environ['CLASSPATH']
|
||||
if not v['JAR']:self.fatal('jar is required for making java packages')
|
||||
if not v['JAVAC']:self.fatal('javac is required for compiling java classes')
|
||||
v['JARCREATE']='cf'
|
||||
v['JAVACFLAGS']=[]
|
||||
"""
|
||||
Detects the javac, java and jar programs
|
||||
"""
|
||||
# If JAVA_PATH is set, we prepend it to the path list
|
||||
java_path = self.environ['PATH'].split(os.pathsep)
|
||||
v = self.env
|
||||
|
||||
if 'JAVA_HOME' in self.environ:
|
||||
java_path = [os.path.join(self.environ['JAVA_HOME'], 'bin')] + java_path
|
||||
self.env.JAVA_HOME = [self.environ['JAVA_HOME']]
|
||||
|
||||
for x in 'javac java jar javadoc'.split():
|
||||
self.find_program(x, var=x.upper(), path_list=java_path, mandatory=(x not in ('javadoc')))
|
||||
|
||||
if 'CLASSPATH' in self.environ:
|
||||
v.CLASSPATH = self.environ['CLASSPATH']
|
||||
|
||||
if not v.JAR:
|
||||
self.fatal('jar is required for making java packages')
|
||||
if not v.JAVAC:
|
||||
self.fatal('javac is required for compiling java classes')
|
||||
|
||||
v.JARCREATE = 'cf' # can use cvf
|
||||
v.JAVACFLAGS = []
|
||||
|
||||
@conf
|
||||
def check_java_class(self,classname,with_classpath=None):
|
||||
javatestdir='.waf-javatest'
|
||||
classpath=javatestdir
|
||||
if self.env['CLASSPATH']:
|
||||
classpath+=os.pathsep+self.env['CLASSPATH']
|
||||
if isinstance(with_classpath,str):
|
||||
classpath+=os.pathsep+with_classpath
|
||||
shutil.rmtree(javatestdir,True)
|
||||
def check_java_class(self, classname, with_classpath=None):
|
||||
"""
|
||||
Checks if the specified java class exists
|
||||
|
||||
:param classname: class to check, like java.util.HashMap
|
||||
:type classname: string
|
||||
:param with_classpath: additional classpath to give
|
||||
:type with_classpath: string
|
||||
"""
|
||||
javatestdir = '.waf-javatest'
|
||||
|
||||
classpath = javatestdir
|
||||
if self.env.CLASSPATH:
|
||||
classpath += os.pathsep + self.env.CLASSPATH
|
||||
if isinstance(with_classpath, str):
|
||||
classpath += os.pathsep + with_classpath
|
||||
|
||||
shutil.rmtree(javatestdir, True)
|
||||
os.mkdir(javatestdir)
|
||||
Utils.writef(os.path.join(javatestdir,'Test.java'),class_check_source)
|
||||
self.exec_command(self.env['JAVAC']+[os.path.join(javatestdir,'Test.java')],shell=False)
|
||||
cmd=self.env['JAVA']+['-cp',classpath,'Test',classname]
|
||||
self.to_log("%s\n"%str(cmd))
|
||||
found=self.exec_command(cmd,shell=False)
|
||||
self.msg('Checking for java class %s'%classname,not found)
|
||||
shutil.rmtree(javatestdir,True)
|
||||
|
||||
Utils.writef(os.path.join(javatestdir, 'Test.java'), class_check_source)
|
||||
|
||||
# Compile the source
|
||||
self.exec_command(self.env.JAVAC + [os.path.join(javatestdir, 'Test.java')], shell=False)
|
||||
|
||||
# Try to run the app
|
||||
cmd = self.env.JAVA + ['-cp', classpath, 'Test', classname]
|
||||
self.to_log("%s\n" % str(cmd))
|
||||
found = self.exec_command(cmd, shell=False)
|
||||
|
||||
self.msg('Checking for java class %s' % classname, not found)
|
||||
|
||||
shutil.rmtree(javatestdir, True)
|
||||
|
||||
return found
|
||||
|
||||
@conf
|
||||
def check_jni_headers(conf):
|
||||
"""
|
||||
Checks for jni headers and libraries. On success the conf.env variables xxx_JAVA are added for use in C/C++ targets::
|
||||
|
||||
def options(opt):
|
||||
opt.load('compiler_c')
|
||||
|
||||
def configure(conf):
|
||||
conf.load('compiler_c java')
|
||||
conf.check_jni_headers()
|
||||
|
||||
def build(bld):
|
||||
bld.shlib(source='a.c', target='app', use='JAVA')
|
||||
"""
|
||||
if not conf.env.CC_NAME and not conf.env.CXX_NAME:
|
||||
conf.fatal('load a compiler first (gcc, g++, ..)')
|
||||
|
||||
if not conf.env.JAVA_HOME:
|
||||
conf.fatal('set JAVA_HOME in the system environment')
|
||||
javaHome=conf.env['JAVA_HOME'][0]
|
||||
dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/include')
|
||||
|
||||
# jni requires the jvm
|
||||
javaHome = conf.env.JAVA_HOME[0]
|
||||
|
||||
dir = conf.root.find_dir(conf.env.JAVA_HOME[0] + '/include')
|
||||
if dir is None:
|
||||
dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/../Headers')
|
||||
dir = conf.root.find_dir(conf.env.JAVA_HOME[0] + '/../Headers') # think different?!
|
||||
if dir is None:
|
||||
conf.fatal('JAVA_HOME does not seem to be set properly')
|
||||
f=dir.ant_glob('**/(jni|jni_md).h')
|
||||
incDirs=[x.parent.abspath()for x in f]
|
||||
dir=conf.root.find_dir(conf.env.JAVA_HOME[0])
|
||||
f=dir.ant_glob('**/*jvm.(so|dll|dylib)')
|
||||
libDirs=[x.parent.abspath()for x in f]or[javaHome]
|
||||
f=dir.ant_glob('**/*jvm.(lib)')
|
||||
|
||||
f = dir.ant_glob('**/(jni|jni_md).h')
|
||||
incDirs = [x.parent.abspath() for x in f]
|
||||
|
||||
dir = conf.root.find_dir(conf.env.JAVA_HOME[0])
|
||||
f = dir.ant_glob('**/*jvm.(so|dll|dylib)')
|
||||
libDirs = [x.parent.abspath() for x in f] or [javaHome]
|
||||
|
||||
# On windows, we need both the .dll and .lib to link. On my JDK, they are
|
||||
# in different directories...
|
||||
f = dir.ant_glob('**/*jvm.(lib)')
|
||||
if f:
|
||||
libDirs=[[x,y.parent.abspath()]for x in libDirs for y in f]
|
||||
libDirs = [[x, y.parent.abspath()] for x in libDirs for y in f]
|
||||
|
||||
if conf.env.DEST_OS == 'freebsd':
|
||||
conf.env.append_unique('LINKFLAGS_JAVA', '-pthread')
|
||||
for d in libDirs:
|
||||
try:
|
||||
conf.check(header_name='jni.h',define_name='HAVE_JNI_H',lib='jvm',libpath=d,includes=incDirs,uselib_store='JAVA',uselib='JAVA')
|
||||
conf.check(header_name='jni.h', define_name='HAVE_JNI_H', lib='jvm',
|
||||
libpath=d, includes=incDirs, uselib_store='JAVA', uselib='JAVA')
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
break
|
||||
else:
|
||||
conf.fatal('could not find lib jvm in %r (see config.log)'%libDirs)
|
||||
conf.fatal('could not find lib jvm in %r (see config.log)' % libDirs)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user