UText

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct UText
{
    public uint magic;
    public int flags;
    public int providerProperties;
    public int sizeOfStruct;
    public long chunkNativeLimit;
    public int extraSize;
    public int nativeIndexingLimit;
    public long chunkNativeStart;
    public int chunkOffset;
    public int chunkLength;
    public IntPtr chunkContents;
    public IntPtr pFuncs;
    public IntPtr pExtra;
    public IntPtr context;
    public IntPtr p;
    public IntPtr q;
    public IntPtr r;
    public IntPtr privP;
    public long a;
    public int b;
    public int c;
    public long privA;
    public int privB;
    public int privC;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure UText
    Public magic As UInteger
    Public flags As Integer
    Public providerProperties As Integer
    Public sizeOfStruct As Integer
    Public chunkNativeLimit As Long
    Public extraSize As Integer
    Public nativeIndexingLimit As Integer
    Public chunkNativeStart As Long
    Public chunkOffset As Integer
    Public chunkLength As Integer
    Public chunkContents As IntPtr
    Public pFuncs As IntPtr
    Public pExtra As IntPtr
    Public context As IntPtr
    Public p As IntPtr
    Public q As IntPtr
    Public r As IntPtr
    Public privP As IntPtr
    Public a As Long
    Public b As Integer
    Public c As Integer
    Public privA As Long
    Public privB As Integer
    Public privC As Integer
End Structure

import ctypes
from ctypes import wintypes

class UText(ctypes.Structure):
    _fields_ = [
        ("magic", wintypes.DWORD),
        ("flags", ctypes.c_int),
        ("providerProperties", ctypes.c_int),
        ("sizeOfStruct", ctypes.c_int),
        ("chunkNativeLimit", ctypes.c_longlong),
        ("extraSize", ctypes.c_int),
        ("nativeIndexingLimit", ctypes.c_int),
        ("chunkNativeStart", ctypes.c_longlong),
        ("chunkOffset", ctypes.c_int),
        ("chunkLength", ctypes.c_int),
        ("chunkContents", ctypes.c_void_p),
        ("pFuncs", ctypes.c_void_p),
        ("pExtra", ctypes.c_void_p),
        ("context", ctypes.c_void_p),
        ("p", ctypes.c_void_p),
        ("q", ctypes.c_void_p),
        ("r", ctypes.c_void_p),
        ("privP", ctypes.c_void_p),
        ("a", ctypes.c_longlong),
        ("b", ctypes.c_int),
        ("c", ctypes.c_int),
        ("privA", ctypes.c_longlong),
        ("privB", ctypes.c_int),
        ("privC", ctypes.c_int),
    ]

#[repr(C)]
pub struct UText {
    pub magic: u32,
    pub flags: i32,
    pub providerProperties: i32,
    pub sizeOfStruct: i32,
    pub chunkNativeLimit: i64,
    pub extraSize: i32,
    pub nativeIndexingLimit: i32,
    pub chunkNativeStart: i64,
    pub chunkOffset: i32,
    pub chunkLength: i32,
    pub chunkContents: *mut core::ffi::c_void,
    pub pFuncs: *mut core::ffi::c_void,
    pub pExtra: *mut core::ffi::c_void,
    pub context: *mut core::ffi::c_void,
    pub p: *mut core::ffi::c_void,
    pub q: *mut core::ffi::c_void,
    pub r: *mut core::ffi::c_void,
    pub privP: *mut core::ffi::c_void,
    pub a: i64,
    pub b: i32,
    pub c: i32,
    pub privA: i64,
    pub privB: i32,
    pub privC: i32,
}

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

type UText struct {
	magic uint32
	flags int32
	providerProperties int32
	sizeOfStruct int32
	chunkNativeLimit int64
	extraSize int32
	nativeIndexingLimit int32
	chunkNativeStart int64
	chunkOffset int32
	chunkLength int32
	chunkContents uintptr
	pFuncs uintptr
	pExtra uintptr
	context uintptr
	p uintptr
	q uintptr
	r uintptr
	privP uintptr
	a int64
	b int32
	c int32
	privA int64
	privB int32
	privC int32
}

type
  UText = record
    magic: DWORD;
    flags: Integer;
    providerProperties: Integer;
    sizeOfStruct: Integer;
    chunkNativeLimit: Int64;
    extraSize: Integer;
    nativeIndexingLimit: Integer;
    chunkNativeStart: Int64;
    chunkOffset: Integer;
    chunkLength: Integer;
    chunkContents: Pointer;
    pFuncs: Pointer;
    pExtra: Pointer;
    context: Pointer;
    p: Pointer;
    q: Pointer;
    r: Pointer;
    privP: Pointer;
    a: Int64;
    b: Integer;
    c: Integer;
    privA: Int64;
    privB: Integer;
    privC: Integer;
  end;

const UText = extern struct {
    magic: u32,
    flags: i32,
    providerProperties: i32,
    sizeOfStruct: i32,
    chunkNativeLimit: i64,
    extraSize: i32,
    nativeIndexingLimit: i32,
    chunkNativeStart: i64,
    chunkOffset: i32,
    chunkLength: i32,
    chunkContents: ?*anyopaque,
    pFuncs: ?*anyopaque,
    pExtra: ?*anyopaque,
    context: ?*anyopaque,
    p: ?*anyopaque,
    q: ?*anyopaque,
    r: ?*anyopaque,
    privP: ?*anyopaque,
    a: i64,
    b: i32,
    c: i32,
    privA: i64,
    privB: i32,
    privC: i32,
};

type
  UText {.bycopy.} = object
    magic: uint32
    flags: int32
    providerProperties: int32
    sizeOfStruct: int32
    chunkNativeLimit: int64
    extraSize: int32
    nativeIndexingLimit: int32
    chunkNativeStart: int64
    chunkOffset: int32
    chunkLength: int32
    chunkContents: pointer
    pFuncs: pointer
    pExtra: pointer
    context: pointer
    p: pointer
    q: pointer
    r: pointer
    privP: pointer
    a: int64
    b: int32
    c: int32
    privA: int64
    privB: int32
    privC: int32

struct UText
{
    uint magic;
    int flags;
    int providerProperties;
    int sizeOfStruct;
    long chunkNativeLimit;
    int extraSize;
    int nativeIndexingLimit;
    long chunkNativeStart;
    int chunkOffset;
    int chunkLength;
    void* chunkContents;
    void* pFuncs;
    void* pExtra;
    void* context;
    void* p;
    void* q;
    void* r;
    void* privP;
    long a;
    int b;
    int c;
    long privA;
    int privB;
    int privC;
}