MI_MethodDecl

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MI_MethodDecl
{
    public uint flags;
    public uint code;
    public IntPtr name;
    public IntPtr qualifiers;
    public uint numQualifiers;
    public IntPtr parameters;
    public uint numParameters;
    public uint size;
    public uint returnType;
    public IntPtr origin;
    public IntPtr propagator;
    public IntPtr schema;
    public IntPtr function;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MI_MethodDecl
    Public flags As UInteger
    Public code As UInteger
    Public name As IntPtr
    Public qualifiers As IntPtr
    Public numQualifiers As UInteger
    Public parameters As IntPtr
    Public numParameters As UInteger
    Public size As UInteger
    Public returnType As UInteger
    Public origin As IntPtr
    Public propagator As IntPtr
    Public schema As IntPtr
    Public function As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class MI_MethodDecl(ctypes.Structure):
    _fields_ = [
        ("flags", wintypes.DWORD),
        ("code", wintypes.DWORD),
        ("name", ctypes.c_void_p),
        ("qualifiers", ctypes.c_void_p),
        ("numQualifiers", wintypes.DWORD),
        ("parameters", ctypes.c_void_p),
        ("numParameters", wintypes.DWORD),
        ("size", wintypes.DWORD),
        ("returnType", wintypes.DWORD),
        ("origin", ctypes.c_void_p),
        ("propagator", ctypes.c_void_p),
        ("schema", ctypes.c_void_p),
        ("function", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct MI_MethodDecl {
    pub flags: u32,
    pub code: u32,
    pub name: *mut core::ffi::c_void,
    pub qualifiers: *mut core::ffi::c_void,
    pub numQualifiers: u32,
    pub parameters: *mut core::ffi::c_void,
    pub numParameters: u32,
    pub size: u32,
    pub returnType: u32,
    pub origin: *mut core::ffi::c_void,
    pub propagator: *mut core::ffi::c_void,
    pub schema: *mut core::ffi::c_void,
    pub function: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type MI_MethodDecl struct {
	flags uint32
	code uint32
	name uintptr
	qualifiers uintptr
	numQualifiers uint32
	parameters uintptr
	numParameters uint32
	size uint32
	returnType uint32
	origin uintptr
	propagator uintptr
	schema uintptr
	function uintptr
}

type
  MI_MethodDecl = record
    flags: DWORD;
    code: DWORD;
    name: Pointer;
    qualifiers: Pointer;
    numQualifiers: DWORD;
    parameters: Pointer;
    numParameters: DWORD;
    size: DWORD;
    returnType: DWORD;
    origin: Pointer;
    propagator: Pointer;
    schema: Pointer;
    function: Pointer;
  end;

const MI_MethodDecl = extern struct {
    flags: u32,
    code: u32,
    name: ?*anyopaque,
    qualifiers: ?*anyopaque,
    numQualifiers: u32,
    parameters: ?*anyopaque,
    numParameters: u32,
    size: u32,
    returnType: u32,
    origin: ?*anyopaque,
    propagator: ?*anyopaque,
    schema: ?*anyopaque,
    function: ?*anyopaque,
};

type
  MI_MethodDecl {.bycopy.} = object
    flags: uint32
    code: uint32
    name: pointer
    qualifiers: pointer
    numQualifiers: uint32
    parameters: pointer
    numParameters: uint32
    size: uint32
    returnType: uint32
    origin: pointer
    propagator: pointer
    schema: pointer
    function: pointer

struct MI_MethodDecl
{
    uint flags;
    uint code;
    void* name;
    void* qualifiers;
    uint numQualifiers;
    void* parameters;
    uint numParameters;
    uint size;
    uint returnType;
    void* origin;
    void* propagator;
    void* schema;
    void* function;
}