Difference between revisions of "Unit CDFS"

Revision as of 03:39, 9 March 2017

`cdfsIso9660 = 0;`
`cdfsJoilet = 1;`
`cdfsSierra = 2;`
`cdfsRockRidge = 3;`
`cdfsAudio = 4;`
`cdfsUDF = 5;`

`cdfsNames:array[0..5] of String = (`
`'CD001',`
`'CD001',`
`'CDROM',`
`,`
`'CDAUDIO',`
`);`

`cdfsAnyName = '*';`
`cdfsDotName = '.';`
`cdfsDotDotName = '..';`
`cdfsBlankName = ;`
`cdfsVersionName = '1';`	Used by version information on end of identifier (Not Used)
`cdfsSeparator1Name = '.';`	Dot on end of identifier when no extension exists (File only)
`cdfsSeparator2Name = ';';`	Used by version information on end of identifier (File only)

`cdfsJolietMaxPath = 240;`	120 (240 bytes)
`cdfsJolietMaxFile = 64;`	(128 bytes)
`cdfsISO9660MaxPath = 240;`
`cdfsISO9660MaxFile = 30;`	31 for Directories

`cdfsISO9660StandardIdentifier = 'CD001';`
`cdfsELTORITOSystemIdentifier = 'EL TORITO SPECIFICATION';`

`cdfsFirstSector = 0;`
`cdfsReservedSectors = 16;`
`cdfsISO9660StartSector = 16;`
`cdfsELTORITOBootSector = 17;`

`cdfsISO9660StructureVersion = 1;`
`cdfsISO9660DescriptorVersion = 1;`
`cdfsELTORITODescriptorVersion = 1;`

`cdfsJolietUCS2Sequence1 = #37 + #47 + #64;`	'%/@'
`cdfsJolietUCS2Sequence2 = #37 + #47 + #67;`	'%/C'
`cdfsJolietUCS2Sequence3 = #37 + #47 + #69;`	'%/E'

`cdfsDotIdentifier = $00;`
`cdfsDotDotIdentifier = $01;`

`cdfsSeparator1Value = $2E;`	'.'
`cdfsSeparator2Value = $3B;`	';'

`cdfsTimeStartYear = 1900;`	CDFS Time starts at 1900
`cdfsTimeOffsetInterval = 15;`	Offset is in 15 minute intervals

`cdfsNullFileTime:TFileTime = (dwLowDateTime:$00000000;dwHighDateTime:$00000000);`

`cdfsStartCluster = 16;`
`cdfsUnknownCluster = LongWord(-1);`

`cdfsRootPathNumber = 1;`

`cdfsPathRecordSize = 9;`	Minimum
`cdfsExtendedRecordSize = 250;`	Minimum
`cdfsDirectoryRecordSize = 34;`	Minimum

`cdfsFileIdentifierSize = 1;`	Minimum
`cdfsPathIdentifierSize = 1;`	Minimum

`cdfsHeaderRecordSize = 32;`	Fixed
`cdfsCatalogRecordSize = 32;`	Fixed
`cdfsExtensionRecordSize = 32;`	Fixed

`cdfsEvenSize = 0;`
`cdfsUnevenSize = 1;`

`cdfsRootRecordOffset = 156;`	Offset of Root Directory in Descriptor

`cdfsInstanceFirst = 0;`
`cdfsInstanceLast = Byte(-1);`

`cdfsTableTypeMask = $00FF0000;`
`cdfsTableTypeShift = 16;`
`cdfsTableInstanceMask = $0000FF00;`
`cdfsTableInstanceShift = 8;`
`cdfsTableDescriptorMask = $000000FF;`
`cdfsTableDescriptorShift = 0;`

`cdfsBitmapUnknown = LongWord(-1);`

CDFS bitmap mask constants cdfsBitmapMask*

`cdfsBitmapMaskBits = 64;`	Int64 Bitmap Masks
`cdfsBitmapMaskNone = $0000000000000000;`	Int64 Used for fast counting of free blocks
`cdfsBitmapMaskAll = $FFFFFFFFFFFFFFFF;`	Int64 Used for fast counting of used blocks

CDFS volume flag constants cdfsVolumeFlag*

`cdfsVolumeFlagNone = $00;`
`cdfsVolumeFlagUnregistered = $01;`	If set this SVD contains an unregistered escape sequence

CDFS file flag constants cdfsFileFlag*

`cdfsFileFlagNone = $00;`
`cdfsFileFlagExistence = $01;`	If set this file is hidden
`cdfsFileFlagDirectory = $02;`	If set this record is a directory
`cdfsFileFlagAssociated = $04;`	If set this file is an associated file
`cdfsFileFlagRecord = $08;`	If set record information is recorded for this file
`cdfsFileFlagProtection = $10;`	If set permissions are recorded for this file
`cdfsFileFlagReserved1 = $20;`	Reserved
`cdfsFileFlagReserved2 = $40;`	Reserved
`cdfsFileFlagMore = $80;`	If set there are more directory records for this file

CDFS permissions constants cdfsPermission*

`cdfsPermissionSystemRead = $0001;`	If set system cannot Read
`cdfsPermissionSystemWrite = $0002;`	If set system cannot Write
`cdfsPermissionSystemExecute = $0004;`	If set system cannot Execute
`cdfsPermissionReserved1 = $0008;`	Reserved
`cdfsPermissionOwnerRead = $0010;`	If set owner cannot Read
`cdfsPermissionOwnerWrite = $0020;`	If set owner cannot Write
`cdfsPermissionOwnerExecute = $0040;`	If set owner cannot Execute
`cdfsPermissionReserved2 = $0080;`	Reserved
`cdfsPermissionGroupRead = $0100;`	If set group cannot Read
`cdfsPermissionGroupWrite = $0200;`	If set group cannot Write
`cdfsPermissionGroupExecute = $0400;`	If set group cannot Execute
`cdfsPermissionReserved3 = $0800;`	Reserved
`cdfsPermissionOtherRead = $1000;`	If set other cannot Read
`cdfsPermissionOtherWrite = $2000;`	If set other cannot Write
`cdfsPermissionOtherExecute = $4000;`	If set other cannot Execute
`cdfsPermissionReserved4 = $8000;`	Reserved

CDFS path table constants cdfsPathTable*

`cdfsPathTableTypePrimary = $00;`
`cdfsPathTableTypeAlternate = $01;`
`cdfsPathTableTypePrimaryM = $02;`
`cdfsPathTableTypeAlternateM = $03;`

CDFS volume descriptor constants cdfsVolumeDescriptor*

`cdfsVolumeDescriptorTypeBoot = $00;`
`cdfsVolumeDescriptorTypePrimary = $01;`
`cdfsVolumeDescriptorTypeSupplementary = $02;`
`cdfsVolumeDescriptorTypePartition = $03;`
`cdfsVolumeDescriptorTypeTerminator = $FF;`

CDFS header constants cdfsElTorito*

`cdfsElToritoHeaderId = $01;`
`cdfsElToritoBootIndicator = $88;`
`cdfsElToritoNoBootIndicator = $00;`
`cdfsElToritoHeaderIndicator = $90;`	91 if final header
`cdfsElToritoHeaderTerminator = $91;`
`cdfsElToritoExtensionIndicator = $44;`

CDFS signature constants cdfsElToritoSignature*

`cdfsElToritoSignature = $AA55;`

CDFS platform Id constants cdfsElToritoPlatform*

`cdfsElToritoPlatformIdx86 = $00;`
`cdfsElToritoPlatformIdPPC = $01;`
`cdfsElToritoPlatformIdMac = $02;`

CDFS media type constants cdfsElToritoMedia*

`cdfsElToritoMediaTypeNone = $00;`	No Emulation
`cdfsElToritoMediaType12M = $01;`	1.2 meg diskette
`cdfsElToritoMediaType144M = $02;`	1.44 meg diskette
`cdfsElToritoMediaType288M = $03;`	2.88 meg diskette
`cdfsElToritoMediaTypeHDD = $04;`	Hard Disk (drive 80)
`cdfsElToritoMediaTypeMask = $0F;`	Values 5-F Reserved, invalid at this time

`cdfsElToritoMediaFlagReserved = $10;`	Reserved, must be 0
`cdfsElToritoMediaFlagContinuation = $20;`	Continuation Entry Follows
`cdfsElToritoMediaFlagAtapi = $40;`	Image contains ATAPI driver
`cdfsElToritoMediaFlagScsi = $80;`	Image contains SCSI drivers
`cdfsElToritoMediaFlagMask = $F0;`

CDFS extension flag constants cdfsElToritoExtensionFlag*

`cdfsElToritoExtensionFlagExtension = $20;`	Extension Record Follows

Type definitions

CDFS specific types

`TCDFSType = (ctNONE,ctISO9660,ctJOLIET,ctSIERRA,ctROCKRIDGE,ctAUDIO,ctUDF);`

