Merge pull request #69 from Ted-Jin-Lab/development

🐛Cpp throw fix.

Author: Ted-Jin-Lab

Directory.Build.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version>2025.11.24.0</Version>
+    <Version>2025.11.24.1</Version>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>preview</LangVersion>

Tests/TedToolkit.Console/FunctionPointer2.cs

@@ -4,10 +4,10 @@ unsafe partial class FunctionPointer2
 {
     public void Test2(int value, FunctionPointer2_Test_method_Delegate method1)
     {
-        SafeRun(loader =>
-        {
-            var method = (delegate* unmanaged[Cdecl]<FunctionPointer2.Data*, int, FunctionPointer2_Test_method_Delegate, global::System.IntPtr> )loader.GetFunctionPointer("FunctionPointer2_Test");
-            return method(Ptr, value, method1);
-        });
+        var __method =
+            (delegate* unmanaged[Cdecl]<FunctionPointer2.Data**, global::System.IntPtr>)Loader.GetFunctionPointer(
+                "FunctionPointer2_Create_0");
+        fixed (Data** ptr = &Ptr)
+            ThrowIfError(__method(ptr));
     }
 }

Tests/TedToolkit.Console/Program.cs

@@ -9,6 +9,7 @@
 using TedToolkit.Assertions.FluentValidation;
 using TedToolkit.Console;
 using TedToolkit.Console.Wrapper;
+using TedToolkit.CppInteropGen;
 using TedToolkit.QuantExtensions;
 using TedToolkit.ValidResults;
 using UnitsNet;
@@ -31,6 +32,8 @@
 Console.WriteLine(length);
 unsafe
 {
+    var hello = 0;
+    double x = *(double*)&hello;
     var ptr = (double*)&length;
     Console.WriteLine(*ptr);
 

src/analyzers/TedToolkit.CppInteropGen.SourceGenerator/BaseParameterGenerator.cs

@@ -18,14 +18,15 @@ public enum ParameterType : byte
     public abstract bool IsRefOrOut { get; }
     public abstract TypeSyntax PublicType { get; }
     public abstract TypeSyntax InnerType { get; }
+    public abstract TypeSyntax InnerCppType{ get; }
     public abstract ParameterSyntax GenerateParameter();
     public abstract IEnumerable<DelegateDeclarationSyntax> GenerateDelegates();
     public abstract IEnumerable<LocalDeclarationStatementSyntax> GenerateLocalDeclaration();
     public abstract ArgumentSyntax GenerateArgument();
     public abstract ExpressionStatementSyntax GenerateAssignment();
 
     public static IEnumerable<BaseParameterGenerator> GenerateParameters(string methodName, string parameterNames,
-        string[] allClassNames)
+        string[] allClassNames, Dictionary<string, string> parameterTypeReplace)
     {
         var funcPtrRegex = new Regex(
             @"(?<retType>\w[\w\s\*&]*)\s*\(\*(?<name>\w+)\)\s*\((?<args>[^\)]*)\)"
@@ -38,11 +39,11 @@ public static IEnumerable<BaseParameterGenerator> GenerateParameters(string meth
                 var name = match.Groups["name"].Value;
                 var args = match.Groups["args"].Value;
                 var retType = match.Groups["retType"].Value;
-                yield return new FunctionPointParameterGenerator(methodName, name, retType, args, allClassNames);
+                yield return new FunctionPointParameterGenerator(methodName, name, retType, args, allClassNames, parameterTypeReplace);
             }
             else
             {
-                yield return new ParameterGenerator(parameterName, allClassNames);
+                yield return new ParameterGenerator(parameterName, allClassNames, parameterTypeReplace);
             }
         }
     }
@@ -74,7 +75,7 @@ private static IEnumerable<string> GetParameterNames(string input)
         yield return input.Substring(start).Trim();
     }
 
