RMTPACK

構造体

サイズx64: 84 バイト / x86: 56 バイトパッキング2

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

フィールド

フィールド	型	サイズ	x64	x86	説明
pISeqStream	ISequentialStream*	8/4	+0	+0	シリアライズデータの順次ストリーム(ISequentialStream)へのポインタ。NULL可。
cbData	DWORD	4	+8	+4	ストリームデータのサイズ(バイト数)。
cBSTR	DWORD	4	+12	+8	rgBSTR配列に含まれるBSTRの個数。
rgBSTR	LPWSTR*	8/4	+16	+12	BSTR(ワイド文字列)配列へのポインタ。
cVARIANT	DWORD	4	+24	+16	rgVARIANT配列に含まれるVARIANTの個数。
rgVARIANT	VARIANT*	8/4	+28	+20	VARIANT配列へのポインタ。
cIDISPATCH	DWORD	4	+36	+24	rgIDISPATCH配列に含まれるIDispatchの個数。
rgIDISPATCH	IDispatch**	8/4	+40	+28	IDispatchインターフェイスポインタ配列へのポインタ。
cIUNKNOWN	DWORD	4	+48	+32	rgIUNKNOWN配列に含まれるIUnknownの個数。
rgIUNKNOWN	IUnknown**	8/4	+52	+36	IUnknownインターフェイスポインタ配列へのポインタ。
cPROPVARIANT	DWORD	4	+60	+40	rgPROPVARIANT配列に含まれるPROPVARIANTの個数。
rgPROPVARIANT	PROPVARIANT*	8/4	+64	+44	PROPVARIANT配列へのポインタ。
cArray	DWORD	4	+72	+48	rgArray配列に含まれる要素の個数。
rgArray	VARIANT*	8/4	+76	+52	配列型(SAFEARRAY等)を保持するVARIANT配列へのポインタ。

各言語での定義

#include <windows.h>

// RMTPACK  (x64 84 / x86 56 バイト)
#pragma pack(push, 2)
typedef struct RMTPACK {
    ISequentialStream* pISeqStream;
    DWORD cbData;
    DWORD cBSTR;
    LPWSTR* rgBSTR;
    DWORD cVARIANT;
    VARIANT* rgVARIANT;
    DWORD cIDISPATCH;
    IDispatch** rgIDISPATCH;
    DWORD cIUNKNOWN;
    IUnknown** rgIUNKNOWN;
    DWORD cPROPVARIANT;
    PROPVARIANT* rgPROPVARIANT;
    DWORD cArray;
    VARIANT* rgArray;
} RMTPACK;
#pragma pack(pop)

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 2, CharSet = CharSet.Unicode)]
public struct RMTPACK
{
    public IntPtr pISeqStream;
    public uint cbData;
    public uint cBSTR;
    public IntPtr rgBSTR;
    public uint cVARIANT;
    public IntPtr rgVARIANT;
    public uint cIDISPATCH;
    public IntPtr rgIDISPATCH;
    public uint cIUNKNOWN;
    public IntPtr rgIUNKNOWN;
    public uint cPROPVARIANT;
    public IntPtr rgPROPVARIANT;
    public uint cArray;
    public IntPtr rgArray;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=2, CharSet:=CharSet.Unicode)>
Public Structure RMTPACK
    Public pISeqStream As IntPtr
    Public cbData As UInteger
    Public cBSTR As UInteger
    Public rgBSTR As IntPtr
    Public cVARIANT As UInteger
    Public rgVARIANT As IntPtr
    Public cIDISPATCH As UInteger
    Public rgIDISPATCH As IntPtr
    Public cIUNKNOWN As UInteger
    Public rgIUNKNOWN As IntPtr
    Public cPROPVARIANT As UInteger
    Public rgPROPVARIANT As IntPtr
    Public cArray As UInteger
    Public rgArray As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class RMTPACK(ctypes.Structure):
    _pack_ = 2
    _fields_ = [
        ("pISeqStream", ctypes.c_void_p),
        ("cbData", wintypes.DWORD),
        ("cBSTR", wintypes.DWORD),
        ("rgBSTR", ctypes.c_void_p),
        ("cVARIANT", wintypes.DWORD),
        ("rgVARIANT", ctypes.c_void_p),
        ("cIDISPATCH", wintypes.DWORD),
        ("rgIDISPATCH", ctypes.c_void_p),
        ("cIUNKNOWN", wintypes.DWORD),
        ("rgIUNKNOWN", ctypes.c_void_p),
        ("cPROPVARIANT", wintypes.DWORD),
        ("rgPROPVARIANT", ctypes.c_void_p),
        ("cArray", wintypes.DWORD),
        ("rgArray", ctypes.c_void_p),
    ]

#[repr(C, packed(2))]
pub struct RMTPACK {
    pub pISeqStream: *mut core::ffi::c_void,
    pub cbData: u32,
    pub cBSTR: u32,
    pub rgBSTR: *mut core::ffi::c_void,
    pub cVARIANT: u32,
    pub rgVARIANT: *mut core::ffi::c_void,
    pub cIDISPATCH: u32,
    pub rgIDISPATCH: *mut core::ffi::c_void,
    pub cIUNKNOWN: u32,
    pub rgIUNKNOWN: *mut core::ffi::c_void,
    pub cPROPVARIANT: u32,
    pub rgPROPVARIANT: *mut core::ffi::c_void,
    pub cArray: u32,
    pub rgArray: *mut core::ffi::c_void,
}

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

