cs-binding-generator 1.0.1.dev21__tar.gz → 1.0.1.dev35__tar.gz

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/.gitignore

@@ -7,3 +7,6 @@ obj/
 dist/
 build/
 _version.py
+
+# Local test output
+out_test/

cs_binding_generator-1.0.1.dev35/COPILOT_CONTEXT.md

@@ -0,0 +1,149 @@
+# CsBindingGenerator - AI Assistant Context
+
+**PURPOSE**: Essential context for AI assistants. For change history, see `git log`.
+
+## Project Overview
+
+Generates C# P/Invoke bindings from C headers using libclang. Modern LibraryImport attributes, multi-file output, regex renames.
+
+## Architecture
+
+```
+C Headers → libclang → Generator → TypeMapper → CodeGenerator → C# Output
+```
+
+- **Generator** (`generator.py`): Parses C headers, manages deduplication, filters system headers
+- **TypeMapper** (`type_mapper.py`): Maps C→C# types, applies renames, context-aware (is_struct_field, is_return_type)
+- **CodeGenerator** (`code_generators.py`): Generates C# code, handles anonymous unions/structs, applies attributes
+- **Config** (`config.py`): Parses XML configuration
+- **Main** (`main.py`): CLI entry point (minimal args - most config in XML)
+
+## Critical Concepts
+
+### Deduplication (Multi-File Mode - Always Enabled)
+
+Global deduplication by name only:
+- Functions: First library wins by `cursor.spelling`
+- Structs/Unions: First library wins by `(name, file, line)`
+
+**CRITICAL**: Library order in XML matters - foundation libraries first.
+
+### Type Mapping Context Awareness
+
+- **`is_struct_field=True`**: Maps C `bool` → C# `byte` (avoids CS8500 managed type errors)
+- **`is_return_type=True`**: Affects pointer type mapping
+
+### Anonymous Unions/Structs
+
+- Detected by "anonymous" in `cursor.spelling`
+- NOT generated as standalone types
+- Members flattened into parent struct
+- Use `cursor.type.get_offset(field_name)` for parent-relative offsets (returns bits ÷ 8 = bytes)
+
+### Variadic Functions
+
+- **Default**: `...` parameter omitted (works with calling conventions, may cause stack issues)
+- **`--use-variadic` flag**: Uses DllImport + `__arglist` (non-AOT compatible)
+
+### Rename Rules
+
+Stored as list: `[(pattern, replacement, is_regex), ...]`
+- Applied in order, first match wins
+- User writes `$1`, `$2` (converted to `\1`, `\2` internally)
+- Uses `re.fullmatch()` for precise matching
+- Post-processing uses word boundaries
+
+**Conflict resolution**: Place specific rules before general ones:
+```xml
+<rename from="SDL_strcasecmp" to="SDL_strcasecmp"/>  <!-- Keep -->
+<rename from="SDL_(.*)" to="$1" regex="true"/>        <!-- Strip rest -->
+```
+
+### System Header Filtering
+
+`_is_system_header()` filters:
+- `/usr/include/` direct files (no subdirectory)
+- `/usr/include/{sys,bits,etc}/` subdirectories
+- C standard library headers (c_std_headers set)
+- `/usr/include/c++` paths
+
+## XML Configuration
+
+```xml
+<bindings visibility="internal">
+    <include_directory path="/custom/path"/>
+    <rename from="PREFIX_(.*)" to="$1" regex="true"/>
+    <remove pattern="DEPRECATED_.*" regex="true"/>
+    <constants name="Flags" pattern="FLAG_.*" type="uint" flags="true"/>
+    
+    <library name="libname" namespace="Namespace" class="ClassName">
+        <using namespace="System.Runtime.CompilerServices"/>
+        <include file="/path/to/header.h"/>
+    </library>
+</bindings>
+```
+
+**Key attributes**:
+- `<bindings>`: `visibility="public|internal"`
+- `<rename>`: `from`, `to`, `regex="true|false"`
+- `<remove>`: `pattern`, `regex="true|false"`
+- `<constants>`: `name`, `pattern`, `type`, `flags="true|false"`
+- `<library>`: `name`, `namespace`, `class` (default: "NativeMethods")
+- `<using>`: `namespace`
+- `<include>`: `file`
+
+**Note**: Don't specify `/usr/include` - clang auto-detects it.
+
+## CLI Arguments (Limited by Design)
+
+- `-C/--config`: XML config file (default: cs-bindings.xml)
+- `-o/--output`: Output directory (default: current)
+- `--ignore-missing`: Continue if headers missing
+- `--use-variadic`: Generate variadic functions with __arglist
+- `--clang-path`: Path to libclang
+
+## Known Edge Cases
+
+- **Duplicate symbols**: Ensure library order in XML (foundation first) for global deduplication
+- **Bool in structs**: Type mapper automatically converts bool→byte when `is_struct_field=True` to avoid managed type errors
+- **System header leakage**: `_is_system_header()` must filter direct `/usr/include/` files and subdirectories
+- **Anonymous unions**: Must detect "anonymous" in `cursor.spelling` and flatten members with parent-relative offsets
+- **Incomplete arrays**: Handle `TypeKind.INCOMPLETEARRAY` → `nuint` for char*, `T*` for others
+
+## libclang Key Concepts
+
+- `cursor.spelling`: Entity name
+- `cursor.location.file`: Source file
+- `cursor.is_definition()`: True if definition (not declaration)
+- `cursor.type.get_offset(field)`: Offset in **bits** (÷ 8 for bytes)
+- `TypeKind.INCOMPLETEARRAY`: Array parameters like `items[]`
+
+## Testing
+
+Run: `source enter_devenv.sh && ./run_tests.sh`
+- pytest 9.0.2, Python 3.13.11
+- Current: 179 tests
+- Test with real C code using `temp_header_file` fixture
+- Verify struct offsets in bytes
+
+## Development Workflow
+
+1. Source env: `source enter_devenv.sh`
+2. Make changes
+3. Run: `./run_tests.sh`
+4. Test projects in `test_dotnet/`: SDL3Test, LibtcodTest, FreeTypeTest
+5. Each has `regenerate_bindings.sh` + `dotnet build`
+
+## User Interaction Rules
+
+1. Never assume pre-existing bugs
+2. Don't try random fixes - ask if uncertain
+3. Read error messages carefully
+4. Check actual implementation (e.g., argparse in main.py) before documenting
+5. Update this file only for architectural insights, not change history
+
+---
+
+**For change history: `git log`**
+
+

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cs_binding_generator
-Version: 1.0.1.dev21
+Version: 1.0.1.dev35
 Summary: Generate C# bindings from C headers using libclang with modern LibraryImport
 Author-email: Robin 'Ruadeil' Degen <mail@ruadeil.lgbt>
 License-Expression: MIT

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/cs_binding_generator/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.1.dev21'
-__version_tuple__ = version_tuple = (1, 0, 1, 'dev21')
+__version__ = version = '1.0.1.dev35'
+__version_tuple__ = version_tuple = (1, 0, 1, 'dev35')
 
