#1126 still redesigning checking in due to to much change

The makefile is starting to get populated

Author: jantje

io.sloeber.core/src/io/sloeber/managedBuild/Internal/ArduinoGnuMakefileGenerator.java

@@ -0,0 +1,105 @@
+package io.sloeber.managedBuild.Internal;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.eclipse.cdt.managedbuilder.core.IInputType;
+import org.eclipse.cdt.managedbuilder.core.IOutputType;
+import org.eclipse.cdt.managedbuilder.core.ITool;
+import org.eclipse.core.resources.IFile;
+
+public class MakeRules {
+    private Set<MakeRule> myMakeRules = new LinkedHashSet<>();
+
+    public void addRule(MakeRule newMakeRule) {
+        if (newMakeRule.isSimpleRule()) {
+            Map<IOutputType, Set<IFile>> targets = newMakeRule.getTargets();
+
+            IOutputType outputType = null;
+            IFile correctOutputPath = null;
+            for (Entry<IOutputType, Set<IFile>> curTarget : targets.entrySet()) {
+                outputType = curTarget.getKey();
+                correctOutputPath = curTarget.getValue().toArray(new IFile[1])[0];
+            }
+            MakeRule makerule = findTarget(outputType, correctOutputPath);
+            if (makerule != null) {
+                Map<IInputType, Set<IFile>> prerequisites = newMakeRule.getPrerequisites();
+
+                IInputType inputType = null;
+                Set<IFile> files = null;
+
+                for (Entry<IInputType, Set<IFile>> curTarget : prerequisites.entrySet()) {
+                    inputType = curTarget.getKey();
+                    files = curTarget.getValue();
+                }
+                newMakeRule.addPrerequisites(inputType, files);
+            }
+        }
+        myMakeRules.add(newMakeRule);
+    }
+
+    public MakeRule findTarget(IOutputType outputType, IFile correctOutputPath) {
+        for (MakeRule makeRule : myMakeRules) {
+            for (Entry<IOutputType, Set<IFile>> target : makeRule.getTargets().entrySet()) {
+                if ((target.getKey() == outputType) && (target.getValue().contains(correctOutputPath))) {
+                    return makeRule;
+                }
+            }
+        }
+        return null;
+    }
+
+    public void addRule(ITool tool, IInputType inputType, String macroName, Set<IFile> InputFiles,
+            IOutputType outputType, IFile correctOutputFile) {
+        MakeRule newMakeRule = findTarget(outputType, correctOutputFile);
+        if (newMakeRule == null) {
+            newMakeRule = new MakeRule(tool, inputType, InputFiles, outputType, correctOutputFile);
+        }
+        newMakeRule.addPrerequisites(inputType, InputFiles);
+        addRule(newMakeRule);
+
+    }
+
+    public int size() {
+        return myMakeRules.size();
+    }
+
+    public void addRules(MakeRules makeRules) {
+        for (MakeRule makeRule : makeRules.getMakeRules()) {
+            addRule(makeRule);
+        }
+    }
+
+    public Map<IOutputType, Set<IFile>> getTargets() {
+        Map<IOutputType, Set<IFile>> ret = new HashMap<>();
+        for (MakeRule makeRule : myMakeRules) {
+            ret.putAll(makeRule.getTargets());
+        }
+        return ret;
+    }
+
+    public Set<String> getMacroNames() {
+        Set<String> ret = new HashSet<>();
+        for (MakeRule makeRule : myMakeRules) {
+            ret.addAll(makeRule.getAllMacros());
+        }
+        return ret;
+    }
+
+    public Set<IFile> getMacroElements(String macroName) {
+        Set<IFile> ret = new HashSet<>();
+        for (MakeRule makeRule : myMakeRules) {
+            ret.addAll(makeRule.getMacroElements(macroName));
+        }
+        return ret;
+    }
+
+    public Set<MakeRule> getMakeRules() {
+        return myMakeRules;
+    }
+
+}

io.sloeber.core/src/io/sloeber/managedBuild/Internal/ArduinoManagedBuildGnuToolInfo.java

@@ -605,6 +605,31 @@ static public IManagedOutputNameProviderJaba getJABANameProvider(IOutputType iTy
                 //ignore errors
             }
         }
