keystone.cs

// ----------------------------------------------------------------------------
// <auto-generated>
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
// </auto-generated>
// ----------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using System.Security;
using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
using __IntPtr = global::System.IntPtr;

namespace keystone.NET
{
    public enum KsArch
    {
        KS_ARCH_ARM = 1,
        KS_ARCH_ARM64 = 2,
        KS_ARCH_MIPS = 3,
        KS_ARCH_X86 = 4,
        KS_ARCH_PPC = 5,
        KS_ARCH_SPARC = 6,
        KS_ARCH_SYSTEMZ = 7,
        KS_ARCH_HEXAGON = 8,
        KS_ARCH_EVM = 9,
        KS_ARCH_MAX = 10
    }

    [Flags]
    public enum KsMode
    {
        KS_MODE_LITTLE_ENDIAN = 0,
        KS_MODE_BIG_ENDIAN = 1073741824,
        KS_MODE_ARM = 1,
        KS_MODE_THUMB = 16,
        KS_MODE_V8 = 64,
        KS_MODE_MICRO = 16,
        KS_MODE_MIPS3 = 32,
        KS_MODE_MIPS32R6 = 64,
        KS_MODE_MIPS32 = 4,
        KS_MODE_MIPS64 = 8,
        KS_MODE_16 = 2,
        KS_MODE_32 = 4,
        KS_MODE_64 = 8,
        KS_MODE_PPC32 = 4,
        KS_MODE_PPC64 = 8,
        KS_MODE_QPX = 16,
        KS_MODE_SPARC32 = 4,
        KS_MODE_SPARC64 = 8,
        KS_MODE_V9 = 16
    }

    public enum KsErr
    {
        KS_ERR_OK = 0,
        KS_ERR_NOMEM = 1,
        KS_ERR_ARCH = 2,
        KS_ERR_HANDLE = 3,
        KS_ERR_MODE = 4,
        KS_ERR_VERSION = 5,
        KS_ERR_OPT_INVALID = 6,
        KS_ERR_ASM_EXPR_TOKEN = 128,
        KS_ERR_ASM_DIRECTIVE_VALUE_RANGE = 129,
        KS_ERR_ASM_DIRECTIVE_ID = 130,
        KS_ERR_ASM_DIRECTIVE_TOKEN = 131,
        KS_ERR_ASM_DIRECTIVE_STR = 132,
        KS_ERR_ASM_DIRECTIVE_COMMA = 133,
        KS_ERR_ASM_DIRECTIVE_RELOC_NAME = 134,
        KS_ERR_ASM_DIRECTIVE_RELOC_TOKEN = 135,
        KS_ERR_ASM_DIRECTIVE_FPOINT = 136,
        KS_ERR_ASM_DIRECTIVE_UNKNOWN = 137,
        KS_ERR_ASM_DIRECTIVE_EQU = 138,
        KS_ERR_ASM_DIRECTIVE_INVALID = 139,
        KS_ERR_ASM_VARIANT_INVALID = 140,
        KS_ERR_ASM_EXPR_BRACKET = 141,
        KS_ERR_ASM_SYMBOL_MODIFIER = 142,
        KS_ERR_ASM_SYMBOL_REDEFINED = 143,
        KS_ERR_ASM_SYMBOL_MISSING = 144,
        KS_ERR_ASM_RPAREN = 145,
        KS_ERR_ASM_STAT_TOKEN = 146,
        KS_ERR_ASM_UNSUPPORTED = 147,
        KS_ERR_ASM_MACRO_TOKEN = 148,
        KS_ERR_ASM_MACRO_PAREN = 149,
        KS_ERR_ASM_MACRO_EQU = 150,
        KS_ERR_ASM_MACRO_ARGS = 151,
        KS_ERR_ASM_MACRO_LEVELS_EXCEED = 152,
        KS_ERR_ASM_MACRO_STR = 153,
        KS_ERR_ASM_MACRO_INVALID = 154,
        KS_ERR_ASM_ESC_BACKSLASH = 155,
        KS_ERR_ASM_ESC_OCTAL = 156,
        KS_ERR_ASM_ESC_SEQUENCE = 157,
        KS_ERR_ASM_ESC_STR = 158,
        KS_ERR_ASM_TOKEN_INVALID = 159,
        KS_ERR_ASM_INSN_UNSUPPORTED = 160,
        KS_ERR_ASM_FIXUP_INVALID = 161,
        KS_ERR_ASM_LABEL_INVALID = 162,
        KS_ERR_ASM_FRAGMENT_INVALID = 163,
        KS_ERR_ASM_INVALIDOPERAND = 512,
        KS_ERR_ASM_MISSINGFEATURE = 513,
        KS_ERR_ASM_MNEMONICFAIL = 514
    }

