How do I pass Varargs for object[] args but i worry about Linux and macOS because __arglist doesn't work everyone.

[DeafMan1983]

Hello I am looking for function: nint CreateVarArgs(object[] args) for print, printf or other...

[DllImport("msvcrt", EntryPoint = "print")]
private static extern void pinvoke_print(string fmt, nint args);
...
private static nint CreateVarArgs(object[] args)
{
    // for argument of implementation like pass to string, integer or pointer
}

public static void print(string fmt, params object[] args)
{
    pinvoke_print(fmt, CreateVarArgs(args));
}

Ps ChatGPT went wrong because it tells more arguments. But I don't want to waste my time.

Can I get simple create variable arguments? I have tried to resolve.

PS I use with sbyte* but it happens because it crashes. I have tried to resolve but no success.

[huoyaoyuan]

You can't interop with va_args on other platforms. They are only supported on Windows x86/x64.

nint CreateVarArgs(object[] args)

va_args is not passed by one pointer. Such function will never work.

You can simulate va_args with separated parameters for simple cases, but it can't handle cases like floating point parameters need to be passed in both integer and FP register. I can't find the previous discussion about this.

If you still do want to do this, the only way is to see what assembly is generated by C code, and try to simulate it with cdecl based on knowledge of calling convention.

[DeafMan1983]

I think that string.Format helps?

But I have tried to resolve if sbyte*, void* or etc example:
printf("Hello, %s.".ForSBytePointer(), "C#")
Result:Hello, C#.

If it happens with %p ( It is a pointer. )
Like an example:
I have create simple sbyte* CreateVarArgs(sbyte* fmt, params object[] args)

    private sbyte* CreateVarArgs(sbyte* fmt, object[] args)
    {
        if (fmt == null)
        {
            return null;
        }

        // Convert to string
        string fmtStr = ((SBytePointer)fmt).ForString();

        // totalSIze of args's length
        int totalSize = 0;
        foreach (var arg in args)
        {
            if (arg is nuint)
            {
                totalSize += sizeof(nuint);
                string.Format(fmtStr, (int)arg);
            }

            else if (arg is SBytePointer)
            {
                totalSize += sizeof(sbyte*);
                string.Format(fmtStr, ((SBytePointer)arg).ForString());
            }
        }

        return fmtStr.ForSBytePointer();
    }

SBytePointer is a structure with implitict sbyte*
And I cheat with Extensions for sbyte*

namespace DeafMan1983.FunctionPointers;

using System.Text;

public static class SBytePointerExtensions
{
    public unsafe static int Length(this SBytePointer pointer)
    {
        if (pointer.value == null)
            return 0;

        int length = 0;
        while (pointer.value[length] != 0)
        {
            length++;
        }

        return length;
    }

    public unsafe static string ForString(this SBytePointer pointer)
    {
        if (pointer.value == null)
            return string.Empty;

        int length = ((SBytePointer)pointer.value).Length();
        byte[] utf8Bytes = new byte[length];
        for (int i = 0; i < length; i++)
        {
            utf8Bytes[i] = (byte)pointer.value[i];
        }

        return Encoding.UTF8.GetString(utf8Bytes);
    }
}

Then I create function pointer

    /*
     *  int printf(const char *fmt, ...)
     */
    private delegate*<sbyte*, int> internal_printf
    {
        get
        {
            return (delegate*<sbyte*, int>)s_getProcAddress("printf".ForSBytePointer());
        }
    }

    public int printf(sbyte* fmt, params object[] args)
    {
        return internal_printf(CreateVarArgs(fmt, args));
    }

But it crashed cause memory leak.
How do I know to fix?

[huoyaoyuan]

I think that string.Format helps?

Then you are not really using printf, but doing the work of printf at managed side. BTW your code is throwing away the result of string.Format.

private delegate*<sbyte*, int> internal_printf

This is just equal to defining a P/Invoke like this:

        [LibraryImport("libc", EntryPoint = "printf", StringMarshalling = StringMarshalling.Utf8)]
        public static partial int printf(string str);

[huoyaoyuan]

printf can't be properly used without the runtime understanding about the varargs convention on the platform.

It's effectively defining an infinite series of P/Invokes like this:

[DllImport("libc", EntryPoint = "printf")]
static extern int printf0(sbyte* fmt);

[DllImport("libc", EntryPoint = "printf")]
static extern int printf1_int(sbyte* fmt, int arg1);

[DllImport("libc", EntryPoint = "printf")]
static extern int printf1_long(sbyte* fmt, long arg1);

[DllImport("libc", EntryPoint = "printf")]
static extern int printf2_int_int(sbyte* fmt, int arg1, int arg2);

[DllImport("libc", EntryPoint = "printf")]
static extern int printf3_int_int_int(sbyte* fmt, int arg1, int arg2, int arg3);

AND dispatching arguments under a complicated rule into arg slots, which is especially troublesome for floating-point types.

[huoyaoyuan]

If the native code is under your control, the only way is defining it like this:

struct ARG_SLOT
{
    int type;
    void* value;
};

ret_t function(int requiredParam, int va_count, ARG_SLOT* va_list);

And define your own rule to interpret ARG_SLOT with different types.

If it's not under your control like printf, then you have literally no way to use it correctly.

[msedi]