+        String[] outputNames = type.getOutputNames();
+        if (outputNames != null && outputNames.length > 0) {
+            String outputName = outputNames[0];
+            return new IManagedOutputNameProviderJaba() {
+
+                @Override
+                public IPath getOutputName(IProject project, IConfiguration cConf, ITool tool, IPath inputName) {
+                    return new Path(outputName);
+                    //return project.getFile(cConf.getName()).getFullPath().append(outputName);
+                }
+            };
+        }
+
+        String[] outputExtensions = type.getOutputExtensionsAttribute();
+        if (outputExtensions != null && outputExtensions.length > 0) {
+            String outputExtension = outputExtensions[0];
+            return new IManagedOutputNameProviderJaba() {
+
+                @Override
+                public IPath getOutputName(IProject project, IConfiguration cConf, ITool tool, IPath inputName) {
+                    return inputName.addFileExtension(outputExtension);
+                }
+            };
+        }
+
         return null;
     }
 

io.sloeber.core/src/io/sloeber/managedBuild/Internal/MakeRule.java

@@ -94,5 +94,6 @@ public class ManagedBuildConstants {
     public static final String INPUTS_PRM_NAME = "INPUTS";
     public static final String VARIABLE_PREFIX = "${";
     public static final String VARIABLE_SUFFIX = "}";
+    public static final String DEPENDENCY_SUFFIX = "_DEPS";
 
 }

io.sloeber.core/src/io/sloeber/managedBuild/Internal/MakeRules.java

@@ -7,15 +7,12 @@
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.cdt.managedbuilder.core.IConfiguration;
-import org.eclipse.cdt.managedbuilder.core.IFileInfo;
 import org.eclipse.cdt.managedbuilder.core.IInputType;
 import org.eclipse.cdt.managedbuilder.core.IOutputType;
-import org.eclipse.cdt.managedbuilder.core.IResourceInfo;
 import org.eclipse.cdt.managedbuilder.core.ITool;
 import org.eclipse.cdt.managedbuilder.internal.core.ManagedMakeMessages;
 import org.eclipse.core.resources.IContainer;