-__commit_id__ = commit_id = 'gcee9644ab'
+__commit_id__ = commit_id = 'g0db8f9507'

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/cs_binding_generator/code_generators.py

@@ -187,11 +187,16 @@ class CodeGenerator:
         # Add helper function for struct return types (skip for variadic functions)
         if is_struct_return and not is_variadic:
             # Build parameters for helper (same as original)
+            # Escape parameter names for the function call
+            param_names = [self._escape_keyword(arg.spelling) if arg.spelling else f"param{i}" 
+                          for i, arg in enumerate(cursor.get_arguments())]
+            params_call_str = ", ".join(param_names) if param_names else ""
+            
             code += f"""
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     {self.visibility} static unsafe {struct_return_type} {func_name}Struct({params_str})
     {{
-        var ptr = {func_name}({", ".join(arg.spelling or f"param{i}" for i, arg in enumerate(cursor.get_arguments())) if cursor.get_arguments() else ""});
+        var ptr = {func_name}({params_call_str});
         return Marshal.PtrToStructure<{struct_return_type}>((nint)ptr);
     }}
 """
@@ -237,10 +242,69 @@ class CodeGenerator:
         # Collect fields with their offsets
         fields = []
         for field in cursor.get_children():
+            # Handle anonymous unions/structs by flattening their members into the parent struct
+            if field.kind == CursorKind.UNION_DECL and field.spelling and "anonymous" in field.spelling.lower() and field.is_definition():
+                # This is an anonymous union - flatten its members into the struct
+                for union_member in field.get_children():
+                    if union_member.kind == CursorKind.FIELD_DECL:
+                        member_name = union_member.spelling
+                        if not member_name:
+                            continue
+                        
+                        # Escape C# keywords
+                        member_name = self._escape_keyword(member_name)
+                        
+                        # Get the offset using parent struct's type.get_offset()
+                        # This gives us the actual offset in the parent struct, not relative to the union
+                        try:
+                            offset_bits = cursor.type.get_offset(union_member.spelling)
+                            offset_bytes = offset_bits // 8
+                        except Exception:
+                            # Fallback to field offset (will be wrong for anonymous unions)
+                            offset_bits = union_member.get_field_offsetof()
+                            offset_bytes = offset_bits // 8
+                        
+                        # Map the type
+                        member_type = self.type_mapper.map_type(union_member.type, is_struct_field=True)
+                        if not member_type or "unnamed" in member_type or "::" in member_type:
+                            continue
+                        
+                        fields.append(f"    [FieldOffset({offset_bytes})]\n    {self.visibility} {member_type} {member_name};")
+                continue
+            
+            # Handle anonymous structs by flattening their members
+            if field.kind == CursorKind.STRUCT_DECL and field.spelling and "anonymous" in field.spelling.lower() and field.is_definition():
+                # This is an anonymous struct - flatten its members into the parent struct
+                for struct_member in field.get_children():
+                    if struct_member.kind == CursorKind.FIELD_DECL:
+                        member_name = struct_member.spelling
+                        if not member_name:
+                            continue
+                        
+                        # Escape C# keywords
+                        member_name = self._escape_keyword(member_name)
+                        
+                        # Get the offset using parent struct's type.get_offset()
+                        try:
+                            offset_bits = cursor.type.get_offset(struct_member.spelling)
+                            offset_bytes = offset_bits // 8
+                        except Exception:
+                            # Fallback to field offset
+                            offset_bits = struct_member.get_field_offsetof()
+                            offset_bytes = offset_bits // 8
+                        
+                        # Map the type
+                        member_type = self.type_mapper.map_type(struct_member.type, is_struct_field=True)
+                        if not member_type or "unnamed" in member_type or "::" in member_type:
+                            continue
+                        
+                        fields.append(f"    [FieldOffset({offset_bytes})]\n    {self.visibility} {member_type} {member_name};")
+                continue
+            
             if field.kind == CursorKind.FIELD_DECL:
                 field_name = field.spelling
 
