# file.h | documentation

    #charset "us-ascii"
    #pragma once

    /*
     *   Copyright (c) 2001, 2006 Michael J. Roberts
     *
     *   This file is part of TADS 3.
     *
     *   This header defines the File intrinsic class.
     */

    /* include our base class definition */
    #include "systype.h"

    /*
     *   File methods use the CharacterSet and ByteArray intrinsic
     *   classes, so include their headers to make sure they're available to
     *   File users.
     */
    #include "charset.h"
    #include "bytearr.h"

    /* if we're using File objects, we probably want FileName objects as well */
    #include "filename.h"

    /* ------------------------------------------------------------------------ */
    /*
     *   File access modes.  These are used when calling the file open methods
     *   to specify how the file is to be accessed.
     */

    /*
     *   Read mode - the file is opened for reading (writing is not allowed).
     *   When opened in this mode, the file must exist, or a
     *   FileNotFoundException is thrown from the open method.
     */
    #define FileAccessRead            0x0001

    /*
     *   Write mode - the file is opened for writing (reading is not allowed).
     *   When opened in this mode, if the file doesn't already exist, a new file
     *   is created; if the file does already exist, the existing data in the
     *   file are discarded (i.e., the file is truncated to zero length) on
     *   open.
     */
    #define FileAccessWrite           0x0002

    /*
     *   Read/write mode, keeping existing contents - the file is opened for
     *   both reading and writing.  If the file does not exist, a new file is
     *   created.  If the file does already exist, the existing contents of the
     *   file are kept intact on open.
     */
    #define FileAccessReadWriteKeep   0x0003

    /*
     *   Read/write mode, truncating existing contents - the file is opened for
     *   both reading and writing.  If the file does not exist, a new file is
     *   created.  If the file does already exist, the existing contents of the
     *   file are discarded (i.e., the file is truncated to zero length) on
     *   open.
     */
    #define FileAccessReadWriteTrunc  0x0004

    /* ------------------------------------------------------------------------ */
    /*
     *   File mode constants.  These are returned from getFileMode() to indicate
     *   the mode used to open the file.
     */

    /* text mode */
    #define FileModeText  1

    /* "data" mode */
    #define FileModeData  2

    /* "raw" mode */
    #define FileModeRaw   3

    /* ------------------------------------------------------------------------ */
    /*
     *   Special file identifiers.  These identifiers can be passed to the 'open'
     *   routines in place of the filename string argument.
     *
     *   The actual name and location of a special file is determined by the
     *   interpreter.  Since games use these internal identifiers rather than the
     *   actual system filenames when accessing special files, different
     *   interpreters can adapt to different local conventions without bothering
     *   the game code with the details.  The game code simply refers to the file
     *   it wants using the virtual identifier, and the interpreter takes care of
     *   the rest.
     *
     *   Note that special files generally bypass the interpreter "file safety"
     *   settings.  This is important because it allows the library and games a
     *   degree of controlled access to the file system, even when the file
     *   safety settings wouldn't normally allow similar access for arbitrary
     *   file operations.  Even though this special file access can bypass the
     *   file safety level, it doesn't compromise security, because the
     *   interpreter has exclusive control over the names and locations of the
     *   special files - thus a game can only access the particular files that
     *   the interpreter designates as special, and can't use special files to
     *   access arbitrary file system entities.
     */

    /*
     *   The library defaults file.  This is the special file where the library
     *   stores user-controlled start-up default settings.
     */
    #define LibraryDefaultsFile    0x0001

    /*
     *   Web UI preference settings file.  This is the special file where we
     *   store display style settings for the Web UI.
     */
    #define WebUIPrefsFile         0x0002

    /* ------------------------------------------------------------------------ */
    /*
     *   The File intrinsic class provides access to files in the external file
     *   system.  This lets you create, read, and write files.  The class
     *   supports text files (with translations to and from local character
     *   sets), "data" files (using the special TADS 2 binary file format), and
     *   "raw" files (this mode lets you manipulate files in arbitrary text or
     *   binary formats by giving you direct access to the raw bytes in the
     *   file).
     */
    intrinsic class File 'file/030003': Object
    {
        /*
         *   File has no constructors.  Instead of using 'new', you create a File
         *   object by opening a file through one of the openXxxFile methods:
         *
         *   f = File.openTextFile()
         *
         *   All of the open methods have a 'filename' argument giving the name
         *   of the file to open.  This is usually a string giving a file name in
         *   the local file system.  You can also use a TemporaryFile object in
         *   place of a filename, to open a temporary file.
         *
         *   All of the open methods throw exceptions if the open fails:
         *
         *   FileNotFoundException - indicates that the requested file doesn't
         *   exist.  This is thrown when the access mode requires an existing
         *   file but the named file does not exist.
         *
         *   FileCreationException - indicates that the requested file couldn't
         *   be created.  This is thrown when the access mode requires creating a
         *   new file but the named file cannot be created.
         *
         *   FileOpenException - indicates that the requested file couldn't be
         *   opened.  This is thrown when the access mode allows either an
         *   existing file to be opened or a new file to be created, but neither
         *   could be accomplished.
         *
         *   FileSafetyException - the requested access mode isn't allowed for
         *   the given file due to the current file safety level set by the user.
         *   Users can set the file safety level (through command-line switches
         *   or other preference mechanisms which vary by interpreter) to
         *   restrict the types of file operations that applications are allowed
         *   to perform, in order to protect their systems from malicious
         *   programs.  This exception indicates that the user has set a safety
         *   level that is too restrictive for the requested operation.
         */

        /*
         *   Static creator method: open a text file.  Returns a File object that
         *   can be used to read or write the file.
         *
         *   'filename' is the name of the file to open.  This is a string giving
         *   the name of a file in the local file system.  It can alternatively
         *   be a TemporaryFile object, to open a temporary file.
         *
         *   'access' is the read/write mode, and must be one of FileAccessRead
         *   or FileAccessWrite.
         *
         *   'charset' is a CharacterSet object, or can optionally be a string
         *   naming a character set, in which case a CharacterSet object for the
         *   named character set will automatically be created.  If 'charset' is
         *   omitted, the local system's default character set for file contents
         *   is used.
         *
         *   When a file is opened in text mode for reading, each call to
         *   readFile() reads and returns a line of text from the file.  When a
         *   file is opened in text mode for writing, any existing file is
         *   discarded and replaced with the new data.  Each read and write to a
         *   text file is mapped through the CharacterSet in effect at the time
         *   of the read or write.
         */
        static openTextFile(filename, access, charset?);

        /*
         *   Static creator method: open a file in 'data' mode.  Returns a File
         *   object that can be used to read or write the file.
         *
         *   'filename' is a string giving the file name in the local file
         *   system, or a TemporaryFile object.
         *
         *   'access' indicates the desired read/write access and the disposition
         *   of any existing file; any of the FileAccessXxx modes can be used.
         *
         *   When a file is opened in data mode, you can read and write integers,
         *   strings, and 'true' values to the file, and the values in the file
         *   are marked with their datatype in a private data format.  Because
         *   the file uses a tads-specific format, this mode cannot be used to
         *   read files created by other applications or write files for use by
         *   other applications; however, this storage format is convenient for
         *   storing simple data values because the File object takes care of
         *   converting to and from a portable binary format.
         */
        static openDataFile(filename, access);

        /*
         *   Static creator method: open a file in 'raw' mode.  Returns a File
         *   object that can be used to read or write the file.
         *
         *   'filename' is a string giving the name of the file in the local file
         *   system, or a TemporaryFile object.
         *
         *   'access' indicates the desired read/write access mode and the
         *   disposition of any existing file; any of the FileAccessXxx modes can
         *   be used.
         *
         *   When a file is opened in raw mode, only ByteArray values can be read
         *   and written.  The File object performs no translations of the bytes
         *   read or written.  This mode requires the calling program itself to
         *   perform all data conversions to and from a raw byte format, but the
         *   benefit of this extra work is that this mode can be used to read and
         *   write files in arbitrary data formats, including formats defined by
         *   other applications.
         */
        static openRawFile(filename, access);

        /*
         *   get the CharacterSet object the File is currently using; returns
         *   nil for a non-text file
         */
        getCharacterSet();

        /*
         *   Set the CharacterSet object the File is to use from now on.  This
         *   isn't meaningful except for text files.  'charset' can be a
         *   CharacterSet object, a string giving the name of a character mapping
         *   (in which case a CharacterSet object is automatically created based
         *   on the name), or nil (in which case the local system's default
         *   character set for text files is used).
         */
        setCharacterSet(charset);

        /*
         *   Close the file.  Flushes any buffered information to the underlying
         *   system file and releases any system resources (such as share locks
         *   or system buffers) associated with the file.  After this routine is
         *   called, no further operations on the file can be performed (a
         *   FileClosedException will be thrown if any subsequent operations are
         *   attempted).
         *
         *   If the game is running in web server mode, the file might be on a
         *   remote storage server.  In this case, if the file was opened with
         *   write access, closing it will send the file to the storage server.
         *
         *   Note that this method can throw an error, so you shouldn't consider
         *   updates to the file to be "safe" until this method returns
         *   successfully.  On many systems, writes are buffered in memory, so
         *   closing the file can involve flushing buffers, which can trigger the
         *   same sorts of errors that can happen with ordinary writes (running
         *   out of disk space, physical media defects, etc).  In addition, when
         *   the file is on a remote network storage server, closing a file
         *   opened with write access transmits the file to the storage server,
         *   which can encounter network errors.
         *
         *   You should always explicitly close files when done with them.  This
         *   is especially important when writing to a file, because many systems
         *   buffer written data in memory and don't write changes to the
         *   physical media until the file is closed.  This means that updates
         *   can be lost if the program crashes (or the computer loses power,
         *   etc) while the file is still open.  Closing the file as soon as
         *   you're done with it reduces the chances of this kind of data loss.
         *   It also helps overall system performance to release resources back
         *   to the operating system as soon as you're done with them.
         *
         *   If you *don't* close a file, though, the system will close it
         *   automatically when the File object becomes unreachable and is
         *   deleted by the garbage collector.  It's considered bad form to
         *   depend on this for the reasons above, and it's also problematic
         *   because you won't have any way of finding out if an error should
         *   happen on close.
         */
        closeFile();

        /*
         *   Read from the file.  Returns a data value that depends on the file
         *   mode, as described below, or nil at end of file.
         *
         *   If the file is open in text mode, this reads a line of text from the
         *   file and returns a string with the text of the line read.  A line of
         *   text is a sequence of characters terminated with a line-ending
         *   sequence, which is a carriage return, line feed, CR/LF pair, LF/CR
         *   pair, or a Unicode line terminator character (0x2028) if the file is
         *   being read with one of the Unicode encodings.  If the line read ends
         *   in a line-ending sequence, the returned text will end in a '\n'
         *   character, regardless of which of the possible line-ending sequences
         *   is actually in the file, so the caller need not worry about the
         *   details of the external file's format.  Every line read from the
         *   file will end in a '\n' except possibly the last line - if the file
         *   doesn't end with a line-ending sequence, then the last line read
         *   from the file won't end in a '\n' character.  All bytes read from
         *   the file will be mapped to characters through the CharacterSet
         *   object currently in effect in the file, so the returned string will
         *   always be a standard Unicode string, regardless of the byte encoding
         *   of the file.
         *
         *   If the file is open in 'data' mode, this reads one data element
         *   using the private tads-specific data format.  The result is a value
         *   of one of the types writable with writeFile() in 'data' mode.  In
         *   order to read a 'data' file, the file must have been previously
         *   written in 'data' mode.
         */
        readFile();

        /*
         *   Write to the file.  Writes the given value to the file in a format
         *   that depends on the file mode, as described below.  No return
         *   value; if an error occurs writing the data, this throws a
         *   FileIOException.
         *
         *   If the file is open in text mode, this writes text to the file,
         *   converting the given value to a string if necessary (and throwing
         *   an error if such a conversion isn't possible), and translating the
         *   string to be written to bytes by mapping the string through the
         *   CharacterSet object currently in effect for the file.  Note that no
         *   line-ending characters are automatically added to the output, so if
         *   the caller wishes to write line terminators, it should simply
         *   include a '\n' character at the end of each line.
         *
         *   If the file is open in 'data' mode, this writes the value, which
         *   must be a string, integer, enum, or 'true' value, in a private
         *   tads-specific data format that can later be read using the same
         *   format.  The values are converted to the private binary format,
         *   which is portable across platforms: a file written in 'data' mode
         *   on one machine can be copied (byte-for-byte) to another machine,
         *   even one that uses different hardware and a different operating
         *   system, and read back in 'data' mode on the new machine to yield
         *   the original values written.
         */
        writeFile(val);

        /*
         *   Read bytes from the file into the given ByteArray object.  This can
         *   only be used for a file opened in 'raw' mode.  If 'start' and 'cnt'
         *   are given, they give the starting index in the byte array at which
         *   the bytes read are to be stored, and the number of bytes to read,
         *   respectively; if these are omitted, one byte is read from the file
         *   for each byte in the byte array.
         *
         *   Returns the number of bytes actually read into the byte array,
         *   which will be less than or equal to the number requested.  If the
         *   number read is less than the number requested, it means that the
         *   end of the file was encountered, and only the returned number of
         *   bytes were available.
         */
        readBytes(byteArr, start?, cnt?);

        /*
         *   Write bytes from the given source object into the file.  This can
         *   only be used for a file opened in 'raw' mode.
         *
         *   The source object must be one of the following object types:
         *
         *   File: the contents of the given source file are copied to 'self'.
         *   'start' is the starting seek position in the source file; if
         *   omitted, the current seek position is the default.  'cnt' is the
         *   number of bytes to copy; if omitted, the file is copied from the
         *   given starting position to the end of the file.
         *
         *   ByteArray: the bytes of the byte array are copied to the file.
         *   'start' is the starting index in the byte array; if omitted, the
         *   default is the first byte (index 1).  'cnt' is the number of bytes
         *   to copy; if omitted, bytes are copied from the start position to the
         *   end of the array.
         *
         *   No return value; if an error occurs writing the data, a
         *   FileIOException is thrown.
         */
        writeBytes(source, start?, cnt?);

        /*
         *   Get the current read/write position in the file.  Returns the byte
         *   offset in the file of the next byte to be read or written.  Note
         *   that this value is an offset, so 0 is the offset of the first byte
         *   in the file.
         */
        getPos();

        /*
         *   Set the current read/write position in the file.  'pos' is a byte
         *   offset in the file; 0 is the offset of the first byte.
         *
         *   For files in 'text' and 'data' modes, a caller should NEVER set the
         *   file position to any value other than a value previously returned
         *   by getPos(), because other positions might violate the format
         *   constraints.  For example, if you move the file position to a byte
         *   in the middle of a line-ending sequence in a text file, subsequent
         *   reading from the file might misinterpret the sequence as something
         *   other than a line ending, or as an extra line ending.  If you move
         *   the position in a 'data' file to a byte in the middle of an integer
         *   value, reading from the file would misinterpret as a data type tag
         *   a byte that is part of the integer value instead.  So it is never
         *   meaningful or safe to set an arbitrary byte offset in these file
         *   formats; only values known to be valid by virtue of having been
         *   returned from getPos() can be used here in these modes.
         */
        setPos(pos);

        /*
         *   Set the current read/write position to the end of the file.  This
         *   can be used, for example, to open a 'data' mode file for
         *   read/write/keep access (keeping the contents of an existing file)
         *   and then adding more data after all of the existing data in the
         *   file.
         */
        setPosEnd();

        /*
         *   Static creator method: open a resource in 'text' mode.  This acts
         *   like openTextFile(), but rather than opening an ordinary file, this
         *   method opens a resource.  Resources differ from ordinary files in
         *   two important respects.  First, a resource is named with a
         *   URL-style path rather than a local file system name.  Second, a
         *   resource can be embedded in the program's executable (.t3) file, or
         *   can be embedded in an external resource bundle (.3r0, etc) file.
         *
         *   Resources are read-only, so the access mode is implicitly
         *   FileAccessRead.
         */
        static openTextResource(resname, charset?);

        /*
         *   Static creator method: open a resource in 'raw' mode.  This acts
         *   like openRawFile(), but opens a resource rather than an ordinary
         *   file.
         *
         *   Resources are read-only, so the access mode is implicitly
         *   FileAccessRead.
         */
        static openRawResource(resname);

        /* get the size in bytes of the file */
        getFileSize();

        /*
         *   Get the file mode.  This returns one of the FileModeXxx constants,
         *   indicating the mode used to open the file (text, data, raw).
         */
        getFileMode();

        /*
         *   Extract the file's "root name" from the given filename string.  This
         *   returns a new string giving the portion of the filename excluding
         *   any directory path.  This parses the filename according to the local
         *   file system's syntax rules.  For example, given the filename
         *   'a/b/c.txt', if you're running on a Unix or Linux machine, the
         *   function returns 'c.txt'.
         *
         *   Note that this function doesn't attempt to open the file or check
         *   for its existence or validity; it simply parses the name according
         *   to the local syntax conventions.
         *
         *   (It's recommended that you use the newer FileName.getBaseName() in
         *   place of this function.)
         */
        static getRootName(filename);

        /*
         *   Delete the file with the given name.  This erases the file from
         *   disk.  'filename' is a string giving the name of the file to delete,
         *   or one of the special file identifier values.
         *
         *   The file can only be deleted if the file safety level would allow
         *   you to write to the file; if not, a file safety exception is thrown.
         *
         *   (It's recommended that you use the newer FileName.deleteFile() in
         *   place of this function.)
         */
        static deleteFile(filename);

        /*
         *   Change the file mode.  'mode' is a FileModeXxx value giving the
         *   desired new file mode.
         *
         *   If the mode is FileModeText, 'charset' is the character set mapping
         *   to use for the file; this can be given as a CharacterSet object, or
         *   as a string giving the name of a character set.  If the value is nil
         *   or the argument is omitted, the local system's default character for
         *   file contents is used.  The 'charset' parameter is ignored for other
         *   modes.
         */
        setFileMode(mode, charset?);

        /*
         *   Pack the given data values into bytes according to a format
         *   definition string, and write the packed bytes to the file.  This
         *   function is designed to simplify writing files that use structured
         *   binary formats defined by third parties, such as JPEG or PDF.  The
         *   function translates native TADS data values into selected binary
         *   formats, and writes the resulting bytes to the file, all in a single
         *   operation.
         *
         *   'format' is the format string, and the remaining arguments are the
         *   values to be packed.
         *
         *   Returns the number of bytes written to the file.  (More precisely,
         *   returns the final file position as a byte offset from the starting
         *   file pointer.  If a positioning code like @ or X is used in the
         *   string, it's possible that more bytes were actually written.)
         *
         *   See Byte Packing in the System Manual for details.
         */
        packBytes(format, ...);

        /*
         *   Read bytes and unpack into a data structure, according to the format
         *   description string 'desc'.
         *
         *   'format' is the format string.  The function reads bytes from the
         *   current location in the file and translates them into data values
         *   according to the format string, returning a list of the unpacked
         *   values.
         *
         *   Refer to Byte Packing in the System Manual for details.
         */
        unpackBytes(format);

        /*
         *   Calculate the 256-bit SHA-2 hash of bytes read from the file,
         *   starting at the current seek location and continuing for the given
         *   number of bytes.  If the length is omitted, the whole rest of the
         *   file is hashed.  This has the side effect of reading the given
         *   number of bytes from the file, so it leaves the seek position set to
         *   the next byte after the bytes hashed.
         *
         *   Returns a string of 64 hex digits giving the hash result.
         *
         *   This can only be used on files opened in raw mode with read access.
         */
        sha256(length?);

        /*
         *   Calculate the MD5 digest of bytes read from the file, starting at
         *   the current seek location and continuing for the given number of
         *   bytes.  If the length is omitted, the whole rest of the file is
         *   digested.  This has the side effect of reading the given number of
         *   bytes from the file, so it leaves the seek position set to the next
         *   byte after the bytes digested.
         *
         *   Returns a string of 32 hex digits giving the digest result.
         *
         *   This can only be used on files opened in raw mode with read access.
         */
        digestMD5(length?);
    }

    /* ------------------------------------------------------------------------ */
    /*
     *   The TemporaryFile intrinsic class represents a temporary file name in
     *   the local file system.  Temporary files can be used to store data too
     *   large to conveniently store in memory.
     *
     *   You create a temporary file with 'new TemporaryFile()'.  This
     *   automatically assigns the object a unique filename in the local file
     *   system, typically in a system directory reserved for temporary files.
     *   The local file can then be opened, read, written, and otherwise
     *   manipulated via the File class, just like any other file.  Simply pass
     *   the TemporaryFile object in place of a filename to the File.openXxx
     *   methods.
     *
     *   The underlying file system file will be deleted automatically when the
     *   TemporaryFile object is collected by the garbage collector (or when the
     *   program terminates).  This means that you don't have to worry about
     *   cleaning up the file system space used by the file; it'll be released
     *   automatically when the file is no longer needed.  However, you can call
     *   the deleteFile() method to explicitly release the file when you're done
     *   with it, if you want to ensure that the resource is returned to the
     *   operating system as soon as possible.
     *
     *   TemporaryFile objects are inherently transient - they're only valid for
     *   the current session on the current local system, so they can't be saved
     *   or restored.
     *
     *   Temporary files are exempt from the file safety level settings, because
     *   the inherent restrictions on temporary files provide the same system
     *   protections that the safety level settings provide for ordinary files.
     */
    intrinsic class TemporaryFile 'tempfile/030000': Object
    {
        /*
         *   Get the name of the underlying file system object.  This returns a
         *   string with the local filename.  This is mostly for debugging
         *   purposes or for displaying to the user.  You can't necessarily use
         *   this filename in a call to File.openXxxFile, because the file path
         *   is usually in a system directory reserved for temporary files, and
         *   the file safety level settings often prohibit opening files outside
         *   of the program's own home directory.  To open the temp file, you
         *   should always pass the TemporaryFile object itself in place of the
         *   filename.
         */
        getFilename();

        /*
         *   Delete the underlying file system object.  This deletes the
         *   temporary file and marks the TemporaryFile object as invalid.  After
         *   calling this, you can no longer open the file via the
         *   File.openXxxFile methods.
         *
         *   This method allows you to release the underlying file system
         *   resources as soon as you're done with the temp file.  It's never
         *   necessary to do this.  TADS automatically deletes the underlying
         *   file system resources when the TemporaryFile object is deleted by
         *   the garbage collector (or when the program terminates), so the
         *   operating system file will be deleted eventually whether you call
         *   this method or not.  The point of this method is to let you tell the
         *   system *exactly* when you're done with the file, so that the
         *   resources can be released earlier than if we waited for garbage
         *   collection to take care of it.  This should make little difference
         *   in most situations, but in a program that will run for a long time
         *   and use a lot of temporary files, it might be worthwhile to release
         *   resources manually as soon as possible.
         */
        deleteFile();
    }

    /* ------------------------------------------------------------------------ */
    /*
     *   The filename passed to the File "open" methods, as well as to most
     *   system functions that accept filename arguments, can be a TadsObject
     *   object in lieu of a string.  Such an object must implement the following
     *   methods:
     *
     *   getFilename() - return the actual filename to use, which must be a
     *   string or TemporaryFile object.
     *
     *   closeFile() - optional.  This is called just after the underlying system
     *   file is closed, allowing the program to perform any desired
     *   post-processing on the file.
     */
    export getFilename 'FileSpec.getFilename';
    export closeFile 'FileSpec.closeFile';

TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3