(let ((*standard-output* <some form generating a stream>)) ...)Because
*STANDARD-OUTPUT*is a dynamic variable, all references to it during execution of the body of the
LETform refer to the stream that you bound it to. After exiting the
LETform, the old value of
*STANDARD-OUTPUT*is restored, no matter if the exit was by normal execution, a
RETURN-FROMleaving the whole function, an exception, or what-have-you. (This is, incidentally, why global variables lose much of their brokenness in Common Lisp compared to other languages: since they can be bound for the execution of a specific form without the risk of losing their former value after the form has finished, their use is quite safe; they act much like additional parameters that are passed to every function.)
If the output of the program should go to a file, you can do the following:
(with-open-file (*standard-output* "somefile.dat" :direction :output :if-exists :supersede) ...)
WITH-OPEN-FILEopens the file - creating it if necessary - binds
*STANDARD-OUTPUT*, executes its body, closes the file, and restores
*STANDARD-OUTPUT*to its former value. It doesn't get more comfortable than this!
(PRINC (CODE-CHAR 0..255) s)to a stream and expect 8-bit bytes to be written out, which is not obvious in the times of Unicode and 16 or 32 bit character representations. It does not require that the characters ä, ß, or þ must have their
CHAR-CODEin the range 0..255 - the implementation is free to use any code. But it does require that no
#\Newlineto CRLF translation takes place, among others.
Common Lisp has a long tradition of distinguishing character from byte
(binary) I/O, e.g.
are in the standard. Some implementations let both functions be called
interchangeably. Others allow either one or the other.
(The simple stream proposal
defines the notion of a bivalent stream where both are
Varying element-types are useful as some protocols rely on the ability
to send 8-Bit output on a channel. E.g. with HTTP, the header is
normally ASCII and ought to use CRLF as line terminators, whereas the
body can have the MIME type application/octet-stream, where CRLF
translation would destroy the data. (This is how the Netscape
browser on MS-Windows destroys data sent by incorrectly configured
Webservers which declare unknown files as having MIME type text/plain
- the default in most Apache configurations).
What follows is a list of implementation dependent choices and behaviours and some code to experiment.
:external-format (ext:make-encoding :charset 'charset:iso-8859-1 :line-terminator :unix)You can also use
(SETF (STREAM-ELEMENT-TYPE F) '(UNSIGNED-BYTE 8)), where the ability to
SETFis a CLISP-specific extension. Using
:EXTERNAL-FORMAT :UNIXwill cause portability problems, since the default character set on MS-Windows is
CHARSET:CP1252doesn't allow output of e.g.
;*** - Character #\u0080 cannot be represented in the character set CHARSET:CP1252Characters with code > 127 cannot be represented in ASCII:
;*** - Character #\u0080 cannot be represented in the character set CHARSET:ASCII
:EXTERNAL-FORMAT :DEFAULT(untested) - no unicode, so probably no problems.
#+(AND ALLEGRO UNIX) :DEFAULT(untested) - seems enough on UNIX, but would not work on the MS-Windows port of AllegroCL.
:EXTERNAL-FORMAT '(:LATIN-1 :EOL-STYLE :LF)(confirmed by Marc Battyani)
(defvar *unicode-test-file* "faithtest-out.txt") (defun generate-256 (&key (filename *unicode-test-file*) #+CLISP (charset 'charset:iso-8859-1) external-format) (let ((e (or external-format #+CLISP (ext:make-encoding :charset charset :line-terminator :unix)))) (describe e) (with-open-file (f filename :direction :output :external-format e) (write-sequence (loop with s = (make-string 256) for i from 0 to 255 do (setf (char s i) (code-char i)) finally (return s)) f) (file-position f)))) ;(generate-256 :external-format :default) ;#+CLISP (generate-256 :external-format :unix) ;#+CLISP (generate-256 :external-format 'charset:ascii) ;(generate-256) (defun check-256 (&optional (filename *unicode-test-file*)) (with-open-file (f filename :direction :input :element-type '(unsigned-byte 8)) (loop for i from 0 for c = (read-byte f nil nil) while c unless (= c i) do (format t "~&Position ~D found ~D(#x~X)." i c c) when (and (= i 33) (= c 32)) do (let ((c (read-byte f))) (format t "~&Resync back 1 byte ~D(#x~X) - cause CRLF?." c c) )) (file-length f))) #| CLISP (check-256 *unicode-test-file*) (progn (generate-256 :external-format :unix) (check-256)) ; uses UTF-8 -> 385 bytes (progn (generate-256 :charset 'charset:iso-8859-1) (check-256)) (progn (generate-256 :external-format :default) (check-256)) ; uses UTF-8 + CRLF(on MS-Windows) -> 387 bytes (progn (generate-256 :external-format (ext:make-encoding :charset 'charset:iso-8859-1 :line-terminator :mac)) (check-256)) (progn (generate-256 :external-format (ext:make-encoding :charset 'charset:iso-8859-1 :line-terminator :dos)) (check-256)) |#
(let ((buf (make-array 4096 :element-type (stream-element-type input-stream))) (loop for pos = (read-sequence input-stream) while (plusp pos) do (write-sequence buf output-stream :end pos))))