Native Interop

using System.Runtime.InteropServices;

internal static partial class NativeMethodsClassic
{
    // int puts(const char *s);
    [DllImport("libc", EntryPoint = "puts", CharSet = CharSet.Ansi, SetLastError = true)]
    internal static extern int Puts(string message);

    // double pow(double x, double y);
    [DllImport("libm", EntryPoint = "pow")]
    internal static extern double Pow(double x, double y);
}

using System.Runtime.InteropServices;

internal static partial class NativeMethods
{
    // The method is `partial`; the generator supplies the body.
    [LibraryImport("libc", EntryPoint = "puts", StringMarshalling = StringMarshalling.Utf8)]
    internal static partial int Puts(string message);

    [LibraryImport("libm", EntryPoint = "pow")]
    internal static partial double Pow(double x, double y);

    // SetLastError works the same way, and is captured by generated code.
    [LibraryImport("libc", EntryPoint = "read", SetLastError = true)]
    internal static partial nint Read(int fd, Span<byte> buffer, nuint count);
}

using System.Runtime.InteropServices;

internal static partial class SizeAware
{
    // size_t strlen(const char *s);
    [LibraryImport("libc", EntryPoint = "strlen", StringMarshalling = StringMarshalling.Utf8)]
    internal static partial nuint StringLength(string value);
}

using System.Runtime.InteropServices;

internal static partial class StringInterop
{
    // Passing a string IN: the marshaller allocates a native copy, and frees it after the call.
    [LibraryImport("libc", EntryPoint = "puts", StringMarshalling = StringMarshalling.Utf8)]
    internal static partial int Puts(string message);

    // Receiving a pointer OUT: return nint and convert by hand, because ownership
    // (who calls free) is a decision the marshaller cannot make for you.
    [LibraryImport("libc", EntryPoint = "getenv", StringMarshalling = StringMarshalling.Utf8)]
    internal static partial nint GetEnvironmentRaw(string name);

    internal static string? GetEnvironment(string name)
    {
        nint pointer = GetEnvironmentRaw(name);

        // The C library owns this memory: copy it, and do NOT free it.
        return pointer == 0 ? null : Marshal.PtrToStringUTF8(pointer);
    }
}

using System.Runtime.InteropServices;

internal static partial class BufferOut
{
    // char *getcwd(char *buf, size_t size);
    [LibraryImport("libc", EntryPoint = "getcwd")]
    private static partial nint GetCurrentDirectoryRaw(Span<byte> buffer, nuint size);

    internal static string? GetCurrentDirectory()
    {
        Span<byte> buffer = stackalloc byte[1024];

        return GetCurrentDirectoryRaw(buffer, (nuint)buffer.Length) == 0
            ? null
            : System.Text.Encoding.UTF8.GetString(buffer[..buffer.IndexOf((byte)0)]);
    }
}

using System.Runtime.InteropServices;

// struct timespec { time_t tv_sec; long tv_nsec; };
[StructLayout(LayoutKind.Sequential)]
internal struct TimeSpec
{
    internal nint Seconds;
    internal nint Nanoseconds;
}

// A struct with a fixed char array and an embedded struct.
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
internal struct DeviceInfo
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
    internal string Name;                       // char name[64], inline

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    internal int[] Capabilities;                // int capabilities[4], inline

    internal TimeSpec LastSeen;
}

internal static partial class StructInterop
{
    // int clock_gettime(clockid_t clk_id, struct timespec *tp);
    [LibraryImport("libc", EntryPoint = "clock_gettime")]
    internal static partial int ClockGetTime(int clockId, out TimeSpec time);
}

using System.Runtime.InteropServices;

internal static partial class ArrayInterop
{
    // void qsort(void *base, size_t nmemb, size_t size,
    //            int (*compar)(const void *, const void *));
    [LibraryImport("libc", EntryPoint = "qsort")]
    internal static unsafe partial void QSort(
        Span<int> data, nuint count, nuint elementSize, delegate* unmanaged[Cdecl]<void*, void*, int> comparer);
}

using System.Runtime.InteropServices;

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate int CompareCallback(nint left, nint right);

internal sealed class SortSession
{
    // The field keeps the delegate alive for as long as native code can call it.
    private readonly CompareCallback _comparer;

    internal SortSession() => _comparer = Compare;

    internal nint FunctionPointer => Marshal.GetFunctionPointerForDelegate(_comparer);

    private static int Compare(nint left, nint right) => left.CompareTo(right);

    internal void KeepAlive() => GC.KeepAlive(_comparer);
}

using System.Runtime.InteropServices;

internal static unsafe class ModernCallback
{
    [UnmanagedCallersOnly(CallConvs = new[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
    private static int Compare(void* left, void* right)
    {
        // Must not throw: an exception escaping into native code terminates the process.
        int a = *(int*)left;
        int b = *(int*)right;
        return a.CompareTo(b);
    }

    internal static delegate* unmanaged[Cdecl]<void*, void*, int> Pointer => &Compare;
}

using System.Runtime.InteropServices;

internal sealed partial class FileDescriptor : SafeHandle
{
    private FileDescriptor() : base(invalidHandleValue: -1, ownsHandle: true)
    {
    }

    public override bool IsInvalid => handle == -1;

    protected override bool ReleaseHandle() => Close((int)handle) == 0;

    [LibraryImport("libc", EntryPoint = "close")]
    private static partial int Close(int fd);
}

internal static partial class SafeHandleInterop
{
    // The marshaller increments the handle's ref count for the duration of the call,
    // so it cannot be released underneath the native code.
    [LibraryImport("libc", EntryPoint = "read", SetLastError = true)]
    internal static partial nint Read(FileDescriptor handle, Span<byte> buffer, nuint count);
}