See also: #82081 and some linked dicussions. I'm not sure what the current state is and what open issues are to discuss for this. I think it would need a proper design and then its simply implemented for the individual platforms ;-)

[DeafMan1983]

I found my old example with pinvokes:
Check old thread!

Now I have replaced modern version of loading shared library or passing static library like ( -lc or -lSDL2 etc )
Now I will explain you how do you pass into single custom void* GetProcAddress(sbyte* proc_name) like whatever any custom function for function pointer.

// Define function pointer first for GetProcAddress-like function
private unsafe delegate*<sbyte*, void*> s_getProcAddress;

// Create first struct for current OS example: Windows as WinCRT ( Windows's C-Runtime -> msvcrt(.dll) ) 
private struct WinVCRT
{
    private const string kernel32 = "kernel32";

    [DllImport(kernel32)]
    private unsafe static extern void* LoadLibraryA(sbyte* libPath);

    [DllImport(kernel32)]
    private unsafe static extern void* GetProcAddress(void* libHandle, sbyte* procName);

    [DllImport(kernel32)]
    public unsafe static extern int FreeLibrary(void* libHandle);

    public unsafe static void* StdString_GetProcAddress(sbyte* procName)
    {
        void* handle = GetProcAddress(LoadLibraryA("msvcrt".ToUTF8SignedBytePointer()), procName);
        if (handle == null)
        {
            Console.WriteLine("Error: Not found msvcrt.dll");
            FreeLibrary(handle);
            return null;
        }
        return handle;
    }
}

// other os you should put but you should same GetProcAddress-like function because it equals delegate*<sbyte*, void*> s_getProcAddress;

...

// Create GetAPI()
public unsafe static StdString GetAPI()
{
    StdString stri = new();
    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        stri.s_getProcAddress = &WinVCRT.StdString_GetProcAddress;
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
    {
        stri.s_getProcAddress = &LinuxC.StdString_GetProcAddress;
    }

    // If you would like to add complete variables like in C/C++
    // But sometimes need to access variables...

    return stri;
}

// If you don't use create custom GetProcAddress-like function - but you need to OS-switcher RuntimeInformation.IsOSPlatform(OSPlatform)
public static GLInvoker GetApi(delegate*<sbyte*, void*> func)
{
    StdString stri = new();
    stri.s_getProcAddress = func;
    if (func == null)
    {
        Console.WriteLine(@"Error: Wrong or incorrect GetProcAddress other built-in advanced get proc address! Thanks!");
    }

    return stri;
}

// Example memcpy()
/*
 *  void *memcpy(void *dest_str, const void * src_str, size_t n)
 */
public unsafe delegate*<void*, void*, nuint, void*> memcpy
{
    get
    {
        return (delegate*<void*, void*, nuint, void*>)s_getProcAddress("memcpy".ToUTF8SignedBytePointer());
    }
}

// any public methods if you add here.

And also printf from stdio.h I already create simple if you love to get implements with printf under C#

/*
    *  int printf(const char *fmt, ...)
    */
private delegate*<sbyte*, void*, int> internal_printf_param1
{
    get
    {
        return (delegate*<sbyte*, void*, int>)s_getProcAddress("printf".ToUTF8SignedBytePointer());
    }
}

public unsafe int printf(sbyte* fmt, params void*[] args)
{

    if (fmt == null)
    {
        return 0;
    }

    int result = 0;
    int argIndex = 0;

    while (*fmt != 0)
    {
        if (*fmt == 0x25) // '%'
        {
            fmt++;

            if (*fmt == 0x73) // 's' 
            {
                // Handle string
                sbyte* str = (sbyte*)args[argIndex];
                result += internal_printf_param1("%s".ToUTF8SignedBytePointer(), str);
                argIndex++;
            }
            else if (*fmt == 0x64 || *fmt == 0x69 || *fmt == 0x66) // 'd' 'i' 'f'
            {
                int number = *((int*)args[argIndex]);
                result += internal_printf_param1("%d".ToUTF8SignedBytePointer(), (void*)number);
                argIndex++;
            }
            else if (*fmt == 0x70) // 'p'
            {
                void* pointer = args[argIndex];
                result += internal_printf_param1("%p".ToUTF8SignedBytePointer(), pointer);
                argIndex++;
            }
            else
            {
                // Unsupported format specifier, print the literal '%'
                result += internal_printf_param1("%c".ToUTF8SignedBytePointer(), (void*)(int)'%'); // Print '%'
            }
        }
        else
        {
            // Print the current character as it is
            result += internal_printf_param1("%c".ToUTF8SignedBytePointer(), (void*)(int)*fmt);
        }

        fmt++;
    }

    return result;
}

If you want to sprintf or fprintf then you should to put some functions with APi of stdio.h like fgets or fscanf etc because fprintf need to write file like stdout - But I am not sure for tmpname(), fopen() or fputs()
If stderr tells failure that is why we need to write fill like in C/C++.
But you shouldn't forget to close with FILE as fclose() end of line of function like public int fprintf(FILE* file, sbyte* fmt, params void*[] args) { ... }

I hope you get successful with C#.
Enjoy your continuation!

[huoyaoyuan]

So you are replicating what printf does in managed side, instead of passing everything to invoke printf.

In the P/Invoke wrapper, you are replicating the functionalities of System.Runtime.InteropServices.NativeLibrary.