[projmgr] Add support for image-only solutions

Author: brondani

tools/projmgr/include/ProjMgrWorker.h

@@ -362,6 +362,7 @@ struct DebuggerType {
  *        selected target-set
  *        load offset for generated binary
  *        load modes
+ *        image only flag
 */
 struct ContextItem {
   CdefaultItem* cdefault = nullptr;
@@ -430,6 +431,7 @@ struct ContextItem {
   std::string targetSet;
   std::string loadOffset;
   StrMap loadMode;
+  bool imageOnly = false;
 };
 
 /**
@@ -748,13 +750,11 @@ class ProjMgrWorker {
    * @brief parse context selection
    * @param contexts pattern (wildcards are allowed)
    * @param check cbuildset flag (default false)
-   * @param active target-set (default empty)
    * @return true if executed successfully
   */
   bool ParseContextSelection(
     const std::vector<std::string>& contextSelection,
-    const bool checkCbuildSet = false,
-    const std::string activeTargetSet = std::string());
+    const bool checkCbuildSet = false);
 
   /**
    * @brief get the list of selected contexts
@@ -910,6 +910,18 @@ class ProjMgrWorker {
   */
   bool ValidateContext(ContextItem& context);
 
+  /**
+   * @brief populate active target set 
+   * @param active target set command line option
+   * @return true if there is no error
+  */
+  bool PopulateActiveTargetSet(const std::string& activeTargetSet);
+
+  /**
+   * @brief add image-only context
+  */
+  void AddImageOnlyContext();
+
   /**
    * @brief clear worker members for reloading a solution
    * @return true if there is no error
@@ -978,6 +990,7 @@ class ProjMgrWorker {
   std::map<std::string, FileNode> m_missingFiles;
   std::string m_activeTargetType;
   TargetSetItem m_activeTargetSet;
+  CprojectItem m_imageOnly;
 
   bool CheckMissingPackRequirements(const std::string& contextName);
   void CheckMissingLinkerScript(ContextItem& context);
@@ -1084,8 +1097,7 @@ class ProjMgrWorker {
   void ProcessTmpDir(std::string& tmpdir, const std::string& base);
   bool IsCreatedByExecute(const std::string file, const std::string dir);
   bool CollectAllRequiredPdscFiles();
-  bool ParseTargetSetContextSelection(const std::string& activeTargetSet);
-  bool GetActiveTargetSet(const std::string& activeTargetSet);
+  bool ParseTargetSetContextSelection();
 };
 
 #endif  // PROJMGRWORKER_H

tools/projmgr/include/ProjMgrYamlParser.h

@@ -128,6 +128,7 @@ static constexpr const char* YAML_ID = "id";
 static constexpr const char* YAML_IF = "if";
 static constexpr const char* YAML_IMAGES = "images";
 static constexpr const char* YAML_IMAGE = "image";
+static constexpr const char* YAML_IMAGE_ONLY = "image-only";
 static constexpr const char* YAML_IMPLEMENTED_BY = "implemented-by";
 static constexpr const char* YAML_IMPLEMENTS = "implements";
 static constexpr const char* YAML_INDEX = "index";

tools/projmgr/schemas/common.schema.json

@@ -1152,7 +1152,7 @@
         "warnings":        { "$ref": "#/definitions/WarningsType" }
       },
       "additionalProperties": false,
-      "required": [ "target-types", "projects" ]
+      "required": [ "target-types" ]
     },
     "ProjectDescType": {
       "title": "project:\nDocumentation: https://open-cmsis-pack.github.io/cmsis-toolbox/YML-Input-Format/#project",
@@ -1208,6 +1208,7 @@
         "csolution": { "type": "string", "description": "Path to csolution.yml file." },
         "cbuild-run": { "type": "string", "description": "Path to cbuild-run.yml file." },
         "tmpdir": { "type": "string", "description": "Specifies the directory for the interim temporary files." },
+        "image-only": { "type": "boolean", "description": "Indicates image only solution." },
         "cprojects": { "$ref": "#/definitions/BuildProjectsType" },
         "cbuilds": { "$ref": "#/definitions/BuildContextsType" },
         "configurations": { "$ref": "#/definitions/BuildConfigurationsType" },
@@ -1219,7 +1220,7 @@
         "rebuild":  { "type": "boolean", "description": "Flag indicating intermediate files need to be cleaned before the next build." }
       },
       "additionalProperties": false,
-      "required": ["generated-by", "csolution", "cprojects"]
+      "required": ["generated-by", "csolution"]
     },
     "BuildProjectsType": {
       "title": "cprojects:\nDocumentation: https://open-cmsis-pack.github.io/cmsis-toolbox/YML-CBuild-Format/#cprojects",
@@ -1279,7 +1280,7 @@
         "messages": { "$ref": "#/definitions/MessagesType" }
       },
       "additionalProperties": false,
-      "required": ["cbuild", "project", "configuration"]
+      "required": ["cbuild", "configuration"]
     },
     "BuildConfigurationsType": {
       "type": "array",

tools/projmgr/src/ProjMgr.cpp

@@ -470,6 +470,10 @@ bool ProjMgr::PopulateContexts(void) {
     }
     // Check cproject separate folders and unique names
     const StrVec& cprojects = m_parser.GetCsolution().cprojects;
+    if (m_activeTargetSet.empty() && cprojects.empty()) {
+      ProjMgrLogger::Get().Error("projects not found", "", m_csolutionFile);
+      return false;
+    }
     if (cprojects.size() > 1) {
       multiset<string> dirs;
       multiset<string> names;
@@ -526,6 +530,14 @@ bool ProjMgr::PopulateContexts(void) {
     }
   }
 
+  // Populate active target-set
+  if (!m_activeTargetSet.empty() && !m_worker.PopulateActiveTargetSet(m_activeTargetSet)) {
+    return false;
+  }
+
+  // Add image only context
+  m_worker.AddImageOnlyContext();
+
   // Retrieve all context types
   m_worker.RetrieveAllContextTypes();
 
@@ -580,7 +592,7 @@ bool ProjMgr::GenerateYMLConfigurationFiles(bool previousResult) {
 
 bool ProjMgr::ParseAndValidateContexts() {
   // Parse context selection
-  if (!m_worker.ParseContextSelection(m_context, m_contextSet, m_activeTargetSet)) {
+  if (!m_worker.ParseContextSelection(m_context, m_contextSet)) {
     return false;
   }
 
@@ -1026,7 +1038,7 @@ bool ProjMgr::RunCodeGenerator(void) {
     return false;
   }
   // Parse context selection
-  if (!m_worker.ParseContextSelection(m_context, (m_context.size() == 0) && m_contextSet, m_activeTargetSet)) {
+  if (!m_worker.ParseContextSelection(m_context, (m_context.size() == 0) && m_contextSet)) {
     return false;
   }
   if (m_extGenerator.IsGlobalGenerator(m_codeGenerator)) {

tools/projmgr/src/ProjMgrCbuild.cpp

@@ -60,7 +60,9 @@ void ProjMgrCbuild::SetContextNode(YAML::Node contextNode, const ContextItem* co
     SetNodeValue(generatorNode[YAML_FROM_PACK], generatorPack);
   }
   SetNodeValue(contextNode[YAML_SOLUTION], FormatPath(context->csolution->path, context->directories.cbuild));
-  SetNodeValue(contextNode[YAML_PROJECT], FormatPath(context->cproject->path, context->directories.cbuild));
+  if (!context->cproject->path.empty()) {
+    SetNodeValue(contextNode[YAML_PROJECT], FormatPath(context->cproject->path, context->directories.cbuild));
+  }
   SetNodeValue(contextNode[YAML_CONTEXT], context->name);
   SetNodeValue(contextNode[YAML_COMPILER], context->toolchain.name +
     (context->toolchain.required.empty() || context->toolchain.required == ">=0.0.0" ? "" : '@' + context->toolchain.required));
@@ -83,33 +85,37 @@ void ProjMgrCbuild::SetContextNode(YAML::Node contextNode, const ContextItem* co
   }
   SetBooksNode(contextNode[YAML_DEVICE_BOOKS], context->deviceBooks, context->directories.cbuild);
   SetDebugConfigNode(contextNode[YAML_DBGCONF], context);
-  SetProcessorNode(contextNode[YAML_PROCESSOR], context->targetAttributes);
+  if (!context->imageOnly) {
+    SetProcessorNode(contextNode[YAML_PROCESSOR], context->targetAttributes);
+  }
   SetPacksNode(contextNode[YAML_PACKS], context);
-  SetControlsNode(contextNode, context, context->controls.processed);
-  vector<string> defines;
-  if (context->rteActiveTarget != nullptr) {
-    for (const auto& define : context->rteActiveTarget->GetDefines()) {
-      CollectionUtils::PushBackUniquely(defines, define);
+  if (!context->imageOnly) {
+    SetControlsNode(contextNode, context, context->controls.processed);
+    vector<string> defines;
+    if (context->rteActiveTarget != nullptr) {
+      for (const auto& define : context->rteActiveTarget->GetDefines()) {
+        CollectionUtils::PushBackUniquely(defines, define);
+      }
     }
-  }
-  SetDefineNode(contextNode[YAML_DEFINE], defines);
-  SetDefineNode(contextNode[YAML_DEFINE_ASM], defines);
-  if (context->rteActiveTarget != nullptr) {
-    for (auto include : context->rteActiveTarget->GetIncludePaths(RteFile::Language::LANGUAGE_NONE)) {
-      RteFsUtils::NormalizePath(include, context->cproject->directory);
-      include = FormatPath(include, context->directories.cbuild);
-      SetNodeValueUniquely(contextNode[YAML_ADDPATH], include);
-      SetNodeValueUniquely(contextNode[YAML_ADDPATH_ASM], include);
+    SetDefineNode(contextNode[YAML_DEFINE], defines);
+    SetDefineNode(contextNode[YAML_DEFINE_ASM], defines);
+    if (context->rteActiveTarget != nullptr) {
+      for (auto include : context->rteActiveTarget->GetIncludePaths(RteFile::Language::LANGUAGE_NONE)) {
+        RteFsUtils::NormalizePath(include, context->cproject->directory);
+        include = FormatPath(include, context->directories.cbuild);
+        SetNodeValueUniquely(contextNode[YAML_ADDPATH], include);
+        SetNodeValueUniquely(contextNode[YAML_ADDPATH_ASM], include);
+      }
     }
+    SetOutputDirsNode(contextNode[YAML_OUTPUTDIRS], context);
+    SetOutputNode(contextNode[YAML_OUTPUT], context);
+    SetComponentsNode(contextNode[YAML_COMPONENTS], context);
+    SetApisNode(contextNode[YAML_APIS], context);
+    SetGeneratorsNode(contextNode[YAML_GENERATORS], context);
+    SetLinkerNode(contextNode[YAML_LINKER], context);
+    SetGroupsNode(contextNode[YAML_GROUPS], context, context->groups);
+    SetConstructedFilesNode(contextNode[YAML_CONSTRUCTEDFILES], context);
   }
-  SetOutputDirsNode(contextNode[YAML_OUTPUTDIRS], context);
-  SetOutputNode(contextNode[YAML_OUTPUT], context);
-  SetComponentsNode(contextNode[YAML_COMPONENTS], context);
-  SetApisNode(contextNode[YAML_APIS], context);
-  SetGeneratorsNode(contextNode[YAML_GENERATORS], context);
-  SetLinkerNode(contextNode[YAML_LINKER], context);
-  SetGroupsNode(contextNode[YAML_GROUPS], context, context->groups);
-  SetConstructedFilesNode(contextNode[YAML_CONSTRUCTEDFILES], context);
   SetLicenseInfoNode(contextNode[YAML_LICENSES], context);
 }
 

tools/projmgr/src/ProjMgrCbuildIdx.cpp

@@ -30,18 +30,24 @@ ProjMgrCbuildIdx::ProjMgrCbuildIdx(YAML::Node node,
   const set<string>& failedContexts, const map<string, ExecutesItem>& executes) : ProjMgrCbuildBase(false) {
   error_code ec;
   SetNodeValue(node[YAML_GENERATED_BY], ORIGINAL_FILENAME + string(" version ") + VERSION_STRING);
-  if (processedContexts.size() > 0) {
-    SetNodeValue(node[YAML_DESCRIPTION], processedContexts[0]->csolution->description);
-  }
-  if (!parser->GetCdefault().path.empty()) {
-    SetNodeValue(node[YAML_CDEFAULT], FormatPath(parser->GetCdefault().path, directory));
+  if (!processedContexts.empty()) {
+    const auto& context = processedContexts.front();
+    SetNodeValue(node[YAML_DESCRIPTION], context->csolution->description);
+    if (!parser->GetCdefault().path.empty() && !context->imageOnly) {
+      SetNodeValue(node[YAML_CDEFAULT], FormatPath(parser->GetCdefault().path, directory));
+    }
   }
   SetNodeValue(node[YAML_CSOLUTION], FormatPath(parser->GetCsolution().path, directory));
   if (!cbuildRun.empty()) {
     SetNodeValue(node[YAML_CBUILD_RUN], FormatPath(cbuildRun, directory));
   }
   SetNodeValue(node[YAML_OUTPUT_TMPDIR], FormatPath(parser->GetCsolution().directories.tmpdir, directory));
 
+  // Image Only flag
+  if (!processedContexts.empty() && processedContexts.front()->imageOnly) {
+    node[YAML_IMAGE_ONLY] = true;
+  }
+
   // Generate layer info for each target
   vector<string> configTargets;
   for (const auto& context : processedContexts) {
@@ -129,7 +135,9 @@ ProjMgrCbuildIdx::ProjMgrCbuildIdx(YAML::Node node,
       const string& relativeFilename = fs::relative(filename, directory, ec).generic_string();
       SetNodeValue(cbuildNode[YAML_CBUILD], relativeFilename);
       if (context->cproject) {
-        SetNodeValue(cbuildNode[YAML_PROJECT], context->cproject->name);
+        if (!context->imageOnly) {
+          SetNodeValue(cbuildNode[YAML_PROJECT], context->cproject->name);
+        }
         SetNodeValue(cbuildNode[YAML_CONFIGURATION],
           (context->type.build.empty() ? "" : ("." + context->type.build)) +
           "+" + context->type.target);

tools/projmgr/src/ProjMgrWorker.cpp

@@ -64,6 +64,25 @@ ProjMgrWorker::~ProjMgrWorker(void) {
   }
 }
 
+void ProjMgrWorker::AddImageOnlyContext() {
+  if (!m_activeTargetSet.images.empty()) {
+    for (const auto& item : m_activeTargetSet.images) {
+      if (!item.context.empty()) {
+        return;
+      }
+    }
+    ContextDesc descriptor;
+    ContextItem context;
+    context.imageOnly = true;
+    context.csolution = &m_parser->GetCsolution();
+    const string name = context.csolution->name;
+    context.cproject = &m_imageOnly;
+    context.cproject->name = name;
+    context.cproject->directory = context.csolution->directory;
+    AddContext(descriptor, { "", m_activeTargetType }, context);
+  }
+}
+
 bool ProjMgrWorker::AddContexts(ProjMgrParser& parser, ContextDesc& descriptor, const string& cprojectFile) {
   error_code ec;
   ContextItem context;
@@ -2134,7 +2153,7 @@ bool ProjMgrWorker::ProcessConfigFiles(ContextItem& context) {
     }
   }
   // Linker script
-  if (!context.outputTypes.lib.on) {
+  if (context.outputTypes.elf.on) {
     if (context.linker.autoGen) {
       if (!context.linker.script.empty()) {
         ProjMgrLogger::Get().Warn("conflict: automatic linker script generation overrules specified script '" + context.linker.script + "'", context.name);
@@ -2816,7 +2835,7 @@ bool ProjMgrWorker::ProcessPrecedences(ContextItem& context, BoardOrDevice proce
   if (!ProcessCompilerPrecedence(compiler, true)) {
     error |= true;
   }
-  if (!ProcessToolchain(context)) {
+  if (!context.imageOnly && !ProcessToolchain(context)) {
     error |= true;
   }
 
@@ -4540,17 +4559,17 @@ bool ProjMgrWorker::ProcessSequencesRelatives(ContextItem& context, BuildType& b
 }
 
 bool ProjMgrWorker::ParseContextSelection(
-  const vector<string>& contextSelection, const bool checkCbuildSet, const string activeTargetSet)
+  const vector<string>& contextSelection, const bool checkCbuildSet)
 {
   vector<string> ymlOrderedContexts;
   ListContexts(ymlOrderedContexts, RteUtils::EMPTY_STRING, true);
 
-  if (checkCbuildSet && !activeTargetSet.empty()) {
+  if (checkCbuildSet && !m_activeTargetType.empty()) {
     ProjMgrLogger::Get().Error("invalid arguments: '-a' option cannot be used in combination with '-S'");
     return false;
   }
-  else if (!activeTargetSet.empty()) {
-    if (!ParseTargetSetContextSelection(activeTargetSet)) {
+  else if (!m_activeTargetType.empty()) {
+    if (!ParseTargetSetContextSelection()) {
       return false;
     }
   }
@@ -4917,7 +4936,7 @@ bool ProjMgrWorker::ProcessOutputFilenames(ContextItem& context) {
   }
 
   // default: elf
-  if (!context.outputTypes.lib.on && !context.outputTypes.elf.on) {
+  if (!context.outputTypes.lib.on && !context.outputTypes.elf.on && !context.imageOnly) {
     context.outputTypes.elf.on = true;
   }
 
@@ -5421,11 +5440,8 @@ void ProjMgrWorker::CollectUnusedPacks() {
   }
 }
 
-bool ProjMgrWorker::ParseTargetSetContextSelection(const string& activeTargetSet) {
+bool ProjMgrWorker::ParseTargetSetContextSelection() {
   // get project-contexts from active target-set
-  if (!GetActiveTargetSet(activeTargetSet)) {
-    return false;
-  }
   m_selectedContexts.clear();
   const auto& targetType = '+' + m_activeTargetType;
   for (const auto& item : m_activeTargetSet.images) {
@@ -5435,9 +5451,11 @@ bool ProjMgrWorker::ParseTargetSetContextSelection(const string& activeTargetSet
   }
   if (m_selectedContexts.empty()) {
     // when target-set is missing under target-types the default value is the first project with first build-type
+    // when the solution is image-only the processing is carried over a single context (+<target-type>)
     vector<string> contexts;
-    ListContexts(contexts, targetType, true);
-    m_selectedContexts.push_back(contexts.front());
+    if (ListContexts(contexts, targetType, true)) {
+      m_selectedContexts.push_back(contexts.front());
+    }
   } else {
     // validate context selection
     if (!ValidateContexts(m_selectedContexts, false)) {
@@ -5447,7 +5465,7 @@ bool ProjMgrWorker::ParseTargetSetContextSelection(const string& activeTargetSet
   return true;
 }
 
-bool ProjMgrWorker::GetActiveTargetSet(const string& activeTargetSet) {
+bool ProjMgrWorker::PopulateActiveTargetSet(const string& activeTargetSet) {
   const auto& targetType = RteUtils::GetPrefix(activeTargetSet, '@');
   const auto& targetSet = RteUtils::GetSuffix(activeTargetSet, '@');
   bool targetSetFound = false;

tools/projmgr/src/ProjMgrYamlParser.cpp

@@ -90,11 +90,6 @@ bool ProjMgrYamlParser::ParseCsolution(const string& input,
       return false;
     }
 
-    if (csolution.cprojects.size() == 0) {
-      ProjMgrLogger::Get().Error("projects not found", "", input);
-      return false;
-    }
-
     if (!ParseTargetTypes(solutionNode, csolution.path, csolution.targetTypes)) {
       ProjMgrLogger::Get().Error("target-types not found", "", input);
       return false;