Basic Turbo Delphi I/O Functions

There are three classes of file: typed, text, and untyped.

The syntax for declaring file types is given in File types.

Note that file types are only available on the Win32 platform.

Once the association with an external file is established, the file variable must be opened to prepare it for input or output. An existing file can be opened via the Reset procedure, and a new file can be created and opened via the Rewrite procedure. Text files opened with Reset are read-only and text files opened with Rewrite and Append are write-only. Typed files and untyped files always allow both reading and writing regardless of whether they were opened with Reset or Rewrite .

By default, all calls to standard I/O procedures and functions are automatically checked for errors, and if an error occurs an exception is raised (or the program is terminated if exception handling is not enabled). This automatic checking can be turned on and off using the {$I+} and {$I-} compiler directives. When I/O checking is off, that is, when a procedure or function call is compiled in the {$I-} state an I/O error doesn't cause an exception to be raised; to check the result of an I/O operation, you must call the standard function IOResult instead.

You must call the IOResult function to clear an error, even if you aren't interested in the error. If you don't clear an error and {$I-} is the current state, the next I/O function call will fail with the lingering IOResult error.

Opens a specified file using a specified access mode.

  function FileOpen(const FileName: string; Mode: Cardinal): Integer;

Mode

• to_read

Description

Use FileOpen to open a file and obtain a file handle. The access mode value is constructed by or-ing one of the fmOpen constants with one of the fmShare constants defined in File open mode constants. If the return value is 0 or greater, the function was successful and the value is the file handle of the opened file. A return value of -1 indicates that an error occurred.

var
  inf_hand : integer; {handle for the file}

      inf_hand := fileopen(CookieFileName,to_read);
      if inf_hand = -1
        {if the handle comes back -1, it didn't work}
        then begin
          bombout('Couldn''t read fortune.');
        end {then}
        else begin
          endptr := fileseek(inf_hand,0,frombottom); {find EOF}
          if locptr >= endptr
            then get_new_fortune_file;
          fileseek(inf_hand,locptr,fromtop);
          if IOresult <> 0
            then bombout('Fileseek failed.');

This section summarizes I/O using file variables of the standard type Text.

When a text file is opened, the external file is interpreted in a special way: It is considered to represent a sequence of characters formatted into lines, where each line is terminated by an end-of-line marker (a carriage-return character, possibly followed by a line feed character). The type Text is distinct from the type file of Char.

LF is optional.

For text files, there are special forms of Read and Write that let you read and write values that are not of type Char. Such values are automatically translated to and from their character representation. For example, Read(F, I), where I is a type Integer variable, reads a sequence of digits, interprets that sequence as a decimal integer, and stores it in I.

Read reads data from a file.

[Delphi] procedure Read(var F: file; V1: Pointer [; V2; …; Vn]);

Description

The Read procedure can be used in Delphi code in the following ways.

For typed files, it reads a file component into a variable.

For text files, it reads one or more values into one or more variables.

Read reads all characters up to, but not including, the next end-of-line marker or until Eof(F) becomes true; it does not skip to the next line after reading. If the resulting string is longer than the maximum length of the string variable, it is truncated.

After the first Read, each subsequent Read sees the end-of-line marker and returns a zero-length string.

Use multiple Readln calls to read successive string values.

When the extended syntax is enabled, Read can read null-terminated strings into zero-based character arrays.

Read reads one character from the file and assigns it to the variable. If CRLF mode is enabled and Eof(F) was true before Read was executed, the value Chr(26) (a Ctrl-Z character) is assigned to the variable. (To enable CRLF mode, use SetLineBreakStyle.)

Read skips any blanks, tabs, or end-of-line markers preceding the numeric string.

If the numeric string does not conform to the expected format, an I/O error occurs; otherwise, the value is assigned to the variable.

The next Read starts with the blank, tab, or end-of-line marker that terminated the numeric string.

Related Information

System.Eof
System.Readln
System.Write
System.Writeln
System.SetLineBreakStyle

The Delphi language's extended syntax allows the Read , Readln , Str , and Val standard procedures to be applied to zero-based character arrays, and allows the Write , Writeln , Val , AssignFile , and Rename standard procedures to be applied to both zero-based character arrays and character pointers.

The following functions are provided for handling null-terminated strings.

Standard string-handling functions have multibyte-enabled counterparts that also implement locale-specific ordering for characters. Names of multibyte functions start with Ansi-. For example, the multibyte version of StrPos is AnsiStrPos.

Multibyte character support is operating-system dependent and based on the current locale.

The System unit provides three functions, WideCharToString , WideCharLenToString, and StringToWideChar, that can be used to convert null- terminated wide character strings to single- or double-byte long strings.

Assignment will also convert between strings. For instance, the following are both valid:

   MyAnsiString := MyWideString;
   MyWideString := MyAnsiString;

The table below lists frequently used procedures and functions found in Borland product libraries. This is not an exhaustive inventory of standard routines.