-    protected static string GetTypeNameFromCpp(string typeName, string[] allClassNames)
+    protected internal static string GetTypeNameFromCpp(string typeName, string[] allClassNames)
     {
         return typeName switch
         {

src/analyzers/TedToolkit.CppInteropGen.SourceGenerator/CppClassGenerator.cs

@@ -26,6 +26,8 @@ public CppClassGenerator(SourceText text, string className, Config config, strin
         List<CMethodGenerator> methods = [];
         StringBuilder? builder = null;
 
+        Dictionary<string, string> typeDefinitions = [];
+
         foreach (var line in text.Lines)
         {
             var lineText = line.ToString().Trim();
@@ -46,6 +48,25 @@ public CppClassGenerator(SourceText text, string className, Config config, strin
             {
                 builder.Append(lineText.Trim());
             }
+            else if (IsStartWith(ref lineText, "typedef"))
+            {
+                var types = lineText.Substring(0, lineText.Length - 1).Split(' ');
+                if (types.Length is not 2) continue;
+                var replacedName = BaseParameterGenerator.GetTypeNameFromCpp(types[0], []);
+                if (replacedName
+                    is not "sbyte" and not "byte"
+                    and not "short" and not "ushort"
+                    and not "int" and not "uint"
+                    and not "long" and not "ulong"
+                    and not "global::System.IntPtr" and not "global::System.UIntPtr"
+                    and not "char"
+                    and not "float" and not "double")
+                {
+                    continue;
+                }
+
+                typeDefinitions[types[1]] = replacedName;
+            }
         }
 
         if (builder is not null) CheckBuilder(builder);
@@ -60,7 +81,7 @@ void CheckBuilder(StringBuilder stringBuilder)
             var index = str.IndexOf('{');
             if (index < 0) return;
             var methodDeclare = str.Substring(0, index);
-            methods.Add(new CMethodGenerator(methodDeclare, className, privateIt, allClassNames));
+            methods.Add(new CMethodGenerator(methodDeclare, className, privateIt, allClassNames, typeDefinitions));
         }
     }
 
@@ -81,7 +102,8 @@ public ClassDeclarationSyntax Generate()
                     ]))
                 .WithAttributeLists([GeneratedCodeAttribute(typeof(CppClassGenerator))])
                 .WithModifiers(
-                    TokenList(Token(SyntaxKind.InternalKeyword), Token(SyntaxKind.ReadOnlyKeyword))),
+                    TokenList(Token(_config.IsInternal ? SyntaxKind.InternalKeyword : SyntaxKind.PublicKeyword),
+                        Token(SyntaxKind.ReadOnlyKeyword))),
 
             StructDeclaration("Data")
                 .WithAttributeLists(
@@ -164,7 +186,7 @@ private class CMethodGenerator
         private readonly IReadOnlyList<BaseParameterGenerator> _parameters;
 
         public CMethodGenerator(string methodDeclare, string className, bool isPrivate,
-            string[] allClassesName)
+            string[] allClassesName, Dictionary<string, string> parameterTypeReplace)
         {
             _className = className;
             var startIndex = methodDeclare.IndexOf('(');
@@ -174,7 +196,8 @@ public CMethodGenerator(string methodDeclare, string className, bool isPrivate,
             var endIndex = methodDeclare.LastIndexOf(')');
 
             _parameters = BaseParameterGenerator.GenerateParameters(_methodName,
-                methodDeclare.Substring(startIndex + 1, endIndex - startIndex - 1), allClassesName).ToArray();
+                methodDeclare.Substring(startIndex + 1, endIndex - startIndex - 1), allClassesName,
+                parameterTypeReplace).ToArray();
 
             _isPrivate = isPrivate || _parameters.Any(p => p.HasHandle);
         }
