@Override
public final void narExecute() throws MojoExecutionException, MojoFailureException {
if (!useGnu() || gnuMakeSkip) {
return;
}
final File srcDir = getGnuAOLSourceDirectory();
if (srcDir.exists()) {
String[] args = null;
String[] env = null;
if (this.gnuMakeArgs != null) {
args = this.gnuMakeArgs.split(" ");
}
if (this.gnuMakeEnv != null) {
env = this.gnuMakeEnv.split(",");
}
getLog().info("Running GNU make");
int result = NarUtil.runCommand("make", args, srcDir, env, getLog());
if (result != 0) {
throw new MojoExecutionException("'make' errorcode: " + result);
}
if (!this.gnuMakeInstallSkip) {
getLog().info("Running make install");
if (args != null) {
this.gnuMakeArgs = this.gnuMakeArgs + " install";
args = this.gnuMakeArgs.split(" ");
} else {
args = new String[] {"install"};
}
result = NarUtil.runCommand("make", args, srcDir, null, getLog());
if (result != 0) {
throw new MojoExecutionException("'make install' errorcode: " + result);
}
}
}
}
private void createLibrary(final Project antProject, final Library library)
throws MojoExecutionException, MojoFailureException {
getLog().debug("Creating Library " + library);
// configure task
final CCTask task = new CCTask();
task.setCommandLogLevel(this.commandLogLevel);
task.setProject(antProject);
task.setDecorateLinkerOptions(this.decorateLinkerOptions);
// subsystem
final SubsystemEnum subSystem = new SubsystemEnum();
subSystem.setValue(library.getSubSystem());
task.setSubsystem(subSystem);
// set max cores
task.setMaxCores(getMaxCores(getAOL()));
// outtype
final OutputTypeEnum outTypeEnum = new OutputTypeEnum();
final String type = library.getType();
outTypeEnum.setValue(type);
task.setOuttype(outTypeEnum);
// stdc++
task.setLinkCPP(library.linkCPP());
// fortran
task.setLinkFortran(library.linkFortran());
task.setLinkFortranMain(library.linkFortranMain());
// outDir
File outDir;
if (type.equals(Library.EXECUTABLE)) {
outDir =
getLayout()
.getBinDirectory(
getTargetDirectory(),
getMavenProject().getArtifactId(),
getMavenProject().getVersion(),
getAOL().toString());
} else {
outDir =
getLayout()
.getLibDirectory(
getTargetDirectory(),
getMavenProject().getArtifactId(),
getMavenProject().getVersion(),
getAOL().toString(),
type);
}
outDir.mkdirs();
// outFile
// FIXME NAR-90 we could get the final name from layout
final File outFile = new File(outDir, getOutput(getAOL(), type));
getLog().debug("NAR - output: '" + outFile + "'");
task.setOutfile(outFile);
// object directory
File objDir = new File(getTargetDirectory(), "obj");
objDir = new File(objDir, getAOL().toString());
objDir.mkdirs();
task.setObjdir(objDir);
// failOnError, libtool
task.setFailonerror(failOnError(getAOL()));
task.setLibtool(useLibtool(getAOL()));
// runtime
final RuntimeType runtimeType = new RuntimeType();
runtimeType.setValue(getRuntime(getAOL()));
task.setRuntime(runtimeType);
// IDL, MC, RC compilations should probably be 'generate source' type
// actions, seperate from main build.
// Needs resolution of handling for generate sources.
// Order is somewhat important here, IDL and MC generate outputs that are
// (often) included in the RC compilation
if (getIdl() != null) {
final CompilerDef idl = getIdl().getCompiler(Compiler.MAIN, null);
if (idl != null) {
task.addConfiguredCompiler(idl);
}
}
if (getMessage() != null) {
final CompilerDef mc = getMessage().getCompiler(Compiler.MAIN, null);
if (mc != null) {
task.addConfiguredCompiler(mc);
}
}
if (getResource() != null) {
final CompilerDef res = getResource().getCompiler(Compiler.MAIN, null);
if (res != null) {
task.addConfiguredCompiler(res);
}
}
// Darren Sargent Feb 11 2010: Use Compiler.MAIN for "type"...appears the
// wrong "type" variable was being used
// since getCompiler() expects "main" or "test", whereas the "type" variable
// here is "executable", "shared" etc.
// add C++ compiler
if (getCpp() != null) {
final CompilerDef cpp = getCpp().getCompiler(Compiler.MAIN, null);
if (cpp != null) {
task.addConfiguredCompiler(cpp);
}
}
// add C compiler
if (getC() != null) {
final CompilerDef c = getC().getCompiler(Compiler.MAIN, null);
if (c != null) {
task.addConfiguredCompiler(c);
}
}
// add Fortran compiler
if (getFortran() != null) {
final CompilerDef fortran = getFortran().getCompiler(Compiler.MAIN, null);
if (fortran != null) {
task.addConfiguredCompiler(fortran);
}
}
// end Darren
// add javah include path
final File jniDirectory = getJavah().getJniDirectory();
if (jniDirectory.exists()) {
task.createIncludePath().setPath(jniDirectory.getPath());
}
// add java include paths
getJava().addIncludePaths(task, type);
final List<NarArtifact> dependencies = getNarArtifacts();
// add dependency include paths
for (final Object element : dependencies) {
// FIXME, handle multiple includes from one NAR
final NarArtifact narDependency = (NarArtifact) element;
final String binding = narDependency.getNarInfo().getBinding(getAOL(), Library.STATIC);
getLog().debug("Looking for " + narDependency + " found binding " + binding);
if (!binding.equals(Library.JNI)) {
final File unpackDirectory = getUnpackDirectory();
final File include =
getLayout()
.getIncludeDirectory(
unpackDirectory, narDependency.getArtifactId(), narDependency.getBaseVersion());
getLog().debug("Looking for include directory: " + include);
if (include.exists()) {
task.createIncludePath().setPath(include.getPath());
} else {
throw new MojoExecutionException("NAR: unable to locate include path: " + include);
}
}
}
// add linker
final LinkerDef linkerDefinition =
getLinker().getLinker(this, antProject, getOS(), getAOL().getKey() + ".linker.", type);
task.addConfiguredLinker(linkerDefinition);
// add dependency libraries
// FIXME: what about PLUGIN and STATIC, depending on STATIC, should we
// not add all libraries, see NARPLUGIN-96
if (type.equals(Library.SHARED)
|| type.equals(Library.JNI)
|| type.equals(Library.EXECUTABLE)) {
final List depLibOrder = getDependencyLibOrder();
List depLibs = dependencies;
// reorder the libraries that come from the nar dependencies
// to comply with the order specified by the user
if (depLibOrder != null && !depLibOrder.isEmpty()) {
final List tmp = new LinkedList();
for (final Iterator i = depLibOrder.iterator(); i.hasNext(); ) {
final String depToOrderName = (String) i.next();
for (final Iterator j = depLibs.iterator(); j.hasNext(); ) {
final NarArtifact dep = (NarArtifact) j.next();
final String depName = dep.getGroupId() + ":" + dep.getArtifactId();
if (depName.equals(depToOrderName)) {
tmp.add(dep);
j.remove();
}
}
}
tmp.addAll(depLibs);
depLibs = tmp;
}
for (final Iterator i = depLibs.iterator(); i.hasNext(); ) {
final NarArtifact dependency = (NarArtifact) i.next();
// FIXME no handling of "local"
// FIXME, no way to override this at this stage
final String binding = dependency.getNarInfo().getBinding(getAOL(), Library.NONE);
getLog().debug("Using Binding: " + binding);
AOL aol = getAOL();
aol = dependency.getNarInfo().getAOL(getAOL());
getLog().debug("Using Library AOL: " + aol.toString());
if (!binding.equals(Library.JNI)
&& !binding.equals(Library.NONE)
&& !binding.equals(Library.EXECUTABLE)) {
final File unpackDirectory = getUnpackDirectory();
final File dir =
getLayout()
.getLibDirectory(
unpackDirectory,
dependency.getArtifactId(),
dependency.getBaseVersion(),
aol.toString(),
binding);
getLog().debug("Looking for Library Directory: " + dir);
if (dir.exists()) {
final LibrarySet libSet = new LibrarySet();
libSet.setProject(antProject);
// FIXME, no way to override
final String libs = dependency.getNarInfo().getLibs(getAOL());
if (libs != null && !libs.equals("")) {
getLog().debug("Using LIBS = " + libs);
libSet.setLibs(new CUtil.StringArrayBuilder(libs));
libSet.setDir(dir);
task.addLibset(libSet);
}
} else {
getLog().debug("Library Directory " + dir + " does NOT exist.");
}
// FIXME, look again at this, for multiple dependencies we may need to
// remove duplicates
final String options = dependency.getNarInfo().getOptions(getAOL());
if (options != null && !options.equals("")) {
getLog().debug("Using OPTIONS = " + options);
final LinkerArgument arg = new LinkerArgument();
arg.setValue(options);
linkerDefinition.addConfiguredLinkerArg(arg);
}
final String sysLibs = dependency.getNarInfo().getSysLibs(getAOL());
if (sysLibs != null && !sysLibs.equals("")) {
getLog().debug("Using SYSLIBS = " + sysLibs);
final SystemLibrarySet sysLibSet = new SystemLibrarySet();
sysLibSet.setProject(antProject);
sysLibSet.setLibs(new CUtil.StringArrayBuilder(sysLibs));
task.addSyslibset(sysLibSet);
}
}
}
}
// Add JVM to linker
getJava().addRuntime(task, getJavaHome(getAOL()), getOS(), getAOL().getKey() + ".java.");
// execute
try {
task.execute();
} catch (final BuildException e) {
throw new MojoExecutionException("NAR: Compile failed", e);
}
// FIXME, this should be done in CPPTasks at some point
if (getRuntime(getAOL()).equals("dynamic")
&& getOS().equals(OS.WINDOWS)
&& getLinker().getName(null, null).equals("msvc")
&& !getLinker().getVersion().startsWith("6.")) {
final String libType = library.getType();
if (libType.equals(Library.JNI) || libType.equals(Library.SHARED)) {
final String dll = outFile.getPath() + ".dll";
final String manifest = dll + ".manifest";
final int result =
NarUtil.runCommand(
"mt.exe",
new String[] {"/manifest", manifest, "/outputresource:" + dll + ";#2"},
null,
null,
getLog());
if (result != 0) {
throw new MojoFailureException("MT.EXE failed with exit code: " + result);
}
} else if (libType.equals(Library.EXECUTABLE)) {
final String exe = outFile.getPath() + ".exe";
final String manifest = exe + ".manifest";
final int result =
NarUtil.runCommand(
"mt.exe",
new String[] {"/manifest", manifest, "/outputresource:" + exe + ";#1"},
null,
null,
getLog());
if (result != 0) {
throw new MojoFailureException("MT.EXE failed with exit code: " + result);
}
}
}
}
public final String getVersion(final AbstractNarMojo mojo)
throws MojoFailureException, MojoExecutionException {
if (this.name == null) {
throw new MojoFailureException("Cannot deduce linker version if name is null");
}
String version = null;
final TextStream out = new StringTextStream();
final TextStream err = new StringTextStream();
final TextStream dbg = new StringTextStream();
if (this.name.equals("g++") || this.name.equals("gcc")) {
NarUtil.runCommand("gcc", new String[] {"--version"}, null, null, out, err, dbg, this.log);
final Pattern p = Pattern.compile("\\d+\\.\\d+\\.\\d+");
final Matcher m = p.matcher(out.toString());
if (m.find()) {
version = m.group(0);
}
} else if (this.name.equals("msvc")) {
version = mojo.getMsvc().getVersion();
} else if (this.name.equals("icc") || this.name.equals("icpc")) {
NarUtil.runCommand("icc", new String[] {"--version"}, null, null, out, err, dbg, this.log);
final Pattern p = Pattern.compile("\\d+\\.\\d+");
final Matcher m = p.matcher(out.toString());
if (m.find()) {
version = m.group(0);
}
} else if (this.name.equals("icl")) {
NarUtil.runCommand("icl", new String[] {"/QV"}, null, null, out, err, dbg, this.log);
final Pattern p = Pattern.compile("\\d+\\.\\d+");
final Matcher m = p.matcher(err.toString());
if (m.find()) {
version = m.group(0);
}
} else if (this.name.equals("CC")) {
NarUtil.runCommand("CC", new String[] {"-V"}, null, null, out, err, dbg, this.log);
final Pattern p = Pattern.compile("\\d+\\.d+");
final Matcher m = p.matcher(err.toString());
if (m.find()) {
version = m.group(0);
}
} else if (this.name.equals("xlC")) {
NarUtil.runCommand(
"/usr/vacpp/bin/xlC", new String[] {"-qversion"}, null, null, out, err, dbg, this.log);
final Pattern p = Pattern.compile("\\d+\\.\\d+");
final Matcher m = p.matcher(out.toString());
if (m.find()) {
version = m.group(0);
}
} else {
throw new MojoFailureException("Cannot find version number for linker '" + this.name + "'");
}
if (version == null) {
if (!err.toString().isEmpty())
mojo.getLog().debug("linker returned error stream: " + err.toString());
throw new MojoFailureException("Cannot deduce version number from: " + out.toString());
}
return version;
}
