get rid of bit0Offset

compiler/src/main/cpp/capnpc-java.c++

@@ -709,7 +709,7 @@ private:
             kj::mv(unionDiscrim.readerIsDecl),
             spaces(indent), "  public ", titleCase, ".Reader get", titleCase, "() {\n",
             spaces(indent), "    return new ", scope, titleCase,
-            ".Reader(segment, data, pointers, dataSize, pointerCount, bit0Offset, nestingLimit);\n",
+            ".Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit);\n",
             spaces(indent), "  }\n",
             "\n"),
 
@@ -717,7 +717,7 @@ private:
               kj::mv(unionDiscrim.builderIsDecl),
               spaces(indent), "  public final ", titleCase, ".Builder get", titleCase, "() {\n",
               spaces(indent), "    return new ", scope, titleCase,
-              ".Builder(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n",
+              ".Builder(segment, data, pointers, dataSize, pointerCount);\n",
               spaces(indent), "  }\n",
               spaces(indent), "  public final ", titleCase, ".Builder init", titleCase, "() {\n",
               unionDiscrim.set,
@@ -738,7 +738,7 @@ private:
                 KJ_UNREACHABLE;
               },
               "  return new ", scope, titleCase,
-              ".Builder(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n",
+              ".Builder(segment, data, pointers, dataSize, pointerCount);\n",
               spaces(indent), "  }\n",
               "\n")
           };
