FileAccess Lua Reference Documentation

chilkat.FileAccess

Current Version: 11.7.0

Markdown version of this page for AI tools (v 11.7.0) · all AI docs

Chilkat.FileAccess

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.

Object Creation

local chilkat = require("chilkat")

local file_access = chilkat.FileAccess.new()
local file_access = chilkat.FileAccess.new()

Creates the object (chilkat.FileAccess() does the same). Lua's garbage collector frees it when it is no longer referenced; file_access:dispose() frees it at once, and in Lua 5.4 and later local file_access <close> = chilkat.FileAccess.new() frees it when the block ends. Calling a method of a disposed object raises an error.

Errors

A method that fails returns nil followed by the error text, as io.open does: local body, err = file_access:method(...), where err is the object's last_error_text. Wrap the call in assert() to raise an error with that text instead. Methods that answer a question return true or false, numbers are returned as they are (check last_method_success where the description says a value means failure), and property reads and writes never fail for Chilkat reasons.

Misuse raises a Lua error: a wrong argument type or a missing argument (bad argument #1 to ...), an unknown property name, a write to a read-only property, an out-of-range integer, or an object of the wrong class.

Names are Chilkat's in snake_case: QuickGetStr is quick_get_str, LastErrorText is last_error_text. Properties are fields (file_access.verbose_logging = true) and methods use the colon (file_access:method(...)). Strings are UTF-8; binary data is a Lua string of bytes. Indexes are 0-based, as in every Chilkat API. Unlocking: call chilkat.unlock_bundle("...") once at startup.

Properties

CurrentDir
-- strVal is a string (read-only)
local strVal = file_access.current_dir

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.

top
DebugLogFilePath
-- strVal is a string
local strVal = file_access.debug_log_file_path
file_access.debug_log_file_path = strVal

If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.

Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.

Possible causes of hangs include:

  • A timeout property set to 0, indicating an infinite timeout.
  • A hang occurring within an event callback in the application code.
  • An internal bug in the Chilkat code causing the hang.

More Information and Examples
top
EndOfFile
-- boolVal is a boolean (read-only)
local boolVal = file_access.end_of_file

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.

top
FileOpenError
-- intVal is an integer (read-only)
local intVal = file_access.file_open_error

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

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

top
FileOpenErrorMsg
-- strVal is a string (read-only)
local strVal = file_access.file_open_error_msg

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

top
LastErrorHtml
-- strVal is a string (read-only)
local strVal = file_access.last_error_html

Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastErrorText
-- strVal is a string (read-only)
local strVal = file_access.last_error_text

Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastErrorXml
-- strVal is a string (read-only)
local strVal = file_access.last_error_xml

Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

top
LastMethodSuccess
-- boolVal is a boolean
local boolVal = file_access.last_method_success
file_access.last_method_success = boolVal

Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.

top
LockFileOnOpen
-- boolVal is a boolean
local boolVal = file_access.lock_file_on_open
file_access.lock_file_on_open = boolVal
Introduced in version 9.5.0.80

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.

top
VerboseLogging
-- boolVal is a boolean
local boolVal = file_access.verbose_logging
file_access.verbose_logging = boolVal

If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.

top
Version
-- strVal is a string (read-only)
local strVal = file_access.version

Version of the component/library, such as "10.1.0"

More Information and Examples
top

Methods

AppendAnsi
-- text is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:append_ansi(text)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
AppendBd
-- bd is a chilkat.BinData
-- ok is true, or nil and err on failure
local ok, err = file_access:append_bd(bd)
Introduced in version 9.5.0.76

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
AppendSb
-- sb is a chilkat.StringBuilder
-- charset is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:append_sb(sb, charset)
Introduced in version 9.5.0.76

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
AppendText
-- str is a string
-- charset is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:append_text(str, charset)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
AppendUnicodeBOM
-- ok is true, or nil and err on failure
local ok, err = file_access:append_unicode_bom()

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
AppendUtf8BOM
-- ok is true, or nil and err on failure
local ok, err = file_access:append_utf8_bom()

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
DirAutoCreate
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:dir_auto_create(file_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
DirCreate
-- dir_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:dir_create(dir_path)

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
DirDelete
-- dir_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:dir_delete(dir_path)

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
DirEnsureExists
-- dir_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:dir_ensure_exists(dir_path)

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
DirExists
-- dir_path is a string
-- flag is true or false
local flag = file_access:dir_exists(dir_path)
Introduced in version 10.0.0

Returns true if dirPath exists as a directory; otherwise returns false.

Returns true or false: an answer, not a success flag.

top
FileClose
file_access:file_close()

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

top
FileContentsEqual
-- file_path1 is a string
-- file_path2 is a string
-- flag is true or false
local flag = file_access:file_contents_equal(file_path1, file_path2)

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.

Returns true or false: an answer, not a success flag.

top
FileCopy
-- existing_filepath is a string
-- new_filepath is a string
-- fail_if_exists is a boolean
-- ok is true, or nil and err on failure
local ok, err = file_access:file_copy(existing_filepath, new_filepath, fail_if_exists)

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileDelete
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:file_delete(file_path)

Deletes the file specified by filePath.

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileExists
-- file_path is a string
-- flag is true or false
local flag = file_access:file_exists(file_path)

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."

Returns true or false: an answer, not a success flag.

top
FileExists3
-- path is a string
-- n is an integer
local n = file_access:file_exists3(path)
Introduced in version 9.5.0.45

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.

top
FileOpen
-- file_path is a string
-- access_mode is an integer
-- share_mode is an integer
-- create_disposition is an integer
-- attributes is an integer
-- ok is true, or nil and err on failure
local ok, err = file_access:file_open(file_path, access_mode, share_mode, create_disposition, attributes)

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

CategoryCommon values
AccessGENERIC_READ = 0x80000000, GENERIC_WRITE = 0x40000000
SharingFILE_SHARE_READ = 0x1, FILE_SHARE_WRITE = 0x2
DispositionCREATE_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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileReadBd
-- max_num_bytes is an integer
-- bin_data is a chilkat.BinData
-- ok is true, or nil and err on failure
local ok, err = file_access:file_read_bd(max_num_bytes, bin_data)
Introduced in version 9.5.0.64

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileRename
-- existing_filepath is a string
-- new_filepath is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:file_rename(existing_filepath, new_filepath)

Renames or moves existingFilepath to newFilepath using the local filesystem.

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileSeek
-- offset is an integer
-- origin is an integer
-- ok is true, or nil and err on failure
local ok, err = file_access:file_seek(offset, origin)

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

0Offset from the beginning of the file.
1Offset from the current file position.
2Offset 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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileSize
-- file_path is a string
-- n is an integer
local n = file_access:file_size(file_path)

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.
top
FileSize64
-- file_path is a string
-- n is an integer
local n = file_access:file_size64(file_path)
Introduced in version 9.5.0.88

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.
top
FileSizeStr
-- file_path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:file_size_str(file_path)
Introduced in version 9.5.0.80

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

Returns the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileType
-- path is a string
-- n is an integer
local n = file_access:file_type(path)
Introduced in version 9.5.0.77

Examines path and classifies the filesystem entry.

-1Unable to determine because of permissions or another error.
0Does not exist.
1Regular file.
2Directory.
3Symbolic link.
4Windows shortcut.
99Another filesystem type.
Future values: Additional file-type codes may be added in future versions as needed.
More Information and Examples
top
FileWrite2
-- byte_data is a string of bytes
-- ok is true, or nil and err on failure
local ok, err = file_access:file_write2(byte_data)
Introduced in version 9.5.0.82

Writes exactly szByteData bytes beginning at pByteData to the currently open file at the current file position.

C++ buffer contract: The caller must supply a valid readable buffer containing at least szByteData bytes.

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
FileWriteBd
-- bin_data is a chilkat.BinData
-- offset is an integer
-- num_bytes is an integer
-- ok is true, or nil and err on failure
local ok, err = file_access:file_write_bd(bin_data, offset, num_bytes)
Introduced in version 9.5.0.64

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
GenBlockId
-- index is an integer
-- length is an integer
-- encoding is a string
-- str is a string, or nil and err on failure
local str, err = file_access:gen_block_id(index, length, encoding)
Introduced in version 9.5.0.58

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
GetDirectoryName
-- path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:get_directory_name(path)
Introduced in version 9.5.0.64

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
GetExtension
-- path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:get_extension(path)
Introduced in version 9.5.0.64

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
GetFileName
-- path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:get_file_name(path)
Introduced in version 9.5.0.64

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
GetFileNameWithoutExtension
-- path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:get_file_name_without_extension(path)
Introduced in version 9.5.0.64

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
GetFileTimeStr
-- path is a string
-- which is an integer
-- str is a string, or nil and err on failure
local str, err = file_access:get_file_time_str(path, which)
Introduced in version 11.0.0

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
GetNumBlocks
-- block_size is an integer
-- n is an integer
local n = file_access:get_num_blocks(block_size)
Introduced in version 9.5.0.58

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.
More Information and Examples
top
GetTempFilename
-- dir_path is a string
-- prefix is a string
-- str is a string, or nil and err on failure
local str, err = file_access:get_temp_filename(dir_path, prefix)

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
OpenForAppend
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:open_for_append(file_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
OpenForRead
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:open_for_read(file_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
OpenForReadWrite
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:open_for_read_write(file_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
OpenForWrite
-- file_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:open_for_write(file_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
ReadBinaryToEncoded
-- file_path is a string
-- encoding is a string
-- str is a string, or nil and err on failure
local str, err = file_access:read_binary_to_encoded(file_path, encoding)

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
ReadBlockBd
-- block_index is an integer
-- block_size is an integer
-- bd is a chilkat.BinData
-- ok is true, or nil and err on failure
local ok, err = file_access:read_block_bd(block_index, block_size, bd)
Introduced in version 9.5.0.79

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
ReadEntireTextFile
-- file_path is a string
-- charset is a string
-- str is a string, or nil and err on failure
local str, err = file_access:read_entire_text_file(file_path, charset)

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
ReadNextFragment
-- start_at_beginning is a boolean
-- begin_marker is a string
-- end_marker is a string
-- charset is a string
-- sb is a chilkat.StringBuilder
-- n is an integer
local n = file_access:read_next_fragment(start_at_beginning, begin_marker, end_marker, charset, sb)
Introduced in version 9.5.0.80

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.

1A fragment was found and appended.
0No matching fragment was found.
-1An error occurred while reading.
More Information and Examples
top
ReassembleFile
-- parts_dir_path is a string
-- part_prefix is a string
-- part_extension is a string
-- reassembled_filename is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:reassemble_file(parts_dir_path, part_prefix, part_extension, reassembled_filename)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
ReplaceStrings
-- file_path is a string
-- charset is a string
-- existing_string is a string
-- replacement_string is a string
-- n is an integer
local n = file_access:replace_strings(file_path, charset, existing_string, replacement_string)

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.
top
SetCurrentDir
-- dir_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:set_current_dir(dir_path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
SetFileTimes
-- file_path is a string
-- create_time is a chilkat.DateTime
-- last_access_time is a chilkat.DateTime
-- last_mod_time is a chilkat.DateTime
-- ok is true, or nil and err on failure
local ok, err = file_access:set_file_times(file_path, create_time, last_access_time, last_mod_time)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
SetLastModified
-- file_path is a string
-- last_modified is a chilkat.DateTime
-- ok is true, or nil and err on failure
local ok, err = file_access:set_last_modified(file_path, last_modified)

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

Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
SplitFile
-- file_to_split is a string
-- part_prefix is a string
-- part_extension is a string
-- part_size is an integer
-- dest_dir is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:split_file(file_to_split, part_prefix, part_extension, part_size, dest_dir)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
SymlinkCreate
-- target_path is a string
-- link_path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:symlink_create(target_path, link_path)
Introduced in version 9.5.0.77

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top
SymlinkTarget
-- link_path is a string
-- str is a string, or nil and err on failure
local str, err = file_access:symlink_target(link_path)
Introduced in version 9.5.0.77

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 the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
TreeDelete
-- path is a string
-- ok is true, or nil and err on failure
local ok, err = file_access:tree_delete(path)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
Truncate
-- ok is true, or nil and err on failure
local ok, err = file_access:truncate()
Introduced in version 9.5.0.80

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

top
WriteEntireTextFile
-- file_path is a string
-- text_data is a string
-- charset is a string
-- included_preamble is a boolean
-- ok is true, or nil and err on failure
local ok, err = file_access:write_entire_text_file(file_path, text_data, charset, included_preamble)

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 on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.

More Information and Examples
top