|
|
<!doctype html>
|
|
|
<html>
|
|
|
<head>
|
|
|
<meta charset="utf-8">
|
|
|
<title>CodeMirror: Common Lisp mode</title>
|
|
|
<link rel="stylesheet" href="../../lib/codemirror.css">
|
|
|
<script src="../../lib/codemirror.js"></script>
|
|
|
<script src="commonlisp.js"></script>
|
|
|
<style>.CodeMirror {background: #f8f8f8;}</style>
|
|
|
<link rel="stylesheet" href="../../doc/docs.css">
|
|
|
</head>
|
|
|
<body>
|
|
|
<h1>CodeMirror: Common Lisp mode</h1>
|
|
|
<form><textarea id="code" name="code">(in-package :cl-postgres)
|
|
|
|
|
|
;; These are used to synthesize reader and writer names for integer
|
|
|
;; reading/writing functions when the amount of bytes and the
|
|
|
;; signedness is known. Both the macro that creates the functions and
|
|
|
;; some macros that use them create names this way.
|
|
|
(eval-when (:compile-toplevel :load-toplevel :execute)
|
|
|
(defun integer-reader-name (bytes signed)
|
|
|
(intern (with-standard-io-syntax
|
|
|
(format nil "~a~a~a~a" '#:read- (if signed "" '#:u) '#:int bytes))))
|
|
|
(defun integer-writer-name (bytes signed)
|
|
|
(intern (with-standard-io-syntax
|
|
|
(format nil "~a~a~a~a" '#:write- (if signed "" '#:u) '#:int bytes)))))
|
|
|
|
|
|
(defmacro integer-reader (bytes)
|
|
|
"Create a function to read integers from a binary stream."
|
|
|
(let ((bits (* bytes 8)))
|
|
|
(labels ((return-form (signed)
|
|
|
(if signed
|
|
|
`(if (logbitp ,(1- bits) result)
|
|
|
(dpb result (byte ,(1- bits) 0) -1)
|
|
|
result)
|
|
|
`result))
|
|
|
(generate-reader (signed)
|
|
|
`(defun ,(integer-reader-name bytes signed) (socket)
|
|
|
(declare (type stream socket)
|
|
|
#.*optimize*)
|
|
|
,(if (= bytes 1)
|
|
|
`(let ((result (the (unsigned-byte 8) (read-byte socket))))
|
|
|
(declare (type (unsigned-byte 8) result))
|
|
|
,(return-form signed))
|
|
|
`(let ((result 0))
|
|
|
(declare (type (unsigned-byte ,bits) result))
|
|
|
,@(loop :for byte :from (1- bytes) :downto 0
|
|
|
:collect `(setf (ldb (byte 8 ,(* 8 byte)) result)
|
|
|
(the (unsigned-byte 8) (read-byte socket))))
|
|
|
,(return-form signed))))))
|
|
|
`(progn
|
|
|
;; This causes weird errors on SBCL in some circumstances. Disabled for now.
|
|
|
;; (declaim (inline ,(integer-reader-name bytes t)
|
|
|
;; ,(integer-reader-name bytes nil)))
|
|
|
(declaim (ftype (function (t) (signed-byte ,bits))
|
|
|
,(integer-reader-name bytes t)))
|
|
|
,(generate-reader t)
|
|
|
(declaim (ftype (function (t) (unsigned-byte ,bits))
|
|
|
,(integer-reader-name bytes nil)))
|
|
|
,(generate-reader nil)))))
|
|
|
|
|
|
(defmacro integer-writer (bytes)
|
|
|
"Create a function to write integers to a binary stream."
|
|
|
(let ((bits (* 8 bytes)))
|
|
|
`(progn
|
|
|
(declaim (inline ,(integer-writer-name bytes t)
|
|
|
,(integer-writer-name bytes nil)))
|
|
|
(defun ,(integer-writer-name bytes nil) (socket value)
|
|
|
(declare (type stream socket)
|
|
|
(type (unsigned-byte ,bits) value)
|
|
|
#.*optimize*)
|
|
|
,@(if (= bytes 1)
|
|
|
`((write-byte value socket))
|
|
|
(loop :for byte :from (1- bytes) :downto 0
|
|
|
:collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)
|
|
|
socket)))
|
|
|
(values))
|
|
|
(defun ,(integer-writer-name bytes t) (socket value)
|
|
|
(declare (type stream socket)
|
|
|
(type (signed-byte ,bits) value)
|
|
|
#.*optimize*)
|
|
|
,@(if (= bytes 1)
|
|
|
`((write-byte (ldb (byte 8 0) value) socket))
|
|
|
(loop :for byte :from (1- bytes) :downto 0
|
|
|
:collect `(write-byte (ldb (byte 8 ,(* byte 8)) value)
|
|
|
socket)))
|
|
|
(values)))))
|
|
|
|
|
|
;; All the instances of the above that we need.
|
|
|
|
|
|
(integer-reader 1)
|
|
|
(integer-reader 2)
|
|
|
(integer-reader 4)
|
|
|
(integer-reader 8)
|
|
|
|
|
|
(integer-writer 1)
|
|
|
(integer-writer 2)
|
|
|
(integer-writer 4)
|
|
|
|
|
|
(defun write-bytes (socket bytes)
|
|
|
"Write a byte-array to a stream."
|
|
|
(declare (type stream socket)
|
|
|
(type (simple-array (unsigned-byte 8)) bytes)
|
|
|
#.*optimize*)
|
|
|
(write-sequence bytes socket))
|
|
|
|
|
|
(defun write-str (socket string)
|
|
|
"Write a null-terminated string to a stream \(encoding it when UTF-8
|
|
|
support is enabled.)."
|
|
|
(declare (type stream socket)
|
|
|
(type string string)
|
|
|
#.*optimize*)
|
|
|
(enc-write-string string socket)
|
|
|
(write-uint1 socket 0))
|
|
|
|
|
|
(declaim (ftype (function (t unsigned-byte)
|
|
|
(simple-array (unsigned-byte 8) (*)))
|
|
|
read-bytes))
|
|
|
(defun read-bytes (socket length)
|
|
|
"Read a byte array of the given length from a stream."
|
|
|
(declare (type stream socket)
|
|
|
(type fixnum length)
|
|
|
#.*optimize*)
|
|
|
(let ((result (make-array length :element-type '(unsigned-byte 8))))
|
|
|
(read-sequence result socket)
|
|
|
result))
|
|
|
|
|
|
(declaim (ftype (function (t) string) read-str))
|
|
|
(defun read-str (socket)
|
|
|
"Read a null-terminated string from a stream. Takes care of encoding
|
|
|
when UTF-8 support is enabled."
|
|
|
(declare (type stream socket)
|
|
|
#.*optimize*)
|
|
|
(enc-read-string socket :null-terminated t))
|
|
|
|
|
|
(defun skip-bytes (socket length)
|
|
|
"Skip a given number of bytes in a binary stream."
|
|
|
(declare (type stream socket)
|
|
|
(type (unsigned-byte 32) length)
|
|
|
#.*optimize*)
|
|
|
(dotimes (i length)
|
|
|
(read-byte socket)))
|
|
|
|
|
|
(defun skip-str (socket)
|
|
|
"Skip a null-terminated string."
|
|
|
(declare (type stream socket)
|
|
|
#.*optimize*)
|
|
|
(loop :for char :of-type fixnum = (read-byte socket)
|
|
|
:until (zerop char)))
|
|
|
|
|
|
(defun ensure-socket-is-closed (socket &key abort)
|
|
|
(when (open-stream-p socket)
|
|
|
(handler-case
|
|
|
(close socket :abort abort)
|
|
|
(error (error)
|
|
|
(warn "Ignoring the error which happened while trying to close PostgreSQL socket: ~A" error)))))
|
|
|
</textarea></form>
|
|
|
<script>
|
|
|
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {lineNumbers: true});
|
|
|
</script>
|
|
|
|
|
|
<p><strong>MIME types defined:</strong> <code>text/x-common-lisp</code>.</p>
|
|
|
|
|
|
</body>
|
|
|
</html>
|
|
|
|
