HEAPENTRY32

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HEAPENTRY32
{
    public UIntPtr dwSize;
    public IntPtr hHandle;
    public UIntPtr dwAddress;
    public UIntPtr dwBlockSize;
    public uint dwFlags;
    public uint dwLockCount;
    public uint dwResvd;
    public uint th32ProcessID;
    public UIntPtr th32HeapID;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HEAPENTRY32
    Public dwSize As UIntPtr
    Public hHandle As IntPtr
    Public dwAddress As UIntPtr
    Public dwBlockSize As UIntPtr
    Public dwFlags As UInteger
    Public dwLockCount As UInteger
    Public dwResvd As UInteger
    Public th32ProcessID As UInteger
    Public th32HeapID As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class HEAPENTRY32(ctypes.Structure):
    _fields_ = [
        ("dwSize", ctypes.c_size_t),
        ("hHandle", ctypes.c_void_p),
        ("dwAddress", ctypes.c_size_t),
        ("dwBlockSize", ctypes.c_size_t),
        ("dwFlags", wintypes.DWORD),
        ("dwLockCount", wintypes.DWORD),
        ("dwResvd", wintypes.DWORD),
        ("th32ProcessID", wintypes.DWORD),
        ("th32HeapID", ctypes.c_size_t),
    ]

#[repr(C)]
pub struct HEAPENTRY32 {
    pub dwSize: usize,
    pub hHandle: *mut core::ffi::c_void,
    pub dwAddress: usize,
    pub dwBlockSize: usize,
    pub dwFlags: u32,
    pub dwLockCount: u32,
    pub dwResvd: u32,
    pub th32ProcessID: u32,
    pub th32HeapID: usize,
}

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

type HEAPENTRY32 struct {
	dwSize uintptr
	hHandle uintptr
	dwAddress uintptr
	dwBlockSize uintptr
	dwFlags uint32
	dwLockCount uint32
	dwResvd uint32
	th32ProcessID uint32
	th32HeapID uintptr
}

type
  HEAPENTRY32 = record
    dwSize: NativeUInt;
    hHandle: Pointer;
    dwAddress: NativeUInt;
    dwBlockSize: NativeUInt;
    dwFlags: DWORD;
    dwLockCount: DWORD;
    dwResvd: DWORD;
    th32ProcessID: DWORD;
    th32HeapID: NativeUInt;
  end;

const HEAPENTRY32 = extern struct {
    dwSize: usize,
    hHandle: ?*anyopaque,
    dwAddress: usize,
    dwBlockSize: usize,
    dwFlags: u32,
    dwLockCount: u32,
    dwResvd: u32,
    th32ProcessID: u32,
    th32HeapID: usize,
};

type
  HEAPENTRY32 {.bycopy.} = object
    dwSize: uint
    hHandle: pointer
    dwAddress: uint
    dwBlockSize: uint
    dwFlags: uint32
    dwLockCount: uint32
    dwResvd: uint32
    th32ProcessID: uint32
    th32HeapID: uint

struct HEAPENTRY32
{
    size_t dwSize;
    void* hHandle;
    size_t dwAddress;
    size_t dwBlockSize;
    uint dwFlags;
    uint dwLockCount;
    uint dwResvd;
    uint th32ProcessID;
    size_t th32HeapID;
}