ホーム › Networking.Clustering › CLUSPROP_BUFFER_HELPER

CLUSPROP_BUFFER_HELPER

共用体

サイズx64: 8 バイト / x86: 4 バイト

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

フィールド

フィールド	型	サイズ	x64	x86	説明
pb	BYTE*	8/4	+0	+0	バイトの配列を格納するバッファーへのポインターです。
pw	WORD*	8/4	+0	+0	WORD 値の配列を格納するバッファーへのポインターです。
pdw	DWORD*	8/4	+0	+0	DWORD 値の配列を格納するバッファーへのポインターです。
pl	INT*	8/4	+0	+0	符号付き long 値の配列を格納するバッファーへのポインターです。
psz	LPWSTR	8/4	+0	+0	NULL 終端の Unicode 文字列値を格納するバッファーへのポインターです。
pList	CLUSPROP_LIST*	8/4	+0	+0	プロパティリストの先頭を記述する CLUSPROP_LIST 構造体へのポインターです。
pSyntax	CLUSPROP_SYNTAX*	8/4	+0	+0	値の形式と型を記述する CLUSPROP_SYNTAX 構造体へのポインターです。
pName	CLUSPROP_SZ*	8/4	+0	+0	プロパティ名の値を格納する CLUSPROP_PROPERTY_NAME 構造体へのポインターです。
pValue	CLUSPROP_VALUE*	8/4	+0	+0	データ値の形式、型、および長さを記述する CLUSPROP_VALUE 構造体へのポインターです。
pBinaryValue	CLUSPROP_BINARY*	8/4	+0	+0	バイナリデータの値を格納する CLUSPROP_BINARY 構造体へのポインターです。
pWordValue	CLUSPROP_WORD*	8/4	+0	+0	数値を格納する CLUSPROP_WORD 構造体へのポインターです。
pDwordValue	CLUSPROP_DWORD*	8/4	+0	+0	数値を格納する CLUSPROP_DWORD 構造体へのポインターです。
pLongValue	CLUSPROP_LONG*	8/4	+0	+0	符号付き long 値を格納する CLUSPROP_LONG 構造体へのポインターです。
pULargeIntegerValue	CLUSPROP_ULARGE_INTEGER*	8/4	+0	+0	符号なしの大きな整数値を格納する CLUSPROP_ULARGE_INTEGER 構造体へのポインターです。
pLargeIntegerValue	CLUSPROP_LARGE_INTEGER*	8/4	+0	+0	大きな整数値を格納する CLUSPROP_LARGE_INTEGER 構造体へのポインターです。
pStringValue	CLUSPROP_SZ*	8/4	+0	+0	NULL 終端の Unicode 文字列値を格納する CLUSPROP_SZ 構造体へのポインターです。
pMultiSzValue	CLUSPROP_SZ*	8/4	+0	+0	複数の null 終端 Unicode 文字列値を格納する CLUSPROP_MULTI_SZ 構造体へのポインターです。
pSecurityDescriptor	CLUSPROP_SECURITY_DESCRIPTOR*	8/4	+0	+0	セキュリティ記述子を格納する CLUSPROP_SECURITY_DESCRIPTOR 構造体へのポインターです。
pResourceClassValue	CLUSPROP_RESOURCE_CLASS*	8/4	+0	+0	リソースクラスの値を格納する CLUSPROP_RESOURCE_CLASS 構造体へのポインターです。
pResourceClassInfoValue	CLUSPROP_RESOURCE_CLASS_INFO*	8/4	+0	+0	リソースクラス情報の値を格納する CLUSPROP_RESOURCE_CLASS_INFO 構造体へのポインターです。
pDiskSignatureValue	CLUSPROP_DWORD*	8/4	+0	+0	ディスクシグネチャの値を格納する CLUSPROP_DISK_SIGNATURE 構造体へのポインターです。
pScsiAddressValue	CLUSPROP_SCSI_ADDRESS*	8/4	+0	+0	SCSI アドレスの値を格納する CLUSPROP_SCSI_ADDRESS 構造体へのポインターです。
pDiskNumberValue	CLUSPROP_DWORD*	8/4	+0	+0	ディスク番号の値を格納する CLUSPROP_DISK_NUMBER 構造体へのポインターです。
pPartitionInfoValue	CLUSPROP_PARTITION_INFO*	8/4	+0	+0	パーティション情報の値を格納する CLUSPROP_PARTITION_INFO 構造体へのポインターです。
pRequiredDependencyValue	CLUSPROP_REQUIRED_DEPENDENCY*	8/4	+0	+0	リソースの依存関係の値を格納する CLUSPROP_REQUIRED_DEPENDENCY 構造体へのポインターです。
pPartitionInfoValueEx	CLUSPROP_PARTITION_INFO_EX*	8/4	+0	+0	パーティション情報の値を格納する CLUSPROP_PARTITION_INFO_EX 構造体へのポインターです。
pPartitionInfoValueEx2	CLUSPROP_PARTITION_INFO_EX2*	8/4	+0	+0	パーティション情報の値を格納する CLUSPROP_PARTITION_INFO_EX2 構造体へのポインターです。 Windows Server 2012 R2、Windows Server 2012、Windows Server 2008 R2、および Windows Server 2008: このメンバーは Windows Server 2016 より前では使用できません。
pFileTimeValue	CLUSPROP_FILETIME*	8/4	+0	+0	日付/時刻の値を格納する CLUSPROP_FILETIME 構造体へのポインターです。

