SWI-Prolog 7.4.1 Reference Manual: Section 4.36

## 4.36 File System Interaction

access_file(+File, +Mode)
  True if File exists and can be accessed by this Prolog process under mode Mode. Mode is one of the atoms `read`, `write`, `append`, `exist`, `none` or `execute`. File may also be the name of a directory. Fails silently otherwise. `access_file(File, none)` simply succeeds without testing anything.

  If Mode is `write` or `append`, this predicate also succeeds if the file does not exist and the user has write access to the directory of the specified location.

  The bahaviour is backed up by the POSIX access() API. The Windows replacement (_waccess()) returns incorrect results because it does not consider ACLs (Access Control Lists). The Prolog flag win_file_access_check may be used to control the level of checking performed by Prolog. Please note that checking access never provides a guarantee that a subsequent open succeeds without errors due to inherent concurrency in file operations. It is generally more robust to try and open the file and handle possible exceptions. See open/4 and catch/3.

exists_file(+File)
  True if File exists and is a regular file. This does not imply the user has read and/or write permission for the file. This is the same as `access_file(File, exist)`.
file_directory_name(+File, -Directory)
  Extracts the directory part of File. The returned Directory name does not end in ``/``. There are two special cases. The directory name of ``/`` is ``/`` itself, and the directory name is ``.`` if File does not contain any ``/`` characters. If the File argument ends with a ``/``, e.g., `'/hello/'`, it is not a valid file name. In this case the final ``/`` is removed from File, e.g., `'/hello'`.

  See also directory_file_path/3 from `library(filesex)`. The system ensures that for every valid Path using the Prolog (POSIX) directory separators, following is true on systems with a sound implementation of same_file/2.127On some systems, Path and Path2 refer to the same entry in the file system, but same_file/2 may fail. See also prolog_to_os_filename/2.

              ...,
              file_directory_name(Path, Dir),
              file_base_name(Path, File),
              directory_file_path(Dir, File, Path2),
              same_file(Path, Path2).

file_base_name(+File, -BaseName)
  Extracts the filename part from a path specification. If File does not contain any directory separators, File is returned in BaseName. See also file_directory_name/2. If the File arguments ends with a ``/``, e.g., `'/hello/'`, BaseName is unified with the empty atom (`''`).
same_file(+File1, +File2)
  True if both filenames refer to the same physical file. That is, if File1 and File2 are the same string or both names exist and point to the same file (due to hard or symbolic links and/or relative vs. absolute paths). On systems that provide stat() with meaningful values for `st_dev` and `st_inode`, same_file/2 is implemented by comparing the device and inode identifiers. On Windows, same_file/2 compares the strings returned by the GetFullPathName() system call.
exists_directory(+Directory)
  True if Directory exists and is a directory. This does not imply the user has read, search or write permission for the directory.
delete_file(+File)
  Remove File from the file system.
rename_file(+File1, +File2)
  Rename File1 as File2. The semantics is compatible to the POSIX semantics of the rename() system call as far as the operating system allows. Notably, if File2 exists, the operation succeeds (except for possible permission errors) and is atomic (meaning there is no window where File2 does not exist).
size_file(+File, -Size)
  Unify Size with the size of File in bytes.
time_file(+File, -Time)
  Unify the last modification time of File with Time. Time is a floating point number expressing the seconds elapsed since Jan 1, 1970. See also convert_time/[2,8] and get_time/1.
absolute_file_name(+File, -Absolute)
  Expand a local filename into an absolute path. The absolute path is canonicalised: references to `.` and `..` are deleted. This predicate ensures that expanding a filename returns the same absolute path regardless of how the file is addressed. SWI-Prolog uses absolute filenames to register source files independent of the current working directory. See also absolute_file_name/3. See also absolute_file_name/3 and expand_file_name/2.
absolute_file_name(+Spec, -Absolute, +Options)
  Convert the given file specification into an absolute path. Spec is a term Alias(Relative) (e.g., `(library(lists)`), a relative filename or an absolute filename. The primary intention of this predicate is to resolve files specified as Alias(Relative). Option is a list of options to guide the conversion:
  extensions(ListOfExtensions)
    List of file extensions to try. Default is `''`. For each extension, absolute_file_name/3 will first add the extension and then verify the conditions imposed by the other options. If the condition fails, the next extension on the list is tried. Extensions may be specified both as `.ext` or plain `ext`.
  relative_to(+FileOrDir)
    Resolve the path relative to the given directory or the directory holding the given file. Without this option, paths are resolved relative to the working directory (see working_directory/2) or, if Spec is atomic and absolute_file_name/[2,3] is executed in a directive, it uses the current source file as reference.
  access(Mode)
    Imposes the condition access_file(File, Mode). Mode is one of `read`, `write`, `append`, `execute`, `exist` or `none`. See also access_file/2.
  file_type(Type)
    Defines extensions. Current mapping: `txt` implies `['']`, `prolog` implies `['.pl', '']`, `executable` implies `['.so', '']`, `qlf` implies `['.qlf', '']` and `directory` implies `['']`. The file type `source` is an alias for `prolog` for compatibility with SICStus Prolog. See also prolog_file_type/2. This predicate only returns non-directories, unless the option `file_type(directory)` is specified.
  file_errors(fail/error)
    If `error` (default), throw an `existence_error` exception if the file cannot be found. If `fail`, stay silent.128Silent operation was the default up to version 3.2.6.
  solutions(first/all)
    If `first` (default), the predicate leaves no choice point. Otherwise a choice point will be left and backtracking may yield more solutions.
  expand(true/false)
    If `true` (default is `false`) and Spec is atomic, call expand_file_name/2 followed by member/2 on Spec before proceeding. This is a SWI-Prolog extension.

  The Prolog flag verbose_file_search can be set to `true` to help debugging Prolog's search for files.

  This predicate is derived from Quintus Prolog. In Quintus Prolog, the argument order was `absolute_file_name(+Spec, +Options, -Path)`. The argument order has been changed for compatibility with ISO and SICStus. The Quintus argument order is still accepted.

