14.2 Filesystem
14.2.1 Locating Paths
(find-system-path kind) → path? |
kind : symbol? |
'home-dir – the current user’s home directory.
Under Unix and Mac OS X, this directory is determined by expanding the path "~", which is expanded by first checking for a HOME environment variable. If none is defined, the USER and LOGNAME environment variables are consulted (in that order) to find a user name, and then system files are consulted to locate the user’s home directory.
Under Windows, the user’s home directory is the user-specific profile directory as determined by the Windows registry. If the registry cannot provide a directory for some reason, the value of the USERPROFILE environment variable is used instead, as long as it refers to a directory that exists. If USERPROFILE also fails, the directory is the one specified by the HOMEDRIVE and HOMEPATH environment variables. If those environment variables are not defined, or if the indicated directory still does not exist, the directory containing the current executable is used as the home directory.
'pref-dir – the standard directory for storing the current user’s preferences. Under Unix, the directory is ".racket" in the user’s home directory. Under Windows, it is "Racket" in the user’s application-data folder as specified by the Windows registry; the application-data folder is usually "Application Data" in the user’s profile directory. Under Mac OS X, it is "Library/Preferences" in the user’s home directory. This directory might not exist.
'pref-file – a file that contains a symbol-keyed association list of preference values. The file’s directory path always matches the result returned for 'pref-dir. The file name is "racket-prefs.rktd" under Unix and Windows, and it is "org.racket-lang.prefs.rktd" under Mac OS X. The file’s directory might not exist. See also get-preference.
'temp-dir – the standard directory for storing temporary files. Under Unix and Mac OS X, this is the directory specified by the TMPDIR environment variable, if it is defined, otherwise it is the first path that exists among "/var/tmp", "/usr/tmp", and "/tmp". Under Windows, the result is the directory specified by the TMP or TEMP environment variable, if it is defined, otherwise it is the current directory.
'init-dir – the directory containing the initialization file used by the Racket executable. It is the same as the current user’s home directory.
'init-file – the file loaded at start-up by the Racket executable. The directory part of the path is the same path as returned for 'init-dir. The file name is platform-specific:
'addon-dir – a directory for installing Racket extensions. This directory is specified by the PLTADDONDIR environment variable, and it can be overridden by the --addon or -A command-line flag. If no environment variable or flag is specified, or if the value is not a legal path name, then this directory defaults to "Library/Racket" in the user’s home directory under Mac OS X and 'pref-dir otherwise. This directory might not exist.
'doc-dir – the standard directory for storing the current user’s documents. Under Unix, it’s the same as 'home-dir. Under Mac OS X, it’s the "Documents" directory in the user’s home directory. Under Windows, it is the user’s documents folder as specified by the Windows registry; the documents folder is usually "My Documents" in the user’s home directory.
'desk-dir – the directory for the current user’s desktop. Under Unix, it’s the same as 'home-dir. Under Windows, it is the user’s desktop folder as specified by the Windows registry; the documents folder is usually "Desktop" in the user’s home directory. Under Mac OS X, it is the desktop directory, which is specifically "~/Desktop" under Mac OS X.
'sys-dir – the directory containing the operating system for Windows. Under Unix and Mac OS X, the result is "/".
'exec-file – the path of the Racket executable as provided by the operating system for the current invocation. For some operating systems, the path can be relative.
For GRacket, the executable path is the name of a GRacket executable.
'run-file – the path of the current executable; this may be different from result for 'exec-file because an alternate path was provided through a --name or -N command-line flag to the Racket (or GRacket) executable, or because an embedding executable installed an alternate path. In particular a “launcher” script created by make-racket-launcher sets this path to the script’s path.
'collects-dir – a path to the main collection of libraries (see Libraries and Collections). If this path is relative, then it is relative to the executable as reported by (find-system-path 'exec-file) – though the latter could be a soft-link or relative to the user’s executable search path, so that the two results should be combined with find-executable-path. The 'collects-dir path is normally embedded in the Racket executable, but it can be overridden by the --collects or -X command-line flag.
'orig-dir – the current directory at start-up, which can be useful in converting a relative-path result from (find-system-path 'exec-file) or (find-system-path 'run-file) to a complete path.
| ||||||||
→ (listof path?) | ||||||||
str : (or/c string? bytes?) | ||||||||
default-path-list : (listof path?) |
| |||||||||||||||||||||
program-sub : path-string? | |||||||||||||||||||||
related-sub : (or/c path-string? #f) = #f | |||||||||||||||||||||
deepest? : any/c = #f |
If related-sub is not #f, then it must be a relative path string, and the path found for program-sub must be such that the file or directory related-sub exists in the same directory as the executable. The result is then the full path for the found related-sub, instead of the path for the executable.
This procedure is used by the Racket executable to find the standard library collection directory (see Libraries and Collections). In this case, program is the name used to start Racket and related is "collects". The related-sub argument is used because, under Unix and Mac OS X, program-sub may involve to a sequence of soft links; in this case, related-sub determines which link in the chain is relevant.
If related-sub is not #f, then when find-executable-path does not finds a program-sub that is a link to another file path, the search can continue with the destination of the link. Further links are inspected until related-sub is found or the end of the chain of links is reached. If deepest? is #f (the default), then the result corresponds to the first path in a chain of links for which related-sub is found (and further links are not actually explored); otherwise, the result corresponds to the last link in the chain for which related-sub is found.
If program-sub is a pathless name, find-executable-path gets the value of the PATH environment variable; if this environment variable is defined, find-executable-path tries each path in PATH as a prefix for program-sub using the search algorithm described above for path-containing program-subs. If the PATH environment variable is not defined, program-sub is prefixed with the current directory and used in the search algorithm above. (Under Windows, the current directory is always implicitly the first item in PATH, so find-executable-path checks the current directory first under Windows.)
14.2.2 Files
(file-exists? path) → boolean? |
path : path-string? |
Under Windows, file-exists? reports #t for all variations of the special filenames (e.g., "LPT1", "x:/baddir/LPT1").
(link-exists? path) → boolean? |
path : path-string? |
The predicates file-exists? or directory-exists? work on the final destination of a link or series of links, while link-exists? only follows links to resolve the base part of path (i.e., everything except the last name in the path).
This procedure never raises the exn:fail:filesystem exception.
(delete-file path) → void? |
path : path-string? |
| |||||||||||||||||||||
old : path-string? | |||||||||||||||||||||
new : path-string? | |||||||||||||||||||||
exists-ok? : any/c = #f |
This procedure can be used to move a file/directory to a different directory (on the same disk) as well as rename a file/directory within a directory. Unless exists-ok? is provided as a true value, new cannot refer to an existing file or directory. Even if exists-ok? is true, new cannot refer to an existing file when old is a directory, and vice versa. (If new exists and is replaced, the replacement is atomic in the filesystem, except under Windows 95, 98, or Me. However, the check for existence is not included in the atomic action, which means that race conditions are possible when exists-ok? is false or not supplied.)
If old is a link, the link is renamed rather than the destination of the link, and it counts as a file for replacing any existing new.
| |||||||||||||||||||||
path : path-string? | |||||||||||||||||||||
secs-n : (or/c exact-integer? #f) = #f | |||||||||||||||||||||
|
If secs-n is provided and not #f, the access and modification times of path are set to the given time.
On error (e.g., if no such file exists), fail-thunk is called, and the default fail-thunk raises exn:fail:filesystem.
(file-or-directory-permissions path) → (listof symbol?) |
path : path-string? |
(file-or-directory-identity path [as-link?]) |
→ exact-positive-integer? |
path : path-string? |
as-link? : any/c = #f |
If as-link? is a true value, then if path refers to a filesystem link, the identity of the link is returned instead of the identity of the referenced file or directory (if any).
(file-size path) → exact-nonnegative-integer? |
path : path-string? |
(copy-file src dest) → void? |
src : path-string? |
dest : path-string? |
(make-file-or-directory-link to path) → void? |
to : path-string? |
path : path-string? |
14.2.3 Directories
See also: rename-file-or-directory, file-or-directory-modify-seconds, file-or-directory-permissions.
(current-directory) → path-string? |
(current-directory path) → void? |
path : path-string? |
When the parameter procedure is called to set the current directory, the path argument is cleansed using cleanse-path, simplified using simplify-path, and then converted to a directory path with path->directory-path; cleansing and simplification raise an exception if the path is ill-formed. Thus, the current value of current-directory is always a cleansed, simplified, complete, directory path.
The path is not checked for existence when the parameter is set.
(current-drive) → path? |
(directory-exists? path) → boolean? |
path : path-string? |
(make-directory path) → void? |
path : path-string? |
(delete-directory path) → void? |
path : path-string? |
(directory-list [path]) → (listof path?) |
path : path-string? = (current-directory) |
See also the in-directory sequence constructor.
Returns a list of all files and directories in the directory specified by path. Under Windows, an element of the list may start with \\?\REL\\.
(filesystem-root-list) → (listof path?) |
14.2.4 Declaring Paths Needed at Run Time
The racket/runtime-path library provides forms for accessing files and directories at run time using a path that are usually relative to an enclosing source file. Unlike using collection-path, define-runtime-path exposes each run-time path to tools like the executable and distribution creators, so that files and directories needed at run time are carried along in a distribution.
In addition to the bindings described below, racket/runtime-path provides #%datum in phase level 1, since string constants are often used as compile-time expressions with define-runtime-path.
(define-runtime-path id expr) |
For run time, id is bound to a path that is based on the result of expr. The path is normally computed by taking a relative path result from expr and adding it to a path for the enclosing file (which is computed as described below). However, tools like the executable creator can also arrange (by colluding with racket/runtime-path) to have a different base path substituted in a generated executable. If expr produces an absolute path, it is normally returned directly, but again may be replaced by an executable creator. In all cases, the executable creator preserves the relative locations of all paths. When expr produces a relative or absolute path, then the path bound to id is always an absolute path.
If expr produces a list of the form (list 'lib str ...+), the value bound to id is an absolute path. The path refers to a collection-based file similar to using the value as a module path.
If expr produces a list of the form (list 'so str), the value bound to id can be either str or an absolute path; it is an absolute path when adding the platform-specific shared-library extension – as produced by (system-type 'so-suffix) – and then searching in the Racket-specific shared-object library directories (as determined by get-lib-search-dirs) locates the path. In this way, shared-object libraries that are installed specifically for Racket get carried along in distributions.
For compile-time, the expr result is used by an executable creator – but not the result when the containing module is compiled. Instead, expr is preserved in the module as a compile-time expression (in the sense of begin-for-syntax). Later, at the time that an executable is created, the compile-time portion of the module is executed (again), and the result of expr is the file to be included with the executable. The reason for the extra compile-time execution is that the result of expr might be platform-dependent, so the result should not be stored in the (platform-independent) bytecode form of the module; the platform at executable-creation time, however, is the same as at run time for the executable. Note that expr is still evaluated at run-time; consequently, avoid procedures like collection-path, which depends on the source installation, and instead use relative paths and forms like (list 'lib str ...+).
If a path is needed only on some platforms and not on others, use define-runtime-path-list with an expr that produces an empty list on platforms where the path is not needed.
The enclosing path for a define-runtime-path is determined as follows from the define-runtime-path syntactic form:
If the form has a source module according to syntax-source-module, then the source location is determined by preserving the original expression as a syntax object, extracting its source module path at run time (again using syntax-source-module), and then resolving the resulting module path index.
If the expression has no source module, the syntax-source location associated with the form is used, if is a string or path.
If no source module is available, and syntax-source produces no path, then current-load-relative-directory is used if it is not #f. Finally, current-directory is used if all else fails.
In the latter two cases, the path is normally preserved in (platform-specific) byte form. If it is is within the result of find-collects-dir, however, it the path is recorded relative to (find-collects-dir), and it is reconstructed using (find-collects-dir) at run time.
Examples:
; Access a file "data.txt" at run-time that is originally |
; located in the same directory as the module source file: |
(define-runtime-path data-file "data.txt") |
(define (read-data) |
(with-input-from-file data-file |
(lambda () |
(read-bytes (file-size data-file))))) |
; Load a platform-specific shared object (using ffi-lib) |
; that is located in a platform-specific sub-directory of the |
; module's source directory: |
(define-runtime-path libfit-path |
(build-path "compiled" "native" (system-library-subpath #f) |
(path-replace-suffix "libfit" |
(system-type 'so-suffix)))) |
(define libfit (ffi-lib libfit-path)) |
; Load a platform-specific shared object that might be installed |
; as part of the operating system, or might be installed |
; specifically for Racket: |
(define-runtime-path libssl-so |
(case (system-type) |
[(windows) '(so "ssleay32")] |
[else '(so "libssl")])) |
(define libssl (ffi-lib libssl-so)) |
(define-runtime-paths (id ...) expr) |
(define-runtime-path-list id expr) |
(define-runtime-module-path id module-path) |
Use define-runtime-module-path to bind a module path that is passed to a reflective function like dynamic-require while also creating a module dependency for building and distributing executables.
The define-runtime-module-path form creates a for-label dependency from an enclosing module to module-path. Since the dependency is merely for-label, module-path is not instantiated or visited when the enclosing module is instantiated or visited (unless such a dependency is created by other requires).
(runtime-paths module-path) |
14.2.5 More File and Directory Utilities
(file->string path [#:mode mode-flag]) → string? |
path : path-string? |
mode-flag : (or/c 'binary 'text) = 'binary |
(file->bytes path [#:mode mode-flag]) → bytes? |
path : path-string? |
mode-flag : (or/c 'binary 'text) = 'binary |
(file->value path [#:mode mode-flag]) → any |
path : path-string? |
mode-flag : (or/c 'binary 'text) = 'binary |
(file->list path [proc #:mode mode-flag]) → (listof any/c) |
path : path-string? |
proc : (input-port? . -> . any/c) = read |
mode-flag : (or/c 'binary 'text) = 'binary |
| |||||||||||||||||||||
path : path-string? | |||||||||||||||||||||
mode-flag : (or/c 'binary 'text) = 'binary | |||||||||||||||||||||
|
| |||||||||||||||||||||
path : path-string? | |||||||||||||||||||||
mode-flag : (or/c 'binary 'text) = 'binary | |||||||||||||||||||||
|
| ||||||||||||||||||||||||||||
v : any/c | ||||||||||||||||||||||||||||
path : path-string? | ||||||||||||||||||||||||||||
mode-flag : (or/c 'binary 'text) = 'binary | ||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||
v : any/c | ||||||||||||||||||||||||||||
path : path-string? | ||||||||||||||||||||||||||||
mode-flag : (or/c 'binary 'text) = 'binary | ||||||||||||||||||||||||||||
|
| |||||||||||||||||||||||||||||||||||
lst : list? | |||||||||||||||||||||||||||||||||||
path : path-string? | |||||||||||||||||||||||||||||||||||
separator : any/c = #"\n" | |||||||||||||||||||||||||||||||||||
mode-flag : (or/c 'binary 'text) = 'binary | |||||||||||||||||||||||||||||||||||
|
(copy-directory/files src dest) → void? |
src : path-string? |
dest : path-string? |
(delete-directory/files path) → void? |
path : path-string? |
(find-files predicate [start-path]) → (listof path?) |
predicate : (path? . -> . any/c) |
start-path : (or/c path-string? #f) = #f |
The predicate procedure is called with a single argument for each file or directory. If start-path is #f, the argument is a pathname string that is relative to the current directory. Otherwise, it is a path building on start-path. Consequently, supplying (current-directory) for start-path is different from supplying #f, because predicate receives complete paths in the former case and relative paths in the latter. Another difference is that predicate is not called for the current directory when start-path is #f.
The find-files traversal follows soft links. To avoid following links, use the more general fold-files procedure.
If start-path does not refer to an existing file or directory, then predicate will be called exactly once with start-path as the argument.
The find-files procedure raises and exception if it encounters a directory for which directory-list fails.
(pathlist-closure path-list) → (listof path?) |
path-list : (listof path-string?) |
if a nested path is given, all of its ancestors are also included in the result (but the same ancestor is not added twice);
if a path refers to directory, all of its descendants are also included in the result;
ancestor directories appear before their descendants in the result list.
| ||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||
init-val : any/c | ||||||||||||||||||||||||||||
start-path : (or/c path-string? #f) = #f | ||||||||||||||||||||||||||||
follow-links? : any/c = #t |
The proc procedure is called with three arguments for each file, directory, or link:
If start-path is #f, the first argument is a pathname string that is relative to the current directory. Otherwise, the first argument is a pathname that starts with start-path. Consequently, supplying (current-directory) for start-path is different from supplying #f, because proc receives complete paths in the former case and relative paths in the latter. Another difference is that proc is not called for the current directory when start-path is #f.
The second argument is a symbol, either 'file, 'dir, or 'link. The second argument can be 'link when follow-links? is #f, in which case the filesystem traversal does not follow links. If follow-links? is #t, then proc will only get a 'link as a second argument when it encounters a dangling symbolic link (one that does not resolve to an existing file or directory).
The third argument is the accumulated result. For the first call to proc, the third argument is init-val. For the second call to proc (if any), the third argument is the result from the first call, and so on. The result of the last call to proc is the result of fold-files.
The proc argument is used in an analogous way to the procedure argument of foldl, where its result is used as the new accumulated result. There is an exception for the case of a directory (when the second argument is 'dir): in this case the procedure may return two values, the second indicating whether the recursive scan should include the given directory or not. If it returns a single value, the directory is scanned. In the cases of files or links (when the second argument is 'file or 'link), a second value is permitted but ignored.
If the start-path is provided but no such path exists, or if paths disappear during the scan, then an exception is raised.
(make-directory* path) → void? |
path : path-string? |
| |||||||||||||||||||||
template : string? = "mztmp~a" | |||||||||||||||||||||
copy-from-filename : (or/c path-string? #f 'directory) = #f | |||||||||||||||||||||
directory : (or/c path-string? #f) = #f |
The template argument must be a format string suitable for use with format and one additional string argument (where the string contains only digits). If the resulting string is a relative path, it is combined with the result of (find-system-path 'temp-dir), unless directory is provided and non-#f, in which case the file name generated from template is combined with directory to obtain a full path.
If copy-from-filename is provided as path, the temporary file is created as a copy of the named file (using copy-file). If copy-from-filename is #f, the temporary file is created as empty. If copy-from-filename is 'directory, then the temporary “file” is created as a directory.
When a temporary file is created, it is not opened for reading or writing when the pathname is returned. The client program calling make-temporary-file is expected to open the file with the desired access and flags (probably using the 'truncate flag; see open-output-file) and to delete it when it is no longer needed.
| ||||||||||||||||||||||||||||
name : symbol? | ||||||||||||||||||||||||||||
failure-thunk : (-> any) = (lambda () #f) | ||||||||||||||||||||||||||||
flush-mode : any/c = 'timestamp | ||||||||||||||||||||||||||||
filename : (or/c string-path? #f) = #f |
The preference file should contain a symbol-keyed association list (written to the file with the default parameter settings). Keys starting with racket:, mzscheme:, mred:, and plt: in any letter case are reserved for use by Racket implementers.
The result of get-preference is the value associated with name if it exists in the association list, or the result of calling failure-thunk otherwise.
Preference settings are cached (weakly) across calls to get-preference, using (path->complete-path filename) as a cache key. If flush-mode is provided as #f, the cache is used instead of the re-consulting the preferences file. If flush-mode is provided as 'timestamp (the default), then the cache is used only if the file has a timestamp that is the same as the last time the file was read. Otherwise, the file is re-consulted.
See also put-preferences. For a more elaborate preference system, see preferences:get.
Old preferences files: When a filename is not provided and the file indicated by (find-system-path 'pref-file) does not exist, the following paths are checked for compatibility with old versions of Racket:
Windows: (build-path (find-system-path 'pref-dir) 'up "PLT Scheme" "plt-prefs.ss")
Mac OS X: (build-path (find-system-path 'pref-dir) "org.plt-scheme.prefs.ss")
Unix: (expand-user-path "~/.plt-scheme/plt-prefs.ss")
| ||||||||||||||||||||||||||||
names : (listof symbol?) | ||||||||||||||||||||||||||||
vals : list? | ||||||||||||||||||||||||||||
locked-proc : (path? . -> . any) = (lambda (p) (error ....)) | ||||||||||||||||||||||||||||
filename : (or/c #f path-string?) = #f |
The names argument supplies the preference names, and vals must have the same length as names. Each element of vals must be an instance of a built-in data type whose write output is readable (i.e., the print-unreadable parameter is set to #f while writing preferences).
Current preference values are read from the preference file before updating, and an update “lock” is held starting before the file read, and lasting until after the preferences file is updated. The lock is implemented by the existence of a file in the same directory as the preference file. If the directory of the preferences file does not already exist, it is created.
If the update lock is already held (i.e., the lock file exists), then locked is called with a single argument: the path of the lock file. The default locked reports an error; an alternative thunk might wait a while and try again, or give the user the choice to delete the lock file (in case a previous update attempt encountered disaster).
If filename is #f or not supplied, and the preference file does not already exist, then values read from the "defaults" collection (if any) are written for preferences that are not mentioned in names.