dub.compilers.utils: Add pkg-config C preprocessor flags support

Query pkg-config for any C preprocessor flags as well (notably include
paths and defines), and pass them to the D compiler so that they can
be included when preprocessing C code and library headers.

Author: CyberShadow

source/dub/compilers/utils.d

@@ -148,6 +148,13 @@ void resolveLibs(ref BuildSettings settings, const scope ref BuildPlatform platf
 					} else if (f.startsWith("-Wl,")) settings.addLFlags(f[4 .. $].split(","));
 					else settings.addLFlags(f);
 				}
+
+				// Also extract C preprocessor flags from pkg-config --cflags
+				auto cflags = execute([pkgconfig_bin, "--cflags"] ~ pkgconfig_libs);
+				if (cflags.status == 0) {
+					logDiagnostic("Using pkg-config to resolve C preprocessor flags for %s.", pkgconfig_libs.join(", "));
+					applyPkgConfigCFlags(settings, cflags.output);
+				}
 			}
 			if (settings.libs.length) logDiagnostic("Using direct -l... flags for %s.", settings.libs.array.join(", "));
 		} catch (Exception e) {
@@ -160,6 +167,68 @@ void resolveLibs(ref BuildSettings settings, const scope ref BuildPlatform platf
 }
 
 
+/**
+	Parses pkg-config --cflags output and applies C preprocessor flags to build settings.
+
+	All C preprocessor flags (-I, -D, -U, -include, -isystem, -idirafter) are passed
+	to the D compiler via -P prefix (for DMD/LDC) so they get forwarded to the C preprocessor.
+	This is called from resolveLibs() which runs after cImportPaths are already processed,
+	so we add directly to dflags with the -P prefix.
+*/
+package void applyPkgConfigCFlags(ref BuildSettings settings, string cflagsOutput)
+{
+	import std.algorithm : splitter, startsWith;
+
+	// Note: We split by whitespace for consistency with --libs parsing above.
+	// This won't handle shell-quoted paths with spaces, but neither does --libs.
+	foreach (f; cflagsOutput.splitter()) {
+		if (f.startsWith("-I") || f.startsWith("-D") || f.startsWith("-U") ||
+		    f.startsWith("-include") || f.startsWith("-isystem") ||
+		    f.startsWith("-idirafter")) {
+			// Pass all C preprocessor flags via -P (for DMD/LDC)
+			settings.addDFlags("-P" ~ f);
+		}
+	}
+}
+
+unittest {
+	BuildSettings settings;
+
+	// Test -I flag extraction (passed via -P prefix)
+	applyPkgConfigCFlags(settings, "-I/usr/include/foo -I/usr/include/bar");
+	assert(settings.dflags == ["-P-I/usr/include/foo", "-P-I/usr/include/bar"]);
+
+	// Test preprocessor define flags
+	settings = BuildSettings.init;
+	applyPkgConfigCFlags(settings, "-DFOO=1 -DBAR -UBAZ");
+	assert(settings.dflags == ["-P-DFOO=1", "-P-DBAR", "-P-UBAZ"]);
+
+	// Test mixed flags
+	settings = BuildSettings.init;
+	applyPkgConfigCFlags(settings, "-I/usr/include -DVERSION=2 -isystem/usr/local/include");
+	assert(settings.dflags == ["-P-I/usr/include", "-P-DVERSION=2", "-P-isystem/usr/local/include"]);
+
+	// Test -idirafter flag (attached path)
+	settings = BuildSettings.init;
+	applyPkgConfigCFlags(settings, "-idirafter/fallback/include");
+	assert(settings.dflags == ["-P-idirafter/fallback/include"]);
+
+	// Note: -include with space-separated argument (e.g., "-include config.h") is not
+	// fully supported - the flag is passed but the argument may be lost if space-separated.
+	// Most pkg-config files use attached arguments (e.g., -I/path, -DFOO).
+
+	// Test empty input
+	settings = BuildSettings.init;
+	applyPkgConfigCFlags(settings, "");
+	assert(settings.dflags.length == 0);
+
+	// Test unknown flags are ignored (e.g., -pthread which is for linker)
+	settings = BuildSettings.init;
+	applyPkgConfigCFlags(settings, "-I/inc -pthread -Wall");
+	assert(settings.dflags == ["-P-I/inc"]);
+}
+
+
 /** Searches the given list of compiler flags for ones that have a generic
 	equivalent.
 

source/dub/generators/build.d

@@ -601,11 +601,22 @@ class BuildGenerator : ProjectGenerator {
 		}
 		if (settings.buildMode == BuildMode.singleFile && generate_binary) {
 			import std.parallelism, std.range : walkLength;
+			import std.algorithm : filter, startsWith;
 
 			auto lbuildsettings = buildsettings;
 			auto srcs = buildsettings.sourceFiles.filter!(f => !isLinkerFile(settings.platform, f));
 			auto objs = new string[](srcs.walkLength);
 
+			// Resolve pkg-config flags early to get C preprocessor flags for compilation.
+			// We do this on lbuildsettings first, then copy -P flags to buildsettings.
+			lbuildsettings.sourceFiles = is_static_library ? [] : lbuildsettings.sourceFiles.filter!(f => isLinkerFile(settings.platform, f)).array;
+			settings.compiler.setTarget(lbuildsettings, settings.platform);
+			settings.compiler.prepareBuildSettings(lbuildsettings, settings.platform, BuildSetting.commandLineSeparate|BuildSetting.sourceFiles);
+
+			// Copy C preprocessor flags (-P...) from linker settings to compiler settings.
+			foreach (flag; lbuildsettings.dflags.filter!(f => f.startsWith("-P")))
+				buildsettings.addDFlags(flag);
+
 			void compileSource(size_t i, string src) {
 				logInfo("Compiling", Color.light_green, "%s", src);
 				const objPath = pathToObjName(settings.platform, src, settings.toolWorkingDirectory);
@@ -619,9 +630,6 @@ class BuildGenerator : ProjectGenerator {
 			}
 
 			logInfo("Linking", Color.light_green, "%s", buildsettings.targetName.color(Mode.bold));
-			lbuildsettings.sourceFiles = is_static_library ? [] : lbuildsettings.sourceFiles.filter!(f => isLinkerFile(settings.platform, f)).array;
-			settings.compiler.setTarget(lbuildsettings, settings.platform);
-			settings.compiler.prepareBuildSettings(lbuildsettings, settings.platform, BuildSetting.commandLineSeparate|BuildSetting.sourceFiles);
 			settings.compiler.invokeLinker(lbuildsettings, settings.platform, objs, settings.linkCallback, settings.toolWorkingDirectory);
 
 		// NOTE: separate compile/link is not yet enabled for GDC.
@@ -646,6 +654,13 @@ class BuildGenerator : ProjectGenerator {
 			if (generate_binary) settings.compiler.setTarget(lbuildsettings, settings.platform);
 			settings.compiler.prepareBuildSettings(lbuildsettings, settings.platform, BuildSetting.commandLineSeparate|BuildSetting.sourceFiles);
 
+			// Copy C preprocessor flags (-P...) from linker settings to compiler settings.
+			// These come from pkg-config --cflags and are needed for ImportC compilation.
+			// We must copy them before clearing libs, since resolveLibs extracts them.
+			import std.algorithm : filter, startsWith;
+			foreach (flag; lbuildsettings.dflags.filter!(f => f.startsWith("-P")))
+				buildsettings.addDFlags(flag);
+
 			// setup compiler command line
 			buildsettings.libs = null;
 			buildsettings.frameworks = null;

test/issue782-gtkd-pkg-config.sh

@@ -22,6 +22,25 @@ else
     export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:-}${LD_LIBRARY_PATH:+:}$PWD/../fake-gtkd
     # pkg-config needs to find our .pc file which is in $PWD/../fake-gtkd/pkgconfig, so set PKG_CONFIG_PATH accordingly
     export PKG_CONFIG_PATH=$PWD/../fake-gtkd/pkgconfig
+
+    # Verify that pkg-config --cflags is being extracted properly
+    # The .pc file includes -DFAKE_GTKD_VERSION=100 which should appear as -P-DFAKE_GTKD_VERSION=100
+    VERBOSE_OUTPUT=$(${DUB} build --force --compiler=${DC} -v 2>&1)
+    if ! echo "$VERBOSE_OUTPUT" | grep -q "\-P-DFAKE_GTKD_VERSION=100"; then
+        echo "FAIL: pkg-config --cflags extraction not working: -P-DFAKE_GTKD_VERSION=100 not found in compiler flags"
+        echo "Verbose output:"
+        echo "$VERBOSE_OUTPUT"
+        exit 1
+    fi
+    echo "PASS: pkg-config --cflags extraction working (-P-DFAKE_GTKD_VERSION=100 found)"
+
+    # Also verify -P-I flag for cImportPaths is present
+    if ! echo "$VERBOSE_OUTPUT" | grep -q "\-P-I.*fake-gtkd"; then
+        echo "FAIL: pkg-config --cflags extraction not working: -P-I path not found in compiler flags"
+        exit 1
+    fi
+    echo "PASS: pkg-config --cflags include path extraction working"
+
     ${DUB} run --force --compiler=${DC}
     cd ..
     rm -rf fake-gtkd/.dub

test/issue782-gtkd-pkg-config/fake-gtkd/pkgconfig/fake-gtkd.pc

@@ -9,4 +9,6 @@ Version: 1.0.0
 # The "-L-defaultlib=libphobos2.so" and "-defaultlib=libphobos2.so" should both end up on the compiler (at link stage) invocation as "-defaultlib=libphobos2.so"
 # For this test, it doesn't hurt that they appear twice on the cmd line...
 Libs: -L-L${libdir} -L-l:libfake-gtkd.so -L-l:libdl.so.2 -pthread -L-defaultlib=libphobos2.so -defaultlib=libphobos2.so
-Cflags: -I${includedir}
+# Cflags should be extracted and passed to the C preprocessor via -P flags
+# -I goes to cImportPaths, -D goes to dflags with -P prefix
+Cflags: -I${includedir} -DFAKE_GTKD_VERSION=100