CDFS time types

PCDFSTime = ^TCDFSTime;

TCDFSTime = packed record

Note: 7 Bytes
`Years:Byte;`	Number of years since 1900
`Month:Byte;`	Month of the year from 1 to 12
`Day:Byte;`	Day of the month from 1 to 31
`Hour:Byte;`	Hour of the day from 0 to 23
`Minute:Byte;`	Minute of the hour from 0 to 59
`Second:Byte;`	Second of the minute from 0 to 59
`Offset:ShortInt;`	Offset from Greenwich Mean Time in number of 15 min intervals from -48 (West) to +52 (East)

CDFS date time types

PCDFSDateTime = ^TCDFSDateTime;

TCDFSDateTime = packed record

Note: 17 Bytes
`Year:array[0..3] of Char;`	Year from 1 to 9999
`Month:array[0..1] of Char;`	Month of the year from 1 to 12
`Day:array[0..1] of Char;`	Day of the month from 1 to 31
`Hour:array[0..1] of Char;`	Hour of the day from 0 to 23
`Minute:array[0..1] of Char;`	Minute of the hour from 0 to 59
`Second:array[0..1] of Char;`	Second of the minute from 0 to 59
`Hundredths:array[0..1] of Char;`	Hundredths of a second
`Offset:ShortInt;`	Offset from Greenwich Mean Time in number of 15 min intervals from -48 (West) to +52 (East)

CDFS directory record types

PCDFSDirectoryRecord = ^TCDFSDirectoryRecord;

TCDFSDirectoryRecord = packed record

Note: 34 Bytes (Minimum not including padding)
`RecordSize:Byte;`	Length of Directory Record (LEN-DR)
`ExtendedSize:Byte;`	Extended Attribute Record Length
`FirstBlock:LongWord;`	Location of Extent
`FirstBlockM:LongWord;`
`DataSize:LongWord;`	Data Length
`DataSizeM:LongWord;`
`CreateTime:TCDFSTime;`	Recording Date and Time
`FileFlags:Byte;`	File Flags 8 bits
`UnitSize:Byte;`	File Unit Size
`InterleaveSize:Byte;`	Interleave Gap Size
`SequenceNumber:Word;`	Volume Sequence Number
`SequenceNumberM:Word;`
`FileIdentifierSize:Byte;`	Length of File Identifier (LEN_FI)
`FileIdentifier:array[0..0] of Char;`	File Identifier d-characters,d1-characters,SEPARATOR 1,SEPARATOR 2,(00) or (01) byte
`Padding:Byte;`	Padding Field (00) byte (Only present if FileIdentifierSize is even (Total size would be odd))
`SystemData:array[0..0] of Byte;`	System Use LEN_SU bytes

CDFS path record types

PCDFSPathRecord = ^TCDFSPathRecord;

TCDFSPathRecord = packed record

Note: 9 Bytes (Minimum not including padding)
`PathIdentifierSize:Byte;`	Length of Directory Identifier (LEN_DI)
`ExtendedSize:Byte;`	Extended Attribute Record Length
`FirstBlock:LongWord;`	Location of Extent
`ParentNumber:Word;`	Parent Directory Number
`PathIdentifier:array[0..0] of Char;`	Directory Identifier d-characters, d1-characters, (00) byte
`Padding:Byte;`	Padding Field (00) byte (Only present if PathIdentifierSize is odd (Total size would be odd))

CDFS extended record types

PCDFSExtendedRecord = ^TCDFSExtendedRecord;

TCDFSExtendedRecord = packed record

Note: 250 Bytes (Minimum)
`OwnerId:Word;`	Owner Identification
`OwnerIdM:Word;`
`GroupId:Word;`	Group Identification
`GroupIdM:Word;`
`Permissions:Word;`	Permissions 16 bits
`CreateTime:TCDFSDateTime;`	File Creation Date and Time
`ModifyTime:TCDFSDateTime;`	File Modification Date and Time
`ExpireTime:TCDFSDateTime;`	File Expiration Date and Time
`EffectiveTime:TCDFSDateTime;`	File Effective Date and Time
`RecordFormat:Byte;`	Record Format
`RecordAttributes:Byte;`	Record Attributes
`RecordLength:Word;`	Record Length
`RecordLengthM:Word;`
`SystemIdentifier:array[0..31] of Char;`	System Identifier a-characters, a1-characters
`SystemData:array[0..63] of Byte;`	System Use not specified
`ExtendedVersion:Byte;`	Extended Attribute Record Version
`EscapeSequenceSize:Byte;`	Length of Escape Sequences (LEN_ESC)
`Reserved1:array[0..63] of Byte;`	Reserved for future standardization (00) bytes
`ApplicationDataSize:Word;`	Length of Application Use (LEN_AU)
`ApplicationDataSizeM:Word;`
`ApplicationData:array[0..0] of Byte;`	Application Use LEN_AU bytes
`EscapeSequence:array[0..0] of Byte;`	Escape Sequences LEN_ESC bytes

CDFS volume descriptor header types

PCDFSVolumeDescriptorHeader = ^TCDFSVolumeDescriptorHeader;

TCDFSVolumeDescriptorHeader = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type 00 = Boot, 01 = Primary etc
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`Reserved:array[0..2040] of Byte;`	Content depends on Descriptor Type

CDFS volume descriptor boot types

PCDFSVolumeDescriptorBoot = ^TCDFSVolumeDescriptorBoot;

TCDFSVolumeDescriptorBoot = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type (00 = Boot)
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`SystemIdentifier:array[0..31] of Char;`	32 a-characters (eg EL TORITO SPECIFICATION)
`BootIdentifier:array[0..31] of Char;`	32 a-characters
`BootData:array[0..1976] of Byte;`

CDFS volume descriptor primary types

PCDFSVolumeDescriptorPrimary = ^TCDFSVolumeDescriptorPrimary;

TCDFSVolumeDescriptorPrimary = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type (01 = Primary)
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`Reserved1:Byte;`	Unused Field (00) byte
`SystemIdentifier:array[0..31] of Char;`	System Identifier a-characters
`VolumeIdentifier:array[0..31] of Char;`	Volume Identifier d-characters
`Reserved2:array[0..7] of Byte;`	Unused Field (00) bytes
`VolumeSpaceSize:LongWord;`	Volume Space Size
`VolumeSpaceSizeM:LongWord;`
`Reserved3:array[0..31] of Byte;`	Unused Field (00) bytes
`VolumeSetSize:Word;`	Volume Set Size
`VolumeSetSizeM:Word;`
`VolumeSequenceNumber:Word;`	Volume Sequence Number
`VolumeSequenceNumberM:Word;`
`LogicalBlockSize:Word;`	Logical Block Size
`LogicalBlockSizeM:Word;`
`PathTableSize:LongWord;`	Path Table Size
`PathTableSizeM:LongWord;`
`PrimaryPathTable:LongWord;`	Location of Occurrence of Type L Path Table
`AlternatePathTable:LongWord;`	Location of Optional Occurrence of Type L Path Table
`PrimaryPathTableM:LongWord;`	Location of Occurrence of Type M Path Table
`AlternatePathTableM:LongWord;`	Location of Optional Occurrence of Type M Path Table
`RootDirectory:TCDFSDirectoryRecord;`	Directory Record for Root Directory 34 bytes
`VolumeSetIdentifier:array[0..127] of Char;`	Volume Set Identifier d-characters
`PublisherIdentifier:array[0..127] of Char;`	Publisher Identifier a-characters
`PreparerIdentifier:array[0..127] of Char;`	Data Preparer Identifier a-characters
`ApplicationIdentifier:array[0..127] of Char;`	Application Identifier a-characters
`CopyrightIdentifier:array[0..36] of Char;`	Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`AbstractIdentifier:array[0..36] of Char;`	Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`BibliographicIdentifier:array[0..36] of Char;`	Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`CreateTime:TCDFSDateTime;`	Volume Creation Date and Time
`ModifyTime:TCDFSDateTime;`	Volume Modification Date and Time
`ExpireTime:TCDFSDateTime;`	Volume Expiration Date and Time
`EffectiveTime:TCDFSDateTime;`	Volume Effective Date and Time
`FileStructureVersion:Byte;`	File Structure Version
`Reserved4:Byte;`	Reserved for future standardization (00) byte
`ApplicationData:array[0..511] of Byte;`	Application Use not specified
`Reserved5:array[0..652] of Byte;`	Reserved for future standardization (00) bytes

CDFS volume descriptor supplementary types

PCDFSVolumeDescriptorSupplementary = ^TCDFSVolumeDescriptorSupplementary;

