clojure 1.0.0

data/src/clj/clojure/zip.clj

@@ -0,0 +1,278 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+;functional hierarchical zipper, with navigation, editing and enumeration
+;see Huet
+
+(ns clojure.zip
+    (:refer-clojure :exclude (replace remove next)))
+
+(defn zipper
+  "Creates a new zipper structure. 
+
+  branch? is a fn that, given a node, returns true if can have
+  children, even if it currently doesn't.
+
+  children is a fn that, given a branch node, returns a seq of its
+  children.
+
+  make-node is a fn that, given an existing node and a seq of
+  children, returns a new branch node with the supplied children.
+  root is the root node."  
+  [branch? children make-node root]
+    #^{:zip/branch? branch? :zip/children children :zip/make-node make-node} 
+    [root nil])
+
+(defn seq-zip
+  "Returns a zipper for nested sequences, given a root sequence"
+  [root]
+    (zipper seq? identity (fn [node children] children) root))
+
+(defn vector-zip
+  "Returns a zipper for nested vectors, given a root vector"
+  [root]
+    (zipper vector? seq (fn [node children] (apply vector children)) root))
+
+(defn xml-zip
+  "Returns a zipper for xml elements (as from xml/parse),
+  given a root element"
+  [root]
+    (zipper (complement string?) 
+            (comp seq :content)
+            (fn [node children]
+              (assoc node :content (and children (apply vector children))))
+            root))
+
+(defn node
+  "Returns the node at loc"
+  [loc] (loc 0))
+
+(defn branch?
+  "Returns true if the node at loc is a branch"
+  [loc]
+    ((:zip/branch? ^loc) (node loc)))
+
+(defn children
+  "Returns a seq of the children of node at loc, which must be a branch"
+  [loc]
+    ((:zip/children ^loc) (node loc)))
+
+(defn make-node
+  "Returns a new branch node, given an existing node and new
+  children. The loc is only used to supply the constructor."
+  [loc node children]
+    ((:zip/make-node ^loc) node children))
+
+(defn path
+  "Returns a seq of nodes leading to this loc"
+  [loc]
+    (:pnodes (loc 1)))
+
+(defn lefts
+  "Returns a seq of the left siblings of this loc"
+  [loc]
+    (seq (:l (loc 1))))
+
+(defn rights
+  "Returns a seq of the right siblings of this loc"
+  [loc]
+    (:r (loc 1)))
+
+
+(defn down
+  "Returns the loc of the leftmost child of the node at this loc, or
+  nil if no children"
+  [loc]
+    (let [[node path] loc
+          [c & cnext :as cs] (children loc)]
+      (when cs
+        (with-meta [c {:l [] 
+                       :pnodes (if path (conj (:pnodes path) node) [node]) 
+                       :ppath path 
+                       :r cnext}] ^loc))))
+
+(defn up
+  "Returns the loc of the parent of the node at this loc, or nil if at
+  the top"
+  [loc]
+    (let [[node {l :l, ppath :ppath, pnodes :pnodes r :r, changed? :changed?, :as path}] loc]
+      (when pnodes
+        (let [pnode (peek pnodes)]
+          (with-meta (if changed?
+                       [(make-node loc pnode (concat l (cons node r))) 
+                        (and ppath (assoc ppath :changed? true))]
+                       [pnode ppath])
+                     ^loc)))))
+
+(defn root
+  "zips all the way up and returns the root node, reflecting any
+ changes."
+  [loc]
+    (if (= :end (loc 1))
+      (node loc)
+      (let [p (up loc)]
+        (if p
+          (recur p)
+          (node loc)))))
+
+(defn right
+  "Returns the loc of the right sibling of the node at this loc, or nil"
+  [loc]
+    (let [[node {l :l  [r & rnext :as rs] :r :as path}] loc]
+      (when (and path rs)
+        (with-meta [r (assoc path :l (conj l node) :r rnext)] ^loc))))
+
+(defn rightmost
+  "Returns the loc of the rightmost sibling of the node at this loc, or self"
+  [loc]
+    (let [[node {l :l r :r :as path}] loc]
+      (if (and path r)
+        (with-meta [(last r) (assoc path :l (apply conj l node (butlast r)) :r nil)] ^loc)
+        loc)))
+
+(defn left
+  "Returns the loc of the left sibling of the node at this loc, or nil"
+  [loc]
+    (let [[node {l :l r :r :as path}] loc]
+      (when (and path (seq l))
+        (with-meta [(peek l) (assoc path :l (pop l) :r (cons node r))] ^loc))))
+
+(defn leftmost
+  "Returns the loc of the leftmost sibling of the node at this loc, or self"
+  [loc]
+    (let [[node {l :l r :r :as path}] loc]
+      (if (and path (seq l))
+        (with-meta [(first l) (assoc path :l [] :r (concat (rest l) [node] r))] ^loc)
+        loc)))
+
+(defn insert-left
+  "Inserts the item as the left sibling of the node at this loc,
+ without moving"
+  [loc item]
+    (let [[node {l :l :as path}] loc]
+      (if (nil? path)
+        (throw (new Exception "Insert at top"))
+        (with-meta [node (assoc path :l (conj l item) :changed? true)] ^loc))))
+
+(defn insert-right
+  "Inserts the item as the right sibling of the node at this loc,
+  without moving"
+  [loc item]
+    (let [[node {r :r :as path}] loc]
+      (if (nil? path)
+        (throw (new Exception "Insert at top"))
+        (with-meta [node (assoc path :r (cons item r) :changed? true)] ^loc))))
+
+(defn replace
+  "Replaces the node at this loc, without moving"
+  [loc node]
+    (let [[_ path] loc]
+      (with-meta [node (assoc path :changed? true)] ^loc)))
+
+(defn edit
+  "Replaces the node at this loc with the value of (f node args)"
+  [loc f & args]
+    (replace loc (apply f (node loc) args)))
+
+(defn insert-child
+  "Inserts the item as the leftmost child of the node at this loc,
+  without moving"
+  [loc item]
+    (replace loc (make-node loc (node loc) (cons item (children loc)))))
+
+(defn append-child
+  "Inserts the item as the rightmost child of the node at this loc,
+  without moving"
+  [loc item]
+    (replace loc (make-node loc (node loc) (concat (children loc) [item]))))
+
+(defn next
+  "Moves to the next loc in the hierarchy, depth-first. When reaching
+  the end, returns a distinguished loc detectable via end?. If already
+  at the end, stays there."
+  [loc]
+    (if (= :end (loc 1))
+      loc
+      (or 
+       (and (branch? loc) (down loc))
+       (right loc)
+       (loop [p loc]
+         (if (up p)
+           (or (right (up p)) (recur (up p)))
+           [(node p) :end])))))
+
+(defn prev
+  "Moves to the previous loc in the hierarchy, depth-first. If already
+  at the root, returns nil."
+  [loc]
+    (if-let [lloc (left loc)]
+      (loop [loc lloc]
+        (if-let [child (and (branch? loc) (down loc))]
+          (recur (rightmost child))
+          loc))
+      (up loc)))
+
+(defn end?
+  "Returns true if loc represents the end of a depth-first walk"
+  [loc]
+    (= :end (loc 1)))
+
+(defn remove
+  "Removes the node at loc, returning the loc that would have preceded
+  it in a depth-first walk."
+  [loc]
+    (let [[node {l :l, ppath :ppath, pnodes :pnodes, rs :r, :as path}] loc]
+      (if (nil? path)
+        (throw (new Exception "Remove at top"))
+        (if (pos? (count l))
+          (loop [loc (with-meta [(peek l) (assoc path :l (pop l) :changed? true)] ^loc)]
+            (if-let [child (and (branch? loc) (down loc))]
+              (recur (rightmost child))
+              loc))
+          (with-meta [(make-node loc (peek pnodes) rs) 
+                      (and ppath (assoc ppath :changed? true))]
+                     ^loc)))))
+  
+(comment
+
+(load-file "/Users/rich/dev/clojure/src/zip.clj")
+(refer 'zip)
+(def data '[[a * b] + [c * d]])
+(def dz (vector-zip data))
+
+(right (down (right (right (down dz)))))
+(lefts (right (down (right (right (down dz))))))
+(rights (right (down (right (right (down dz))))))
+(up (up (right (down (right (right (down dz)))))))
+(path (right (down (right (right (down dz))))))
+
+(-> dz down right right down right)
+(-> dz down right right down right (replace '/) root)
+(-> dz next next (edit str) next next next (replace '/) root)
+(-> dz next next next next next next next next next remove root)
+(-> dz next next next next next next next next next remove (insert-right 'e) root)
+(-> dz next next next next next next next next next remove up (append-child 'e) root)
+
+(end? (-> dz next next next next next next next next next remove next))
+
+(-> dz next remove next remove root)
+
+(loop [loc dz]
+  (if (end? loc)
+    (root loc)
+    (recur (next (if (= '* (node loc)) 
+                   (replace loc '/)
+                   loc)))))
+
+(loop [loc dz]
+  (if (end? loc)
+    (root loc)
+    (recur (next (if (= '* (node loc)) 
+                   (remove loc)
+                   loc)))))
+)

data/src/jvm/clojure/asm/AnnotationVisitor.java

@@ -0,0 +1,97 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2005 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package clojure.asm;
+
+/**
+ * A visitor to visit a Java annotation. The methods of this interface must be
+ * called in the following order: (<tt>visit<tt> | <tt>visitEnum<tt> |
+ * <tt>visitAnnotation<tt> | <tt>visitArray<tt>)* <tt>visitEnd<tt>.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+public interface AnnotationVisitor{
+
+/**
+ * Visits a primitive value of the annotation.
+ *
+ * @param name  the value name.
+ * @param value the actual value, whose type must be {@link Byte},
+ *              {@link Boolean}, {@link Character}, {@link Short},
+ *              {@link Integer}, {@link Long}, {@link Float}, {@link Double},
+ *              {@link String} or {@link Type}. This value can also be an array
+ *              of byte, boolean, short, char, int, long, float or double values
+ *              (this is equivalent to using {@link #visitArray visitArray} and
+ *              visiting each array element in turn, but is more convenient).
+ */
+void visit(String name, Object value);
+
+/**
+ * Visits an enumeration value of the annotation.
+ *
+ * @param name  the value name.
+ * @param desc  the class descriptor of the enumeration class.
+ * @param value the actual enumeration value.
+ */
+void visitEnum(String name, String desc, String value);
+
+/**
+ * Visits a nested annotation value of the annotation.
+ *
+ * @param name the value name.
+ * @param desc the class descriptor of the nested annotation class.
+ * @return a visitor to visit the actual nested annotation value, or
+ *         <tt>null</tt> if this visitor is not interested in visiting
+ *         this nested annotation. <i>The nested annotation value must be
+ *         fully visited before calling other methods on this annotation
+ *         visitor</i>.
+ */
+AnnotationVisitor visitAnnotation(String name, String desc);
+
+/**
+ * Visits an array value of the annotation. Note that arrays of primitive
+ * types (such as byte, boolean, short, char, int, long, float or double)
+ * can be passed as value to {@link #visit visit}. This is what
+ * {@link ClassReader} does.
+ *
+ * @param name the value name.
+ * @return a visitor to visit the actual array value elements, or
+ *         <tt>null</tt> if this visitor is not interested in visiting
+ *         these values. The 'name' parameters passed to the methods of this
+ *         visitor are ignored. <i>All the array values must be visited
+ *         before calling other methods on this annotation visitor</i>.
+ */
+AnnotationVisitor visitArray(String name);
+
+/**
+ * Visits the end of the annotation.
+ */
+void visitEnd();
+}

data/src/jvm/clojure/asm/AnnotationWriter.java

@@ -0,0 +1,357 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2005 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package clojure.asm;
+
+/**
+ * An {@link AnnotationVisitor} that generates annotations in bytecode form.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+final class AnnotationWriter implements AnnotationVisitor{
+
+/**
+ * The class writer to which this annotation must be added.
+ */
+private final ClassWriter cw;
+
+/**
+ * The number of values in this annotation.
+ */
+private int size;
+
+/**
+ * <tt>true<tt> if values are named, <tt>false</tt> otherwise. Annotation
+ * writers used for annotation default and annotation arrays use unnamed
+ * values.
+ */
+private final boolean named;
+
+/**
+ * The annotation values in bytecode form. This byte vector only contains
+ * the values themselves, i.e. the number of values must be stored as a
+ * unsigned short just before these bytes.
+ */
+private final ByteVector bv;
+
+/**
+ * The byte vector to be used to store the number of values of this
+ * annotation. See {@link #bv}.
+ */
+private final ByteVector parent;
+
+/**
+ * Where the number of values of this annotation must be stored in
+ * {@link #parent}.
+ */
+private final int offset;
+
+/**
+ * Next annotation writer. This field is used to store annotation lists.
+ */
+AnnotationWriter next;
+
+/**
+ * Previous annotation writer. This field is used to store annotation lists.
+ */
+AnnotationWriter prev;
+
+// ------------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------------
+
+/**
+ * Constructs a new {@link AnnotationWriter}.
+ *
+ * @param cw     the class writer to which this annotation must be added.
+ * @param named  <tt>true<tt> if values are named, <tt>false</tt> otherwise.
+ * @param bv     where the annotation values must be stored.
+ * @param parent where the number of annotation values must be stored.
+ * @param offset where in <tt>parent</tt> the number of annotation values must
+ *               be stored.
+ */
+AnnotationWriter(
+		final ClassWriter cw,
+		final boolean named,
+		final ByteVector bv,
+		final ByteVector parent,
+		final int offset){
+	this.cw = cw;
+	this.named = named;
+	this.bv = bv;
+	this.parent = parent;
+	this.offset = offset;
+}
+
+// ------------------------------------------------------------------------
+// Implementation of the AnnotationVisitor interface
+// ------------------------------------------------------------------------
+
+public void visit(final String name, final Object value){
+	++size;
+	if(named)
+		{
+		bv.putShort(cw.newUTF8(name));
+		}
+	if(value instanceof String)
+		{
+		bv.put12('s', cw.newUTF8((String) value));
+		}
+	else if(value instanceof Byte)
+		{
+		bv.put12('B', cw.newInteger(((Byte) value).byteValue()).index);
+		}
+	else if(value instanceof Boolean)
+		{
+		int v = ((Boolean) value).booleanValue() ? 1 : 0;
+		bv.put12('Z', cw.newInteger(v).index);
+		}
+	else if(value instanceof Character)
+		{
+		bv.put12('C', cw.newInteger(((Character) value).charValue()).index);
+		}
+	else if(value instanceof Short)
+		{
+		bv.put12('S', cw.newInteger(((Short) value).shortValue()).index);
+		}
+	else if(value instanceof Type)
+		{
+		bv.put12('c', cw.newUTF8(((Type) value).getDescriptor()));
+		}
+	else if(value instanceof byte[])
+		{
+		byte[] v = (byte[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('B', cw.newInteger(v[i]).index);
+			}
+		}
+	else if(value instanceof boolean[])
+		{
+		boolean[] v = (boolean[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('Z', cw.newInteger(v[i] ? 1 : 0).index);
+			}
+		}
+	else if(value instanceof short[])
+		{
+		short[] v = (short[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('S', cw.newInteger(v[i]).index);
+			}
+		}
+	else if(value instanceof char[])
+		{
+		char[] v = (char[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('C', cw.newInteger(v[i]).index);
+			}
+		}
+	else if(value instanceof int[])
+		{
+		int[] v = (int[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('I', cw.newInteger(v[i]).index);
+			}
+		}
+	else if(value instanceof long[])
+		{
+		long[] v = (long[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('J', cw.newLong(v[i]).index);
+			}
+		}
+	else if(value instanceof float[])
+		{
+		float[] v = (float[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('F', cw.newFloat(v[i]).index);
+			}
+		}
+	else if(value instanceof double[])
+		{
+		double[] v = (double[]) value;
+		bv.put12('[', v.length);
+		for(int i = 0; i < v.length; i++)
+			{
+			bv.put12('D', cw.newDouble(v[i]).index);
+			}
+		}
+	else
+		{
+		Item i = cw.newConstItem(value);
+		bv.put12(".s.IFJDCS".charAt(i.type), i.index);
+		}
+}
+
+public void visitEnum(
+		final String name,
+		final String desc,
+		final String value){
+	++size;
+	if(named)
+		{
+		bv.putShort(cw.newUTF8(name));
+		}
+	bv.put12('e', cw.newUTF8(desc)).putShort(cw.newUTF8(value));
+}
+
+public AnnotationVisitor visitAnnotation(
+		final String name,
+		final String desc){
+	++size;
+	if(named)
+		{
+		bv.putShort(cw.newUTF8(name));
+		}
+	// write tag and type, and reserve space for values count
+	bv.put12('@', cw.newUTF8(desc)).putShort(0);
+	return new AnnotationWriter(cw, true, bv, bv, bv.length - 2);
+}
+
+public AnnotationVisitor visitArray(final String name){
+	++size;
+	if(named)
+		{
+		bv.putShort(cw.newUTF8(name));
+		}
+	// write tag, and reserve space for array size
+	bv.put12('[', 0);
+	return new AnnotationWriter(cw, false, bv, bv, bv.length - 2);
+}
+
+public void visitEnd(){
+	if(parent != null)
+		{
+		byte[] data = parent.data;
+		data[offset] = (byte) (size >>> 8);
+		data[offset + 1] = (byte) size;
+		}
+}
+
+// ------------------------------------------------------------------------
+// Utility methods
+// ------------------------------------------------------------------------
+
+/**
+ * Returns the size of this annotation writer list.
+ *
+ * @return the size of this annotation writer list.
+ */
+int getSize(){
+	int size = 0;
+	AnnotationWriter aw = this;
+	while(aw != null)
+		{
+		size += aw.bv.length;
+		aw = aw.next;
+		}
+	return size;
+}
+
+/**
+ * Puts the annotations of this annotation writer list into the given byte
+ * vector.
+ *
+ * @param out where the annotations must be put.
+ */
+void put(final ByteVector out){
+	int n = 0;
+	int size = 2;
+	AnnotationWriter aw = this;
+	AnnotationWriter last = null;
+	while(aw != null)
+		{
+		++n;
+		size += aw.bv.length;
+		aw.visitEnd(); // in case user forgot to call visitEnd
+		aw.prev = last;
+		last = aw;
+		aw = aw.next;
+		}
+	out.putInt(size);
+	out.putShort(n);
+	aw = last;
+	while(aw != null)
+		{
+		out.putByteArray(aw.bv.data, 0, aw.bv.length);
+		aw = aw.prev;
+		}
+}
+
+/**
+ * Puts the given annotation lists into the given byte vector.
+ *
+ * @param panns an array of annotation writer lists.
+ * @param out   where the annotations must be put.
+ */
+static void put(final AnnotationWriter[] panns, final ByteVector out){
+	int size = 1 + 2 * panns.length;
+	for(int i = 0; i < panns.length; ++i)
+		{
+		size += panns[i] == null ? 0 : panns[i].getSize();
+		}
+	out.putInt(size).putByte(panns.length);
+	for(int i = 0; i < panns.length; ++i)
+		{
+		AnnotationWriter aw = panns[i];
+		AnnotationWriter last = null;
+		int n = 0;
+		while(aw != null)
+			{
+			++n;
+			aw.visitEnd(); // in case user forgot to call visitEnd
+			aw.prev = last;
+			last = aw;
+			aw = aw.next;
+			}
+		out.putShort(n);
+		aw = last;
+		while(aw != null)
+			{
+			out.putByteArray(aw.bv.data, 0, aw.bv.length);
+			aw = aw.prev;
+			}
+		}
+}
+}