string[] to byte ** / sbyte ** and byte ** / sbyte ** to string[] for example?

[DeafMan1983]

Hello everyone,

I would like to know how do I convert sbyte * to string and string to sbyte * but I have made in DeafMan1983.Conversion and but I want know how do I string[] to sbyte ** and sbyte ** to string[] and I don't get already to find Google but I don't have idea. I tried to write string[] to sbyte **. No success...

Do you have idea with double pointers to string[] args

Because sometimes UnmanagedCallerOnly doesn't like to pass string[] if parameter of unmanaged function like example

[UnmanagedCallerOnly(EntryPoint = "MyFunc")]
Public void MyFunc(sbyte **args)
{
    // pass to string[] with for statement
    string[] sArgs = StringArrayFromCharDoublePointer(args);
    for (int i = 0; i < sArgs.Length: i++)
    {
        // pass in command line like this sArgs[i] = "--help" etc
    }
}

Program pass with delegate *unmanaged[Cdecl]<sbyte **, void> pfnMyFunc with dlsym sorry I use only Linux not Windows.

Example with Main(string[] args)

static void Main(string[] args)
{
   ....
   delegate *unmanaged[Cdecl]<sbyte **, void> pfnMyFunc = (delegate *unmanaged[Cdecl]<sbyte **, void>)dlsym(CharPtrsfromString("MyFunc"));
    // that is passing args with external functions from native library 
    pfnMyFunc(CharDoublePtrsFromStringArray(args));
}

A Method sbyte **CharDoublePtrsFromStringArray(string[] args) is for double pointers to string array and other method string[] StringArrayFromCharDoublePointer(sbyte **unmanagedargs)

I have problem with multiple arrays or pointers. How do I know like this? Can you help me if you have ideas?

[jkotas]

Here is an example where we do something similar in this repo:

runtime/src/libraries/Common/src/Interop/Unix/System.Native/Interop.ForkAndExecProcess.cs

