--- /dev/null
+<!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>
git://git.onelab.eu / myslice.git / blobdiff