---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: FileAccess
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkFileAccessRef.html
---
# Chilkat FileAccess — Delphi DLL — v11.7.0

> Chilkat 11.7.0 · language=delphidll · class=FileAccess
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/FileAccess.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/guide.md`.

## Purpose

**Read, write, compare, copy, split, inspect, and manage files and paths.**

`Chilkat.FileAccess` provides general-purpose file-system utilities for applications that need direct control over files, directories, paths, timestamps, and low-level file operations. It can read, write, append, seek, compare, copy, rename, delete, split, reassemble, and inspect files, and also includes helpers for directory operations, path parsing, symbolic links, temporary filenames, block-based reading, fragment scanning, text replacement, and open-file access.

**Read and write files**

Load or save text and binary files, append data, replace file contents, and work with explicit character encodings when needed.

**File management**

Copy, rename, delete, compare, split, reassemble, and inspect files using straightforward file-system utility methods.

**Directories and paths**

Create, remove, check, and work with directories, and use path helpers to extract filenames, extensions, directory names, and related path parts.

**Open-file operations**

Open files for lower-level reading or writing, seek within files, read blocks, and process large files without loading everything at once.

**Timestamps and metadata**

Get or set file times, inspect sizes and existence, and use metadata helpers when coordinating file processing workflows.

**Special file utilities**

Generate temporary filenames, work with symbolic links, scan for byte fragments, and perform text replacement in files.

**Common pattern:** Use `FileAccess` for local file-system tasks that are outside the scope of a specific protocol class. It is especially useful for preparing files before upload, saving downloaded data, comparing or splitting files, reading large files in blocks, manipulating paths, or performing small filesystem operations without using platform-specific APIs.

For an extended overview, see [FileAccess Class Overview](https://www.chilkatsoft.com/fileaccess_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkFileAccess;

begin
myObject := CkFileAccess_Create();

// ...

CkFileAccess_Dispose(myObject);
end;
```

`function CkFileAccess_Create: HCkFileAccess; stdcall;`

Creates an instance of the HCkFileAccess object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

`procedure CkFileAccess_Dispose(handle: HCkFileAccess); stdcall;`