Lines 50 to 89 in cb5fe56

	private static unsafe void AllocNullTerminatedArray(string[] arr, ref byte** arrPtr)
	{
	nuint arrLength = (nuint)arr.Length + 1; // +1 is for null termination
	// Allocate the unmanaged array to hold each string pointer.
	// It needs to have an extra element to null terminate the array.
	// Zero the memory so that if any of the individual string allocations fails,
	// we can loop through the array to free any that succeeded.
	// The last element will remain null.
	arrPtr = (byte**)NativeMemory.AllocZeroed(arrLength, (nuint)sizeof(byte*));
	// Now copy each string to unmanaged memory referenced from the array.
	// We need the data to be an unmanaged, null-terminated array of UTF8-encoded bytes.
	for (int i = 0; i < arr.Length; i++)
	{
	string str = arr[i];
	int byteLength = Encoding.UTF8.GetByteCount(str);
	arrPtr[i] = (byte*)NativeMemory.Alloc((nuint)byteLength + 1); //+1 for null termination
	int bytesWritten = Encoding.UTF8.GetBytes(str, new Span<byte>(arrPtr[i], byteLength));
	Debug.Assert(bytesWritten == byteLength);
	arrPtr[i][bytesWritten] = (byte)'\0'; // null terminate
	}
	}
	private static unsafe void FreeArray(byte** arr, int length)
	{
	if (arr != null)
	{
	// Free each element of the array
	for (int i = 0; i < length; i++)
	{
	NativeMemory.Free(arr[i]);
	}
	// And then the array itself
	NativeMemory.Free(arr);
	}

.

The idea is to allocate the converted strings in native memory. It is necessary to free them once you are done with it.

[DeafMan1983]

Thanks for fix but still nothing display Console from external native library :/

Fullcode:
Program.cs

namespace valve;

using static DeafMan1983.ConvFunctions;

using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;

unsafe class Game
{
    // For Linux:
    private const string dl = "c";    
    
    [DllImport(dl)]
    private static extern void *dlopen(sbyte *so_file, uint flags);

    [DllImport(dl)]
    private static extern void *dlsym(void *so_handle, sbyte *func_name);

    [DllImport(dl)]
    private static extern void dlclose(void *so_handle);

    [DllImport(dl)]
    private static extern sbyte *dlerror();
    public static delegate *unmanaged[Cdecl]<sbyte **, int, sbyte *, int, delegate* unmanaged[Cdecl]<sbyte *, void>, int> pfnMain_p_new;
    public static delegate* unmanaged[Cdecl]<void> pfnShutdown_p_new;

    private static string szGameDir = string.Empty;
    private static string[] szArgs = Environment.GetCommandLineArgs();

    private static string GAMEDIR = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "valve");

    private static string GetError()
    {
        return StringwithSBytePointer(dlerror());
    }
    private static void *hEngine;

    private static void FreeLibrary()
    {
        if (hEngine != null)
        {
            dlclose(hEngine);
        }
    }

    private static string strncpy(ref string dst, string src, int num)
    {
        return dst=src.Substring(0,num);
    }


    private static void Sys_LoadEngine()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            hEngine = dlopen(SBytePointerWithString(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Engine.so")), 0x00002);
            if (hEngine == null)
            {
                Console.WriteLine("Unable to load {0}", GetError());
            }

            pfnMain_p_new = (delegate *unmanaged[Cdecl]<sbyte **, int, sbyte *, int, delegate* unmanaged[Cdecl]<sbyte *, void>, int> )dlsym(hEngine, SBytePointerWithString("Host_Main"));
            if (pfnMain_p_new == null)
            {
                Console.WriteLine("Unable to pass function name {0}", GetError());
            }
        }

        pfnShutdown_p_new = (delegate *unmanaged[Cdecl]<void>)dlsym(hEngine, SBytePointerWithString("Host_Shutdown"));
    }

    private static void Sys_UnloadEngine()
    {
        if (pfnShutdown_p_new != null)
        {
            pfnShutdown_p_new();
        }

        if (hEngine != null)
        {
            FreeLibrary();
        }

        pfnMain_p_new = null;
	    pfnShutdown_p_new = null;
    }

    private static sbyte **GetIndex(string[] args)
    {
        sbyte **sArgs = stackalloc sbyte*[args.Length];
        for (int i = 0; i < args.Length; i++)
        {
            sArgs[i] = SBytePointerWithString(args[i]);
        }
        return sArgs;
    }

    [UnmanagedCallersOnly(CallConvs = new[] {typeof(CallConvCdecl)})]
    private static void Sys_ChangeGame(sbyte *progname)
    {
        if (progname == null)
        {
            Console.Error.WriteLine("Error: Sys_ChangeGame is null.");
        }

        if (pfnShutdown_p_new == null)
        {
            Console.Error.WriteLine("Error: Sys_ChangeGame: missed 'Host_Shutdown'.");
        }

        strncpy(ref szGameDir, StringwithSBytePointer(progname), szGameDir.Length - 1);
        Sys_UnloadEngine();
        Sys_LoadEngine();
        delegate* unmanaged[Cdecl]<sbyte *, void> pfnChangeGame = &Sys_ChangeGame;
        pfnMain_p_new(GetIndex(szArgs), szArgs.Length, SBytePointerWithString(szGameDir), 1, pfnChangeGame);
    }

    public static int Sys_Start()
    {
        Sys_LoadEngine();
        delegate* unmanaged[Cdecl]<sbyte *, void> pfnChangeGame = &Sys_ChangeGame;
        int returnCode = pfnMain_p_new(GetIndex(szArgs), szArgs.Length, SBytePointerWithString(GAMEDIR), 0, pfnChangeGame);
        Sys_UnloadEngine();
        return returnCode;
    }

    static int Main(string[] args)
    {
        return Sys_Start();
    }
}

