lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject [lucy-commits] svn commit: r1098445 [11/23] - in /incubator/lucy/trunk: charmonizer/ charmonizer/src/Charmonizer/ charmonizer/src/Charmonizer/Core/ charmonizer/src/Charmonizer/Probe/ charmonizer/src/Charmonizer/Test/ clownfish/lib/ clownfish/lib/Clownfish/Binding/ cl...
Date Sun, 01 May 2011 23:50:38 GMT
Modified: incubator/lucy/trunk/core/Lucy/Object/Host.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/Host.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/Host.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/Host.cfh Sun May  1 23:50:24 2011
@@ -58,7 +58,7 @@ __END_C__
  * series of arguments using the ARG_XXX macros.
  *
  *   int32_t area = (int32_t)Host_callback_i64(self, "calc_area", 2,
- *        ARG_I32("length", len),  ARG_I32("width", width) );
+ *        ARG_I32("length", len),  ARG_I32("width", width));
  *
  * The first argument is void* to avoid the need for tiresome casting to Obj*,
  * but must always be a Clownfish object.
@@ -67,7 +67,7 @@ __END_C__
  * callback rather than an object callback.
  */
 inert class Lucy::Object::Host {
- 
+
     /** Invoke an object method in a void context.
      */
     inert void
@@ -81,7 +81,7 @@ inert class Lucy::Object::Host {
     /** Invoke an object method, expecting a 64-bit floating point return
      * value.
      */
-    inert double 
+    inert double
     callback_f64(void *self, char *method, uint32_t num_args, ...);
 
     /** Invoke an object method, expecting a Obj-derived object back, or

Modified: incubator/lucy/trunk/core/Lucy/Object/I32Array.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/I32Array.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/I32Array.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/I32Array.c Sun May  1 23:50:24 2011
@@ -20,8 +20,7 @@
 #include "Lucy/Object/I32Array.h"
 
 I32Array*
-I32Arr_new(int32_t *ints, uint32_t size) 
-{
+I32Arr_new(int32_t *ints, uint32_t size) {
     I32Array *self = (I32Array*)VTable_Make_Obj(I32ARRAY);
     int32_t *ints_copy = (int32_t*)MALLOCATE(size * sizeof(int32_t));
     memcpy(ints_copy, ints, size * sizeof(int32_t));
@@ -29,47 +28,41 @@ I32Arr_new(int32_t *ints, uint32_t size)
 }
 
 I32Array*
-I32Arr_new_blank(uint32_t size) 
-{
+I32Arr_new_blank(uint32_t size) {
     I32Array *self = (I32Array*)VTable_Make_Obj(I32ARRAY);
     int32_t *ints = (int32_t*)CALLOCATE(size, sizeof(int32_t));
     return I32Arr_init(self, ints, size);
 }
 
 I32Array*
-I32Arr_new_steal(int32_t *ints, uint32_t size) 
-{
+I32Arr_new_steal(int32_t *ints, uint32_t size) {
     I32Array *self = (I32Array*)VTable_Make_Obj(I32ARRAY);
     return I32Arr_init(self, ints, size);
 }
 
 I32Array*
-I32Arr_init(I32Array *self, int32_t *ints, uint32_t size) 
-{
+I32Arr_init(I32Array *self, int32_t *ints, uint32_t size) {
     self->ints = ints;
     self->size = size;
     return self;
 }
 
 void
-I32Arr_destroy(I32Array *self)
-{
+I32Arr_destroy(I32Array *self) {
     FREEMEM(self->ints);
     SUPER_DESTROY(self, I32ARRAY);
 }
 
 void
-I32Arr_set(I32Array *self, uint32_t tick, int32_t value)
-{
+I32Arr_set(I32Array *self, uint32_t tick, int32_t value) {
     if (tick >= self->size) {
         THROW(ERR, "Out of bounds: %u32 >= %u32", tick, self->size);
     }
     self->ints[tick] = value;
 }
 
-int32_t 
-I32Arr_get(I32Array *self, uint32_t tick)
-{
+int32_t
+I32Arr_get(I32Array *self, uint32_t tick) {
     if (tick >= self->size) {
         THROW(ERR, "Out of bounds: %u32 >= %u32", tick, self->size);
     }
@@ -77,6 +70,8 @@ I32Arr_get(I32Array *self, uint32_t tick
 }
 
 uint32_t
-I32Arr_get_size(I32Array *self) { return self->size; }
+I32Arr_get_size(I32Array *self) {
+    return self->size;
+}
 
 

Modified: incubator/lucy/trunk/core/Lucy/Object/I32Array.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/I32Array.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/I32Array.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/I32Array.cfh Sun May  1 23:50:24 2011
@@ -46,7 +46,7 @@ class Lucy::Object::I32Array cnick I32Ar
 
     /** Accessor for 'size' member.
      */
-    uint32_t 
+    uint32_t
     Get_Size(I32Array *self);
 
     public void

Modified: incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.c Sun May  1 23:50:24 2011
@@ -33,24 +33,21 @@ typedef struct lucy_LFRegEntry {
 #define LFRegEntry lucy_LFRegEntry
 
 LockFreeRegistry*
-LFReg_new(size_t capacity)
-{
-    LockFreeRegistry *self 
+LFReg_new(size_t capacity) {
+    LockFreeRegistry *self
         = (LockFreeRegistry*)VTable_Make_Obj(LOCKFREEREGISTRY);
     return LFReg_init(self, capacity);
 }
 
 LockFreeRegistry*
-LFReg_init(LockFreeRegistry *self, size_t capacity)
-{
+LFReg_init(LockFreeRegistry *self, size_t capacity) {
     self->capacity = capacity;
     self->entries  = CALLOCATE(capacity, sizeof(void*));
     return self;
 }
 
 bool_t
-LFReg_register(LockFreeRegistry *self, Obj *key, Obj *value)
-{
+LFReg_register(LockFreeRegistry *self, Obj *key, Obj *value) {
     LFRegEntry  *new_entry = NULL;
     int32_t      hash_sum  = Obj_Hash_Sum(key);
     size_t       bucket    = (uint32_t)hash_sum  % self->capacity;
@@ -59,10 +56,10 @@ LFReg_register(LockFreeRegistry *self, O
 
     // Proceed through the linked list.  Bail out if the key has already been
     // registered.
-    FIND_END_OF_LINKED_LIST:
+FIND_END_OF_LINKED_LIST:
     while (*slot) {
         LFRegEntry *entry = *slot;
-        if (entry->hash_sum  == hash_sum) {
+        if (entry->hash_sum == hash_sum) {
             if (Obj_Equals(key, entry->key)) {
                 return false;
             }
@@ -92,8 +89,7 @@ LFReg_register(LockFreeRegistry *self, O
 }
 
 Obj*
-LFReg_fetch(LockFreeRegistry *self, Obj *key)
-{
+LFReg_fetch(LockFreeRegistry *self, Obj *key) {
     int32_t      hash_sum  = Obj_Hash_Sum(key);
     size_t       bucket    = (uint32_t)hash_sum  % self->capacity;
     LFRegEntry **entries   = (LFRegEntry**)self->entries;
@@ -112,8 +108,7 @@ LFReg_fetch(LockFreeRegistry *self, Obj 
 }
 
 void
-LFReg_destroy(LockFreeRegistry *self)
-{
+LFReg_destroy(LockFreeRegistry *self) {
     size_t i;
     LFRegEntry **entries = (LFRegEntry**)self->entries;
 

Modified: incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/LockFreeRegistry.cfh Sun May  1 23:50:24 2011
@@ -37,7 +37,7 @@ class Lucy::Object::LockFreeRegistry cni
 
     nullable Obj*
     Fetch(LockFreeRegistry *self, Obj *key);
-    
+
     void*
     To_Host(LockFreeRegistry *self);
 }

Modified: incubator/lucy/trunk/core/Lucy/Object/Num.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/Num.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/Num.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/Num.c Sun May  1 23:50:24 2011
@@ -32,15 +32,13 @@
 #include "Lucy/Store/OutStream.h"
 
 Num*
-Num_init(Num *self)
-{
+Num_init(Num *self) {
     ABSTRACT_CLASS_CHECK(self, NUM);
     return self;
 }
 
 bool_t
-Num_equals(Num *self, Obj *other)
-{
+Num_equals(Num *self, Obj *other) {
     Num *twin = (Num*)other;
     if (twin == self) { return true; }
     if (!Obj_Is_A(other, NUM)) { return false; }
@@ -50,18 +48,17 @@ Num_equals(Num *self, Obj *other)
 }
 
 int32_t
-Num_compare_to(Num *self, Obj *other)
-{
+Num_compare_to(Num *self, Obj *other) {
     Num *twin = (Num*)CERTIFY(other, NUM);
     double f64_diff = Num_To_F64(self) - Num_To_F64(twin);
     if (f64_diff) {
-        if      (f64_diff < 0) { return -1; }
+        if (f64_diff < 0)      { return -1; }
         else if (f64_diff > 0) { return 1;  }
     }
     else {
         int64_t i64_diff = Num_To_I64(self) - Num_To_I64(twin);
-        if (i64_diff) { 
-            if      (i64_diff < 0) { return -1; }
+        if (i64_diff) {
+            if (i64_diff < 0)      { return -1; }
             else if (i64_diff > 0) { return 1;  }
         }
     }
@@ -71,94 +68,86 @@ Num_compare_to(Num *self, Obj *other)
 /***************************************************************************/
 
 FloatNum*
-FloatNum_init(FloatNum *self)
-{
+FloatNum_init(FloatNum *self) {
     ABSTRACT_CLASS_CHECK(self, FLOATNUM);
     return (FloatNum*)Num_init((Num*)self);
 }
 
 CharBuf*
-FloatNum_to_string(FloatNum *self)
-{
+FloatNum_to_string(FloatNum *self) {
     return CB_newf("%f64", FloatNum_To_F64(self));
 }
 
 /***************************************************************************/
 
 IntNum*
-IntNum_init(IntNum *self)
-{
+IntNum_init(IntNum *self) {
     ABSTRACT_CLASS_CHECK(self, INTNUM);
     return (IntNum*)Num_init((Num*)self);
 }
 
 CharBuf*
-IntNum_to_string(IntNum *self)
-{
+IntNum_to_string(IntNum *self) {
     return CB_newf("%i64", IntNum_To_I64(self));
 }
 
 /***************************************************************************/
 
 Float32*
-Float32_new(float value)
-{
+Float32_new(float value) {
     Float32 *self = (Float32*)VTable_Make_Obj(FLOAT32);
     return Float32_init(self, value);
 }
 
 Float32*
-Float32_init(Float32 *self, float value)
-{
+Float32_init(Float32 *self, float value) {
     self->value = value;
     return (Float32*)FloatNum_init((FloatNum*)self);
 }
 
 float
-Float32_get_value(Float32 *self) { return self->value; }
+Float32_get_value(Float32 *self) {
+    return self->value;
+}
+
 void
-Float32_set_value(Float32 *self, float value) { self->value = value; }
+Float32_set_value(Float32 *self, float value) {
+    self->value = value;
+}
 
 double
-Float32_to_f64(Float32 *self)
-{
+Float32_to_f64(Float32 *self) {
     return self->value;
 }
 
 int64_t
-Float32_to_i64(Float32 *self)
-{
+Float32_to_i64(Float32 *self) {
     return (int64_t)self->value;
 }
 
 int32_t
-Float32_hash_sum(Float32 *self)
-{
+Float32_hash_sum(Float32 *self) {
     return *(int32_t*)&self->value;
 }
 
 Float32*
-Float32_clone(Float32 *self)
-{
+Float32_clone(Float32 *self) {
     return Float32_new(self->value);
 }
 
 void
-Float32_mimic(Float32 *self, Obj *other)
-{
+Float32_mimic(Float32 *self, Obj *other) {
     Float32 *twin = (Float32*)CERTIFY(other, FLOAT32);
     self->value = twin->value;
 }
 
 void
-Float32_serialize(Float32 *self, OutStream *outstream)
-{
+Float32_serialize(Float32 *self, OutStream *outstream) {
     OutStream_Write_F32(outstream, self->value);
 }
 
 Float32*
-Float32_deserialize(Float32 *self, InStream *instream)
-{
+Float32_deserialize(Float32 *self, InStream *instream) {
     float value = InStream_Read_F32(instream);
     return self ? Float32_init(self, value) : Float32_new(value);
 }
@@ -166,65 +155,61 @@ Float32_deserialize(Float32 *self, InStr
 /***************************************************************************/
 
 Float64*
-Float64_new(double value)
-{
+Float64_new(double value) {
     Float64 *self = (Float64*)VTable_Make_Obj(FLOAT64);
     return Float64_init(self, value);
 }
 
 Float64*
-Float64_init(Float64 *self, double value)
-{
+Float64_init(Float64 *self, double value) {
     self->value = value;
     return (Float64*)FloatNum_init((FloatNum*)self);
 }
 
 double
-Float64_get_value(Float64 *self) { return self->value; }
+Float64_get_value(Float64 *self) {
+    return self->value;
+}
+
 void
-Float64_set_value(Float64 *self, double value) { self->value = value; }
+Float64_set_value(Float64 *self, double value) {
+    self->value = value;
+}
 
 double
-Float64_to_f64(Float64 *self)
-{
+Float64_to_f64(Float64 *self) {
     return self->value;
 }
 
 int64_t
-Float64_to_i64(Float64 *self)
-{
+Float64_to_i64(Float64 *self) {
     return (int64_t)self->value;
 }
 
 Float64*
-Float64_clone(Float64 *self)
-{
+Float64_clone(Float64 *self) {
     return Float64_new(self->value);
 }
 
 void
-Float64_mimic(Float64 *self, Obj *other)
-{
+Float64_mimic(Float64 *self, Obj *other) {
     Float64 *twin = (Float64*)CERTIFY(other, FLOAT64);
     self->value = twin->value;
 }
 
 int32_t
-Float64_hash_sum(Float64 *self)
-{
+Float64_hash_sum(Float64 *self) {
     int32_t *ints = (int32_t*)&self->value;
     return ints[0] ^ ints[1];
 }
 
 void
-Float64_serialize(Float64 *self, OutStream *outstream)
-{
+Float64_serialize(Float64 *self, OutStream *outstream) {
     OutStream_Write_F64(outstream, self->value);
 }
 
 Float64*
-Float64_deserialize(Float64 *self, InStream *instream)
-{
+Float64_deserialize(Float64 *self, InStream *instream) {
     double value = InStream_Read_F64(instream);
     return self ? Float64_init(self, value) : Float64_new(value);
 }
@@ -232,64 +217,60 @@ Float64_deserialize(Float64 *self, InStr
 /***************************************************************************/
 
 Integer32*
-Int32_new(int32_t value)
-{
+Int32_new(int32_t value) {
     Integer32 *self = (Integer32*)VTable_Make_Obj(INTEGER32);
     return Int32_init(self, value);
 }
 
 Integer32*
-Int32_init(Integer32 *self, int32_t value)
-{
+Int32_init(Integer32 *self, int32_t value) {
     self->value = value;
     return (Integer32*)IntNum_init((IntNum*)self);
 }
 
 int32_t
-Int32_get_value(Integer32 *self) { return self->value; }
+Int32_get_value(Integer32 *self) {
+    return self->value;
+}
+
 void
-Int32_set_value(Integer32 *self, int32_t value) { self->value = value; }
+Int32_set_value(Integer32 *self, int32_t value) {
+    self->value = value;
+}
 
 double
-Int32_to_f64(Integer32 *self)
-{
+Int32_to_f64(Integer32 *self) {
     return self->value;
 }
 
 int64_t
-Int32_to_i64(Integer32 *self)
-{
+Int32_to_i64(Integer32 *self) {
     return self->value;
 }
 
 Integer32*
-Int32_clone(Integer32 *self)
-{
+Int32_clone(Integer32 *self) {
     return Int32_new(self->value);
 }
 
 void
-Int32_mimic(Integer32 *self, Obj *other)
-{
+Int32_mimic(Integer32 *self, Obj *other) {
     Integer32 *twin = (Integer32*)CERTIFY(other, INTEGER32);
     self->value = twin->value;
 }
 
 int32_t
-Int32_hash_sum(Integer32 *self)
-{
+Int32_hash_sum(Integer32 *self) {
     return self->value;
 }
 
 void
-Int32_serialize(Integer32 *self, OutStream *outstream)
-{
+Int32_serialize(Integer32 *self, OutStream *outstream) {
     OutStream_Write_C32(outstream, (uint32_t)self->value);
 }
 
 Integer32*
-Int32_deserialize(Integer32 *self, InStream *instream)
-{
+Int32_deserialize(Integer32 *self, InStream *instream) {
     int32_t value = (int32_t)InStream_Read_C32(instream);
     return self ? Int32_init(self, value) : Int32_new(value);
 }
@@ -297,59 +278,56 @@ Int32_deserialize(Integer32 *self, InStr
 /***************************************************************************/
 
 Integer64*
-Int64_new(int64_t value)
-{
+Int64_new(int64_t value) {
     Integer64 *self = (Integer64*)VTable_Make_Obj(INTEGER64);
     return Int64_init(self, value);
 }
 
 Integer64*
-Int64_init(Integer64 *self, int64_t value)
-{
+Int64_init(Integer64 *self, int64_t value) {
     self->value = value;
     return (Integer64*)FloatNum_init((FloatNum*)self);
 }
 
 int64_t
-Int64_get_value(Integer64 *self) { return self->value; }
+Int64_get_value(Integer64 *self) {
+    return self->value;
+}
+
 void
-Int64_set_value(Integer64 *self, int64_t value) { self->value = value; }
+Int64_set_value(Integer64 *self, int64_t value) {
+    self->value = value;
+}
 
 double
-Int64_to_f64(Integer64 *self)
-{
+Int64_to_f64(Integer64 *self) {
     return (double)self->value;
 }
 
 int64_t
-Int64_to_i64(Integer64 *self)
-{
+Int64_to_i64(Integer64 *self) {
     return self->value;
 }
 
 Integer64*
-Int64_clone(Integer64 *self)
-{
+Int64_clone(Integer64 *self) {
     return Int64_new(self->value);
 }
 
 void
-Int64_mimic(Integer64 *self, Obj *other)
-{
+Int64_mimic(Integer64 *self, Obj *other) {
     Integer64 *twin = (Integer64*)CERTIFY(other, INTEGER64);
     self->value = twin->value;
 }
 
 int32_t
-Int64_hash_sum(Integer64 *self)
-{
+Int64_hash_sum(Integer64 *self) {
     int32_t *ints = (int32_t*)&self->value;
     return ints[0] ^ ints[1];
 }
 
 bool_t
-Int64_equals(Integer64 *self, Obj *other)
-{
+Int64_equals(Integer64 *self, Obj *other) {
     Num *twin = (Num*)other;
     if (twin == (Num*)self)         { return true; }
     if (!Obj_Is_A(other, NUM)) { return false; }
@@ -366,14 +344,12 @@ Int64_equals(Integer64 *self, Obj *other
 }
 
 void
-Int64_serialize(Integer64 *self, OutStream *outstream)
-{
+Int64_serialize(Integer64 *self, OutStream *outstream) {
     OutStream_Write_C64(outstream, (uint64_t)self->value);
 }
 
 Integer64*
-Int64_deserialize(Integer64 *self, InStream *instream)
-{
+Int64_deserialize(Integer64 *self, InStream *instream) {
     int64_t value = (int64_t)InStream_Read_C64(instream);
     return self ? Int64_init(self, value) : Int64_new(value);
 }

Modified: incubator/lucy/trunk/core/Lucy/Object/Num.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/Num.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/Num.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/Num.cfh Sun May  1 23:50:24 2011
@@ -72,7 +72,7 @@ class Lucy::Object::Float32 inherits Luc
     void
     Set_Value(Float32 *self, float value);
 
-    float 
+    float
     Get_Value(Float32 *self);
 
     public int64_t
@@ -142,7 +142,7 @@ class Lucy::Object::Float64 inherits Luc
 
 /** 32-bit signed integer.
  */
-class Lucy::Object::Integer32 cnick Int32 
+class Lucy::Object::Integer32 cnick Int32
     inherits Lucy::Object::IntNum {
 
     int32_t value;
@@ -159,7 +159,7 @@ class Lucy::Object::Integer32 cnick Int3
     void
     Set_Value(Integer32 *self, int32_t value);
 
-    int32_t 
+    int32_t
     Get_Value(Integer32 *self);
 
     public int64_t
@@ -187,7 +187,7 @@ class Lucy::Object::Integer32 cnick Int3
 /**
  * 64-bit signed integer.
  */
-class Lucy::Object::Integer64 cnick Int64 
+class Lucy::Object::Integer64 cnick Int64
     inherits Lucy::Object::IntNum {
 
     int64_t value;
@@ -204,7 +204,7 @@ class Lucy::Object::Integer64 cnick Int6
     void
     Set_Value(Integer64 *self, int64_t value);
 
-    int64_t 
+    int64_t
     Get_Value(Integer64 *self);
 
     public int64_t

Modified: incubator/lucy/trunk/core/Lucy/Object/Obj.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/Obj.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/Obj.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/Obj.c Sun May  1 23:50:24 2011
@@ -33,28 +33,24 @@
 #include "Lucy/Util/Memory.h"
 
 Obj*
-Obj_init(Obj *self)
-{
+Obj_init(Obj *self) {
     ABSTRACT_CLASS_CHECK(self, OBJ);
     return self;
 }
 
 void
-Obj_destroy(Obj *self)
-{
+Obj_destroy(Obj *self) {
     FREEMEM(self);
 }
 
 int32_t
-Obj_hash_sum(Obj *self)
-{
+Obj_hash_sum(Obj *self) {
     int64_t hash_sum = PTR_TO_I64(self);
     return (int32_t)hash_sum;
 }
 
 bool_t
-Obj_is_a(Obj *self, VTable *ancestor)
-{
+Obj_is_a(Obj *self, VTable *ancestor) {
     VTable *vtable = self ? self->vtable : NULL;
 
     while (vtable != NULL) {
@@ -68,21 +64,18 @@ Obj_is_a(Obj *self, VTable *ancestor)
 }
 
 bool_t
-Obj_equals(Obj *self, Obj *other)
-{
+Obj_equals(Obj *self, Obj *other) {
     return (self == other);
 }
 
 void
-Obj_serialize(Obj *self, OutStream *outstream)
-{
+Obj_serialize(Obj *self, OutStream *outstream) {
     CharBuf *class_name = Obj_Get_Class_Name(self);
     CB_Serialize(class_name, outstream);
 }
 
 Obj*
-Obj_deserialize(Obj *self, InStream *instream)
-{
+Obj_deserialize(Obj *self, InStream *instream) {
     CharBuf *class_name = CB_deserialize(NULL, instream);
     if (!self) {
         VTable *vtable = VTable_singleton(class_name, OBJ);
@@ -99,8 +92,7 @@ Obj_deserialize(Obj *self, InStream *ins
 }
 
 CharBuf*
-Obj_to_string(Obj *self)
-{
+Obj_to_string(Obj *self) {
 #if (SIZEOF_PTR == 4)
     return CB_newf("%o@0x%x32", Obj_Get_Class_Name(self), self);
 #elif (SIZEOF_PTR == 8)
@@ -109,21 +101,25 @@ Obj_to_string(Obj *self)
     uint32_t  address_hi = address >> 32;
     uint32_t  address_lo = address & 0xFFFFFFFF;
     return CB_newf("%o@0x%x32%x32", Obj_Get_Class_Name(self), address_hi,
-        address_lo);
+                   address_lo);
 #else
   #error Unexpected pointer size.
 #endif
 }
 
 Obj*
-Obj_dump(Obj *self)
-{
+Obj_dump(Obj *self) {
     return (Obj*)Obj_To_String(self);
 }
 
 VTable*
-Obj_get_vtable(Obj *self) { return self->vtable; }
+Obj_get_vtable(Obj *self) {
+    return self->vtable;
+}
+
 CharBuf*
-Obj_get_class_name(Obj *self) { return VTable_Get_Name(self->vtable); }
+Obj_get_class_name(Obj *self) {
+    return VTable_Get_Name(self->vtable);
+}
 
 

Modified: incubator/lucy/trunk/core/Lucy/Object/Obj.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/Obj.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/Obj.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/Obj.cfh Sun May  1 23:50:24 2011
@@ -43,7 +43,7 @@ class Lucy::Object::Obj {
      *
      * @return The object, allowing an assignment idiom.
      */
-    incremented Obj* 
+    incremented Obj*
     Inc_RefCount(Obj *self);
 
     /** NULL-safe invocation of Inc_RefCount().
@@ -66,7 +66,7 @@ class Lucy::Object::Obj {
      * @return NULL if <code>self</code> is NULL, otherwise the return value
      * of Dec_RefCount().
      */
-    inert inline uint32_t 
+    inert inline uint32_t
     decref(Obj *self);
 
     /** Return a host-language object wrapper for this object.
@@ -187,9 +187,8 @@ class Lucy::Object::Obj {
 
 __C__
 static CHY_INLINE void
-lucy_Obj_super_destroy(lucy_Obj *self, lucy_VTable *vtable)
-{
-    lucy_Obj_destroy_t super_destroy 
+lucy_Obj_super_destroy(lucy_Obj *self, lucy_VTable *vtable) {
+    lucy_Obj_destroy_t super_destroy
         = (lucy_Obj_destroy_t)LUCY_SUPER_METHOD(vtable, Obj, Destroy);
     super_destroy(self);
 }
@@ -197,18 +196,16 @@ lucy_Obj_super_destroy(lucy_Obj *self, l
 #define LUCY_SUPER_DESTROY(_self, _vtable) \
     lucy_Obj_super_destroy((lucy_Obj*)_self, _vtable)
 
-static CHY_INLINE lucy_Obj* 
-lucy_Obj_incref(lucy_Obj *self)
-{
+static CHY_INLINE lucy_Obj*
+lucy_Obj_incref(lucy_Obj *self) {
     if (self != NULL) { return Lucy_Obj_Inc_RefCount(self); }
     else { return NULL; }
 }
 
 #define LUCY_INCREF(_self) lucy_Obj_incref((lucy_Obj*)_self)
 
-static CHY_INLINE uint32_t 
-lucy_Obj_decref(lucy_Obj *self)
-{
+static CHY_INLINE uint32_t
+lucy_Obj_decref(lucy_Obj *self) {
     if (self != NULL) { return Lucy_Obj_Dec_RefCount(self); }
     else { return 0; }
 }

Modified: incubator/lucy/trunk/core/Lucy/Object/VArray.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/VArray.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/VArray.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/VArray.c Sun May  1 23:50:24 2011
@@ -31,16 +31,14 @@
 #include "Lucy/Store/OutStream.h"
 
 VArray*
-VA_new(uint32_t capacity) 
-{
+VA_new(uint32_t capacity) {
     VArray *self = (VArray*)VTable_Make_Obj(VARRAY);
     VA_init(self, capacity);
     return self;
 }
 
 VArray*
-VA_init(VArray *self, uint32_t capacity)
-{
+VA_init(VArray *self, uint32_t capacity) {
     // Init.
     self->size = 0;
 
@@ -54,12 +52,11 @@ VA_init(VArray *self, uint32_t capacity)
 }
 
 void
-VA_destroy(VArray *self) 
-{
+VA_destroy(VArray *self) {
     if (self->elems) {
         Obj **elems        = self->elems;
         Obj **const limit  = elems + self->size;
-        for ( ; elems < limit; elems++) {
+        for (; elems < limit; elems++) {
             DECREF(*elems);
         }
         FREEMEM(self->elems);
@@ -68,8 +65,7 @@ VA_destroy(VArray *self) 
 }
 
 VArray*
-VA_dump(VArray *self)
-{
+VA_dump(VArray *self) {
     VArray *dump = VA_new(self->size);
     uint32_t i, max;
     for (i = 0, max = self->size; i < max; i++) {
@@ -80,8 +76,7 @@ VA_dump(VArray *self)
 }
 
 VArray*
-VA_load(VArray *self, Obj *dump)
-{
+VA_load(VArray *self, Obj *dump) {
     VArray *source = (VArray*)CERTIFY(dump, VARRAY);
     VArray *loaded = VA_new(source->size);
     uint32_t i, max;
@@ -98,8 +93,7 @@ VA_load(VArray *self, Obj *dump)
 }
 
 void
-VA_serialize(VArray *self, OutStream *outstream)
-{
+VA_serialize(VArray *self, OutStream *outstream) {
     uint32_t i;
     uint32_t last_valid_tick = 0;
     OutStream_Write_C32(outstream, self->size);
@@ -116,8 +110,7 @@ VA_serialize(VArray *self, OutStream *ou
 }
 
 VArray*
-VA_deserialize(VArray *self, InStream *instream)
-{
+VA_deserialize(VArray *self, InStream *instream) {
     uint32_t tick;
     uint32_t size = InStream_Read_C32(instream);
     if (self) {
@@ -126,10 +119,10 @@ VA_deserialize(VArray *self, InStream *i
         self->elems = (Obj**)CALLOCATE(self->cap, sizeof(Obj*));
     }
     else self = VA_new(size);
-    for (tick = InStream_Read_C32(instream); 
-         tick < size; 
+    for (tick = InStream_Read_C32(instream);
+         tick < size;
          tick += InStream_Read_C32(instream)
-    ) {
+        ) {
         Obj *obj = THAW(instream);
         self->elems[tick] = obj;
     }
@@ -138,8 +131,7 @@ VA_deserialize(VArray *self, InStream *i
 }
 
 VArray*
-VA_clone(VArray *self)
-{
+VA_clone(VArray *self) {
     uint32_t i;
     VArray *twin = VA_new(self->size);
 
@@ -158,8 +150,7 @@ VA_clone(VArray *self)
 }
 
 VArray*
-VA_shallow_copy(VArray *self)
-{
+VA_shallow_copy(VArray *self) {
     uint32_t i;
     VArray *twin;
     Obj **elems;
@@ -179,23 +170,21 @@ VA_shallow_copy(VArray *self)
 }
 
 void
-VA_push(VArray *self, Obj *element) 
-{
-    if (self->size == self->cap) { 
+VA_push(VArray *self, Obj *element) {
+    if (self->size == self->cap) {
         VA_Grow(self, Memory_oversize(self->size + 1, sizeof(Obj*)));
     }
-    self->elems[ self->size ] = element;
+    self->elems[self->size] = element;
     self->size++;
 }
 
 void
-VA_push_varray(VArray *self, VArray *other) 
-{
+VA_push_varray(VArray *self, VArray *other) {
     uint32_t i;
     uint32_t tick = self->size;
     uint32_t new_size = self->size + other->size;
-    if (new_size > self->cap) { 
-        VA_Grow(self, Memory_oversize(new_size, sizeof(Obj*))); 
+    if (new_size > self->cap) {
+        VA_Grow(self, Memory_oversize(new_size, sizeof(Obj*)));
     }
     for (i = 0; i < other->size; i++, tick++) {
         Obj *elem = VA_Fetch(other, i);
@@ -207,19 +196,17 @@ VA_push_varray(VArray *self, VArray *oth
 }
 
 Obj*
-VA_pop(VArray *self) 
-{
+VA_pop(VArray *self) {
     if (!self->size) {
         return NULL;
     }
     self->size--;
-    return  self->elems[ self->size ];
+    return  self->elems[self->size];
 }
 
 void
-VA_unshift(VArray *self, Obj *elem) 
-{
-    if (self->size == self->cap) { 
+VA_unshift(VArray *self, Obj *elem) {
+    if (self->size == self->cap) {
         VA_Grow(self, Memory_oversize(self->size + 1, sizeof(Obj*)));
     }
     memmove(self->elems + 1, self->elems, self->size * sizeof(Obj*));
@@ -228,8 +215,7 @@ VA_unshift(VArray *self, Obj *elem) 
 }
 
 Obj*
-VA_shift(VArray *self) 
-{
+VA_shift(VArray *self) {
     if (!self->size) {
         return NULL;
     }
@@ -237,16 +223,15 @@ VA_shift(VArray *self) 
         Obj *const return_val = self->elems[0];
         self->size--;
         if (self->size > 0) {
-            memmove(self->elems, self->elems + 1, 
-                self->size * sizeof(Obj*));
+            memmove(self->elems, self->elems + 1,
+                    self->size * sizeof(Obj*));
         }
         return return_val;
     }
 }
 
 Obj*
-VA_fetch(VArray *self, uint32_t num) 
-{
+VA_fetch(VArray *self, uint32_t num) {
     if (num >= self->size) {
         return NULL;
     }
@@ -255,10 +240,9 @@ VA_fetch(VArray *self, uint32_t num) 
 }
 
 void
-VA_store(VArray *self, uint32_t tick, Obj *elem) 
-{
+VA_store(VArray *self, uint32_t tick, Obj *elem) {
     if (tick >= self->cap) {
-        VA_Grow(self, Memory_oversize(tick + 1, sizeof(Obj*))); 
+        VA_Grow(self, Memory_oversize(tick + 1, sizeof(Obj*)));
     }
     if (tick < self->size) { DECREF(self->elems[tick]); }
     else                   { self->size = tick + 1; }
@@ -266,19 +250,17 @@ VA_store(VArray *self, uint32_t tick, Ob
 }
 
 void
-VA_grow(VArray *self, uint32_t capacity) 
-{
+VA_grow(VArray *self, uint32_t capacity) {
     if (capacity > self->cap) {
-        self->elems = (Obj**)REALLOCATE(self->elems, capacity * sizeof(Obj*)); 
+        self->elems = (Obj**)REALLOCATE(self->elems, capacity * sizeof(Obj*));
         self->cap   = capacity;
         memset(self->elems + self->size, 0,
-            (capacity - self->size) * sizeof(Obj*));
+               (capacity - self->size) * sizeof(Obj*));
     }
 }
 
 Obj*
-VA_delete(VArray *self, uint32_t num)
-{
+VA_delete(VArray *self, uint32_t num) {
     Obj *elem = NULL;
     if (num < self->size) {
         elem = self->elems[num];
@@ -288,33 +270,30 @@ VA_delete(VArray *self, uint32_t num)
 }
 
 void
-VA_excise(VArray *self, uint32_t offset, uint32_t length)
-{
+VA_excise(VArray *self, uint32_t offset, uint32_t length) {
     uint32_t i;
     uint32_t num_to_move;
-    
+
     if (self->size <= offset) return;
     else if (self->size < offset + length) length = self->size - offset;
-    
+
     for (i = 0; i < length; i++) {
         DECREF(self->elems[offset + i]);
     }
 
     num_to_move = self->size - (offset + length);
-    memmove(self->elems + offset, self->elems + offset + length, 
-        num_to_move * sizeof(Obj*));
+    memmove(self->elems + offset, self->elems + offset + length,
+            num_to_move * sizeof(Obj*));
     self->size -= length;
 }
 
 void
-VA_clear(VArray *self)
-{
+VA_clear(VArray *self) {
     VA_excise(self, 0, self->size);
 }
 
 void
-VA_resize(VArray *self, uint32_t size)
-{
+VA_resize(VArray *self, uint32_t size) {
     if (size < self->size) {
         VA_Excise(self, size, self->size - size);
     }
@@ -325,32 +304,34 @@ VA_resize(VArray *self, uint32_t size)
 }
 
 uint32_t
-VA_get_size(VArray *self) { return self->size; }
+VA_get_size(VArray *self) {
+    return self->size;
+}
+
 uint32_t
-VA_get_capacity(VArray *self) { return self->cap; }
+VA_get_capacity(VArray *self) {
+    return self->cap;
+}
 
 static int
-S_default_compare(void *context, const void *va, const void *vb)
-{
+S_default_compare(void *context, const void *va, const void *vb) {
     Obj *a = *(Obj**)va;
     Obj *b = *(Obj**)vb;
     UNUSED_VAR(context);
-    if      (a != NULL && b != NULL) { return Obj_Compare_To(a, b); }
+    if (a != NULL && b != NULL)      { return Obj_Compare_To(a, b); }
     else if (a == NULL && b == NULL) { return 0;  }
     else if (a == NULL)              { return 1;  } // NULL to the back
     else  /* b == NULL */            { return -1; } // NULL to the back
 }
 
 void
-VA_sort(VArray *self, lucy_Sort_compare_t compare, void *context)
-{
+VA_sort(VArray *self, lucy_Sort_compare_t compare, void *context) {
     if (!compare) { compare = S_default_compare; }
     Sort_quicksort(self->elems, self->size, sizeof(void*), compare, context);
 }
 
 bool_t
-VA_equals(VArray *self, Obj *other)
-{ 
+VA_equals(VArray *self, Obj *other) {
     VArray *twin = (VArray*)other;
     if (twin == self) return true;
     if (!Obj_Is_A(other, VARRAY)) return false;
@@ -358,7 +339,7 @@ VA_equals(VArray *self, Obj *other)
         return false;
     }
     else {
-        uint32_t i, max; 
+        uint32_t i, max;
         for (i = 0, max = self->size; i < max; i++) {
             Obj *val       = self->elems[i];
             Obj *other_val = twin->elems[i];
@@ -370,13 +351,12 @@ VA_equals(VArray *self, Obj *other)
 }
 
 VArray*
-VA_gather(VArray *self, lucy_VA_gather_test_t test, void *data)
-{
+VA_gather(VArray *self, lucy_VA_gather_test_t test, void *data) {
     uint32_t i, max;
     VArray *gathered = VA_new(self->size);
     for (i = 0, max = self->size; i < max; i++) {
         if (test(self, i, data)) {
-            Obj *elem = self->elems[i]; 
+            Obj *elem = self->elems[i];
             VA_Push(gathered, elem ? INCREF(elem) : NULL);
         }
     }

Modified: incubator/lucy/trunk/core/Lucy/Object/VArray.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/VArray.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/VArray.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/VArray.cfh Sun May  1 23:50:24 2011
@@ -119,7 +119,7 @@ class Lucy::Object::VArray cnick VA inhe
      * @param context Argument supplied to the comparison routine.
      */
     void
-    Sort(VArray *self, lucy_Sort_compare_t compare = NULL, 
+    Sort(VArray *self, lucy_Sort_compare_t compare = NULL,
          void *context = NULL);
 
     /** Set the size for the VArray.  If the new size is larger than the

Modified: incubator/lucy/trunk/core/Lucy/Object/VTable.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/VTable.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/VTable.c (original)
+++ incubator/lucy/trunk/core/Lucy/Object/VTable.c Sun May  1 23:50:24 2011
@@ -40,40 +40,35 @@ S_scrunch_charbuf(CharBuf *source, CharB
 LockFreeRegistry *VTable_registry = NULL;
 
 void
-VTable_destroy(VTable *self)
-{
+VTable_destroy(VTable *self) {
     THROW(ERR, "Insane attempt to destroy VTable for class '%o'", self->name);
 }
 
 VTable*
-VTable_clone(VTable *self)
-{
-    VTable *twin 
+VTable_clone(VTable *self) {
+    VTable *twin
         = (VTable*)Memory_wrapped_calloc(self->vt_alloc_size, 1);
 
     memcpy(twin, self, self->vt_alloc_size);
     twin->name = CB_Clone(self->name);
-    twin->ref.count = 1; 
+    twin->ref.count = 1;
 
     return twin;
 }
 
 Obj*
-VTable_inc_refcount(VTable *self)
-{
+VTable_inc_refcount(VTable *self) {
     return (Obj*)self;
 }
 
 uint32_t
-VTable_dec_refcount(VTable *self)
-{
+VTable_dec_refcount(VTable *self) {
     UNUSED_VAR(self);
     return 1;
 }
 
 uint32_t
-VTable_get_refcount(VTable *self)
-{
+VTable_get_refcount(VTable *self) {
     UNUSED_VAR(self);
     /* VTable_Get_RefCount() lies to other Lucy code about the refcount
      * because we don't want to have to synchronize access to the cached host
@@ -91,23 +86,29 @@ VTable_get_refcount(VTable *self)
 }
 
 void
-VTable_override(VTable *self, lucy_method_t method, size_t offset) 
-{
+VTable_override(VTable *self, lucy_method_t method, size_t offset) {
     union { char *char_ptr; lucy_method_t *func_ptr; } pointer;
     pointer.char_ptr = ((char*)self) + offset;
     pointer.func_ptr[0] = method;
 }
 
 CharBuf*
-VTable_get_name(VTable *self)   { return self->name; }
+VTable_get_name(VTable *self) {
+    return self->name;
+}
+
 VTable*
-VTable_get_parent(VTable *self) { return self->parent; }
+VTable_get_parent(VTable *self) {
+    return self->parent;
+}
+
 size_t
-VTable_get_obj_alloc_size(VTable *self) { return self->obj_alloc_size; }
+VTable_get_obj_alloc_size(VTable *self) {
+    return self->obj_alloc_size;
+}
 
 void
-VTable_init_registry()
-{
+VTable_init_registry() {
     LockFreeRegistry *reg = LFReg_new(256);
     if (Atomic_cas_ptr((void*volatile*)&VTable_registry, NULL, reg)) {
         return;
@@ -118,10 +119,9 @@ VTable_init_registry()
 }
 
 VTable*
-VTable_singleton(const CharBuf *subclass_name, VTable *parent)
-{
-    if (VTable_registry == NULL) { 
-        VTable_init_registry(); 
+VTable_singleton(const CharBuf *subclass_name, VTable *parent) {
+    if (VTable_registry == NULL) {
+        VTable_init_registry();
     }
 
     VTable *singleton = (VTable*)LFReg_Fetch(VTable_registry, (Obj*)subclass_name);
@@ -133,7 +133,7 @@ VTable_singleton(const CharBuf *subclass
             CharBuf *parent_class = VTable_find_parent_class(subclass_name);
             if (parent_class == NULL) {
                 THROW(ERR, "Class '%o' doesn't descend from %o", subclass_name,
-                    OBJ->name);
+                      OBJ->name);
             }
             else {
                 parent = VTable_singleton(parent_class, NULL);
@@ -145,10 +145,10 @@ VTable_singleton(const CharBuf *subclass
         singleton = VTable_Clone(parent);
 
         // Turn clone into child.
-        singleton->parent = parent; 
+        singleton->parent = parent;
         DECREF(singleton->name);
         singleton->name = CB_Clone(subclass_name);
-        
+
         // Allow host methods to override.
         novel_host_methods = VTable_novel_host_methods(subclass_name);
         num_novel = VA_Get_Size(novel_host_methods);
@@ -167,11 +167,11 @@ VTable_singleton(const CharBuf *subclass
             for (i = 0; callbacks[i] != NULL; i++) {
                 cfish_Callback *const callback = callbacks[i];
                 ZCB_Assign_Str(callback_name, callback->name,
-                    callback->name_len);
+                               callback->name_len);
                 S_scrunch_charbuf((CharBuf*)callback_name, scrunched);
                 if (Hash_Fetch(meths, (Obj*)scrunched)) {
-                    VTable_Override(singleton, callback->func, 
-                        callback->offset);
+                    VTable_Override(singleton, callback->func,
+                                    callback->offset);
                 }
             }
             DECREF(scrunched);
@@ -189,17 +189,16 @@ VTable_singleton(const CharBuf *subclass
             singleton = (VTable*)LFReg_Fetch(VTable_registry, (Obj*)subclass_name);
             if (!singleton) {
                 THROW(ERR, "Failed to either insert or fetch VTable for '%o'",
-                    subclass_name);
+                      subclass_name);
             }
         }
     }
-    
+
     return singleton;
 }
 
 Obj*
-VTable_make_obj(VTable *self)
-{
+VTable_make_obj(VTable *self) {
     Obj *obj = (Obj*)Memory_wrapped_calloc(self->obj_alloc_size, 1);
     obj->vtable = self;
     obj->ref.count = 1;
@@ -207,8 +206,7 @@ VTable_make_obj(VTable *self)
 }
 
 Obj*
-VTable_init_obj(VTable *self, void *allocation)
-{
+VTable_init_obj(VTable *self, void *allocation) {
     Obj *obj = (Obj*)allocation;
     obj->vtable = self;
     obj->ref.count = 1;
@@ -216,8 +214,7 @@ VTable_init_obj(VTable *self, void *allo
 }
 
 Obj*
-VTable_load_obj(VTable *self, Obj *dump)
-{
+VTable_load_obj(VTable *self, Obj *dump) {
     Obj_load_t load = (Obj_load_t)METHOD(self, Obj, Load);
     if (load == Obj_load) {
         THROW(ERR, "Abstract method Load() not defined for %o", self->name);
@@ -226,8 +223,7 @@ VTable_load_obj(VTable *self, Obj *dump)
 }
 
 static void
-S_scrunch_charbuf(CharBuf *source, CharBuf *target)
-{
+S_scrunch_charbuf(CharBuf *source, CharBuf *target) {
     ZombieCharBuf *iterator = ZCB_WRAP(source);
     CB_Set_Size(target, 0);
     while (ZCB_Get_Size(iterator)) {
@@ -242,8 +238,7 @@ S_scrunch_charbuf(CharBuf *source, CharB
 }
 
 bool_t
-VTable_add_to_registry(VTable *vtable)
-{
+VTable_add_to_registry(VTable *vtable) {
     if (VTable_registry == NULL) {
         VTable_init_registry();
     }
@@ -252,7 +247,7 @@ VTable_add_to_registry(VTable *vtable)
     }
     else {
         CharBuf *klass = CB_Clone(vtable->name);
-        bool_t retval 
+        bool_t retval
             = LFReg_Register(VTable_registry, (Obj*)klass, (Obj*)vtable);
         DECREF(klass);
         return retval;
@@ -260,8 +255,7 @@ VTable_add_to_registry(VTable *vtable)
 }
 
 bool_t
-VTable_add_alias_to_registry(VTable *vtable, CharBuf *alias)
-{
+VTable_add_alias_to_registry(VTable *vtable, CharBuf *alias) {
     if (VTable_registry == NULL) {
         VTable_init_registry();
     }
@@ -270,7 +264,7 @@ VTable_add_alias_to_registry(VTable *vta
     }
     else {
         CharBuf *klass = CB_Clone(alias);
-        bool_t retval 
+        bool_t retval
             = LFReg_Register(VTable_registry, (Obj*)klass, (Obj*)vtable);
         DECREF(klass);
         return retval;
@@ -278,8 +272,7 @@ VTable_add_alias_to_registry(VTable *vta
 }
 
 VTable*
-VTable_fetch_vtable(const CharBuf *class_name)
-{
+VTable_fetch_vtable(const CharBuf *class_name) {
     VTable *vtable = NULL;
     if (VTable_registry != NULL) {
         vtable = (VTable*)LFReg_Fetch(VTable_registry, (Obj*)class_name);

Modified: incubator/lucy/trunk/core/Lucy/Object/VTable.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Object/VTable.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Object/VTable.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Object/VTable.cfh Sun May  1 23:50:24 2011
@@ -75,7 +75,7 @@ class Lucy::Object::VTable inherits Lucy
      */
     inert nullable VTable*
     fetch_vtable(const CharBuf *class_name);
-    
+
     /** Given a class name, return the name of a parent class which descends
      * from Lucy::Object::Obj, or NULL if such a class can't be found.
      */
@@ -125,8 +125,8 @@ class Lucy::Object::VTable inherits Lucy
 
     size_t
     Get_Obj_Alloc_Size(VTable *self);
-    
-    public incremented VTable* 
+
+    public incremented VTable*
     Clone(VTable *self);
 
     incremented Obj*
@@ -140,8 +140,8 @@ class Lucy::Object::VTable inherits Lucy
 
     void*
     To_Host(VTable *self);
-    
-    public void 
+
+    public void
     Destroy(VTable *self);
 }
 

Modified: incubator/lucy/trunk/core/Lucy/Plan/Architecture.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/Architecture.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/Architecture.c (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/Architecture.c Sun May  1 23:50:24 2011
@@ -40,21 +40,18 @@
 #include "Lucy/Store/Folder.h"
 
 Architecture*
-Arch_new()
-{
+Arch_new() {
     Architecture *self = (Architecture*)VTable_Make_Obj(ARCHITECTURE);
     return Arch_init(self);
 }
 
 Architecture*
-Arch_init(Architecture *self)
-{
+Arch_init(Architecture *self) {
     return self;
 }
 
 bool_t
-Arch_equals(Architecture *self, Obj *other)
-{
+Arch_equals(Architecture *self, Obj *other) {
     Architecture *twin = (Architecture*)other;
     if (twin == self) return true;
     if (!Obj_Is_A(other, ARCHITECTURE)) return false;
@@ -62,8 +59,7 @@ Arch_equals(Architecture *self, Obj *oth
 }
 
 void
-Arch_init_seg_writer(Architecture *self, SegWriter *writer)
-{
+Arch_init_seg_writer(Architecture *self, SegWriter *writer) {
     Arch_Register_Lexicon_Writer(self, writer);
     Arch_Register_Posting_List_Writer(self, writer);
     Arch_Register_Sort_Writer(self, writer);
@@ -73,74 +69,70 @@ Arch_init_seg_writer(Architecture *self,
 }
 
 void
-Arch_register_lexicon_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_lexicon_writer(Architecture *self, SegWriter *writer) {
     Schema        *schema     = SegWriter_Get_Schema(writer);
     Snapshot      *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment       *segment    = SegWriter_Get_Segment(writer);
     PolyReader    *polyreader = SegWriter_Get_PolyReader(writer);
-    LexiconWriter *lex_writer 
+    LexiconWriter *lex_writer
         = LexWriter_new(schema, snapshot, segment, polyreader);
     UNUSED_VAR(self);
     SegWriter_Register(writer, VTable_Get_Name(LEXICONWRITER),
-        (DataWriter*)lex_writer);
+                       (DataWriter*)lex_writer);
 }
 
 void
-Arch_register_posting_list_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_posting_list_writer(Architecture *self, SegWriter *writer) {
     Schema        *schema     = SegWriter_Get_Schema(writer);
     Snapshot      *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment       *segment    = SegWriter_Get_Segment(writer);
     PolyReader    *polyreader = SegWriter_Get_PolyReader(writer);
-    LexiconWriter *lex_writer = (LexiconWriter*)SegWriter_Fetch(writer, 
-        VTable_Get_Name(LEXICONWRITER));
+    LexiconWriter *lex_writer = (LexiconWriter*)SegWriter_Fetch(
+                                    writer, VTable_Get_Name(LEXICONWRITER));
     UNUSED_VAR(self);
     if (!lex_writer) {
         THROW(ERR, "Can't fetch a LexiconWriter");
     }
     else {
-        PostingListWriter *plist_writer = PListWriter_new(schema, snapshot,
-            segment, polyreader, lex_writer);
-        SegWriter_Register(writer, VTable_Get_Name(POSTINGLISTWRITER), 
-            (DataWriter*)plist_writer);
+        PostingListWriter *plist_writer
+            = PListWriter_new(schema, snapshot, segment, polyreader,
+                              lex_writer);
+        SegWriter_Register(writer, VTable_Get_Name(POSTINGLISTWRITER),
+                           (DataWriter*)plist_writer);
         SegWriter_Add_Writer(writer, (DataWriter*)INCREF(plist_writer));
     }
 }
 
 void
-Arch_register_doc_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_doc_writer(Architecture *self, SegWriter *writer) {
     Schema     *schema     = SegWriter_Get_Schema(writer);
     Snapshot   *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment    *segment    = SegWriter_Get_Segment(writer);
     PolyReader *polyreader = SegWriter_Get_PolyReader(writer);
-    DocWriter  *doc_writer 
+    DocWriter  *doc_writer
         = DocWriter_new(schema, snapshot, segment, polyreader);
     UNUSED_VAR(self);
-    SegWriter_Register(writer, VTable_Get_Name(DOCWRITER), 
-        (DataWriter*)doc_writer);
+    SegWriter_Register(writer, VTable_Get_Name(DOCWRITER),
+                       (DataWriter*)doc_writer);
     SegWriter_Add_Writer(writer, (DataWriter*)INCREF(doc_writer));
 }
 
 void
-Arch_register_sort_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_sort_writer(Architecture *self, SegWriter *writer) {
     Schema     *schema     = SegWriter_Get_Schema(writer);
     Snapshot   *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment    *segment    = SegWriter_Get_Segment(writer);
     PolyReader *polyreader = SegWriter_Get_PolyReader(writer);
-    SortWriter *sort_writer 
+    SortWriter *sort_writer
         = SortWriter_new(schema, snapshot, segment, polyreader);
     UNUSED_VAR(self);
-    SegWriter_Register(writer, VTable_Get_Name(SORTWRITER), 
-        (DataWriter*)sort_writer);
+    SegWriter_Register(writer, VTable_Get_Name(SORTWRITER),
+                       (DataWriter*)sort_writer);
     SegWriter_Add_Writer(writer, (DataWriter*)INCREF(sort_writer));
 }
 
 void
-Arch_register_highlight_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_highlight_writer(Architecture *self, SegWriter *writer) {
     Schema     *schema     = SegWriter_Get_Schema(writer);
     Snapshot   *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment    *segment    = SegWriter_Get_Segment(writer);
@@ -148,29 +140,27 @@ Arch_register_highlight_writer(Architect
     HighlightWriter *hl_writer
         = HLWriter_new(schema, snapshot, segment, polyreader);
     UNUSED_VAR(self);
-    SegWriter_Register(writer, VTable_Get_Name(HIGHLIGHTWRITER), 
-        (DataWriter*)hl_writer);
+    SegWriter_Register(writer, VTable_Get_Name(HIGHLIGHTWRITER),
+                       (DataWriter*)hl_writer);
     SegWriter_Add_Writer(writer, (DataWriter*)INCREF(hl_writer));
 }
 
 void
-Arch_register_deletions_writer(Architecture *self, SegWriter *writer)
-{
+Arch_register_deletions_writer(Architecture *self, SegWriter *writer) {
     Schema     *schema     = SegWriter_Get_Schema(writer);
     Snapshot   *snapshot   = SegWriter_Get_Snapshot(writer);
     Segment    *segment    = SegWriter_Get_Segment(writer);
     PolyReader *polyreader = SegWriter_Get_PolyReader(writer);
-    DefaultDeletionsWriter *del_writer 
+    DefaultDeletionsWriter *del_writer
         = DefDelWriter_new(schema, snapshot, segment, polyreader);
     UNUSED_VAR(self);
-    SegWriter_Register(writer, VTable_Get_Name(DELETIONSWRITER), 
-        (DataWriter*)del_writer);
+    SegWriter_Register(writer, VTable_Get_Name(DELETIONSWRITER),
+                       (DataWriter*)del_writer);
     SegWriter_Set_Del_Writer(writer, (DeletionsWriter*)del_writer);
 }
 
 void
-Arch_init_seg_reader(Architecture *self, SegReader *reader)
-{
+Arch_init_seg_reader(Architecture *self, SegReader *reader) {
     Arch_Register_Doc_Reader(self, reader);
     Arch_Register_Lexicon_Reader(self, reader);
     Arch_Register_Posting_List_Reader(self, reader);
@@ -180,70 +170,66 @@ Arch_init_seg_reader(Architecture *self,
 }
 
 void
-Arch_register_doc_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_doc_reader(Architecture *self, SegReader *reader) {
     Schema     *schema   = SegReader_Get_Schema(reader);
     Folder     *folder   = SegReader_Get_Folder(reader);
     VArray     *segments = SegReader_Get_Segments(reader);
     Snapshot   *snapshot = SegReader_Get_Snapshot(reader);
     int32_t     seg_tick = SegReader_Get_Seg_Tick(reader);
-    DefaultDocReader *doc_reader 
+    DefaultDocReader *doc_reader
         = DefDocReader_new(schema, folder, snapshot, segments, seg_tick);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(DOCREADER), 
-        (DataReader*)doc_reader);
+    SegReader_Register(reader, VTable_Get_Name(DOCREADER),
+                       (DataReader*)doc_reader);
 }
 
 void
-Arch_register_posting_list_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_posting_list_reader(Architecture *self, SegReader *reader) {
     Schema    *schema   = SegReader_Get_Schema(reader);
     Folder    *folder   = SegReader_Get_Folder(reader);
     VArray    *segments = SegReader_Get_Segments(reader);
     Snapshot  *snapshot = SegReader_Get_Snapshot(reader);
     int32_t    seg_tick = SegReader_Get_Seg_Tick(reader);
-    LexiconReader *lex_reader = (LexiconReader*)SegReader_Obtain(reader, 
-        VTable_Get_Name(LEXICONREADER));
-    DefaultPostingListReader *plist_reader = DefPListReader_new(schema, folder, 
-        snapshot, segments, seg_tick, lex_reader);
+    LexiconReader *lex_reader = (LexiconReader*)SegReader_Obtain(
+                                    reader, VTable_Get_Name(LEXICONREADER));
+    DefaultPostingListReader *plist_reader
+        = DefPListReader_new(schema, folder, snapshot, segments, seg_tick,
+                             lex_reader);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(POSTINGLISTREADER), 
-        (DataReader*)plist_reader);
+    SegReader_Register(reader, VTable_Get_Name(POSTINGLISTREADER),
+                       (DataReader*)plist_reader);
 }
 
 void
-Arch_register_lexicon_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_lexicon_reader(Architecture *self, SegReader *reader) {
     Schema    *schema   = SegReader_Get_Schema(reader);
     Folder    *folder   = SegReader_Get_Folder(reader);
     VArray    *segments = SegReader_Get_Segments(reader);
     Snapshot  *snapshot = SegReader_Get_Snapshot(reader);
     int32_t    seg_tick = SegReader_Get_Seg_Tick(reader);
-    DefaultLexiconReader *lex_reader 
+    DefaultLexiconReader *lex_reader
         = DefLexReader_new(schema, folder, snapshot, segments, seg_tick);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(LEXICONREADER), 
-        (DataReader*)lex_reader);
+    SegReader_Register(reader, VTable_Get_Name(LEXICONREADER),
+                       (DataReader*)lex_reader);
 }
 
 void
-Arch_register_sort_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_sort_reader(Architecture *self, SegReader *reader) {
     Schema     *schema   = SegReader_Get_Schema(reader);
     Folder     *folder   = SegReader_Get_Folder(reader);
     VArray     *segments = SegReader_Get_Segments(reader);
     Snapshot   *snapshot = SegReader_Get_Snapshot(reader);
     int32_t     seg_tick = SegReader_Get_Seg_Tick(reader);
-    DefaultSortReader *sort_reader 
+    DefaultSortReader *sort_reader
         = DefSortReader_new(schema, folder, snapshot, segments, seg_tick);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(SORTREADER), 
-        (DataReader*)sort_reader);
+    SegReader_Register(reader, VTable_Get_Name(SORTREADER),
+                       (DataReader*)sort_reader);
 }
 
 void
-Arch_register_highlight_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_highlight_reader(Architecture *self, SegReader *reader) {
     Schema     *schema   = SegReader_Get_Schema(reader);
     Folder     *folder   = SegReader_Get_Folder(reader);
     VArray     *segments = SegReader_Get_Segments(reader);
@@ -252,13 +238,12 @@ Arch_register_highlight_reader(Architect
     DefaultHighlightReader* hl_reader
         = DefHLReader_new(schema, folder, snapshot, segments, seg_tick);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(HIGHLIGHTREADER), 
-        (DataReader*)hl_reader);
+    SegReader_Register(reader, VTable_Get_Name(HIGHLIGHTREADER),
+                       (DataReader*)hl_reader);
 }
 
 void
-Arch_register_deletions_reader(Architecture *self, SegReader *reader)
-{
+Arch_register_deletions_reader(Architecture *self, SegReader *reader) {
     Schema     *schema   = SegReader_Get_Schema(reader);
     Folder     *folder   = SegReader_Get_Folder(reader);
     VArray     *segments = SegReader_Get_Segments(reader);
@@ -267,27 +252,24 @@ Arch_register_deletions_reader(Architect
     DefaultDeletionsReader* del_reader
         = DefDelReader_new(schema, folder, snapshot, segments, seg_tick);
     UNUSED_VAR(self);
-    SegReader_Register(reader, VTable_Get_Name(DELETIONSREADER), 
-        (DataReader*)del_reader);
+    SegReader_Register(reader, VTable_Get_Name(DELETIONSREADER),
+                       (DataReader*)del_reader);
 }
 
 Similarity*
-Arch_make_similarity(Architecture *self)
-{
+Arch_make_similarity(Architecture *self) {
     UNUSED_VAR(self);
     return Sim_new();
 }
 
 int32_t
-Arch_index_interval(Architecture *self) 
-{
+Arch_index_interval(Architecture *self) {
     UNUSED_VAR(self);
     return 128;
 }
 
 int32_t
-Arch_skip_interval(Architecture *self) 
-{
+Arch_skip_interval(Architecture *self) {
     UNUSED_VAR(self);
     return 16;
 }

Modified: incubator/lucy/trunk/core/Lucy/Plan/Architecture.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/Architecture.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/Architecture.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/Architecture.cfh Sun May  1 23:50:24 2011
@@ -147,13 +147,13 @@ class Lucy::Plan::Architecture cnick Arc
     public int32_t
     Index_Interval(Architecture *self);
 
-    public int32_t 
+    public int32_t
     Skip_Interval(Architecture *self);
 
     /** Returns true for any Architecture object. Subclasses should override
      * this weak check.
      */
-    public bool_t 
+    public bool_t
     Equals(Architecture *self, Obj *other);
 }
 

Modified: incubator/lucy/trunk/core/Lucy/Plan/BlobType.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/BlobType.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/BlobType.c (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/BlobType.c Sun May  1 23:50:24 2011
@@ -20,51 +20,44 @@
 #include "Lucy/Plan/BlobType.h"
 
 BlobType*
-BlobType_new(bool_t stored)
-{
+BlobType_new(bool_t stored) {
     BlobType *self = (BlobType*)VTable_Make_Obj(BLOBTYPE);
     return BlobType_init(self, stored);
 }
 
 BlobType*
-BlobType_init(BlobType *self, bool_t stored)
-{
+BlobType_init(BlobType *self, bool_t stored) {
     FType_init((FieldType*)self);
     self->stored = stored;
     return self;
 }
 
 bool_t
-BlobType_binary(BlobType *self)
-{
+BlobType_binary(BlobType *self) {
     UNUSED_VAR(self);
     return true;
 }
 
 void
-BlobType_set_sortable(BlobType *self, bool_t sortable)
-{
+BlobType_set_sortable(BlobType *self, bool_t sortable) {
     UNUSED_VAR(self);
     if (sortable) { THROW(ERR, "BlobType fields can't be sortable"); }
 }
 
 ViewByteBuf*
-BlobType_make_blank(BlobType *self)
-{
+BlobType_make_blank(BlobType *self) {
     UNUSED_VAR(self);
     return ViewBB_new(NULL, 0);
 }
 
 int8_t
-BlobType_primitive_id(BlobType *self)
-{
+BlobType_primitive_id(BlobType *self) {
     UNUSED_VAR(self);
     return FType_BLOB;
 }
 
 bool_t
-BlobType_equals(BlobType *self, Obj *other)
-{
+BlobType_equals(BlobType *self, Obj *other) {
     BlobType *twin = (BlobType*)other;
     if (twin == self) return true;
     if (!Obj_Is_A(other, BLOBTYPE)) return false;
@@ -72,8 +65,7 @@ BlobType_equals(BlobType *self, Obj *oth
 }
 
 Hash*
-BlobType_dump_for_schema(BlobType *self) 
-{
+BlobType_dump_for_schema(BlobType *self) {
     Hash *dump = Hash_new(0);
     Hash_Store_Str(dump, "type", 4, (Obj*)CB_newf("blob"));
 
@@ -93,24 +85,22 @@ BlobType_dump_for_schema(BlobType *self)
 }
 
 Hash*
-BlobType_dump(BlobType *self)
-{
+BlobType_dump(BlobType *self) {
     Hash *dump = BlobType_Dump_For_Schema(self);
-    Hash_Store_Str(dump, "_class", 6, 
-        (Obj*)CB_Clone(BlobType_Get_Class_Name(self)));
+    Hash_Store_Str(dump, "_class", 6,
+                   (Obj*)CB_Clone(BlobType_Get_Class_Name(self)));
     DECREF(Hash_Delete_Str(dump, "type", 4));
     return dump;
 }
 
 BlobType*
-BlobType_load(BlobType *self, Obj *dump)
-{
+BlobType_load(BlobType *self, Obj *dump) {
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
-    VTable *vtable 
-        = (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF)) 
-        ? VTable_singleton(class_name, NULL)
-        : BLOBTYPE;
+    VTable *vtable
+        = (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF))
+          ? VTable_singleton(class_name, NULL)
+          : BLOBTYPE;
     BlobType *loaded     = (BlobType*)VTable_Make_Obj(vtable);
     Obj *boost_dump      = Hash_Fetch_Str(source, "boost", 5);
     Obj *indexed_dump    = Hash_Fetch_Str(source, "indexed", 7);

Modified: incubator/lucy/trunk/core/Lucy/Plan/BlobType.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/BlobType.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/BlobType.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/BlobType.cfh Sun May  1 23:50:24 2011
@@ -21,16 +21,16 @@ parcel Lucy;
  * BlobType is an implementation of FieldType tuned for use with fields
  * containing binary data, which cannot be indexed or searched -- only stored.
  */
-class Lucy::Plan::BlobType inherits Lucy::Plan::FieldType 
+class Lucy::Plan::BlobType inherits Lucy::Plan::FieldType
     : dumpable {
 
     /**
      * @param stored boolean indicating whether the field should be stored.
      */
-    public inert BlobType* 
+    public inert BlobType*
     init(BlobType *self, bool_t stored);
 
-    public inert incremented BlobType* 
+    public inert incremented BlobType*
     new(bool_t stored);
 
     /** Returns true.

Modified: incubator/lucy/trunk/core/Lucy/Plan/FieldType.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/FieldType.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/FieldType.c (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/FieldType.c Sun May  1 23:50:24 2011
@@ -23,15 +23,13 @@
 #include "Lucy/Index/Similarity.h"
 
 FieldType*
-FType_init(FieldType *self)
-{
+FType_init(FieldType *self) {
     return FType_init2(self, 1.0f, false, false, false);
 }
 
 FieldType*
 FType_init2(FieldType *self, float boost, bool_t indexed, bool_t stored,
-            bool_t sortable)
-{
+            bool_t sortable) {
     self->boost              = boost;
     self->indexed            = indexed;
     self->stored             = stored;
@@ -41,50 +39,65 @@ FType_init2(FieldType *self, float boost
 }
 
 void
-FType_set_boost(FieldType *self, float boost) 
-    { self->boost = boost; }
+FType_set_boost(FieldType *self, float boost) {
+    self->boost = boost;
+}
+
 void
-FType_set_indexed(FieldType *self, bool_t indexed) 
-    { self->indexed = !!indexed; }
+FType_set_indexed(FieldType *self, bool_t indexed) {
+    self->indexed = !!indexed;
+}
+
 void
-FType_set_stored(FieldType *self, bool_t stored) 
-    { self->stored = !!stored; }
+FType_set_stored(FieldType *self, bool_t stored) {
+    self->stored = !!stored;
+}
+
 void
-FType_set_sortable(FieldType *self, bool_t sortable) 
-    { self->sortable = !!sortable; }
+FType_set_sortable(FieldType *self, bool_t sortable) {
+    self->sortable = !!sortable;
+}
 
 float
-FType_get_boost(FieldType *self)  { return self->boost; }
+FType_get_boost(FieldType *self) {
+    return self->boost;
+}
+
 bool_t
-FType_indexed(FieldType *self)    { return self->indexed; }
+FType_indexed(FieldType *self) {
+    return self->indexed;
+}
+
 bool_t
-FType_stored(FieldType *self)     { return self->stored; }
+FType_stored(FieldType *self) {
+    return self->stored;
+}
+
 bool_t
-FType_sortable(FieldType *self)   { return self->sortable; }
+FType_sortable(FieldType *self) {
+    return self->sortable;
+}
 
 bool_t
-FType_binary(FieldType *self) { 
-    UNUSED_VAR(self); 
-    return false; 
+FType_binary(FieldType *self) {
+    UNUSED_VAR(self);
+    return false;
 }
 
 Similarity*
-FType_similarity(FieldType *self)
-{
+FType_similarity(FieldType *self) {
     UNUSED_VAR(self);
     return NULL;
 }
 
 int32_t
-FType_compare_values(FieldType *self, Obj *a, Obj *b)
-{
+FType_compare_values(FieldType *self, Obj *a, Obj *b) {
     UNUSED_VAR(self);
     return Obj_Compare_To(a, b);
 }
 
 bool_t
-FType_equals(FieldType *self, Obj *other)
-{
+FType_equals(FieldType *self, Obj *other) {
     FieldType *twin = (FieldType*)other;
     if (twin == self) return true;
     if (FType_Get_VTable(self) != FType_Get_VTable(twin)) return false;

Modified: incubator/lucy/trunk/core/Lucy/Plan/FieldType.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/FieldType.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/FieldType.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/FieldType.cfh Sun May  1 23:50:24 2011
@@ -69,7 +69,7 @@ __END_C__
  * and scoring behavior for the field.  It is required if the field is
  * <code>indexed</code>.
  */
-abstract class Lucy::Plan::FieldType cnick FType 
+abstract class Lucy::Plan::FieldType cnick FType
     inherits Lucy::Object::Obj {
 
     float         boost;
@@ -77,11 +77,11 @@ abstract class Lucy::Plan::FieldType cni
     bool_t        stored;
     bool_t        sortable;
 
-    inert FieldType* 
+    inert FieldType*
     init(FieldType *self);
 
-    inert FieldType* 
-    init2(FieldType *self, float boost = 1.0, bool_t indexed = false, 
+    inert FieldType*
+    init2(FieldType *self, float boost = 1.0, bool_t indexed = false,
           bool_t stored = false, bool_t sortable = false);
 
     /** Setter for <code>boost</code>.
@@ -168,9 +168,8 @@ abstract class Lucy::Plan::FieldType cni
 __C__
 
 static CHY_INLINE int32_t
-lucy_FType_null_back_compare_values(lucy_FieldType *self, 
-                                    lucy_Obj *a, lucy_Obj *b)
-{
+lucy_FType_null_back_compare_values(lucy_FieldType *self,
+                                    lucy_Obj *a, lucy_Obj *b) {
     if (a == NULL) {
         if (b == NULL) { return 0; }
         else { return 1; }

Modified: incubator/lucy/trunk/core/Lucy/Plan/FullTextType.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/FullTextType.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/FullTextType.c (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/FullTextType.c Sun May  1 23:50:24 2011
@@ -23,23 +23,20 @@
 #include "Lucy/Index/Similarity.h"
 
 FullTextType*
-FullTextType_new(Analyzer *analyzer)
-{
+FullTextType_new(Analyzer *analyzer) {
     FullTextType *self = (FullTextType*)VTable_Make_Obj(FULLTEXTTYPE);
     return FullTextType_init(self, analyzer);
 }
 
 FullTextType*
-FullTextType_init(FullTextType *self, Analyzer *analyzer)
-{
+FullTextType_init(FullTextType *self, Analyzer *analyzer) {
     return FullTextType_init2(self, analyzer, 1.0, true, true, false, false);
 }
 
 FullTextType*
 FullTextType_init2(FullTextType *self, Analyzer *analyzer, float boost,
-                   bool_t indexed, bool_t stored, bool_t sortable, 
-                   bool_t highlightable)
-{
+                   bool_t indexed, bool_t stored, bool_t sortable,
+                   bool_t highlightable) {
     FType_init((FieldType*)self);
 
     /* Assign */
@@ -54,15 +51,13 @@ FullTextType_init2(FullTextType *self, A
 }
 
 void
-FullTextType_destroy(FullTextType *self)
-{
+FullTextType_destroy(FullTextType *self) {
     DECREF(self->analyzer);
     SUPER_DESTROY(self, FULLTEXTTYPE);
 }
 
 bool_t
-FullTextType_equals(FullTextType *self, Obj *other)
-{
+FullTextType_equals(FullTextType *self, Obj *other) {
     FullTextType *twin = (FullTextType*)other;
     if (twin == self) return true;
     if (!Obj_Is_A(other, FULLTEXTTYPE)) return false;
@@ -76,8 +71,7 @@ FullTextType_equals(FullTextType *self, 
 }
 
 Hash*
-FullTextType_dump_for_schema(FullTextType *self) 
-{
+FullTextType_dump_for_schema(FullTextType *self) {
     Hash *dump = Hash_new(0);
     Hash_Store_Str(dump, "type", 4, (Obj*)CB_newf("fulltext"));
 
@@ -102,28 +96,26 @@ FullTextType_dump_for_schema(FullTextTyp
 }
 
 Hash*
-FullTextType_dump(FullTextType *self)
-{
+FullTextType_dump(FullTextType *self) {
     Hash *dump = FullTextType_Dump_For_Schema(self);
-    Hash_Store_Str(dump, "_class", 6, 
-        (Obj*)CB_Clone(FullTextType_Get_Class_Name(self)));
-    Hash_Store_Str(dump, "analyzer", 8, 
-        (Obj*)Analyzer_Dump(self->analyzer));
+    Hash_Store_Str(dump, "_class", 6,
+                   (Obj*)CB_Clone(FullTextType_Get_Class_Name(self)));
+    Hash_Store_Str(dump, "analyzer", 8,
+                   (Obj*)Analyzer_Dump(self->analyzer));
     DECREF(Hash_Delete_Str(dump, "type", 4));
-    
+
     return dump;
 }
 
 FullTextType*
-FullTextType_load(FullTextType *self, Obj *dump)
-{
+FullTextType_load(FullTextType *self, Obj *dump) {
     UNUSED_VAR(self);
     Hash *source = (Hash*)CERTIFY(dump, HASH);
     CharBuf *class_name = (CharBuf*)Hash_Fetch_Str(source, "_class", 6);
-    VTable *vtable 
-        = (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF)) 
-        ? VTable_singleton(class_name, NULL)
-        : FULLTEXTTYPE;
+    VTable *vtable
+        = (class_name != NULL && Obj_Is_A((Obj*)class_name, CHARBUF))
+          ? VTable_singleton(class_name, NULL)
+          : FULLTEXTTYPE;
     FullTextType *loaded = (FullTextType*)VTable_Make_Obj(vtable);
 
     // Extract boost.
@@ -166,17 +158,22 @@ FullTextType_load(FullTextType *self, Ob
 }
 
 void
-FullTextType_set_highlightable(FullTextType *self, bool_t highlightable)
-    { self->highlightable = highlightable; }
+FullTextType_set_highlightable(FullTextType *self, bool_t highlightable) {
+    self->highlightable = highlightable;
+}
 
 Analyzer*
-FullTextType_get_analyzer(FullTextType *self)  { return self->analyzer; }
+FullTextType_get_analyzer(FullTextType *self) {
+    return self->analyzer;
+}
+
 bool_t
-FullTextType_highlightable(FullTextType *self) { return self->highlightable; }
+FullTextType_highlightable(FullTextType *self) {
+    return self->highlightable;
+}
 
 Similarity*
-FullTextType_make_similarity(FullTextType *self)
-{
+FullTextType_make_similarity(FullTextType *self) {
     UNUSED_VAR(self);
     return Sim_new();
 }

Modified: incubator/lucy/trunk/core/Lucy/Plan/FullTextType.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/FullTextType.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/FullTextType.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/FullTextType.cfh Sun May  1 23:50:24 2011
@@ -28,7 +28,7 @@ parcel Lucy;
  * For an exact-match, single value field type using character data, see
  * L<StringType|Lucy::Plan::StringType>.
  */
-class Lucy::Plan::FullTextType 
+class Lucy::Plan::FullTextType
     inherits Lucy::Plan::TextType : dumpable {
 
     bool_t      highlightable;
@@ -43,15 +43,15 @@ class Lucy::Plan::FullTextType 
      * @param highlightable boolean indicating whether the field should be
      * highlightable.
      */
-    public inert FullTextType* 
+    public inert FullTextType*
     init(FullTextType *self, Analyzer *analyzer);
 
-    inert FullTextType* 
+    inert FullTextType*
     init2(FullTextType *self, Analyzer *analyzer, float boost = 1.0,
-          bool_t indexed = true, bool_t stored = true, 
+          bool_t indexed = true, bool_t stored = true,
           bool_t sortable = false, bool_t highlightable = false);
 
-    public inert incremented FullTextType* 
+    public inert incremented FullTextType*
     new(Analyzer *analyzer);
 
     /** Indicate whether to store data required by

Modified: incubator/lucy/trunk/core/Lucy/Plan/NumericType.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/NumericType.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/NumericType.c (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/NumericType.c Sun May  1 23:50:24 2011
@@ -20,15 +20,13 @@
 #include "Lucy/Plan/NumericType.h"
 
 NumericType*
-NumType_init(NumericType *self)
-{
+NumType_init(NumericType *self) {
     return NumType_init2(self, 1.0, true, true, false);
 }
 
 NumericType*
-NumType_init2(NumericType *self, float boost, bool_t indexed, bool_t stored, 
-              bool_t sortable)
-{
+NumType_init2(NumericType *self, float boost, bool_t indexed, bool_t stored,
+              bool_t sortable) {
     FType_init((FieldType*)self);
     self->boost      = boost;
     self->indexed    = indexed;
@@ -38,15 +36,13 @@ NumType_init2(NumericType *self, float b
 }
 
 bool_t
-NumType_binary(NumericType *self)
-{
+NumType_binary(NumericType *self) {
     UNUSED_VAR(self);
     return true;
 }
 
 Hash*
-NumType_dump_for_schema(NumericType *self) 
-{
+NumType_dump_for_schema(NumericType *self) {
     Hash *dump = Hash_new(0);
     Hash_Store_Str(dump, "type", 4, (Obj*)NumType_Specifier(self));
 
@@ -68,18 +64,16 @@ NumType_dump_for_schema(NumericType *sel
 }
 
 Hash*
-NumType_dump(NumericType *self)
-{
+NumType_dump(NumericType *self) {
     Hash *dump = NumType_Dump_For_Schema(self);
-    Hash_Store_Str(dump, "_class", 6, 
-        (Obj*)CB_Clone(NumType_Get_Class_Name(self)));
+    Hash_Store_Str(dump, "_class", 6,
+                   (Obj*)CB_Clone(NumType_Get_Class_Name(self)));
     DECREF(Hash_Delete_Str(dump, "type", 4));
     return dump;
 }
 
 NumericType*
-NumType_load(NumericType *self, Obj *dump)
-{
+NumType_load(NumericType *self, Obj *dump) {
     UNUSED_VAR(self);
     Hash *source = (Hash*)CERTIFY(dump, HASH);
 
@@ -91,17 +85,17 @@ NumType_load(NumericType *self, Obj *dum
         vtable = VTable_singleton(class_name, NULL);
     }
     else if (type_spec != NULL && Obj_Is_A((Obj*)type_spec, CHARBUF)) {
-        if (CB_Equals_Str(type_spec, "i32_t", 5)) { 
-            vtable = INT32TYPE; 
+        if (CB_Equals_Str(type_spec, "i32_t", 5)) {
+            vtable = INT32TYPE;
         }
-        else if (CB_Equals_Str(type_spec, "i64_t", 5)) { 
-            vtable = INT64TYPE; 
+        else if (CB_Equals_Str(type_spec, "i64_t", 5)) {
+            vtable = INT64TYPE;
         }
-        else if (CB_Equals_Str(type_spec, "f32_t", 5)) { 
-            vtable = FLOAT32TYPE; 
+        else if (CB_Equals_Str(type_spec, "f32_t", 5)) {
+            vtable = FLOAT32TYPE;
         }
-        else if (CB_Equals_Str(type_spec, "f64_t", 5)) { 
-            vtable = FLOAT64TYPE; 
+        else if (CB_Equals_Str(type_spec, "f64_t", 5)) {
+            vtable = FLOAT64TYPE;
         }
         else {
             THROW(ERR, "Unrecognized type string: '%o'", type_spec);
@@ -128,192 +122,168 @@ NumType_load(NumericType *self, Obj *dum
 /****************************************************************************/
 
 Float64Type*
-Float64Type_new()
-{
+Float64Type_new() {
     Float64Type *self = (Float64Type*)VTable_Make_Obj(FLOAT64TYPE);
     return Float64Type_init(self);
 }
 
 Float64Type*
-Float64Type_init(Float64Type *self)
-{
+Float64Type_init(Float64Type *self) {
     return Float64Type_init2(self, 1.0, true, true, false);
 }
 
 Float64Type*
-Float64Type_init2(Float64Type *self, float boost, bool_t indexed, 
-                  bool_t stored, bool_t sortable)
-{
-    return (Float64Type*)NumType_init2((NumericType*)self, boost, indexed, 
-        stored, sortable);
+Float64Type_init2(Float64Type *self, float boost, bool_t indexed,
+                  bool_t stored, bool_t sortable) {
+    return (Float64Type*)NumType_init2((NumericType*)self, boost, indexed,
+                                       stored, sortable);
 }
 
 CharBuf*
-Float64Type_specifier(Float64Type *self)
-{
+Float64Type_specifier(Float64Type *self) {
     UNUSED_VAR(self);
     return CB_newf("f64_t");
 }
 
 int8_t
-Float64Type_primitive_id(Float64Type *self)
-{
+Float64Type_primitive_id(Float64Type *self) {
     UNUSED_VAR(self);
     return FType_FLOAT64;
 }
 
 bool_t
-Float64Type_equals(Float64Type *self, Obj *other)
-{
+Float64Type_equals(Float64Type *self, Obj *other) {
     if (self == (Float64Type*)other) { return true; }
     if (!other) { return false; }
     if (!Obj_Is_A(other, FLOAT64TYPE)) { return false; }
-    Float64Type_equals_t super_equals = (Float64Type_equals_t)
-        SUPER_METHOD(FLOAT64TYPE, Float64Type, Equals);
+    Float64Type_equals_t super_equals = (Float64Type_equals_t)SUPER_METHOD(
+                                            FLOAT64TYPE, Float64Type, Equals);
     return super_equals(self, other);
 }
 
 /****************************************************************************/
 
 Float32Type*
-Float32Type_new()
-{
+Float32Type_new() {
     Float32Type *self = (Float32Type*)VTable_Make_Obj(FLOAT32TYPE);
     return Float32Type_init(self);
 }
 
 Float32Type*
-Float32Type_init(Float32Type *self)
-{
+Float32Type_init(Float32Type *self) {
     return Float32Type_init2(self, 1.0, true, true, false);
 }
 
 Float32Type*
-Float32Type_init2(Float32Type *self, float boost, bool_t indexed, 
-                  bool_t stored, bool_t sortable)
-{
-    return (Float32Type*)NumType_init2((NumericType*)self, boost, indexed, 
-        stored, sortable);
+Float32Type_init2(Float32Type *self, float boost, bool_t indexed,
+                  bool_t stored, bool_t sortable) {
+    return (Float32Type*)NumType_init2((NumericType*)self, boost, indexed,
+                                       stored, sortable);
 }
 
 CharBuf*
-Float32Type_specifier(Float32Type *self)
-{
+Float32Type_specifier(Float32Type *self) {
     UNUSED_VAR(self);
     return CB_newf("f32_t");
 }
 
 int8_t
-Float32Type_primitive_id(Float32Type *self)
-{
+Float32Type_primitive_id(Float32Type *self) {
     UNUSED_VAR(self);
     return FType_FLOAT32;
 }
 
 bool_t
-Float32Type_equals(Float32Type *self, Obj *other)
-{
+Float32Type_equals(Float32Type *self, Obj *other) {
     if (self == (Float32Type*)other) { return true; }
     if (!other) { return false; }
     if (!Obj_Is_A(other, FLOAT32TYPE)) { return false; }
-    Float32Type_equals_t super_equals = (Float32Type_equals_t)
-        SUPER_METHOD(FLOAT32TYPE, Float32Type, Equals);
+    Float32Type_equals_t super_equals = (Float32Type_equals_t)SUPER_METHOD(
+                                            FLOAT32TYPE, Float32Type, Equals);
     return super_equals(self, other);
 }
 
 /****************************************************************************/
 
 Int32Type*
-Int32Type_new()
-{
+Int32Type_new() {
     Int32Type *self = (Int32Type*)VTable_Make_Obj(INT32TYPE);
     return Int32Type_init(self);
 }
 
 Int32Type*
-Int32Type_init(Int32Type *self)
-{
+Int32Type_init(Int32Type *self) {
     return Int32Type_init2(self, 1.0, true, true, false);
 }
 
 Int32Type*
-Int32Type_init2(Int32Type *self, float boost, bool_t indexed, 
-                bool_t stored, bool_t sortable)
-{
-    return (Int32Type*)NumType_init2((NumericType*)self, boost, indexed, 
-        stored, sortable);
+Int32Type_init2(Int32Type *self, float boost, bool_t indexed,
+                bool_t stored, bool_t sortable) {
+    return (Int32Type*)NumType_init2((NumericType*)self, boost, indexed,
+                                     stored, sortable);
 }
 
 CharBuf*
-Int32Type_specifier(Int32Type *self)
-{
+Int32Type_specifier(Int32Type *self) {
     UNUSED_VAR(self);
     return CB_newf("i32_t");
 }
 
 int8_t
-Int32Type_primitive_id(Int32Type *self)
-{
+Int32Type_primitive_id(Int32Type *self) {
     UNUSED_VAR(self);
     return FType_INT32;
 }
 
 bool_t
-Int32Type_equals(Int32Type *self, Obj *other)
-{
+Int32Type_equals(Int32Type *self, Obj *other) {
     if (self == (Int32Type*)other) { return true; }
     if (!other) { return false; }
     if (!Obj_Is_A(other, INT32TYPE)) { return false; }
-    Int32Type_equals_t super_equals = (Int32Type_equals_t)
-        SUPER_METHOD(INT32TYPE, Int32Type, Equals);
+    Int32Type_equals_t super_equals = (Int32Type_equals_t)SUPER_METHOD(
+                                          INT32TYPE, Int32Type, Equals);
     return super_equals(self, other);
 }
 
 /****************************************************************************/
 
 Int64Type*
-Int64Type_new()
-{
+Int64Type_new() {
     Int64Type *self = (Int64Type*)VTable_Make_Obj(INT64TYPE);
     return Int64Type_init(self);
 }
 
 Int64Type*
-Int64Type_init(Int64Type *self)
-{
+Int64Type_init(Int64Type *self) {
     return Int64Type_init2(self, 1.0, true, true, false);
 }
 
 Int64Type*
-Int64Type_init2(Int64Type *self, float boost, bool_t indexed, 
-                bool_t stored, bool_t sortable)
-{
-    return (Int64Type*)NumType_init2((NumericType*)self, boost, indexed, 
-        stored, sortable);
+Int64Type_init2(Int64Type *self, float boost, bool_t indexed,
+                bool_t stored, bool_t sortable) {
+    return (Int64Type*)NumType_init2((NumericType*)self, boost, indexed,
+                                     stored, sortable);
 }
 
 CharBuf*
-Int64Type_specifier(Int64Type *self)
-{
+Int64Type_specifier(Int64Type *self) {
     UNUSED_VAR(self);
     return CB_newf("i64_t");
 }
 
 int8_t
-Int64Type_primitive_id(Int64Type *self)
-{
+Int64Type_primitive_id(Int64Type *self) {
     UNUSED_VAR(self);
     return FType_INT64;
 }
 
 bool_t
-Int64Type_equals(Int64Type *self, Obj *other)
-{
+Int64Type_equals(Int64Type *self, Obj *other) {
     if (self == (Int64Type*)other) { return true; }
     if (!other) { return false; }
     if (!Obj_Is_A(other, INT64TYPE)) { return false; }
-    Int64Type_equals_t super_equals = (Int64Type_equals_t)
-        SUPER_METHOD(INT64TYPE, Int64Type, Equals);
+    Int64Type_equals_t super_equals = (Int64Type_equals_t)SUPER_METHOD(
+                                          INT64TYPE, Int64Type, Equals);
     return super_equals(self, other);
 }
 

Modified: incubator/lucy/trunk/core/Lucy/Plan/NumericType.cfh
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/core/Lucy/Plan/NumericType.cfh?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/core/Lucy/Plan/NumericType.cfh (original)
+++ incubator/lucy/trunk/core/Lucy/Plan/NumericType.cfh Sun May  1 23:50:24 2011
@@ -16,14 +16,14 @@
 
 parcel Lucy;
 
-class Lucy::Plan::NumericType cnick NumType 
+class Lucy::Plan::NumericType cnick NumType
     inherits Lucy::Plan::FieldType : dumpable {
 
-    public inert NumericType* 
+    public inert NumericType*
     init(NumericType *self);
 
-    inert NumericType* 
-    init2(NumericType *self, float boost = 1.0, bool_t indexed = true, 
+    inert NumericType*
+    init2(NumericType *self, float boost = 1.0, bool_t indexed = true,
           bool_t stored = true, bool_t sortable = false);
 
     /** Returns true.
@@ -47,20 +47,20 @@ class Lucy::Plan::NumericType cnick NumT
     Load(NumericType *self, Obj *dump);
 }
 
-abstract class Lucy::Plan::FloatType 
+abstract class Lucy::Plan::FloatType
     inherits Lucy::Plan::NumericType : dumpable { }
 
-class Lucy::Plan::Float64Type 
+class Lucy::Plan::Float64Type
     inherits Lucy::Plan::FloatType : dumpable {
 
-    public inert Float64Type* 
+    public inert Float64Type*
     new();
 
-    public inert Float64Type* 
+    public inert Float64Type*
     init(Float64Type *self);
 
-    inert Float64Type* 
-    init2(Float64Type *self, float boost = 1.0, bool_t indexed = true, 
+    inert Float64Type*
+    init2(Float64Type *self, float boost = 1.0, bool_t indexed = true,
           bool_t stored = true, bool_t sortable = true);
 
     int8_t
@@ -73,17 +73,17 @@ class Lucy::Plan::Float64Type 
     Equals(Float64Type *self, Obj *other);
 }
 
-class Lucy::Plan::Float32Type 
+class Lucy::Plan::Float32Type
     inherits Lucy::Plan::FloatType : dumpable {
 
-    public inert Float32Type* 
+    public inert Float32Type*
     new();
 
-    public inert Float32Type* 
+    public inert Float32Type*
     init(Float32Type *self);
 
-    inert Float32Type* 
-    init2(Float32Type *self, float boost = 1.0, bool_t indexed = true, 
+    inert Float32Type*
+    init2(Float32Type *self, float boost = 1.0, bool_t indexed = true,
           bool_t stored = true, bool_t sortable = false);
 
     int8_t
@@ -96,20 +96,20 @@ class Lucy::Plan::Float32Type 
     Equals(Float32Type *self, Obj *other);
 }
 
-abstract class Lucy::Plan::IntType 
+abstract class Lucy::Plan::IntType
     inherits Lucy::Plan::NumericType : dumpable { }
 
-class Lucy::Plan::Int32Type 
+class Lucy::Plan::Int32Type
     inherits Lucy::Plan::IntType : dumpable {
 
-    public inert Int32Type* 
+    public inert Int32Type*
     new();
 
-    public inert Int32Type* 
+    public inert Int32Type*
     init(Int32Type *self);
 
-    inert Int32Type* 
-    init2(Int32Type *self, float boost = 1.0, bool_t indexed = true, 
+    inert Int32Type*
+    init2(Int32Type *self, float boost = 1.0, bool_t indexed = true,
           bool_t stored = true, bool_t sortable = false);
 
     int8_t
@@ -122,17 +122,17 @@ class Lucy::Plan::Int32Type 
     Equals(Int32Type *self, Obj *other);
 }
 
-class Lucy::Plan::Int64Type 
+class Lucy::Plan::Int64Type
     inherits Lucy::Plan::IntType : dumpable {
 
-    public inert Int64Type* 
+    public inert Int64Type*
     new();
 
-    public inert Int64Type* 
+    public inert Int64Type*
     init(Int64Type *self);
 
-    inert Int64Type* 
-    init2(Int64Type *self, float boost = 1.0, bool_t indexed = true, 
+    inert Int64Type*
+    init2(Int64Type *self, float boost = 1.0, bool_t indexed = true,
           bool_t stored = true, bool_t sortable = false);
 
     int8_t



Mime
View raw message