@@ -191,21 +214,23 @@ public IEnumerable<MemberDeclarationSyntax> Generate()
                         .._parameters.Take(_parameters.Count - 1).Select(p => p.GenerateParameter())
                     ]))
                     .WithBody(Block(
-                        GetRunMethod(Block(
-                            GetFunctionPointer(_parameters.Select(p => FunctionPointerParameter(p.InnerType))),
-                            FixedStatement(VariableDeclaration(PointerType(PointerType(IdentifierName("Data"))))
-                                    .WithVariables([
-                                        VariableDeclarator(Identifier("ptr"))
-                                            .WithInitializer(EqualsValueClause(PrefixUnaryExpression(
-                                                SyntaxKind.AddressOfExpression, IdentifierName("Ptr"))))
-                                    ]),
-                                ReturnStatement(InvocationExpression(IdentifierName("__method"))
-                                    .WithArgumentList(ArgumentList(
-                                    [
-                                        .._parameters.Take(_parameters.Count - 1).Select(p => p.GenerateArgument()),
-                                        Argument(IdentifierName("ptr"))
-                                    ]))))
-                        ))));
+                        GetFunctionPointer(_parameters.Select(p => FunctionPointerParameter(p.InnerType))),
+                        FixedStatement(VariableDeclaration(PointerType(PointerType(IdentifierName("Data"))))
+                                .WithVariables([
+                                    VariableDeclarator(Identifier("ptr"))
+                                        .WithInitializer(EqualsValueClause(PrefixUnaryExpression(
+                                            SyntaxKind.AddressOfExpression, IdentifierName("Ptr"))))
+                                ]),
+                            ExpressionStatement(InvocationExpression(IdentifierName("ThrowIfError"))
+                                .WithArgumentList(ArgumentList([
+                                    Argument(InvocationExpression(IdentifierName("__method"))
+                                        .WithArgumentList(ArgumentList(
+                                        [
+                                            .._parameters.Take(_parameters.Count - 1).Select(p => p.GenerateArgument()),
+                                            Argument(IdentifierName("ptr"))
+                                        ])))
+                                ]))))
+                    ));
                 yield break;
             }
 
@@ -215,14 +240,16 @@ public IEnumerable<MemberDeclarationSyntax> Generate()
                     .WithModifiers(TokenList(Token(SyntaxKind.ProtectedKeyword), Token(SyntaxKind.OverrideKeyword)))
                     .WithAttributeLists([GeneratedCodeAttribute(typeof(CMethodGenerator))])
                     .WithBody(Block(
-                        GetRunMethod(Block(
-                            GetFunctionPointer(_parameters.Select(p => FunctionPointerParameter(p.InnerType))),
-                            ReturnStatement(InvocationExpression(IdentifierName("__method"))
-                                .WithArgumentList(ArgumentList(
-                                [
-                                    Argument(IdentifierName("Ptr"))
-                                ])))
-                        ))));
+                        GetFunctionPointer(_parameters.Select(p => FunctionPointerParameter(p.InnerType))),
+                        ExpressionStatement(InvocationExpression(IdentifierName("ThrowIfError"))
+                            .WithArgumentList(ArgumentList([
+                                Argument(InvocationExpression(IdentifierName("__method"))
+                                    .WithArgumentList(ArgumentList(
+                                    [
+                                        Argument(IdentifierName("Ptr")),
+                                    ])))
+                            ])))
+                    ));
                 yield break;
             }
 
@@ -242,28 +269,22 @@ public IEnumerable<MemberDeclarationSyntax> Generate()
                 .WithBody(Block((StatementSyntax[])
                 [
                     .._parameters.Skip(1).Where(p => p.IsRefOrOut).SelectMany(p => p.GenerateLocalDeclaration()),
-                    GetRunMethod(Block(
-                        GetFunctionPointer(_parameters.Select(p => FunctionPointerParameter(p.InnerType))),
-                        ReturnStatement(InvocationExpression(IdentifierName("__method"))
-                            .WithArgumentList(ArgumentList(
-                            [
-                                Argument(IdentifierName("Ptr")),
-                                .._parameters.Skip(1).Select(p => p.GenerateArgument())
-                            ]))))),
+
+                    GetFunctionPointer(_parameters.Select((p, i) =>
+                        FunctionPointerParameter(i == 0 ? p.InnerType : p.InnerCppType))),
+                    ExpressionStatement(InvocationExpression(IdentifierName("ThrowIfError"))
+                        .WithArgumentList(ArgumentList([
+                            Argument(InvocationExpression(IdentifierName("__method"))
+                                .WithArgumentList(ArgumentList(
+                                [
+                                    Argument(IdentifierName("Ptr")),
+                                    .._parameters.Skip(1).Select(p => p.GenerateArgument())
+                                ])))
+                        ]))),
                     .._parameters.Skip(1).Where(p => p.IsRefOrOut).Select(p => p.GenerateAssignment())
                 ]));
             yield break;
 
