Merge pull request #4 from scymtym/master

(cl:defpackage :nibbles

  (:use :cl)

  ;; Basic types and constructors.

  (:export #:octet #:index

           #:octet-vector #:simple-octet-vector

           #:make-octet-vector)

  ;; Basic octet vector accessors.

  (:export #:ub16ref/le #:ub16ref/be #:sb16ref/le #:sb16ref/be

           #:ub32ref/le #:ub32ref/be #:sb32ref/le #:sb32ref/be

          (t (values 0 nil))))))

(defun generate-random-octet-vector (n-octets)

  (loop with v = (make-array n-octets :element-type '(unsigned-byte 8))

  (loop with v = (nibbles:make-octet-vector n-octets)

        for i from 0 below n-octets

        do (setf (aref v i) (random 256))

        finally (return v)))

(defun read-file-as-octets (pathname)

  (with-open-file (stream pathname :direction :input

                          :element-type '(unsigned-byte 8))

    (let ((v (make-array (file-length stream) :element-type '(unsigned-byte 8))))

    (let ((v (nibbles:make-octet-vector (file-length stream))))

      (read-sequence v stream)

      v)))

(cl:in-package :nibbles)

(deftype index () '(mod #.array-dimension-limit))

(deftype octet ()

  '(unsigned-byte 8))

(deftype index ()

  '(mod #.array-dimension-limit))

;;; Type `octet-vector' and constructors

;;

(deftype octet-vector (&optional (length '*))

  `(array (unsigned-byte 8) (,length)))

  `(array octet (,length)))

(declaim (ftype (function (index

                           &key

                           (:initial-element octet))

                          octet-vector)

                make-octet-vector)

         (inline make-octet-vector))

(defun make-octet-vector (count

                          &key

                          (initial-element 0))

  "Make and return an `octet-vector' with COUNT elements.

If supplied, INITIAL-ELEMENT is used to populate the vector. The value

of INITIAL-ELEMENT has to of type `octet'. "

  (make-array count

              :element-type    'octet

              :initial-element initial-element))

(declaim (ftype (function (&rest octet) octet-vector) octet-vector)

         (inline octet-vector))

(defun octet-vector (&rest args)

  "Make and return an `octet-vector' containing the elements ARGS.

ARGS have to be of type `octet'."

  (make-array (length args)

              :element-type     'octet

              :initial-contents args

              :adjustable       nil

              :fill-pointer     nil))

;;; Type `simple-octet-vector'

;;

(deftype simple-octet-vector (&optional (length '*))

  #+(or sbcl cmu) `(simple-array (unsigned-byte 8) (,length))

  #-(or sbcl cmu) `(array (unsigned-byte 8) (,length)))

  #+(or sbcl cmu) `(simple-array octet (,length))

  #-(or sbcl cmu) `(array octet (,length)))