    public enum KsOptType
    {
        KS_OPT_SYNTAX = 1,
        KS_OPT_SYM_RESOLVER = 2
    }

    [Flags]
    public enum KsOptValue
    {
        KS_OPT_SYNTAX_INTEL = 1,
        KS_OPT_SYNTAX_ATT = 2,
        KS_OPT_SYNTAX_NASM = 4,
        KS_OPT_SYNTAX_MASM = 8,
        KS_OPT_SYNTAX_GAS = 16,
        KS_OPT_SYNTAX_RADIX16 = 32
    }

    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(__CallingConvention.Cdecl)]
    [return: MarshalAs(UnmanagedType.I1)]
    public unsafe delegate bool KsSymResolver([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string symbol, ulong* value);
    public unsafe partial class KsStruct
    {

        public partial struct __Internal
        {
        }

        public __IntPtr __Instance { get; protected set; }

        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::keystone.NET.KsStruct> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::keystone.NET.KsStruct>();

        protected bool __ownsNativeInstance;

        internal static KsStruct __CreateInstance(__IntPtr native, bool skipVTables = false)
        {
            return new KsStruct(native.ToPointer(), skipVTables);
        }

        internal static KsStruct __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
        {
            if (native == __IntPtr.Zero)
                return null;
            if (NativeToManagedMap.TryGetValue(native, out var managed))
                return (KsStruct)managed;
            var result = __CreateInstance(native, skipVTables);
            if (saveInstance)
                NativeToManagedMap[native] = result;
            return result;
        }

        internal static KsStruct __CreateInstance(__Internal native, bool skipVTables = false)
        {
            return new KsStruct(native, skipVTables);
        }

        private static void* __CopyValue(__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(__Internal));
            *(__Internal*) ret = native;
            return ret.ToPointer();
        }

        private KsStruct(__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected KsStruct(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new __IntPtr(native);
        }
    }

    public unsafe partial class keystone
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_version", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern uint KsVersion(uint* major, uint* minor);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_arch_supported", CallingConvention = __CallingConvention.Cdecl)]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool KsArchSupported(global::keystone.NET.KsArch arch);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_open", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern global::keystone.NET.KsErr KsOpen(global::keystone.NET.KsArch arch, int mode, IntPtr* ks);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_close", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern global::keystone.NET.KsErr KsClose(__IntPtr ks);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_errno", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern global::keystone.NET.KsErr KsErrno(__IntPtr ks);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_strerror", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern __IntPtr KsStrerror(global::keystone.NET.KsErr code);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_option", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern global::keystone.NET.KsErr KsOption(__IntPtr ks, global::keystone.NET.KsOptType type, ulong value);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_asm", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern int KsAsm(__IntPtr ks, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string @string, ulong address, byte** encoding, ulong* encoding_size, ulong* stat_count);

            [SuppressUnmanagedCodeSecurity, DllImport("keystone", EntryPoint = "ks_free", CallingConvention = __CallingConvention.Cdecl)]
            internal static extern void KsFree(byte* p);
        }

        public static uint KsVersion(ref uint major, ref uint minor)
        {
            fixed (uint* __major0 = &major)
            {
                var __arg0 = __major0;
                fixed (uint* __minor1 = &minor)
                {
                    var __arg1 = __minor1;
                    var __ret = __Internal.KsVersion(__arg0, __arg1);
                    return __ret;
                }
            }
        }

        public static bool KsArchSupported(global::keystone.NET.KsArch arch)
        {
            var __ret = __Internal.KsArchSupported(arch);
            return __ret;
        }

        public static global::keystone.NET.KsErr KsOpen(global::keystone.NET.KsArch arch, int mode,out global::keystone.NET.KsStruct ks)
        {
            IntPtr __arg2;
            var __ret = __Internal.KsOpen(arch, mode, &__arg2);
            ks = global::keystone.NET.KsStruct.__CreateInstance(__arg2);
            return __ret;
        }

        public static global::keystone.NET.KsErr KsClose(global::keystone.NET.KsStruct ks)
        {
            var __arg0 = ks is null ? __IntPtr.Zero : ks.__Instance;
            var __ret = __Internal.KsClose(__arg0);
            return __ret;
        }

        public static global::keystone.NET.KsErr KsErrno(global::keystone.NET.KsStruct ks)
        {
            var __arg0 = ks is null ? __IntPtr.Zero : ks.__Instance;
            var __ret = __Internal.KsErrno(__arg0);
            return __ret;
        }

        public static string KsStrerror(global::keystone.NET.KsErr code)
        {
            var __ret = __Internal.KsStrerror(code);
            return CppSharp.Runtime.MarshalUtil.GetString(global::System.Text.Encoding.UTF8, __ret);
        }

        public static global::keystone.NET.KsErr KsOption(global::keystone.NET.KsStruct ks, global::keystone.NET.KsOptType type, ulong value)
        {
            var __arg0 = ks is null ? __IntPtr.Zero : ks.__Instance;
            var __ret = __Internal.KsOption(__arg0, type, value);
            return __ret;
        }

        public static int KsAsm(global::keystone.NET.KsStruct ks, string @string, ulong address, byte** encoding, out ulong encoding_size, out ulong stat_count)
        {
            var __arg0 = ks is null ? __IntPtr.Zero : ks.__Instance;
            fixed (ulong* __encoding_size4 = &encoding_size)
            {
                var __arg4 = __encoding_size4;
                fixed (ulong* __stat_count5 = &stat_count)
                {
                    var __arg5 = __stat_count5;
                    var __ret = __Internal.KsAsm(__arg0, @string, address, encoding, __arg4, __arg5);
                    return __ret;
                }
            }
        }

        public static void KsFree(byte* p)
        {
            __Internal.KsFree(p);
        }
    }

    public enum KsErrAsmArm64
    {
        KS_ERR_ASM_ARM64INVALIDOPERAND = 512,
        KS_ERR_ASM_ARM64MISSINGFEATURE = 513,
        KS_ERR_ASM_ARM64MNEMONICFAIL = 514
    }

    public enum KsErrAsmArm
    {
        KS_ERR_ASM_ARM_INVALIDOPERAND = 512,
        KS_ERR_ASM_ARM_MISSINGFEATURE = 513,
        KS_ERR_ASM_ARM_MNEMONICFAIL = 514
    }

    public enum KsErrAsmEvm
    {
        KS_ERR_ASM_EVM_INVALIDOPERAND = 512,
        KS_ERR_ASM_EVM_MISSINGFEATURE = 513,
        KS_ERR_ASM_EVM_MNEMONICFAIL = 514
    }

    public enum KsErrAsmHexagon
    {
        KS_ERR_ASM_HEXAGON_INVALIDOPERAND = 512,
        KS_ERR_ASM_HEXAGON_MISSINGFEATURE = 513,
        KS_ERR_ASM_HEXAGON_MNEMONICFAIL = 514
    }

    public enum KsErrAsmMips
    {
        KS_ERR_ASM_MIPS_INVALIDOPERAND = 512,
        KS_ERR_ASM_MIPS_MISSINGFEATURE = 513,
        KS_ERR_ASM_MIPS_MNEMONICFAIL = 514
    }

    public enum KsErrAsmPpc
    {
        KS_ERR_ASM_PPC_INVALIDOPERAND = 512,
        KS_ERR_ASM_PPC_MISSINGFEATURE = 513,
        KS_ERR_ASM_PPC_MNEMONICFAIL = 514
    }

    public enum KsErrAsmSparc
    {
        KS_ERR_ASM_SPARC_INVALIDOPERAND = 512,
        KS_ERR_ASM_SPARC_MISSINGFEATURE = 513,
        KS_ERR_ASM_SPARC_MNEMONICFAIL = 514
    }

    public enum KsErrAsmSystemz
    {
        KS_ERR_ASM_SYSTEMZ_INVALIDOPERAND = 512,
        KS_ERR_ASM_SYSTEMZ_MISSINGFEATURE = 513,
        KS_ERR_ASM_SYSTEMZ_MNEMONICFAIL = 514
    }

    public enum KsErrAsmX86
    {
        KS_ERR_ASM_X86INVALIDOPERAND = 512,
        KS_ERR_ASM_X86MISSINGFEATURE = 513,
        KS_ERR_ASM_X86MNEMONICFAIL = 514
    }
}