TCDFSVolumeDescriptorSupplementary = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type (02 = Supplementary)
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`VolumeFlags:Byte;`	Volume Flags 8 bits
`SystemIdentifier:array[0..31] of Char;`	System Identifier a-characters
`VolumeIdentifier:array[0..31] of Char;`	Volume Identifier d-characters
`Reserved2:array[0..7] of Byte;`	Unused Field (00) bytes
`VolumeSpaceSize:LongWord;`	Volume Space Size
`VolumeSpaceSizeM:LongWord;`
`EscapeSequences:array[0..31] of Byte;`	Escape Sequences 32 bytes
`VolumeSetSize:Word;`	Volume Set Size
`VolumeSetSizeM:Word;`
`VolumeSequenceNumber:Word;`	Volume Sequence Number
`VolumeSequenceNumberM:Word;`
`LogicalBlockSize:Word;`	Logical Block Size
`LogicalBlockSizeM:Word;`
`PathTableSize:LongWord;`	Path Table Size
`PathTableSizeM:LongWord;`
`PrimaryPathTable:LongWord;`	Location of Occurrence of Type L Path Table
`AlternatePathTable:LongWord;`	Location of Optional Occurrence of Type L Path Table
`PrimaryPathTableM:LongWord;`	Location of Occurrence of Type M Path Table
`AlternatePathTableM:LongWord;`	Location of Optional Occurrence of Type M Path Table
`RootDirectory:TCDFSDirectoryRecord;`	Directory Record for Root Directory 34 bytes
`VolumeSetIdentifier:array[0..127] of Char;`	Volume Set Identifier d-characters
`PublisherIdentifier:array[0..127] of Char;`	Publisher Identifier a-characters
`PreparerIdentifier:array[0..127] of Char;`	Data Preparer Identifier a-characters
`ApplicationIdentifier:array[0..127] of Char;`	Application Identifier a-characters
`CopyrightIdentifier:array[0..36] of Char;`	Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`AbstractIdentifier:array[0..36] of Char;`	Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`BibliographicIdentifier:array[0..36] of Char;`	Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`CreateTime:TCDFSDateTime;`	Volume Creation Date and Time
`ModifyTime:TCDFSDateTime;`	Volume Modification Date and Time
`ExpireTime:TCDFSDateTime;`	Volume Expiration Date and Time
`EffectiveTime:TCDFSDateTime;`	Volume Effective Date and Time
`FileStructureVersion:Byte;`	File Structure Version
`Reserved4:Byte;`	Reserved for future standardization (00) byte
`ApplicationData:array[0..511] of Byte;`	Application Use not specified
`Reserved5:array[0..652] of Byte;`	Reserved for future standardization (00) bytes

CDFS volume descriptor partition types

PCDFSVolumeDescriptorPartition = ^TCDFSVolumeDescriptorPartition;

TCDFSVolumeDescriptorPartition = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type (03 = Partition)
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`Reserved1:Byte;`	Unused Field (00) byte
`SystemIdentifier:array[0..31] of Char;`	System Identifier a-characters
`PartitionIdentifier:array[0..31] of Char;`	Volume Partition Identifier d-characters
`PartitionStart:LongWord;`	Volume Partition Location (first Logical Block)
`PartitionStartM:LongWord;`
`PartitionSize:LongWord;`	Volume Partition Size (in Logical Blocks)
`PartitionSizeM:LongWord;`
`SystemData:array[0..1959] of Byte;`	System Use not specified

CDFS volume descriptor terminator types

PCDFSVolumeDescriptorTerminator = ^TCDFSVolumeDescriptorTerminator;

TCDFSVolumeDescriptorTerminator = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Descriptor Type (FF = Terminator)
`StandardIdentifier:array[0..4] of Char;`	Standard Identifier ('CD001')
`DescriptorVersion:Byte;`	Descriptor Version (1)
`Reserved:array[0..2040] of Byte;`	Reserved (Always 00)

EL TORITO validation record types

PELTORITOValidationRecord = ^TELTORITOValidationRecord;

TELTORITOValidationRecord = packed record

Note: 32 Bytes
`HeaderId:Byte;`	Header ID, must be 01
`PlatformId:Byte;`	Platform ID 0 = 80x86, 1 = PowerPC, 2 = Mac
`Reserved1:Word;`	Reserved, must be 0
`VendorId:array[0..23] of Char;`	ID string. This is intended to identify the manufacturer/developer of the CD-ROM
`Checksum:Word;`	Checksum Word. This sum of all the words in this record should be 0
`Signature:Word;`	Key byte, must be 55. Key byte, must be AA. This value is included in the checksum

EL TORITO default record types

PELTORITODefaultRecord = ^TELTORITODefaultRecord;

TELTORITODefaultRecord = packed record

Note: 32 Bytes
`BootIndicator:Byte;`	Boot Indicator. 88 = Bootable, 00 = Not Bootable
`BootMedia:Byte;`	Boot media type. This specifies what media the boot image is intended to emulate
`LoadSegment:Word;`	This is the load segment for the initial boot image. If this value is 0 the system will use the traditional segment of 7C0
`SystemType:Byte;`	This must be a copy of byte 5 (System Type) from the Partition Table found in the boot image (PartitionId)
`Reserved1:Byte;`	Unused, must be 0
`LoadCount:Word;`	Sector Count. This is the number of virtual/emulated sectors the system will store at Load Segment during the initial boot procedure
`LoadRBA:LongWord;`	Load RBA. This is the start address of the virtual disk. CD's use Relative/Logical block addressing
`Reserved2:array[0..19] of Byte; {Unused, must be 0}`

EL TORITO section header types

PELTORITOSectionHeader = ^TELTORITOSectionHeader;

TELTORITOSectionHeader = packed record

Note: 32 Bytes
`HeaderIndicator:Byte;`	Header Indicator, 90 - Header, more headers follow, 91 - Final Header
`PlatformId:Byte;`	Platform ID 0 = 80x86, 1 = PowerPC, 2 = Mac
`SectionCount:Word;`	Number of section entries following this header
`SectionId:array[0..27] of Char;`	ID string. This identifies a section

EL TORITO section record types

PELTORITOSectionRecord = ^TELTORITOSectionRecord;

TELTORITOSectionRecord = packed record

Note: 32 Bytes
`BootIndicator:Byte;`	Boot Indicator. 88 = Bootable, 00 = Not Bootable
`BootMedia:Byte;`	Boot media type. This specifies what media the boot image emulates
`LoadSegment:Word;`	Load Segment. This is the load segment for the initial boot image. If this value is 0 the system will use the traditional segment of 7C0
`SystemType:Byte;`	System Type. This must be a copy of byte 5 (System Type) from the Partition Table found in the boot image (PartitionId)
`Reserved1:Byte;`	Unused, must be 0
`LoadCount:Word;`	Sector Count. This is the number of virtual/emulated sectors the system will store at Load Segment during the initial boot procedure
`LoadRBA:LongWord;`	Load RBA. This is the start address of the virtual disk. CD?s use Relative/Logical block addressing
`SelectionType:Byte;`	Selection criteria type. 0 - No selection criteria, 1- Language and Version Information (IBM), 2-FF - Reserved
`SelectionData:array[0..18] of Byte;`	Vendor unique selection criteria

EL TORITO section extension types

PELTORITOSectionExtension = ^TELTORITOSectionExtension;

TELTORITOSectionExtension = packed record

Note: 32 Bytes
`ExtensionIndicator:Byte;`	Extension Indicator. Must be 44
`ExtensionFlag:Byte;`	Bits 1-4 - Unused, Bit 5 (1 = Extension Record follows, 0 = This is final Extension), Bits 6-7 - Unused
`SelectionData:array[0..29] of Byte;`	Vendor unique selection criteria

EL TORITO volume descriptor boot types

PELTORITOVolumeDescriptorBoot = ^TELTORITOVolumeDescriptorBoot;

TELTORITOVolumeDescriptorBoot = packed record

Note: 2048 Bytes
`DescriptorType:Byte;`	Boot Record Indicator, must be 0
`StandardIdentifier:array[0..4] of Char;`	ISO-9660 Identifier, must be 'CD001'
`DescriptorVersion:Byte;`	Version of this descriptor, must be 1
`SystemIdentifier:array[0..31] of Char;`	Boot System Identifier, must be 'EL TORITO SPECIFICATION' padded with 0?s
`Reserved1:array[0..31] of Byte;`	Unused, must be 0
`CatalogStart:LongWord;`	Absolute pointer to first sector of Boot Catalog
`Reserved2:array[0..1972] of Byte;`	Unused, must be 0

Class definitions

CDFS recognizer

TCDFSRecognizer = class(TRecognizer)

`constructor Create(ADriver:TFileSysDriver);`
private
`FLongNames:Boolean;`
`FSwapSerial:Boolean;`

`function CheckPrimaryDescriptor(ASector:PSector; const AStartSector:Int64; ASectorCount:LongWord):Boolean;`
protected
`function GetName:String; override;`
public
`property LongNames:Boolean read FLongNames write FLongNames;`
`property SwapSerial:Boolean read FSwapSerial write FSwapSerial;`