-                # Skip unnamed fields (anonymous unions/structs)
+                # Skip unnamed fields (anonymous unions/structs without definitions are already handled above)
                 if not field_name:
                     continue
 
@@ -255,7 +319,7 @@ class CodeGenerator:
                 if field.type.kind == TypeKind.CONSTANTARRAY:
                     element_type = field.type.get_array_element_type()
                     array_size = field.type.get_array_size()
-                    element_csharp = self.type_mapper.map_type(element_type)
+                    element_csharp = self.type_mapper.map_type(element_type, is_struct_field=True)
 
                     # Skip if element type cannot be mapped
                     if not element_csharp:
@@ -265,6 +329,7 @@ class CodeGenerator:
                     element_size = element_type.get_size()  # size in bytes
 
                     # Check if element type is a primitive type (can use fixed keyword)
+                    # Note: bool is excluded because fixed bool arrays make structs managed
                     primitive_types = {
                         "byte",
                         "sbyte",
@@ -276,7 +341,6 @@ class CodeGenerator:
                         "ulong",
                         "float",
                         "double",
-                        "bool",
                         "char",
                     }
 
@@ -355,7 +419,7 @@ class CodeGenerator:
                 if field.type.kind == TypeKind.CONSTANTARRAY:
                     element_type = field.type.get_array_element_type()
                     array_size = field.type.get_array_size()
-                    element_csharp = self.type_mapper.map_type(element_type)
+                    element_csharp = self.type_mapper.map_type(element_type, is_struct_field=True)
 
                     # Skip if element type cannot be mapped
                     if not element_csharp:
@@ -365,6 +429,7 @@ class CodeGenerator:
                     element_size = element_type.get_size()
 
                     # Check if element type is a primitive type (can use fixed keyword)
+                    # Note: bool is excluded because fixed bool arrays make structs managed
                     primitive_types = {
                         "byte",
                         "sbyte",
@@ -376,7 +441,6 @@ class CodeGenerator:
                         "ulong",
                         "float",
                         "double",
-                        "bool",
                         "char",
                     }
 
@@ -555,9 +619,14 @@ class CodeGenerator:
             if csharp_type and csharp_type != "int":
                 inheritance_clause = f" : {csharp_type}"
 
