Joseph Ferano
2e203f64b8
The INSERTIONSORT crash, all three rulings (FIX.org 2026-09-20): - (bytes s) allocates a writable copy through the allocator surface — context or (bytes s a), StorageExhausted with retry, a registry note in dev builds (flan_bytes_dup, lowered like vec-new). (bytes-view s) is the old zero-cost reinterpret, renamed, read-only by convention; every in-repo reader swept over to it. (string b) unchanged. - String constants were already read-only on both backends at -O0; now pinned — bytes-copy.flan rows on LLVM/-O0/--x86, and dies_segv rows asserting the write-through-view trap on both backends. - A dev build installs a SIGSEGV/SIGBUS handler by the same dev-only constructor slot that arms the registry: one line naming the address and the innermost frame, then the trap-hook park — stopped, not dead, the daemon serving. No agent: message and re-raise. Release builds untouched. Pinned by trap_park over dev-segv.flan.
108 lines
5.1 KiB
Plaintext
108 lines
5.1 KiB
Plaintext
;;;; The file surface beyond slurp and barf: file-exists?, file-size,
|
|
;;;; delete-file, rename-file and make-directory.
|
|
;;;;
|
|
;;;; The split down the middle of that list is the whole design and this file
|
|
;;;; is arranged to show it. The two that ask a *question* — is it there, how
|
|
;;;; big is it — answer a value, because absence is a reply and not a fault;
|
|
;;;; they are prelude functions over one declare and the compiler knows
|
|
;;;; nothing about them. The three that *change* the filesystem answer () and
|
|
;;;; signal FileError with the two restarts slurp and barf already establish,
|
|
;;;; because each of their failures is one a handler can act on: make the
|
|
;;;; parent directory and retry, or supply another path.
|
|
;;;;
|
|
;;;; Everything is made and removed inside this program, so it leaves the
|
|
;;;; directory as it found it — checked at the end rather than assumed.
|
|
|
|
;; Handlers cannot see the locals of the function that established them, so the
|
|
;; observations are globals, as in slurp.flan.
|
|
(defvar seen i64)
|
|
(defvar last-reason i32)
|
|
(defvar last-op i32)
|
|
|
|
(defn main [] i32
|
|
;; ── The questions ─────────────────────────────────────────────────
|
|
(println (file-exists? "programs/assets/a.txt")) ; true
|
|
(println (file-exists? "programs/assets/nope")) ; false
|
|
;; A directory resolves, which is what the name asks and not "is a regular
|
|
;; file" — a caller wanting the narrower question is asking a second one.
|
|
(println (file-exists? "programs/assets")) ; true
|
|
|
|
(match (file-size "programs/assets/a.txt")
|
|
(Some n) (println n) ; 13
|
|
None (println "missing"))
|
|
;; None folds every reason into one answer, which is the trade a question
|
|
;; with no restart on it makes.
|
|
(match (file-size "programs/assets/nope")
|
|
(Some n) (println n)
|
|
None (println "none"))
|
|
|
|
;; ── make-directory, rename-file, delete-file ──────────────────────
|
|
(make-directory "files-tmp")
|
|
(println (file-exists? "files-tmp")) ; true
|
|
|
|
(barf "files-tmp/one.txt" (bytes-view "0123456789"))
|
|
(match (file-size "files-tmp/one.txt")
|
|
(Some n) (println n) ; 10
|
|
None (println "missing"))
|
|
|
|
(rename-file "files-tmp/one.txt" "files-tmp/two.txt")
|
|
(println (file-exists? "files-tmp/one.txt")) ; false
|
|
(println (file-exists? "files-tmp/two.txt")) ; true
|
|
|
|
(delete-file "files-tmp/two.txt")
|
|
(println (file-exists? "files-tmp/two.txt")) ; false
|
|
|
|
;; ── retry, after the handler made the parent ──────────────────────
|
|
;; The restart this family exists for. Writing into a directory that is not
|
|
;; there is ENOENT, which arrives as `missing`; the handler makes the
|
|
;; directory and takes `retry`, and the second attempt succeeds. Nothing in
|
|
;; the failing code knows any of that happened.
|
|
(handler-bind
|
|
[(FileError [c]
|
|
(set seen (+ seen 1))
|
|
(set last-reason (.reason c))
|
|
(set last-op (.op c))
|
|
(make-directory "files-tmp/sub")
|
|
(invoke-restart 'retry))]
|
|
(barf "files-tmp/sub/deep.txt" (bytes-view "deep")))
|
|
(println seen) ; 1
|
|
(println (= last-reason file-missing)) ; true
|
|
(println (= last-op file-op-write)) ; true
|
|
(println (file-exists? "files-tmp/sub/deep.txt")) ; true
|
|
|
|
;; ── use-value, on a delete ────────────────────────────────────────
|
|
;; The same restart slurp's read offers, on an operation that writes: the
|
|
;; handler names a path that is there and the delete resumes against it.
|
|
(set seen 0)
|
|
(handler-bind
|
|
[(FileError [c]
|
|
(set seen (+ seen 1))
|
|
(set last-op (.op c))
|
|
(invoke-restart 'use-value "files-tmp/sub/deep.txt"))]
|
|
(delete-file "files-tmp/sub/not-there.txt"))
|
|
(println seen) ; 1
|
|
(println (= last-op file-op-delete)) ; true
|
|
(println (file-exists? "files-tmp/sub/deep.txt")) ; false
|
|
|
|
;; ── A non-empty directory does not delete ─────────────────────────
|
|
;; remove() is unlink or rmdir depending on what the path names, so an empty
|
|
;; directory goes by the same call a file does — and a full one does not,
|
|
;; which is deliberate: a recursive delete is a loop the caller writes and
|
|
;; sees. Here the handler declines to answer, which is what an unhandled
|
|
;; condition would do, so it counts and lets the program carry on by
|
|
;; supplying the child path instead.
|
|
(set seen 0)
|
|
(handler-bind
|
|
[(FileError [c]
|
|
(set seen (+ seen 1))
|
|
(set last-op (.op c))
|
|
(invoke-restart 'use-value "files-tmp/sub"))]
|
|
(delete-file "files-tmp"))
|
|
(println seen) ; 1
|
|
(println (= last-op file-op-delete)) ; true
|
|
|
|
;; And now it is empty, so it goes.
|
|
(delete-file "files-tmp")
|
|
(println (file-exists? "files-tmp")) ; false
|
|
0)
|