d5/d2c/fieldoff_8c_source.html

#include "cdprocs.h"

#include <stdio.h>


#define doit(a,b) { printf("%s %04lx %4lx %s\n", #a, FIELD_OFFSET(a,b), sizeof(d.b), #b); }


VOID

__cdecl

main (argc, argv)

    int argc;

    char *argv[];

{

    printf("<Record>  <offset>  <size>  <field>\n\n");

    {

        CD_MCB d;

        doit( CD_MCB, MaximumEntryCount );

        doit( CD_MCB, CurrentEntryCount );

        doit( CD_MCB, McbArray );

    }

    printf("\n");

    {

        CD_MCB_ENTRY d;

        doit( CD_MCB_ENTRY, DiskOffset );

        doit( CD_MCB_ENTRY, ByteCount );

        doit( CD_MCB_ENTRY, FileOffset );

        doit( CD_MCB_ENTRY, DataBlockByteCount );

        doit( CD_MCB_ENTRY, TotalBlockByteCount );

    }

    printf("\n");

    {

        CD_NAME d;

        doit( CD_NAME, FileName );

        doit( CD_NAME, VersionString );

    }

    printf("\n");

    {

        NAME_LINK d;

        doit( NAME_LINK, Links );

        doit( NAME_LINK, FileName );

    }

    printf("\n");

    {

        PREFIX_ENTRY d;

        doit( PREFIX_ENTRY, Fcb );

        doit( PREFIX_ENTRY, PrefixFlags );

        doit( PREFIX_ENTRY, ExactCaseName );

        doit( PREFIX_ENTRY, IgnoreCaseName );

        doit( PREFIX_ENTRY, FileNameBuffer );

    }

    printf("\n");

    {

        CD_DATA d;

        doit( CD_DATA, NodeTypeCode );

        doit( CD_DATA, NodeByteSize );

        doit( CD_DATA, DriverObject );

        doit( CD_DATA, VcbQueue );

        doit( CD_DATA, IrpContextDepth );

        doit( CD_DATA, IrpContextMaxDepth );

        doit( CD_DATA, IrpContextList );

        doit( CD_DATA, FileSystemDeviceObject );

        doit( CD_DATA, AsyncCloseQueue );

        doit( CD_DATA, AsyncCloseCount );

        doit( CD_DATA, FspCloseActive );

        doit( CD_DATA, ReduceDelayedClose );

        doit( CD_DATA, PadUshort );

        doit( CD_DATA, DelayedCloseQueue );

        doit( CD_DATA, DelayedCloseCount );

        doit( CD_DATA, MinDelayedCloseCount );

        doit( CD_DATA, MaxDelayedCloseCount );

        doit( CD_DATA, CdDataLockThread );

        doit( CD_DATA, CdDataMutex );

        doit( CD_DATA, DataResource );

        doit( CD_DATA, CacheManagerCallbacks );

        doit( CD_DATA, CacheManagerVolumeCallbacks );

        doit( CD_DATA, CloseItem );

    }

    printf("\n");

    {

        VCB d;

        doit( VCB, NodeTypeCode );

        doit( VCB, NodeByteSize );

        doit( VCB, Vpb );

        doit( VCB, TargetDeviceObject );

        doit( VCB, VolumeLockFileObject );

        doit( VCB, VcbLinks );

        doit( VCB, VcbState );

        doit( VCB, VcbCondition );

        doit( VCB, VcbCleanup );

        doit( VCB, VcbReference );

        doit( VCB, VcbUserReference );

        doit( VCB, VolumeDasdFcb );

        doit( VCB, RootIndexFcb );

        doit( VCB, PathTableFcb );

        doit( VCB, BaseSector );

        doit( VCB, VdSectorOffset );

        doit( VCB, PrimaryVdSectorOffset );

        doit( VCB, XASector );

        doit( VCB, XADiskOffset );

        doit( VCB, VcbResource );

        doit( VCB, FileResource );

        doit( VCB, VcbMutex );

        doit( VCB, VcbLockThread );

        doit( VCB, NotifySync );

        doit( VCB, DirNotifyList );

        doit( VCB, BlockSize );

        doit( VCB, BlockToSectorShift );

        doit( VCB, BlockToByteShift );

        doit( VCB, BlocksPerSector );

        doit( VCB, BlockMask );

        doit( VCB, BlockInverseMask );

        doit( VCB, FcbTable );

        doit( VCB, CdromToc );

        doit( VCB, TocLength );

        doit( VCB, TrackCount );

        doit( VCB, DiskFlags );

        doit( VCB, BlockFactor );

    }

    printf("\n");

    {

        VOLUME_DEVICE_OBJECT d;

        doit( VOLUME_DEVICE_OBJECT, DeviceObject );

        doit( VOLUME_DEVICE_OBJECT, PostedRequestCount );

        doit( VOLUME_DEVICE_OBJECT, OverflowQueueCount );

        doit( VOLUME_DEVICE_OBJECT, OverflowQueue );

        doit( VOLUME_DEVICE_OBJECT, OverflowQueueSpinLock );

        doit( VOLUME_DEVICE_OBJECT, Vcb );

    }

    printf("\n");

    {

        FCB_DATA d;

        doit( FCB_DATA, FileLock );

    }

    printf("\n");

    {

        FCB_INDEX d;

        doit( FCB_INDEX, FileObject );

        doit( FCB_INDEX, StreamOffset );

        doit( FCB_INDEX, FcbQueue );

        doit( FCB_INDEX, Ordinal );

        doit( FCB_INDEX, ChildPathTableOffset );

        doit( FCB_INDEX, ChildOrdinal );

        doit( FCB_INDEX, ExactCaseRoot );

        doit( FCB_INDEX, IgnoreCaseRoot );

    }

    printf("\n");

    {

        FCB_NONPAGED d;

        doit( FCB_NONPAGED, NodeTypeCode );

        doit( FCB_NONPAGED, NodeByteSize );

        doit( FCB_NONPAGED, SegmentObject );

        doit( FCB_NONPAGED, FcbResource );

        doit( FCB_NONPAGED, FcbMutex );

    }

    printf("\n");

    {

        FCB d;

        doit( FCB, Header );

        doit( FCB, Vcb );

        doit( FCB, ParentFcb );

        doit( FCB, FcbLinks );

        doit( FCB, FileId );

        doit( FCB, FcbCleanup );

        doit( FCB, FcbReference );

        doit( FCB, FcbUserReference );

        doit( FCB, FcbState );

        doit( FCB, FileAttributes );

        doit( FCB, XAAttributes );

        doit( FCB, XAFileNumber );

        doit( FCB, FcbLockThread );

        doit( FCB, FcbLockCount );

        doit( FCB, FcbNonpaged );

        doit( FCB, ShareAccess );

        doit( FCB, McbEntry );

        doit( FCB, Mcb );

        doit( FCB, ShortNamePrefix );

        doit( FCB, FileNamePrefix );

        doit( FCB, CreationTime );

        doit( FCB, FcbType );

    }

    printf("\n");

    {

        CCB d;

        doit( CCB, NodeTypeCode );

        doit( CCB, NodeByteSize );

        doit( CCB, Flags );

        doit( CCB, Fcb );

        doit( CCB, CurrentDirentOffset );

        doit( CCB, SearchExpression );

    }

    printf("\n");

    {

        IRP_CONTEXT d;

        doit( IRP_CONTEXT, NodeTypeCode );

        doit( IRP_CONTEXT, NodeByteSize );

        doit( IRP_CONTEXT, Irp );

        doit( IRP_CONTEXT, Vcb );

        doit( IRP_CONTEXT, ExceptionStatus );

        doit( IRP_CONTEXT, Flags );

        doit( IRP_CONTEXT, RealDevice );

        doit( IRP_CONTEXT, IoContext );

        doit( IRP_CONTEXT, TeardownFcb );

        doit( IRP_CONTEXT, TopLevel );

        doit( IRP_CONTEXT, MajorFunction );

        doit( IRP_CONTEXT, MinorFunction );

        doit( IRP_CONTEXT, ThreadContext );

        doit( IRP_CONTEXT, WorkQueueItem );

    }

    printf("\n");

    {

        IRP_CONTEXT_LITE d;

        doit( IRP_CONTEXT_LITE, NodeTypeCode );

        doit( IRP_CONTEXT_LITE, NodeByteSize );

        doit( IRP_CONTEXT_LITE, Fcb );

        doit( IRP_CONTEXT_LITE, DelayedCloseLinks );

        doit( IRP_CONTEXT_LITE, UserReference );

        doit( IRP_CONTEXT_LITE, RealDevice );

    }

    printf("\n");

    {

        CD_IO_CONTEXT d;

        doit( CD_IO_CONTEXT, IrpCount );

        doit( CD_IO_CONTEXT, MasterIrp );

        doit( CD_IO_CONTEXT, Status );

        doit( CD_IO_CONTEXT, AllocatedContext );

        doit( CD_IO_CONTEXT, Resource );

        doit( CD_IO_CONTEXT, ResourceThreadId );

        doit( CD_IO_CONTEXT, SyncEvent );

    }

    printf("\n");

    {

        THREAD_CONTEXT d;

        doit( THREAD_CONTEXT, Cdfs );

        doit( THREAD_CONTEXT, SavedTopLevelIrp );

        doit( THREAD_CONTEXT, TopLevelIrpContext );

    }

    printf("\n");

    {

        PATH_ENUM_CONTEXT d;

        doit( PATH_ENUM_CONTEXT, Data );

        doit( PATH_ENUM_CONTEXT, BaseOffset );

        doit( PATH_ENUM_CONTEXT, DataLength );

        doit( PATH_ENUM_CONTEXT, Bcb );

        doit( PATH_ENUM_CONTEXT, DataOffset );

        doit( PATH_ENUM_CONTEXT, AllocatedData );

        doit( PATH_ENUM_CONTEXT, LastDataBlock );

    }

    printf("\n");

    {

        PATH_ENTRY d;

        doit( PATH_ENTRY, Ordinal );

        doit( PATH_ENTRY, PathTableOffset );

        doit( PATH_ENTRY, DiskOffset );

        doit( PATH_ENTRY, PathEntryLength );

        doit( PATH_ENTRY, ParentOrdinal );

        doit( PATH_ENTRY, DirNameLen );

        doit( PATH_ENTRY, DirName );

        doit( PATH_ENTRY, Flags );

        doit( PATH_ENTRY, CdDirName );

        doit( PATH_ENTRY, CdCaseDirName );

        doit( PATH_ENTRY, NameBuffer );

    }

    printf("\n");

    {

        COMPOUND_PATH_ENTRY d;

        doit( COMPOUND_PATH_ENTRY, PathContext );

        doit( COMPOUND_PATH_ENTRY, PathEntry );

    }

    printf("\n");

    {

        DIRENT_ENUM_CONTEXT d;

        doit( DIRENT_ENUM_CONTEXT, Sector );

        doit( DIRENT_ENUM_CONTEXT, BaseOffset );

        doit( DIRENT_ENUM_CONTEXT, DataLength );

        doit( DIRENT_ENUM_CONTEXT, Bcb );

        doit( DIRENT_ENUM_CONTEXT, SectorOffset );

        doit( DIRENT_ENUM_CONTEXT, NextDirentOffset );

    }

    printf("\n");

    {

        DIRENT d;

        doit( DIRENT, DirentOffset );

        doit( DIRENT, DirentLength );

        doit( DIRENT, StartingOffset );

        doit( DIRENT, DataLength );

        doit( DIRENT, CdTime );

        doit( DIRENT, DirentFlags );

        doit( DIRENT, Flags );

        doit( DIRENT, FileUnitSize );

        doit( DIRENT, InterleaveGapSize );

        doit( DIRENT, SystemUseOffset );

        doit( DIRENT, XAAttributes );

        doit( DIRENT, XAFileNumber );

        doit( DIRENT, FileNameLen );

        doit( DIRENT, FileName );

        doit( DIRENT, CdFileName );

        doit( DIRENT, CdCaseFileName );

        doit( DIRENT, ExtentType );

        doit( DIRENT, NameBuffer );

    }

    printf("\n");

    {

        COMPOUND_DIRENT d;

        doit( COMPOUND_DIRENT, DirContext );

        doit( COMPOUND_DIRENT, Dirent );

    }

    printf("\n");

    {

        FILE_ENUM_CONTEXT d;

        doit( FILE_ENUM_CONTEXT, PriorDirent );

        doit( FILE_ENUM_CONTEXT, InitialDirent );

        doit( FILE_ENUM_CONTEXT, CurrentDirent );

        doit( FILE_ENUM_CONTEXT, Flags );

        doit( FILE_ENUM_CONTEXT, FileSize );

        doit( FILE_ENUM_CONTEXT, ShortName );

        doit( FILE_ENUM_CONTEXT, ShortNameBuffer );

        doit( FILE_ENUM_CONTEXT, Dirents );

    }

    printf("\n");

    {

        RIFF_HEADER d;

        doit( RIFF_HEADER, ChunkId );

        doit( RIFF_HEADER, ChunkSize );

        doit( RIFF_HEADER, SignatureCDXA );

        doit( RIFF_HEADER, SignatureFMT );

        doit( RIFF_HEADER, XAChunkSize );

        doit( RIFF_HEADER, OwnerId );

        doit( RIFF_HEADER, Attributes );

        doit( RIFF_HEADER, SignatureXA );

        doit( RIFF_HEADER, FileNumber );

        doit( RIFF_HEADER, Reserved );

        doit( RIFF_HEADER, SignatureData );

        doit( RIFF_HEADER, RawSectors );

    }

    printf("\n");

    {

        AUDIO_PLAY_HEADER d;

        doit( AUDIO_PLAY_HEADER, Chunk );

        doit( AUDIO_PLAY_HEADER, ChunkSize );

        doit( AUDIO_PLAY_HEADER, SignatureCDDA );

        doit( AUDIO_PLAY_HEADER, SignatureFMT );

        doit( AUDIO_PLAY_HEADER, FMTChunkSize );

        doit( AUDIO_PLAY_HEADER, FormatTag );

        doit( AUDIO_PLAY_HEADER, TrackNumber );

        doit( AUDIO_PLAY_HEADER, DiskID );

        doit( AUDIO_PLAY_HEADER, StartingSector );

        doit( AUDIO_PLAY_HEADER, SectorCount );

        doit( AUDIO_PLAY_HEADER, TrackAddress );

        doit( AUDIO_PLAY_HEADER, TrackLength );

    }

    printf("\n");

    {

        RAW_ISO_VD d;

        doit( RAW_ISO_VD, DescType );

        doit( RAW_ISO_VD, StandardId );

        doit( RAW_ISO_VD, Version );

        doit( RAW_ISO_VD, VolumeFlags );

        doit( RAW_ISO_VD, SystemId );

        doit( RAW_ISO_VD, VolumeId );

        doit( RAW_ISO_VD, Reserved );

        doit( RAW_ISO_VD, VolSpaceI );

        doit( RAW_ISO_VD, VolSpaceM );

        doit( RAW_ISO_VD, CharSet );

        doit( RAW_ISO_VD, VolSetSizeI );

        doit( RAW_ISO_VD, VolSetSizeM );

        doit( RAW_ISO_VD, VolSeqNumI );

        doit( RAW_ISO_VD, VolSeqNumM );

        doit( RAW_ISO_VD, LogicalBlkSzI );

        doit( RAW_ISO_VD, LogicalBlkSzM );

        doit( RAW_ISO_VD, PathTableSzI );

        doit( RAW_ISO_VD, PathTableSzM );

        doit( RAW_ISO_VD, PathTabLocI );

        doit( RAW_ISO_VD, PathTabLocM );

        doit( RAW_ISO_VD, RootDe );

        doit( RAW_ISO_VD, VolSetId );

        doit( RAW_ISO_VD, PublId );

        doit( RAW_ISO_VD, PreparerId );

        doit( RAW_ISO_VD, AppId );

        doit( RAW_ISO_VD, Copyright );

        doit( RAW_ISO_VD, Abstract );

        doit( RAW_ISO_VD, Bibliograph );

        doit( RAW_ISO_VD, CreateDate );

        doit( RAW_ISO_VD, ModDate );

        doit( RAW_ISO_VD, ExpireDate );

        doit( RAW_ISO_VD, EffectDate );

        doit( RAW_ISO_VD, FileStructVer );

        doit( RAW_ISO_VD, Reserved3 );

        doit( RAW_ISO_VD, ResApp );

        doit( RAW_ISO_VD, Reserved4 );

    }

    printf("\n");

    {

        RAW_HSG_VD d;

        doit( RAW_HSG_VD, BlkNumI );

        doit( RAW_HSG_VD, BlkNumM );

        doit( RAW_HSG_VD, DescType );

        doit( RAW_HSG_VD, StandardId );

        doit( RAW_HSG_VD, Version );

        doit( RAW_HSG_VD, VolumeFlags );

        doit( RAW_HSG_VD, SystemId );

        doit( RAW_HSG_VD, VolumeId );

        doit( RAW_HSG_VD, Reserved );

        doit( RAW_HSG_VD, VolSpaceI );

        doit( RAW_HSG_VD, VolSpaceM );

        doit( RAW_HSG_VD, CharSet );

        doit( RAW_HSG_VD, VolSetSizeI );

        doit( RAW_HSG_VD, VolSetSizeM );

        doit( RAW_HSG_VD, VolSeqNumI );

        doit( RAW_HSG_VD, VolSeqNumM );

        doit( RAW_HSG_VD, LogicalBlkSzI );

        doit( RAW_HSG_VD, LogicalBlkSzM );

        doit( RAW_HSG_VD, PathTableSzI );

        doit( RAW_HSG_VD, PathTableSzM );

        doit( RAW_HSG_VD, PathTabLocI );

        doit( RAW_HSG_VD, PathTabLocM );

        doit( RAW_HSG_VD, RootDe );

        doit( RAW_HSG_VD, VolSetId );

        doit( RAW_HSG_VD, PublId );

        doit( RAW_HSG_VD, PreparerId );

        doit( RAW_HSG_VD, AppId );

        doit( RAW_HSG_VD, Copyright );

        doit( RAW_HSG_VD, Abstract );

        doit( RAW_HSG_VD, CreateDate );

        doit( RAW_HSG_VD, ModDate );

        doit( RAW_HSG_VD, ExpireDate );

        doit( RAW_HSG_VD, EffectDate );

        doit( RAW_HSG_VD, FileStructVer );

        doit( RAW_HSG_VD, Reserved3 );

        doit( RAW_HSG_VD, ResApp );

        doit( RAW_HSG_VD, Reserved4 );

    }

    printf("\n");

    {

        RAW_DIRENT d;

        doit( RAW_DIRENT, DirLen );

        doit( RAW_DIRENT, XarLen );

        doit( RAW_DIRENT, FileLoc );

        doit( RAW_DIRENT, FileLocMot );

        doit( RAW_DIRENT, DataLen );

        doit( RAW_DIRENT, DataLenMot );

        doit( RAW_DIRENT, RecordTime );

        doit( RAW_DIRENT, FlagsHSG );

        doit( RAW_DIRENT, FlagsISO );

        doit( RAW_DIRENT, IntLeaveSize );

        doit( RAW_DIRENT, IntLeaveSkip );

        doit( RAW_DIRENT, Vssn );

        doit( RAW_DIRENT, VssnMot );

        doit( RAW_DIRENT, FileIdLen );

        doit( RAW_DIRENT, FileId );

    }

    printf("\n");

    {

        RAW_PATH_ISO d;

        doit( RAW_PATH_ISO, DirIdLen );

        doit( RAW_PATH_ISO, XarLen );

        doit( RAW_PATH_ISO, DirLoc );

        doit( RAW_PATH_ISO, ParentNum );

        doit( RAW_PATH_ISO, DirId );

    }

    printf("\n");

    {

        RAW_PATH_HSG d;

        doit( RAW_PATH_HSG, DirLoc );

        doit( RAW_PATH_HSG, XarLen );

        doit( RAW_PATH_HSG, DirIdLen );

        doit( RAW_PATH_HSG, ParentNum );

        doit( RAW_PATH_HSG, DirId );

    }

    printf("\n");

    {

        SYSTEM_USE_XA d;

        doit( SYSTEM_USE_XA, OwnerId );

        doit( SYSTEM_USE_XA, Attributes );

        doit( SYSTEM_USE_XA, Signature );

        doit( SYSTEM_USE_XA, FileNumber );

        doit( SYSTEM_USE_XA, Reserved );

    }

}

