Example 1 with FileContextData
use of org.eclipse.cdt.managedbuilder.internal.macros.FileContextData 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);
}
}
}
}
Also used :
IManagedDependencyCalculator(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyCalculator)
ArrayList(java.util.ArrayList)
IFolderInfo(org.eclipse.cdt.managedbuilder.core.IFolderInfo)
IManagedDependencyGeneratorType(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyGeneratorType)
IBuildObject(org.eclipse.cdt.managedbuilder.core.IBuildObject)
BuildMacroException(org.eclipse.cdt.managedbuilder.macros.BuildMacroException)
IManagedDependencyGenerator2(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyGenerator2)
IManagedDependencyCommands(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyCommands)
IBuildMacroProvider(org.eclipse.cdt.managedbuilder.macros.IBuildMacroProvider)
Vector(java.util.Vector)
IPath(org.eclipse.core.runtime.IPath)
Path(org.eclipse.core.runtime.Path)
IManagedDependencyGenerator(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyGenerator)
IPath(org.eclipse.core.runtime.IPath)
IManagedCommandLineGenerator(org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator)
FileContextData(org.eclipse.cdt.managedbuilder.internal.macros.FileContextData)
IManagedDependencyInfo(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyInfo)
ITool(org.eclipse.cdt.managedbuilder.core.ITool)
IFileInfo(org.eclipse.cdt.managedbuilder.core.IFileInfo)
IManagedCommandLineInfo(org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo)
IManagedDependencyPreBuild(org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyPreBuild)
BuildException(org.eclipse.cdt.managedbuilder.core.BuildException)
Example 2 with FileContextData
use of org.eclipse.cdt.managedbuilder.internal.macros.FileContextData 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;
}
Also used :
IPath(org.eclipse.core.runtime.IPath)
Path(org.eclipse.core.runtime.Path)
IManagedCommandLineGenerator(org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator)
BuildMacroException(org.eclipse.cdt.managedbuilder.macros.BuildMacroException)
IManagedCommandLineInfo(org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo)
ArrayList(java.util.ArrayList)
FileContextData(org.eclipse.cdt.managedbuilder.internal.macros.FileContextData)
BuildException(org.eclipse.cdt.managedbuilder.core.BuildException)
Example 3 with FileContextData
use of org.eclipse.cdt.managedbuilder.internal.macros.FileContextData in project arduino-eclipse-plugin by Sloeber.
the class ArduinoGnuMakefileGenerator method calculateOutputsForSource.
/**
* Returns the output <code>IPath</code>s for this invocation of the tool
* with the specified source file The priorities for determining the names
* of the outputs of a tool are: 1. If the tool is the build target and
* primary output, use artifact name & extension - This case does not apply
* here... 2. If an option is specified, use the value of the option 3. If a
* nameProvider is specified, call it 4. If outputNames is specified, use it
* 5. Use the name pattern to generate a transformation macro so that the
* source names can be transformed into the target names using the built-in
* string substitution functions of <code>make</code>.
*
* @param relativePath
* build output directory relative path of the current output
* directory
* @param ruleOutputs
* Vector of rule IPaths that are relative to the build directory
* @param enumeratedPrimaryOutputs
* Vector of IPaths of primary outputs that are relative to the
* build directory
* @param enumeratedSecondaryOutputs
* Vector of IPaths of secondary outputs that are relative to the
* build directory
*/
protected void calculateOutputsForSource(ITool tool, String relativePath, IResource resource, IPath sourceLocation, List<IPath> ruleOutputs, List<IPath> enumeratedPrimaryOutputs, List<IPath> enumeratedSecondaryOutputs) {
String inExt = sourceLocation.getFileExtension();
String outExt = tool.getOutputExtension(inExt);
// IResourceInfo rcInfo = tool.getParentResourceInfo();
IOutputType[] outTypes = tool.getOutputTypes();
if (outTypes != null && outTypes.length > 0) {
for (IOutputType type : outTypes) {
boolean primaryOutput = (type == tool.getPrimaryOutputType());
// if (primaryOutput && ignorePrimary) continue;
String outputPrefix = type.getOutputPrefix();
// if (config != null) {
try {
if (containsSpecialCharacters(sourceLocation.toOSString())) {
outputPrefix = ManagedBuildManager.getBuildMacroProvider().resolveValue(outputPrefix, new String(), " ", IBuildMacroProvider.CONTEXT_CONFIGURATION, this.config);
} else {
outputPrefix = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(outputPrefix, new String(), " ", IBuildMacroProvider.CONTEXT_CONFIGURATION, this.config);
}
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
// }
boolean multOfType = type.getMultipleOfType();
IOption option = tool.getOptionBySuperClassId(type.getOptionId());
IManagedOutputNameProvider nameProvider = type.getNameProvider();
String[] outputNames = type.getOutputNames();
// 2. If an option is specified, use the value of the option
if (option != null) {
try {
List<String> outputList = new ArrayList<>();
int optType = option.getValueType();
if (optType == IOption.STRING) {
outputList.add(outputPrefix + option.getStringValue());
} else if (optType == IOption.STRING_LIST || optType == IOption.LIBRARIES || optType == IOption.OBJECTS || optType == IOption.INCLUDE_FILES || optType == IOption.LIBRARY_PATHS || optType == IOption.LIBRARY_FILES || optType == IOption.MACRO_FILES) {
@SuppressWarnings("unchecked") List<String> value = (List<String>) option.getValue();
outputList = value;
((Tool) tool).filterValues(optType, outputList);
// Add outputPrefix to each if necessary
if (outputPrefix.length() > 0) {
for (int j = 0; j < outputList.size(); j++) {
outputList.set(j, outputPrefix + outputList.get(j));
}
}
}
for (int j = 0; j < outputList.size(); j++) {
String outputName = outputList.get(j);
// names
try {
String resolved = null;
if (containsSpecialCharacters(sourceLocation.toOSString())) {
resolved = ManagedBuildManager.getBuildMacroProvider().resolveValue(outputName, new String(), " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, null, option, tool));
} else {
resolved = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(outputName, new String(), " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, null, option, tool));
}
if ((resolved = resolved.trim()).length() > 0)
outputName = resolved;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
IPath outPath = Path.fromOSString(outputName);
// relative path of this output directory
if (outPath.segmentCount() == 1) {
outPath = Path.fromOSString(relativePath + outputList.get(j));
}
if (primaryOutput) {
ruleOutputs.add(j, outPath);
enumeratedPrimaryOutputs.add(j, resolvePercent(outPath, sourceLocation));
} else {
ruleOutputs.add(outPath);
enumeratedSecondaryOutputs.add(resolvePercent(outPath, sourceLocation));
}
}
} catch (BuildException ex) {
/* JABA is not going to write this code */
}
} else // 3. If a nameProvider is specified, call it
if (nameProvider != null) {
IPath[] inPaths = new IPath[1];
// ;
inPaths[0] = resource.getProjectRelativePath();
// sourceLocation.removeFirstSegments(project.getLocation().segmentCount());
IPath[] outPaths = null;
try {
IManagedOutputNameProviderJaba newNameProvider = (IManagedOutputNameProviderJaba) nameProvider;
outPaths = newNameProvider.getOutputNames(this.project, this.config, tool, inPaths);
} catch (Exception e) {
// The provided class is not a
// IManagedOutputNameProviderJaba class;
Common.log(new Status(IStatus.ERROR, Const.CORE_PLUGIN_ID, //
"The provided class is not of type IManagedOutputNameProviderJaba", e));
}
if (outPaths != null) {
// MODDED BY JABA ADDED to handle
// null as return value
// MODDED By JABA added to
this.usedOutType = type;
// command line
for (int j = 0; j < outPaths.length; j++) {
IPath outPath = outPaths[j];
String outputName = outPaths[j].toOSString();
// names
try {
String resolved = null;
if (containsSpecialCharacters(sourceLocation.toOSString())) {
resolved = ManagedBuildManager.getBuildMacroProvider().resolveValue(outputName, "", " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, null, option, tool));
} else {
resolved = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(outputName, "", " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, null, option, tool));
}
if ((resolved = resolved.trim()).length() > 0)
outputName = resolved;
} catch (BuildMacroException e) {
// JABA is not
// going to write
// this code
}
// relative path of this output directory
if (outPath.segmentCount() == 1) {
outPath = Path.fromOSString(relativePath + outPath.toOSString());
}
if (type.getPrimaryOutput()) {
ruleOutputs.add(j, outPath);
enumeratedPrimaryOutputs.add(j, resolvePercent(outPath, sourceLocation));
} else {
ruleOutputs.add(outPath);
enumeratedSecondaryOutputs.add(resolvePercent(outPath, sourceLocation));
}
}
}
// MODDED BY JABA ADDED
} else // 4. If outputNames is specified, use it
if (outputNames != null) {
for (int j = 0; j < outputNames.length; j++) {
String outputName = outputNames[j];
try {
// try to resolve the build macros in the output
// names
String resolved = ManagedBuildManager.getBuildMacroProvider().resolveValueToMakefileFormat(outputName, new String(), " ", IBuildMacroProvider.CONTEXT_FILE, new FileContextData(sourceLocation, null, option, tool));
if ((resolved = resolved.trim()).length() > 0)
outputName = resolved;
} catch (BuildMacroException e) {
/* JABA is not going to write this code */
}
IPath outPath = Path.fromOSString(outputName);
// path of this output directory
if (outPath.segmentCount() == 1) {
outPath = Path.fromOSString(relativePath + outPath.toOSString());
}
if (primaryOutput) {
ruleOutputs.add(j, outPath);
enumeratedPrimaryOutputs.add(j, resolvePercent(outPath, sourceLocation));
} else {
ruleOutputs.add(outPath);
enumeratedSecondaryOutputs.add(resolvePercent(outPath, sourceLocation));
}
}
} else {
// <code>make</code>.
if (multOfType) {
// This case is not handled - a nameProvider or
// outputNames must be specified
// TODO - report error
} else {
String namePattern = type.getNamePattern();
IPath namePatternPath = null;
if (namePattern == null || namePattern.length() == 0) {
namePattern = relativePath + outputPrefix + IManagedBuilderMakefileGenerator.WILDCARD;
if (outExt != null && outExt.length() > 0) {
namePattern += DOT + outExt;
}
namePatternPath = Path.fromOSString(namePattern);
} else {
if (outputPrefix.length() > 0) {
namePattern = outputPrefix + namePattern;
}
namePatternPath = Path.fromOSString(namePattern);
// relative path of this output directory
if (namePatternPath.segmentCount() == 1) {
namePatternPath = Path.fromOSString(relativePath + namePatternPath.toOSString());
}
}
if (primaryOutput) {
ruleOutputs.add(0, namePatternPath);
enumeratedPrimaryOutputs.add(0, resolvePercent(namePatternPath, sourceLocation));
} else {
ruleOutputs.add(namePatternPath);
enumeratedSecondaryOutputs.add(resolvePercent(namePatternPath, sourceLocation));
}
}
}
}
} else {
// For support of pre-CDT 3.0 integrations.
// NOTE WELL: This only supports the case of a single "target tool"
// that consumes exactly all of the object files, $OBJS, produced
// by other tools in the build and produces a single output.
// In this case, the output file name is the input file name with
// the output extension.
// if (!ignorePrimary) {
String outPrefix = tool.getOutputPrefix();
IPath outPath = Path.fromOSString(relativePath + outPrefix + WILDCARD);
outPath = outPath.addFileExtension(outExt);
ruleOutputs.add(0, outPath);
enumeratedPrimaryOutputs.add(0, resolvePercent(outPath, sourceLocation));
// }
}
}
Also used :
MultiStatus(org.eclipse.core.runtime.MultiStatus)
IStatus(org.eclipse.core.runtime.IStatus)
Status(org.eclipse.core.runtime.Status)
IResourceStatus(org.eclipse.core.resources.IResourceStatus)
IPath(org.eclipse.core.runtime.IPath)
IOption(org.eclipse.cdt.managedbuilder.core.IOption)
ArrayList(java.util.ArrayList)
FileContextData(org.eclipse.cdt.managedbuilder.internal.macros.FileContextData)
CoreException(org.eclipse.core.runtime.CoreException)
OperationCanceledException(org.eclipse.core.runtime.OperationCanceledException)
BuildException(org.eclipse.cdt.managedbuilder.core.BuildException)
IOException(java.io.IOException)
BuildMacroException(org.eclipse.cdt.managedbuilder.macros.BuildMacroException)
BuildMacroException(org.eclipse.cdt.managedbuilder.macros.BuildMacroException)
IManagedOutputNameProvider(org.eclipse.cdt.managedbuilder.core.IManagedOutputNameProvider)
List(java.util.List)
ArrayList(java.util.ArrayList)
BuildException(org.eclipse.cdt.managedbuilder.core.BuildException)
IOutputType(org.eclipse.cdt.managedbuilder.core.IOutputType)
Example 4 with FileContextData
use of org.eclipse.cdt.managedbuilder.internal.macros.FileContextData 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());
}
Also used :
IManagedCommandLineGenerator(org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator)
BuildMacroException(org.eclipse.cdt.managedbuilder.macros.BuildMacroException)
FileContextData(org.eclipse.cdt.managedbuilder.internal.macros.FileContextData)
Aggregations
FileContextData (org.eclipse.cdt.managedbuilder.internal.macros.FileContextData)4
BuildMacroException (org.eclipse.cdt.managedbuilder.macros.BuildMacroException)4
ArrayList (java.util.ArrayList)3
BuildException (org.eclipse.cdt.managedbuilder.core.BuildException)3
IManagedCommandLineGenerator (org.eclipse.cdt.managedbuilder.core.IManagedCommandLineGenerator)3
IPath (org.eclipse.core.runtime.IPath)3
IManagedCommandLineInfo (org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo)2
Path (org.eclipse.core.runtime.Path)2
IOException (java.io.IOException)1
List (java.util.List)1
Vector (java.util.Vector)1
IBuildObject (org.eclipse.cdt.managedbuilder.core.IBuildObject)1
IFileInfo (org.eclipse.cdt.managedbuilder.core.IFileInfo)1
IFolderInfo (org.eclipse.cdt.managedbuilder.core.IFolderInfo)1
IManagedOutputNameProvider (org.eclipse.cdt.managedbuilder.core.IManagedOutputNameProvider)1
IOption (org.eclipse.cdt.managedbuilder.core.IOption)1
IOutputType (org.eclipse.cdt.managedbuilder.core.IOutputType)1
ITool (org.eclipse.cdt.managedbuilder.core.ITool)1
IBuildMacroProvider (org.eclipse.cdt.managedbuilder.macros.IBuildMacroProvider)1
IManagedDependencyCalculator (org.eclipse.cdt.managedbuilder.makegen.IManagedDependencyCalculator)1
