Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 2 Next »

The FileSystem Service Class

The service class FileSystem interacts with the operating system to form, decompose, and determine file names and attributes so that they conform the requirements of the hosting platform. In addition, it performs several low level file management operations such as searching for files and loading text files into internal text streams.

A full filename is viewed as consisting of three components:

Component Description
pathname Contains the location within the file system of the file. If it is omitted the the currently selected location is assumed.
localname contains the actual name of the file. This is the only component that cannot be omitted.
extension contains a short extension that describes the type of the file. If it is omitted then the context is often used to determine its value.


The method FileSystem_FileName

Prototype


int FileSystem_FileName(char* fileIdent,int nIdent,char* name,int iExt);
The FileSystem_FileName method extracts the local name from a full filename. In particular it locates the local name and copies it into the return parameter as a null-terminated string. If the include extension flag is nonzero, then the extension is included with the name. Its parameters are as follows:

Parameter Description
fileIdent Contains the file name to be parsed. It need be null-terminated only if its length is not specified.
nIdent Specifies the length of file name. If it is set to zero, then the length is computed.
name Receives the localname of the file possibly concatenated with its extension. It is null-terminated.
iExt Specifies whether the extension should be included in the returned name. If it is nonzero, then the extension is included in the name.

This method returns the overall length of the local name.

The method FileSystem_FindFiles

Prototype


void* FileSystem_FindFiles(char* directory,char* extensions);
The FileSystem_FindFiles method searches the directory tree starting in a specified directory for all files that have some specified number of extensions. The full names of the local files are stored in a text stream whose handle is the return value of this method. Its parameters are as follows:

Parameter Description
directory Contains the full name of the root directory for the search.
extensions Contains a comma-delimited string of the extensions to be searched for.

The method returns the handle of the local text stream which contains the full filenames. It can be NULL, if it could not be created. It can contain no entries, if no files were found or if the starting directory did not exist.

The method FileSystem_GetDirectory

Prototype


int FileSystem_GetDirectory(char* buffer,char* string,int nString,int remove);
The FileSystem_GetDirectory method gets the full directory name from a path name by removing the local filename. In addition, it may remove additional subdirectory names. Its parameters are as follows:

Parameter Description
buffer Receives the directory name extracted from the pathname in null-terminated form.
string Contains the full pathname of a file whose directory location is wanted. It need be null-terminated only if nString set to zero.
nString Specifies the overall length of the pathname. If set to zero, then the length of the pathname is computed.
removed Specifies the number of subdirectory names to be removed from the back of the directory name.

This method returns the length in characters of the returned directory name.

The method FileSystem_LoadFile

Prototype


int FileSystem_LoadFile(void* Storage,char* filename,int strip);
The FileSystem_LoadFile method loads the content of a text file into a text stream in storage. Optionally, leading and/or trailing whitespace is stripped. The file is closed after it has been read. Note that both ASCII and Unicode files can be read by this method. The Unicode is transparently converted to ASCII before loading the records into the text stream. Its parameters are as follows:

Parameter Description
Storage Specifies the handle for the storage area to contain the text buffer. If this handle is NULL, then the text buffer will be allocated to a memory based storage area. If the LoadFile_UseExisting entry flag is set then this parameter Specifies the handle of the text stream.
filename Contains the full filename for the text file whose content is to be loaded.
strip Specifies how records are to be modified and/or stored in the text stream. The bits this parameter are used as follows:

Entry Description of use
LoadFile_StripTrailing strip trailing whitespace
LoadFile_StripLeading strip leading white space
LoadFile_ReplaceCR replace embedded CR's with newlines
LoadFile_NullTerminate terminate stored records with null-byte
LoadFile_UseExisting insert file into existing text stream


The method returns the root offset of the variable information stream that contains the records of the file if all goes well. If the file cannot be opened with readonly access, then a zero is returned.

The method FileSystem_MakeFullName

Prototype


int FileSystem_MakeFullName(char* path,char* name,int nname,char* ext,char* fullname);
The FileSystem_MakeFullName method forms a full filename from its components. This method views a file as though it consisted of three concatenated components: path name, local name, and extension. This method constructs the full name in accordance with the conventions of the platform. It has the following parameters:

Parameter Description
path Contains the path name to be used. It may be NULL, in which case a local filename is constructed.
name Contains the local name of the file. It need not be null-terminated if the nname parameter is not zero.
nname Specifies the number of characters in the beginning of the name parameter. If it is zero, then the name string must be null-terminated and its entire content is used.
ext Contains the extension to be used. If it is NULL then the filename contains no extension.
fullname Receives the full constructed name of the file in null-terminated form. If is up to the user to ensure that it contains sufficient space.

The method returns the overall length of the filename as constructed.

The method FileSystem_MakeLocalName

Prototype


int FileSystem_MakeLocalName(char* FileName,char* LocalName,int LocalLength,CONST char* Extension,int XtnLength);
The FileSystem_MakeLocalName method creates a local filename by concatenating a local name with the local extension character and an extension. Note that the local name may already contain an extension. In that case that extension is replaced. Its parameters are:

Parameter Description
FileName Receives the constructed local filename in null-terminated form.
LocalName Contains the local name to be used. This name may already have an extension at its back. This method does not check the front of this name therefore, it may contain a path name as well.
LocalLength specifies length of local name. A value of zero means that LocalName is null-terminated and its length is computed.
Extension Contains the extension.
XtnLength Specifies the length of the extension. If it is zero then Extension is assumed to be null-terminated.

The method returns the length of the constructed filename.

The method FileSystem_ParseFileName

Prototype


int FileSystem_ParseFileName(char* FileName,int Length,int* LocalStart,int* XtnStart);
The FileSystem_ParseFileName method parses a filename into its components. It views a filename as though it consisted of three concatenated components: path name, local name, and extension. This method computes the relative position within the full name of the start of the local name and the start of the extension. Since the path name is always first, if the local name start is greater than zero, then the beginning of the filename contains a path name. Its parameters are as follows:

Parameter Description
FileName Contains the filename to be parsed. It need be null-terminated only if Length set to zero.
Length Specifies the overall length of the filename. If set to zero, then the length of the filename is computed.
LocalStart returns the offset of the start of the local name in the filename. A value of zero indicates that the name contains no path name component.
XtnStart returns the offset of the start of the extension in the filename. A value of Length indicates that the name had no extension.

The method returns the overall length of the filename.

The method FileSystem_RelativePathName

Prototype


int FileSystem_RelativePathName(char* parent,char* child,char* relative);
The FileSystem_RelativePathName method creates a relative pathname of a child file as referenced by a parent file, such as a code file being referenced by a project file. Its parameters are as follows:

Parameter Description
parent Contains the full pathname of the parent file.
child Contains the full pathname of the child file.
relative Receives the relative pathname required to reference the child file when in the parent location.

The method returns the length of the relative name.
Table of Contents

  • No labels