SPropValue

構造体

サイズx64: 24 バイト / x86: 16 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド	型	サイズ	x64	x86	説明
ulPropTag	DWORD	4	+0	+0	プロパティの種類と型を示すプロパティタグ。
dwAlignPad	DWORD	4	+4	+4	8バイト境界アラインメント用のパディング。
Value	__UPV	16/8	+8	+8	プロパティタグの型に応じた値を格納する__UPV共用体。

各言語での定義

#include <windows.h>

// CY  (x64 8 / x86 8 バイト)
typedef struct CY {
    _Anonymous_e__Struct Anonymous;
    LONGLONG int64;
} CY;

// FILETIME  (x64 8 / x86 8 バイト)
typedef struct FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
} FILETIME;

// SBinary  (x64 16 / x86 8 バイト)
typedef struct SBinary {
    DWORD cb;
    BYTE* lpb;
} SBinary;

// SShortArray  (x64 16 / x86 8 バイト)
typedef struct SShortArray {
    DWORD cValues;
    SHORT* lpi;
} SShortArray;

// SLongArray  (x64 16 / x86 8 バイト)
typedef struct SLongArray {
    DWORD cValues;
    INT* lpl;
} SLongArray;

// SRealArray  (x64 16 / x86 8 バイト)
typedef struct SRealArray {
    DWORD cValues;
    FLOAT* lpflt;
} SRealArray;

// SDoubleArray  (x64 16 / x86 8 バイト)
typedef struct SDoubleArray {
    DWORD cValues;
    DOUBLE* lpdbl;
} SDoubleArray;

// SCurrencyArray  (x64 16 / x86 8 バイト)
typedef struct SCurrencyArray {
    DWORD cValues;
    CY* lpcur;
} SCurrencyArray;

// SAppTimeArray  (x64 16 / x86 8 バイト)
typedef struct SAppTimeArray {
    DWORD cValues;
    DOUBLE* lpat;
} SAppTimeArray;

// SDateTimeArray  (x64 16 / x86 8 バイト)
typedef struct SDateTimeArray {
    DWORD cValues;
    FILETIME* lpft;
} SDateTimeArray;

// SBinaryArray  (x64 16 / x86 8 バイト)
typedef struct SBinaryArray {
    DWORD cValues;
    SBinary* lpbin;
} SBinaryArray;

// SLPSTRArray  (x64 16 / x86 8 バイト)
typedef struct SLPSTRArray {
    DWORD cValues;
    LPSTR* lppszA;
} SLPSTRArray;

// SWStringArray  (x64 16 / x86 8 バイト)
typedef struct SWStringArray {
    DWORD cValues;
    LPWSTR* lppszW;
} SWStringArray;

// SGuidArray  (x64 16 / x86 8 バイト)
typedef struct SGuidArray {
    DWORD cValues;
    GUID* lpguid;
} SGuidArray;

// SLargeIntegerArray  (x64 16 / x86 8 バイト)
typedef struct SLargeIntegerArray {
    DWORD cValues;
    LONGLONG* lpli;
} SLargeIntegerArray;

// __UPV  (x64 16 / x86 8 バイト)
typedef struct __UPV {
    SHORT i;
    INT l;
    DWORD ul;
    FLOAT flt;
    DOUBLE dbl;
    WORD b;
    CY cur;
    DOUBLE at;
    FILETIME ft;
    LPSTR lpszA;
    SBinary bin;
    LPWSTR lpszW;
    GUID* lpguid;
    LONGLONG li;
    SShortArray MVi;
    SLongArray MVl;
    SRealArray MVflt;
    SDoubleArray MVdbl;
    SCurrencyArray MVcur;
    SAppTimeArray MVat;
    SDateTimeArray MVft;
    SBinaryArray MVbin;
    SLPSTRArray MVszA;
    SWStringArray MVszW;
    SGuidArray MVguid;
    SLargeIntegerArray MVli;
    INT err;
    INT x;
} __UPV;