+        # Check if this enum should have [Flags] attribute
+        flags_attribute = ""
+        if self.type_mapper.is_flag_enum(enum_name):
+            flags_attribute = "[Flags]\n"
+
         values_str = "\n".join(values)
 
-        code = f"""{self.visibility} enum {enum_name}{inheritance_clause}
+        code = f"""{flags_attribute}{self.visibility} enum {enum_name}{inheritance_clause}
 {{
 {values_str}
 }}
@@ -640,6 +709,7 @@ class OutputBuilder:
             argv_copy[0] = "cs_binding_generator"
         command_line = " ".join(argv_copy)
 
+        parts.append("// <auto-generated />")
         parts.append("//")
         parts.append("// This file was automatically generated by cs-binding-generator")
         parts.append("// https://github.com/cs-binding-generator/cs-binding-generator")
@@ -648,6 +718,8 @@ class OutputBuilder:
         parts.append("// Do not modify this file directly")
         parts.append("//")
         parts.append("")
+        parts.append("#nullable enable")
+        parts.append("")
 
         # Usings (non-global)
         from .constants import REQUIRED_USINGS

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/cs_binding_generator/config.py

@@ -3,10 +3,27 @@ XML configuration file parsing for C# bindings generator
 """
 
 import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BindingConfig:
+    """Configuration for C# bindings generation"""
+    header_library_pairs: list[tuple[str, str]] = field(default_factory=list)
+    include_dirs: list[str] = field(default_factory=list)
+    renames: list[tuple[str, str, bool]] = field(default_factory=list)
+    removals: list[tuple[str, bool]] = field(default_factory=list)
+    flag_enums: list[tuple[str, bool]] = field(default_factory=list)
+    library_class_names: dict[str, str] = field(default_factory=dict)
+    library_namespaces: dict[str, str] = field(default_factory=dict)
+    library_using_statements: dict[str, list[str]] = field(default_factory=dict)
+    visibility: str = "public"
+    global_constants: list[tuple[str, str, str, bool]] = field(default_factory=list)
+    global_defines: list[tuple[str, str | None]] = field(default_factory=list)
 
 
 def parse_config_file(config_path):
-    """Parse XML configuration file and return header-library pairs, include directories, and renames"""
+    """Parse XML configuration file and return BindingConfig object"""
     try:
         tree = ET.parse(config_path)
         root = tree.getroot()
@@ -14,20 +31,13 @@ def parse_config_file(config_path):
         if root.tag != "bindings":
             raise ValueError(f"Expected root element 'bindings', got '{root.tag}'")
 
-        header_library_pairs = []
-        include_dirs = []
-        renames = []  # Changed to list of (from, to, is_regex) tuples
-        removals = []  # List of (pattern, is_regex) tuples
-        library_class_names = {}  # Map library name to class name
-        library_namespaces = {}  # Map library name to namespace
-        library_using_statements = {}  # Map library name to list of using statements
-        library_constants = {}  # Map library name to list of (name, pattern, type) tuples
+        config = BindingConfig()
 
         # Get global visibility setting (default to "public")
-        visibility = root.get("visibility", "public").strip().lower()
-        if visibility not in ("public", "internal"):
+        config.visibility = root.get("visibility", "public").strip().lower()
+        if config.visibility not in ("public", "internal"):
             import sys
-            print(f"Error: Invalid visibility value '{visibility}'. Must be 'public' or 'internal'.", file=sys.stderr)
+            print(f"Error: Invalid visibility value '{config.visibility}'. Must be 'public' or 'internal'.", file=sys.stderr)
             sys.exit(1)
 
         # Get global include directories
@@ -35,7 +45,7 @@ def parse_config_file(config_path):
             path = include_dir.get("path")
             if not path:
                 raise ValueError("Include directory element missing 'path' attribute")
-            include_dirs.append(path.strip())
+            config.include_dirs.append(path.strip())
 
         # Get global renames (support both simple and regex)
         for rename in root.findall("rename"):
@@ -44,7 +54,7 @@ def parse_config_file(config_path):
             if not from_name or not to_name:
                 raise ValueError("Rename element missing 'from' or 'to' attribute")
             is_regex = rename.get("regex", "false").lower() == "true"
-            renames.append((from_name.strip(), to_name.strip(), is_regex))
+            config.renames.append((from_name.strip(), to_name.strip(), is_regex))
 
         # Get global removals (support both simple and regex)
         for remove in root.findall("remove"):