-            ExpressionStatementSyntax GetRunMethod(BlockSyntax block)
-            {
-                return ExpressionStatement(InvocationExpression(IdentifierName("SafeRun"))
-                    .WithArgumentList(ArgumentList(
-                    [
-                        Argument(SimpleLambdaExpression(Parameter(Identifier("loader")))
-                            .WithBlock(block))
-                    ])));
-            }
-
             LocalDeclarationStatementSyntax GetFunctionPointer(IEnumerable<FunctionPointerParameterSyntax> parameters)
             {
                 return LocalDeclarationStatement(VariableDeclaration(IdentifierName("var"))
@@ -283,9 +304,7 @@ LocalDeclarationStatementSyntax GetFunctionPointer(IEnumerable<FunctionPointerPa
                                         ..parameters,
                                         FunctionPointerParameter(IdentifierName("global::System.IntPtr"))
                                     ])),
-                                InvocationExpression(MemberAccessExpression(
-                                        SyntaxKind.SimpleMemberAccessExpression,
-                                        IdentifierName("loader"), IdentifierName("GetFunctionPointer")))
+                                InvocationExpression( IdentifierName("GetFunctionPointer"))
                                     .WithArgumentList(ArgumentList(
                                     [
                                         Argument(LiteralExpression(SyntaxKind.StringLiteralExpression,

src/analyzers/TedToolkit.CppInteropGen.SourceGenerator/FunctionPointParameterGenerator.cs

@@ -9,13 +9,13 @@ namespace TedToolkit.CppInteropGen.SourceGenerator;
 using static SyntaxExtensions;
 using static SyntaxFactory;
 
-public class FunctionPointParameterGenerator(string methodName, string name, string returnType, string args, string[] allClassNames)
+public class FunctionPointParameterGenerator(string methodName, string name, string returnType, string args, string[] allClassNames, Dictionary<string, string> parameterTypeReplace)
     : BaseParameterGenerator
 {
     private readonly IReadOnlyList<BaseParameterGenerator> _parameters =
-        GenerateParameters(methodName + "_" + name, args, allClassNames).ToArray();
+        GenerateParameters(methodName + "_" + name, args, allClassNames, parameterTypeReplace).ToArray();
 
-    private readonly ParameterGenerator _return = new(returnType, allClassNames);
+    private readonly ParameterGenerator _return = new(returnType, allClassNames, parameterTypeReplace);
     private readonly string _delegateName = methodName + "_" + name + "_Delegate";
     public override string Name { get; } = name;
     public override bool HasHandle => false;
@@ -24,6 +24,7 @@ public class FunctionPointParameterGenerator(string methodName, string name, str
     public override TypeSyntax PublicType => IdentifierName(_delegateName);
 
     public override TypeSyntax InnerType => IdentifierName(_delegateName);
+    public override TypeSyntax InnerCppType => IdentifierName(_delegateName);
 
     public override ParameterSyntax GenerateParameter()
     {
@@ -52,7 +53,7 @@ public override IEnumerable<DelegateDeclarationSyntax> GenerateDelegates()
             .WithParameterList(ParameterList(
             [
                 .._parameters.Select(i =>
-                    Parameter(Identifier(i.Name)).WithType(i.InnerType)),
+                    Parameter(Identifier(i.Name)).WithType(i.InnerCppType)),
             ]));
     }
 

src/analyzers/TedToolkit.CppInteropGen.SourceGenerator/ParameterGenerator.cs

@@ -1,22 +1,21 @@
-using System.Text;
-using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 using SyntaxExtensions = TedToolkit.RoslynHelper.Extensions.SyntaxExtensions;
 
 namespace TedToolkit.CppInteropGen.SourceGenerator;
 
-using static SyntaxExtensions;
 using static SyntaxFactory;
 
 public sealed class ParameterGenerator : BaseParameterGenerator
 {
     private readonly int _ptrCount;
     private readonly string _rawTypeName;
+    private readonly string _cppTypeName;
     private readonly ParameterType _type;
     public override string Name { get; }
 
-    public ParameterGenerator(string parameterString, string[] allClassNames)
+    public ParameterGenerator(string parameterString, string[] allClassNames,
+        Dictionary<string, string> parameterTypeReplace)
     {
         var cleanedString = parameterString
             .Replace("const", string.Empty)
@@ -29,6 +28,9 @@ public ParameterGenerator(string parameterString, string[] allClassNames)
         var typeName = beautifulStrings.First(s => !string.IsNullOrEmpty(s));
         Name = beautifulStrings.Last(s => !string.IsNullOrEmpty(s));
         _rawTypeName = GetTypeNameFromCpp(typeName, allClassNames);
+        _cppTypeName = parameterTypeReplace.TryGetValue(typeName, out var replaceName)
+            ? replaceName
+            : _rawTypeName;
         _type = CheckType();
         return;
 
@@ -85,11 +87,19 @@ public override IEnumerable<DelegateDeclarationSyntax> GenerateDelegates()
     }
 
     public override TypeSyntax InnerType => IdentifierName(_rawTypeName + new string('*', _ptrCount));
+    public override TypeSyntax InnerCppType => IdentifierName(_cppTypeName + new string('*', _ptrCount));
 
     public override ArgumentSyntax GenerateArgument()
     {
         var name = IsData && _type is not ParameterType.Out ? Name + ".Ptr" : Name;
         if (_type is ParameterType.Out or ParameterType.Ref) name = "__" + name;
+        if (_rawTypeName != _cppTypeName)
+        {
+            return Argument(PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression,
+                CastExpression(PointerType(IdentifierName(_cppTypeName)),
+                    PrefixUnaryExpression(SyntaxKind.AddressOfExpression, IdentifierName(name)))));
+        }
+
         return Argument(IdentifierName(name));
     }
 

src/libraries/TedToolkit.CppInteropGen/CppObject.cs

@@ -57,20 +57,19 @@ void IDisposable.Dispose()
         Delete();
     }
 
+    /// <summary>
+    /// Get the Method Pointer.
+    /// </summary>
+    protected IntPtr GetFunctionPointer(string name) =>
+        NativeFunctionLoader.GetLoader(FileFullPath).GetFunctionPointer(name);
+
     [DebuggerStepThrough]
-    protected void SafeRun(Func<NativeFunctionLoader, IntPtr> func)
+    protected unsafe void ThrowIfError(IntPtr errorPtr)
     {
-        var loader = NativeFunctionLoader.GetLoader(FileFullPath);
-        var errorPtr = func(loader);
         if (errorPtr == IntPtr.Zero) return;
-        throw new CppException(GetStringFromIntPtr(errorPtr, loader));
-
-        static unsafe string GetStringFromIntPtr(IntPtr errorPtr, NativeFunctionLoader loader)
-        {
-            var message = Marshal.PtrToStringAnsi(errorPtr) ?? "Unknown error";
-            ((delegate* unmanaged[Cdecl]<IntPtr, void>)loader.GetFunctionPointer("free_error"))(errorPtr);
-            return message;
-        }
+        var message = Marshal.PtrToStringAnsi(errorPtr) ?? "Unknown error";
+        ((delegate* unmanaged[Cdecl]<IntPtr, void>)GetFunctionPointer("free_error"))(errorPtr);
+        throw new CppException(message);
     }
 
     protected virtual void Dispose()