use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator in project arduino-eclipse-plugin by Sloeber.
the class ArduinoGnuMakefileGenerator method addRuleForSource.
/**
* Create a rule for this source file. We create a pattern rule if possible.
* This is an example of a pattern rule:
* <relative_path>/%.<outputExtension>: ../<relative_path>/%.
* <inputExtension>
*
* @echo Building file: $<
* @echo Invoking tool xxx
* @echo <tool> <flags> <output_flag><output_prefix>$@ $<
* @<tool> <flags> <output_flag><output_prefix>$@ $< && \ echo -n
* $(@:%.o=%.d) ' <relative_path>/' >> $(@:%.o=%.d) && \ <tool> -P
* -MM -MG <flags> $< >> $(@:%.o=%.d)
* @echo Finished building: $<
* @echo ' ' Note that the macros all come from the build model and are
* resolved to a real command before writing to the module makefile,
* so a real command might look something like: source1/%.o:
* ../source1/%.cpp
* @echo Building file: $<
* @echo Invoking tool xxx
* @echo g++ -g -O2 -c -I/cygdrive/c/eclipse/workspace/Project/headers -o$@
* $< @g++ -g -O2 -c -I/cygdrive/c/eclipse/workspace/Project/headers
* -o$@ $< && \ echo -n $(@:%.o=%.d) ' source1/' >> $(@:%.o=%.d) && \
* g++ -P -MM -MG -g -O2 -c
* -I/cygdrive/c/eclipse/workspace/Project/headers $< >> $(@:%.o=%.d)
* @echo Finished building: $<
* @echo ' '
* @param relativePath
* top build output directory relative path of the current output
* directory
* @param buffer
* buffer to populate with the build rule
* @param resource
* the source file for this invocation of the tool
* @param sourceLocation
* the full path of the source
* @param rcInfo
* the IResourceInfo associated with this file or null
* @param generatedSource
* <code>true</code> if the resource is a generated output
* @param enumeratedOutputs
* vector of the filenames that are the output of this rule
*/
@SuppressWarnings("null")
protected void addRuleForSource(String relativePath, StringBuffer buffer, IResource resource, IPath sourceLocation, IResourceInfo rcInfo, boolean generatedSource, List<IPath> generatedDepFiles, List<IPath> enumeratedOutputs) {
String fileName = sourceLocation.removeFileExtension().lastSegment();
String inputExtension = sourceLocation.getFileExtension();
String outputExtension = null;
ITool tool = null;
if (rcInfo instanceof IFileInfo) {
IFileInfo fi = (IFileInfo) rcInfo;
ITool[] tools = fi.getToolsToInvoke();
if (tools != null && tools.length > 0) {
tool = tools[0];
}
} else {
IFolderInfo foInfo = (IFolderInfo) rcInfo;
tool = foInfo.getToolFromInputExtension(inputExtension);
}
ToolInfoHolder h = getToolInfo(rcInfo.getPath());
if (tool != null)
outputExtension = tool.getOutputExtension(inputExtension);
if (outputExtension == null)
outputExtension = EMPTY_STRING;
// Get the dependency generator information for this tool and file
// extension
IManagedDependencyGenerator oldDepGen = null;
IManagedDependencyGenerator2 depGen = null;
IManagedDependencyInfo depInfo = null;
IManagedDependencyCommands depCommands = null;
IManagedDependencyPreBuild depPreBuild = null;
IPath[] depFiles = null;
boolean doDepGen = false;
{
IManagedDependencyGeneratorType t = null;
if (tool != null)
t = tool.getDependencyGeneratorForExtension(inputExtension);
if (t != null) {
int calcType = t.getCalculatorType();
if (calcType <= IManagedDependencyGeneratorType.TYPE_OLD_TYPE_LIMIT) {
oldDepGen = (IManagedDependencyGenerator) t;
doDepGen = (calcType == IManagedDependencyGeneratorType.TYPE_COMMAND);
if (doDepGen) {
IPath depFile = Path.fromOSString(relativePath + fileName + DOT + DEP_EXT);
getDependencyMakefiles(h).add(depFile);
generatedDepFiles.add(depFile);
}
} else {
depGen = (IManagedDependencyGenerator2) t;
doDepGen = (calcType == IManagedDependencyGeneratorType.TYPE_BUILD_COMMANDS);
IBuildObject buildContext = rcInfo;
depInfo = depGen.getDependencySourceInfo(resource.getProjectRelativePath(), resource, buildContext, tool, getBuildWorkingDir());
if (calcType == IManagedDependencyGeneratorType.TYPE_BUILD_COMMANDS) {
depCommands = (IManagedDependencyCommands) depInfo;
depFiles = depCommands.getDependencyFiles();
} else if (calcType == IManagedDependencyGeneratorType.TYPE_PREBUILD_COMMANDS) {
depPreBuild = (IManagedDependencyPreBuild) depInfo;
depFiles = depPreBuild.getDependencyFiles();
}
if (depFiles != null) {
for (IPath depFile : depFiles) {
getDependencyMakefiles(h).add(depFile);
generatedDepFiles.add(depFile);
}
}
}
}
}
// Figure out the output paths
String optDotExt = EMPTY_STRING;
if (outputExtension.length() > 0)
optDotExt = DOT + outputExtension;
List<IPath> ruleOutputs = new ArrayList<>();
List<IPath> enumeratedPrimaryOutputs = new ArrayList<>();
List<IPath> enumeratedSecondaryOutputs = new ArrayList<>();
// JABA
this.usedOutType = tool.getPrimaryOutputType();
calculateOutputsForSource(tool, relativePath, resource, sourceLocation, ruleOutputs, enumeratedPrimaryOutputs, enumeratedSecondaryOutputs);
enumeratedOutputs.addAll(enumeratedPrimaryOutputs);
enumeratedOutputs.addAll(enumeratedSecondaryOutputs);
String primaryOutputName = null;
if (enumeratedPrimaryOutputs.size() > 0) {
primaryOutputName = escapeWhitespaces(enumeratedPrimaryOutputs.get(0).toOSString());
} else {
primaryOutputName = escapeWhitespaces(relativePath + fileName + optDotExt);
}
String otherPrimaryOutputs = EMPTY_STRING;
for (int i = 1; i < enumeratedPrimaryOutputs.size(); i++) {
otherPrimaryOutputs += WHITESPACE + escapeWhitespaces(enumeratedPrimaryOutputs.get(i).toOSString());
}
// Output file location needed for the file-specific build macros
IPath outputLocation = Path.fromOSString(primaryOutputName);
if (!outputLocation.isAbsolute()) {
outputLocation = getPathForResource(this.project).append(getBuildWorkingDir()).append(primaryOutputName);
}
// A separate rule is needed for the resource in the case where explicit
// file-specific macros
// are referenced, or if the resource contains special characters in its
// path (e.g., whitespace)
/*
* fix for 137674 We only need an explicit rule if one of the following
* is true: - The resource is linked, and its full path to its real
* location contains special characters - The resource is not linked,
* but its project relative path contains special characters
*/
boolean resourceNameRequiresExplicitRule = (resource.isLinked() && containsSpecialCharacters(sourceLocation.toOSString())) || (!resource.isLinked() && containsSpecialCharacters(resource.getProjectRelativePath().toOSString()));
boolean needExplicitRuleForFile = resourceNameRequiresExplicitRule || BuildMacroProvider.getReferencedExplitFileMacros(tool).length > 0 || BuildMacroProvider.getReferencedExplitFileMacros(tool.getToolCommand(), IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool)).length > 0;
// Get and resolve the command
String cmd = tool.getToolCommand();
try {
String resolvedCommand = null;
if (!needExplicitRuleForFile) {
resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(cmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
} else {
// if we need an explicit rule then don't use any builder
// variables, resolve everything
// to explicit strings
resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValue(cmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
}
if ((resolvedCommand = resolvedCommand.trim()).length() > 0)
cmd = resolvedCommand;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
String defaultOutputName = EMPTY_STRING;
String primaryDependencyName = EMPTY_STRING;
String patternPrimaryDependencyName = EMPTY_STRING;
String home = (generatedSource) ? DOT : ROOT;
String resourcePath = null;
boolean patternRule = true;
boolean isItLinked = false;
if (resource.isLinked(IResource.CHECK_ANCESTORS)) {
// it IS linked, so use the actual location
isItLinked = true;
resourcePath = sourceLocation.toOSString();
// Need a hardcoded rule, not a pattern rule, as a linked file
// can reside in any path
defaultOutputName = escapeWhitespaces(relativePath + fileName + optDotExt);
primaryDependencyName = escapeWhitespaces(resourcePath);
patternRule = false;
} else {
// Use the relative path (not really needed to store per se but in
// the future someone may want this)
resourcePath = relativePath;
// The rule and command to add to the makefile
if (rcInfo instanceof IFileInfo || needExplicitRuleForFile) {
// Need a hardcoded rule, not a pattern rule
defaultOutputName = escapeWhitespaces(resourcePath + fileName + optDotExt);
patternRule = false;
} else {
defaultOutputName = relativePath + WILDCARD + optDotExt;
}
primaryDependencyName = escapeWhitespaces(home + FILE_SEPARATOR + resourcePath + fileName + DOT + inputExtension);
patternPrimaryDependencyName = home + FILE_SEPARATOR + resourcePath + WILDCARD + DOT + inputExtension;
}
// end fix for PR 70491
// If the tool specifies a dependency calculator of
// TYPE_BUILD_COMMANDS,
// ask whether
// the dependency commands are "generic" (i.e., we can use a pattern
// rule)
boolean needExplicitDependencyCommands = false;
if (depCommands != null) {
needExplicitDependencyCommands = !depCommands.areCommandsGeneric();
}
// things
if (patternRule) {
patternRule = false;
// Make sure that at least one of the rule outputs contains a %.
for (int i = 0; i < ruleOutputs.size(); i++) {
String ruleOutput = ruleOutputs.get(i).toOSString();
if (ruleOutput.indexOf('%') >= 0) {
patternRule = true;
break;
}
}
if (patternRule) {
patternRule = !needExplicitDependencyCommands;
}
}
// Begin building the rule for this source file
String buildRule = EMPTY_STRING;
if (patternRule) {
if (ruleOutputs.size() == 0) {
buildRule += defaultOutputName;
} else {
boolean first = true;
for (int i = 0; i < ruleOutputs.size(); i++) {
String ruleOutput = ruleOutputs.get(i).toOSString();
if (ruleOutput.indexOf('%') >= 0) {
if (first) {
first = false;
} else {
buildRule += WHITESPACE;
}
buildRule += ruleOutput;
}
}
}
} else {
buildRule += primaryOutputName;
}
String buildRuleDependencies = primaryDependencyName;
String patternBuildRuleDependencies = patternPrimaryDependencyName;
// Other additional inputs
// Get any additional dependencies specified for the tool in other
// InputType elements and AdditionalInput elements
IPath[] addlDepPaths = tool.getAdditionalDependencies();
for (IPath addlDepPath : addlDepPaths) {
// Translate the path from project relative to build directory
// relative
IPath addlPath = addlDepPath;
if (!(addlPath.toString().startsWith("$("))) {
if (!addlPath.isAbsolute()) {
IPath tempPath = this.project.getLocation().append(new Path(ensureUnquoted(addlPath.toString())));
if (tempPath != null) {
addlPath = ManagedBuildManager.calculateRelativePath(getTopBuildDir(), tempPath);
}
}
}
String suitablePath = ensurePathIsGNUMakeTargetRuleCompatibleSyntax(addlPath.toOSString());
buildRuleDependencies += WHITESPACE + suitablePath;
patternBuildRuleDependencies += WHITESPACE + suitablePath;
}
buildRule += COLON + WHITESPACE + (patternRule ? patternBuildRuleDependencies : buildRuleDependencies);
// it or the commands to build the file
if (getRuleList().contains(buildRule)) {
// TODO: Should we assert that this is a pattern rule?
} else {
getRuleList().add(buildRule);
// Echo starting message
buffer.append(buildRule + NEWLINE);
buffer.append(TAB + AT + escapedEcho(MESSAGE_START_FILE + WHITESPACE + IN_MACRO));
buffer.append(TAB + AT + escapedEcho(tool.getAnnouncement()));
// there are any pre-tool commands.
if (depCommands != null) {
String[] preToolCommands = depCommands.getPreToolDependencyCommands();
if (preToolCommands != null && preToolCommands.length > 0) {
for (String preCmd : preToolCommands) {
try {
String resolvedCommand;
IBuildMacroProvider provider = ManagedBuildManager.getBuildMacroProvider();
if (!needExplicitRuleForFile) {
resolvedCommand = provider.resolveValueToMakefileFormat(preCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
} else {
// if we need an explicit rule then don't use
// any builder
// variables, resolve everything to explicit
// strings
resolvedCommand = provider.resolveValue(preCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
}
if (resolvedCommand != null)
buffer.append(resolvedCommand).append(NEWLINE);
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
}
}
}
// Generate the command line
Vector<String> inputs = new Vector<>();
inputs.add(IN_MACRO);
// Other additional inputs
// Get any additional dependencies specified for the tool in other
// InputType elements and AdditionalInput elements
IPath[] addlInputPaths = getAdditionalResourcesForSource(tool);
for (IPath addlInputPath : addlInputPaths) {
// Translate the path from project relative to build directory
// relative
IPath addlPath = addlInputPath;
if (!(addlPath.toString().startsWith("$("))) {
if (!addlPath.isAbsolute()) {
IPath tempPath = getPathForResource(this.project).append(addlPath);
if (tempPath != null) {
addlPath = ManagedBuildManager.calculateRelativePath(getTopBuildDir(), tempPath);
}
}
}
inputs.add(addlPath.toOSString());
}
String[] inputStrings = inputs.toArray(new String[inputs.size()]);
String[] flags = null;
// Get the tool command line options
try {
flags = tool.getToolCommandFlags(sourceLocation, outputLocation);
} catch (BuildException ex) {
// TODO add some routines to catch this
flags = EMPTY_STRING_ARRAY;
}
// it wants added to the command line
if (depCommands != null) {
flags = addDependencyOptions(depCommands, flags);
}
IManagedCommandLineInfo cmdLInfo = null;
String outflag = null;
String outputPrefix = null;
if (rcInfo instanceof IFileInfo || needExplicitRuleForFile || needExplicitDependencyCommands) {
outflag = tool.getOutputFlag();
outputPrefix = tool.getOutputPrefix();
// Call the command line generator
IManagedCommandLineGenerator cmdLGen = tool.getCommandLineGenerator();
cmdLInfo = cmdLGen.generateCommandLineInfo(tool, cmd, flags, outflag, outputPrefix, OUT_MACRO + otherPrimaryOutputs, inputStrings, tool.getCommandLinePattern());
} else {
// config.getOutputFlag(outputExtension);
outflag = tool.getOutputFlag();
// config.getOutputPrefix(outputExtension);
outputPrefix = tool.getOutputPrefix();
// Call the command line generator
cmdLInfo = generateToolCommandLineInfo(tool, inputExtension, flags, outflag, outputPrefix, OUT_MACRO + otherPrimaryOutputs, inputStrings, sourceLocation, outputLocation);
}
// The command to build
String buildCmd;
if (cmdLInfo != null) {
buildCmd = cmdLInfo.getCommandLine();
} else {
StringBuffer buildFlags = new StringBuffer();
for (String flag : flags) {
if (flag != null) {
buildFlags.append(flag).append(WHITESPACE);
}
}
buildCmd = cmd + WHITESPACE + buildFlags.toString().trim() + WHITESPACE + outflag + WHITESPACE + outputPrefix + OUT_MACRO + otherPrimaryOutputs + WHITESPACE + IN_MACRO;
}
// generated
try {
String resolvedCommand;
IBuildMacroProvider provider = ManagedBuildManager.getBuildMacroProvider();
if (!needExplicitRuleForFile) {
resolvedCommand = provider.resolveValueToMakefileFormat(buildCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
} else {
// if we need an explicit rule then don't use any builder
// variables, resolve everything to explicit strings
resolvedCommand = provider.resolveValue(buildCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
}
if ((resolvedCommand = resolvedCommand.trim()).length() > 0)
buildCmd = resolvedCommand;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
// buffer.append(TAB).append(AT).append(escapedEcho(buildCmd));
// buffer.append(TAB).append(AT).append(buildCmd);
buffer.append(TAB).append(buildCmd);
// Determine if there are any dependencies to calculate
if (doDepGen) {
// Get the dependency rule out of the generator
String[] depCmds = null;
if (oldDepGen != null) {
depCmds = new String[1];
depCmds[0] = oldDepGen.getDependencyCommand(resource, ManagedBuildManager.getBuildInfo(this.project));
} else {
if (depCommands != null) {
depCmds = depCommands.getPostToolDependencyCommands();
}
}
if (depCmds != null) {
for (String depCmd : depCmds) {
// Resolve any macros in the dep command after it has
// been generated.
// Note: do not trim the result because it will strip
// out necessary tab characters.
buffer.append(WHITESPACE).append(LOGICAL_AND).append(WHITESPACE).append(LINEBREAK);
try {
if (!needExplicitRuleForFile) {
depCmd = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(depCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
} else {
depCmd = ManagedBuildManager.getBuildMacroProvider().resolveValue(depCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
}
} catch (BuildMacroException e) {
/* JABA is not going to do this */
}
buffer.append(depCmd);
}
}
}
// Echo finished message
buffer.append(NEWLINE);
buffer.append(TAB + AT + escapedEcho(MESSAGE_FINISH_FILE + WHITESPACE + IN_MACRO));
buffer.append(TAB + AT + ECHO_BLANK_LINE + NEWLINE);
}
// Determine if there are calculated dependencies
IPath[] addlDeps = null;
IPath[] addlTargets = null;
String calculatedDependencies = null;
boolean addedDepLines = false;
String depLine;
if (oldDepGen != null && oldDepGen.getCalculatorType() != IManagedDependencyGeneratorType.TYPE_COMMAND) {
addlDeps = oldCalculateDependenciesForSource(oldDepGen, tool, relativePath, resource);
} else {
if (depGen != null && depGen.getCalculatorType() == IManagedDependencyGeneratorType.TYPE_CUSTOM) {
if (depInfo instanceof IManagedDependencyCalculator) {
IManagedDependencyCalculator depCalculator = (IManagedDependencyCalculator) depInfo;
addlDeps = calculateDependenciesForSource(depCalculator);
addlTargets = depCalculator.getAdditionalTargets();
}
}
}
if (addlDeps != null && addlDeps.length > 0) {
calculatedDependencies = new String();
for (IPath addlDep : addlDeps) {
calculatedDependencies += WHITESPACE + escapeWhitespaces(addlDep.toOSString());
}
}
if (calculatedDependencies != null) {
depLine = primaryOutputName + COLON + calculatedDependencies + NEWLINE;
if (!getDepLineList().contains(depLine)) {
getDepLineList().add(depLine);
addedDepLines = true;
buffer.append(depLine);
}
}
// Add any additional outputs here using dependency lines
Vector<IPath> addlOutputs = new Vector<>();
if (enumeratedPrimaryOutputs.size() > 1) {
// output
for (int i = 1; i < enumeratedPrimaryOutputs.size(); i++) addlOutputs.add(enumeratedPrimaryOutputs.get(i));
}
addlOutputs.addAll(enumeratedSecondaryOutputs);
if (addlTargets != null) {
for (IPath addlTarget : addlTargets) addlOutputs.add(addlTarget);
}
for (int i = 0; i < addlOutputs.size(); i++) {
depLine = escapeWhitespaces(addlOutputs.get(i).toOSString()) + COLON + WHITESPACE + primaryOutputName;
if (calculatedDependencies != null)
depLine += calculatedDependencies;
depLine += NEWLINE;
if (!getDepLineList().contains(depLine)) {
getDepLineList().add(depLine);
addedDepLines = true;
buffer.append(depLine);
}
}
if (addedDepLines) {
buffer.append(NEWLINE);
}
// get the rule to build the dependency file
if (depPreBuild != null && depFiles != null) {
addedDepLines = false;
String[] preBuildCommands = depPreBuild.getDependencyCommands();
if (preBuildCommands != null) {
depLine = "";
// Can we use a pattern rule?
patternRule = !isItLinked && !needExplicitRuleForFile && depPreBuild.areCommandsGeneric();
// Begin building the rule
for (int i = 0; i < depFiles.length; i++) {
if (i > 0)
depLine += WHITESPACE;
if (patternRule) {
optDotExt = EMPTY_STRING;
String depExt = depFiles[i].getFileExtension();
if (depExt != null && depExt.length() > 0)
optDotExt = DOT + depExt;
depLine += escapeWhitespaces(relativePath + WILDCARD + optDotExt);
} else {
depLine += escapeWhitespaces((depFiles[i]).toOSString());
}
}
depLine += COLON + WHITESPACE + (patternRule ? patternBuildRuleDependencies : buildRuleDependencies);
if (!getDepRuleList().contains(depLine)) {
getDepRuleList().add(depLine);
addedDepLines = true;
buffer.append(depLine + NEWLINE);
buffer.append(TAB + AT + escapedEcho(MESSAGE_START_DEPENDENCY + WHITESPACE + OUT_MACRO));
for (String preBuildCommand : preBuildCommands) {
depLine = preBuildCommand;
// Resolve macros
try {
if (!needExplicitRuleForFile) {
depLine = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(depLine, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
} else {
depLine = ManagedBuildManager.getBuildMacroProvider().resolveValue(depLine, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, outputLocation, null, tool));
}
} catch (BuildMacroException e) {
// JABA is not going to write this code
}
// buffer.append(TAB + AT + escapedEcho(depLine));
// buffer.append(TAB + AT + depLine + NEWLINE);
buffer.append(TAB + depLine + NEWLINE);
}
}
if (addedDepLines) {
buffer.append(TAB + AT + ECHO_BLANK_LINE + NEWLINE);
}
}
}
}
use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator in project arduino-eclipse-plugin by Sloeber.
the class ArduinoGnuMakefileGenerator method addRuleForTool.
/**
* Create the rule
*
* @param buffer
* Buffer to add makefile rules to
* @param bTargetTool
* True if this is the target tool
* @param targetName
* If this is the "targetTool", the target file name, else
* <code>null</code>
* @param targetExt
* If this is the "targetTool", the target file extension, else
* <code>null</code>
* @param outputVarsAdditionsList
* list to add needed build output variables to
* @param managedProjectOutputs
* Other projects in the workspace that this project depends upon
* @param bEmitPostBuildStepCall
* Emit post-build step invocation
*/
protected boolean addRuleForTool(ITool tool, StringBuffer buffer, boolean bTargetTool, String targetName, String targetExt, List<String> outputVarsAdditionsList, List<String> managedProjectOutputs, boolean bEmitPostBuildStepCall) {
// Get the tool's inputs and outputs
List<String> inputs = new ArrayList<>();
List<String> dependencies = new ArrayList<>();
List<String> outputs = new ArrayList<>();
List<String> enumeratedPrimaryOutputs = new ArrayList<>();
List<String> enumeratedSecondaryOutputs = new ArrayList<>();
List<String> outputVariables = new ArrayList<>();
List<String> additionalTargets = new ArrayList<>();
String outputPrefix = EMPTY_STRING;
if (!getToolInputsOutputs(tool, inputs, dependencies, outputs, enumeratedPrimaryOutputs, enumeratedSecondaryOutputs, outputVariables, additionalTargets, bTargetTool, managedProjectOutputs)) {
return false;
}
// primary output
if (enumeratedPrimaryOutputs.size() == 0) {
enumeratedPrimaryOutputs = enumeratedSecondaryOutputs;
enumeratedSecondaryOutputs.clear();
}
// Add the output variables for this tool to our list
outputVarsAdditionsList.addAll(outputVariables);
// Create the build rule
String buildRule = EMPTY_STRING;
String outflag = tool.getOutputFlag();
String primaryOutputs = EMPTY_STRING;
String primaryOutputsQuoted = EMPTY_STRING;
boolean first = true;
for (int i = 0; i < enumeratedPrimaryOutputs.size(); i++) {
String output = enumeratedPrimaryOutputs.get(i);
if (!first) {
primaryOutputs += WHITESPACE;
primaryOutputsQuoted += WHITESPACE;
}
first = false;
primaryOutputs += new Path(output).toOSString();
primaryOutputsQuoted += ensurePathIsGNUMakeTargetRuleCompatibleSyntax(new Path(output).toOSString());
}
buildRule += (primaryOutputsQuoted + COLON + WHITESPACE);
first = true;
String calculatedDependencies = EMPTY_STRING;
for (int i = 0; i < dependencies.size(); i++) {
String input = dependencies.get(i);
if (!first)
calculatedDependencies += WHITESPACE;
first = false;
calculatedDependencies += input;
}
buildRule += calculatedDependencies;
// We can't have duplicates in a makefile
if (getRuleList().contains(buildRule)) {
/* JABA is not going to write this code */
} else {
getRuleList().add(buildRule);
buffer.append(buildRule + NEWLINE);
if (bTargetTool) {
buffer.append(TAB + AT + escapedEcho(MESSAGE_START_BUILD + WHITESPACE + OUT_MACRO));
}
buffer.append(TAB + AT + escapedEcho(tool.getAnnouncement()));
// Get the command line for this tool invocation
String[] flags;
try {
flags = tool.getToolCommandFlags(null, null);
} catch (BuildException ex) {
// TODO report error
flags = EMPTY_STRING_ARRAY;
}
String command = tool.getToolCommand();
try {
// try to resolve the build macros in the tool command
String resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(command, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(null, null, null, tool));
if ((resolvedCommand = resolvedCommand.trim()).length() > 0)
command = resolvedCommand;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
String[] cmdInputs = inputs.toArray(new String[inputs.size()]);
IManagedCommandLineGenerator gen = tool.getCommandLineGenerator();
IManagedCommandLineInfo cmdLInfo = gen.generateCommandLineInfo(tool, command, flags, outflag, outputPrefix, primaryOutputs, cmdInputs, tool.getCommandLinePattern());
// The command to build
String buildCmd = null;
if (cmdLInfo == null) {
String toolFlags;
try {
toolFlags = tool.getToolCommandFlagsString(null, null);
} catch (BuildException ex) {
// TODO report error
toolFlags = EMPTY_STRING;
}
buildCmd = command + WHITESPACE + toolFlags + WHITESPACE + outflag + WHITESPACE + outputPrefix + primaryOutputs + WHITESPACE + IN_MACRO;
} else
buildCmd = cmdLInfo.getCommandLine();
// generated
try {
String resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(buildCmd, EMPTY_STRING, WHITESPACE, IBuildMacroProvider.CONTEXT_FILE, new FileContextData(null, null, null, tool));
if ((resolvedCommand = resolvedCommand.trim()).length() > 0)
buildCmd = resolvedCommand;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
// buffer.append(TAB).append(AT).append(escapedEcho(buildCmd));
// buffer.append(TAB).append(AT).append(buildCmd);
buffer.append(TAB).append(buildCmd);
// TODO
// NOTE WELL: Dependency file generation is not handled for this
// type of Tool
// Echo finished message
buffer.append(NEWLINE);
buffer.append(TAB + AT + escapedEcho((bTargetTool ? MESSAGE_FINISH_BUILD : MESSAGE_FINISH_FILE) + WHITESPACE + OUT_MACRO));
buffer.append(TAB + AT + ECHO_BLANK_LINE);
// the makefile originally
if (bEmitPostBuildStepCall) {
buffer.append(TAB + MAKE + WHITESPACE + NO_PRINT_DIR + WHITESPACE + POSTBUILD + NEWLINE + NEWLINE);
} else {
// Just emit a blank line
buffer.append(NEWLINE);
}
}
// commands
if (enumeratedSecondaryOutputs.size() > 0 || additionalTargets.size() > 0) {
String primaryOutput = enumeratedPrimaryOutputs.get(0);
List<String> addlOutputs = new ArrayList<>();
addlOutputs.addAll(enumeratedSecondaryOutputs);
addlOutputs.addAll(additionalTargets);
for (int i = 0; i < addlOutputs.size(); i++) {
String output = addlOutputs.get(i);
String depLine = output + COLON + WHITESPACE + primaryOutput + WHITESPACE + calculatedDependencies + NEWLINE;
if (!getDepLineList().contains(depLine)) {
getDepLineList().add(depLine);
buffer.append(depLine);
}
}
buffer.append(NEWLINE);
}
return true;
}
use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator in project usbdm-eclipse-plugins by podonoghue.
the class DisassembleCFileHandler method execute.
// public static void pipeStream(InputStream input, OutputStream output)
// throws IOException {
//
// byte buffer[] = new byte[1024];
// int numRead = 0;
//
// while (input.available() > 0) {
// numRead = input.read(buffer);
// output.write(buffer, 0, numRead);
// }
// output.flush();
// }
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
String os = System.getProperty("os.name");
boolean isLinux = (os != null) && os.toUpperCase().contains("LINUX");
Object source = HandlerUtil.getCurrentSelection(event);
// System.err.println("Event source = "+source.toString()+"\n class = "+source.getClass().toString());
if (!(source instanceof TreeSelection)) {
// System.err.println("Source is not an instance of TreeSelection");
return null;
}
TreeSelection selection = (TreeSelection) source;
if (!(selection.getFirstElement() instanceof IBinary)) {
// System.err.println("Selection.getFirstElement() is not an instance of org.eclipse.cdt.core.model.IBinary");
return null;
}
IBinary binary = (IBinary) selection.getFirstElement();
IResource resource = binary.getUnderlyingResource();
IPath resourcePath = resource.getLocation();
IPath dissassemblyPath = resourcePath.removeFileExtension().addFileExtension("lis");
// Get Environment (path etc)
CoreModel cdtCoreModel = org.eclipse.cdt.core.model.CoreModel.getDefault();
ICProjectDescription cProjectDescription = cdtCoreModel.getProjectDescription(resource.getProject());
ICConfigurationDescription cConfigurationDescription = cProjectDescription.getActiveConfiguration();
IContributedEnvironment contributedEnvironment = CCorePlugin.getDefault().getBuildEnvironmentManager().getContributedEnvironment();
IEnvironmentVariable[] environmentVariablesArray = contributedEnvironment.getVariables(cConfigurationDescription);
HashMap<String, String> environmentMap = new HashMap<String, String>();
for (IEnvironmentVariable ev : environmentVariablesArray) {
String name = ev.getName();
if ((!isLinux) && name.equals("PATH")) {
name = "Path";
}
// System.err.println("Adding Environment variable: "+name+" => "+ev.getValue());
environmentMap.put(name, ev.getValue());
}
// String resourceName = resource.getName();
// System.err.println("resourceName = "+resourceName);
IManagedBuildInfo buildInfo = ManagedBuildManager.getBuildInfo(resource);
IConfiguration configuration = buildInfo.getDefaultConfiguration();
// System.err.println("configuration = "+configuration);
// Find lister tool in configuration
ITool[] toolArray = configuration.getTools();
ITool tool = null;
for (ITool t : toolArray) {
Pattern p = Pattern.compile("net\\.sourceforge\\.usbdm\\.cdt\\..*\\.toolchain\\.lister\\..*");
if (p.matcher(t.getId()).matches()) {
tool = configuration.getTool(t.getId());
break;
}
}
if (tool == null) {
return null;
}
// System.err.println("tool.getName = "+tool.getName());
// System.err.println("tool.getToolCommand = "+tool.getToolCommand());
// Get command line generator
IManagedCommandLineGenerator commandLineGenerator = tool.getCommandLineGenerator();
// Get command line
try {
String[] inputs = { resourcePath.lastSegment() };
IManagedCommandLineInfo commandLineInfo = commandLineGenerator.generateCommandLineInfo(tool, tool.getToolCommand(), tool.getToolCommandFlags(resourcePath, dissassemblyPath), "", ">", dissassemblyPath.lastSegment(), inputs, "${COMMAND} ${INPUTS} ${FLAGS} ${OUTPUT_FLAG}${OUTPUT_PREFIX}${OUTPUT}");
// System.err.println("cl.toString() = "+commandLineInfo.toString());
// System.err.println("cl.getCommandLine() = "+commandLineInfo.getCommandLine());
String[] commandArray = null;
if (isLinux) {
// Construct command (Use cmd for PATH changes!)
ArrayList<String> command = new ArrayList<String>(20);
command.add("/bin/sh");
command.add("-c");
command.add(commandLineInfo.getCommandLine());
commandArray = (String[]) command.toArray(new String[command.size()]);
} else {
// Construct command (Use cmd for PATH changes!)
ArrayList<String> command = new ArrayList<String>(20);
command.add("cmd.exe");
command.add("/C");
command.add(commandLineInfo.getCommandLine());
commandArray = (String[]) command.toArray(new String[command.size()]);
}
// Run command
// System.err.println("Running...");
ProcessBuilder pb = new ProcessBuilder(commandArray);
pb.environment().putAll(environmentMap);
File commandFile = findExecutableOnPath(pb.environment().get("PATH"), commandLineInfo.getCommandName());
if (commandFile != null) {
// System.err.println("commandFile.toPath() = "+ commandFile.toPath());
// System.err.println("pwd = "+ resourcePath.removeLastSegments(1).toFile());
}
// System.err.println("=================== Environment variables ===================");
// for (String envName : pb.environment().keySet()) {
// System.err.println("Environment variable: "+envName+" => "+pb.environment().get(envName));
// }
// System.err.println("=================== End of Environment variables ===================");
pb.redirectInput(Redirect.INHERIT);
pb.redirectError(Redirect.INHERIT);
pb.redirectOutput(Redirect.INHERIT);
pb.directory(resourcePath.removeLastSegments(1).toFile());
// System.err.println("WD =" + pb.directory());
Process p = pb.start();
// System.err.println("Waiting...");
p.waitFor();
// System.err.println("Exit value = " + p.waitFor());
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BuildException e) {
e.printStackTrace();
}
try {
// Refresh parent directory so file is visible
resource.getParent().refreshLocal(1, null);
} catch (CoreException e) {
e.printStackTrace();
}
try {
// Open disassembled file in editor
IPath asmPath = resource.getFullPath().removeFileExtension().addFileExtension("lis");
IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
IDE.openEditor(page, ResourcesPlugin.getWorkspace().getRoot().getFile(asmPath));
} catch (PartInitException e) {
e.printStackTrace();
}
// System.err.println("Completed");
return null;
}
use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator in project arduino-eclipse-plugin by Sloeber.
the class ArduinoGnuMakefileGenerator method generateToolCommandLineInfo.
@SuppressWarnings({ "static-method" })
private IManagedCommandLineInfo generateToolCommandLineInfo(ITool tool, String sourceExtension, String[] flags, String outputFlag, String outputPrefix, String outputName, String[] inputResources, IPath inputLocation, IPath outputLocation) {
String cmd = tool.getToolCommand();
// try to resolve the build macros in the tool command
try {
String resolvedCommand = null;
if ((inputLocation != null && inputLocation.toString().indexOf(" ") != -1) || (outputLocation != null && outputLocation.toString().indexOf(" ") != -1)) {
resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValue(cmd, new String(), " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(inputLocation, outputLocation, null, tool));
} else {
resolvedCommand = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(cmd, new String(), " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(inputLocation, outputLocation, null, tool));
}
if ((resolvedCommand = resolvedCommand.trim()).length() > 0)
cmd = resolvedCommand;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
IManagedCommandLineGenerator gen = tool.getCommandLineGenerator();
return gen.generateCommandLineInfo(tool, cmd, flags, outputFlag, outputPrefix, outputName, inputResources, tool.getCommandLinePattern());
}
Aggregations