@@ -52,12 +62,29 @@ def parse_config_file(config_path):
             if not pattern:
                 raise ValueError("Remove element missing 'pattern' attribute")
             is_regex = remove.get("regex", "false").lower() == "true"
-            removals.append((pattern.strip(), is_regex))
+            config.removals.append((pattern.strip(), is_regex))
+
+        # Get global flag enums (enum patterns that should have [Flags] attribute)
+        for flag_enum in root.findall("flags"):
+            pattern = flag_enum.get("pattern")
+            if not pattern:
+                raise ValueError("Flags element missing 'pattern' attribute")
+            is_regex = flag_enum.get("regex", "false").lower() == "true"
+            config.flag_enums.append((pattern.strip(), is_regex))
+
+        # Get global compiler defines
+        for define in root.findall("define"):
+            name = define.get("name")
+            if not name:
+                raise ValueError("Define element missing 'name' attribute")
+            value = define.get("value")  # Optional, can be None
+            if value is not None:
+                value = value.strip()
+            config.global_defines.append((name.strip(), value))
 
         # Get global constants (macros to extract)
         # These are stored as a list of (name, pattern, type, is_flags) tuples
         # They will be applied to all libraries during processing
-        global_constants = []
         for const in root.findall("constants"):
             const_name = const.get("name")
             const_pattern = const.get("pattern")
@@ -69,7 +96,7 @@ def parse_config_file(config_path):
             if not const_pattern:
                 raise ValueError("Constants element missing 'pattern' attribute")
 
-            global_constants.append((const_name.strip(), const_pattern.strip(), const_type.strip(), const_flags))
+            config.global_constants.append((const_name.strip(), const_pattern.strip(), const_type.strip(), const_flags))
 
         for library in root.findall("library"):
             library_name = library.get("name")
@@ -78,12 +105,12 @@ def parse_config_file(config_path):
 
             # Get class name (default to NativeMethods if not specified)
             class_name = library.get("class", "NativeMethods")
-            library_class_names[library_name.strip()] = class_name.strip()
+            config.library_class_names[library_name.strip()] = class_name.strip()
 
             # Get namespace from library attribute
             library_namespace = library.get("namespace")
             if library_namespace is not None:
-                library_namespaces[library_name.strip()] = library_namespace.strip()
+                config.library_namespaces[library_name.strip()] = library_namespace.strip()
 
             # Get using statements
             using_statements = []
@@ -92,33 +119,23 @@ def parse_config_file(config_path):
                 if using_namespace:
                     using_statements.append(using_namespace.strip())
             if using_statements:
-                library_using_statements[library_name.strip()] = using_statements
+                config.library_using_statements[library_name.strip()] = using_statements
 
             # Get library-specific include directories
             for include_dir in library.findall("include_directory"):
                 path = include_dir.get("path")
                 if not path:
                     raise ValueError(f"Include directory element in library '{library_name}' missing 'path' attribute")
-                include_dirs.append(path.strip())
+                config.include_dirs.append(path.strip())
 
             # Get include files
             for include in library.findall("include"):
                 header_path = include.get("file")
                 if not header_path:
                     raise ValueError(f"Include element in library '{library_name}' missing 'file' attribute")
-                header_library_pairs.append((header_path.strip(), library_name.strip()))
-
-        return (
-            header_library_pairs,
-            include_dirs,
-            renames,
-            removals,
-            library_class_names,
-            library_namespaces,
-            library_using_statements,
-            visibility,
-            global_constants,
-        )
+                config.header_library_pairs.append((header_path.strip(), library_name.strip()))
+
+        return config
 
     except ET.ParseError as e:
         raise ValueError(f"XML parsing error: {e}")

{cs_binding_generator-1.0.1.dev21 → cs_binding_generator-1.0.1.dev35}/cs_binding_generator/generator.py

@@ -265,6 +265,9 @@ class CSharpBindingsGenerator:
 
         elif cursor.kind == CursorKind.STRUCT_DECL:
             if cursor.is_definition():
+                # Skip anonymous structs - they are handled inline by their parent struct
+                if cursor.spelling and "anonymous" in cursor.spelling.lower():
+                    return
                 # Only generate code for non-system headers
                 if cursor.location.file:
                     file_path = str(Path(cursor.location.file.name).resolve())
@@ -292,6 +295,9 @@ class CSharpBindingsGenerator:
 
         elif cursor.kind == CursorKind.UNION_DECL:
             if cursor.is_definition():