for Launcher

and Host.cs from Engine, classlib as native library

namespace Engine;

using System;
using System.IO;
using System.Runtime.InteropServices;

using static DeafMan1983.ConvFunctions;

public unsafe class Host
{
    private static delegate* unmanaged[Cdecl]<string, void> pChangeGame = null;


    // ...

    private static string[] FromIndex(sbyte ** sArrays, int array_length)
    {
        string[] arrays = new string[array_length];
        for (int i = 0; i < array_length; i++)
        {
            arrays[i] = StringwithSBytePointer(sArrays[i]);
        }
        return arrays;
    }

    // ------------------------------------------------
    // Host_Main()
    // ------------------------------------------------
    [UnmanagedCallersOnly(EntryPoint = "Host_Main")]
    public static int Host_Main(sbyte** args, int array_length, sbyte* progname, int bchange_name, delegate* unmanaged[Cdecl]<string, void> func)
    {
        Console.WriteLine("Hello Half-Life Engine, lol!");

        pChangeGame = func;

        if (!Directory.Exists(StringwithSBytePointer(progname)))
        {
            Console.WriteLine("Not found, Please re-update Steam!");
        }
        else
        {
            Console.WriteLine("Woohoo, Half-Life Sharp (x64)");
            Console.WriteLine("All executables and libraries are written in C#\n" +
            "and are compiled in NativeAot with Shared. :-D");
        }

        string[] sArgs = FromIndex(args, array_length);
        for (int i = 0; i < sArgs.Length; i++)
        {
            // Parammeter "help" example: ./Launcher help
            if (sArgs[i] == "help")
            {
                Console.WriteLine("Display help!");
            }
        }

        return 0;
    }

    // ------------------------------------------------
    // Host_Shutdown()
    // ------------------------------------------------
    [UnmanagedCallersOnly(EntryPoint = "Host_Shutdown")]
    public static void Host_Shutdown()
    {
        Environment.Exit(0);
    }
}

And result looks without argument help

And I try to pass argument help

Eh where is console line? Do you think I need to exercise AppWithPlugins Example into Native Aot?

[jkotas]

    private static sbyte **GetIndex(string[] args)
    {
        sbyte **sArgs = stackalloc sbyte*[args.Length];
        for (int i = 0; i < args.Length; i++)
        {
            sArgs[i] = SBytePointerWithString(args[i]);
        }
        return sArgs;
    }

This is wrong. You cannot return stackallocated memory from a function that stackallocated it.

[DeafMan1983]

Then ???

I have tried.....

    private static sbyte **GetIndex(string[] args)
    {
        sbyte[][] sArgs = new sbyte[args.Length][];
        for (int i = 0; i < args.Length; i++)
        {
            fixed (sbyte** sArgsPtrs = sArgs[i][i])
            {
                sArgsPtrs[i] = SBytePointerWithString(args[i]);
                return sArgsPtrs;
            }
        }
    }

sbyte* =/= sbyte[]
sbyte** =/= sbyte[][]

How do I get successfully?

[jkotas]

Either allocate array of pointers sbyte*[] sArgs = new sbyte*[args.Length]; and pin it using fixed;
or allocate native memory using sbyte** sArgs = (sbyte**)NativeMemory.Alloc(args.Length * sizeof(sbyte*)); and then free it using NativeMemory.Free once you are done with it.

[DeafMan1983]

Thanks for Fixed wow why do I need NativeMemory? I expect Memory Leak. Thanks for supporting me. I need invite you for rewards 😋🙂

[DeafMan1983]

Hey my friend, person from discord told me because NativeMemory() has leak. I don't understand why does it happen?
Proof screenshot of discord:
Check out.

[stephentoub]

What is your code?

[DeafMan1983]

Check out my repository code. Has it Memory Leak? But I already tested with my own game with loading native library engine. And it has not problem. Who said because my Conversion for sbyte ** and string[]?