argc
static int argc
Definition: ServiceArgs.c:12

__cdecl
#define __cdecl
Definition: accygwin.h:79

FileNameBuffer
WCHAR FileNameBuffer[MAX_PATH]
Definition: framewnd.c:233

SystemUseOffset
Dirent SystemUseOffset
Definition: dirsup.c:521

FileUnitSize
Dirent FileUnitSize
Definition: dirsup.c:484

XAFileNumber
Dirent XAFileNumber
Definition: dirsup.c:519

DirentOffset
Dirent DirentOffset
Definition: dirsup.c:444

XAAttributes
Dirent XAAttributes
Definition: dirsup.c:518

CdTime
Dirent CdTime
Definition: dirsup.c:471

FileNameLen
Dirent FileNameLen
Definition: dirsup.c:506

ExtentType
Dirent ExtentType
Definition: dirsup.c:520

DirentFlags
Dirent DirentFlags
Definition: dirsup.c:477

DirentLength
Dirent DirentLength
Definition: dirsup.c:450

cdprocs.h

DiskOffset
_In_ PFCB _In_ LONGLONG _Out_ PLONGLONG DiskOffset
Definition: cdprocs.h:161

FileOffset
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160

ParentFcb
_In_ PFCB ParentFcb
Definition: cdprocs.h:736