@@ -31,12 +28,18 @@
 public class SubDirMakeGenerator {
     private ArduinoGnuMakefileGenerator caller;
     private Set<MakeRule> myMakeRules = new LinkedHashSet<>();
-    private IContainer myModule;
+    private IFile myMakefile;
 
     SubDirMakeGenerator(ArduinoGnuMakefileGenerator theCaller, IContainer module) {
         caller = theCaller;
-        myModule = module;
-        getMakeRules();
+        IProject project = getProject();
+        IPath buildRoot = getBuildWorkingDir();
+        if (buildRoot == null) {
+            return;
+        }
+        IPath moduleOutputPath = buildRoot.append(module.getProjectRelativePath());
+        myMakefile = project.getFile(moduleOutputPath.append(MODFILE_NAME));
+        getMakeRulesFromSourceFiles(module);
     }
 
     public Set<String> getDependecyMacros() {
@@ -63,6 +66,10 @@ public Set<String> getTargetMacros() {
         return ret;
     }
 
+    public Set<MakeRule> getMakeRules() {
+        return myMakeRules;
+    }
+
     public Set<String> getPrerequisiteMacros() {
         HashSet<String> ret = new LinkedHashSet<>();
         for (MakeRule curMakeRule : myMakeRules) {
@@ -87,8 +94,8 @@ public Set<IFile> getDependencyFiles() {
         return ret;
     }
 
-    public Map<IOutputType, List<IFile>> getTargets() {
-        Map<IOutputType, List<IFile>> ret = new LinkedHashMap<>();
+    public Map<IOutputType, Set<IFile>> getTargets() {
+        Map<IOutputType, Set<IFile>> ret = new LinkedHashMap<>();
         for (MakeRule curMakeRule : myMakeRules) {
             ret.putAll(curMakeRule.getTargets());
         }
@@ -119,22 +126,13 @@ private IProject getProject() {
      * generated for each project directory/subdirectory that contains source files.
      */
     public void generateMakefile() throws CoreException {
-        //create the parent folder on disk and file in eclispe
-        IProject project = getProject();
-        IPath buildRoot = getBuildWorkingDir();
-        if (buildRoot == null) {
-            return;
-        }
-        IPath moduleOutputPath = buildRoot.append(myModule.getProjectRelativePath());
-        IFile modMakefile = project.getFile(moduleOutputPath.append(MODFILE_NAME));
-
         //generate the file content
         StringBuffer makeBuf = addDefaultHeader();
         makeBuf.append(GenerateMacros());
         makeBuf.append(GenerateRules(getConfig()));
 
         // Save the files
-        save(makeBuf, modMakefile);
+        save(makeBuf, myMakefile);
     }
 
     private StringBuffer GenerateMacros() {
@@ -179,85 +177,65 @@ private StringBuffer GenerateRules(IConfiguration config) {
     }
 
     //Get the rules for the source files
-    private void getMakeRules() {
+    private void getMakeRulesFromSourceFiles(IContainer module) {
         myMakeRules.clear();
         IConfiguration config = getConfig();
         IProject project = getProject();
 
         // Visit the resources in this folder 
         try {
-            for (IResource resource : myModule.members()) {
+            for (IResource resource : module.members()) {
                 if (resource.getType() != IResource.FILE) {
                     //only handle files
                     continue;
                 }
                 IFile inputFile = (IFile) resource;
+                String ext = inputFile.getFileExtension();
+                if (ext == null || ext.isBlank()) {
+                    continue;
+                }
                 IPath rcProjRelPath = inputFile.getProjectRelativePath();
                 if (!caller.isSource(rcProjRelPath)) {
                     // this resource is excluded from build
                     continue;
                 }
-                IResourceInfo rcInfo = config.getResourceInfo(rcProjRelPath, false);
-                String ext = rcProjRelPath.getFileExtension();
 
-                ITool tool = null;
-                //try to find tool 
-                if (rcInfo instanceof IFileInfo) {
-                    IFileInfo fi = (IFileInfo) rcInfo;
-                    ITool[] tools = fi.getToolsToInvoke();
-                    if (tools != null && tools.length > 0) {
-                        tool = tools[0];
-                    }
-                }
-
-                //No tool found yet try other way
-                if (tool == null) {
-                    ToolInfoHolder h = ToolInfoHolder.getToolInfo(caller, rcInfo.getPath());
-                    ITool buildTools[] = h.buildTools;
-                    h = ToolInfoHolder.getToolInfo(caller, Path.EMPTY);
-                    buildTools = h.buildTools;
-                    for (ITool buildTool : buildTools) {
-                        if (buildTool.buildsFileType(ext)) {
-                            tool = buildTool;
-                            break;
+                for (ITool tool : config.getTools()) {
+                    for (IInputType inputType : tool.getInputTypes()) {
+                        if (!inputType.isSourceExtension(tool, ext)) {
+                            continue;
+                        }
+                        for (IOutputType outputType : tool.getOutputTypes()) {
+                            IManagedOutputNameProviderJaba nameProvider = getJABANameProvider(outputType);
+                            if (nameProvider == null) {
+                                continue;
+                            }
+                            IPath outputFile = nameProvider.getOutputName(getProject(), config, tool,
+                                    resource.getProjectRelativePath());
+                            if (outputFile == null) {
+                                continue;
+                            }
+                            //We found a tool that provides a outputfile for our source file
+                            //TOFIX if this is a multiple to one we should only create one MakeRule
+                            IPath correctOutputPath = new Path(config.getName()).append(outputFile);
+                            MakeRule newMakeRule = new MakeRule(tool, inputType, inputFile, outputType,
+                                    project.getFile(correctOutputPath));
+                            newMakeRule.addDependencies(caller);
+
+                            myMakeRules.add(newMakeRule);
                         }
                     }
                 }
 
-                //We found a tool get the other info
-                //TOFIX we should simply loop over all available tools
-                if (tool == null) {
-                    continue;
-                }
-
-                // Generate the rule to build this source file
-                //TOFIX check wether this tool can handle this file
-                IInputType inputType = tool.getPrimaryInputType();
-                if (inputType == null) {
-                    inputType = tool.getInputType(ext);
-                }
-
-                for (IOutputType outputType : tool.getOutputTypes()) {
-                    IManagedOutputNameProviderJaba nameProvider = getJABANameProvider(outputType);
-                    if (nameProvider == null) {
-                        continue;
-                    }
-                    IPath outputFile = nameProvider.getOutputName(getProject(), config, tool,
-                            resource.getProjectRelativePath());
-                    if (outputFile != null) {
-                        //We found a tool that provides a outputfile for our source file
-                        //TOFIX if this is a multiple to one we should only create one MakeRule
-                        IPath correctOutputPath = new Path(config.getName()).append(outputFile);
-                        MakeRule newMakeRule = new MakeRule(caller, tool, inputType, inputFile, outputType,
-                                project.getFile(correctOutputPath));
-
-                        myMakeRules.add(newMakeRule);
-                    }
-                }
             }
         } catch (CoreException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
+
+    public boolean isEmpty() {
+        return myMakeRules.size() == 0;
+    }
+
 }