is_absolute_file_name(+File)
  True if File specifies an absolute path name. On Unix systems, this implies the path starts with a `/'. For Microsoft-based systems this implies the path starts with `<letter>:`. This predicate is intended to provide platform-independent checking for absolute paths. See also absolute_file_name/2 and prolog_to_os_filename/2.
file_name_extension(?Base, ?Extension, ?Name)
  This predicate is used to add, remove or test filename extensions. The main reason for its introduction is to deal with different filename properties in a portable manner. If the file system is case-insensitive, testing for an extension will also be done case-insensitive. Extension may be specified with or without a leading dot (``.``). If an Extension is generated, it will not have a leading dot.
directory_files(+Directory, -Entries)
  Unify Entries with a list of entries in Directory. Each member of Entries is an atom denoting an entry relative to Directory. Entries contains all entries, including hidden files and, if supplied by the OS, the special entries ``.`` and `..`. See also expand_file_name/2.129This predicate should be considered a misnomer because it returns entries rather than files. We stick to this name for compatibility with, e.g., SICStus, Ciao and YAP.
expand_file_name(+WildCard, -List)
  Unify List with a sorted list of files or directories matching WildCard. The normal Unix wildcard constructs ```?``', ```*``', ``[ ... ]`' and ``{...}`' are recognised. The interpretation of ``{...}`' is slightly different from the C shell (csh(1)). The comma-separated argument can be arbitrary patterns, including ``{...}`' patterns. The empty pattern is legal as well: ``{.pl,}`' matches either ``.pl`' or the empty string.

  If the pattern contains wildcard characters, only existing files and directories are returned. Expanding a `pattern' without wildcard characters returns the argument, regardless of whether or not it exists.

  Before expanding wildcards, the construct `$var` is expanded to the value of the environment variable var, and a possible leading `~` character is expanded to the user's home directory.130On Windows, the home directory is determined as follows: if the environment variable `HOME` exists, this is used. If the variables `HOMEDRIVE` and `HOMEPATH` exist (Windows-NT), these are used. At initialisation, the system will set the environment variable `HOME` to point to the SWI-Prolog home directory if neither `HOME` nor `HOMEPATH` and `HOMEDRIVE` are defined.

prolog_to_os_filename(?PrologPath, ?OsPath)
  Convert between the internal Prolog path name conventions and the operating system path name conventions. The internal conventions follow the POSIX standard, which implies that this predicate is equivalent to =/2 (unify) on POSIX (e.g., Unix) systems. On Windows systems it changes the directory separator from ``\`` into ``/``.
read_link(+File, -Link, -Target)
  If File points to a symbolic link, unify Link with the value of the link and Target to the file the link is pointing to. Target points to a file, directory or non-existing entry in the file system, but never to a link. Fails if File is not a link. Fails always on systems that do not support symbolic links.
[deprecated]tmp_file(+Base, -TmpName)
  Create a name for a temporary file. Base is an identifier for the category of file. The TmpName is guaranteed to be unique. If the system halts, it will automatically remove all created temporary files. Base is used as part of the final filename. Portable applications should limit themselves to alphanumeric characters.

  Because it is possible to guess the generated filename, attackers may create the filesystem entry as a link and possibly create a security issue. New code should use tmp_file_stream/3.

tmp_file_stream(+Encoding, -FileName, -Stream)
  Create a temporary filename FileName and open it for writing in the given Encoding. Encoding is a text-encoding name or `binary`. Stream is the output stream. If the OS supports it, the created file is only accessible to the current user. If the OS supports it, the file is created using the open()-flag `O_EXCL`, which guarantees that the file did not exist before this call. This predicate is a safe replacement of tmp_file/2. Note that in those cases where the temporary file is needed to store output from an external command, the file must be closed first. E.g., the following downloads a file from a URL to a temporary file and opens the file for reading (on Unix systems you can delete the file for cleanup after opening it for reading):

      open_url(URL, In) :-
              tmp_file_stream(text, File, Stream),
              close(Stream),
              process_create(curl, ['-o', File, URL], []),
              open(File, read, In),
              delete_file(File).              % Unix-only

  Temporary files created using this call are removed if the Prolog process terminates gracefully. Calling delete_file/1 using FileName removes the file and removes the entry from the administration of files-to-be-deleted.

make_directory(+Directory)
  Create a new directory (folder) on the filesystem. Raises an exception on failure. On Unix systems, the directory is created with default permissions (defined by the process umask setting).
delete_directory(+Directory)
  Delete directory (folder) from the filesystem. Raises an exception on failure. Please note that in general it will not be possible to delete a non-empty directory.
working_directory(-Old, +New)
  Unify Old with an absolute path to the current working directory and change working directory to New. Use the pattern `working_directory(CWD, CWD)` to get the current directory. See also absolute_file_name/2 and chdir/1.bugSome of the file I/O predicates use local filenames. Changing directory while file-bound streams are open causes wrong results on telling/1, seeing/1 and current_stream/3. Note that the working directory is shared between all threads.
chdir(+Path)
  Compatibility predicate. New code should use working_directory/2.