公式ドキュメント

プロパティリストまたは値リストの構築や解析に使用します。

解説(Remarks)

CLUSPROP_BUFFER_HELPER 構造体は、プロパティリストや値リストを扱う際に役立ちます。アプリケーションは汎用の CLUSPROP_BUFFER_HELPER ポインターを使用して、プロパティリストまたは値リストのエントリをオフセット単位でたどり、適切なデータ型へキャストすることなく値を取得または設定できます。

複数のプロパティを扱う場合は、代替の構造体である RESUTIL_PROPERTY_ITEM を使用することもできます。

値リスト、プロパティリスト、パラメーターブロックのような DWORD 境界に整列された構造体で large integer 値を参照する場合は注意してください。Itanium ベースのシステム向け Windows Server では、自然に整列された large integer 値は常に 0 または 8h で終わるアドレスから始まります。DWORD 単位の整列では、大きな値が整列されていない境界(4h または C で終わるアドレス)から始まる場合があり、そのデータを読み書きするとアライメントフォールトが発生します。大きな値の上位部分と下位部分を別々に扱うか、必ず自然に整列されることが保証されるローカル変数を使用することで、アライメントフォールトを回避できます。

例

次の例のほか、プロパティリストの作成、プロパティリストの解析、値リストの作成、および値リストの解析も参照してください。

