diff --git a/src/Generation/Generator/Model/Type.cs b/src/Generation/Generator/Model/Type.cs index fe268b10f..02e51a810 100644 --- a/src/Generation/Generator/Model/Type.cs +++ b/src/Generation/Generator/Model/Type.cs @@ -19,9 +19,11 @@ public static string GetName(GirModel.Type type) GirModel.SignedByte => "sbyte", GirModel.Short => "short", GirModel.Long => "long", + GirModel.CLong => "long", GirModel.UnsignedShort => "ushort", GirModel.UnsignedInteger => "uint", GirModel.UnsignedLong => "ulong", + GirModel.UnsignedCLong => "ulong", GirModel.Byte => "byte", GirModel.Bool => "bool", GirModel.Void => "void", diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs new file mode 100644 index 000000000..fb8200ac0 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/CLong.cs @@ -0,0 +1,25 @@ +namespace Generator.Renderer.Internal.Field; + +internal class CLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + Attribute: null, + NullableTypeName: GetNullableTypeName(field) + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : "CLong"; + } +} diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs index 0b70ef722..38534a169 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/Long.cs @@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field) { return field.IsPointer ? Model.Type.Pointer - : "CLong"; + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); } } diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..46a9da47f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedCLong.cs @@ -0,0 +1,25 @@ +namespace Generator.Renderer.Internal.Field; + +internal class UnsignedCLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + Attribute: null, + NullableTypeName: GetNullableTypeName(field) + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : "CULong"; + } +} diff --git a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs index 7269e71f2..687235bba 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Converter/UnsignedLong.cs @@ -20,6 +20,6 @@ private static string GetNullableTypeName(GirModel.Field field) { return field.IsPointer ? Model.Type.Pointer - : "CULong"; + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); } } diff --git a/src/Generation/Generator/Renderer/Internal/Field/Fields.cs b/src/Generation/Generator/Renderer/Internal/Field/Fields.cs index 12382baeb..d37ba8ea7 100644 --- a/src/Generation/Generator/Renderer/Internal/Field/Fields.cs +++ b/src/Generation/Generator/Renderer/Internal/Field/Fields.cs @@ -21,6 +21,8 @@ internal static class Fields new Field.PointerArray(), new Field.Long(), //Must be before primitive value new Field.UnsignedLong(), //Must be before primitive value + new Field.CLong(), //Must be before primitive value + new Field.UnsignedCLong(), //Must be before primitive value new Field.PrimitiveValueType(), new Field.PrimitiveValueTypeAlias(), new Field.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs b/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs index 0ada82832..e7a717d58 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/CallbackParameters.cs @@ -27,6 +27,8 @@ internal static class CallbackParameters new Parameter.PointerGLibPtrArray(), new Parameter.Long(), //Must be before primitive value type new Parameter.UnsignedLong(), //Must be before primitive value type + new Parameter.CLong(), //Must be before primitive value type + new Parameter.UnsignedCLong(), //Must be before primitive value type new Parameter.PrimitiveValueType(), new Parameter.PrimitiveValueTypeAlias(), new Parameter.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs new file mode 100644 index 000000000..dbe1a9e8f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/CLong.cs @@ -0,0 +1,44 @@ +using System; + +namespace Generator.Renderer.Internal.Parameter; + +internal class CLong : ParameterConverter +{ + public bool Supports(GirModel.AnyType anyType) + { + return anyType.Is(); + } + + public RenderableParameter Convert(GirModel.Parameter parameter) + { + // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly + // ownership transfer (this combination does not currently occur for any functions). + if (parameter is { Nullable: true, Optional: true }) + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported"); + + // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. + if (parameter.Nullable) + Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + + // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) + if (parameter.CallerAllocates) + Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + + return new RenderableParameter( + Attribute: string.Empty, + Direction: GetDirection(parameter), + NullableTypeName: "CLong", + Name: Model.Parameter.GetName(parameter) + ); + } + + private static string GetDirection(GirModel.Parameter parameter) => parameter switch + { + // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired. + { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), + { Direction: GirModel.Direction.In } => ParameterDirection.In(), + _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.") + }; +} diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs index b1055f050..a52c36ce3 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/Long.cs @@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter) // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly // ownership transfer (this combination does not currently occur for any functions). if (parameter is { Nullable: true, Optional: true }) - throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Long value type with nullable=true and optional=true not yet supported"); + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported"); // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. if (parameter.Nullable) - Log.Information($"Long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) if (parameter.CallerAllocates) - Log.Information($"Long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); return new RenderableParameter( Attribute: string.Empty, Direction: GetDirection(parameter), - NullableTypeName: "CLong", + NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0), Name: Model.Parameter.GetName(parameter) ); } @@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter) { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), { Direction: GirModel.Direction.In } => ParameterDirection.In(), - _ => throw new Exception($"Can't figure out direction for internal long value type parameter {parameter}.") + _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.") }; } diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..17a13bc3d --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedCLong.cs @@ -0,0 +1,44 @@ +using System; + +namespace Generator.Renderer.Internal.Parameter; + +internal class UnsignedCLong : ParameterConverter +{ + public bool Supports(GirModel.AnyType anyType) + { + return anyType.Is(); + } + + public RenderableParameter Convert(GirModel.Parameter parameter) + { + // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly + // ownership transfer (this combination does not currently occur for any functions). + if (parameter is { Nullable: true, Optional: true }) + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported"); + + // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. + if (parameter.Nullable) + Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + + // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) + if (parameter.CallerAllocates) + Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + + return new RenderableParameter( + Attribute: string.Empty, + Direction: GetDirection(parameter), + NullableTypeName: "CULong", + Name: Model.Parameter.GetName(parameter) + ); + } + + private static string GetDirection(GirModel.Parameter parameter) => parameter switch + { + // - Optional inout and out types are just exposed as non-nullable ref / out parameters which the user can ignore if desired. + { Direction: GirModel.Direction.In, IsPointer: true } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), + { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), + { Direction: GirModel.Direction.In } => ParameterDirection.In(), + _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.") + }; +} diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs index d5396f0e1..48833c472 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Converter/UnsignedLong.cs @@ -14,20 +14,20 @@ public RenderableParameter Convert(GirModel.Parameter parameter) // If the parameter is both nullable and optional this implies a parameter type like 'int **' and possibly // ownership transfer (this combination does not currently occur for any functions). if (parameter is { Nullable: true, Optional: true }) - throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Unsigned long value type with nullable=true and optional=true not yet supported"); + throw new System.NotImplementedException($"{parameter.AnyTypeOrVarArgs} - Primitive value type with nullable=true and optional=true not yet supported"); // Nullable-only parameters likely have incorrect annotations and should be marked optional instead. if (parameter.Nullable) - Log.Information($"Unsigned long value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with nullable=true is likely an incorrect annotation"); // The caller-allocates flag is not meaningful for primitive types (https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/446) if (parameter.CallerAllocates) - Log.Information($"Unsigned long value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); + Log.Information($"Primitive value type '{parameter.Name}' with caller-allocates=true is an incorrect annotation"); return new RenderableParameter( Attribute: string.Empty, Direction: GetDirection(parameter), - NullableTypeName: "CULong", + NullableTypeName: Model.Type.GetName(parameter.AnyTypeOrVarArgs.AsT0.AsT0), Name: Model.Parameter.GetName(parameter) ); } @@ -39,6 +39,6 @@ public RenderableParameter Convert(GirModel.Parameter parameter) { Direction: GirModel.Direction.InOut } => ParameterDirection.Ref(), { Direction: GirModel.Direction.Out } => ParameterDirection.Out(), { Direction: GirModel.Direction.In } => ParameterDirection.In(), - _ => throw new Exception($"Can't figure out direction for internal unsigned long value type parameter {parameter}.") + _ => throw new Exception($"Can't figure out direction for internal primitive value type parameter {parameter}.") }; } diff --git a/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs b/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs index 144b0c531..081cb83d9 100644 --- a/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs +++ b/src/Generation/Generator/Renderer/Internal/Parameter/Parameters.cs @@ -32,6 +32,8 @@ internal static class Parameters new Parameter.PointerGLibPtrArray(), new Parameter.Long(), //Must be before primitive value type new Parameter.UnsignedLong(), //Must be before primitive value type + new Parameter.CLong(), //Must be before primitive value type + new Parameter.UnsignedCLong(), //Must be before primitive value type new Parameter.PrimitiveValueType(), new Parameter.PrimitiveValueTypeAlias(), new Parameter.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs new file mode 100644 index 000000000..463cd2954 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/CLong.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Internal.ParameterToManagedExpressions; + +internal class CLong : ToManagedParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToManagedData parameterData, IEnumerable parameters) + { + switch (parameterData.Parameter) + { + case { Direction: GirModel.Direction.In, IsPointer: false }: + Direct(parameterData); + break; + default: + throw new NotImplementedException($"This kind of internal long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently."); + } + } + + private static void Direct(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"{variableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs index eb69e0b5e..5f02d8e6f 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/Long.cs @@ -12,19 +12,41 @@ public void Initialize(ParameterToManagedData parameterData, IEnumerable variableName); + parameterData.SetCallName(() => $"ref {variableName}"); + } + private static void Direct(ParameterToManagedData parameterData) { var variableName = Model.Parameter.GetName(parameterData.Parameter); parameterData.SetSignatureName(() => variableName); - parameterData.SetCallName(() => $"{variableName}.Value"); + parameterData.SetCallName(() => variableName); + } + + private static void Out(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"out {variableName}"); } } diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..daef63381 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Internal.ParameterToManagedExpressions; + +internal class UnsignedCLong : ToManagedParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToManagedData parameterData, IEnumerable parameters) + { + switch (parameterData.Parameter) + { + case { Direction: GirModel.Direction.In, IsPointer: false }: + Direct(parameterData); + break; + default: + throw new NotImplementedException($"This kind of internal unsigned long value type (pointed: {parameterData.Parameter.IsPointer}, direction: {parameterData.Parameter.Direction} can't be converted to managed currently."); + } + } + + private static void Direct(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"{variableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs index 97e667229..0300cf5be 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/Converter/UnsignedLong.cs @@ -12,19 +12,41 @@ public void Initialize(ParameterToManagedData parameterData, IEnumerable variableName); + parameterData.SetCallName(() => $"ref {variableName}"); + } + private static void Direct(ParameterToManagedData parameterData) { var variableName = Model.Parameter.GetName(parameterData.Parameter); parameterData.SetSignatureName(() => variableName); - parameterData.SetCallName(() => $"{variableName}.Value"); + parameterData.SetCallName(() => variableName); + } + + private static void Out(ParameterToManagedData parameterData) + { + var variableName = Model.Parameter.GetName(parameterData.Parameter); + + parameterData.SetSignatureName(() => variableName); + parameterData.SetCallName(() => $"out {variableName}"); } } diff --git a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs index c02d67e18..0bc64b99b 100644 --- a/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs +++ b/src/Generation/Generator/Renderer/Internal/ParameterToManagedExpression/ParameterToManagedExpression.cs @@ -21,6 +21,8 @@ internal static class ParameterToManagedExpression new ParameterToManagedExpressions.PointerAlias(), new ParameterToManagedExpressions.Long(), //Must be before primitive value type new ParameterToManagedExpressions.UnsignedLong(), //Must be before primitive value type + new ParameterToManagedExpressions.CLong(), //Must be before primitive value type + new ParameterToManagedExpressions.UnsignedCLong(), //Must be before primitive value type new ParameterToManagedExpressions.PrimitiveValueType(), new ParameterToManagedExpressions.PrimitiveValueTypeAlias(), new ParameterToManagedExpressions.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs new file mode 100644 index 000000000..791ce5d64 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/CLong.cs @@ -0,0 +1,18 @@ +namespace Generator.Renderer.Internal.ReturnType; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.ReturnType returnType) + { + return returnType.AnyType.Is(); + } + + public RenderableReturnType Convert(GirModel.ReturnType returnType) + { + var nullableTypeName = returnType.IsPointer + ? Model.Type.Pointer + : "CLong"; + + return new RenderableReturnType(nullableTypeName); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs index b8b12d08b..4152a69e7 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/Long.cs @@ -11,7 +11,7 @@ public RenderableReturnType Convert(GirModel.ReturnType returnType) { var nullableTypeName = returnType.IsPointer ? Model.Type.Pointer - : "CLong"; + : Model.Type.GetName(returnType.AnyType.AsT0); return new RenderableReturnType(nullableTypeName); } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..bd2da332e --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedCLong.cs @@ -0,0 +1,18 @@ +namespace Generator.Renderer.Internal.ReturnType; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(GirModel.ReturnType returnType) + { + return returnType.AnyType.Is(); + } + + public RenderableReturnType Convert(GirModel.ReturnType returnType) + { + var nullableTypeName = returnType.IsPointer + ? Model.Type.Pointer + : "CULong"; + + return new RenderableReturnType(nullableTypeName); + } +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs index 02c52fc3b..6fb7dcb69 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/Converter/UnsignedLong.cs @@ -11,7 +11,7 @@ public RenderableReturnType Convert(GirModel.ReturnType returnType) { var nullableTypeName = returnType.IsPointer ? Model.Type.Pointer - : "CULong"; + : Model.Type.GetName(returnType.AnyType.AsT0); return new RenderableReturnType(nullableTypeName); } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs index 6c800edbe..d24eb70df 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRenderer.cs @@ -21,6 +21,8 @@ internal static class ReturnTypeRenderer new ReturnType.PointerAlias(), new ReturnType.Long(), //Must be before primitive value type new ReturnType.UnsignedLong(), //Must be before primitive value type + new ReturnType.CLong(), //Must be before primitive value type + new ReturnType.UnsignedCLong(), //Must be before primitive value type new ReturnType.PrimitiveValueType(), new ReturnType.PrimitiveValueTypeAlias(), new ReturnType.PrimitiveValueTypeAliasArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs index cdc5998b9..984780610 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnType/ReturnTypeRendererCallback.cs @@ -18,8 +18,10 @@ internal static class ReturnTypeRendererCallback new ReturnType.PlatformStringInCallback(), new ReturnType.PlatformStringArrayInCallback(), new ReturnType.Pointer(), - new ReturnType.Long(), - new ReturnType.UnsignedLong(), + new ReturnType.Long(), //Must be before primitive value type + new ReturnType.UnsignedLong(), //Must be before primitive value type + new ReturnType.CLong(), //Must be before primitive value type + new ReturnType.UnsignedCLong(), //Must be before primitive value type new ReturnType.PrimitiveValueType(), new ReturnType.PrimitiveValueTypeAlias(), new ReturnType.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs new file mode 100644 index 000000000..ec6710d89 --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/CLong.cs @@ -0,0 +1,10 @@ +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public string GetString(GirModel.ReturnType returnType, string fromVariableName) + => $"new CLong(checked((nint){fromVariableName}))"; +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs index a85d2d855..ea0f23575 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/Long.cs @@ -1,10 +1,12 @@ -namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; +using GirModel; + +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; internal class Long : ReturnTypeConverter { - public bool Supports(GirModel.AnyType type) + public bool Supports(AnyType type) => type.Is(); public string GetString(GirModel.ReturnType returnType, string fromVariableName) - => $"new CLong(checked((nint){fromVariableName}))"; + => fromVariableName; } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..abccc342f --- /dev/null +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,10 @@ +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public string GetString(GirModel.ReturnType returnType, string fromVariableName) + => $"new CULong(checked((nuint){fromVariableName}))"; +} diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs index d12586849..99920c3cb 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/Converter/UnsignedLong.cs @@ -1,10 +1,12 @@ -namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; +using GirModel; -internal class UnsigendLong : ReturnTypeConverter +namespace Generator.Renderer.Internal.ReturnTypeToNativeExpressions; + +internal class UnsignedLong : ReturnTypeConverter { - public bool Supports(GirModel.AnyType type) + public bool Supports(AnyType type) => type.Is(); public string GetString(GirModel.ReturnType returnType, string fromVariableName) - => $"new CULong(checked((nuint){fromVariableName}))"; + => fromVariableName; } diff --git a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs index 1ec15ad88..54ba488b1 100644 --- a/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs +++ b/src/Generation/Generator/Renderer/Internal/ReturnTypeToNativeExpression/ReturnTypeToNativeExpression.cs @@ -15,7 +15,9 @@ internal static class ReturnTypeToNativeExpression new ReturnTypeToNativeExpressions.OpaqueUntypedRecord(), new ReturnTypeToNativeExpressions.Pointer(), new ReturnTypeToNativeExpressions.Long(), //Must be before Primitive value type - new ReturnTypeToNativeExpressions.UnsigendLong(), //Must be before primitive value type + new ReturnTypeToNativeExpressions.UnsignedLong(), //Must be before Primitive value type + new ReturnTypeToNativeExpressions.CLong(), //Must be before Primitive value type + new ReturnTypeToNativeExpressions.UnsignedCLong(), //Must be before primitive value type new ReturnTypeToNativeExpressions.PrimitiveValueType(), new ReturnTypeToNativeExpressions.PrimitiveValueTypeAlias(), new ReturnTypeToNativeExpressions.TypedRecord(), diff --git a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs index 0c45552ea..31637c118 100644 --- a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs +++ b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueType.cs @@ -31,6 +31,7 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.Byte => byte.TryParse(constant.Value, out _), GirModel.Double => double.TryParse(constant.Value, out _), GirModel.Integer => int.TryParse(constant.Value, out _), + GirModel.CLong => long.TryParse(constant.Value, out _), GirModel.Long => long.TryParse(constant.Value, out _), GirModel.NativeInteger => nint.TryParse(constant.Value, out _), GirModel.NativeUnsignedInteger => nuint.TryParse(constant.Value, out _), @@ -38,6 +39,7 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.SignedByte => sbyte.TryParse(constant.Value, out _), GirModel.UnsignedInteger => uint.TryParse(constant.Value, out _), GirModel.UnsignedLong => ulong.TryParse(constant.Value, out _), + GirModel.UnsignedCLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedShort => ushort.TryParse(constant.Value, out _), _ => false }; diff --git a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs index cf2637e47..41ae25a11 100644 --- a/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs +++ b/src/Generation/Generator/Renderer/Public/Constant/Converter/PrimitiveValueTypeAlias.cs @@ -34,12 +34,14 @@ private static bool IsValidValue(GirModel.Constant constant) GirModel.Byte => byte.TryParse(constant.Value, out _), GirModel.Double => double.TryParse(constant.Value, out _), GirModel.Integer => int.TryParse(constant.Value, out _), + GirModel.CLong => long.TryParse(constant.Value, out _), GirModel.Long => long.TryParse(constant.Value, out _), GirModel.NativeInteger => nint.TryParse(constant.Value, out _), GirModel.NativeUnsignedInteger => nuint.TryParse(constant.Value, out _), GirModel.Short => short.TryParse(constant.Value, out _), GirModel.SignedByte => sbyte.TryParse(constant.Value, out _), GirModel.UnsignedInteger => uint.TryParse(constant.Value, out _), + GirModel.UnsignedCLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedLong => ulong.TryParse(constant.Value, out _), GirModel.UnsignedShort => ushort.TryParse(constant.Value, out _), _ => false diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs new file mode 100644 index 000000000..1feaa7352 --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/CLong.cs @@ -0,0 +1,36 @@ +namespace Generator.Renderer.Public.Field; + +internal class CLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + NullableTypeName: GetNullableTypeName(field), + SetExpression: SetExpression, + GetExpression: GetExpression + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); + } + + private static string SetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Set{Model.Field.GetName(field)}(new CLong(checked((nint)value)))"; + } + + private static string GetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Get{Model.Field.GetName(field)}().Value"; + } +} diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs index e16c5f4d7..9aba91891 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/Long.cs @@ -26,11 +26,11 @@ private static string GetNullableTypeName(GirModel.Field field) private static string SetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Set{Model.Field.GetName(field)}(new CLong(checked((nint)value)))"; + return $"Handle.Set{Model.Field.GetName(field)}(value)"; } private static string GetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Get{Model.Field.GetName(field)}().Value"; + return $"Handle.Get{Model.Field.GetName(field)}()"; } } diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..55b36ca5a --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedCLong.cs @@ -0,0 +1,36 @@ +namespace Generator.Renderer.Public.Field; + +internal class UnsignedCLong : FieldConverter +{ + public bool Supports(GirModel.Field field) + { + return field.AnyTypeOrCallback.TryPickT0(out var anyType, out _) && anyType.Is(); + } + + public RenderableField Convert(GirModel.Field field) + { + return new RenderableField( + Name: Model.Field.GetName(field), + NullableTypeName: GetNullableTypeName(field), + SetExpression: SetExpression, + GetExpression: GetExpression + ); + } + + private static string GetNullableTypeName(GirModel.Field field) + { + return field.IsPointer + ? Model.Type.Pointer + : Model.Type.GetName(field.AnyTypeOrCallback.AsT0.AsT0); + } + + private static string SetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Set{Model.Field.GetName(field)}(new CULong(checked((nuint)value)))"; + } + + private static string GetExpression(GirModel.Record record, GirModel.Field field) + { + return $"Handle.Get{Model.Field.GetName(field)}().Value"; + } +} diff --git a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs index 44f335bd4..140e99406 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Converter/UnsignedLong.cs @@ -26,11 +26,11 @@ private static string GetNullableTypeName(GirModel.Field field) private static string SetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Set{Model.Field.GetName(field)}(new CULong(checked((nuint)value)))"; + return $"Handle.Set{Model.Field.GetName(field)}(value)"; } private static string GetExpression(GirModel.Record record, GirModel.Field field) { - return $"Handle.Get{Model.Field.GetName(field)}().Value"; + return $"Handle.Get{Model.Field.GetName(field)}()"; } } diff --git a/src/Generation/Generator/Renderer/Public/Field/Fields.cs b/src/Generation/Generator/Renderer/Public/Field/Fields.cs index af897c8fd..d5fbbeb40 100644 --- a/src/Generation/Generator/Renderer/Public/Field/Fields.cs +++ b/src/Generation/Generator/Renderer/Public/Field/Fields.cs @@ -8,7 +8,9 @@ internal static class Fields { new Field.Bitfield(), new Field.Enumeration(), + new Field.CLong(), //Must be before PrimitiveValueType new Field.Long(), //Must be before PrimitiveValueType + new Field.UnsignedCLong(), //Must be before PrimitiveValueType new Field.UnsignedLong(), //Must be before PrimitiveValueType new Field.PrimitiveValueType(), new Field.String(), diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs new file mode 100644 index 000000000..596b476cb --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/CLong.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ParameterToNativeExpressions; + +internal class CLong : ToNativeParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToNativeData parameter, IEnumerable _) + { + //Array length parameters are handled as part of the corresponding array converters + if (parameter.IsArrayLengthParameter) + return; + + switch (parameter.Parameter) + { + case { IsPointer: false, Direction: GirModel.Direction.In }: + Direct(parameter); + break; + default: + throw new NotImplementedException($"{parameter.Parameter.AnyTypeOrVarArgs}: This long value type can not yet be converted to native"); + } + } + + private static void Direct(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"new CLong(checked((nint) {parameterName}))"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs index dce7942a0..8fa1d47b8 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/Long.cs @@ -16,11 +16,20 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable parameterName); - parameter.SetCallName(() => $"new CLong(checked((nint) {parameterName}))"); + parameter.SetCallName(() => parameterName); + } + + private static void Ref(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"ref {parameterName}"); + } + + private static void Out(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => parameter.IsArrayLengthParameter + ? $"out var {parameterName}" + : $"out {parameterName}"); } } diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..a469a4738 --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ParameterToNativeExpressions; + +internal class UnsignedCLong : ToNativeParameterConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ParameterToNativeData parameter, IEnumerable _) + { + //Array length parameters are handled as part of the corresponding array converters + if (parameter.IsArrayLengthParameter) + return; + + switch (parameter.Parameter) + { + case { IsPointer: false, Direction: GirModel.Direction.In }: + Direct(parameter); + break; + default: + throw new NotImplementedException($"{parameter.Parameter.AnyTypeOrVarArgs}: This unsigned long value type can not yet be converted to native"); + } + } + + private static void Direct(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"new CULong(checked((nuint) {parameterName}))"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs index 7b4a47c2c..2f75ebdfd 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/Converter/UnsignedLong.cs @@ -16,11 +16,20 @@ public void Initialize(ParameterToNativeData parameter, IEnumerable parameterName); - parameter.SetCallName(() => $"new CULong(checked((nuint) {parameterName}))"); + parameter.SetCallName(() => parameterName); + } + + private static void Ref(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => $"ref {parameterName}"); + } + + private static void Out(ParameterToNativeData parameter) + { + var parameterName = Model.Parameter.GetName(parameter.Parameter); + parameter.SetSignatureName(() => parameterName); + parameter.SetCallName(() => parameter.IsArrayLengthParameter + ? $"out var {parameterName}" + : $"out {parameterName}"); } } diff --git a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs index 07267737b..0da5d7f67 100644 --- a/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs +++ b/src/Generation/Generator/Renderer/Public/ParameterToNativeExpression/ParameterToNativeExpression.cs @@ -26,7 +26,9 @@ internal static class ParameterToNativeExpression new ParameterToNativeExpressions.Pointer(), new ParameterToNativeExpressions.PointerAlias(), new ParameterToNativeExpressions.Long(), //Must be before primitive value type + new ParameterToNativeExpressions.CLong(), //Must be before primitive value type new ParameterToNativeExpressions.UnsignedLong(), //Must be before primitive value type + new ParameterToNativeExpressions.UnsignedCLong(), //Must be before primitive value type new ParameterToNativeExpressions.PrimitiveValueType(), new ParameterToNativeExpressions.PrimitiveValueTypeAlias(), new ParameterToNativeExpressions.PrimitiveValueTypeArray(), diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs new file mode 100644 index 000000000..f869123ae --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/CLong.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; + +namespace Generator.Renderer.Public.ReturnTypeToManagedExpressions; + +internal class CLong : ReturnTypeConverter +{ + public bool Supports(GirModel.AnyType type) + => type.Is(); + + public void Initialize(ReturnTypeToManagedData data, IEnumerable _) + { + data.SetExpression(fromVariableName => data.ReturnType.IsPointer + ? fromVariableName + : $"{fromVariableName}.Value" + ); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs index ae2ce9c68..79a977aa8 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/Long.cs @@ -9,10 +9,5 @@ public bool Supports(AnyType type) => type.Is(); public void Initialize(ReturnTypeToManagedData data, IEnumerable _) - { - data.SetExpression(fromVariableName => data.ReturnType.IsPointer - ? fromVariableName - : $"{fromVariableName}.Value" - ); - } + => data.SetExpression(fromVariableName => fromVariableName); //Valid for IsPointer = true && IsPointer = false } diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs new file mode 100644 index 000000000..6abd6ab0f --- /dev/null +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedCLong.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; +using GirModel; + +namespace Generator.Renderer.Public.ReturnTypeToManagedExpressions; + +internal class UnsignedCLong : ReturnTypeConverter +{ + public bool Supports(AnyType type) + => type.Is(); + + public void Initialize(ReturnTypeToManagedData data, IEnumerable _) + { + data.SetExpression(fromVariableName => data.ReturnType.IsPointer + ? fromVariableName + : $"{fromVariableName}.Value"); + } +} diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs index dd2f6bc37..c2dce1dd0 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/Converter/UnsignedLong.cs @@ -9,9 +9,5 @@ public bool Supports(AnyType type) => type.Is(); public void Initialize(ReturnTypeToManagedData data, IEnumerable _) - { - data.SetExpression(fromVariableName => data.ReturnType.IsPointer - ? fromVariableName - : $"{fromVariableName}.Value"); - } + => data.SetExpression(fromVariableName => fromVariableName); //Valid for IsPointer = true && IsPointer = false } diff --git a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs index b4ab950db..00130c73e 100644 --- a/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs +++ b/src/Generation/Generator/Renderer/Public/ReturnTypeToManagedExpression/ReturnTypeToManagedExpression.cs @@ -19,6 +19,8 @@ internal static class ReturnTypeToManagedExpression new ReturnTypeToManagedExpressions.PointerAlias(), new ReturnTypeToManagedExpressions.Long(), //Must be before primitive value type new ReturnTypeToManagedExpressions.UnsignedLong(), //Must be before primitive value type + new ReturnTypeToManagedExpressions.CLong(), //Must be before primitive value type + new ReturnTypeToManagedExpressions.UnsignedCLong(), //Must be before primitive value type new ReturnTypeToManagedExpressions.PrimitiveValueType(), new ReturnTypeToManagedExpressions.PrimitiveValueTypeAlias(), new ReturnTypeToManagedExpressions.PrimitiveValueTypeAliasArray(), diff --git a/src/Generation/GirLoader/Output/CLong.cs b/src/Generation/GirLoader/Output/CLong.cs new file mode 100644 index 000000000..fcfaf3811 --- /dev/null +++ b/src/Generation/GirLoader/Output/CLong.cs @@ -0,0 +1,6 @@ +namespace GirLoader.Output; + +public class CLong : PrimitiveValueType, GirModel.CLong +{ + public CLong(string ctype) : base(ctype) { } +} diff --git a/src/Generation/GirLoader/Output/UnsignedCLong.cs b/src/Generation/GirLoader/Output/UnsignedCLong.cs new file mode 100644 index 000000000..c33d293ed --- /dev/null +++ b/src/Generation/GirLoader/Output/UnsignedCLong.cs @@ -0,0 +1,6 @@ +namespace GirLoader.Output; + +public class UnsignedCLong : PrimitiveValueType, GirModel.UnsignedCLong +{ + public UnsignedCLong(string ctype) : base(ctype) { } +} diff --git a/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs b/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs index 607136341..b66239ff3 100644 --- a/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs +++ b/src/Generation/GirLoader/TypeReferenceResolver/TypeReferenceResolver.GlobalTypeCache.cs @@ -57,7 +57,7 @@ public GlobalTypeCache() Add(new Output.UnpointedSignedByte("char")); Add(new Output.SignedByte("gint8")); - Add(new Output.Long("glong")); + Add(new Output.CLong("glong")); Add(new Output.NativeInteger("gssize")); Add(new Output.Long("gint64")); Add(new Output.Long("goffset")); @@ -65,7 +65,7 @@ public GlobalTypeCache() Add(new Output.NativeUnsignedInteger("gsize")); Add(new Output.UnsignedLong("guint64")); - Add(new Output.UnsignedLong("gulong")); + Add(new Output.UnsignedCLong("gulong")); Add(new Output.Utf8String()); Add(new Output.PlatformString()); diff --git a/src/Generation/GirModel/CLong.cs b/src/Generation/GirModel/CLong.cs new file mode 100644 index 000000000..b03140dfa --- /dev/null +++ b/src/Generation/GirModel/CLong.cs @@ -0,0 +1,3 @@ +namespace GirModel; + +public interface CLong : PrimitiveValueType { } diff --git a/src/Generation/GirModel/UnsignedCLong.cs b/src/Generation/GirModel/UnsignedCLong.cs new file mode 100644 index 000000000..36da3f88e --- /dev/null +++ b/src/Generation/GirModel/UnsignedCLong.cs @@ -0,0 +1,3 @@ +namespace GirModel; + +public interface UnsignedCLong : PrimitiveValueType { } diff --git a/src/Generation/GirModel/UnsignedLong.cs b/src/Generation/GirModel/UnsignedLong.cs index db06436e3..5d161dff6 100644 --- a/src/Generation/GirModel/UnsignedLong.cs +++ b/src/Generation/GirModel/UnsignedLong.cs @@ -1,6 +1,3 @@ namespace GirModel; -public interface UnsignedLong : PrimitiveValueType -{ - -} +public interface UnsignedLong : PrimitiveValueType { } diff --git a/src/Native/GirTestLib/girtest-long-tester.c b/src/Native/GirTestLib/girtest-clong-tester.c similarity index 52% rename from src/Native/GirTestLib/girtest-long-tester.c rename to src/Native/GirTestLib/girtest-clong-tester.c index 1ebe81313..e42304ed4 100644 --- a/src/Native/GirTestLib/girtest-long-tester.c +++ b/src/Native/GirTestLib/girtest-clong-tester.c @@ -1,22 +1,22 @@ -#include "girtest-long-tester.h" +#include "girtest-clong-tester.h" /** - * GirTestLongTester: + * GirTestCLongTester: * - * Test records with long fields + * Test records with CLong fields */ -gsize girtest_long_tester_get_sizeof_l(GirTestLongTester* record) +gsize girtest_clong_tester_get_sizeof_l(GirTestCLongTester* record) { return sizeof(record->l); } -glong girtest_long_tester_get_max_long_value() +glong girtest_clong_tester_get_max_long_value() { return LONG_MAX; } -gboolean girtest_long_tester_is_max_long_value(glong value) +gboolean girtest_clong_tester_is_max_long_value(glong value) { if(value == LONG_MAX) return TRUE; @@ -24,12 +24,12 @@ gboolean girtest_long_tester_is_max_long_value(glong value) return FALSE; } -glong girtest_long_tester_get_min_long_value() +glong girtest_clong_tester_get_min_long_value() { return LONG_MIN; } -gboolean girtest_long_tester_is_min_long_value(glong value) +gboolean girtest_clong_tester_is_min_long_value(glong value) { if(value == LONG_MIN) return TRUE; @@ -38,7 +38,7 @@ gboolean girtest_long_tester_is_min_long_value(glong value) } /** - * girtest_long_tester_run_callback: + * girtest_clong_tester_run_callback: * @value: The long value which should be passed to the callback * @callback: (scope call): a function that is called receives a long and should return a long * @@ -46,7 +46,7 @@ gboolean girtest_long_tester_is_min_long_value(glong value) * * Returns: The result of the callback. **/ -glong girtest_long_tester_run_callback(glong value, GirTestLongCallback callback) +glong girtest_clong_tester_run_callback(glong value, GirTestCLongCallback callback) { return callback(value); } \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-clong-tester.h b/src/Native/GirTestLib/girtest-clong-tester.h new file mode 100644 index 000000000..0fc0c7cda --- /dev/null +++ b/src/Native/GirTestLib/girtest-clong-tester.h @@ -0,0 +1,22 @@ +#pragma once + +#include + +G_BEGIN_DECLS + +typedef glong (*GirTestCLongCallback) (glong val); + +typedef struct _GirTestCLongTester GirTestCLongTester; + +struct _GirTestCLongTester +{ + long l; +}; + +gsize girtest_clong_tester_get_sizeof_l(GirTestCLongTester* record); +glong girtest_clong_tester_get_max_long_value(); +glong girtest_clong_tester_get_min_long_value(); +gboolean girtest_clong_tester_is_max_long_value(glong value); +gboolean girtest_clong_tester_is_min_long_value(glong value); +glong girtest_clong_tester_run_callback(glong value, GirTestCLongCallback callback); +G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-ulong-tester.c b/src/Native/GirTestLib/girtest-culong-tester.c similarity index 56% rename from src/Native/GirTestLib/girtest-ulong-tester.c rename to src/Native/GirTestLib/girtest-culong-tester.c index ffb7c1096..f4ddc6256 100644 --- a/src/Native/GirTestLib/girtest-ulong-tester.c +++ b/src/Native/GirTestLib/girtest-culong-tester.c @@ -1,22 +1,22 @@ -#include "girtest-ulong-tester.h" +#include "girtest-culong-tester.h" /** - * GirTestULongTester: + * GirTestCULongTester: * * Test records with unsigned long fields */ -gsize girtest_ulong_tester_get_sizeof_ul(GirTestULongTester* record) +gsize girtest_culong_tester_get_sizeof_ul(GirTestCULongTester* record) { return sizeof(record->ul); } -gulong girtest_ulong_tester_get_max_unsigned_long_value() +gulong girtest_culong_tester_get_max_unsigned_long_value() { return ULONG_MAX; } -gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value) +gboolean girtest_culong_tester_is_max_unsigned_long_value(gulong value) { if(value == ULONG_MAX) return TRUE; @@ -25,7 +25,7 @@ gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value) } /** - * girtest_ulong_tester_run_callback: + * girtest_culong_tester_run_callback: * @value: The long value which should be passed to the callback * @callback: (scope call): a function that is called receives a ulong and should return a ulong * @@ -33,7 +33,7 @@ gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value) * * Returns: The result of the callback. **/ -gulong girtest_ulong_tester_run_callback(gulong value, GirTestULongCallback callback) +gulong girtest_culong_tester_run_callback(gulong value, GirTestCULongCallback callback) { return callback(value); } \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-culong-tester.h b/src/Native/GirTestLib/girtest-culong-tester.h new file mode 100644 index 000000000..6f2343445 --- /dev/null +++ b/src/Native/GirTestLib/girtest-culong-tester.h @@ -0,0 +1,20 @@ +#pragma once + +#include + +G_BEGIN_DECLS + +typedef gulong (*GirTestCULongCallback) (gulong val); + +typedef struct _GirTestCULongTester GirTestCULongTester; + +struct _GirTestCULongTester +{ + unsigned long ul; +}; + +gsize girtest_culong_tester_get_sizeof_ul(GirTestCULongTester* record); +gulong girtest_culong_tester_get_max_unsigned_long_value(); +gboolean girtest_culong_tester_is_max_unsigned_long_value(gulong value); +gulong girtest_culong_tester_run_callback(gulong value, GirTestCULongCallback callback); +G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-integer-array-tester.c b/src/Native/GirTestLib/girtest-integer-array-tester.c index 3b071ab86..e2601ed65 100644 --- a/src/Native/GirTestLib/girtest-integer-array-tester.c +++ b/src/Native/GirTestLib/girtest-integer-array-tester.c @@ -124,6 +124,21 @@ girtest_integer_array_tester_get_data_from_const_pointer(gconstpointer data, gsi return *(p + (size -1)); } +/** + * girtest_integer_array_tester_get_data_with_gint64_size: + * @data: (transfer none) (array length=size) (element-type gint) (nullable): + * the data to be used + * @size: the size of @data + * + * Returns: The last integer of the given data. + */ +gint +girtest_integer_array_tester_get_data_with_gint64_size(gconstpointer data, gint64 size) +{ + gint* p = (gint*) data; + return *(p + (size -1)); +} + /** * girtest_integer_array_tester_clear_data: * @data: (array length=count) (element-type gint) (inout): diff --git a/src/Native/GirTestLib/girtest-integer-array-tester.h b/src/Native/GirTestLib/girtest-integer-array-tester.h index 10e7dddc4..f8bfd600e 100644 --- a/src/Native/GirTestLib/girtest-integer-array-tester.h +++ b/src/Native/GirTestLib/girtest-integer-array-tester.h @@ -34,6 +34,7 @@ gsize girtest_integer_array_tester_get_data_count(); void girtest_integer_array_tester_invoke_callback(GirTestIntegerArrayTesterCallback callback); void girtest_integer_array_tester_invoke_callback_no_length(GirTestIntegerArrayTesterCallbackNoLength callback); gint girtest_integer_array_tester_get_data_from_const_pointer(gconstpointer data, gsize size); +gint girtest_integer_array_tester_get_data_with_gint64_size(gconstpointer data, gint64 size); void girtest_integer_array_tester_clear_data(void *data, gsize count); G_END_DECLS diff --git a/src/Native/GirTestLib/girtest-long-tester.h b/src/Native/GirTestLib/girtest-long-tester.h deleted file mode 100644 index abb5056da..000000000 --- a/src/Native/GirTestLib/girtest-long-tester.h +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include - -G_BEGIN_DECLS - -typedef glong (*GirTestLongCallback) (glong val); - -typedef struct _GirTestLongTester GirTestLongTester; - -struct _GirTestLongTester -{ - long l; -}; - -gsize girtest_long_tester_get_sizeof_l(GirTestLongTester* record); -glong girtest_long_tester_get_max_long_value(); -glong girtest_long_tester_get_min_long_value(); -gboolean girtest_long_tester_is_max_long_value(glong value); -gboolean girtest_long_tester_is_min_long_value(glong value); -glong girtest_long_tester_run_callback(glong value, GirTestLongCallback callback); -G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest-ulong-tester.h b/src/Native/GirTestLib/girtest-ulong-tester.h deleted file mode 100644 index 143aca1fa..000000000 --- a/src/Native/GirTestLib/girtest-ulong-tester.h +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include - -G_BEGIN_DECLS - -typedef gulong (*GirTestULongCallback) (gulong val); - -typedef struct _GirTestULongTester GirTestULongTester; - -struct _GirTestULongTester -{ - unsigned long ul; -}; - -gsize girtest_ulong_tester_get_sizeof_ul(GirTestULongTester* record); -gulong girtest_ulong_tester_get_max_unsigned_long_value(); -gboolean girtest_ulong_tester_is_max_unsigned_long_value(gulong value); -gulong girtest_ulong_tester_run_callback(gulong value, GirTestULongCallback callback); -G_END_DECLS \ No newline at end of file diff --git a/src/Native/GirTestLib/girtest.h b/src/Native/GirTestLib/girtest.h index b3c5314b1..c09e2a47f 100644 --- a/src/Native/GirTestLib/girtest.h +++ b/src/Native/GirTestLib/girtest.h @@ -6,11 +6,12 @@ #include "girtest-byte-array-tester.h" #include "girtest-callback-tester.h" #include "girtest-class-tester.h" +#include "girtest-clong-tester.h" #include "girtest-constant-tester.h" +#include "girtest-culong-tester.h" #include "girtest-enum-tester.h" #include "girtest-error-tester.h" #include "girtest-integer-array-tester.h" -#include "girtest-long-tester.h" #include "girtest-opaque-typed-record-copy-annotation-tester.h" #include "girtest-opaque-typed-record-tester.h" #include "girtest-opaque-untyped-record-tester.h" @@ -24,7 +25,6 @@ #include "girtest-string-tester.h" #include "girtest-typed-record-copy-annotation-tester.h" #include "girtest-typed-record-tester.h" -#include "girtest-ulong-tester.h" #include "girtest-untyped-record-tester.h" #include "girtest-utf8-string-array-null-terminated-tester.h" #include "data/girtest-executor.h" diff --git a/src/Native/GirTestLib/meson.build b/src/Native/GirTestLib/meson.build index 52ab40e01..8d6b8aada 100644 --- a/src/Native/GirTestLib/meson.build +++ b/src/Native/GirTestLib/meson.build @@ -9,11 +9,12 @@ header_files = [ 'girtest-byte-array-tester.h', 'girtest-callback-tester.h', 'girtest-class-tester.h', + 'girtest-clong-tester.h', 'girtest-constant-tester.h', + 'girtest-culong-tester.h', 'girtest-enum-tester.h', 'girtest-error-tester.h', 'girtest-integer-array-tester.h', - 'girtest-long-tester.h', 'girtest-method-hiding.h', 'girtest-opaque-typed-record-copy-annotation-tester.h', 'girtest-opaque-typed-record-tester.h', @@ -28,7 +29,6 @@ header_files = [ 'girtest-string-tester.h', 'girtest-typed-record-copy-annotation-tester.h', 'girtest-typed-record-tester.h', - 'girtest-ulong-tester.h', 'girtest-untyped-record-tester.h', 'girtest-utf8-string-array-null-terminated-tester.h', 'data/girtest-executor.h', @@ -41,10 +41,11 @@ source_files = [ 'girtest-byte-array-tester.c', 'girtest-callback-tester.c', 'girtest-class-tester.c', + 'girtest-clong-tester.c', + 'girtest-culong-tester.c', 'girtest-enum-tester.c', 'girtest-error-tester.c', 'girtest-integer-array-tester.c', - 'girtest-long-tester.c', 'girtest-method-hiding.c', 'girtest-opaque-typed-record-copy-annotation-tester.c', 'girtest-opaque-typed-record-tester.c', @@ -59,7 +60,6 @@ source_files = [ 'girtest-string-tester.c', 'girtest-typed-record-copy-annotation-tester.c', 'girtest-typed-record-tester.c', - 'girtest-ulong-tester.c', 'girtest-untyped-record-tester.c', 'girtest-utf8-string-array-null-terminated-tester.c', 'data/girtest-executor.c', diff --git a/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs b/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs index 02e44e1f8..5c0a36cca 100644 --- a/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs +++ b/src/Tests/Generation/GirLoader.Tests/ClassPropertyTest.cs @@ -88,14 +88,14 @@ public void PropertyNameShouldBeLoaded() [DataRow("gchar", false, typeof(Output.SignedByte))] [DataRow("char", false, typeof(Output.SignedByte))] [DataRow("gint8", false, typeof(Output.SignedByte))] - [DataRow("glong", false, typeof(Output.Long))] + [DataRow("glong", false, typeof(Output.CLong))] [DataRow("gssize", false, typeof(Output.NativeInteger))] [DataRow("gint64", false, typeof(Output.Long))] [DataRow("goffset", false, typeof(Output.Long))] [DataRow("time_t", false, typeof(Output.Long))] [DataRow("gsize", false, typeof(Output.NativeUnsignedInteger))] [DataRow("guint64", false, typeof(Output.UnsignedLong))] - [DataRow("gulong", false, typeof(Output.UnsignedLong))] + [DataRow("gulong", false, typeof(Output.UnsignedCLong))] [DataRow("gboolean*", true, typeof(Output.Boolean))] [DataRow("gfloat*", true, typeof(Output.Float))] [DataRow("float*", true, typeof(Output.Float))] @@ -124,14 +124,14 @@ public void PropertyNameShouldBeLoaded() //[DataRow("gchar*", true, typeof(Output.Model.String))] -> Ambigous between UTF8 and platform strings //[DataRow("char*", true, typeof(Output.Model.String))] -> Ambigous between UTF8 and platform strings [DataRow("gint8*", true, typeof(Output.SignedByte))] - [DataRow("glong*", true, typeof(Output.Long))] + [DataRow("glong*", true, typeof(Output.CLong))] [DataRow("gssize*", true, typeof(Output.NativeInteger))] [DataRow("gint64*", true, typeof(Output.Long))] [DataRow("goffset*", true, typeof(Output.Long))] [DataRow("time_t*", true, typeof(Output.Long))] [DataRow("gsize*", true, typeof(Output.NativeUnsignedInteger))] [DataRow("guint64*", true, typeof(Output.UnsignedLong))] - [DataRow("gulong*", true, typeof(Output.UnsignedLong))] + [DataRow("gulong*", true, typeof(Output.UnsignedCLong))] public void PropertyTypeShouldMatchCType(string ctype, bool isPointer, System.Type resultType) { var property = GetLoadedProperty(ctype, null); diff --git a/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs similarity index 83% rename from src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs rename to src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs index 61de83cd7..88f4aaf94 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/LongTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/CLongTest.cs @@ -6,12 +6,12 @@ namespace GirTest.Tests; [TestClass, TestCategory("BindingTest")] -public class LongTest : Test +public class CLongTest : Test { [TestMethod] public void ShouldUseCLongInInternalStructData() { - var data = new GirTest.Internal.LongTesterData(); + var data = new GirTest.Internal.CLongTesterData(); data.L.Should().BeOfType(); } @@ -19,7 +19,7 @@ public void ShouldUseCLongInInternalStructData() public unsafe void GetSizeOfLShouldBeSizeOfCLong() { var sizeOfCLong = sizeof(CLong); - var obj = new LongTester(); + var obj = new CLongTester(); obj.GetSizeofL().Should().Be((nuint) sizeOfCLong); } @@ -31,7 +31,7 @@ public void ShouldHandleMaxMinLongValue(long value) if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - var obj = new LongTester { L = value }; + var obj = new CLongTester { L = value }; obj.L.Should().Be(value); } @@ -43,7 +43,7 @@ public void ShouldHandleMaxMinIntValue(int value) if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var obj = new LongTester { L = value }; + var obj = new CLongTester { L = value }; obj.L.Should().Be(value); } @@ -55,7 +55,7 @@ public void ShouldThrowIfValueExceedsIntegerSize(long value) if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var obj = new LongTester(); + var obj = new CLongTester(); var act = () => obj.L = value; act.Should().Throw(); } @@ -66,7 +66,7 @@ public void ReturnsMaxLongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.GetMaxLongValue().Should().Be(long.MaxValue); + CLongTester.GetMaxLongValue().Should().Be(long.MaxValue); } [TestMethod] @@ -75,7 +75,7 @@ public void ReturnsMaxLongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - LongTester.GetMaxLongValue().Should().Be(int.MaxValue); + CLongTester.GetMaxLongValue().Should().Be(int.MaxValue); } [TestMethod] @@ -84,7 +84,7 @@ public void ReturnsMinLongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.GetMinLongValue().Should().Be(long.MinValue); + CLongTester.GetMinLongValue().Should().Be(long.MinValue); } [TestMethod] @@ -93,7 +93,7 @@ public void ReturnsMinLongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - LongTester.GetMinLongValue().Should().Be(int.MinValue); + CLongTester.GetMinLongValue().Should().Be(int.MinValue); } [TestMethod] @@ -102,7 +102,7 @@ public void SetsMaxLongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); + CLongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); } [TestMethod] @@ -111,7 +111,7 @@ public void SetsMaxLongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - LongTester.IsMaxLongValue(int.MaxValue).Should().BeTrue(); + CLongTester.IsMaxLongValue(int.MaxValue).Should().BeTrue(); } [TestMethod] @@ -120,7 +120,7 @@ public void SetsMinLongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - LongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); + CLongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); } [TestMethod] @@ -129,7 +129,7 @@ public void SetsMinLongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - LongTester.IsMinLongValue(int.MinValue).Should().BeTrue(); + CLongTester.IsMinLongValue(int.MinValue).Should().BeTrue(); } [TestMethod] @@ -138,7 +138,7 @@ public void ThrowsOverflowExceptionIfLongMinValueIsPassedOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var action = () => LongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); + var action = () => CLongTester.IsMinLongValue(long.MinValue).Should().BeTrue(); action.Should().Throw(); } @@ -148,7 +148,7 @@ public void ThrowsOverflowExceptionIfLongMaxValueIsPassedOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var action = () => LongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); + var action = () => CLongTester.IsMaxLongValue(long.MaxValue).Should().BeTrue(); action.Should().Throw(); } @@ -165,7 +165,7 @@ long Callback(long val) return val; } - LongTester.RunCallback(value, Callback).Should().Be(value); + CLongTester.RunCallback(value, Callback).Should().Be(value); } [DataTestMethod] @@ -181,6 +181,6 @@ long Callback(long val) return val; } - LongTester.RunCallback(value, Callback).Should().Be(value); + CLongTester.RunCallback(value, Callback).Should().Be(value); } } diff --git a/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs similarity index 83% rename from src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs rename to src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs index 1717a3b0d..68d7f1988 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/ULongTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/CULongTest.cs @@ -6,12 +6,12 @@ namespace GirTest.Tests; [TestClass, TestCategory("BindingTest")] -public class ULongTest : Test +public class CULongTest : Test { [TestMethod] public void ShouldUseCULongInInternalStructData() { - var data = new GirTest.Internal.ULongTesterData(); + var data = new GirTest.Internal.CULongTesterData(); data.Ul.Should().BeOfType(); } @@ -19,7 +19,7 @@ public void ShouldUseCULongInInternalStructData() public unsafe void GetSizeOfLShouldBeSizeOfCULong() { var sizeOfCULong = sizeof(CULong); - var obj = new ULongTester(); + var obj = new CULongTester(); obj.GetSizeofUl().Should().Be((nuint) sizeOfCULong); } @@ -31,7 +31,7 @@ public void ShouldHandleMaxULongValue(ulong value) if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - var obj = new ULongTester { Ul = value }; + var obj = new CULongTester { Ul = value }; obj.Ul.Should().Be(value); } @@ -43,7 +43,7 @@ public void ShouldHandleMaxMinUIntValue(uint value) if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var obj = new ULongTester { Ul = value }; + var obj = new CULongTester { Ul = value }; obj.Ul.Should().Be(value); } @@ -53,7 +53,7 @@ public void ShouldThrowIfValueExceedsUIntegerSize() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var obj = new ULongTester(); + var obj = new CULongTester(); var act = () => obj.Ul = ulong.MaxValue; act.Should().Throw(); } @@ -64,7 +64,7 @@ public void ReturnsMaxULongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - ULongTester.GetMaxUnsignedLongValue().Should().Be(ulong.MaxValue); + CULongTester.GetMaxUnsignedLongValue().Should().Be(ulong.MaxValue); } [TestMethod] @@ -73,7 +73,7 @@ public void ReturnsMaxULongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - ULongTester.GetMaxUnsignedLongValue().Should().Be(uint.MaxValue); + CULongTester.GetMaxUnsignedLongValue().Should().Be(uint.MaxValue); } [TestMethod] @@ -82,7 +82,7 @@ public void SetsMaxULongValueOn64BitUnix() if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on 64 Bit Unix operating Systems"); - ULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); + CULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); } [TestMethod] @@ -91,7 +91,7 @@ public void SetsMaxULongValueOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - ULongTester.IsMaxUnsignedLongValue(uint.MaxValue).Should().BeTrue(); + CULongTester.IsMaxUnsignedLongValue(uint.MaxValue).Should().BeTrue(); } [TestMethod] @@ -100,7 +100,7 @@ public void ThrowsOverflowExceptionIfULongMaxValueIsPassedOnWindows() if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.Is64BitOperatingSystem) Assert.Inconclusive("Only supported on windows or 32 bit unix operating Systems"); - var action = () => ULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); + var action = () => CULongTester.IsMaxUnsignedLongValue(ulong.MaxValue).Should().BeTrue(); action.Should().Throw(); } @@ -117,7 +117,7 @@ ulong Callback(ulong val) return val; } - ULongTester.RunCallback(value, Callback).Should().Be(value); + CULongTester.RunCallback(value, Callback).Should().Be(value); } [DataTestMethod] @@ -133,6 +133,6 @@ ulong Callback(ulong val) return val; } - ULongTester.RunCallback(value, Callback).Should().Be(value); + CULongTester.RunCallback(value, Callback).Should().Be(value); } } diff --git a/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs b/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs index f6ca7d59e..1fdb49872 100644 --- a/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs +++ b/src/Tests/Libs/GirTest-0.1.Tests/IntegerArrayTest.cs @@ -100,6 +100,13 @@ public void IntegerArrayFromConstPointer() IntegerArrayTester.GetDataFromConstPointer(data).Should().Be(6); } + [TestMethod] + public void IntegerArrayWithGint64Size() + { + var data = new int[] { 5, 6 }; + IntegerArrayTester.GetDataWithGint64Size(data).Should().Be(6); + } + [TestMethod] public void SupportsInOutIntegerArray() {