Initial buffer reuse encoding commit

1 files changed, 22 insertions, 23 deletions

diff --git a/src/eris.lisp b/src/eris.lisp
index 91200a1..d86934b 100644
--- a/src/eris.lisp
+++ b/src/eris.lisp
@@ -166,38 +166,37 @@ versioning bytes are not supported by eris-cl."
 
 (defvar *output-hashmap* nil)
 
-(defmacro output-block (ref-vector &rest expr)
+(defmacro output-block (ref-vector)
   `(let ((reference (compute-reference block)))
      (if hash-output
          (unless (gethash reference *output-hashmap*)
            (let ((rk (encrypt-block block secret reference)))
              (vector-push-extend rk ,ref-vector)
-             (funcall output-function block (reference rk))
-             (setf (gethash reference *output-hashmap*) t)))
+             (setf (gethash reference *output-hashmap*) t)
+             (funcall output-function block (reference rk))))
          (let ((rk (encrypt-block block secret reference)))
            (vector-push-extend rk ,ref-vector)
-           (funcall output-function block (reference rk))))
-     ,@expr))
+           (funcall output-function block (reference rk))))))
 
-(defmacro output-internal-block (ref-vector nonce &rest expr)
+(defmacro output-internal-block (ref-vector nonce)
   `(let ((reference (compute-reference block)))
      (if hash-output
          (unless (gethash reference *output-hashmap*)
            (let ((rk (encrypt-internal-block block reference ,nonce)))
              (vector-push-extend rk ,ref-vector)
-             (funcall output-function block (reference rk))
-             (setf (gethash reference *output-hashmap*) t)))
+             (setf (gethash reference *output-hashmap*) t)
+             (funcall output-function block (reference rk))))
          (let ((rk (encrypt-internal-block block reference ,nonce)))
            (vector-push-extend rk ,ref-vector)
-           (funcall output-function block (reference rk))))
-     ,@expr))
+           (funcall output-function block (reference rk))))))
 
 (defgeneric eris-encode (input block-size output-function &key secret hash-output)
   (:documentation
    "Encode an INPUT into BLOCK-SIZE (32kib or 1kib) blocks, that are output using
 the function OUTPUT-FUNCTION. This function wil be called with two arguments: an
-encoded block and a 32-byte reference octet vector. Returns a read-capability
-object.
+encoded block and a 32-byte reference octet vector, and it MUST return
+a (SIMPLE-ARRAY (UNSIGNED-BYTE 8)) of equal size to the one given, which will be
+destructively modified. Returns a read-capability object.
 
 An optional 32-byte secret can be passed for additional encryption using the
 SECRET keyword argument.
@@ -215,11 +214,11 @@ guarantee that a reference is only output once."))
   (let ((reference-vector (make-array 16 :adjustable t :fill-pointer 0))
         (*output-hashmap* (if hash-output (make-hash-table :test #'equalp) nil)))
     (loop for block = (make-array block-size :element-type 'octet :initial-element 0)
+           ;; then (output-block reference-vector)
           for i = 0 then (incf i)
           until (= (length input) (* i block-size)) 
-          do (progn
-               (replace block input :start2 (* i block-size))
-               (output-block reference-vector nil)))
+          do (progn (replace block input :start2 (* i block-size))
+                    (setf block (output-block reference-vector))))
     (eris-create-tree reference-vector block-size output-function :hash-output hash-output)))
 
 (defmethod eris-encode ((input stream) block-size output-function &key (secret null-secret) hash-output)
@@ -230,11 +229,12 @@ guarantee that a reference is only output once."))
   (let ((reference-vector (make-array 16 :adjustable t :fill-pointer 0))
         (*output-hashmap* (if hash-output (make-hash-table :test #'equalp) nil)))
     (loop for block = (make-array block-size :element-type 'octet :initial-element 0)
+            ;;then (output-block reference-vector)
           for bytes-read = (read-sequence block input)
           for i = 0 then (incf i)
           if (< bytes-read block-size)
             do (setf (aref block bytes-read) #x80)
-          do (output-block reference-vector nil)
+          do (setf block (output-block reference-vector))
           until (< bytes-read block-size))
     (eris-create-tree reference-vector block-size output-function :hash-output hash-output)))
 
@@ -246,10 +246,10 @@ guarantee that a reference is only output once."))
         with reference-vector-l = (make-array 16 :adjustable t :fill-pointer 0)
         for nonce = (make-nonce (1+ level))
         when (eql (length reference-vector) 1)
-        do (return (make-instance 'read-capability
-                                  :reference-pair (aref reference-vector 0)
-                                  :level level
-                                  :block-size block-size)) 
+          do (return (make-instance 'read-capability
+                                    :reference-pair (aref reference-vector 0)
+                                    :level level
+                                    :block-size block-size)) 
         do (progn
              (incf level)
              ;; loop across the key-reference vector and build the tree
@@ -257,9 +257,8 @@ guarantee that a reference is only output once."))
                    for rk across reference-vector
                    with i = 0
                    when (eql i block-keys)
-                     do (output-internal-block reference-vector-l nonce
-                                               (setf block (make-array block-size :element-type 'octet :initial-element 0)
-                                                     i 0))
+                     do (setf block (output-internal-block reference-vector-l nonce)
+                              i 0)
                    do (progn (reference-pair-to-octets rk block (* 64 i))
                              (incf i))
                    finally (unless (zerop i)