Dirent
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT _Inout_ PDIRENT Dirent
Definition: cdprocs.h:427

DirName
_In_ PFCB _In_ PCD_NAME DirName
Definition: cdprocs.h:737

StartingOffset
_In_ PFCB _In_ LONGLONG StartingOffset
Definition: cdprocs.h:291

Fcb
_In_ PFCB Fcb
Definition: cdprocs.h:159

SectorOffset
#define SectorOffset(L)
Definition: cdprocs.h:1622

Resource
_Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _Inout_ PERESOURCE Resource
Definition: cdprocs.h:843

DirContext
_In_ PFCB _In_ PDIRENT_ENUM_CONTEXT DirContext
Definition: cdprocs.h:425

DataLength
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t _In_ PVOID _In_ size_t _Out_ size_t * DataLength
Definition: cdrom.h:1444

Header
Definition: Header.h:9

Irp
_In_ PIRP Irp
Definition: csq.h:116

CharSet
static void CharSet(RTF_Info *info)
Definition: reader.c:2420

Signature
static const WCHAR Signature[]
Definition: parser.c:141

ShareAccess
_In_ PIO_STACK_LOCATION _Inout_ PFILE_OBJECT _Inout_ PVCB _Outptr_result_maybenull_ PDCB _In_ PDCB _In_ PDIRENT _In_ ULONG _In_ ULONG _In_ PUNICODE_STRING _In_ PACCESS_MASK _In_ USHORT ShareAccess
Definition: create.c:4147

