build: support lib.cc

src/BuildConfig.cc

@@ -494,6 +494,15 @@ BuildConfig::defineLinkTarget(
   defineTarget(binTarget, commands, deps);
 }
 
+void
+BuildConfig::defineLibTarget(
+    const std::string& libTarget, const std::unordered_set<std::string>& deps
+) {
+  std::vector<std::string> commands;
+  commands.emplace_back("ar rcs lib" + getPackageName() + ".a $^");
+  defineTarget(libTarget, commands, deps);
+}
+
 // Map a path to header file to the corresponding object file.
 //
 // e.g., src/path/to/header.h -> poac.d/path/to/header.o
@@ -791,6 +800,9 @@ BuildConfig::configureBuild() {
   const auto isMainSource = [](const fs::path& file) {
     return file.filename().stem() == "main";
   };
+  const auto isLibSource = [](const fs::path& file) {
+    return file.filename().stem() == "lib";
+  };
   fs::path mainSource;
   for (const auto& entry : fs::directory_iterator(srcDir)) {
     const fs::path& path = entry.path();
@@ -802,13 +814,34 @@ BuildConfig::configureBuild() {
     }
     if (mainSource.empty()) {
       mainSource = path;
+      executable = true;
     } else {
       throw PoacError("multiple main sources were found");
     }
   }
 
-  if (mainSource.empty()) {
-    throw PoacError(fmt::format("src/main{} was not found", SOURCE_FILE_EXTS));
+  fs::path libSource;
+  for (const auto& entry : fs::directory_iterator(srcDir)) {
+    const fs::path& path = entry.path();
+    if (!SOURCE_FILE_EXTS.contains(path.extension())) {
+      continue;
+    }
+    if (!isLibSource(path)) {
+      continue;
+    }
+    if (libSource.empty()) {
+      libSource = path;
+      library = true;
+    } else {
+      throw PoacError("multiple lib sources were found");
+    }
+  }
+
+  if (mainSource.empty() && libSource.empty()) {
+    throw PoacError(fmt::format(
+        "neither src/main{} nor src/lib{} was not found", SOURCE_FILE_EXTS,
+        SOURCE_FILE_EXTS
+    ));
   }
 
   if (!fs::exists(outBasePath)) {
@@ -817,8 +850,16 @@ BuildConfig::configureBuild() {
 
   setVariables();
 
+  std::unordered_set<std::string> buildAll = {};
+  if (executable) {
+    buildAll.insert(packageName);
+  }
+  if (library) {
+    buildAll.insert("lib" + packageName + ".a");
+  }
+
   // Build rules
-  setAll({ packageName });
+  setAll(buildAll);
   addPhony("all");
 
   std::vector<fs::path> sourceFilePaths = listSourceFilePaths(srcDir);
@@ -832,7 +873,16 @@ BuildConfig::configureBuild() {
           "Move it directly to 'src/' if intended as such.",
           sourceFilePath.string()
       ));
+    } else if (sourceFilePath != libSource && isLibSource(sourceFilePath)) {
+      logger::warn(fmt::format(
+          "source file `{}` is named `lib` but is not located directly in the "
+          "`src/` directory. "
+          "This file will not be treated as a library. "
+          "Move it directly to 'src/' if intended as such.",
+          sourceFilePath.string()
+      ));
     }
+
     srcs += ' ' + sourceFilePath.string();
   }
 
@@ -842,16 +892,31 @@ BuildConfig::configureBuild() {
   const std::unordered_set<std::string> buildObjTargets =
       processSources(sourceFilePaths);
 
-  // Project binary target.
-  const std::string mainObjTarget = buildOutPath / "main.o";
-  std::unordered_set<std::string> projTargetDeps = { mainObjTarget };
-  collectBinDepObjs(
-      projTargetDeps, "",
-      targets.at(mainObjTarget).remDeps, // we don't need sourceFile
-      buildObjTargets
-  );
+  if (executable) {
+    // Project binary target.
+    const std::string mainObjTarget = buildOutPath / "main.o";
+    std::unordered_set<std::string> projTargetDeps = { mainObjTarget };
 
-  defineLinkTarget(outBasePath / packageName, projTargetDeps);
+    collectBinDepObjs(
+        projTargetDeps, "",
+        targets.at(mainObjTarget).remDeps, // we don't need sourceFile
+        buildObjTargets
+    );
+
+    defineLinkTarget(outBasePath / packageName, projTargetDeps);
+  }
+
+  if (library) {
+    // Project library target.
+    const std::string libTarget = buildOutPath / "lib.o";
+    std::unordered_set<std::string> libTargetDeps = { libTarget };
+    collectBinDepObjs(
+        libTargetDeps, "",
+        targets.at(libTarget).remDeps, // we don't need sourceFile
+        buildObjTargets
+    );
+    defineLibTarget(outBasePath / ("lib" + packageName + ".a"), libTargetDeps);
+  }
 
   // Test Pass
   std::unordered_set<std::string> testTargets;

src/BuildConfig.hpp

@@ -51,6 +51,11 @@ struct BuildConfig {
   fs::path unittestOutPath;
   bool isDebug;
 
+  // if we are building an executable
+  bool executable;
+  // if we are building a library
+  bool library;
+
   std::unordered_map<std::string, Variable> variables;
   std::unordered_map<std::string, std::vector<std::string>> varDeps;
   std::unordered_map<std::string, Target> targets;
@@ -67,6 +72,13 @@ struct BuildConfig {
 public:
   explicit BuildConfig(const std::string& packageName, bool isDebug = true);
 
+  bool isExecutable() const {
+    return executable;
+  }
+  bool isLibrary() const {
+    return library;
+  }
+
   void defineVar(
       const std::string& name, const Variable& value,
       const std::unordered_set<std::string>& dependsOn = {}
@@ -77,12 +89,14 @@ struct BuildConfig {
       varDeps[dep].push_back(name);
     }
   }
+
   void defineSimpleVar(
       const std::string& name, const std::string& value,
       const std::unordered_set<std::string>& dependsOn = {}
   ) {
     defineVar(name, { .value = value, .type = VarType::Simple }, dependsOn);
   }
+
   void defineCondVar(
       const std::string& name, const std::string& value,
       const std::unordered_set<std::string>& dependsOn = {}
@@ -145,6 +159,9 @@ struct BuildConfig {
   void defineLinkTarget(
       const std::string& binTarget, const std::unordered_set<std::string>& deps
   );
+  void defineLibTarget(
+      const std::string& binTarget, const std::unordered_set<std::string>& deps
+  );
 
   void collectBinDepObjs( // NOLINT(misc-no-recursion)
       std::unordered_set<std::string>& deps, std::string_view sourceFileName,

src/Cmd/Build.cc

@@ -40,23 +40,48 @@ buildImpl(std::string& outDir, const bool isDebug) {
   outDir = config.outBasePath;
 
   const std::string& packageName = getPackageName();
-  const Command makeCmd = getMakeCommand().addArg("-C").addArg(outDir).addArg(
-      (config.outBasePath / packageName).string()
-  );
-  Command checkUpToDateCmd = makeCmd;
-  checkUpToDateCmd.addArg("--question");
-
-  int exitCode = execCmd(checkUpToDateCmd);
-  if (exitCode != EXIT_SUCCESS) {
-    // If packageName binary is not up-to-date, compile it.
-    logger::info(
-        "Compiling",
-        fmt::format(
-            "{} v{} ({})", packageName, getPackageVersion().toString(),
-            getProjectBasePath().string()
-        )
+  int exitCode = 0;
+  if (config.isExecutable()) {
+    const Command makeCmd = getMakeCommand().addArg("-C").addArg(outDir).addArg(
+        (config.outBasePath / packageName).string()
+    );
+    Command checkUpToDateCmd = makeCmd;
+    checkUpToDateCmd.addArg("--question");
+
+    exitCode = execCmd(checkUpToDateCmd);
+    if (exitCode != EXIT_SUCCESS) {
+      // If packageName binary is not up-to-date, compile it.
+      logger::info(
+          "Compiling",
+          fmt::format(
+              "{} v{} ({})", packageName, getPackageVersion().toString(),
+              getProjectBasePath().string()
+          )
+      );
+      exitCode = execCmd(makeCmd);
+    }
+  }
+
+  if (config.isLibrary()) {
+    std::string libName = "lib" + packageName + ".a";
+    const Command makeCmd = getMakeCommand().addArg("-C").addArg(outDir).addArg(
+        (config.outBasePath / libName).string()
     );
-    exitCode = execCmd(makeCmd);
+    Command checkUpToDateCmd = makeCmd;
+    checkUpToDateCmd.addArg("--question");
+
+    exitCode = execCmd(checkUpToDateCmd);
+    if (exitCode != EXIT_SUCCESS) {
+      // If packageName binary is not up-to-date, compile it.
+      logger::info(
+          "Compiling",
+          fmt::format(
+              "{} v{} ({})", libName, getPackageVersion().toString(),
+              getProjectBasePath().string()
+          )
+      );
+      exitCode = execCmd(makeCmd);
+    }
   }
 
   const auto end = std::chrono::steady_clock::now();