`function RecognizePartitionId(APartitionId:Byte):Boolean; override;`
`function RecognizeBootSector(ABootSector:PBootSector; const AStartSector,ASectorCount:Int64):Boolean; override;`

`function RecognizePartition(APartition:TDiskPartition):Boolean; override;`
`function RecognizeVolume(AVolume:TDiskVolume):Boolean; override;`
`function MountVolume(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean; override;`

CDFS formatter

TCDFSFormatter = class(TDiskFormatter)

private
`function CheckDevice(AVolume:TDiskVolume; ADrive:TDiskDrive; AFloppyType:TFloppyType):Boolean;`
`function CheckPartition(AVolume:TDiskVolume; ADrive:TDiskDrive; AFileSysType:TFileSysType):Boolean;`

`function GetPathTableSize(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;`
`function GetPathTableStart(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary,AEndian:Boolean):LongWord;`

`function GetRootDirectorySize(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;`
`function GetRootDirectoryStart(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;`

`function CreatePrimaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;`
`function WritePrimaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;`
`function WritePrimaryPathTables(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;`
`function WritePrimaryRootDirectory(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;`

`function CreateSupplementaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;`
`function WriteSupplementaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;`
`function WriteSupplementaryPathTables(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;`
`function WriteSupplementaryRootDirectory(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;`

`function CreateTerminatorDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorTerminator):Boolean;`
`function WriteTerminatorDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorTerminator):Boolean;`
public
`function AcceptVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; override;`
`function FormatVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; override;`

CDFS resizer

TCDFSResizer = class(TDiskResizer)

public
`function AcceptVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;`

`function ShrinkVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;`
`function ExpandVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;`

CDFS copier

TCDFSCopier = class(TDiskCopier)

public
`function AcceptVolume(AVolume,ADest:TDiskVolume):Boolean; override;`

`function CopyVolume(AVolume,ADest:TDiskVolume):Boolean; override;`

CDFS file system

TCDFSFileSystem = class(TFileSystem)

`constructor Create(ADriver:TFileSysDriver; AVolume:TDiskVolume; ADrive:TDiskDrive);`
`destructor Destroy; override;`
private
`FCDFSType:TCDFSType;`
`FSwapSerial:Boolean;`
`FVolumeFlags:LongWord;`	Volume flags

`FTreesLoaded:Boolean;`
`FBlocksLoaded:Boolean;`
`FCatalogsLoaded:Boolean;`
`FCatalogsLoading:Boolean;`

`FBlockWrite:Boolean;`
`FTreesPrepared:Boolean;`
`FCatalogsChecked:Boolean;`

`FLogicalBlockSize:Word;`	Size of a logical block on disk
`FLogicalBlockCount:LongWord;`	Number of logical blocks on disk

`FSectorsPerCluster:LongWord;`	Usually 1,2,4,8,16,32,64,128 etc

`FDataStartCluster:LongWord;`	Usually 16 (First cluster of Data Area)
`FBootStartCluster:LongWord;`	Usually 17 (Cluster of the Boot Descriptor)
`FRootStartCluster:LongWord;`	Pointed to by Primary Descriptor

`FBlockShiftCount:Word;`	Shift count for Cluster <-> BlockNo
`FSectorShiftCount:Word;`	Shift count for Sector <-> Cluster
`FClusterShiftCount:Word;`	Shift count for Cluster <-> Bytes

`FEntriesPerBlock:LongWord;`	Number of Cluster entries per Block of bitmap
`FClustersPerBlock:LongWord;`	Number of Clusters per Block of bitmap entries
`FTotalBlockCount:LongWord;`	Total number of Blocks in bitmap

`FTotalClusterCount:LongWord;`	Total number of Clusters on volume

`FLastFreeCluster:LongWord;`	Or cdfsUnknownCluster if not known
`FFreeClusterCount:LongWord;`	Or cdfsUnknownCluster if not known

`FClusterSize:LongWord;`	Size of a Cluster in Bytes (Max 65536 > Word)

`FBoot:TCDFSDiskDescriptor;`
`FPrimary:TCDFSDiskDescriptor;`
`FSupplementary:TCDFSDiskDescriptor;`

`FHeaders:TFileSysList;`	List of Catalog Headers
`FExtensions:TFileSysList;`	List of Catalog Extensions
`FDescriptors:TFileSysList;`	List of Volume Descriptors

`FHeaderLocal:TMutexHandle;`	Local Lock shared by all Catalog Headers
`FExtensionLocal:TMutexHandle;`	Local Lock shared by all Catalog Extensions
`FDescriptorLocal:TMutexHandle;`	Local Lock shared by all Volume Descriptors

`FExtendedLocal:TMutexHandle;`	Local Lock shared by all Extended Attributes

`FPathLock:TSynchronizerHandle;`	Lock shared by all Path lists

`FReadBuffer:Pointer;`	Buffer for partial cluster entry reads (Cluster size)
`FReadLock:TMutexHandle;`	Lock for read buffer

`FWriteBuffer:Pointer;`	Buffer for partial cluster entry writes (Cluster size)
`FWriteLock:TMutexHandle;`	Lock for write buffer

`FClusterBuffer:Pointer;`	Buffer of exactly cluster size
`FClusterLock:TMutexHandle;`	Lock for cluster buffer

`function ReadLock:Boolean;`
`function ReadUnlock:Boolean;`

`function WriteLock:Boolean;`
`function WriteUnlock:Boolean;`

`function ClusterLock:Boolean;`
`function ClusterUnlock:Boolean;`

`function LoadTree(AEntry:TDiskEntry):Boolean;`
`function MarkTree(AEntry:TDiskEntry):Boolean;`
`function PrepareTree(AEntry:TDiskEntry):Boolean;`
`function PrepareTable(ATable:TDiskTable):Boolean;`

`function PrepareTrees:Boolean;`
`function CheckCatalogs:Boolean;`

`function LocatePath(ATable:TCDFSDiskTable; APathNumber:Word):TCDFSDiskPath;`
`function LocateEntry(AEntry:TCDFSDiskEntry; AStartCluster:LongWord):TCDFSDiskEntry;`

`function LoadVolumeFlags:LongWord;`

`function FillClusters(ACluster:LongWord; ACount:Word; AValue:Byte):Boolean;`

`function ReadClusters(ACluster:LongWord; ACount:Word; var ABuffer):Boolean;`
`function WriteClusters(ACluster:LongWord; ACount:Word; const ABuffer):Boolean;`

`function TestClusters(ACluster,ACount:LongWord):Boolean;`
`function MarkClusters(ACluster,ACount:LongWord; AUsed:Boolean):Boolean;`

`function AllocClusters(var ACluster:LongWord; ACount:LongWord):Boolean;`
`function ReleaseClusters(ACluster,ACount:LongWord):Boolean;`

`function GetNextFreeCluster:LongWord;`	Return is a Cluster
`function GetFreeClusterCount:LongWord;`

`function TestBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;`
`function MarkBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord; AUsed:Boolean):Boolean;`

`function AllocBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;`
`function ReleaseBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;`

`function GetBlockNextFree(ABlock:TCDFSDiskBlock; AStart:LongWord):LongWord;`
`function GetBlockFreeCount(ABlock:TCDFSDiskBlock):LongWord;`

`function TestBitmap(ABuffer:Pointer; ASize,AStart,ACount:LongWord):Boolean;`
`function MarkBitmap(ABuffer:Pointer; ASize,AStart,ACount:LongWord; AUsed:Boolean):Boolean;`

`function AllocBitmap(ABuffer:Pointer; ASize:LongWord; AStart,ACount:LongWord):Boolean;`
`function ReleaseBitmap(ABuffer:Pointer; ASize:LongWord; AStart,ACount:LongWord):Boolean;`

`function GetBitmapNextFree(ABuffer:Pointer; ASize,AStart:LongWord):LongWord;`
`function GetBitmapFreeCount(ABuffer:Pointer; ASize:LongWord):LongWord;`

`function GetTableDataFree(ATable:TDiskTable):LongWord;`
`function GetEntryDataFree(AEntry:TDiskEntry):LongWord;`
`function GetCatalogDataFree(ADescriptor:TCDFSDiskDescriptor):LongWord;`

`function GetPreviousPath(ATable:TCDFSDiskTable; APath:TCDFSDiskPath):TCDFSDiskPath;`
`function GetPreviousEntry(AParent,AEntry:TCDFSDiskEntry):TCDFSDiskEntry;`

`function GetSectorsPerCluster(AClusterSize:LongWord):LongWord;`
`function GetBlockShiftCount(AClusterSize:LongWord):Word;`
`function GetSectorShiftCount(AClusterSize:LongWord):Word;`
`function GetClusterShiftCount(AClusterSize:LongWord):Word;`

