.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "sonarlint.pathToCompileCommands": "${workspaceFolder}/build/compile_commands.json"
+}

CMakeLists.txt

@@ -0,0 +1,27 @@
+# Specifies the minimum version of CMake required to configure the project.
+cmake_minimum_required(VERSION 3.10)
+
+# Defines the name of the project. This name is used for various CMake targets and variables.
+project(cmake_tutorial C)
+
+# Configures CMake to generate a 'compile_commands.json' file in the build directory.
+# This file is used by many IDEs and language servers (e.g., VS Code, CLion)
+# to provide intelligent code features like autocompletion, go-to-definition, and static analysis.
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands for IDEs." FORCE)
+
+# Includes the CMakeLists.txt files from the specified subdirectories.
+# This makes the targets (libraries) defined in those subdirectories available in the current scope.
+# The order is important: libraries must be defined before they are linked.
+add_subdirectory(libs/lib1)
+add_subdirectory(libs/lib2)
+add_subdirectory(libs/lib3)
+
+# Defines an executable target named 'cmake_tutorialApp' from the source file 'src/app.c'.
+add_executable(cmake_tutorial src/app.c)
+
+# Links the executable target 'cmake_tutorialApp' to the specified libraries.
+# - PRIVATE: Indicates that 'cmake_tutorialApp' needs these libraries for its own compilation/linking,
+#            but targets that link to 'cmake_tutorialApp' do NOT need them.
+# CMake automatically propagates the PUBLIC/INTERFACE include directories from lib1, lib2, and lib3
+# to cmake_tutorialApp, so explicit target_include_directories is not needed here.
+target_link_libraries(cmake_tutorial PRIVATE lib1 lib2 lib3)

libs/lib1/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Defines a static library target named 'lib1' from its source file.
+add_library(lib1 STATIC src/lib1.c)
+
+# Specifies include directories that are part of lib1's public interface.
+# - PUBLIC: Means that targets linking to lib1 (like cmake_tutorialApp) will
+#           inherit this include path. This allows them to find lib1.h.
+# ${CMAKE_CURRENT_SOURCE_DIR} refers to the current directory where this CMakeLists.txt resides.
+target_include_directories(lib1 PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+)
+
+# Links lib1 to lib2 and lib3.
+# - PRIVATE: Indicates that lib1's implementation depends on lib2 and lib3,
+#            but targets linking to lib1 do NOT need to know about lib2 or lib3.
+# CMake automatically propagates the PUBLIC/INTERFACE include directories from lib2 and lib3
+# to lib1, so explicit include directories for them are not needed here.
+target_link_libraries(lib1 PRIVATE lib2 lib3)

libs/lib1/inc/lib1.h

@@ -0,0 +1,6 @@
+#pragma once
+// No need to include lib2.h or lib3.h here unless their types/functions
+// are part of lib1.h's public interface. For simple calls in lib1.c,
+// including in lib1.c is sufficient.
+
+void lib1_function();

libs/lib1/src/lib1.c

@@ -0,0 +1,11 @@
+#include "lib1.h" // Include lib1's own header
+#include "lib2.h" // Include lib2's header to call lib2_function
+#include "lib3.h" // Include lib3's header to call lib3_function
+#include <stdio.h> // Include standard I/O here, as printf is used in this source file.
+
+void lib1_function() {
+  printf("This is a function from Library 1.\n");
+  lib2_function(); // Call function from lib2
+  lib3_function(); // Call function from lib3
+  printf("Lib1 has called functions from Lib2 and Lib3.\n");
+}

libs/lib2/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Defines a static library target named 'lib2' from its source file.
+add_library(lib2 STATIC src/lib2.c)
+
+# Specifies include directories that are part of lib2's public interface.
+# - PUBLIC: Means that targets linking to lib2 (like cmake_tutorialApp or lib1) will
+#           inherit this include path. This allows them to find lib2.h.
+target_include_directories(lib2 PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+)
+

libs/lib2/inc/lib2.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void lib2_function(); // Function declaration for lib2

libs/lib2/src/lib2.c

@@ -0,0 +1,7 @@
+#include "lib2.h"  // Include lib2's own header
+#include <stdio.h> // Include standard I/O here, as printf is used in this source file.
+
+void lib2_function()
+{
+  printf("This is a function from Library 2.\n");
+}

libs/lib3/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Defines an INTERFACE library target named 'lib3'.
+# - INTERFACE: This type of library does not compile any source files itself.
+#              It is used purely to propagate usage requirements (like include directories)
+#              to targets that link to it.
+add_library(lib3 INTERFACE)
+
+# Specifies include directories that are part of lib3's interface.
+# - INTERFACE: Means that targets linking to lib3 (like cmake_tutorialApp or lib1) will
+#              inherit this include path. This allows them to find lib3.h.
+target_include_directories(lib3 INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+)
+

libs/lib3/inc/lib3.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <stdio.h> // Standard I/O header is needed here because printf is used within this header-only function.
+
+// Declared as static to prevent multiple definition errors.
+// Since this is a header-only function, it will be included and compiled
+// into every translation unit that includes lib3.h. 'static' limits its
+// linkage to the current translation unit, preventing linker conflicts.
+static void lib3_function()
+{
+  printf("This is a function from Header-Only Library 3.\n");
+}

src/app.c

@@ -0,0 +1,13 @@
+#include "lib1.h"  // Header for Library 1 (static library)
+#include "lib2.h"  // Header for Library 2 (static library)
+#include "lib3.h"  // Header for Library 3 (header-only library)
+#include <stdio.h> // Standard I/O functions like printf
+
+int main() {
+  printf("Hello from main application!\n");
+  // Call functions from the linked libraries
+  lib1_function();
+  lib2_function();
+  lib3_function();
+  return 0;
+}