feat: Add support for -isystem

This change introduces support for the -isystem flag, allowing users to
specify system include directories. The addition includes handling the
new flag in both the argument parsing and include resolution logic,
as well as updating relevant tests to validate the new functionality.

Author: jcfr

integration_test.py

@@ -7,6 +7,7 @@
 from testutils import (
     simplecpp,
     format_include_path_arg,
+    format_isystem_path_arg,
     format_framework_path_arg,
     format_iframework_path_arg,
     format_include,
@@ -346,15 +347,16 @@ def test_framework_lookup(record_property, tmpdir, is_sys, is_iframework, is_pri
     "order,expected",
     [
         # Note:
-        # - `I1` / `F1` / `IFW1` point to distinct directories and contain `Component_1.h` (a decoy).
-        # - `I` / `F` / `IFW` point to directories that contain `Component.h`, which the
+        # - `I1` / `ISYS1` / `F1` / `IFW1` point to distinct directories and contain `Component_1.h` (a decoy).
+        # - `I` / `ISYS` / `F` / `IFW` point to directories that contain `Component.h`, which the
         #   translation unit (TU) includes via `#include "MyKit/Component.h"`.
         #
-        # This makes the winning flag (-I, -F, or -iframework) uniquely identifiable
+        # This makes the winning flag (-I, -isystem, -F, or -iframework) uniquely identifiable
         # in the preprocessor `#line` output.
 
         # Sanity checks
         (("I",), "I"),
+        (("ISYS",), "ISYS"),
         (("F",), "F"),
         (("IFW",), "IFW"),
 
@@ -365,6 +367,13 @@ def test_framework_lookup(record_property, tmpdir, is_sys, is_iframework, is_pri
         (("I1", "I", "I1"), "I"),
         (("I", "I1", "I"), "I"),
 
+        # System includes (-isystem)
+        (("ISYS1", "ISYS"), "ISYS"),
+        (("ISYS", "ISYS1"), "ISYS"),
+        # System includes (-isystem) duplicates
+        (("ISYS1", "ISYS", "ISYS1"), "ISYS"),
+        (("ISYS", "ISYS1", "ISYS"), "ISYS"),
+
         # Framework (-F)
         (("F1", "F"), "F"),
         (("F", "F1"), "F"),
@@ -385,6 +394,16 @@ def test_framework_lookup(record_property, tmpdir, is_sys, is_iframework, is_pri
         (("F", "I"), "F"),
         (("F1", "F", "I"), "F"),
 
+        # -I and -F takes precedence over -isystem
+        (("I", "ISYS"), "I"),
+        (("F", "ISYS"), "F"),
+        (("ISYS", "F"), "F"),
+        (("ISYS", "I", "F"), "I"),
+        (("ISYS", "I1", "F1", "I", "F"), "I"),
+        (("ISYS", "I"), "I"),
+        (("ISYS", "F", "I"), "F"),
+        (("ISYS", "F1", "I1", "F", "I"), "F"),
+
         # -I and -F beat system framework (-iframework)
         (("I", "IFW"), "I"),
         (("F", "IFW"), "F"),
@@ -394,16 +413,24 @@ def test_framework_lookup(record_property, tmpdir, is_sys, is_iframework, is_pri
         (("IFW", "I"), "I"),
         (("IFW", "F", "I"), "F"),
         (("IFW", "F1", "I1", "F", "I"), "F"),
+
+        # system include (-isystem) beats system framework (-iframework)
+        (("ISYS", "IFW"), "ISYS"),
+        (("IFW", "ISYS"), "ISYS"),
+        (("IFW1", "ISYS1", "IFW", "ISYS"), "ISYS"),
+        (("I1", "F1", "IFW1", "ISYS1", "IFW", "ISYS"), "ISYS"),
     ],
 )
 def test_searchpath_order(record_property, tmpdir, is_sys, order, expected):
     """
-    Validate include resolution order across -I (user include), -F (user framework),
-    and -iframework (system framework) using a minimal file layout, asserting which
-    physical header path appears in the preprocessor #line output.
+    Validate include resolution order across -I (user include),
+    -isystem (system include), -F (user framework), and
+    -iframework (system framework) using a minimal file layout,
+    asserting which physical header path appears in the preprocessor #line output.
 
-    The test constructs three parallel trees (two entries per kind):
+    The test constructs four parallel trees (two entries per kind):
     - inc{,_1}/MyKit/Component{,_1}.h                     # for -I
+    - isys{,_1}/MyKit/Component{,_1}.h                    # for -isystem
     - Fw{,_1}/MyKit.framework/Headers/Component{,_1}.h    # for -F
     - SysFw{,_1}/MyKit.framework/Headers/Component{,_1}.h # for -iframework
 
@@ -418,7 +445,7 @@ def test_searchpath_order(record_property, tmpdir, is_sys, order, expected):
     """
 
     # Create two include dirs, two user framework dirs, and two system framework dirs
-    inc_dirs, fw_dirs, sysfw_dirs = [], [], []
+    inc_dirs, isys_dirs, fw_dirs, sysfw_dirs = [], [], [], []
 
     def _suffix(idx: int) -> str:
         return f"_{idx}" if idx > 0 else ""
@@ -429,6 +456,11 @@ def _suffix(idx: int) -> str:
         __test_create_header(inc_dir, hdr_relpath=f"MyKit/Component{_suffix(idx)}.h")
         inc_dirs.append(inc_dir)
 
+        # -isystem paths (system includes)
+        isys_dir = os.path.join(tmpdir, f"isys{_suffix(idx)}")
+        __test_create_header(isys_dir, hdr_relpath=f"MyKit/Component{_suffix(idx)}.h")
+        isys_dirs.append(isys_dir)
+
         # -F paths (user frameworks)
         fw_dir = os.path.join(tmpdir, f"Fw{_suffix(idx)}")
         __test_create_framework(fw_dir, "MyKit", f"Component{_suffix(idx)}.h")
@@ -443,15 +475,17 @@ def _suffix(idx: int) -> str:
     test_file = __test_create_source(tmpdir, "MyKit/Component.h", is_include_sys=is_sys)
 
     def idx_from_flag(prefix: str, flag: str) -> int:
-        """Extract numeric suffix from tokens like 'I1', 'F1', 'IFW1'.
-        Returns 0 when no suffix is present (e.g., 'I', 'F', 'IFW')."""
+        """Extract numeric suffix from tokens like 'I1', 'ISYS1', 'F1', 'IFW1'.
+        Returns 0 when no suffix is present (e.g., 'I', 'ISYS', 'F', 'IFW')."""
         return int(flag[len(prefix):]) if len(flag) > len(prefix) else 0
 
     # Build argv in the exact order requested by `order`
     args = []
     for flag in order:
         if flag in ["I", "I1"]:
             args.append(format_include_path_arg(inc_dirs[idx_from_flag("I", flag)]))
+        elif flag in ["ISYS", "ISYS1"]:
+            args.append(format_isystem_path_arg(isys_dirs[idx_from_flag("ISYS", flag)]))
         elif flag in ["F", "F1"]:
             args.append(format_framework_path_arg(fw_dirs[idx_from_flag("F", flag)]))
         elif flag in ["IFW", "IFW1"]:
@@ -469,14 +503,17 @@ def idx_from_flag(prefix: str, flag: str) -> int:
     root = pathlib.PurePath(tmpdir).as_posix()
 
     inc_paths = [f"{root}/inc{_suffix(idx)}/MyKit/Component{_suffix(idx)}.h" for idx in range(2)]
+    isys_paths = [f"{root}/isys{_suffix(idx)}/MyKit/Component{_suffix(idx)}.h" for idx in range(2)]
     fw_paths = [f"{root}/Fw{_suffix(idx)}/MyKit.framework/Headers/Component{_suffix(idx)}.h" for idx in range(2)]
     ifw_paths = [f"{root}/SysFw{_suffix(idx)}/MyKit.framework/Headers/Component{_suffix(idx)}.h" for idx in range(2)]
-    all_candidate_paths = [*inc_paths, *fw_paths, *ifw_paths]
+    all_candidate_paths = [*inc_paths, *isys_paths, *fw_paths, *ifw_paths]
 
     # Compute the single path we expect to appear
     expected_path = None
     if expected in ["I", "I1"]:
         expected_path = inc_paths[idx_from_flag("I", expected)]
+    elif expected in ["ISYS", "ISYS1"]:
+        expected_path = isys_paths[idx_from_flag("ISYS", expected)]
     elif expected in ["F", "F1"]:
         expected_path = fw_paths[idx_from_flag("F", expected)]
     elif expected in ["IFW", "IFW1"]:

main.cpp

@@ -57,6 +57,9 @@ int main(int argc, char **argv)
                 if (std::strncmp(arg, "-include=",9)==0) {
                     dui.includes.push_back(arg+9);
                     found = true;
+                } else if (std::strncmp(arg, "-isystem", 8) == 0) {
+                    dui.searchPaths.push_back({arg + 8, simplecpp::DUI::PathKind::SystemInclude});
+                    found = true;
                 } else if (std::strncmp(arg, "-is",3)==0) {
                     use_istream = true;
                     found = true;
@@ -109,6 +112,7 @@ int main(int argc, char **argv)
         std::cout << "simplecpp [options] filename" << std::endl;
         std::cout << "  -DNAME          Define NAME." << std::endl;
         std::cout << "  -IPATH          Include path." << std::endl;
+        std::cout << "  -isystemPATH    System include path." << std::endl;
         std::cout << "  -FPATH          Framework path." << std::endl;
         std::cout << "  -iframeworkPATH System framework path." << std::endl;
         std::cout << "  -include=FILE   Include FILE." << std::endl;

simplecpp.cpp

@@ -3052,6 +3052,15 @@ static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const
         }
     }
 
+    // -isystem
+    for (const auto &searchPath : searchPaths) {
+        if (searchPath.kind == simplecpp::DUI::PathKind::SystemInclude) {
+            std::string path = openHeaderDirect(f, simplecpp::simplifyPath(searchPath.path + "/" + header));
+            if (!path.empty())
+                return path;
+        }
+    }
+
     // -iframework
     for (const auto &searchPath : searchPaths) {
         if (searchPath.kind == simplecpp::DUI::PathKind::SystemFramework) {
@@ -3149,6 +3158,13 @@ std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::
         }
     }
 
+    // -isystem
+    for (const auto &searchPath : searchPaths) {
+        if (searchPath.kind == DUI::PathKind::SystemInclude) {
+            push_unique(candidates, simplecpp::simplifyPath(searchPath.path + "/" + header));
+        }
+    }
+
     // -iframework
     for (const auto &searchPath : searchPaths) {
         if (searchPath.kind == simplecpp::DUI::PathKind::SystemFramework) {

simplecpp.h

@@ -400,6 +400,7 @@ namespace simplecpp {
      *   -D <name>=<value>       Add macro definition
      *   -U <name>               Undefine macro
      *   -I <dir>                Add include search directory
+     *   -isystem <dir>          Add system include search directory
      *   -F <dir>                Add framework search directory (Darwin)
      *   -iframework <dir>       Add system framework search directory (Darwin)
      *   --include <file>        Force inclusion of a header
@@ -416,8 +417,8 @@ namespace simplecpp {
     struct SIMPLECPP_LIB DUI {
         DUI() : clearIncludeCache(false), removeComments(false) {}
 
-        // Typed search path entry. Mirrors GCC behavior for -I, -F, -iframework.
-        enum class PathKind { Include, Framework, SystemFramework };
+        // Typed search path entry. Mirrors GCC behavior for -I, -isystem, -F, -iframework.
+        enum class PathKind { Include, SystemInclude, Framework, SystemFramework };
         struct SearchPath {
             std::string path;
             PathKind kind;
@@ -427,6 +428,10 @@ namespace simplecpp {
         void addIncludePath(const std::string& path) {
             searchPaths.push_back({path, PathKind::Include});
         }
+        // Mirrors compiler option -I<dir>
+        void addSystemIncludePath(const std::string& path) {
+            searchPaths.push_back({path, PathKind::SystemInclude});
+        }
         // Mirrors compiler option -F<dir>
         void addFrameworkPath(const std::string& path) {
             searchPaths.push_back({path, PathKind::Framework});

testutils.py

@@ -42,6 +42,9 @@ def simplecpp(args = [], cwd = None):
         simplecpp_path = os.environ['SIMPLECPP_EXE_PATH']
     else:
         simplecpp_path = os.path.join(dir_path, "simplecpp")
+
+    print("*" * 20)
+    print([simplecpp_path] + args)
     return __run_subprocess([simplecpp_path] + args, cwd = cwd)
 
 def quoted_string(s):
@@ -50,6 +53,9 @@ def quoted_string(s):
 def format_include_path_arg(include_path):
     return f"-I{str(include_path)}"
 
+def format_isystem_path_arg(include_path):
+    return f"-isystem{str(include_path)}"
+
 def format_framework_path_arg(framework_path):
     return f"-F{str(framework_path)}"