`function GetEntriesPerBlock(AClusterSize:LongWord):LongWord;`
`function GetClustersPerBlock(AClusterSize:LongWord):LongWord;`
`function GetTotalBlockCount(ATotalClusterCount:LongWord):LongWord;`

`function RenumberPaths(ATable:TDiskTable):Boolean;`

`function ComparePath(APath1,APath2:TCDFSDiskPath; AUnicode:Boolean):Integer;`
`function CompareEntry(AEntry1,AEntry2:TCDFSDiskEntry; AUnicode:Boolean):Integer;`

`function PadString(const AString:String; ALength:Integer; APrefix,AUnicode:Boolean):String;`
`function CompareString(const AString1,AString2:String; AReverse:Boolean):Integer;`

`function ChecksumValidationRecord(AValidation:PELTORITOValidationRecord):Word;`

`function RecordToPath(ARecord:Pointer; APath:TCDFSDiskPath; AUnicode,AEndian:Boolean):Boolean;`
`function PathToRecord(APath:TCDFSDiskPath; ARecord:Pointer; AUnicode,AEndian:Boolean):Boolean;`

`function RecordToEntry(ARecord:Pointer; AEntry:TCDFSDiskEntry; AUnicode:Boolean):Boolean;`
`function EntryToRecord(AEntry:TCDFSDiskEntry; ARecord:Pointer; AUnicode:Boolean):Boolean;`

`function CDFSTypeToFileSysType(ACDFSType:TCDFSType):TFileSysType;`
protected
`function LoadMaxFile:Integer; override;`
`function LoadMaxPath:Integer; override;`
`function LoadAttributes:LongWord; override;`
`function LoadSystemName:String; override;`
`function LoadVolumeName:String; override;`
`function LoadVolumeSerial:LongWord; override;`
`function LoadFileSysType:TFileSysType; override;`

`function SetVolumeName(const AName:String):Boolean;`
`function SetVolumeSerial(ASerial:LongWord):Boolean;`

`function ReadEntry(AParent,AEntry:TDiskEntry; var ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; override;`
`function WriteEntry(AParent,AEntry:TDiskEntry; const ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; override;`

`function LoadTrees:Boolean;`	Not override
`function LoadTables:Boolean; override;`
`function LoadBlocks:Boolean; override;`
`function LoadDescriptors:Boolean;`	Not override
`function LoadRoots:Boolean;`	Not override
`function LoadPaths(ATable:TCDFSDiskTable):Boolean;`	Not override
`function LoadEntries(AParent:TDiskEntry):Boolean; override;`
`function LoadCatalogs:Boolean; override;`

`function SetPaths(ATable:TCDFSDiskTable):Boolean;`	Not override
`function SetEntries(AParent:TDiskEntry):Boolean;`	Not override
`function SetCatalogs:Boolean;`	Not override

`function LoadTable(ATableNo:LongWord):Boolean; override;`
`function LoadBlock(ABlockNo:LongWord):Boolean; override;`
`function LoadDescriptor(ABuffer:Pointer; ACluster:LongWord):Boolean;`	Not override
`function LoadRoot(ADescriptor:TCDFSDiskDescriptor):Boolean;`	Not override
`function LoadPath(ATable:TCDFSDiskTable; ABuffer:Pointer; AOffset:LongWord; ANumber:Word):Boolean;`	Not override
`function LoadEntry(AParent:TCDFSDiskEntry; ABuffer:Pointer; AOffset,ACluster:LongWord):Boolean;`	Not override
`function LoadHeader(ABuffer:Pointer; AOffset,ACluster:LongWord; AHeaderNo:LongWord):Boolean;`	Not override
`function LoadCatalog(ABuffer:Pointer; AOffset,ACluster:LongWord; ACatalogNo:LongWord; AInitial:Boolean):Boolean;`	Not override
`function LoadExtension(ABuffer:Pointer; AOffset,ACluster:LongWord; AExtensionNo:LongWord):Boolean;`	Not override
`function LoadExtended(AEntry:TDiskEntry):Boolean;`	Not override

`function AddDescriptor(AType:Byte):TCDFSDiskDescriptor;`	Not override
`function RemoveDescriptor(ADescriptor:TCDFSDiskDescriptor):Boolean;`	Not override

`function AddPath(ATable:TDiskTable; AParentNumber:Word; const AName:String; AStartCluster:LongWord):TCDFSDiskPath;`	Not override
`function RemovePath(ATable:TDiskTable; APath:TCDFSDiskPath):Boolean;`	Not override
`function RenamePath(ATable:TDiskTable; APath:TCDFSDiskPath; const AName:String):Boolean;`	Not override
`function MovePath(ATable:TDiskTable; ADestNumber:Word; APath:TCDFSDiskPath):Boolean;`	Not override

`function AddEntry(AParent:TDiskEntry; const AName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; override;`
`function AddEntryEx(AParent:TDiskEntry; const AName,AAltName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; override;`
`function RemoveEntry(AParent,AEntry:TDiskEntry):Boolean; override;`
`function RenameEntry(AParent,AEntry:TDiskEntry; const AName:String):Boolean; override;`
`function RenameEntryEx(AParent,AEntry:TDiskEntry; const AAltName:String):Boolean; override;`
`function MoveEntry(ASource,ADest,AEntry:TDiskEntry):Boolean; override;`

`function AddCatalog(AEntry:TDiskEntry; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):TDiskCatalog; override;`
`function RemoveCatalog(ACatalog:TDiskCatalog):Boolean; override;`
`function GetNextHeaderNo:LongWord;`	Not override
`function GetMaxHeaderNo:LongWord;`	Not override
`function GetNextHeaderOffset:LongWord;`	Not override
`function GetNextHeaderCluster:LongWord;`	Not override
`function GetNextCatalogOffset:LongWord;`	Not override
`function GetNextCatalogCluster:LongWord;`	Not override

`function SetTable(ATable:TDiskTable):Boolean; override;`
`function SetBlock(ABlock:TDiskBlock):Boolean; override;`
`function SetDescriptor(ADescriptor:TCDFSDiskDescriptor):Boolean;`	Not override
`function SetRoot(ADescriptor:TCDFSDiskDescriptor; ARoot:TDiskEntry):Boolean;`	Not override
`function SetPath(ATable:TDiskTable; APath:TCDFSDiskPath; ABuffer:Pointer):Boolean;`	Not override
`function SetEntry(AParent,AEntry:TDiskEntry):Boolean; override;`
`function SetHeader(AHeader:TCDFSDiskHeader):Boolean;`	Not override
`function SetCatalog(ACatalog:TDiskCatalog):Boolean; override;`
`function SetExtension(AExtension:TCDFSDiskExtension):Boolean;`	Not override
`function SetExtended(AEntry:TDiskEntry; AExtended:TCDFSDiskExtended):Boolean;`	Not override

`function SizeEntry(AParent,AEntry:TDiskEntry; const ASize:Int64):Boolean; override;`

`function GetBlock(ABlockNo:LongWord):TDiskBlock; override;`
`function GetBlockEx(ABlockNo:LongWord; AWrite:Boolean):TDiskBlock; override;`
`function GetDescriptor(AType,AInstance:Byte):TCDFSDiskDescriptor;`	Not override
`function GetDescriptorEx(AType,AInstance:Byte; AWrite:Boolean):TCDFSDiskDescriptor;`	Not override
`function GetRoot(ADescriptor:TCDFSDiskDescriptor):TDiskEntry;`	Not override
`function GetPath(ATable:TDiskTable; AParentNumber:Word; const AName:String):TCDFSDiskPath;`	Not override
`function GetHeader(AHeaderNo:LongWord):TCDFSDiskHeader;`	Not override
`function GetHeaderEx(AHeaderNo:LongWord; AWrite:Boolean):TCDFSDiskHeader;`	Not override
`function GetExtension(AExtensionNo:LongWord):TCDFSDiskExtension;`	Not override
`function GetExtensionEx(AExtensionNo:LongWord; AWrite:Boolean):TCDFSDiskExtension;`	Not override
`function GetExtended(AEntry:TDiskEntry):TCDFSDiskExtended;`	Not override

`function GetVersion(const AName:String):String;`

`function StripDot(const AName:String):String;`
`function StripVersion(const AName:String):String;`

`function CompareName(const AName,AMatch:String; AWildcard:Boolean):Boolean; override;`
`function CompareSequence(const ASequence; const ACompare; ASize:Integer):Boolean;`
`function CompareIdentifier(const AIdentifier; const ACompare; ASize:Integer):Boolean;`

`function CalculateVolumeSerial(ABuffer:Pointer; ASize:Integer):LongWord;`
public
`property ReadOnly:Boolean read FReadOnly write FReadOnly;`
`property LongNames:Boolean read FLongNames write FLongNames;`
`property CasePreserved:Boolean read FCasePreserved write FCasePreserved;`
`property UnicodeNames:Boolean read FUnicodeNames write FUnicodeNames;`
`property SwapSerial:Boolean read FSwapSerial write FSwapSerial;`

