Examples with IManagedCommandLineInfo org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo used on opensource projects

Example 1 with IManagedCommandLineInfo

use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo 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);
            }
        }
    }
}

Example 2 with IManagedCommandLineInfo

use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo 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;
}

Example 3 with IManagedCommandLineInfo

use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo 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;
}

Example 4 with IManagedCommandLineInfo

use of org.eclipse.cdt.managedbuilder.core.IManagedCommandLineInfo in project usbdm-eclipse-plugins by podonoghue.

the class ManagedCommandLineGenerator method generateCommandLineInfo.

@Override
public IManagedCommandLineInfo generateCommandLineInfo(ITool tool, String commandName, String[] flags, String outputFlag, String outputPrefix, String output, String[] inputResources, String commandLinePattern) {
    if ((commandLinePattern == null) || (commandLinePattern.length() == 0)) {
        commandLinePattern = DEFAULT_PATTERN;
    }
    // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo(output=\'"+output.toString()+"\')");
    output = quoteToken(output);
    String inputsStr = stringArrayToString(inputResources, false);
    String flagsStr = stringArrayToString(flags, false);
    // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo(inputsStr=\'"+inputsStr+"\')");
    // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo(flagsStr =\'"+flagsStr+"\')");
    // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo(output   =\'"+output+"\')");
    RelacementPair[] replacementPair = { new RelacementPair("COMMAND", commandName), new RelacementPair("FLAGS", flagsStr), new RelacementPair("OUTPUT_FLAG", outputFlag), new RelacementPair("OUTPUT_PREFIX", outputPrefix), new RelacementPair("OUTPUT", output), new RelacementPair("INPUTS", inputsStr) };
    String command = commandLinePattern;
    for (RelacementPair pair : replacementPair) {
        // System.err.println("/'" + makeVariable(pair.key)+ "/'==>/'" + pair.value + "/'");
        command = command.replace(makeVariable(pair.key), pair.value);
        command = command.replace(makeVariable(pair.key).toLowerCase(), pair.value);
    }
    try {
        IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
        // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo() Before newCommandName = \'" + newCommandName);
        commandName = manager.performStringSubstitution(commandName);
    } catch (CoreException e1) {
        e1.printStackTrace();
    }
    // System.err.println("ManagedCommandLineGenerator.generateCommandLineInfo() commandName = \'"+commandName+"\'");
    return new ManagedCommandLineInfo(command.trim(), commandLinePattern, commandName, flagsStr, outputFlag, outputPrefix, output, inputsStr);
}