@@ -1105,8 +1105,8 @@ private:
     return kj::strTree(
       spaces(indent), "public static final class Reader extends org.capnproto.StructReader {\n",
       spaces(indent), "  Reader(org.capnproto.SegmentReader segment, int data, int pointers,",
-      "int dataSize, short pointerCount, byte bit0Offset, int nestingLimit){\n",
+      "int dataSize, short pointerCount, int nestingLimit){\n",
-      spaces(indent), "    super(segment, data, pointers, dataSize, pointerCount, bit0Offset, nestingLimit);\n",
+      spaces(indent), "    super(segment, data, pointers, dataSize, pointerCount, nestingLimit);\n",
       spaces(indent), "  }\n",
       "\n",
       makeWhich(schema, indent+1),
@@ -1121,12 +1121,12 @@ private:
     return kj::strTree(
       spaces(indent), "public static final class Builder extends org.capnproto.StructBuilder {\n",
       spaces(indent), "  Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,",
-      "int dataSize, short pointerCount, byte bit0Offset){\n",
+      "int dataSize, short pointerCount){\n",
-      spaces(indent), "    super(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n",
+      spaces(indent), "    super(segment, data, pointers, dataSize, pointerCount);\n",
       spaces(indent), "  }\n",
       makeWhich(schema, indent+1),
       spaces(indent), "  public final Reader asReader() {\n",
-      spaces(indent), "    return new Reader(segment, data, pointers, dataSize, pointerCount, bit0Offset, 0x7fffffff);\n",
+      spaces(indent), "    return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff);\n",
       //spaces(indent), "    return new Reader(this._builder.asReader());\n",
       spaces(indent), "  }\n",
       kj::mv(methodDecls),
@@ -1156,12 +1156,12 @@ private:
         spaces(indent), "  public static final class Factory extends org.capnproto.StructFactory<Builder, Reader> {\n",
         spaces(indent),
         "    public final Reader constructReader(org.capnproto.SegmentReader segment, int data,",
-        "int pointers, int dataSize, short pointerCount, byte bit0Offset, int nestingLimit) {\n",
+        "int pointers, int dataSize, short pointerCount, int nestingLimit) {\n",
-        spaces(indent), "      return new Reader(segment,data,pointers,dataSize,pointerCount,bit0Offset,nestingLimit);\n",
+        spaces(indent), "      return new Reader(segment,data,pointers,dataSize,pointerCount, nestingLimit);\n",
         spaces(indent), "    }\n",
         spaces(indent), "    public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,",
-        "int pointers, int dataSize, short pointerCount, byte bit0Offset) {\n",
+        "int pointers, int dataSize, short pointerCount) {\n",
-        spaces(indent), "      return new Builder(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n",
+        spaces(indent), "      return new Builder(segment, data, pointers, dataSize, pointerCount);\n",
         spaces(indent), "    }\n",
         spaces(indent), "    public final org.capnproto.StructSize structSize() {\n",
         spaces(indent), "      return ", fullName, ".STRUCT_SIZE;\n",

runtime/src/main/java/org/capnproto/ListBuilder.java

@@ -122,8 +122,7 @@ public class ListBuilder {
                                         structData,
                                         structPointers,
                                         this.structDataSize,
-                                        this.structPointerCount,
+                                        this.structPointerCount);
-                                        (byte)(indexBit % 8));
     }
 
     protected final <T> T _getPointerElement(FromPointerBuilder<T> factory, int index) {

runtime/src/main/java/org/capnproto/ListReader.java

@@ -100,12 +100,11 @@ public class ListReader {
         // TODO check nesting limit
 
         int indexBit = index * this.step;
-
         int structData = this.ptr + (indexBit / 8);
         int structPointers = structData + (this.structDataSize / 8);
 
         return factory.constructReader(this.segment, structData, structPointers / 8, this.structDataSize,
-                                       this.structPointerCount, (byte) (indexBit % 8), this.nestingLimit - 1);
+                                       this.structPointerCount, this.nestingLimit - 1);
     }
 
     protected <T> T _getPointerElement(FromPointerReader<T> factory, int index) {

runtime/src/main/java/org/capnproto/StructBuilder.java

@@ -24,7 +24,7 @@ package org.capnproto;
 public class StructBuilder {
     public interface Factory<T> {
         T constructBuilder(SegmentBuilder segment, int data, int pointers, int dataSize,
-                                    short pointerCount, byte bit0Offset);
+                           short pointerCount);
         StructSize structSize();
     }
 
@@ -33,21 +33,18 @@ public class StructBuilder {
     protected final int pointers; // word offset of pointer section
     protected final int dataSize; // in bits
     protected final short pointerCount;
-    protected final byte bit0Offset;
 
     public StructBuilder(SegmentBuilder segment, int data,
-                         int pointers, int dataSize, short pointerCount,
+                         int pointers, int dataSize, short pointerCount) {
-                         byte bit0Offset) {
         this.segment = segment;
         this.data = data;
         this.pointers = pointers;
         this.dataSize = dataSize;
         this.pointerCount = pointerCount;
-        this.bit0Offset = bit0Offset;
     }
 
     protected final boolean _getBooleanField(int offset) {
-        int bitOffset = (offset == 0 ? this.bit0Offset : offset);
+        int bitOffset = offset;
         int position = this.data + (bitOffset / 8);
         return (this.segment.buffer.get(position) & (1 << (bitOffset % 8))) != 0;
     }
@@ -58,7 +55,6 @@ public class StructBuilder {
 
     protected final void _setBooleanField(int offset, boolean value) {
         int bitOffset = offset;
-        if (offset == 0) { bitOffset = this.bit0Offset; }
         byte bitnum = (byte)(bitOffset % 8);
         int position = this.data + (bitOffset / 8);
         byte oldValue = this.segment.buffer.get(position);

runtime/src/main/java/org/capnproto/StructReader.java

@@ -25,7 +25,7 @@ public class StructReader {
     public interface Factory<T> {
         abstract T constructReader(SegmentReader segment, int data, int pointers,
                                    int dataSize, short pointerCount,
-                                   byte bit0Offset, int nestingLimit);
+                                   int nestingLimit);
     }
 
     protected final SegmentReader segment;
@@ -33,7 +33,6 @@ public class StructReader {
     protected final int pointers; // word offset of pointer section
     protected final int dataSize; // in bits
     protected final short pointerCount;
-    protected final byte bit0Offset;
     protected final int nestingLimit;
 
     public StructReader() {
@@ -42,28 +41,23 @@ public class StructReader {
         this.pointers = 0;
         this.dataSize = 0;
         this.pointerCount = 0;
-        this.bit0Offset = 0;
         this.nestingLimit = 0x7fffffff;
     }
 
     public StructReader(SegmentReader segment, int data,
                         int pointers, int dataSize, short pointerCount,
-                        byte bit0Offset, int nestingLimit) {
+                        int nestingLimit) {
         this.segment = segment;
         this.data = data;
         this.pointers = pointers;
         this.dataSize = dataSize;
         this.pointerCount = pointerCount;
-        this.bit0Offset = bit0Offset;
         this.nestingLimit = nestingLimit;
     }
 
     protected final boolean _getBooleanField(int offset) {
         // XXX should use unsigned operations
         if (offset < this.dataSize) {
-            if (offset == 0) {
-                offset = this.bit0Offset;
-            }
             byte b = this.segment.buffer.get(this.data + offset / 8);
 
             return (b & (1 << (offset % 8))) != 0;

runtime/src/main/java/org/capnproto/WireHelpers.java

@@ -178,7 +178,7 @@ final class WireHelpers {
         StructPointer.setFromStructSize(allocation.segment.buffer, allocation.refOffset, size);
         return factory.constructBuilder(allocation.segment, allocation.ptr * Constants.BYTES_PER_WORD,
                                          allocation.ptr + size.data,
-                                         size.data * 64, size.pointers, (byte)0);
+                                         size.data * 64, size.pointers);
     }
 
     static <T> T getWritableStructPointer(StructBuilder.Factory<T> factory,
@@ -207,7 +207,7 @@ final class WireHelpers {
         } else {
             return factory.constructBuilder(resolved.segment, resolved.ptr * Constants.BYTES_PER_WORD,
                                             oldPointerSectionOffset, oldDataSize * Constants.BITS_PER_WORD,
-                                            oldPointerCount, (byte)0);
+                                            oldPointerCount);
         }
 
     }
@@ -484,7 +484,7 @@ final class WireHelpers {
         long ref = WirePointer.get(segment.buffer, refOffset);
         if (WirePointer.isNull(ref)) {
             if (defaultSegment == null) {
-                return factory.constructReader(SegmentReader.EMPTY, 0, 0, 0, (short) 0, (byte) 0, 0x7fffffff);
+                return factory.constructReader(SegmentReader.EMPTY, 0, 0, 0, (short) 0, 0x7fffffff);
             } else {
                 segment = defaultSegment;
                 refOffset = defaultOffset;
@@ -512,7 +512,6 @@ final class WireHelpers {
                                         (resolved.ptr + dataSizeWords),
                                         dataSizeWords * Constants.BITS_PER_WORD,
                                         StructPointer.ptrCount(resolved.ref),
-                                        (byte)0,
                                         nestingLimit - 1);
 
     }
@@ -643,7 +642,7 @@ final class WireHelpers {
                                                      resolved.ptr + StructPointer.dataSize(resolved.ref),
                                                      StructPointer.dataSize(resolved.ref) * Constants.BITS_PER_WORD,
                                                      StructPointer.ptrCount(resolved.ref),
-                                                     (byte) 0, nestingLimit - 1));
+                                                     nestingLimit - 1));
         case WirePointer.LIST :
             byte elementSize = ListPointer.elementSize(resolved.ref);
             if (nestingLimit <= 0) {

runtime/src/test/scala/org/capnproto/LayoutTest.scala

@@ -28,8 +28,8 @@ class LayoutSuite extends FunSuite {
 
   class BareStructReader extends StructReader.Factory[StructReader] {
     def constructReader(segment: org.capnproto.SegmentReader, data: Int, pointers: Int,
-                        dataSize: Int, pointerCount: Short, bit0Offset: Byte, nestingLimit:Int) : StructReader = {
+                        dataSize: Int, pointerCount: Short, nestingLimit:Int) : StructReader = {
-      return new StructReader(segment,data,pointers,dataSize,pointerCount,bit0Offset,nestingLimit);
+      return new StructReader(segment,data,pointers,dataSize,pointerCount,nestingLimit);
     }
   }
 
@@ -122,8 +122,8 @@ class LayoutSuite extends FunSuite {
   class BareStructBuilder(structSize : StructSize) extends StructBuilder.Factory[StructBuilder] {
 
     def constructBuilder(segment: org.capnproto.SegmentBuilder, data: Int, pointers: Int,
-                          dataSize: Int, pointerCount: Short, bit0Offset: Byte) : StructBuilder = {
+                          dataSize: Int, pointerCount: Short) : StructBuilder = {
-      return new StructBuilder(segment,data,pointers,dataSize,pointerCount,bit0Offset);
+      return new StructBuilder(segment,data,pointers,dataSize,pointerCount);
     }
     def structSize() : StructSize = {
       return structSize;