generate glenum, link glenum, add source gen for text regex

tools/StgSharp.GenerateGL/Generation/ManagedApiPlanner.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using StgSharp.GenerateGL.Analysis;
 using StgSharp.GenerateGL.Naming;
@@ -20,21 +21,26 @@ namespace StgSharp.GenerateGL.Generation
         private readonly IReadOnlyList<IGlApiFilter> _filters = Array.AsReadOnly<IGlApiFilter>(
             new IGlApiFilter[]
             {
+                new GlManagedApiSuppressionFilter(),
                 new GlOverloadApiFilter(),
                 new GlGetValueApiFilter(),
                 new GlHandleApiFilter(),
             });
         private readonly GlEquivalentTypeMapper _typeMapper;
+        private readonly GlEnumTypeMap _enumTypeMap;
         private readonly GlManagedApiNamePolicy _namePolicy;
 
         public ManagedApiPlanner(
             GlEquivalentTypeMapper typeMapper,
-            GlFunctionFamilyAnalysis familyAnalysis
+            GlFunctionFamilyAnalysis familyAnalysis,
+            GlEnumTypeMap enumTypeMap
         )
         {
             ArgumentNullException.ThrowIfNull(typeMapper);
             ArgumentNullException.ThrowIfNull(familyAnalysis);
+            ArgumentNullException.ThrowIfNull(enumTypeMap);
             _typeMapper = typeMapper;
+            _enumTypeMap = enumTypeMap;
             _namePolicy = new GlManagedApiNamePolicy(familyAnalysis);
         }
 
@@ -57,6 +63,8 @@ namespace StgSharp.GenerateGL.Generation
                     methods = filter.Apply(command, methods, _typeMapper);
                 }
 
+                methods = ApplyEnumTypes(command, methods);
+
                 result.AddRange(
                     methods.Select(
                         method => method with
@@ -77,6 +85,77 @@ namespace StgSharp.GenerateGL.Generation
             return Array.AsReadOnly(result.ToArray());
         }
 
+        private ReadOnlyCollection<ManagedMethodDefinition> ApplyEnumTypes(
+            GlCommandDefinition command,
+            IReadOnlyList<ManagedMethodDefinition> methods
+        )
+        {
+            bool hasEnumReturn = _enumTypeMap.TryReadReturnType(
+                command.Return,
+                out string enumReturnType);
+            return Array.AsReadOnly(
+                methods.Select(
+                    method => ConvertEnumReturn(method, hasEnumReturn, enumReturnType)).ToArray());
+        }
+
+        private ManagedMethodDefinition ConvertEnumReturn(
+            ManagedMethodDefinition method,
+            bool hasEnumReturn,
+            string enumReturnType
+        )
+        {
+            string returnType = string.Empty;
+            bool isEnumReturn = hasEnumReturn && TryReplaceNativeEnumType(
+                method.ReturnType,
+                enumReturnType,
+                out returnType);
+            return method with
+            {
+                ReturnType = isEnumReturn ? returnType : method.ReturnType,
+                IsEnumReturn = isEnumReturn,
+                Parameters = Array.AsReadOnly(
+                    method.Parameters.Select(ConvertEnumParameter).ToArray()),
+            };
+        }
+
+        private ManagedParameterDefinition ConvertEnumParameter(
+            ManagedParameterDefinition parameter
+        )
+        {
+            if (parameter.NativeParameter is null ||
+                !_enumTypeMap.TryReadParameterType(
+                    parameter.NativeParameter,
+                    out string enumType) ||
+                !TryReplaceNativeEnumType(parameter.Type, enumType, out string convertedType))
+            {
+                return parameter;
+            }
+
+            return parameter with
+            {
+                Type = convertedType,
+                IsEnum = true,
+            };
+        }
+
+        private static bool TryReplaceNativeEnumType(
+            string nativeType,
+            string enumType,
+            out string convertedType
+        )
+        {
+            const string nativeBaseType = "uint";
+            if (!nativeType.StartsWith(nativeBaseType, StringComparison.Ordinal) ||
+                nativeType.AsSpan(nativeBaseType.Length).ContainsAnyExcept('*'))
+            {
+                convertedType = string.Empty;
+                return false;
+            }
+
+            convertedType = enumType + nativeType[nativeBaseType.Length..];
+            return true;
+        }
+
         public static void Validate(
             IEnumerable<ManagedMethodDefinition> methods
         )