Commit a405fbaa authored by Nathan Froyd's avatar Nathan Froyd
Browse files

make vector stream readers/writers use sequences

parent e283500c

macro-utils.lisp

+2 −2
Original line number Diff line number Diff line
@@ -18,9 +18,9 @@ 
    (intern (format nil "~:[WRITE~;READ~]-~:[U~;S~]B~D/~:[LE~;BE~]"

                    readp signedp bitsize big-endian-p))))



(defun stream-vector-fun-name (bitsize readp signedp big-endian-p)

(defun stream-seq-fun-name (bitsize readp signedp big-endian-p)

  (let ((*package* (find-package :nibbles)))

    (intern (format nil "~:[WRITE~;READ~]-~:[U~;S~]B~D/~:[LE~;BE~]-VECTOR"

    (intern (format nil "~:[WRITE~;READ~]-~:[U~;S~]B~D/~:[LE~;BE~]-SEQUENCE"

		    readp signedp bitsize big-endian-p))))



(defun internalify (s)

package.lisp

+12 −12
Original line number Diff line number Diff line
@@ -13,12 +13,12 @@ 
           #:read-ub32/le #:read-ub32/be #:read-sb32/be #:read-sb32/le

           #:read-ub64/le #:read-ub64/be #:read-sb64/be #:read-sb64/le)

  ;; Stream readers for vectors.

  (:export #:read-ub16/le-vector #:read-ub16/be-vector

	   #:read-sb16/le-vector #:read-sb16/be-vector

	   #:read-ub32/le-vector #:read-ub32/be-vector

	   #:read-sb32/le-vector #:read-sb32/be-vector

	   #:read-ub64/le-vector #:read-ub64/be-vector

	   #:read-sb64/le-vector #:read-sb64/be-vector)

  (:export #:read-ub16/le-sequence #:read-ub16/be-sequence

	   #:read-sb16/le-sequence #:read-sb16/be-sequence

	   #:read-ub32/le-sequence #:read-ub32/be-sequence

	   #:read-sb32/le-sequence #:read-sb32/be-sequence

	   #:read-ub64/le-sequence #:read-ub64/be-sequence

	   #:read-sb64/le-sequence #:read-sb64/be-sequence)

  ;; Non-consing variants akin to READ-SEQUENCE.

  (:export #:read-ub16/le-into-sequence #:read-ub16/be-into-sequence

	   #:read-sb16/le-into-sequence #:read-sb16/be-into-sequence
@@ -31,9 +31,9 @@ 
           #:write-ub32/le #:write-ub32/be #:write-sb32/be #:write-sb32/le

           #:write-ub64/le #:write-ub64/be #:write-sb64/be #:write-sb64/le)

  ;; Stream writers for vectors.

  (:export #:write-ub16/le-vector #:write-ub16/be-vector

	   #:write-sb16/le-vector #:write-sb16/be-vector

	   #:write-ub32/le-vector #:write-ub32/be-vector

	   #:write-sb32/le-vector #:write-sb32/be-vector

	   #:write-ub64/le-vector #:write-ub64/be-vector

	   #:write-sb64/le-vector #:write-sb64/be-vector))
 
  (:export #:write-ub16/le-sequence #:write-ub16/be-sequence

	   #:write-sb16/le-sequence #:write-sb16/be-sequence

	   #:write-ub32/le-sequence #:write-ub32/be-sequence

	   #:write-sb32/le-sequence #:write-sb32/be-sequence

	   #:write-ub64/le-sequence #:write-ub64/be-sequence

	   #:write-sb64/le-sequence #:write-sb64/be-sequence))

streams.lisp

+23 −12
Original line number Diff line number Diff line
@@ -64,19 +64,30 @@ 
        collect `(defun ,name ,byte-arglist

		   (,subfun ,@byte-arglist ,n-bytes #',byte-fun)) into forms

	if readp

	  collect `(defun ,(stream-vector-fun-name bitsize t signedp big-endian-p)

		       (stream n-elements)

		     (let ((vector (make-array n-elements

	  collect `(defun ,(stream-seq-fun-name bitsize t signedp big-endian-p)

		       (result-type stream count)

		     (case result-type

		       (list

			(let ((list (make-list count)))

			  (read-into-list* stream list 0 count

					   ,n-bytes #',byte-fun)))

		       (vector

			(let ((vector (make-array count

						  :element-type ',element-type)))

		       (read-into-vector* stream vector 0 n-elements

					  ,n-bytes #',byte-fun))) into forms

			  (read-into-vector* stream vector 0 count

					     ,n-bytes #',byte-fun))))) into forms

	else

	  collect `(defun ,(stream-vector-fun-name bitsize nil signedp big-endian-p)

		       (vector stream &key (start 0) end)

		     (loop with end = (or end (length vector))

	  collect `(defun ,(stream-seq-fun-name bitsize nil signedp big-endian-p)

		       (seq stream &key (start 0) end)

		     (etypecase seq

		       (list

			(mapc #',name (subseq seq start end))

			seq)

		       (vector

			(loop with end = (or end (length seq))

			      for i from start below end 

			   do (,name (aref vector i) stream)

			   finally (return vector))) into forms

			      do (,name (aref seq i) stream)

			      finally (return seq))))) into forms

	if readp

	  collect `(defun ,(intern (format nil "READ-~:[U~;S~]B~D/~:[LE~;BE~]-INTO-SEQUENCE"

					   signedp bitsize big-endian-p))

tests.lisp

+13 −13
Original line number Diff line number Diff line
@@ -279,7 +279,7 @@ 
			    :element-type '(unsigned-byte 8))

      (let* ((n-values (truncate (length file-contents)

				 (truncate bitsize 8)))

	     (read-values (funcall reader stream n-values)))

	     (read-values (funcall reader 'vector stream n-values)))

	(if (mismatch read-values expected-values)

	    :bad

	    :ok)))))
@@ -333,51 +333,51 @@ 
  :ok)



(rtest:deftest :read-ub16/be-vector

  (read-vector-test 'nibbles:read-ub16/be-vector 16 nil t)

  (read-vector-test 'nibbles:read-ub16/be-sequence 16 nil t)

  :ok)



(rtest:deftest :read-sb16/be-vector

  (read-vector-test 'nibbles:read-sb16/be-vector 16 t t)

  (read-vector-test 'nibbles:read-sb16/be-sequence 16 t t)

  :ok)



(rtest:deftest :read-ub32/be-vector

  (read-vector-test 'nibbles:read-ub32/be-vector 32 nil t)

  (read-vector-test 'nibbles:read-ub32/be-sequence 32 nil t)

  :ok)



(rtest:deftest :read-sb32/be-vector

  (read-vector-test 'nibbles:read-sb32/be-vector 32 t t)

  (read-vector-test 'nibbles:read-sb32/be-sequence 32 t t)

  :ok)



(rtest:deftest :read-ub64/be-vector

  (read-vector-test 'nibbles:read-ub64/be-vector 64 nil t)

  (read-vector-test 'nibbles:read-ub64/be-sequence 64 nil t)

  :ok)



(rtest:deftest :read-sb64/be-vector

  (read-vector-test 'nibbles:read-sb64/be-vector 64 t t)

  (read-vector-test 'nibbles:read-sb64/be-sequence 64 t t)

  :ok)



(rtest:deftest :read-ub16/le-vector

  (read-vector-test 'nibbles:read-ub16/le-vector 16 nil nil)

  (read-vector-test 'nibbles:read-ub16/le-sequence 16 nil nil)

  :ok)



(rtest:deftest :read-sb16/le-vector

  (read-vector-test 'nibbles:read-sb16/le-vector 16 t nil)

  (read-vector-test 'nibbles:read-sb16/le-sequence 16 t nil)

  :ok)



(rtest:deftest :read-ub32/le-vector

  (read-vector-test 'nibbles:read-ub32/le-vector 32 nil nil)

  (read-vector-test 'nibbles:read-ub32/le-sequence 32 nil nil)

  :ok)



(rtest:deftest :read-sb32/le-vector

  (read-vector-test 'nibbles:read-sb32/le-vector 32 t nil)

  (read-vector-test 'nibbles:read-sb32/le-sequence 32 t nil)

  :ok)



(rtest:deftest :read-ub64/le-vector

  (read-vector-test 'nibbles:read-ub64/le-vector 64 nil nil)

  (read-vector-test 'nibbles:read-ub64/le-sequence 64 nil nil)

  :ok)



(rtest:deftest :read-sb64/le-vector

  (read-vector-test 'nibbles:read-sb64/le-vector 64 t nil)

  (read-vector-test 'nibbles:read-sb64/le-sequence 64 t nil)

  :ok)



;;; Stream writing tests