// SPropValue  (x64 24 / x86 16 バイト)
typedef struct SPropValue {
    DWORD ulPropTag;
    DWORD dwAlignPad;
    __UPV Value;
} SPropValue;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CY
{
    public _Anonymous_e__Struct Anonymous;
    public long int64;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SBinary
{
    public uint cb;
    public IntPtr lpb;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SShortArray
{
    public uint cValues;
    public IntPtr lpi;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SLongArray
{
    public uint cValues;
    public IntPtr lpl;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SRealArray
{
    public uint cValues;
    public IntPtr lpflt;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SDoubleArray
{
    public uint cValues;
    public IntPtr lpdbl;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SCurrencyArray
{
    public uint cValues;
    public IntPtr lpcur;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SAppTimeArray
{
    public uint cValues;
    public IntPtr lpat;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SDateTimeArray
{
    public uint cValues;
    public IntPtr lpft;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SBinaryArray
{
    public uint cValues;
    public IntPtr lpbin;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SLPSTRArray
{
    public uint cValues;
    public IntPtr lppszA;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SWStringArray
{
    public uint cValues;
    public IntPtr lppszW;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SGuidArray
{
    public uint cValues;
    public IntPtr lpguid;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SLargeIntegerArray
{
    public uint cValues;
    public IntPtr lpli;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct __UPV
{
    public short i;
    public int l;
    public uint ul;
    public float flt;
    public double dbl;
    public ushort b;
    public CY cur;
    public double at;
    public FILETIME ft;
    public IntPtr lpszA;
    public SBinary bin;
    public IntPtr lpszW;
    public IntPtr lpguid;
    public long li;
    public SShortArray MVi;
    public SLongArray MVl;
    public SRealArray MVflt;
    public SDoubleArray MVdbl;
    public SCurrencyArray MVcur;
    public SAppTimeArray MVat;
    public SDateTimeArray MVft;
    public SBinaryArray MVbin;
    public SLPSTRArray MVszA;
    public SWStringArray MVszW;
    public SGuidArray MVguid;
    public SLargeIntegerArray MVli;
    public int err;
    public int x;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPropValue
{
    public uint ulPropTag;
    public uint dwAlignPad;
    public __UPV Value;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CY
    Public Anonymous As _Anonymous_e__Struct
    Public int64 As Long
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SBinary
    Public cb As UInteger
    Public lpb As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SShortArray
    Public cValues As UInteger
    Public lpi As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SLongArray
    Public cValues As UInteger
    Public lpl As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SRealArray
    Public cValues As UInteger
    Public lpflt As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SDoubleArray
    Public cValues As UInteger
    Public lpdbl As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SCurrencyArray
    Public cValues As UInteger
    Public lpcur As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SAppTimeArray
    Public cValues As UInteger
    Public lpat As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SDateTimeArray
    Public cValues As UInteger
    Public lpft As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SBinaryArray
    Public cValues As UInteger
    Public lpbin As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SLPSTRArray
    Public cValues As UInteger
    Public lppszA As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SWStringArray
    Public cValues As UInteger
    Public lppszW As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SGuidArray
    Public cValues As UInteger
    Public lpguid As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SLargeIntegerArray
    Public cValues As UInteger
    Public lpli As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure __UPV
    Public i As Short
    Public l As Integer
    Public ul As UInteger
    Public flt As Single
    Public dbl As Double
    Public b As UShort
    Public cur As CY
    Public at As Double
    Public ft As FILETIME
    Public lpszA As IntPtr
    Public bin As SBinary
    Public lpszW As IntPtr
    Public lpguid As IntPtr
    Public li As Long
    Public MVi As SShortArray
    Public MVl As SLongArray
    Public MVflt As SRealArray
    Public MVdbl As SDoubleArray
    Public MVcur As SCurrencyArray
    Public MVat As SAppTimeArray
    Public MVft As SDateTimeArray
    Public MVbin As SBinaryArray
    Public MVszA As SLPSTRArray
    Public MVszW As SWStringArray
    Public MVguid As SGuidArray
    Public MVli As SLargeIntegerArray
    Public err As Integer
    Public x As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPropValue
    Public ulPropTag As UInteger
    Public dwAlignPad As UInteger
    Public Value As __UPV
End Structure

import ctypes
from ctypes import wintypes

class CY(ctypes.Structure):
    _fields_ = [
        ("Anonymous", _Anonymous_e__Struct),
        ("int64", ctypes.c_longlong),
    ]

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class SBinary(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("lpb", ctypes.c_void_p),
    ]

class SShortArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpi", ctypes.c_void_p),
    ]

class SLongArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpl", ctypes.c_void_p),
    ]

class SRealArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpflt", ctypes.c_void_p),
    ]

class SDoubleArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpdbl", ctypes.c_void_p),
    ]

class SCurrencyArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpcur", ctypes.c_void_p),
    ]

class SAppTimeArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpat", ctypes.c_void_p),
    ]

class SDateTimeArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpft", ctypes.c_void_p),
    ]

class SBinaryArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpbin", ctypes.c_void_p),
    ]

class SLPSTRArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lppszA", ctypes.c_void_p),
    ]

class SWStringArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lppszW", ctypes.c_void_p),
    ]

class SGuidArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpguid", ctypes.c_void_p),
    ]

class SLargeIntegerArray(ctypes.Structure):
    _fields_ = [
        ("cValues", wintypes.DWORD),
        ("lpli", ctypes.c_void_p),
    ]

class __UPV(ctypes.Structure):
    _fields_ = [
        ("i", ctypes.c_short),
        ("l", ctypes.c_int),
        ("ul", wintypes.DWORD),
        ("flt", ctypes.c_float),
        ("dbl", ctypes.c_double),
        ("b", ctypes.c_ushort),
        ("cur", CY),
        ("at", ctypes.c_double),
        ("ft", FILETIME),
        ("lpszA", ctypes.c_void_p),
        ("bin", SBinary),
        ("lpszW", ctypes.c_void_p),
        ("lpguid", ctypes.c_void_p),
        ("li", ctypes.c_longlong),
        ("MVi", SShortArray),
        ("MVl", SLongArray),
        ("MVflt", SRealArray),
        ("MVdbl", SDoubleArray),
        ("MVcur", SCurrencyArray),
        ("MVat", SAppTimeArray),
        ("MVft", SDateTimeArray),
        ("MVbin", SBinaryArray),
        ("MVszA", SLPSTRArray),
        ("MVszW", SWStringArray),
        ("MVguid", SGuidArray),
        ("MVli", SLargeIntegerArray),
        ("err", ctypes.c_int),
        ("x", ctypes.c_int),
    ]

class SPropValue(ctypes.Structure):
    _fields_ = [
        ("ulPropTag", wintypes.DWORD),
        ("dwAlignPad", wintypes.DWORD),
        ("Value", __UPV),
    ]

#[repr(C)]
pub struct CY {
    pub Anonymous: _Anonymous_e__Struct,
    pub int64: i64,
}

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct SBinary {
    pub cb: u32,
    pub lpb: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SShortArray {
    pub cValues: u32,
    pub lpi: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SLongArray {
    pub cValues: u32,
    pub lpl: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SRealArray {
    pub cValues: u32,
    pub lpflt: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SDoubleArray {
    pub cValues: u32,
    pub lpdbl: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SCurrencyArray {
    pub cValues: u32,
    pub lpcur: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SAppTimeArray {
    pub cValues: u32,
    pub lpat: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SDateTimeArray {
    pub cValues: u32,
    pub lpft: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SBinaryArray {
    pub cValues: u32,
    pub lpbin: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SLPSTRArray {
    pub cValues: u32,
    pub lppszA: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SWStringArray {
    pub cValues: u32,
    pub lppszW: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SGuidArray {
    pub cValues: u32,
    pub lpguid: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SLargeIntegerArray {
    pub cValues: u32,
    pub lpli: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct __UPV {
    pub i: i16,
    pub l: i32,
    pub ul: u32,
    pub flt: f32,
    pub dbl: f64,
    pub b: u16,
    pub cur: CY,
    pub at: f64,
    pub ft: FILETIME,
    pub lpszA: *mut core::ffi::c_void,
    pub bin: SBinary,
    pub lpszW: *mut core::ffi::c_void,
    pub lpguid: *mut core::ffi::c_void,
    pub li: i64,
    pub MVi: SShortArray,
    pub MVl: SLongArray,
    pub MVflt: SRealArray,
    pub MVdbl: SDoubleArray,
    pub MVcur: SCurrencyArray,
    pub MVat: SAppTimeArray,
    pub MVft: SDateTimeArray,
    pub MVbin: SBinaryArray,
    pub MVszA: SLPSTRArray,
    pub MVszW: SWStringArray,
    pub MVguid: SGuidArray,
    pub MVli: SLargeIntegerArray,
    pub err: i32,
    pub x: i32,
}

#[repr(C)]
pub struct SPropValue {
    pub ulPropTag: u32,
    pub dwAlignPad: u32,
    pub Value: __UPV,
}

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

type CY struct {
	Anonymous _Anonymous_e__Struct
	int64 int64
}

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type SBinary struct {
	cb uint32
	lpb uintptr
}

type SShortArray struct {
	cValues uint32
	lpi uintptr
}

type SLongArray struct {
	cValues uint32
	lpl uintptr
}

type SRealArray struct {
	cValues uint32
	lpflt uintptr
}

type SDoubleArray struct {
	cValues uint32
	lpdbl uintptr
}

type SCurrencyArray struct {
	cValues uint32
	lpcur uintptr
}

type SAppTimeArray struct {
	cValues uint32
	lpat uintptr
}

type SDateTimeArray struct {
	cValues uint32
	lpft uintptr
}

type SBinaryArray struct {
	cValues uint32
	lpbin uintptr
}

type SLPSTRArray struct {
	cValues uint32
	lppszA uintptr
}

type SWStringArray struct {
	cValues uint32
	lppszW uintptr
}

type SGuidArray struct {
	cValues uint32
	lpguid uintptr
}

type SLargeIntegerArray struct {
	cValues uint32
	lpli uintptr
}

type __UPV struct {
	i int16
	l int32
	ul uint32
	flt float32
	dbl float64
	b uint16
	cur CY
	at float64
	ft FILETIME
	lpszA uintptr
	bin SBinary
	lpszW uintptr
	lpguid uintptr
	li int64
	MVi SShortArray
	MVl SLongArray
	MVflt SRealArray
	MVdbl SDoubleArray
	MVcur SCurrencyArray
	MVat SAppTimeArray
	MVft SDateTimeArray
	MVbin SBinaryArray
	MVszA SLPSTRArray
	MVszW SWStringArray
	MVguid SGuidArray
	MVli SLargeIntegerArray
	err int32
	x int32
}

type SPropValue struct {
	ulPropTag uint32
	dwAlignPad uint32
	Value __UPV
}

type
  CY = record
    Anonymous: _Anonymous_e__Struct;
    int64: Int64;
  end;

  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  SBinary = record
    cb: DWORD;
    lpb: Pointer;
  end;

  SShortArray = record
    cValues: DWORD;
    lpi: Pointer;
  end;

  SLongArray = record
    cValues: DWORD;
    lpl: Pointer;
  end;

  SRealArray = record
    cValues: DWORD;
    lpflt: Pointer;
  end;

  SDoubleArray = record
    cValues: DWORD;
    lpdbl: Pointer;
  end;

  SCurrencyArray = record
    cValues: DWORD;
    lpcur: Pointer;
  end;

  SAppTimeArray = record
    cValues: DWORD;
    lpat: Pointer;
  end;

  SDateTimeArray = record
    cValues: DWORD;
    lpft: Pointer;
  end;

  SBinaryArray = record
    cValues: DWORD;
    lpbin: Pointer;
  end;

  SLPSTRArray = record
    cValues: DWORD;
    lppszA: Pointer;
  end;

  SWStringArray = record
    cValues: DWORD;
    lppszW: Pointer;
  end;

  SGuidArray = record
    cValues: DWORD;
    lpguid: Pointer;
  end;

  SLargeIntegerArray = record
    cValues: DWORD;
    lpli: Pointer;
  end;

  __UPV = record
    i: Smallint;
    l: Integer;
    ul: DWORD;
    flt: Single;
    dbl: Double;
    b: Word;
    cur: CY;
    at: Double;
    ft: FILETIME;
    lpszA: Pointer;
    bin: SBinary;
    lpszW: Pointer;
    lpguid: Pointer;
    li: Int64;
    MVi: SShortArray;
    MVl: SLongArray;
    MVflt: SRealArray;
    MVdbl: SDoubleArray;
    MVcur: SCurrencyArray;
    MVat: SAppTimeArray;
    MVft: SDateTimeArray;
    MVbin: SBinaryArray;
    MVszA: SLPSTRArray;
    MVszW: SWStringArray;
    MVguid: SGuidArray;
    MVli: SLargeIntegerArray;
    err: Integer;
    x: Integer;
  end;

  SPropValue = record
    ulPropTag: DWORD;
    dwAlignPad: DWORD;
    Value: __UPV;
  end;

const CY = extern struct {
    Anonymous: _Anonymous_e__Struct,
    int64: i64,
};

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const SBinary = extern struct {
    cb: u32,
    lpb: ?*anyopaque,
};

const SShortArray = extern struct {
    cValues: u32,
    lpi: ?*anyopaque,
};

const SLongArray = extern struct {
    cValues: u32,
    lpl: ?*anyopaque,
};

const SRealArray = extern struct {
    cValues: u32,
    lpflt: ?*anyopaque,
};

const SDoubleArray = extern struct {
    cValues: u32,
    lpdbl: ?*anyopaque,
};

const SCurrencyArray = extern struct {
    cValues: u32,
    lpcur: ?*anyopaque,
};

const SAppTimeArray = extern struct {
    cValues: u32,
    lpat: ?*anyopaque,
};

const SDateTimeArray = extern struct {
    cValues: u32,
    lpft: ?*anyopaque,
};

const SBinaryArray = extern struct {
    cValues: u32,
    lpbin: ?*anyopaque,
};

const SLPSTRArray = extern struct {
    cValues: u32,
    lppszA: ?*anyopaque,
};

const SWStringArray = extern struct {
    cValues: u32,
    lppszW: ?*anyopaque,
};

const SGuidArray = extern struct {
    cValues: u32,
    lpguid: ?*anyopaque,
};

const SLargeIntegerArray = extern struct {
    cValues: u32,
    lpli: ?*anyopaque,
};

const __UPV = extern struct {
    i: i16,
    l: i32,
    ul: u32,
    flt: f32,
    dbl: f64,
    b: u16,
    cur: CY,
    at: f64,
    ft: FILETIME,
    lpszA: ?*anyopaque,
    bin: SBinary,
    lpszW: ?*anyopaque,
    lpguid: ?*anyopaque,
    li: i64,
    MVi: SShortArray,
    MVl: SLongArray,
    MVflt: SRealArray,
    MVdbl: SDoubleArray,
    MVcur: SCurrencyArray,
    MVat: SAppTimeArray,
    MVft: SDateTimeArray,
    MVbin: SBinaryArray,
    MVszA: SLPSTRArray,
    MVszW: SWStringArray,
    MVguid: SGuidArray,
    MVli: SLargeIntegerArray,
    err: i32,
    x: i32,
};

const SPropValue = extern struct {
    ulPropTag: u32,
    dwAlignPad: u32,
    Value: __UPV,
};

type
  CY {.bycopy.} = object
    Anonymous: _Anonymous_e__Struct
    int64: int64

  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  SBinary {.bycopy.} = object
    cb: uint32
    lpb: pointer

  SShortArray {.bycopy.} = object
    cValues: uint32
    lpi: pointer

  SLongArray {.bycopy.} = object
    cValues: uint32
    lpl: pointer

  SRealArray {.bycopy.} = object
    cValues: uint32
    lpflt: pointer

  SDoubleArray {.bycopy.} = object
    cValues: uint32
    lpdbl: pointer

  SCurrencyArray {.bycopy.} = object
    cValues: uint32
    lpcur: pointer

  SAppTimeArray {.bycopy.} = object
    cValues: uint32
    lpat: pointer

  SDateTimeArray {.bycopy.} = object
    cValues: uint32
    lpft: pointer

  SBinaryArray {.bycopy.} = object
    cValues: uint32
    lpbin: pointer

  SLPSTRArray {.bycopy.} = object
    cValues: uint32
    lppszA: pointer

  SWStringArray {.bycopy.} = object
    cValues: uint32
    lppszW: pointer

  SGuidArray {.bycopy.} = object
    cValues: uint32
    lpguid: pointer

  SLargeIntegerArray {.bycopy.} = object
    cValues: uint32
    lpli: pointer

  __UPV {.bycopy.} = object
    i: int16
    l: int32
    ul: uint32
    flt: float32
    dbl: float64
    b: uint16
    cur: CY
    at: float64
    ft: FILETIME
    lpszA: pointer
    bin: SBinary
    lpszW: pointer
    lpguid: pointer
    li: int64
    MVi: SShortArray
    MVl: SLongArray
    MVflt: SRealArray
    MVdbl: SDoubleArray
    MVcur: SCurrencyArray
    MVat: SAppTimeArray
    MVft: SDateTimeArray
    MVbin: SBinaryArray
    MVszA: SLPSTRArray
    MVszW: SWStringArray
    MVguid: SGuidArray
    MVli: SLargeIntegerArray
    err: int32
    x: int32

  SPropValue {.bycopy.} = object
    ulPropTag: uint32
    dwAlignPad: uint32
    Value: __UPV

struct CY
{
    _Anonymous_e__Struct Anonymous;
    long int64;
}

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct SBinary
{
    uint cb;
    void* lpb;
}

struct SShortArray
{
    uint cValues;
    void* lpi;
}

struct SLongArray
{
    uint cValues;
    void* lpl;
}

struct SRealArray
{
    uint cValues;
    void* lpflt;
}

struct SDoubleArray
{
    uint cValues;
    void* lpdbl;
}

struct SCurrencyArray
{
    uint cValues;
    void* lpcur;
}

struct SAppTimeArray
{
    uint cValues;
    void* lpat;
}

struct SDateTimeArray
{
    uint cValues;
    void* lpft;
}

struct SBinaryArray
{
    uint cValues;
    void* lpbin;
}

struct SLPSTRArray
{
    uint cValues;
    void* lppszA;
}

struct SWStringArray
{
    uint cValues;
    void* lppszW;
}

struct SGuidArray
{
    uint cValues;
    void* lpguid;
}

struct SLargeIntegerArray
{
    uint cValues;
    void* lpli;
}

struct __UPV
{
    short i;
    int l;
    uint ul;
    float flt;
    double dbl;
    ushort b;
    CY cur;
    double at;
    FILETIME ft;
    void* lpszA;
    SBinary bin;
    void* lpszW;
    void* lpguid;
    long li;
    SShortArray MVi;
    SLongArray MVl;
    SRealArray MVflt;
    SDoubleArray MVdbl;
    SCurrencyArray MVcur;
    SAppTimeArray MVat;
    SDateTimeArray MVft;
    SBinaryArray MVbin;
    SLPSTRArray MVszA;
    SWStringArray MVszW;
    SGuidArray MVguid;
    SLargeIntegerArray MVli;
    int err;
    int x;
}

struct SPropValue
{
    uint ulPropTag;
    uint dwAlignPad;
    __UPV Value;
}

HSP用定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; SPropValue サイズ: 16 バイト(x86)
dim st, 4    ; 4byte整数×4(構造体サイズ 16 / 4 切り上げ)
; ulPropTag : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; dwAlignPad : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; Value : __UPV (+8, 8byte)  varptr(st)+8 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; SPropValue サイズ: 24 バイト(x64)
dim st, 6    ; 4byte整数×6(構造体サイズ 24 / 4 切り上げ)
; ulPropTag : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; dwAlignPad : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; Value : __UPV (+8, 16byte)  varptr(st)+8 を基点に操作(16byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global SPropValue
    #field int ulPropTag
    #field int dwAlignPad
    #field byte Value 16
#endstruct

stdim st, SPropValue        ; NSTRUCT 変数を確保
st->ulPropTag = 100
mes "ulPropTag=" + st->ulPropTag
; ※union フィールドは byte 列で確保(NSTRUCT は union 非対応)。必要に応じ手動でアクセス。

SPropValue

フィールド

各言語での定義

HSP用 定義

HSP用定義