`function FileSystemInit:Boolean; override;`

`function MountFileSystem:Boolean; override;`
`function DismountFileSystem:Boolean; override;`
`function InitializeFileSystem(ASectorsPerCluster:LongWord; AFileSysType:TFileSysType):Boolean; override;`

`function GetDriveLabel:String; override;`
`function SetDriveLabel(const ALabel:String):Boolean; override;`
`function SetDriveSerial(ASerial:LongWord):Boolean; override;`

`function GetDriveFreeSpaceEx:Int64; override;`
`function GetDriveTotalSpaceEx:Int64; override;`

CDFS disk table

TCDFSDiskTable = class(TDiskTable)

Note: Represents a CDFS path table.

`constructor Create(ALock:TSynchronizerHandle; ALocalLock:TMutexHandle; ADescriptor:TCDFSDiskDescriptor);`
`destructor Destroy; override;`
private
`FTableType:Byte;`
`FEndian:Boolean;`
`FUnicode:Boolean;`

`FPathsLoaded:Boolean;`

`FStartCluster:LongWord;`
`FClusterCount:LongWord;`

`FDataFree:LongWord;`	Data Free
`FDataSize:LongWord;`	Data Length

`FPaths:TFileSysListEx;`
`FPathLocal:TMutexHandle;`

`FDescriptor:TCDFSDiskDescriptor;`

public
`property TableType:Byte read FTableType write FTableType;`
`property Endian:Boolean read FEndian write FEndian;`
`property Unicode:Boolean read FUnicode write FUnicode;`

`property PathsLoaded:Boolean read FPathsLoaded write FPathsLoaded;`

`property StartCluster:LongWord read FStartCluster write FStartCluster;`
`property ClusterCount:LongWord read FClusterCount write FClusterCount;`

`property DataFree:LongWord read FDataFree write FDataFree;`
`property DataSize:LongWord read FDataSize write FDataSize;`

`property Paths:TFileSysListEx read FPaths;`
`property PathLocal:TMutexHandle read FPathLocal;`
`property Descriptor:TCDFSDiskDescriptor read FDescriptor;`

CDFS disk block

TCDFSDiskBlock = class(TDiskBlock)

Note: Represents a block of clusters.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FBlockCount:LongWord;`	Number of cluster entries in this block
`FBlockBuffer:Pointer;`
`FBlockCluster:LongWord;`	First cluster represented by this block

public
`property BlockCount:LongWord read FBlockCount write FBlockCount;`
`property BlockBuffer:Pointer read FBlockBuffer write FBlockBuffer;`
`property BlockCluster:LongWord read FBlockCluster write FBlockCluster;`

CDFS disk entry

TCDFSDiskEntry = class(TDiskEntry)

Note: Represents a CDFS directory entry.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FUnicode:Boolean;`
`FVersion:String;`

`FEntryOffset:LongWord;`
`FEntryCluster:LongWord;`
`FStartCluster:LongWord;`
`FClusterCount:LongWord;`

`FRecordSize:Byte;`	Length of Directory Record (LEN-DR)
`FExtendedSize:Byte;`	Extended Attribute Record Length
`FDataSize:LongWord;`	Data Length
`FUnitSize:Byte;`	File Unit Size
`FInterleaveSize:Byte;`	Interleave Gap Size
`FSequenceNumber:Word;`	Volume Sequence Number

`FDataFree:LongWord;`	Data Free

`FPath:TCDFSDiskPath;`
`FPathM:TCDFSDiskPath;`
`FAltPath:TCDFSDiskPath;`
`FAltPathM:TCDFSDiskPath;`
`FExtended:TCDFSDiskExtended;`

`function GetVersion:String;`
`procedure SetVersion(const AVersion:String);`
public
`property Unicode:Boolean read FUnicode write FUnicode;`
`property Version:String read GetVersion write SetVersion;`

`property EntryOffset:LongWord read FEntryOffset write FEntryOffset;`
`property EntryCluster:LongWord read FEntryCluster write FEntryCluster;`
`property StartCluster:LongWord read FStartCluster write FStartCluster;`
`property ClusterCount:LongWord read FClusterCount write FClusterCount;`

`property RecordSize:Byte read FRecordSize write FRecordSize;`
`property ExtendedSize:Byte read FExtendedSize write FExtendedSize;`
`property DataSize:LongWord read FDataSize write FDataSize;`
`property FirstBlock:LongWord read FStartCluster write FStartCluster;`
`property UnitSize:Byte read FUnitSize write FUnitSize;`
`property InterleaveSize:Byte read FInterleaveSize write FInterleaveSize;`
`property SequenceNumber:Word read FSequenceNumber write FSequenceNumber;`

`property DataFree:LongWord read FDataFree write FDataFree;`

`property Path:TCDFSDiskPath read FPath write FPath;`
`property PathM:TCDFSDiskPath read FPathM write FPathM;`
`property AltPath:TCDFSDiskPath read FAltPath write FAltPath;`
`property AltPathM:TCDFSDiskPath read FAltPathM write FAltPathM;`
`property Extended:TCDFSDiskExtended read FExtended write FExtended;`

`function PathNumber:Word;`
`function ParentNumber:Word;`

`function FileIdentifier:String;`
`function FileIdentifierSize:Byte;`
`function DirectoryRecordSize:Byte;`
`function ExtendedRecordSize:Byte;`

CDFS disk catalog

TCDFSDiskCatalog = class(TDiskCatalog)

Note: Represents a CDFS boot catalog entry (Also the Initial/Default entry).

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FCatalogOffset:LongWord;`
`FCatalogCluster:LongWord;`
`FStartCluster:LongWord;`
`FClusterCount:LongWord;`

`FInitial:Boolean;`
`FBootIndicator:Byte;`
`FBootMedia:Byte;`
`FLoadSegment:Word;`
`FSystemType:Byte;`
`FLoadCount:Word;`

`FSelectionType:Byte;`
`FSelectionData:Pointer;`

`FEntry:TCDFSDiskEntry;`
`FHeader:TCDFSDiskHeader;`
protected
`function GetName:String; override;`
`procedure SetName(const AName:String); override;`
`function GetMediaType:TMediaType; override;`
`procedure SetMediaType(AMediaType:TMediaType); override;`
`function GetFloppyType:TFloppyType; override;`
`procedure SetFloppyType(AFloppyType:TFloppyType); override;`
`function GetAttributes:LongWord; override;`
`procedure SetAttributes(AAttributes:LongWord); override;`
`function GetSectorSize:Word; override;`
`procedure SetSectorSize(ASectorSize:Word); override;`
`function GetSectorCount:Int64; override;`
`procedure SetSectorCount(const ASectorCount:Int64); override;`

`function GetStartCluster:LongWord;`
`procedure SetStartCluster(AStartCluster:LongWord);`
`function GetClusterCount:LongWord;`
`procedure SetClusterCount(AClusterCount:LongWord);`
public
`property CatalogOffset:LongWord read FCatalogOffset write FCatalogOffset;`
`property CatalogCluster:LongWord read FCatalogCluster write FCatalogCluster;`
`property StartCluster:LongWord read GetStartCluster write SetStartCluster;`
`property ClusterCount:LongWord read GetClusterCount write SetClusterCount;`

`property Initial:Boolean read FInitial write FInitial;`
`property BootIndicator:Byte read FBootIndicator write FBootIndicator;`
`property BootMedia:Byte read FBootMedia write FBootMedia;`
`property LoadSegment:Word read FLoadSegment write FLoadSegment;`
`property SystemType:Byte read FSystemType write FSystemType;`
`property LoadCount:Word read FLoadCount write FLoadCount;`

`property SelectionType:Byte read FSelectionType write FSelectionType;`
`property SelectionData:Pointer read FSelectionData write FSelectionData;`

`property Entry:TCDFSDiskEntry read FEntry write FEntry;`
`property Header:TCDFSDiskHeader read FHeader write FHeader;`
`property Validation:TCDFSDiskHeader read FHeader write FHeader;`

CDFS disk path

TCDFSDiskPath = class(TListObject)

Note: Represents a CDFS path table entry.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FLocalLock:TMutexHandle;`

`FName:String;`
`FHash:LongWord;`

`FPathNumber:Word;`
`FPathOffset:LongWord;`
`FStartCluster:LongWord;`

`FExtendedSize:Byte;`	Extended Attribute Record Length
`FParentNumber:Word;`	Parent Directory Number

