UConverterToUnicodeArgs

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct UConverterToUnicodeArgs
{
    public ushort size;
    public sbyte flush;
    public IntPtr converter;
    public IntPtr source;
    public IntPtr sourceLimit;
    public IntPtr target;
    public IntPtr targetLimit;
    public IntPtr offsets;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure UConverterToUnicodeArgs
    Public size As UShort
    Public flush As SByte
    Public converter As IntPtr
    Public source As IntPtr
    Public sourceLimit As IntPtr
    Public target As IntPtr
    Public targetLimit As IntPtr
    Public offsets As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class UConverterToUnicodeArgs(ctypes.Structure):
    _fields_ = [
        ("size", ctypes.c_ushort),
        ("flush", ctypes.c_byte),
        ("converter", ctypes.c_void_p),
        ("source", ctypes.c_void_p),
        ("sourceLimit", ctypes.c_void_p),
        ("target", ctypes.c_void_p),
        ("targetLimit", ctypes.c_void_p),
        ("offsets", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct UConverterToUnicodeArgs {
    pub size: u16,
    pub flush: i8,
    pub converter: *mut core::ffi::c_void,
    pub source: *mut core::ffi::c_void,
    pub sourceLimit: *mut core::ffi::c_void,
    pub target: *mut core::ffi::c_void,
    pub targetLimit: *mut core::ffi::c_void,
    pub offsets: *mut core::ffi::c_void,
}

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

type UConverterToUnicodeArgs struct {
	size uint16
	flush int8
	converter uintptr
	source uintptr
	sourceLimit uintptr
	target uintptr
	targetLimit uintptr
	offsets uintptr
}

type
  UConverterToUnicodeArgs = record
    size: Word;
    flush: Shortint;
    converter: Pointer;
    source: Pointer;
    sourceLimit: Pointer;
    target: Pointer;
    targetLimit: Pointer;
    offsets: Pointer;
  end;

const UConverterToUnicodeArgs = extern struct {
    size: u16,
    flush: i8,
    converter: ?*anyopaque,
    source: ?*anyopaque,
    sourceLimit: ?*anyopaque,
    target: ?*anyopaque,
    targetLimit: ?*anyopaque,
    offsets: ?*anyopaque,
};

type
  UConverterToUnicodeArgs {.bycopy.} = object
    size: uint16
    flush: int8
    converter: pointer
    source: pointer
    sourceLimit: pointer
    target: pointer
    targetLimit: pointer
    offsets: pointer

struct UConverterToUnicodeArgs
{
    ushort size;
    byte flush;
    void* converter;
    void* source;
    void* sourceLimit;
    void* target;
    void* targetLimit;
    void* offsets;
}