//////////////////////////////////////////////////////////////////////
//  
//    HOW TO USE CLUSPROP_BUFFER HELPER
//  
//    (1) Position cbh to the next read or write location.
//    (2) Read or write data using an appropriate pointer.
//    (3) Check position within buffer.
//  
//    Repeat (1)(2)(3)
//    
//////////////////////////////////////////////////////////////////////
void ClusDocEx_UsingCBH()
{
    LPVOID lp = LocalAlloc( LPTR, 100 ); // It is important for cbh
                                         // to know the allocated
                                         // size.
    CLUSPROP_BUFFER_HELPER cbh;

   
// ( 1 )
//
//    Position cbh.  The pb member is convenient for
//    targeting single bytes.
//

      cbh.pb = (LPBYTE) lp;     


//
//    The pb member points to the first byte of lp.
//
//    lp -----> 0 0 0 0 0 0 0 0 0 0 0 ... 0 
//
//    cbh.pb-->|-|
//
//
//    Note what happens when different cbh pointer types are used:
//
//                   lp -----> 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 
//
//    cbh.pdw              -->|-------|
//    cbh.psz              -->|-|
//    cbh.pValue           -->|---------------|
//    cbh.pValue->Syntax.dw-->|-------|
//    cbh.pValue->cbLength         -->|-------|
//
//
//    The configuration of bytes that will be affected by a read
//    or write operation depends on the type of pointer used.
//


// ( 2 )
//
//    Read or write data to the present location.  Note how the
//    structure pointers let you "reach over" intervening members.
//

      cbh.pValue->Syntax.dw = CLUSPROP_SYNTAX_LIST_VALUE_DWORD; 
    
      cbh.pValue->cbLength = sizeof( DWORD );

      cbh.pDwordValue->dw  = 0x0000EEEEL;

//
//    Result:   lp ----->| syntax | length |  value  | 0 0 0 0 ... 0 
//


// ( 3 )
//
//    Check your remaining space.  Be sure you have room to advance
//    cbh past the current data and perform a read operation on the
//    next value.
//
      
      DWORD cbPosition = cbh.pb - (LPBYTE) lp;

      DWORD cbAdvance = ClusDocEx_ListEntrySize( sizeof( DWORD ) );  // See "ClusDocEx.h"

      if( ( cbPosition + cbAdvance + sizeof( DWORD ) ) > 100 )
      {
          // handle the fact that there's more data than the reported size of the buffer
      }

//
//    Repeat ( 1 ), ( 2 ), and ( 3 ) for the next value:
// 

      // Position cbh

      cbh.pb += cbAdvance;


      // Write next entry

      cbh.pStringValue->Syntax.dw = CLUSPROP_SYNTAX_LIST_VALUE_SZ;

      cbh.pStringValue->cbLength = ( lstrlenW( L"String Value" ) + 1 ) * sizeof( WCHAR );
      
      StringCchCopyW( cbh.pStringValue->sz, cbh.pStringValue->cbLength, L"String Value" );


      // Check space
      
      cbPosition = cbh.pb - (LPBYTE) lp;

      cbAdvance = ClusDocEx_ListEntrySize( cbh.pStringValue->cbLength ); 

      if( ( cbPosition + cbAdvance + sizeof( DWORD ) ) > 100 )
      {
          // 
      }

//
//    Repeat ( 1 ), ( 2 ), and ( 3 )  until all values have been written or read.
//


      cbh.pb = NULL;

      LocalFree( lp );
}

出典・ライセンス: 上記「公式ドキュメント」の内容は Microsoft の Win32 API ドキュメント(MicrosoftDocs/sdk-api)を日本語に翻訳・改変したものです。© Microsoft Corporation. CC BY 4.0 で提供。
Microsoft 公式リファレンス: 英語 (en-us) · 日本語 (ja-jp) · 原文ソース (GitHub)

各言語での定義

#include <windows.h>