`FParent:TCDFSDiskPath;`

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function GetName:String;`
`procedure SetName(const AName:String);`
public
`property Name:String read GetName write SetName;`
`property Hash:LongWord read FHash;`

`property PathNumber:Word read FPathNumber write FPathNumber;`
`property PathOffset:LongWord read FPathOffset write FPathOffset;`
`property StartCluster:LongWord read FStartCluster write FStartCluster;`

`property ExtendedSize:Byte read FExtendedSize write FExtendedSize;`
`property FirstBlock:LongWord read FStartCluster write FStartCluster;`
`property ParentNumber:Word read FParentNumber write FParentNumber;`

`property Parent:TCDFSDiskPath read FParent write FParent;`

`function PathIdentifier:String;`
`function PathIdentifierSize(AUnicode:Boolean):Byte;`
`function PathRecordSize(AUnicode:Boolean):Byte;`

CDFS disk extended

TCDFSDiskExtended = class(TObject)

Note: Represents a CDFS extended attribute.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FLocalLock:TMutexHandle;`

`FStartCluster:LongWord;`
`FClusterCount:LongWord;`

`FOwnerId:Word;`	Owner Identification
`FGroupId:Word;`	Group Identification
`FPermissions:Word;`	Permissions 16 bits
`FCreateTime:TFileTime;`	File Creation Date and Time
`FModifyTime:TFileTime;`	File Modification Date and Time
`FExpireTime:TFileTime;`	File Expiration Date and Time
`FEffectiveTime:TFileTime;`	File Effective Date and Time
`FRecordFormat:Byte;`	Record Format
`FRecordAttributes:Byte;`	Record Attributes
`FRecordLength:Word;`	Record Length
`FSystemIdentifier:String;`	System Identifier a-characters, a1-characters
`FSystemData:Pointer;`	System Use not specified
`FExtendedVersion:Byte;`	Extended Attribute Record Version
`FEscapeSequenceSize:Byte;`	Length of Escape Sequences (LEN_ESC)
`FApplicationDataSize:Word;`	Length of Application Use (LEN_AU)
`FApplicationData:Pointer;`	Application Use LEN_AU bytes
`FEscapeSequence:Pointer;`	Escape Sequences LEN_ESC bytes

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function GetSystemIdentifier:String;`
`procedure SetSystemIdentifier(const ASystemIdentifier:String);`
public
`property StartCluster:LongWord read FStartCluster write FStartCluster;`
`property ClusterCount:LongWord read FClusterCount write FClusterCount;`

`property OwnerId:Word read FOwnerId write FOwnerId;`
`property GroupId:Word read FGroupId write FGroupId;`
`property Permissions:Word read FPermissions write FPermissions;`
`property CreateTime:TFileTime read FCreateTime write FCreateTime;`
`property ModifyTime:TFileTime read FModifyTime write FModifyTime;`
`property ExpireTime:TFileTime read FExpireTime write FExpireTime;`
`property EffectiveTime:TFileTime read FEffectiveTime write FEffectiveTime;`
`property RecordFormat:Byte read FRecordFormat write FRecordFormat;`
`property RecordAttributes:Byte read FRecordAttributes write FRecordAttributes;`
`property RecordLength:Word read FRecordLength write FRecordLength;`
`property SystemIdentifier:String read GetSystemIdentifier write SetSystemIdentifier;`
`property SystemData:Pointer read FSystemData write FSystemData;`
`property ExtendedVersion:Byte read FExtendedVersion write FExtendedVersion;`
`property EscapeSequenceSize:Byte read FEscapeSequenceSize write FEscapeSequenceSize;`
`property ApplicationDataSize:Word read FApplicationDataSize write FApplicationDataSize;`
`property ApplicationData:Pointer read FApplicationData write FApplicationData;`
`property EscapeSequence:Pointer read FEscapeSequence write FEscapeSequence;`

`function ExtendedRecordSize:Byte;`

CDFS disk descriptor

TCDFSDiskDescriptor = class(TListObject)

Note: Represents a CDFS volume descriptor.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FLocalLock:TMutexHandle;`

`FUnicode:Boolean;`

`FStartCluster:LongWord;`

`FDescriptorType:Byte;`	Descriptor Type (00 = Boot, 01 = Primary etc)
`FDescriptorVersion:Byte;`	Descriptor Version (1)
`FStandardIdentifier:String;`	Standard Identifier ('CD001')

`FSystemIdentifier:String;`	System Identifier a-characters (eg EL TORITO SPECIFICATION)
`FVolumeIdentifier:String;`	Volume Identifier d-characters
`FVolumeSpaceSize:LongWord;`	Volume Space Size
`FVolumeSetSize:Word;`	Volume Set Size
`FVolumeSequenceNumber:Word;`	Volume Sequence Number
`FLogicalBlockSize:Word;`	Logical Block Size
`FPathTableSize:LongWord;`	Path Table Size
`FPrimaryPathTable:LongWord;`	Location of Occurrence of Type L Path Table
`FAlternatePathTable:LongWord;`	Location of Optional Occurrence of Type L Path Table
`FPrimaryPathTableM:LongWord;`	Location of Occurrence of Type M Path Table
`FAlternatePathTableM:LongWord;`	Location of Optional Occurrence of Type M Path Table
`FVolumeSetIdentifier:String;`	Volume Set Identifier d-characters
`FPublisherIdentifier:String;`	Publisher Identifier a-characters
`FPreparerIdentifier:String;`	Data Preparer Identifier a-characters
`FApplicationIdentifier:String;`	Application Identifier a-characters
`FCopyrightIdentifier:String;`	Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`FAbstractIdentifier:String;`	Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`FBibliographicIdentifier:String;`	Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
`FCreateTime:TFileTime;`	Volume Creation Date and Time
`FModifyTime:TFileTime;`	Volume Modification Date and Time
`FExpireTime:TFileTime;`	Volume Expiration Date and Time
`FEffectiveTime:TFileTime;`	Volume Effective Date and Time
`FFileStructureVersion:Byte;`	File Structure Version
`FApplicationData:Pointer;`	Application Use not specified

`FVolumeFlags:Byte;`	Volume Flags 8 bits
`FEscapeSequences:Pointer;`	Escape Sequences 32 bytes

`FBootIdentifier:String;`	32 a-characters
`FCatalogStart:LongWord;`	Absolute pointer to first sector of Boot Catalog
`FCatalogCount:LongWord;`	Number of Sectors in Boot Catalog (Not Stored)

`FPartitionIdentifier:String;`	Volume Partition Identifier d-characters
`FPartitionStart:LongWord;`	Volume Partition Location (first Logical Block)
`FPartitionSize:LongWord;`	Volume Partition Size (in Logical Blocks)
`FSystemData:Pointer;`	System Use not specified

`FRoot:TCDFSDiskEntry;`
`FPrimary:TCDFSDiskTable;`
`FPrimaryM:TCDFSDiskTable;`
`FAlternate:TCDFSDiskTable;`
`FAlternateM:TCDFSDiskTable;`