main
int main()
Definition: test.c:6

TargetDeviceObject
IN OUT PVCB IN PDEVICE_OBJECT TargetDeviceObject
Definition: fatprocs.h:1674

Bcb
IN PVCB IN VBO IN ULONG OUT PBCB * Bcb
Definition: fatprocs.h:414

TopLevel
IN PFCB IN PCCB IN TYPE_OF_OPEN IN BOOLEAN IN BOOLEAN TopLevel
Definition: fatprocs.h:2417

Vpb
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb
Definition: fatprocs.h:1675

ShortName
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING ShortName
Definition: fatprocs.h:1306

Mcb
IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN OUT PLARGE_MCB Mcb
Definition: fatprocs.h:348

doit
#define doit(a, b)
Definition: fieldoff.c:4

FileAttributes
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE _In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Out_ PIO_STATUS_BLOCK _In_opt_ PLARGE_INTEGER _In_ ULONG FileAttributes
Definition: fltkernel.h:1236

printf
#define printf
Definition: freeldr.h:97

OwnerId
_Must_inspect_result_ _In_opt_ PVOID OwnerId
Definition: fsrtlfuncs.h:907

FileSize
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
Definition: fsrtlfuncs.h:108

Status
Status
Definition: gdiplustypes.h:25

void
Definition: nsiface.idl:2307

