floating point defaults

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

@@ -730,22 +730,22 @@ private:
       case schema::Type::FLOAT32:
         kind = FieldKind::PRIMITIVE;
         if (defaultBody.getFloat32() != 0) {
-          uint32_t mask;
+          int32_t mask;
           float value = defaultBody.getFloat32();
           static_assert(sizeof(mask) == sizeof(value), "bug");
           memcpy(&mask, &value, sizeof(mask));
-          defaultMask = kj::str(mask, "u");
+          defaultMask = kj::str(mask);
         }
         break;
 
       case schema::Type::FLOAT64:
         kind = FieldKind::PRIMITIVE;
         if (defaultBody.getFloat64() != 0) {
-          uint64_t mask;
+          int64_t mask;
           double value = defaultBody.getFloat64();
           static_assert(sizeof(mask) == sizeof(value), "bug");
           memcpy(&mask, &value, sizeof(mask));
-          defaultMask = kj::str(mask, "ull");
+          defaultMask = kj::str(mask, "L");
         }
         break;
 

compiler/src/test/scala/org/capnproto/TestUtil.scala

@@ -167,17 +167,19 @@ object TestUtil {
 
   }
 
-  def checkDefaultMessage(reader : TestDefaults.Builder) {
+  def checkDefaultMessage(builder : TestDefaults.Builder) {
-    reader.getVoidField();
+    builder.getVoidField();
-    assert(reader.getBoolField() == true);
+    assert(builder.getBoolField() == true);
-    assert(reader.getInt8Field() == -123);
+    assert(builder.getInt8Field() == -123);
-    assert(reader.getInt16Field() == -12345);
+    assert(builder.getInt16Field() == -12345);
-    assert(reader.getInt32Field() == -12345678);
+    assert(builder.getInt32Field() == -12345678);
-    assert(reader.getInt64Field() == -123456789012345L);
+    assert(builder.getInt64Field() == -123456789012345L);
-    assert(reader.getUInt8Field() == 0xea.toByte);
+    assert(builder.getUInt8Field() == 0xea.toByte);
-    assert(reader.getUInt16Field() == 45678.toShort);
+    assert(builder.getUInt16Field() == 45678.toShort);
-    assert(reader.getUInt32Field() == 0xce0a6a14);
+    assert(builder.getUInt32Field() == 0xce0a6a14);
-    assert(reader.getUInt64Field() == 0xab54a98ceb1f0ad2L);
+    assert(builder.getUInt64Field() == 0xab54a98ceb1f0ad2L);
+    assert(builder.getFloat32Field() == 1234.5f);
+    assert(builder.getFloat64Field() == -123e45);
   }
 
   def checkDefaultMessage(reader : TestDefaults.Reader) {
@@ -191,6 +193,8 @@ object TestUtil {
     assert(reader.getUInt16Field() == 45678.toShort);
     assert(reader.getUInt32Field() == 0xce0a6a14);
     assert(reader.getUInt64Field() == 0xab54a98ceb1f0ad2L);
+    assert(reader.getFloat32Field() == 1234.5f);
+    assert(reader.getFloat64Field() == -123e45);
   }
 
 

compiler/src/test/schema/test.capnp

@@ -64,8 +64,8 @@ struct TestDefaults {
   uInt16Field    @7  : UInt16  = 45678;
   uInt32Field    @8  : UInt32  = 3456789012;
   uInt64Field    @9  : UInt64  = 12345678901234567890;
-#  float32Field   @10 : Float32 = 1234.5;
+  float32Field   @10 : Float32 = 1234.5;
-#  float64Field   @11 : Float64 = -123e45;
+  float64Field   @11 : Float64 = -123e45;
 }
 
 struct TestOutOfOrder {

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

@@ -118,18 +118,37 @@ public final class StructBuilder {
         return this.segment.buffer.getFloat(this.data + offset * 4);
     }
 
+    public final float getFloatField(int offset, int mask) {
+        return Float.intBitsToFloat(
+            this.segment.buffer.getInt(this.data + offset * 4) ^ mask);
+    }
+
     public final void setFloatField(int offset, float value) {
         this.segment.buffer.putFloat(this.data + offset * 4, value);
     }
 
+    public final void setFloatField(int offset, float value, int mask) {
+        this.segment.buffer.putInt(this.data + offset * 4,
+                                   Float.floatToIntBits(value) ^ mask);
+    }
+
     public final double getDoubleField(int offset) {
         return this.segment.buffer.getDouble(this.data + offset * 8);
     }
 
+    public final double getDoubleField(int offset, long mask) {
+        return Double.longBitsToDouble(
+            this.segment.buffer.getLong(this.data + offset * 8) ^ mask);
+    }
+
     public final void setDoubleField(int offset, double value) {
         this.segment.buffer.putDouble(this.data + offset * 8, value);
     }
 
+    public final void setDoubleField(int offset, double value, long mask) {
+        this.segment.buffer.putLong(this.data + offset * 8,
+                                    Double.doubleToLongBits(value) ^ mask);
+    }
 
     public final PointerBuilder getPointerField(int index) {
         return new PointerBuilder(this.segment, this.pointers + index);

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

@@ -95,6 +95,14 @@ public final class StructReader {
         }
     }
 
+    public final float getFloatField(int offset, int mask) {
+        if ((offset + 1) * 32 <= this.dataSize) {
+            return Float.intBitsToFloat(this.segment.buffer.getInt(this.data + offset * 4) ^ mask);
+        } else {
+            return Float.intBitsToFloat(mask);
+        }
+    }
+
     public final double getDoubleField(int offset) {
         if ((offset + 1) * 64 <= this.dataSize) {
             return this.segment.buffer.getDouble(this.data + offset * 8);
@@ -103,6 +111,14 @@ public final class StructReader {
         }
     }
 
+    public final double getDoubleField(int offset, long mask) {
+        if ((offset + 1) * 64 <= this.dataSize) {
+            return Double.longBitsToDouble(this.segment.buffer.getLong(this.data + offset * 8) ^ mask);
+        } else {
+            return Double.longBitsToDouble(mask);
+        }
+    }
+
     public final PointerReader getPointerField(int ptrIndex) {
         if (ptrIndex < this.pointerCount) {
             return new PointerReader(this.segment,