wirehelpers

Makefile

@@ -1,12 +1,14 @@
 CXX=g++ -std=c++11
 
 CAPNP_SOURCES=\
+	src/capnp/FieldSize.java\
 	src/capnp/FromStructReader.java\
 	src/capnp/ListPointer.java\
 	src/capnp/ListReader.java\
 	src/capnp/PointerReader.java\
 	src/capnp/SegmentReader.java\
 	src/capnp/StructReader.java\
+	src/capnp/StructPointer.java\
 	src/capnp/StructList.java\
 	src/capnp/Text.java\
 	src/capnp/WireHelpers.java\

src/capnp/FieldSize.java

@@ -0,0 +1,12 @@
+package capnp;
+
+public class FieldSize {
+    public static final byte VOID = 0;
+    public static final byte BIT = 1;
+    public static final byte BYTE = 2;
+    public static final byte TWO_BYTES = 3;
+    public static final byte FOUR_BYTES = 4;
+    public static final byte EIGHT_BYTES = 5;
+    public static final byte POINTER = 6;
+    public static final byte INLINE_COMPOSITE = 7;
+}

src/capnp/ListPointer.java

@@ -8,7 +8,15 @@ class ListPointer extends WirePointer {
         super(buffer, buffer_offset);
     }
 
+    public byte elementSize() {
+        return (byte)(this.buffer.getInt(buffer_offset * 2 + 1) & 7);
+    }
+
     public int elementCount() {
-        return this.buffer.getInt(buffer_offset * 2) >> 3;
+        return this.buffer.getInt(buffer_offset * 2 + 1) >> 3;
+    }
+
+    public int inlineCompositeWordCount() {
+        return this.elementCount();
     }
 }

src/capnp/PointerReader.java

@@ -7,7 +7,7 @@ public class PointerReader {
 
     public PointerReader() {
         this.segment = null;
-        this.pointer = 0; // XXX
+        this.pointer = 0; // XXX ?
         this.nestingLimit = 0x7fffffff;
     }
 
@@ -17,7 +17,17 @@ public class PointerReader {
         this.nestingLimit = nestingLimit;
     }
 
-    public void getText() {
-        throw new Error();
+    public ListReader getList(byte expectedElementSize) {
+        // TODO check nullness
+        WirePointer ref = new WirePointer(this.segment.ptr, this.pointer);
+        return WireHelpers.readListPointer(this.segment,
+                                           ref,
+                                           expectedElementSize);
+    }
+
+    public Text.Reader getText() {
+        return WireHelpers.readTextPointer(this.segment,
+                                           new WirePointer(this.segment.ptr,
+                                                           this.pointer));
     }
 }

src/capnp/StructPointer.java

@@ -0,0 +1,22 @@
+package capnp;
+
+import java.nio.ByteBuffer;
+
+class StructPointer extends WirePointer {
+
+    public StructPointer(ByteBuffer buffer, int buffer_offset) {
+        super(buffer, buffer_offset);
+    }
+
+    public short dataSize() {
+        return this.buffer.getShort(this.buffer_offset * 4 + 2);
+    }
+
+    public short ptrCount() {
+        return this.buffer.getShort(this.buffer_offset * 4 + 3);
+    }
+
+    public int wordSize() {
+        return this.dataSize() + this.ptrCount();
+    }
+}

src/capnp/WireHelpers.java

@@ -1,6 +1,50 @@
 package capnp;
 
 class WireHelpers {
+
+    public static ListReader readListPointer(SegmentReader segment,
+                                             WirePointer ref,
+                                             int nestingLimit) {
+
+        // TODO check for null, follow fars, nestingLimit
+
+        ListPointer listPtr = (ListPointer)ref;
+
+        WordPointer ptr = ref.target();
+
+        switch (listPtr.elementSize()) {
+        case FieldSize.INLINE_COMPOSITE : {
+            int wordCount = listPtr.inlineCompositeWordCount();
+
+            WirePointer tag = new WirePointer(ptr);
+            ptr.offset += 1;
+
+            // TODO bounds check
+
+            int size = tag.inlineCompositeListElementCount();
+            StructPointer structPtr = (StructPointer)tag;
+            int wordsPerElement = structPtr.wordSize();
+
+            // TODO check that elemements do not overrun word count
+
+            // TODO check whether the size is compatible
+
+            return new ListReader(segment,    // TODO follow fars
+                                  ptr.offset, //
+                                  size,
+                                  wordsPerElement * 64,
+                                  structPtr.dataSize() * 64,
+                                  structPtr.ptrCount(),
+                                  nestingLimit - 1);
+        }
+        case FieldSize.VOID : break;
+        default :
+            throw new Error("unrecognized element size");
+        }
+
+        throw new Error();
+    }
+
     public static Text.Reader readTextPointer(SegmentReader segment,
                                               WirePointer ref) {
         ref.target();

src/capnp/WirePointer.java

@@ -6,16 +6,21 @@ class WirePointer {
     public final ByteBuffer buffer;
     public final int buffer_offset; // in words
 
-    public final byte STRUCT = 0;
-    public final byte LIST = 1;
-    public final byte FAR = 2;
-    public final byte OTHER = 3;
+    public static final byte STRUCT = 0;
+    public static final byte LIST = 1;
+    public static final byte FAR = 2;
+    public static final byte OTHER = 3;
 
     public WirePointer(ByteBuffer buffer, int offset) {
         this.buffer = buffer;
         this.buffer_offset = offset;
     }
 
+    public WirePointer(WordPointer word) {
+        this.buffer = word.buffer;
+        this.buffer_offset = word.offset;
+    }
+
     public int offset_and_kind() {
         return this.buffer.getInt(buffer_offset * 2);
     }
@@ -27,6 +32,9 @@ class WirePointer {
     public WordPointer target() {
         return new WordPointer(buffer,
                                1 + (this.offset_and_kind() >> 2));
+    }
 
+    public int inlineCompositeListElementCount() {
+        return this.offset_and_kind() >> 2;
     }
 }

src/capnp/WordPointer.java

@@ -4,7 +4,7 @@ import java.nio.ByteBuffer;
 
 class WordPointer {
     public final ByteBuffer buffer;
-    public final int offset; // in words
+    public int offset; // in words
 
     public WordPointer(ByteBuffer buffer, int offset) {
         this.buffer = buffer;