d
#define d
Definition: ke_i.h:81

argv
#define argv
Definition: mplay32.c:18

SectorCount
ULONG SectorCount
Definition: part_xbox.c:31

Vcb
#define Vcb
Definition: cdprocs.h:1415

Reserved3
@ Reserved3
Definition: sacdrv.h:1471

Reserved4
@ Reserved4
Definition: sacdrv.h:1472

Data
Definition: sort_test.cpp:77

IRP_CONTEXT
Definition: usbstor.h:98

_AUDIO_PLAY_HEADER
Definition: cdstruc.h:1772

_CCB
Definition: cdstruc.h:1067

_CD_DATA
Definition: cdstruc.h:315

_CD_IO_CONTEXT
Definition: cdstruc.h:1319

_CD_MCB_ENTRY
Definition: cdstruc.h:200

_CD_MCB
Definition: cdstruc.h:182

_CD_NAME
Definition: cdstruc.h:236

_COMPOUND_DIRENT
Definition: cdstruc.h:1681

_COMPOUND_PATH_ENTRY
Definition: cdstruc.h:1525

_DIRENT_ENUM_CONTEXT
Definition: cdstruc.h:1539

_DIRENT
Definition: cdstruc.h:1577

_FCB_DATA
Definition: cdstruc.h:784