+                # Skip anonymous unions - they are handled inline by their parent struct
+                if cursor.spelling and "anonymous" in cursor.spelling.lower():
+                    return
                 # Only generate code for non-system headers
                 if cursor.location.file:
                     file_path = str(Path(cursor.location.file.name).resolve())
@@ -377,6 +383,28 @@ class CSharpBindingsGenerator:
                                 self.seen_structs.add((type_name, None, None))
                                 # Register as opaque type for pointer handling
                                 self.type_mapper.opaque_types.add(type_name)
+                                # Also generate an opaque type for the underlying struct name
+                                # e.g. when typedef struct _XDisplay Display; we also want _XDisplay
+                                try:
+                                    underlying_spelling = str(child.type.spelling)
+                                except Exception:
+                                    underlying_spelling = None
+                                if underlying_spelling:
+                                    # strip 'struct ' prefix if present
+                                    u_name = underlying_spelling
+                                    for prefix in ["const ", "volatile ", "struct ", "union ", "class "]:
+                                        if u_name.startswith(prefix):
+                                            u_name = u_name[len(prefix) :]
+                                            break
+                                    if u_name and u_name != type_name:
+                                        u_struct_key = (u_name, str(cursor.location.file), cursor.location.line)
+                                        if u_struct_key not in self.seen_structs:
+                                            u_code = self.code_generator.generate_opaque_type(u_name)
+                                            if u_code:
+                                                self._add_to_library_collection(self.generated_structs, self.current_library, u_code)
+                                                self.seen_structs.add(u_struct_key)
+                                                self.seen_structs.add((u_name, None, None))
+                                                self.type_mapper.opaque_types.add(u_name)
                 elif child.kind == CursorKind.STRUCT_DECL and not child.is_definition() and child.spelling:
                     # Direct forward declaration
                     struct_key = (child.spelling, str(cursor.location.file), cursor.location.line)
@@ -495,6 +523,7 @@ class CSharpBindingsGenerator:
         library_using_statements: Optional[dict[str, list[str]]] = None,
         visibility: str = "public",
         global_constants: Optional[list[tuple[str, str, str, bool]]] = None,
+        global_defines: Optional[list[tuple[str, Optional[str]]]] = None,
     ) -> dict[str, str]:
         """Generate C# bindings from C header file(s)
 
@@ -503,12 +532,13 @@ class CSharpBindingsGenerator:
             output: Output directory for generated files (required)
             include_dirs: List of directories to search for included headers
             ignore_missing: Continue processing even if some header files are not found
-            skip_variadic: Skip generating bindings for variadic functions
+            skip_variadic: Skip generating bindings for variadic functions (default: True)
             library_class_names: Dict mapping library names to custom class names (defaults to NativeMethods)
             library_namespaces: Dict mapping library names to custom namespaces
             library_using_statements: Dict mapping library names to lists of using statements
             visibility: Visibility modifier for generated code ("public" or "internal")
             global_constants: List of (name, pattern, type) tuples for macro extraction, applied to all libraries
+            global_defines: List of (name, value) tuples for compiler defines, applied to all headers
         """
         # Store visibility setting
         self.visibility = visibility
@@ -528,6 +558,9 @@ class CSharpBindingsGenerator:
         # Store global constants
         self.global_constants = global_constants or []
 
+        # Store global defines
+        self.global_defines = global_defines or []
+
         # Clear previous state
         self._clear_state()
 
@@ -539,6 +572,13 @@ class CSharpBindingsGenerator:
         for include_dir in include_dirs:
             clang_args.append(f"-I{include_dir}")
 
+        # Add global compiler defines
+        for name, value in self.global_defines:
+            if value is None or value == "":
+                clang_args.append(f"-D{name}")
+            else:
+                clang_args.append(f"-D{name}={value}")
+
         # Add system include paths so clang can find standard headers
         # These paths are typical locations for system headers
         import subprocess
@@ -671,8 +711,13 @@ class CSharpBindingsGenerator:
                 if underlying_type and underlying_type != "int":
                     inheritance_clause = f" : {underlying_type}"
 
+                # Check if this enum should have [Flags] attribute
+                flags_attribute = ""
+                if self.type_mapper.is_flag_enum(enum_name):
+                    flags_attribute = "[Flags]\n"
+
                 values_str = "\n".join([f"    {name} = {value}," for name, value in members])
-                code = f"""{self.visibility} enum {enum_name}{inheritance_clause}
+                code = f"""{flags_attribute}{self.visibility} enum {enum_name}{inheritance_clause}
 {{
 {values_str}
 }}