Objects created by calling CkFileAccess_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Delphi DLL.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `procedure CkFileAccess_getDebugLogFilePath(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; procedure CkFileAccess_putDebugLogFilePath(objHandle: HCkFileAccess; newPropVal: PWideChar); stdcall; function CkFileAccess__debugLogFilePath(objHandle: HCkFileAccess): PWideChar; stdcall;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `procedure CkFileAccess_getLastErrorHtml(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__lastErrorHtml(objHandle: HCkFileAccess): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkFileAccess_getLastErrorText(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__lastErrorText(objHandle: HCkFileAccess): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkFileAccess_getLastErrorXml(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__lastErrorXml(objHandle: HCkFileAccess): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkFileAccess_getLastMethodSuccess(objHandle: HCkFileAccess): wordbool; stdcall; procedure CkFileAccess_putLastMethodSuccess(objHandle: HCkFileAccess; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkFileAccess_getVerboseLogging(objHandle: HCkFileAccess): wordbool; stdcall; procedure CkFileAccess_putVerboseLogging(objHandle: HCkFileAccess; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkFileAccess_getVersion(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__version(objHandle: HCkFileAccess): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `CurrentDir` | property, read-only | `procedure CkFileAccess_getCurrentDir(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__currentDir(objHandle: HCkFileAccess): PWideChar; stdcall;` |
| `EndOfFile` | property, read-only | `function CkFileAccess_getEndOfFile(objHandle: HCkFileAccess): wordbool; stdcall;` |
| `FileOpenError` | property, read-only | `function CkFileAccess_getFileOpenError(objHandle: HCkFileAccess): Integer; stdcall;` |
| `FileOpenErrorMsg` | property, read-only | `procedure CkFileAccess_getFileOpenErrorMsg(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall; function CkFileAccess__fileOpenErrorMsg(objHandle: HCkFileAccess): PWideChar; stdcall;` |
| `LockFileOnOpen` | property, read/write | `function CkFileAccess_getLockFileOnOpen(objHandle: HCkFileAccess): wordbool; stdcall; procedure CkFileAccess_putLockFileOnOpen(objHandle: HCkFileAccess; newPropVal: wordbool); stdcall;` |
| `AppendAnsi` | method | `function CkFileAccess_AppendAnsi(objHandle: HCkFileAccess;     text: PWideChar): wordbool; stdcall;` |
| `AppendBd` | method | `function CkFileAccess_AppendBd(objHandle: HCkFileAccess;     bd: HCkBinData): wordbool; stdcall;` |
| `AppendSb` | method | `function CkFileAccess_AppendSb(objHandle: HCkFileAccess;     sb: HCkStringBuilder;     charset: PWideChar): wordbool; stdcall;` |
| `AppendText` | method | `function CkFileAccess_AppendText(objHandle: HCkFileAccess;     str: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `AppendUnicodeBOM` | method | `function CkFileAccess_AppendUnicodeBOM(objHandle: HCkFileAccess): wordbool; stdcall;` |
| `AppendUtf8BOM` | method | `function CkFileAccess_AppendUtf8BOM(objHandle: HCkFileAccess): wordbool; stdcall;` |
| `DirAutoCreate` | method | `function CkFileAccess_DirAutoCreate(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `DirCreate` | method | `function CkFileAccess_DirCreate(objHandle: HCkFileAccess;     dirPath: PWideChar): wordbool; stdcall;` |
| `DirDelete` | method | `function CkFileAccess_DirDelete(objHandle: HCkFileAccess;     dirPath: PWideChar): wordbool; stdcall;` |
| `DirEnsureExists` | method | `function CkFileAccess_DirEnsureExists(objHandle: HCkFileAccess;     dirPath: PWideChar): wordbool; stdcall;` |
| `DirExists` | method | `function CkFileAccess_DirExists(objHandle: HCkFileAccess;     dirPath: PWideChar): wordbool; stdcall;` |
| `FileClose` | method | `procedure CkFileAccess_FileClose(objHandle: HCkFileAccess) stdcall;` |
| `FileContentsEqual` | method | `function CkFileAccess_FileContentsEqual(objHandle: HCkFileAccess;     filePath1: PWideChar;     filePath2: PWideChar): wordbool; stdcall;` |
| `FileCopy` | method | `function CkFileAccess_FileCopy(objHandle: HCkFileAccess;     existingFilepath: PWideChar;     newFilepath: PWideChar;     failIfExists: wordbool): wordbool; stdcall;` |
| `FileDelete` | method | `function CkFileAccess_FileDelete(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `FileExists` | method | `function CkFileAccess_FileExists(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `FileExists3` | method | `function CkFileAccess_FileExists3(objHandle: HCkFileAccess;     path: PWideChar): Integer; stdcall;` |
| `FileOpen` | method | `function CkFileAccess_FileOpen(objHandle: HCkFileAccess;     filePath: PWideChar;     accessMode: LongWord;     shareMode: LongWord;     createDisposition: LongWord;     attributes: LongWord): wordbool; stdcall;` |
| `FileReadBd` | method | `function CkFileAccess_FileReadBd(objHandle: HCkFileAccess;     maxNumBytes: Integer;     binData: HCkBinData): wordbool; stdcall;` |
| `FileRename` | method | `function CkFileAccess_FileRename(objHandle: HCkFileAccess;     existingFilepath: PWideChar;     newFilepath: PWideChar): wordbool; stdcall;` |
| `FileSeek` | method | `function CkFileAccess_FileSeek(objHandle: HCkFileAccess;     offset: Integer;     origin: Integer): wordbool; stdcall;` |
| `FileSize` | method | `function CkFileAccess_FileSize(objHandle: HCkFileAccess;     filePath: PWideChar): Integer; stdcall;` |
| `FileSize64` | method | `function CkFileAccess_FileSize64(objHandle: HCkFileAccess;     filePath: PWideChar): Int64; stdcall;` |
| `FileSizeStr` | method | `function CkFileAccess_FileSizeStr(objHandle: HCkFileAccess;     filePath: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__fileSizeStr(objHandle: HCkFileAccess;     filePath: PWideChar): PWideChar; stdcall;` |
| `FileType` | method | `function CkFileAccess_FileType(objHandle: HCkFileAccess;     path: PWideChar): Integer; stdcall;` |
| `FileWriteBd` | method | `function CkFileAccess_FileWriteBd(objHandle: HCkFileAccess;     binData: HCkBinData;     offset: Integer;     numBytes: Integer): wordbool; stdcall;` |
| `GenBlockId` | method | `function CkFileAccess_GenBlockId(objHandle: HCkFileAccess;     index: Integer;     length: Integer;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__genBlockId(objHandle: HCkFileAccess;     index: Integer;     length: Integer;     encoding: PWideChar): PWideChar; stdcall;` |
| `GetDirectoryName` | method | `function CkFileAccess_GetDirectoryName(objHandle: HCkFileAccess;     path: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getDirectoryName(objHandle: HCkFileAccess;     path: PWideChar): PWideChar; stdcall;` |
| `GetExtension` | method | `function CkFileAccess_GetExtension(objHandle: HCkFileAccess;     path: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getExtension(objHandle: HCkFileAccess;     path: PWideChar): PWideChar; stdcall;` |
| `GetFileName` | method | `function CkFileAccess_GetFileName(objHandle: HCkFileAccess;     path: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getFileName(objHandle: HCkFileAccess;     path: PWideChar): PWideChar; stdcall;` |
| `GetFileNameWithoutExtension` | method | `function CkFileAccess_GetFileNameWithoutExtension(objHandle: HCkFileAccess;     path: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getFileNameWithoutExtension(objHandle: HCkFileAccess;     path: PWideChar): PWideChar; stdcall;` |
| `GetFileTimeStr` | method | `function CkFileAccess_GetFileTimeStr(objHandle: HCkFileAccess;     path: PWideChar;     which: Integer;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getFileTimeStr(objHandle: HCkFileAccess;     path: PWideChar;     which: Integer): PWideChar; stdcall;` |
| `GetNumBlocks` | method | `function CkFileAccess_GetNumBlocks(objHandle: HCkFileAccess;     blockSize: Integer): Integer; stdcall;` |
| `GetTempFilename` | method | `function CkFileAccess_GetTempFilename(objHandle: HCkFileAccess;     dirPath: PWideChar;     prefix: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__getTempFilename(objHandle: HCkFileAccess;     dirPath: PWideChar;     prefix: PWideChar): PWideChar; stdcall;` |
| `OpenForAppend` | method | `function CkFileAccess_OpenForAppend(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `OpenForRead` | method | `function CkFileAccess_OpenForRead(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `OpenForReadWrite` | method | `function CkFileAccess_OpenForReadWrite(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `OpenForWrite` | method | `function CkFileAccess_OpenForWrite(objHandle: HCkFileAccess;     filePath: PWideChar): wordbool; stdcall;` |
| `ReadBinaryToEncoded` | method | `function CkFileAccess_ReadBinaryToEncoded(objHandle: HCkFileAccess;     filePath: PWideChar;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__readBinaryToEncoded(objHandle: HCkFileAccess;     filePath: PWideChar;     encoding: PWideChar): PWideChar; stdcall;` |
| `ReadBlockBd` | method | `function CkFileAccess_ReadBlockBd(objHandle: HCkFileAccess;     blockIndex: Integer;     blockSize: Integer;     bd: HCkBinData): wordbool; stdcall;` |
| `ReadEntireTextFile` | method | `function CkFileAccess_ReadEntireTextFile(objHandle: HCkFileAccess;     filePath: PWideChar;     charset: PWideChar;     outStrFileContents: HCkString): wordbool; stdcall; function CkFileAccess__readEntireTextFile(objHandle: HCkFileAccess;     filePath: PWideChar;     charset: PWideChar): PWideChar; stdcall;` |
| `ReadNextFragment` | method | `function CkFileAccess_ReadNextFragment(objHandle: HCkFileAccess;     startAtBeginning: wordbool;     beginMarker: PWideChar;     endMarker: PWideChar;     charset: PWideChar;     sb: HCkStringBuilder): Integer; stdcall;` |
| `ReassembleFile` | method | `function CkFileAccess_ReassembleFile(objHandle: HCkFileAccess;     partsDirPath: PWideChar;     partPrefix: PWideChar;     partExtension: PWideChar;     reassembledFilename: PWideChar): wordbool; stdcall;` |
| `ReplaceStrings` | method | `function CkFileAccess_ReplaceStrings(objHandle: HCkFileAccess;     filePath: PWideChar;     charset: PWideChar;     existingString: PWideChar;     replacementString: PWideChar): Integer; stdcall;` |
| `SetCurrentDir` | method | `function CkFileAccess_SetCurrentDir(objHandle: HCkFileAccess;     dirPath: PWideChar): wordbool; stdcall;` |
| `SetFileTimes` | method | `function CkFileAccess_SetFileTimes(objHandle: HCkFileAccess;     filePath: PWideChar;     createTime: HCkDateTime;     lastAccessTime: HCkDateTime;     lastModTime: HCkDateTime): wordbool; stdcall;` |
| `SetLastModified` | method | `function CkFileAccess_SetLastModified(objHandle: HCkFileAccess;     filePath: PWideChar;     lastModified: HCkDateTime): wordbool; stdcall;` |
| `SplitFile` | method | `function CkFileAccess_SplitFile(objHandle: HCkFileAccess;     fileToSplit: PWideChar;     partPrefix: PWideChar;     partExtension: PWideChar;     partSize: Integer;     destDir: PWideChar): wordbool; stdcall;` |
| `SymlinkCreate` | method | `function CkFileAccess_SymlinkCreate(objHandle: HCkFileAccess;     targetPath: PWideChar;     linkPath: PWideChar): wordbool; stdcall;` |
| `SymlinkTarget` | method | `function CkFileAccess_SymlinkTarget(objHandle: HCkFileAccess;     linkPath: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkFileAccess__symlinkTarget(objHandle: HCkFileAccess;     linkPath: PWideChar): PWideChar; stdcall;` |
| `TreeDelete` | method | `function CkFileAccess_TreeDelete(objHandle: HCkFileAccess;     path: PWideChar): wordbool; stdcall;` |
| `Truncate` | method | `function CkFileAccess_Truncate(objHandle: HCkFileAccess): wordbool; stdcall;` |
| `WriteEntireTextFile` | method | `function CkFileAccess_WriteEntireTextFile(objHandle: HCkFileAccess;     filePath: PWideChar;     textData: PWideChar;     charset: PWideChar;     includedPreamble: wordbool): wordbool; stdcall;` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### FileAccess.CurrentDir

`Chilkat 11.7.0 · delphidll · FileAccess · CurrentDir · property · read-only`

```pascal
procedure CkFileAccess_getCurrentDir(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall;
function CkFileAccess__currentDir(objHandle: HCkFileAccess): PWideChar; stdcall;
```

Returns the current working directory of the calling process. Relative file and directory paths are resolved against this process-wide working directory.

**Process-wide setting:** The working directory belongs to the process, not to an individual `FileAccess` object. Changing it can therefore affect relative-path behavior elsewhere in the application.

### FileAccess.EndOfFile

`Chilkat 11.7.0 · delphidll · FileAccess · EndOfFile · property · read-only`

```pascal
function CkFileAccess_getEndOfFile(objHandle: HCkFileAccess): wordbool; stdcall;
```

Returns `True` when the currently open file is positioned at end-of-file; otherwise returns `False`.

**Open-file state:** This property applies to the file opened by `OpenForRead`, `OpenForWrite`, `OpenForReadWrite`, `OpenForAppend`, or `FileOpen`.

### FileAccess.FileOpenError

`Chilkat 11.7.0 · delphidll · FileAccess · FileOpenError · property · read-only`

```pascal
function CkFileAccess_getFileOpenError(objHandle: HCkFileAccess): Integer; stdcall;
```

Provides the detailed open-error code from the most recent call to `FileOpen`, `OpenForRead`, `OpenForWrite`, `OpenForReadWrite`, or `OpenForAppend`.

| Code | Meaning |
| :--- | :--- |
| `0` | Success; no open error. |
| `1` | Access denied. |
| `2` | File not found. |
| `3` | General, non-specific open error. |
| `4` | File already exists. |
| `5` | The path refers to a directory and the requested access involves writing. |
| `6` | Too many symbolic links were encountered while resolving the path. |
| `7` | The process already has the maximum number of files open. |
| `8` | The pathname is too long. |
| `9` | The system-wide limit on open files has been reached. |
| `10` | The pathname refers to a device special file for which no corresponding device exists. |
| `11` | Insufficient kernel memory was available. |
| `12` | A file was to be created, but the containing device has no space available. |
| `13` | A pathname component expected to be a directory is not a directory. |
| `14` | The regular file is too large to be opened because of an operating-system limitation. |
| `15` | The path is on a read-only filesystem and write access was requested. |

**Use with FileOpenErrorMsg:** `FileOpenError` is useful for programmatic handling; `FileOpenErrorMsg` provides the corresponding human-readable message.

### FileAccess.FileOpenErrorMsg

`Chilkat 11.7.0 · delphidll · FileAccess · FileOpenErrorMsg · property · read-only`

```pascal
procedure CkFileAccess_getFileOpenErrorMsg(objHandle: HCkFileAccess; outPropVal: HCkString); stdcall;
function CkFileAccess__fileOpenErrorMsg(objHandle: HCkFileAccess): PWideChar; stdcall;
```

Returns the human-readable message corresponding to `FileOpenError` for the most recent file-open attempt.

### FileAccess.LockFileOnOpen

`Chilkat 11.7.0 · delphidll · FileAccess · LockFileOnOpen · property · read/write · since 9.5.0.80`

```pascal
function CkFileAccess_getLockFileOnOpen(objHandle: HCkFileAccess): wordbool; stdcall;
procedure CkFileAccess_putLockFileOnOpen(objHandle: HCkFileAccess; newPropVal: wordbool); stdcall;
```

**Windows only.** If `True`, `OpenForAppend`, `OpenForRead`, `OpenForReadWrite`, and `OpenForWrite` request exclusive access to the file. Other processes are prevented from opening the file until `FileClose` releases the handle. The default is `False`.

**File sharing:** Windows file sharing is established when the file handle is opened. Set this property before calling an `OpenFor*` method.

## Methods

### FileAccess.AppendAnsi

`Chilkat 11.7.0 · delphidll · FileAccess · AppendAnsi · method`

```pascal
function CkFileAccess_AppendAnsi(objHandle: HCkFileAccess;
    text: PWideChar): wordbool; stdcall;
```

Appends `text` to the currently open file after converting the string to the legacy ANSI character encoding used by Chilkat for the platform.

**Character encoding:** Use `AppendText` or `AppendSb` when an explicit encoding such as `utf-8` is preferred.

Returns True for success, False for failure.

### FileAccess.AppendBd

`Chilkat 11.7.0 · delphidll · FileAccess · AppendBd · method · since 9.5.0.76`

```pascal
function CkFileAccess_AppendBd(objHandle: HCkFileAccess;
    bd: HCkBinData): wordbool; stdcall;
```

Appends all bytes contained in `bd` to the currently open file without text conversion.

Returns True for success, False for failure.

### FileAccess.AppendSb

`Chilkat 11.7.0 · delphidll · FileAccess · AppendSb · method · since 9.5.0.76`

```pascal
function CkFileAccess_AppendSb(objHandle: HCkFileAccess;
    sb: HCkStringBuilder;
    charset: PWideChar): wordbool; stdcall;
```

Appends the text contained in `sb` to the currently open file using the character encoding specified by `charset`.

Returns True for success, False for failure.

### FileAccess.AppendText

`Chilkat 11.7.0 · delphidll · FileAccess · AppendText · method`

```pascal
function CkFileAccess_AppendText(objHandle: HCkFileAccess;
    str: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Appends `str` to the currently open file after encoding the text with the character set named by `charset`, such as `utf-8` or `iso-8859-1`.

Returns True for success, False for failure.

### FileAccess.AppendUnicodeBOM

`Chilkat 11.7.0 · delphidll · FileAccess · AppendUnicodeBOM · method`

```pascal
function CkFileAccess_AppendUnicodeBOM(objHandle: HCkFileAccess): wordbool; stdcall;
```

Appends the UTF-16 little-endian byte-order mark to the currently open file. The two bytes written are `FF FE`.

**BOM placement:** A BOM normally belongs at the beginning of a text file. This method appends bytes at the current write position, so call it before writing text when creating a new UTF-16LE file.

Returns True for success, False for failure.

### FileAccess.AppendUtf8BOM

`Chilkat 11.7.0 · delphidll · FileAccess · AppendUtf8BOM · method`

```pascal
function CkFileAccess_AppendUtf8BOM(objHandle: HCkFileAccess): wordbool; stdcall;
```

Appends the UTF-8 byte-order mark to the currently open file. The three bytes written are `EF BB BF`.

**UTF-8 BOM:** A UTF-8 BOM is optional. Some software uses it as an encoding signature, while other software expects BOM-less UTF-8.

Returns True for success, False for failure.

### FileAccess.DirAutoCreate

`Chilkat 11.7.0 · delphidll · FileAccess · DirAutoCreate · method`

```pascal
function CkFileAccess_DirAutoCreate(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Ensures that the directory portion of `filePath` exists. Any missing parent directories are created; the final path component is treated as a filename and is not created as a directory.

**Difference from DirEnsureExists:** Use `DirAutoCreate` when you have a file path. Use `DirEnsureExists` when the argument itself is a directory path.

Returns True for success, False for failure.

### FileAccess.DirCreate

`Chilkat 11.7.0 · delphidll · FileAccess · DirCreate · method`

```pascal
function CkFileAccess_DirCreate(objHandle: HCkFileAccess;
    dirPath: PWideChar): wordbool; stdcall;
```

Creates the directory specified by `dirPath`. Parent directories must already exist; use `DirEnsureExists` when missing parent directories should also be created.

Returns True for success, False for failure.

### FileAccess.DirDelete

`Chilkat 11.7.0 · delphidll · FileAccess · DirDelete · method`

```pascal
function CkFileAccess_DirDelete(objHandle: HCkFileAccess;
    dirPath: PWideChar): wordbool; stdcall;
```

Deletes the directory specified by `dirPath`. The directory must be empty; use `TreeDelete` to recursively delete a directory and its contents.

Returns True for success, False for failure.

### FileAccess.DirEnsureExists

`Chilkat 11.7.0 · delphidll · FileAccess · DirEnsureExists · method`

```pascal
function CkFileAccess_DirEnsureExists(objHandle: HCkFileAccess;
    dirPath: PWideChar): wordbool; stdcall;
```

Ensures that the complete directory path `dirPath` exists, creating missing directories along the path as needed.

Returns True for success, False for failure.

### FileAccess.DirExists

`Chilkat 11.7.0 · delphidll · FileAccess · DirExists · method · since 10.0.0`

```pascal
function CkFileAccess_DirExists(objHandle: HCkFileAccess;
    dirPath: PWideChar): wordbool; stdcall;
```

Returns `True` if `dirPath` exists as a directory; otherwise returns `False`.

### FileAccess.FileClose

`Chilkat 11.7.0 · delphidll · FileAccess · FileClose · method`

```pascal
procedure CkFileAccess_FileClose(objHandle: HCkFileAccess) stdcall;
```

Closes the currently open file and releases its operating-system file handle. Any exclusive lock obtained through `LockFileOnOpen` is released at this time.

### FileAccess.FileContentsEqual

`Chilkat 11.7.0 · delphidll · FileAccess · FileContentsEqual · method`

```pascal
function CkFileAccess_FileContentsEqual(objHandle: HCkFileAccess;
    filePath1: PWideChar;
    filePath2: PWideChar): wordbool; stdcall;
```

Compares `filePath1` and `filePath2` byte-for-byte and returns `True` only when their contents are identical. File sizes are compared first; when sizes match, the files are compared incrementally rather than being loaded entirely into memory.

**Binary comparison:** The comparison is byte-oriented. Text encodings, line-ending conventions, and Unicode normalization are not interpreted or normalized.

### FileAccess.FileCopy

`Chilkat 11.7.0 · delphidll · FileAccess · FileCopy · method`

```pascal
function CkFileAccess_FileCopy(objHandle: HCkFileAccess;
    existingFilepath: PWideChar;
    newFilepath: PWideChar;
    failIfExists: wordbool): wordbool; stdcall;
```

Copies `existingFilepath` to `newFilepath`. If `failIfExists` is `True` and the destination already exists, the copy fails instead of overwriting it.

Returns True for success, False for failure.

### FileAccess.FileDelete

`Chilkat 11.7.0 · delphidll · FileAccess · FileDelete · method`

```pascal
function CkFileAccess_FileDelete(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Deletes the file specified by `filePath`.

Returns True for success, False for failure.

### FileAccess.FileExists

`Chilkat 11.7.0 · delphidll · FileAccess · FileExists · method`

```pascal
function CkFileAccess_FileExists(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Returns `True` if `filePath` exists; otherwise returns `False`. Use `FileExists3` when the application must distinguish "does not exist" from "could not determine because of an error."

### FileAccess.FileExists3

`Chilkat 11.7.0 · delphidll · FileAccess · FileExists3 · method · since 9.5.0.45`

```pascal
function CkFileAccess_FileExists3(objHandle: HCkFileAccess;
    path: PWideChar): Integer; stdcall;
```

Checks whether `path` exists and returns a three-state result: `1` if it exists, `0` if it does not exist, and `-1` if Chilkat could not determine the result because of permissions or another filesystem error.

### FileAccess.FileOpen

`Chilkat 11.7.0 · delphidll · FileAccess · FileOpen · method`

```pascal
function CkFileAccess_FileOpen(objHandle: HCkFileAccess;
    filePath: PWideChar;
    accessMode: LongWord;
    shareMode: LongWord;
    createDisposition: LongWord;
    attributes: LongWord): wordbool; stdcall;
```

**Windows-specific low-level open.** Opens `filePath` using arguments modeled after the Win32 `CreateFile` API. For portable code, prefer `OpenForRead`, `OpenForWrite`, `OpenForReadWrite`, or `OpenForAppend`.

| Category | Common values |
| --- | --- |
| Access | `GENERIC_READ = 0x80000000`, `GENERIC_WRITE = 0x40000000` |
| Sharing | `FILE_SHARE_READ = 0x1`, `FILE_SHARE_WRITE = 0x2` |
| Disposition | `CREATE_NEW=1`, `CREATE_ALWAYS=2`, `OPEN_EXISTING=3`, `OPEN_ALWAYS=4`, `TRUNCATE_EXISTING=5` |

**Open failures:** When this method fails, inspect `FileOpenError` and `FileOpenErrorMsg` for the reason.

Returns True for success, False for failure.

### FileAccess.FileReadBd

`Chilkat 11.7.0 · delphidll · FileAccess · FileReadBd · method · since 9.5.0.64`

```pascal
function CkFileAccess_FileReadBd(objHandle: HCkFileAccess;
    maxNumBytes: Integer;
    binData: HCkBinData): wordbool; stdcall;
```

Reads up to `maxNumBytes` bytes from the current file position and appends the bytes to `binData`. The file position advances by the number of bytes read.

**Destination behavior:** Existing bytes already present in `binData` are preserved; newly read bytes are appended.

Returns True for success, False for failure.

### FileAccess.FileRename

`Chilkat 11.7.0 · delphidll · FileAccess · FileRename · method`

```pascal
function CkFileAccess_FileRename(objHandle: HCkFileAccess;
    existingFilepath: PWideChar;
    newFilepath: PWideChar): wordbool; stdcall;
```

Renames or moves `existingFilepath` to `newFilepath` using the local filesystem.

Returns True for success, False for failure.

### FileAccess.FileSeek

`Chilkat 11.7.0 · delphidll · FileAccess · FileSeek · method`

```pascal
function CkFileAccess_FileSeek(objHandle: HCkFileAccess;
    offset: Integer;
    origin: Integer): wordbool; stdcall;
```

Moves the current file position by `offset` bytes relative to `origin`.

|  |  |
| --- | --- |
| `0` | Offset from the beginning of the file. |
| `1` | Offset from the current file position. |
| `2` | Offset from end-of-file; negative offsets are commonly used. |

**Random access:** Seeking changes where the next read or write occurs; it does not itself read, write, or resize the file.

Returns True for success, False for failure.

### FileAccess.FileSize

`Chilkat 11.7.0 · delphidll · FileAccess · FileSize · method`

```pascal
function CkFileAccess_FileSize(objHandle: HCkFileAccess;
    filePath: PWideChar): Integer; stdcall;
```

Returns the file size in bytes as a signed 32-bit integer.

**Failure returns 0:** If the size cannot be obtained (for example, the file does not exist or cannot be accessed), the return value is `0`, which is the same as for an empty file. To detect failure, use `FileSizeStr`, which fails instead of returning a size, or check first with `FileExists3`.

**Large files:** A signed 32-bit result cannot represent files larger than approximately 2 GB. Use `FileSize64` or `FileSizeStr` for large files.

### FileAccess.FileSize64

`Chilkat 11.7.0 · delphidll · FileAccess · FileSize64 · method · since 9.5.0.88`

```pascal
function CkFileAccess_FileSize64(objHandle: HCkFileAccess;
    filePath: PWideChar): Int64; stdcall;
```

Returns the size of `filePath` in bytes as a signed 64-bit integer.

**Failure returns 0:** If the size cannot be obtained (for example, the file does not exist or cannot be accessed), the return value is `0`, which is the same as for an empty file. To detect failure, use `FileSizeStr`, which fails instead of returning a size, or check first with `FileExists3`.

### FileAccess.FileSizeStr

`Chilkat 11.7.0 · delphidll · FileAccess · FileSizeStr · method · since 9.5.0.80`

```pascal
function CkFileAccess_FileSizeStr(objHandle: HCkFileAccess;
    filePath: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__fileSizeStr(objHandle: HCkFileAccess;
    filePath: PWideChar): PWideChar; stdcall;
```

Returns the size of `filePath` in bytes as a decimal string. This avoids the range limitation of a 32-bit integer return value.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.FileType

`Chilkat 11.7.0 · delphidll · FileAccess · FileType · method · since 9.5.0.77`

```pascal
function CkFileAccess_FileType(objHandle: HCkFileAccess;
    path: PWideChar): Integer; stdcall;
```

Examines `path` and classifies the filesystem entry.

|  |  |
| --- | --- |
| `-1` | Unable to determine because of permissions or another error. |
| `0` | Does not exist. |
| `1` | Regular file. |
| `2` | Directory. |
| `3` | Symbolic link. |
| `4` | Windows shortcut. |
| `99` | Another filesystem type. |

**Future values:** Additional file-type codes may be added in future versions as needed.

### FileAccess.FileWriteBd

`Chilkat 11.7.0 · delphidll · FileAccess · FileWriteBd · method · since 9.5.0.64`

```pascal
function CkFileAccess_FileWriteBd(objHandle: HCkFileAccess;
    binData: HCkBinData;
    offset: Integer;
    numBytes: Integer): wordbool; stdcall;
```

Writes bytes from `binData` to the currently open file. `offset` selects the starting byte within the `BinData`; `numBytes` selects how many bytes to write. Set both to `0` to write the entire `BinData`, or set `numBytes` to `0` to write all remaining bytes beginning at `offset`.

Returns True for success, False for failure.

### FileAccess.GenBlockId

`Chilkat 11.7.0 · delphidll · FileAccess · GenBlockId · method · since 9.5.0.58`

```pascal
function CkFileAccess_GenBlockId(objHandle: HCkFileAccess;
    index: Integer;
    length: Integer;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__genBlockId(objHandle: HCkFileAccess;
    index: Integer;
    length: Integer;
    encoding: PWideChar): PWideChar; stdcall;
```

Generates a fixed-width decimal block identifier from `index`, padded to `length` characters, and then encodes those bytes using `encoding` (for example `base64`, `hex`, or `ascii`). This utility was originally added for block-oriented uploads such as Azure Blob block uploads.

**Ordering:** Fixed-width decimal identifiers preserve numeric ordering when identifiers are compared lexically, provided the chosen width is large enough for all indexes.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetDirectoryName

`Chilkat 11.7.0 · delphidll · FileAccess · GetDirectoryName · method · since 9.5.0.64`

```pascal
function CkFileAccess_GetDirectoryName(objHandle: HCkFileAccess;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getDirectoryName(objHandle: HCkFileAccess;
    path: PWideChar): PWideChar; stdcall;
```

Returns the directory portion of `path` according to Chilkat path-parsing rules.

```
GetDirectoryName('C:\MyDir\MySubDir\myfile.ext')  ->  'C:\MyDir\MySubDir\'
GetDirectoryName('C:\MyDir\MySubDir')             ->  'C:\MyDir\'
GetDirectoryName('C:\')                             ->  'C:\'
```

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetExtension

`Chilkat 11.7.0 · delphidll · FileAccess · GetExtension · method · since 9.5.0.64`

```pascal
function CkFileAccess_GetExtension(objHandle: HCkFileAccess;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getExtension(objHandle: HCkFileAccess;
    path: PWideChar): PWideChar; stdcall;
```

Returns the filename extension portion of `path`, including the leading period. A period appearing only in a directory name is not treated as the file extension.

```
GetExtension('C:\mydir.old\myfile.ext')  ->  '.ext'
GetExtension('C:\mydir.old\')            ->  ''
```

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetFileName

`Chilkat 11.7.0 · delphidll · FileAccess · GetFileName · method · since 9.5.0.64`

```pascal
function CkFileAccess_GetFileName(objHandle: HCkFileAccess;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getFileName(objHandle: HCkFileAccess;
    path: PWideChar): PWideChar; stdcall;
```

Returns the final filename component of `path`, including its extension. If the path ends with a directory separator, the returned filename is empty.

```
GetFileName('C:\mydir\myfile.ext')  ->  'myfile.ext'
GetFileName('C:\mydir\')            ->  ''
```

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetFileNameWithoutExtension

`Chilkat 11.7.0 · delphidll · FileAccess · GetFileNameWithoutExtension · method · since 9.5.0.64`

```pascal
function CkFileAccess_GetFileNameWithoutExtension(objHandle: HCkFileAccess;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getFileNameWithoutExtension(objHandle: HCkFileAccess;
    path: PWideChar): PWideChar; stdcall;
```

Returns the final filename component of `path` with its extension removed. If `path` ends with a directory separator, the returned value is empty.

```
GetFileNameWithoutExtension('C:\mydir\myfile.ext')  ->  'myfile'
GetFileNameWithoutExtension('C:\mydir\')            ->  ''
```

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetFileTimeStr

`Chilkat 11.7.0 · delphidll · FileAccess · GetFileTimeStr · method · since 11.0.0`

```pascal
function CkFileAccess_GetFileTimeStr(objHandle: HCkFileAccess;
    path: PWideChar;
    which: Integer;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getFileTimeStr(objHandle: HCkFileAccess;
    path: PWideChar;
    which: Integer): PWideChar; stdcall;
```

Returns one file timestamp as an ISO 8601 UTC string in the form `YYYY-MM-DDTHH:MM:SSZ`. The `which` argument selects `0` = last-modified, `1` = last-access, or `2` = creation.

**Portability:** Creation/birth time is not available on every filesystem. The documented Chilkat behavior on Linux is to return the last-modified time when creation time is unavailable.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.GetNumBlocks

`Chilkat 11.7.0 · delphidll · FileAccess · GetNumBlocks · method · since 9.5.0.58`

```pascal
function CkFileAccess_GetNumBlocks(objHandle: HCkFileAccess;
    blockSize: Integer): Integer; stdcall;
```

Returns how many `blockSize`-byte blocks are required to cover the currently open file. A partial final block counts as one block. Returns `0` for an empty file and `-1` if no file is open.

**Calculation:** Conceptually this is `ceil(fileSize / blockSize)` for a non-empty file.

### FileAccess.GetTempFilename

`Chilkat 11.7.0 · delphidll · FileAccess · GetTempFilename · method`

```pascal
function CkFileAccess_GetTempFilename(objHandle: HCkFileAccess;
    dirPath: PWideChar;
    prefix: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__getTempFilename(objHandle: HCkFileAccess;
    dirPath: PWideChar;
    prefix: PWideChar): PWideChar; stdcall;
```

Generates a temporary pathname in `dirPath` using `prefix` and a random alphanumeric suffix, in the general form `prefix_xxxx.TMP`. The returned pathname is guaranteed not to already exist at the time it is generated.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.OpenForAppend

`Chilkat 11.7.0 · delphidll · FileAccess · OpenForAppend · method`

```pascal
function CkFileAccess_OpenForAppend(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Opens `filePath` for writing at end-of-file. The file is created if it does not exist. Existing content is preserved, and the initial file position is at the end.

**Open failures:** If the open/create operation fails, inspect `FileOpenError` and `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.

Returns True for success, False for failure.

### FileAccess.OpenForRead

`Chilkat 11.7.0 · delphidll · FileAccess · OpenForRead · method`

```pascal
function CkFileAccess_OpenForRead(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Opens an existing `filePath` for reading. The file may contain text or binary data and must already exist.

**Open failures:** If the open/create operation fails, inspect `FileOpenError` and `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.

Returns True for success, False for failure.

### FileAccess.OpenForReadWrite

`Chilkat 11.7.0 · delphidll · FileAccess · OpenForReadWrite · method`

```pascal
function CkFileAccess_OpenForReadWrite(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Opens `filePath` for both reading and writing. The file is created if necessary. Existing content is preserved, and the initial file position is at the beginning.

**Open failures:** If the open/create operation fails, inspect `FileOpenError` and `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.

Returns True for success, False for failure.

### FileAccess.OpenForWrite

`Chilkat 11.7.0 · delphidll · FileAccess · OpenForWrite · method`

```pascal
function CkFileAccess_OpenForWrite(objHandle: HCkFileAccess;
    filePath: PWideChar): wordbool; stdcall;
```

Opens `filePath` for writing. The file is created if necessary; if it already exists, it is truncated to zero length when opened.

**Open failures:** If the open/create operation fails, inspect `FileOpenError` and `FileOpenErrorMsg`. On Windows, `LockFileOnOpen` can request exclusive access for this method.

Returns True for success, False for failure.

### FileAccess.ReadBinaryToEncoded

`Chilkat 11.7.0 · delphidll · FileAccess · ReadBinaryToEncoded · method`

```pascal
function CkFileAccess_ReadBinaryToEncoded(objHandle: HCkFileAccess;
    filePath: PWideChar;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__readBinaryToEncoded(objHandle: HCkFileAccess;
    filePath: PWideChar;
    encoding: PWideChar): PWideChar; stdcall;
```

Reads the entire file at `filePath` as binary data and returns an encoded textual representation. Supported encoding names documented for this method include `base64`, `hex`, `qp`, and `url`.

**Encoding is not encryption:** These encodings transform bytes into text; they do not provide confidentiality.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.ReadBlockBd

`Chilkat 11.7.0 · delphidll · FileAccess · ReadBlockBd · method · since 9.5.0.79`

```pascal
function CkFileAccess_ReadBlockBd(objHandle: HCkFileAccess;
    blockIndex: Integer;
    blockSize: Integer;
    bd: HCkBinData): wordbool; stdcall;
```

Reads the zero-based block `blockIndex` from the currently open file, using `blockSize` bytes per block, and appends the bytes to `bd`. A partial final block is appended at its actual length.

**Destination behavior:** Existing contents of `bd` are preserved; the block bytes are appended.

Returns True for success, False for failure.

### FileAccess.ReadEntireTextFile

`Chilkat 11.7.0 · delphidll · FileAccess · ReadEntireTextFile · method`

```pascal
function CkFileAccess_ReadEntireTextFile(objHandle: HCkFileAccess;
    filePath: PWideChar;
    charset: PWideChar;
    outStrFileContents: HCkString): wordbool; stdcall;
function CkFileAccess__readEntireTextFile(objHandle: HCkFileAccess;
    filePath: PWideChar;
    charset: PWideChar): PWideChar; stdcall;
```

Reads the entire file at `filePath`, decodes its bytes using `charset`, and returns the resulting text.

**Charset matters:** The charset controls byte-to-character conversion. Use the encoding that actually represents the file; incorrect charset selection can produce incorrect text or conversion failure.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.ReadNextFragment

`Chilkat 11.7.0 · delphidll · FileAccess · ReadNextFragment · method · since 9.5.0.80`

```pascal
function CkFileAccess_ReadNextFragment(objHandle: HCkFileAccess;
    startAtBeginning: wordbool;
    beginMarker: PWideChar;
    endMarker: PWideChar;
    charset: PWideChar;
    sb: HCkStringBuilder): Integer; stdcall;
```

Scans the currently open file for the next text fragment beginning with `beginMarker` and ending with `endMarker`. The matched fragment, including both markers, is decoded using `charset` and appended to `sb`. If `startAtBeginning` is `True`, scanning restarts at the beginning of the file; otherwise it continues after the previously matched fragment.

|  |  |
| --- | --- |
| `1` | A fragment was found and appended. |
| `0` | No matching fragment was found. |
| `-1` | An error occurred while reading. |

### FileAccess.ReassembleFile

`Chilkat 11.7.0 · delphidll · FileAccess · ReassembleFile · method`

```pascal
function CkFileAccess_ReassembleFile(objHandle: HCkFileAccess;
    partsDirPath: PWideChar;
    partPrefix: PWideChar;
    partExtension: PWideChar;
    reassembledFilename: PWideChar): wordbool; stdcall;
```

Reassembles a file previously divided by `SplitFile`. Parts are read from `partsDirPath` using the supplied `partPrefix` and `partExtension`, and the combined bytes are written to `reassembledFilename`.

**Byte-for-byte reconstruction:** Reassembly is a binary operation; no text decoding or newline conversion is performed.

Returns True for success, False for failure.

### FileAccess.ReplaceStrings

`Chilkat 11.7.0 · delphidll · FileAccess · ReplaceStrings · method`

```pascal
function CkFileAccess_ReplaceStrings(objHandle: HCkFileAccess;
    filePath: PWideChar;
    charset: PWideChar;
    existingString: PWideChar;
    replacementString: PWideChar): Integer; stdcall;
```

Reads the file at `filePath` as text using `charset`, replaces occurrences of `existingString` with `replacementString`, writes the updated text back to the file, and returns the number of replacements made.

**Text operation:** This is character-based replacement after decoding the file. It is not suitable for arbitrary binary files.

### FileAccess.SetCurrentDir

`Chilkat 11.7.0 · delphidll · FileAccess · SetCurrentDir · method`

```pascal
function CkFileAccess_SetCurrentDir(objHandle: HCkFileAccess;
    dirPath: PWideChar): wordbool; stdcall;
```

Changes the current working directory of the calling process to `dirPath`.

**Process-wide effect:** The current directory is normally process-wide, so changing it can affect relative paths used by other code or threads. Absolute paths avoid that dependency.

Returns True for success, False for failure.

### FileAccess.SetFileTimes

`Chilkat 11.7.0 · delphidll · FileAccess · SetFileTimes · method`

```pascal
function CkFileAccess_SetFileTimes(objHandle: HCkFileAccess;
    filePath: PWideChar;
    createTime: HCkDateTime;
    lastAccessTime: HCkDateTime;
    lastModTime: HCkDateTime): wordbool; stdcall;
```

Sets the creation, last-access, and last-modified timestamps for `filePath` from the supplied `CkDateTime` objects. On filesystems that do not support a creation/birth time, `createTime` is ignored.

**Filesystem differences:** Timestamp availability and precision are filesystem- and operating-system-dependent.

Returns True for success, False for failure.

### FileAccess.SetLastModified

`Chilkat 11.7.0 · delphidll · FileAccess · SetLastModified · method`

```pascal
function CkFileAccess_SetLastModified(objHandle: HCkFileAccess;
    filePath: PWideChar;
    lastModified: HCkDateTime): wordbool; stdcall;
```

Sets the last-modified timestamp of `filePath` from `lastModified`. The precision actually stored depends on the underlying filesystem.

Returns True for success, False for failure.

### FileAccess.SplitFile

`Chilkat 11.7.0 · delphidll · FileAccess · SplitFile · method`

```pascal
function CkFileAccess_SplitFile(objHandle: HCkFileAccess;
    fileToSplit: PWideChar;
    partPrefix: PWideChar;
    partExtension: PWideChar;
    partSize: Integer;
    destDir: PWideChar): wordbool; stdcall;
```

Splits `fileToSplit` into sequential binary parts of up to `partSize` bytes and writes them to `destDir` using `partPrefix` and `partExtension`. Use `ReassembleFile` to reconstruct the original file.

Returns True for success, False for failure.

### FileAccess.SymlinkCreate

`Chilkat 11.7.0 · delphidll · FileAccess · SymlinkCreate · method · since 9.5.0.77`

```pascal
function CkFileAccess_SymlinkCreate(objHandle: HCkFileAccess;
    targetPath: PWideChar;
    linkPath: PWideChar): wordbool; stdcall;
```

Creates a symbolic link at `linkPath` that refers to `targetPath`.

**Windows note:** A Windows symbolic link is not the same as a Windows shortcut. Windows may require elevated privileges or an operating-system configuration such as Developer Mode that permits unprivileged symbolic-link creation, depending on system policy and how the application is launched.

Returns True for success, False for failure.

### FileAccess.SymlinkTarget

`Chilkat 11.7.0 · delphidll · FileAccess · SymlinkTarget · method · since 9.5.0.77`

```pascal
function CkFileAccess_SymlinkTarget(objHandle: HCkFileAccess;
    linkPath: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkFileAccess__symlinkTarget(objHandle: HCkFileAccess;
    linkPath: PWideChar): PWideChar; stdcall;
```

Returns the resolved target pathname for the symbolic link at `linkPath`. On Windows, this method also understands Windows shortcut (`.lnk`) files and returns the absolute target path.

**Link vs. target:** A symbolic link is a filesystem object that refers to another path. A Windows shortcut is a separate shell-file format; Chilkat supports both here even though they are different mechanisms.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### FileAccess.TreeDelete

`Chilkat 11.7.0 · delphidll · FileAccess · TreeDelete · method`

```pascal
function CkFileAccess_TreeDelete(objHandle: HCkFileAccess;
    path: PWideChar): wordbool; stdcall;
```

Recursively deletes the directory tree rooted at `path`, including contained files and subdirectories.

**Destructive operation:** This operation is recursive and destructive. Ensure `path` identifies the intended tree before calling it.

Returns True for success, False for failure.

### FileAccess.Truncate

`Chilkat 11.7.0 · delphidll · FileAccess · Truncate · method · since 9.5.0.80`

```pascal
function CkFileAccess_Truncate(objHandle: HCkFileAccess): wordbool; stdcall;
```

Truncates the currently open file at the current file position. Bytes at and after that position are removed, making the current position the new end-of-file.

**Use with FileSeek:** A common pattern is to seek to the desired new length and then call `Truncate`.

Returns True for success, False for failure.

### FileAccess.WriteEntireTextFile

`Chilkat 11.7.0 · delphidll · FileAccess · WriteEntireTextFile · method`

```pascal
function CkFileAccess_WriteEntireTextFile(objHandle: HCkFileAccess;
    filePath: PWideChar;
    textData: PWideChar;
    charset: PWideChar;
    includedPreamble: wordbool): wordbool; stdcall;
```

Creates or opens `filePath`, encodes `textData` using `charset`, writes the resulting bytes, and closes the file. Existing file content is replaced. If `includePreamble` is `True`, an appropriate preamble/BOM is included for encodings such as UTF-8 or UTF-16.

**BOM terminology:** A BOM is part of the byte representation of the text file; it is not part of the application string itself.

Returns True for success, False for failure.

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `FileRead` | method | before 11.6.1 | — |
| `FileWrite` | method | before 11.6.1 | — |
| `GetFileTime` | method | before 11.6.1 | `GetFileTimeStr` |
| `GetLastModified` | method | before 11.6.1 | `GetFileTimeStr` |
| `ReadBlock` | method | before 11.6.1 | — |
| `ReadEntireFile` | method | before 11.6.1 | — |
| `WriteEntireFile` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/BinData.md), [`CkDateTime`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/CkDateTime.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/StringBuilder.md)