_FCB_INDEX
Definition: cdstruc.h:806

_FCB_NONPAGED
Definition: cdstruc.h:856

_FCB
Definition: cdstruc.h:902

_FILE_ENUM_CONTEXT
Definition: cdstruc.h:1696

_FileName
Definition: filecomp.c:348

_IRP_CONTEXT_LITE
Definition: cdstruc.h:1274

_NAME_LINK
Definition: cdstruc.h:260

_PATH_ENTRY
Definition: cdstruc.h:1460

_PATH_ENUM_CONTEXT
Definition: cdstruc.h:1403

_PREFIX_ENTRY
Definition: cdstruc.h:275

_RAW_DIRENT
Definition: cd.h:330

_RAW_HSG_VD
Definition: cd.h:169

_RAW_ISO_VD
Definition: cd.h:126

_RAW_PATH_HSG
Definition: cd.h:432

_RAW_PATH_ISO
Definition: cd.h:419

_RIFF_HEADER
Definition: cdstruc.h:1750

_SYSTEM_USE_XA
Definition: cd.h:479

_THREAD_CONTEXT
Definition: cdstruc.h:1363

_VCB
Definition: cdstruc.h:498

_VOLUME_DEVICE_OBJECT
Definition: cdstruc.h:727

Attributes
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97

DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055

FileObject
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550

MajorFunction
_In_ UCHAR MajorFunction
Definition: wdfdevice.h:1697

MinorFunction
_In_ UCHAR _In_ UCHAR MinorFunction
Definition: wdfdevice.h:1699

DriverObject
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213

Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469

Reserved
_Reserved_ PVOID Reserved
Definition: winddi.h:3974

Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

ResourceThreadId
_In_ ERESOURCE_THREAD ResourceThreadId
Definition: exfuncs.h:1052

ByteCount
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _In_ LARGE_INTEGER ByteCount
Definition: iotypes.h:1099

ChunkSize
_Inout_ PUCHAR _In_ PUCHAR _Out_ PUCHAR _Out_ PULONG ChunkSize
Definition: rtlfuncs.h:2277