// CLUSPROP_BUFFER_HELPER  (x64 8 / x86 4 バイト)
typedef struct CLUSPROP_BUFFER_HELPER {
    BYTE* pb;
    WORD* pw;
    DWORD* pdw;
    INT* pl;
    LPWSTR psz;
    CLUSPROP_LIST* pList;
    CLUSPROP_SYNTAX* pSyntax;
    CLUSPROP_SZ* pName;
    CLUSPROP_VALUE* pValue;
    CLUSPROP_BINARY* pBinaryValue;
    CLUSPROP_WORD* pWordValue;
    CLUSPROP_DWORD* pDwordValue;
    CLUSPROP_LONG* pLongValue;
    CLUSPROP_ULARGE_INTEGER* pULargeIntegerValue;
    CLUSPROP_LARGE_INTEGER* pLargeIntegerValue;
    CLUSPROP_SZ* pStringValue;
    CLUSPROP_SZ* pMultiSzValue;
    CLUSPROP_SECURITY_DESCRIPTOR* pSecurityDescriptor;
    CLUSPROP_RESOURCE_CLASS* pResourceClassValue;
    CLUSPROP_RESOURCE_CLASS_INFO* pResourceClassInfoValue;
    CLUSPROP_DWORD* pDiskSignatureValue;
    CLUSPROP_SCSI_ADDRESS* pScsiAddressValue;
    CLUSPROP_DWORD* pDiskNumberValue;
    CLUSPROP_PARTITION_INFO* pPartitionInfoValue;
    CLUSPROP_REQUIRED_DEPENDENCY* pRequiredDependencyValue;
    CLUSPROP_PARTITION_INFO_EX* pPartitionInfoValueEx;
    CLUSPROP_PARTITION_INFO_EX2* pPartitionInfoValueEx2;
    CLUSPROP_FILETIME* pFileTimeValue;
} CLUSPROP_BUFFER_HELPER;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CLUSPROP_BUFFER_HELPER
{
    public IntPtr pb;
    public IntPtr pw;
    public IntPtr pdw;
    public IntPtr pl;
    public IntPtr psz;
    public IntPtr pList;
    public IntPtr pSyntax;
    public IntPtr pName;
    public IntPtr pValue;
    public IntPtr pBinaryValue;
    public IntPtr pWordValue;
    public IntPtr pDwordValue;
    public IntPtr pLongValue;
    public IntPtr pULargeIntegerValue;
    public IntPtr pLargeIntegerValue;
    public IntPtr pStringValue;
    public IntPtr pMultiSzValue;
    public IntPtr pSecurityDescriptor;
    public IntPtr pResourceClassValue;
    public IntPtr pResourceClassInfoValue;
    public IntPtr pDiskSignatureValue;
    public IntPtr pScsiAddressValue;
    public IntPtr pDiskNumberValue;
    public IntPtr pPartitionInfoValue;
    public IntPtr pRequiredDependencyValue;
    public IntPtr pPartitionInfoValueEx;
    public IntPtr pPartitionInfoValueEx2;
    public IntPtr pFileTimeValue;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CLUSPROP_BUFFER_HELPER
    Public pb As IntPtr
    Public pw As IntPtr
    Public pdw As IntPtr
    Public pl As IntPtr
    Public psz As IntPtr
    Public pList As IntPtr
    Public pSyntax As IntPtr
    Public pName As IntPtr
    Public pValue As IntPtr
    Public pBinaryValue As IntPtr
    Public pWordValue As IntPtr
    Public pDwordValue As IntPtr
    Public pLongValue As IntPtr
    Public pULargeIntegerValue As IntPtr
    Public pLargeIntegerValue As IntPtr
    Public pStringValue As IntPtr
    Public pMultiSzValue As IntPtr
    Public pSecurityDescriptor As IntPtr
    Public pResourceClassValue As IntPtr
    Public pResourceClassInfoValue As IntPtr
    Public pDiskSignatureValue As IntPtr
    Public pScsiAddressValue As IntPtr
    Public pDiskNumberValue As IntPtr
    Public pPartitionInfoValue As IntPtr
    Public pRequiredDependencyValue As IntPtr
    Public pPartitionInfoValueEx As IntPtr
    Public pPartitionInfoValueEx2 As IntPtr
    Public pFileTimeValue As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class CLUSPROP_BUFFER_HELPER(ctypes.Structure):
    _fields_ = [
        ("pb", ctypes.c_void_p),
        ("pw", ctypes.c_void_p),
        ("pdw", ctypes.c_void_p),
        ("pl", ctypes.c_void_p),
        ("psz", ctypes.c_void_p),
        ("pList", ctypes.c_void_p),
        ("pSyntax", ctypes.c_void_p),
        ("pName", ctypes.c_void_p),
        ("pValue", ctypes.c_void_p),
        ("pBinaryValue", ctypes.c_void_p),
        ("pWordValue", ctypes.c_void_p),
        ("pDwordValue", ctypes.c_void_p),
        ("pLongValue", ctypes.c_void_p),
        ("pULargeIntegerValue", ctypes.c_void_p),
        ("pLargeIntegerValue", ctypes.c_void_p),
        ("pStringValue", ctypes.c_void_p),
        ("pMultiSzValue", ctypes.c_void_p),
        ("pSecurityDescriptor", ctypes.c_void_p),
        ("pResourceClassValue", ctypes.c_void_p),
        ("pResourceClassInfoValue", ctypes.c_void_p),
        ("pDiskSignatureValue", ctypes.c_void_p),
        ("pScsiAddressValue", ctypes.c_void_p),
        ("pDiskNumberValue", ctypes.c_void_p),
        ("pPartitionInfoValue", ctypes.c_void_p),
        ("pRequiredDependencyValue", ctypes.c_void_p),
        ("pPartitionInfoValueEx", ctypes.c_void_p),
        ("pPartitionInfoValueEx2", ctypes.c_void_p),
        ("pFileTimeValue", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct CLUSPROP_BUFFER_HELPER {
    pub pb: *mut core::ffi::c_void,
    pub pw: *mut core::ffi::c_void,
    pub pdw: *mut core::ffi::c_void,
    pub pl: *mut core::ffi::c_void,
    pub psz: *mut core::ffi::c_void,
    pub pList: *mut core::ffi::c_void,
    pub pSyntax: *mut core::ffi::c_void,
    pub pName: *mut core::ffi::c_void,
    pub pValue: *mut core::ffi::c_void,
    pub pBinaryValue: *mut core::ffi::c_void,
    pub pWordValue: *mut core::ffi::c_void,
    pub pDwordValue: *mut core::ffi::c_void,
    pub pLongValue: *mut core::ffi::c_void,
    pub pULargeIntegerValue: *mut core::ffi::c_void,
    pub pLargeIntegerValue: *mut core::ffi::c_void,
    pub pStringValue: *mut core::ffi::c_void,
    pub pMultiSzValue: *mut core::ffi::c_void,
    pub pSecurityDescriptor: *mut core::ffi::c_void,
    pub pResourceClassValue: *mut core::ffi::c_void,
    pub pResourceClassInfoValue: *mut core::ffi::c_void,
    pub pDiskSignatureValue: *mut core::ffi::c_void,
    pub pScsiAddressValue: *mut core::ffi::c_void,
    pub pDiskNumberValue: *mut core::ffi::c_void,
    pub pPartitionInfoValue: *mut core::ffi::c_void,
    pub pRequiredDependencyValue: *mut core::ffi::c_void,
    pub pPartitionInfoValueEx: *mut core::ffi::c_void,
    pub pPartitionInfoValueEx2: *mut core::ffi::c_void,
    pub pFileTimeValue: *mut core::ffi::c_void,
}

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

type CLUSPROP_BUFFER_HELPER struct {
	pb uintptr
	pw uintptr
	pdw uintptr
	pl uintptr
	psz uintptr
	pList uintptr
	pSyntax uintptr
	pName uintptr
	pValue uintptr
	pBinaryValue uintptr
	pWordValue uintptr
	pDwordValue uintptr
	pLongValue uintptr
	pULargeIntegerValue uintptr
	pLargeIntegerValue uintptr
	pStringValue uintptr
	pMultiSzValue uintptr
	pSecurityDescriptor uintptr
	pResourceClassValue uintptr
	pResourceClassInfoValue uintptr
	pDiskSignatureValue uintptr
	pScsiAddressValue uintptr
	pDiskNumberValue uintptr
	pPartitionInfoValue uintptr
	pRequiredDependencyValue uintptr
	pPartitionInfoValueEx uintptr
	pPartitionInfoValueEx2 uintptr
	pFileTimeValue uintptr
}

type
  CLUSPROP_BUFFER_HELPER = record
    pb: Pointer;
    pw: Pointer;
    pdw: Pointer;
    pl: Pointer;
    psz: Pointer;
    pList: Pointer;
    pSyntax: Pointer;
    pName: Pointer;
    pValue: Pointer;
    pBinaryValue: Pointer;
    pWordValue: Pointer;
    pDwordValue: Pointer;
    pLongValue: Pointer;
    pULargeIntegerValue: Pointer;
    pLargeIntegerValue: Pointer;
    pStringValue: Pointer;
    pMultiSzValue: Pointer;
    pSecurityDescriptor: Pointer;
    pResourceClassValue: Pointer;
    pResourceClassInfoValue: Pointer;
    pDiskSignatureValue: Pointer;
    pScsiAddressValue: Pointer;
    pDiskNumberValue: Pointer;
    pPartitionInfoValue: Pointer;
    pRequiredDependencyValue: Pointer;
    pPartitionInfoValueEx: Pointer;
    pPartitionInfoValueEx2: Pointer;
    pFileTimeValue: Pointer;
  end;

const CLUSPROP_BUFFER_HELPER = extern struct {
    pb: ?*anyopaque,
    pw: ?*anyopaque,
    pdw: ?*anyopaque,
    pl: ?*anyopaque,
    psz: ?*anyopaque,
    pList: ?*anyopaque,
    pSyntax: ?*anyopaque,
    pName: ?*anyopaque,
    pValue: ?*anyopaque,
    pBinaryValue: ?*anyopaque,
    pWordValue: ?*anyopaque,
    pDwordValue: ?*anyopaque,
    pLongValue: ?*anyopaque,
    pULargeIntegerValue: ?*anyopaque,
    pLargeIntegerValue: ?*anyopaque,
    pStringValue: ?*anyopaque,
    pMultiSzValue: ?*anyopaque,
    pSecurityDescriptor: ?*anyopaque,
    pResourceClassValue: ?*anyopaque,
    pResourceClassInfoValue: ?*anyopaque,
    pDiskSignatureValue: ?*anyopaque,
    pScsiAddressValue: ?*anyopaque,
    pDiskNumberValue: ?*anyopaque,
    pPartitionInfoValue: ?*anyopaque,
    pRequiredDependencyValue: ?*anyopaque,
    pPartitionInfoValueEx: ?*anyopaque,
    pPartitionInfoValueEx2: ?*anyopaque,
    pFileTimeValue: ?*anyopaque,
};

type
  CLUSPROP_BUFFER_HELPER {.bycopy.} = object
    pb: pointer
    pw: pointer
    pdw: pointer
    pl: pointer
    psz: pointer
    pList: pointer
    pSyntax: pointer
    pName: pointer
    pValue: pointer
    pBinaryValue: pointer
    pWordValue: pointer
    pDwordValue: pointer
    pLongValue: pointer
    pULargeIntegerValue: pointer
    pLargeIntegerValue: pointer
    pStringValue: pointer
    pMultiSzValue: pointer
    pSecurityDescriptor: pointer
    pResourceClassValue: pointer
    pResourceClassInfoValue: pointer
    pDiskSignatureValue: pointer
    pScsiAddressValue: pointer
    pDiskNumberValue: pointer
    pPartitionInfoValue: pointer
    pRequiredDependencyValue: pointer
    pPartitionInfoValueEx: pointer
    pPartitionInfoValueEx2: pointer
    pFileTimeValue: pointer

struct CLUSPROP_BUFFER_HELPER
{
    void* pb;
    void* pw;
    void* pdw;
    void* pl;
    void* psz;
    void* pList;
    void* pSyntax;
    void* pName;
    void* pValue;
    void* pBinaryValue;
    void* pWordValue;
    void* pDwordValue;
    void* pLongValue;
    void* pULargeIntegerValue;
    void* pLargeIntegerValue;
    void* pStringValue;
    void* pMultiSzValue;
    void* pSecurityDescriptor;
    void* pResourceClassValue;
    void* pResourceClassInfoValue;
    void* pDiskSignatureValue;
    void* pScsiAddressValue;
    void* pDiskNumberValue;
    void* pPartitionInfoValue;
    void* pRequiredDependencyValue;
    void* pPartitionInfoValueEx;
    void* pPartitionInfoValueEx2;
    void* pFileTimeValue;
}

HSP用定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; CLUSPROP_BUFFER_HELPER サイズ: 4 バイト(x86)
dim st, 1    ; 4byte整数×1(構造体サイズ 4 / 4 切り上げ)
; pb : BYTE* (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; pw : WORD* (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; pdw : DWORD* (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; pl : INT* (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; psz : LPWSTR (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; pList : CLUSPROP_LIST* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pSyntax : CLUSPROP_SYNTAX* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pName : CLUSPROP_SZ* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pValue : CLUSPROP_VALUE* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pBinaryValue : CLUSPROP_BINARY* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pWordValue : CLUSPROP_WORD* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pDwordValue : CLUSPROP_DWORD* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pLongValue : CLUSPROP_LONG* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pULargeIntegerValue : CLUSPROP_ULARGE_INTEGER* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pLargeIntegerValue : CLUSPROP_LARGE_INTEGER* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pStringValue : CLUSPROP_SZ* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pMultiSzValue : CLUSPROP_SZ* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pSecurityDescriptor : CLUSPROP_SECURITY_DESCRIPTOR* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pResourceClassValue : CLUSPROP_RESOURCE_CLASS* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pResourceClassInfoValue : CLUSPROP_RESOURCE_CLASS_INFO* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pDiskSignatureValue : CLUSPROP_DWORD* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pScsiAddressValue : CLUSPROP_SCSI_ADDRESS* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pDiskNumberValue : CLUSPROP_DWORD* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pPartitionInfoValue : CLUSPROP_PARTITION_INFO* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pRequiredDependencyValue : CLUSPROP_REQUIRED_DEPENDENCY* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pPartitionInfoValueEx : CLUSPROP_PARTITION_INFO_EX* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pPartitionInfoValueEx2 : CLUSPROP_PARTITION_INFO_EX2* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; pFileTimeValue : CLUSPROP_FILETIME* (+0, 4byte)  varptr(st)+0 を基点に操作(4byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; CLUSPROP_BUFFER_HELPER サイズ: 8 バイト(x64)
dim st, 2    ; 4byte整数×2(構造体サイズ 8 / 4 切り上げ)
; pb : BYTE* (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; pw : WORD* (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; pdw : DWORD* (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; pl : INT* (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; psz : LPWSTR (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; pList : CLUSPROP_LIST* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pSyntax : CLUSPROP_SYNTAX* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pName : CLUSPROP_SZ* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pValue : CLUSPROP_VALUE* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pBinaryValue : CLUSPROP_BINARY* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pWordValue : CLUSPROP_WORD* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pDwordValue : CLUSPROP_DWORD* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pLongValue : CLUSPROP_LONG* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pULargeIntegerValue : CLUSPROP_ULARGE_INTEGER* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pLargeIntegerValue : CLUSPROP_LARGE_INTEGER* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pStringValue : CLUSPROP_SZ* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pMultiSzValue : CLUSPROP_SZ* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pSecurityDescriptor : CLUSPROP_SECURITY_DESCRIPTOR* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pResourceClassValue : CLUSPROP_RESOURCE_CLASS* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pResourceClassInfoValue : CLUSPROP_RESOURCE_CLASS_INFO* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pDiskSignatureValue : CLUSPROP_DWORD* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pScsiAddressValue : CLUSPROP_SCSI_ADDRESS* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pDiskNumberValue : CLUSPROP_DWORD* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pPartitionInfoValue : CLUSPROP_PARTITION_INFO* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pRequiredDependencyValue : CLUSPROP_REQUIRED_DEPENDENCY* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pPartitionInfoValueEx : CLUSPROP_PARTITION_INFO_EX* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pPartitionInfoValueEx2 : CLUSPROP_PARTITION_INFO_EX2* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; pFileTimeValue : CLUSPROP_FILETIME* (+0, 8byte)  varptr(st)+0 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
#defstruct global CLUSPROP_BUFFER_HELPER
    #field intptr pb
    #field intptr pw
    #field intptr pdw
    #field intptr pl
    #field intptr psz
    #field intptr pList
    #field intptr pSyntax
    #field intptr pName
    #field intptr pValue
    #field intptr pBinaryValue
    #field intptr pWordValue
    #field intptr pDwordValue
    #field intptr pLongValue
    #field intptr pULargeIntegerValue
    #field intptr pLargeIntegerValue
    #field intptr pStringValue
    #field intptr pMultiSzValue
    #field intptr pSecurityDescriptor
    #field intptr pResourceClassValue
    #field intptr pResourceClassInfoValue
    #field intptr pDiskSignatureValue
    #field intptr pScsiAddressValue
    #field intptr pDiskNumberValue
    #field intptr pPartitionInfoValue
    #field intptr pRequiredDependencyValue
    #field intptr pPartitionInfoValueEx
    #field intptr pPartitionInfoValueEx2
    #field intptr pFileTimeValue
#endstruct

stdim st, CLUSPROP_BUFFER_HELPER        ; NSTRUCT 変数を確保