diff --git a/Directory.Build.props b/Directory.Build.props index 3b291f70..c5231b74 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -43,7 +43,7 @@ $(BaseArtifactsPath)pkg/$(Configuration)/ ClangSharp 12.0.0 - beta2 + beta3 pr diff --git a/Directory.Build.targets b/Directory.Build.targets index b5df26ed..d9444a7d 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -21,7 +21,7 @@ - + $(NETCoreSdkRuntimeIdentifier) $(OVERRIDE_RUNTIME_IDENTIFIER) diff --git a/scripts/azure-pipelines.yml b/scripts/azure-pipelines.yml index 2be7c59d..5266557e 100644 --- a/scripts/azure-pipelines.yml +++ b/scripts/azure-pipelines.yml @@ -29,6 +29,14 @@ jobs: architecture: x64 testwin32metadata: false +- template: azure-windows.yml + parameters: + name: windows_release_x64 + pool: windows-latest + configuration: Release + architecture: x64 + testwin32metadata: false + - template: azure-windows.yml parameters: name: test_win32metadata diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs index 90c551d4..850a7cb4 100644 --- a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs +++ b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitDecl.cs @@ -952,7 +952,27 @@ void ForFunctionDecl(ParmVarDecl parmVarDecl, FunctionDecl functionDecl) if (parmVarDecl.HasDefaultArg) { _outputBuilder.BeginParameterDefault(); - UncheckStmt(typeName, parmVarDecl.DefaultArg); + + var defaultArg = parmVarDecl.DefaultArg; + + if (parmVarDecl.Type.CanonicalType.IsPointerType && (defaultArg.Handle.Evaluate.Kind == CXEvalResultKind.CXEval_UnExposed)) + { + if (!IsStmtAsWritten(defaultArg, out _, removeParens: true) && + (!IsStmtAsWritten(defaultArg, out var castExpr, removeParens: true) || (castExpr.CastKind != CX_CastKind.CX_CK_NullToPointer)) && + (!IsStmtAsWritten(defaultArg, out var integerLiteral, removeParens: true) || (integerLiteral.Value != 0))) + { + AddDiagnostic(DiagnosticLevel.Info, $"Unsupported default parameter: '{name}'. Generated bindings may be incomplete.", defaultArg); + } + + var outputBuilder = StartCSharpCode(); + outputBuilder.Write("null"); + StopCSharpCode(); + } + else + { + UncheckStmt(typeName, parmVarDecl.DefaultArg); + } + _outputBuilder.EndParameterDefault(); } @@ -2521,12 +2541,12 @@ void ForUnderlyingType(TypedefDecl typedefDecl, Type underlyingType) if (_config.LogPotentialTypedefRemappings) { var typedefName = typedefDecl.UnderlyingDecl.Name; - var possibleNamesToRemap = new string[] {"_" + typedefName, "_tag" + typedefName, "tag" + typedefName}; + var possibleNamesToRemap = new string[] {"_" + typedefName, "_tag" + typedefName, "tag" + typedefName, typedefName + "_tag" }; var underlyingName = underlyingTagType.AsString; foreach (var possibleNameToRemap in possibleNamesToRemap) { - if (!_config.RemappedNames.ContainsKey(possibleNameToRemap)) + if (!_config.RemappedNames.ContainsKey(possibleNameToRemap) && !_config.RemappedNames.ContainsKey(possibleNameToRemap + "*")) { if (possibleNameToRemap == underlyingName) { @@ -2704,7 +2724,7 @@ private void VisitVarDecl(VarDecl varDecl) } } } - else if ((type.IsLocalConstQualified || isMacroDefinitionRecord) && CanBeConstant(type, varDecl.Init)) + else if ((type.IsLocalConstQualified || isMacroDefinitionRecord) && CanBeConstant(type, typeName, varDecl.Init)) { kind |= ConstantKind.PrimitiveConstant; } @@ -2820,15 +2840,15 @@ void ForDeclStmt(VarDecl varDecl, DeclStmt declStmt) StopCSharpCode(); } - bool CanBeConstant(Type type, Expr initExpr) + bool CanBeConstant(Type type, string targetTypeName, Expr initExpr) { if (type is AttributedType attributedType) { - return CanBeConstant(attributedType.ModifiedType, initExpr); + return CanBeConstant(attributedType.ModifiedType, targetTypeName, initExpr); } else if (type is AutoType autoType) { - return CanBeConstant(autoType.CanonicalType, initExpr); + return CanBeConstant(autoType.CanonicalType, targetTypeName, initExpr); } else if (type is BuiltinType builtinType) { @@ -2852,28 +2872,28 @@ bool CanBeConstant(Type type, Expr initExpr) case CXTypeKind.CXType_Float: case CXTypeKind.CXType_Double: { - return IsConstant(initExpr); + return IsConstant(targetTypeName, initExpr); } } } else if (type is ElaboratedType elaboratedType) { - return CanBeConstant(elaboratedType.NamedType, initExpr); + return CanBeConstant(elaboratedType.NamedType, targetTypeName, initExpr); } else if (type is EnumType enumType) { - return CanBeConstant(enumType.Decl.IntegerType, initExpr); + return CanBeConstant(enumType.Decl.IntegerType, targetTypeName, initExpr); } else if (type is TypedefType typedefType) { - return CanBeConstant(typedefType.Decl.UnderlyingType, initExpr); + return CanBeConstant(typedefType.Decl.UnderlyingType, targetTypeName, initExpr); } return false; } } - private bool IsConstant(Expr initExpr) + private bool IsConstant(string targetTypeName, Expr initExpr) { switch (initExpr.StmtClass) { @@ -2882,7 +2902,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_ConditionalOperator: { var conditionalOperator = (ConditionalOperator)initExpr; - return IsConstant(conditionalOperator.Cond) && IsConstant(conditionalOperator.LHS) && IsConstant(conditionalOperator.RHS); + return IsConstant(targetTypeName, conditionalOperator.Cond) && IsConstant(targetTypeName, conditionalOperator.LHS) && IsConstant(targetTypeName, conditionalOperator.RHS); } // case CX_StmtClass.CX_StmtClass_AddrLabelExpr: @@ -2901,7 +2921,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_BinaryOperator: { var binaryOperator = (BinaryOperator)initExpr; - return IsConstant(binaryOperator.LHS) && IsConstant(binaryOperator.RHS); + return IsConstant(targetTypeName, binaryOperator.LHS) && IsConstant(targetTypeName, binaryOperator.RHS); } // case CX_StmtClass.CX_StmtClass_CompoundAssignOperator: @@ -2982,7 +3002,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_CXXFunctionalCastExpr: { var cxxFunctionalCastExpr = (ExplicitCastExpr)initExpr; - return IsConstant(cxxFunctionalCastExpr.SubExprAsWritten); + return IsConstant(targetTypeName, cxxFunctionalCastExpr.SubExprAsWritten); } // case CX_StmtClass.CX_StmtClass_CXXConstCastExpr: @@ -2993,7 +3013,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_ImplicitCastExpr: { var implicitCastExpr = (ImplicitCastExpr)initExpr; - return IsConstant(implicitCastExpr.SubExprAsWritten); + return IsConstant(targetTypeName, implicitCastExpr.SubExprAsWritten); } case CX_StmtClass.CX_StmtClass_CharacterLiteral: @@ -3012,7 +3032,7 @@ private bool IsConstant(Expr initExpr) { var declRefExpr = (DeclRefExpr)initExpr; return (declRefExpr.Decl is EnumConstantDecl) || - ((declRefExpr.Decl is VarDecl varDecl) && varDecl.HasInit && IsConstant(varDecl.Init)); + ((declRefExpr.Decl is VarDecl varDecl) && varDecl.HasInit && IsConstant(targetTypeName, varDecl.Init)); } // case CX_StmtClass.CX_StmtClass_DependentCoawaitExpr: @@ -3033,7 +3053,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_ExprWithCleanups: { var exprWithCleanups = (ExprWithCleanups)initExpr; - return IsConstant(exprWithCleanups.SubExpr); + return IsConstant(targetTypeName, exprWithCleanups.SubExpr); } // case CX_StmtClass.CX_StmtClass_FunctionParmPackExpr: @@ -3089,7 +3109,7 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_ParenExpr: { var parenExpr = (ParenExpr)initExpr; - return IsConstant(parenExpr.SubExpr); + return IsConstant(targetTypeName, parenExpr.SubExpr); } case CX_StmtClass.CX_StmtClass_ParenListExpr: @@ -3098,7 +3118,7 @@ private bool IsConstant(Expr initExpr) foreach (var expr in parenListExpr.Exprs) { - if (IsConstant(expr)) + if (IsConstant(targetTypeName, expr)) { return true; } @@ -3159,7 +3179,18 @@ private bool IsConstant(Expr initExpr) case CX_StmtClass.CX_StmtClass_UnaryOperator: { var unaryOperator = (UnaryOperator)initExpr; - return IsConstant(unaryOperator.SubExpr); + + if (!IsConstant(targetTypeName, unaryOperator.SubExpr)) + { + return false; + } + + if (unaryOperator.Opcode != CX_UnaryOperatorKind.CX_UO_Minus) + { + return true; + } + + return targetTypeName is not "IntPtr" and not "nint" and not "nuint" and not "UIntPtr"; } // case CX_StmtClass.CX_StmtClass_VAArgExpr: diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs index 8d12da68..f606a521 100644 --- a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs +++ b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs @@ -188,18 +188,38 @@ private void VisitCharacterLiteral(CharacterLiteral characterLiteral) } else { - var isPreviousExplicitCast = IsPrevContextStmt(out _); + var castType = ""; - if (!isPreviousExplicitCast) + if (IsPrevContextStmt(out var implicitCastExpr)) { - outputBuilder.Write("(byte)("); + // C# characters are effectively `ushort` while C defaults to "char" which is + // most typically `sbyte`. Due to this we need to insert a correct implicit + // cast to ensure things are correctly handled here. + + var castExprTypeName = GetRemappedTypeName(implicitCastExpr, context: null, implicitCastExpr.Type, out _, skipUsing: true); + + if (!IsUnsigned(castExprTypeName)) + { + castType = "sbyte"; + } + else if (implicitCastExpr.Type.Handle.NumBits < 16) + { + // Cast to byte if the target type is less + + castType = "byte"; + } + } + + if (castType != "") + { + outputBuilder.Write("(sbyte)("); } outputBuilder.Write('\''); outputBuilder.Write(EscapeCharacter((char)characterLiteral.Value)); outputBuilder.Write('\''); - if (!isPreviousExplicitCast) + if (castType != "") { outputBuilder.Write(')'); } @@ -634,6 +654,7 @@ private void VisitDoStmt(DoStmt doStmt) private void VisitExplicitCastExpr(ExplicitCastExpr explicitCastExpr) { var outputBuilder = StartCSharpCode(); + if (IsPrevContextDecl(out _) && explicitCastExpr.Type is EnumType enumType) { outputBuilder.Write('('); @@ -643,10 +664,17 @@ private void VisitExplicitCastExpr(ExplicitCastExpr explicitCastExpr) } var type = explicitCastExpr.Type; - - var typeName = GetRemappedTypeName(explicitCastExpr, context: null, type, out _); + if (typeName == "IntPtr") + { + typeName = "nint"; + } + else if (typeName == "UIntPtr") + { + typeName = "nuint"; + } + outputBuilder.Write('('); outputBuilder.Write(typeName); outputBuilder.Write(')'); @@ -832,7 +860,7 @@ private void VisitImplicitCastExpr(ImplicitCastExpr implicitCastExpr) default: { - if ((subExpr is DeclRefExpr declRefExpr) && (declRefExpr.Decl is EnumConstantDecl enumConstantDecl)) + if (IsStmtAsWritten(subExpr, out var declRefExpr, removeParens: true) && (declRefExpr.Decl is EnumConstantDecl enumConstantDecl)) { ForEnumConstantDecl(implicitCastExpr, enumConstantDecl); } @@ -1901,7 +1929,7 @@ private void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr unaryExprOrT { var arg = args[i]; - if (IsStmtAsWritten(arg, unaryExprOrTypeTraitExpr)) + if (IsStmtAsWritten(arg, unaryExprOrTypeTraitExpr, removeParens: true)) { index = i; break; @@ -2026,7 +2054,18 @@ private void VisitUnaryOperator(UnaryOperator unaryOperator) if (canonicalType.IsIntegerType && (canonicalType.Kind != CXTypeKind.CXType_Bool)) { + var needsParens = IsStmtAsWritten(subExpr, out _); + + if (needsParens) + { + outputBuilder.Write('('); + } Visit(subExpr); + + if (needsParens) + { + outputBuilder.Write(')'); + } outputBuilder.Write(" == 0"); } else if (canonicalType is PointerType or ReferenceType) diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs index 7cfab004..f3c033eb 100644 --- a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs +++ b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs @@ -662,14 +662,20 @@ private string EscapeAndStripName(string name) return EscapeName(name); } - internal static string EscapeCharacter(char value) => EscapeString(value.ToString()); + internal static string EscapeCharacter(char value) => value switch { + '\\' => "\\\\", + '\r' => "\\r", + '\n' => "\\n", + '\t' => "\\t", + '\'' => "\\'", + _ => value.ToString(), + }; internal static string EscapeString(string value) => value.Replace("\\", "\\\\") .Replace("\r", "\\r") .Replace("\n", "\\n") .Replace("\t", "\\t") - .Replace("\"", "\\\"") - .Replace("\'", "\\'"); + .Replace("\"", "\\\""); private AccessSpecifier GetAccessSpecifier(NamedDecl namedDecl) { @@ -1488,7 +1494,7 @@ private string GetTypeName(Cursor cursor, Cursor context, Type rootType, Type ty { if (_config.GenerateUnixTypes) { - goto case CXTypeKind.CXType_Int; + goto case CXTypeKind.CXType_UInt; } else { @@ -3230,9 +3236,38 @@ private bool IsUnchecked(string targetTypeName, Stmt stmt) case CX_StmtClass.CX_StmtClass_UnaryOperator: { var unaryOperator = (UnaryOperator)stmt; - return IsUnchecked(targetTypeName, unaryOperator.SubExpr) - || IsUnchecked(targetTypeName, unaryOperator.Handle.Evaluate) - || ((unaryOperator.Opcode == CX_UnaryOperatorKind.CX_UO_Minus) && IsUnsigned(targetTypeName)); + + if (IsUnchecked(targetTypeName, unaryOperator.SubExpr)) + { + return true; + } + + var evaluation = unaryOperator.Handle.Evaluate; + + if (IsUnchecked(targetTypeName, evaluation)) + { + return true; + } + + var sourceTypeName = GetTypeName(stmt, context: null, unaryOperator.SubExpr.Type, out _); + + switch (unaryOperator.Opcode) + { + case CX_UnaryOperatorKind.CX_UO_Minus: + { + return IsUnsigned(targetTypeName); + } + + case CX_UnaryOperatorKind.CX_UO_Not: + { + return IsUnsigned(targetTypeName) != IsUnsigned(sourceTypeName); + } + + default: + { + return false; + } + } } // case CX_StmtClass.CX_StmtClass_VAArgExpr: @@ -3249,9 +3284,42 @@ bool IsOverflow(BinaryOperator binaryOperator) var lhs = binaryOperator.LHS; var rhs = binaryOperator.RHS; - if (!IsStmtAsWritten(lhs, out var lhsIntegerLiteral, removeParens: true) || !IsStmtAsWritten(rhs, out var rhsIntegerLiteral, removeParens: true)) + long lhsValue, rhsValue; + + if (IsStmtAsWritten(lhs, out var lhsIntegerLiteral, removeParens: true)) { - return false; + lhsValue = lhsIntegerLiteral.Value; + } + else + { + var lhsEvaluation = lhs.Handle.Evaluate; + + if (lhsEvaluation.Kind == CXEvalResultKind.CXEval_Int) + { + lhsValue = lhsEvaluation.AsInt; + } + else + { + return false; + } + } + + if (IsStmtAsWritten(rhs, out var rhsIntegerLiteral, removeParens: true)) + { + rhsValue = rhsIntegerLiteral.Value; + } + else + { + var rhsEvaluation = rhs.Handle.Evaluate; + + if (rhsEvaluation.Kind == CXEvalResultKind.CXEval_Int) + { + rhsValue = rhsEvaluation.AsInt; + } + else + { + return false; + } } var targetTypeName = GetRemappedTypeName(binaryOperator, context: null, binaryOperator.Type, out _); @@ -3262,15 +3330,15 @@ bool IsOverflow(BinaryOperator binaryOperator) case CX_BinaryOperatorKind.CX_BO_Add: { return isUnsigned - ? (ulong)lhsIntegerLiteral.Value + (ulong)rhsIntegerLiteral.Value < (ulong)lhsIntegerLiteral.Value - : lhsIntegerLiteral.Value + rhsIntegerLiteral.Value < lhsIntegerLiteral.Value; + ? (ulong)lhsValue + (ulong)rhsValue < (ulong)lhsValue + : lhsValue + rhsValue < lhsValue; } case CX_BinaryOperatorKind.CX_BO_Sub: { return isUnsigned - ? (ulong)lhsIntegerLiteral.Value - (ulong)rhsIntegerLiteral.Value > (ulong)lhsIntegerLiteral.Value - : lhsIntegerLiteral.Value - rhsIntegerLiteral.Value > lhsIntegerLiteral.Value; + ? (ulong)lhsValue - (ulong)rhsValue > (ulong)lhsValue + : lhsValue - rhsValue > lhsValue; } default: @@ -3313,6 +3381,7 @@ private static bool IsUnchecked(string typeName, long signedValue, bool isNegati case "uint": case "UInt32": case "nuint": + case "UIntPtr": { return false; } @@ -3338,6 +3407,7 @@ private static bool IsUnchecked(string typeName, long signedValue, bool isNegati case "int": case "Int32": case "nint": + case "IntPtr": { return (signedValue < int.MinValue) || (int.MaxValue < signedValue) || (isNegative && isHex); } diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/FunctionDeclarationDllImportTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/FunctionDeclarationDllImportTest.cs index 4d586330..e32cf7ab 100644 --- a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/FunctionDeclarationDllImportTest.cs +++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/FunctionDeclarationDllImportTest.cs @@ -50,7 +50,7 @@ public abstract class FunctionDeclarationDllImportTest : PInvokeGeneratorTest [InlineData("unsigned short", "7", true, "ushort", "7")] [InlineData("unsigned int", "8", true, "uint", "8")] [InlineData("unsigned long long", "9", true, "ulong", "9")] - [InlineData("unsigned short", "'A'", true, "ushort", "(byte)('A')")] + [InlineData("unsigned short", "'A'", true, "ushort", "'A'")] public abstract Task OptionalParameterTest(string nativeType, string nativeInit, bool expectedNativeTypeNameAttr, string expectedManagedType, string expectedManagedInit); [Theory] diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/VarDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/VarDeclarationTest.cs index a6681969..d4537cf1 100644 --- a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/VarDeclarationTest.cs +++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/VarDeclarationTest.cs @@ -186,7 +186,7 @@ namespace ClangSharp.Test public static partial class Methods {{ [NativeTypeName(""#define MyMacro1 (long)0x80000000L"")] - public const IntPtr MyMacro1 = (IntPtr)(0x80000000); + public const IntPtr MyMacro1 = unchecked((nint)(0x80000000)); [NativeTypeName(""#define MyMacro2 (int)0x80000000"")] public const int MyMacro2 = unchecked((int)(0x80000000)); @@ -227,7 +227,7 @@ namespace ClangSharp.Test public static partial class Methods {{ [NativeTypeName(""#define MyMacro3 MyMacro2(3)"")] - public const int MyMacro3 = unchecked((int)(((UIntPtr)(1) << 31) | ((UIntPtr)(2) << 16) | ((UIntPtr)(3)))); + public const int MyMacro3 = unchecked((int)(((nuint)(1) << 31) | ((nuint)(2) << 16) | ((nuint)(3)))); }} }} "; diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/VarDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/VarDeclarationTest.cs index 9873d3fc..9f0b2ed9 100644 --- a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/VarDeclarationTest.cs +++ b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/VarDeclarationTest.cs @@ -224,7 +224,11 @@ public override Task UncheckedConversionMacroTest() IntPtr - (IntPtr)(0x80000000) + + + (nint)(0x80000000) + + @@ -285,7 +289,7 @@ public override Task UncheckedConversionMacroTest2() int - ((int)(((UIntPtr)(1) << 31) | ((UIntPtr)(2) << 16) | ((UIntPtr)(3)))) + ((int)(((nuint)(1) << 31) | ((nuint)(2) << 16) | ((nuint)(3))))