`FInitial:TCDFSDiskCatalog;`
`FValidation:TCDFSDiskHeader;`

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function GetStandardIdentifier:String;`
`procedure SetStandardIdentifier(const AStandardIdentifier:String);`

`function GetSystemIdentifier:String;`
`procedure SetSystemIdentifier(const ASystemIdentifier:String);`
`function GetVolumeIdentifier:String;`
`procedure SetVolumeIdentifier(const AVolumeIdentifier:String);`

`function GetVolumeSetIdentifier:String;`
`procedure SetVolumeSetIdentifier(const AVolumeSetIdentifier:String);`
`function GetPublisherIdentifier:String;`
`procedure SetPublisherIdentifier(const APublisherIdentifier:String);`
`function GetPreparerIdentifier:String;`
`procedure SetPreparerIdentifier(const APreparerIdentifier:String);`
`function GetApplicationIdentifier:String;`
`procedure SetApplicationIdentifier(const AApplicationIdentifier:String);`
`function GetCopyrightIdentifier:String;`
`procedure SetCopyrightIdentifier(const ACopyrightIdentifier:String);`
`function GetAbstractIdentifier:String;`
`procedure SetAbstractIdentifier(const AAbstractIdentifier:String);`
`function GetBibliographicIdentifier:String;`
`procedure SetBibliographicIdentifier(const ABibliographicIdentifier:String);`

`function GetBootIdentifier:String;`
`procedure SetBootIdentifier(const ABootIdentifier:String);`

`function GetPartitionIdentifier:String;`
`procedure SetPartitionIdentifier(const APartitionIdentifier:String);`
public
`property Unicode:Boolean read FUnicode write FUnicode;`

`property StartCluster:LongWord read FStartCluster write FStartCluster;`

`property DescriptorType:Byte read FDescriptorType write FDescriptorType;`
`property DescriptorVersion:Byte read FDescriptorVersion write FDescriptorVersion;`
`property StandardIdentifier:String read GetStandardIdentifier write SetStandardIdentifier;`

`property SystemIdentifier:String read GetSystemIdentifier write SetSystemIdentifier;`
`property VolumeIdentifier:String read GetVolumeIdentifier write SetVolumeIdentifier;`
`property VolumeSpaceSize:LongWord read FVolumeSpaceSize write FVolumeSpaceSize;`
`property VolumeSetSize:Word read FVolumeSetSize write FVolumeSetSize;`
`property VolumeSequenceNumber:Word read FVolumeSequenceNumber write FVolumeSequenceNumber;`
`property LogicalBlockSize:Word read FLogicalBlockSize write FLogicalBlockSize;`
`property PathTableSize:LongWord read FPathTableSize write FPathTableSize;`
`property PrimaryPathTable:LongWord read FPrimaryPathTable write FPrimaryPathTable;`
`property AlternatePathTable:LongWord read FAlternatePathTable write FAlternatePathTable;`
`property PrimaryPathTableM:LongWord read FPrimaryPathTableM write FPrimaryPathTableM;`
`property AlternatePathTableM:LongWord read FAlternatePathTableM write FAlternatePathTableM;`
`property VolumeSetIdentifier:String read GetVolumeSetIdentifier write SetVolumeSetIdentifier;`
`property PublisherIdentifier:String read GetPublisherIdentifier write SetPublisherIdentifier;`
`property PreparerIdentifier:String read GetPreparerIdentifier write SetPreparerIdentifier;`
`property ApplicationIdentifier:String read GetApplicationIdentifier write SetApplicationIdentifier;`
`property CopyrightIdentifier:String read GetCopyrightIdentifier write SetCopyrightIdentifier;`
`property AbstractIdentifier:String read GetAbstractIdentifier write SetAbstractIdentifier;`
`property BibliographicIdentifier:String read GetBibliographicIdentifier write SetBibliographicIdentifier;`
`property CreateTime:TFileTime read FCreateTime write FCreateTime;`
`property ModifyTime:TFileTime read FModifyTime write FModifyTime;`
`property ExpireTime:TFileTime read FExpireTime write FExpireTime;`
`property EffectiveTime:TFileTime read FEffectiveTime write FEffectiveTime;`
`property FileStructureVersion:Byte read FFileStructureVersion write FFileStructureVersion;`
`property ApplicationData:Pointer read FApplicationData write FApplicationData;`

`property VolumeFlags:Byte read FVolumeFlags write FVolumeFlags;`
`property EscapeSequences:Pointer read FEscapeSequences write FEscapeSequences;`

`property BootIdentifier:String read GetBootIdentifier write SetBootIdentifier;`
`property CatalogStart:LongWord read FCatalogStart write FCatalogStart;`
`property CatalogCount:LongWord read FCatalogCount write FCatalogCount;`

`property PartitionIdentifier:String read GetPartitionIdentifier write SetPartitionIdentifier;`
`property PartitionStart:LongWord read FPartitionStart write FPartitionStart;`
`property PartitionSize:LongWord read FPartitionSize write FPartitionSize;`
`property SystemData:Pointer read FSystemData write FSystemData;`

`property Root:TCDFSDiskEntry read FRoot write FRoot;`
`property Primary:TCDFSDiskTable read FPrimary write FPrimary;`
`property PrimaryM:TCDFSDiskTable read FPrimaryM write FPrimaryM;`
`property Alternate:TCDFSDiskTable read FAlternate write FAlternate;`
`property AlternateM:TCDFSDiskTable read FAlternateM write FAlternateM;`

`property Initial:TCDFSDiskCatalog read FInitial write FInitial;`
`property Validation:TCDFSDiskHeader read FValidation write FValidation;`

CDFS disk header

TCDFSDiskHeader = class(TListObject)

Note: Represents a CDFS catalog header (Also the Validation entry).

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FLocalLock:TMutexHandle;`

`FHeaderNo:LongWord;`

`FHeaderOffset:LongWord;`
`FHeaderCluster:LongWord;`

`FValidation:Boolean;`
`FHeaderId:Byte;`
`FPlatformId:Byte;`
`FVendorId:String;`
`FChecksum:Word;`
`FSignature:Word;`

`FSectionCount:Word;`

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`

`function GetVendorId:String;`
`procedure SetVendorId(const AVendorId:String);`
public
`property HeaderNo:LongWord read FHeaderNo write FHeaderNo;`

`property HeaderOffset:LongWord read FHeaderOffset write FHeaderOffset;`
`property HeaderCluster:LongWord read FHeaderCluster write FHeaderCluster;`

`property Validation:Boolean read FValidation write FValidation;`
`property HeaderId:Byte read FHeaderId write FHeaderId;`
`property PlatformId:Byte read FPlatformId write FPlatformId;`
`property VendorId:String read GetVendorId write SetVendorId;`
`property Checksum:Word read FChecksum write FChecksum;`
`property Signature:Word read FSignature write FSignature;`

`property HeaderIndicator:Byte read FHeaderId write FHeaderId;`
`property SectionCount:Word read FSectionCount write FSectionCount;`
`property SectionId:String read GetVendorId write SetVendorId;`

CDFS disk extension

TCDFSDiskExtension = class(TListObject)

Note: Represents a CDFS catalog extension.

`constructor Create(ALocalLock:TMutexHandle);`
`destructor Destroy; override;`
private
`FLocalLock:TMutexHandle;`

`FExtensionNo:LongWord;`

`FExtensionOffset:LongWord;`
`FExtensionCluster:LongWord;`

`FExtensionIndicator:Byte;`
`FExtensionFlag:Byte;`
`FSelectionData:Pointer;`

`FCatalog:TCDFSDiskCatalog;`

`function AcquireLock:Boolean;`
`function ReleaseLock:Boolean;`
public
`property ExtensionNo:LongWord read FExtensionNo write FExtensionNo;`

`property ExtensionOffset:LongWord read FExtensionOffset write FExtensionOffset;`
`property ExtensionCluster:LongWord read FExtensionCluster write FExtensionCluster;`

`property ExtensionIndicator:Byte read FExtensionIndicator write FExtensionIndicator;`
`property ExtensionFlag:Byte read FExtensionFlag write FExtensionFlag;`
`property SelectionData:Pointer read FSelectionData write FSelectionData;`

`property Catalog:TCDFSDiskCatalog read FCatalog write FCatalog;`

Public variables

None defined

Function declarations

Initialization functions

procedure CDFSInit;

Description: To be documented

Note	None documented

procedure CDFSQuit;

Description: To be documented

Note	None documented

CDFS helper functions

function CDFSDataToPointer(const AData; ASize:Integer; ASwap:Boolean):Pointer;

Description: Creates a pointer and copies data from a buffer

Note	Allows byte order swapping on copy

function CDFSPointerToData(APointer:Pointer; var AData; ASize:Integer; ASwap:Boolean):Boolean;

Description: Copies data to a buffer from supplied pointer

Note	Allows byte order swapping on copy

function CDFSIdentifierToString(const AIdentifier; ASize:Integer; AUnicode:Boolean):String;

Description: Converts the supplied indentifier to a string

Note	Accounts for unicode and byte ordering

function CDFSStringToIdentifier(const AString:String; var AIdentifier; ASize:Integer; AUnicode:Boolean):Boolean;

Description: Converts the supplied string to an identifier

Note	Accounts for unicode and byte ordering

function CDFSIdentifierToFileName(const AIdentifier; ASize:Integer; AUnicode:Boolean):String;

Description: Converts the supplied identifier to a filename

Note	Accounts for dot and dot dot special entries

function CDFSFileNameToIdentifier(const AFileName:String; var AIdentifier; ASize:Integer; AUnicode:Boolean):Boolean;

Description: Converts the supplied filename to an identifier

Note	Accounts for dot and dot dot special entries

function CDFSTimeToFileTime(const ATime:TCDFSTime):TFileTime;

Description: Converts a CDFS Time in Local to a File Time in UTC

Note	None documented

function FileTimeToCDFSTime(const AFileTime:TFileTime; var ATime:TCDFSTime):Boolean;

Description: Converts a File Time in UTC to a CDFS Time in Local

Note	None documented

function CDFSDateTimeToFileTime(const ADateTime:TCDFSDateTime):TFileTime;

Description: Converts a CDFS Date Time in Local to a File Time in UTC

Note	None documented

function FileTimeToCDFSDateTime(const AFileTime:TFileTime; var ADateTime:TCDFSDateTime):Boolean;

Description: Converts a File Time in UTC to a CDFS Date Time in Local

Note	None documented

Return to Unit Reference

@@ Line 1,243: / Line 1,243: @@
 |-
 | <code>LoadRBA:LongWord;</code>
-| Load RBA. This is the start address of the virtual disk. CD?s use Relative/Logical block addressing
+| Load RBA. This is the start address of the virtual disk. CD's use Relative/Logical block addressing
 |-
 | <code>Reserved2:array[0..19] of Byte; {Unused, must be 0}</code>

Difference between revisions of "Unit CDFS"

Revision as of 03:39, 9 March 2017

Contents

Description

Constants

Type definitions

Class definitions

Public variables

Function declarations

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Tools