type RMTPACK struct {
	pISeqStream uintptr
	cbData uint32
	cBSTR uint32
	rgBSTR uintptr
	cVARIANT uint32
	rgVARIANT uintptr
	cIDISPATCH uint32
	rgIDISPATCH uintptr
	cIUNKNOWN uint32
	rgIUNKNOWN uintptr
	cPROPVARIANT uint32
	rgPROPVARIANT uintptr
	cArray uint32
	rgArray uintptr
}

type
  RMTPACK = packed record
    pISeqStream: Pointer;
    cbData: DWORD;
    cBSTR: DWORD;
    rgBSTR: Pointer;
    cVARIANT: DWORD;
    rgVARIANT: Pointer;
    cIDISPATCH: DWORD;
    rgIDISPATCH: Pointer;
    cIUNKNOWN: DWORD;
    rgIUNKNOWN: Pointer;
    cPROPVARIANT: DWORD;
    rgPROPVARIANT: Pointer;
    cArray: DWORD;
    rgArray: Pointer;
  end;

const RMTPACK = extern struct {
    pISeqStream: ?*anyopaque,
    cbData: u32,
    cBSTR: u32,
    rgBSTR: ?*anyopaque,
    cVARIANT: u32,
    rgVARIANT: ?*anyopaque,
    cIDISPATCH: u32,
    rgIDISPATCH: ?*anyopaque,
    cIUNKNOWN: u32,
    rgIUNKNOWN: ?*anyopaque,
    cPROPVARIANT: u32,
    rgPROPVARIANT: ?*anyopaque,
    cArray: u32,
    rgArray: ?*anyopaque,
};

type
  RMTPACK {.packed.} = object
    pISeqStream: pointer
    cbData: uint32
    cBSTR: uint32
    rgBSTR: pointer
    cVARIANT: uint32
    rgVARIANT: pointer
    cIDISPATCH: uint32
    rgIDISPATCH: pointer
    cIUNKNOWN: uint32
    rgIUNKNOWN: pointer
    cPROPVARIANT: uint32
    rgPROPVARIANT: pointer
    cArray: uint32
    rgArray: pointer

align(2)
struct RMTPACK
{
    void* pISeqStream;
    uint cbData;
    uint cBSTR;
    void* rgBSTR;
    uint cVARIANT;
    void* rgVARIANT;
    uint cIDISPATCH;
    void* rgIDISPATCH;
    uint cIUNKNOWN;
    void* rgIUNKNOWN;
    uint cPROPVARIANT;
    void* rgPROPVARIANT;
    uint cArray;
    void* rgArray;
}

HSP用定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; RMTPACK サイズ: 56 バイト(x86)
dim st, 14    ; 4byte整数×14(構造体サイズ 56 / 4 切り上げ)
; pISeqStream : ISequentialStream* (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; cbData : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; cBSTR : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; rgBSTR : LPWSTR* (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; cVARIANT : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; rgVARIANT : VARIANT* (+20, 4byte)  varptr(st)+20 を基点に操作(4byte:入れ子/配列)
; cIDISPATCH : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; rgIDISPATCH : IDispatch** (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; cIUNKNOWN : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; rgIUNKNOWN : IUnknown** (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; cPROPVARIANT : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; rgPROPVARIANT : PROPVARIANT* (+44, 4byte)  varptr(st)+44 を基点に操作(4byte:入れ子/配列)
; cArray : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; rgArray : VARIANT* (+52, 4byte)  varptr(st)+52 を基点に操作(4byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; RMTPACK サイズ: 84 バイト(x64)
dim st, 21    ; 4byte整数×21(構造体サイズ 84 / 4 切り上げ)
; pISeqStream : ISequentialStream* (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; cbData : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; cBSTR : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; rgBSTR : LPWSTR* (+16, 8byte)  qpoke st,16,値 / qpeek(st,16)  ※IronHSPのみ。3.7/3.8は lpoke st,16,下位 : lpoke st,20,上位
; cVARIANT : DWORD (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; rgVARIANT : VARIANT* (+28, 8byte)  varptr(st)+28 を基点に操作(8byte:入れ子/配列)
; cIDISPATCH : DWORD (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; rgIDISPATCH : IDispatch** (+40, 8byte)  qpoke st,40,値 / qpeek(st,40)  ※IronHSPのみ。3.7/3.8は lpoke st,40,下位 : lpoke st,44,上位
; cIUNKNOWN : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; rgIUNKNOWN : IUnknown** (+52, 8byte)  qpoke st,52,値 / qpeek(st,52)  ※IronHSPのみ。3.7/3.8は lpoke st,52,下位 : lpoke st,56,上位
; cPROPVARIANT : DWORD (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; rgPROPVARIANT : PROPVARIANT* (+64, 8byte)  varptr(st)+64 を基点に操作(8byte:入れ子/配列)
; cArray : DWORD (+72, 4byte)  st.18 = 値  /  値 = st.18   (lpoke/lpeek も可)
; rgArray : VARIANT* (+76, 8byte)  varptr(st)+76 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global RMTPACK, pack=2
    #field intptr pISeqStream
    #field int cbData
    #field int cBSTR
    #field intptr rgBSTR
    #field int cVARIANT
    #field intptr rgVARIANT
    #field int cIDISPATCH
    #field intptr rgIDISPATCH
    #field int cIUNKNOWN
    #field intptr rgIUNKNOWN
    #field int cPROPVARIANT
    #field intptr rgPROPVARIANT
    #field int cArray
    #field intptr rgArray
#endstruct

stdim st, RMTPACK        ; NSTRUCT 変数を確保
st->cbData = 100
mes "cbData=" + st->cbData

RMTPACK

フィールド

各言語での定義

HSP用 定義

HSP用定義