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 [3/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/ clo...
Date Sun, 01 May 2011 23:50:38 GMT
Modified: incubator/lucy/trunk/clownfish/src/CFCClass.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCClass.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCClass.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCClass.c Sun May  1 23:50:24 2011
@@ -104,31 +104,29 @@ static void
 S_bequeath_methods(CFCClass *self);
 
 CFCClass*
-CFCClass_create(struct CFCParcel *parcel, const char *exposure, 
-                const char *class_name, const char *cnick, 
-                const char *micro_sym, CFCDocuComment *docucomment, 
-                const char *source_class, const char *parent_class_name, 
-                int is_final, int is_inert)
-{
+CFCClass_create(struct CFCParcel *parcel, const char *exposure,
+                const char *class_name, const char *cnick,
+                const char *micro_sym, CFCDocuComment *docucomment,
+                const char *source_class, const char *parent_class_name,
+                int is_final, int is_inert) {
     CFCClass *self = (CFCClass*)CFCBase_allocate(sizeof(CFCClass),
-        "Clownfish::Class");
+                                                 "Clownfish::Class");
     return CFCClass_do_create(self, parcel, exposure, class_name, cnick,
-        micro_sym, docucomment, source_class, parent_class_name, is_final, 
-        is_inert);
+                              micro_sym, docucomment, source_class,
+                              parent_class_name, is_final, is_inert);
 }
 
 CFCClass*
-CFCClass_do_create(CFCClass *self, struct CFCParcel *parcel, 
-                   const char *exposure, const char *class_name, 
-                   const char *cnick, const char *micro_sym, 
-                   CFCDocuComment *docucomment, const char *source_class, 
-                   const char *parent_class_name, int is_final, int is_inert)
-{
+CFCClass_do_create(CFCClass *self, struct CFCParcel *parcel,
+                   const char *exposure, const char *class_name,
+                   const char *cnick, const char *micro_sym,
+                   CFCDocuComment *docucomment, const char *source_class,
+                   const char *parent_class_name, int is_final, int is_inert) {
     CFCUTIL_NULL_CHECK(class_name);
     exposure  = exposure  ? exposure  : "parcel";
     micro_sym = micro_sym ? micro_sym : "class";
-    CFCSymbol_init((CFCSymbol*)self, parcel, exposure, class_name, cnick, 
-        micro_sym);
+    CFCSymbol_init((CFCSymbol*)self, parcel, exposure, class_name, cnick,
+                   micro_sym);
     self->parent     = NULL;
     self->tree_grown = false;
     self->autocode   = (char*)CALLOCATE(1, sizeof(char));
@@ -145,19 +143,19 @@ CFCClass_do_create(CFCClass *self, struc
     self->attributes      = (CFCClassAttribute**)CALLOCATE(1, sizeof(CFCClassAttribute*));
     self->num_attributes  = 0;
     self->parent_class_name = CFCUtil_strdup(parent_class_name);
-    self->docucomment 
+    self->docucomment
         = (CFCDocuComment*)CFCBase_incref((CFCBase*)docucomment);
 
     // Assume that Foo::Bar should be found in Foo/Bar.h.
-    self->source_class = source_class 
-                       ? CFCUtil_strdup(source_class)
-                       : CFCUtil_strdup(class_name);
+    self->source_class = source_class
+                         ? CFCUtil_strdup(source_class)
+                         : CFCUtil_strdup(class_name);
 
     // Cache several derived symbols.
     const char *last_colon = strrchr(class_name, ':');
-    self->struct_sym = last_colon 
-                     ? CFCUtil_strdup(last_colon + 1)
-                     : CFCUtil_strdup(class_name);
+    self->struct_sym = last_colon
+                       ? CFCUtil_strdup(last_colon + 1)
+                       : CFCUtil_strdup(class_name);
     const char *prefix = CFCSymbol_get_prefix((CFCSymbol*)self);
     size_t prefix_len = strlen(prefix);
     size_t struct_sym_len = strlen(self->struct_sym);
@@ -171,7 +169,7 @@ CFCClass_do_create(CFCClass *self, struc
     }
     self->short_vtable_var[struct_sym_len] = '\0';
     int check = sprintf(self->full_struct_sym, "%s%s", prefix,
-        self->struct_sym);
+                        self->struct_sym);
     if (check < 0) { croak("sprintf failed"); }
     for (i = 0; self->full_struct_sym[i] != '\0'; i++) {
         self->full_vtable_var[i] = toupper(self->full_struct_sym[i]);
@@ -206,8 +204,7 @@ CFCClass_do_create(CFCClass *self, struc
 }
 
 void
-CFCClass_destroy(CFCClass *self)
-{
+CFCClass_destroy(CFCClass *self) {
     CFCBase_decref((CFCBase*)self->docucomment);
     CFCBase_decref((CFCBase*)self->parent);
     size_t i;
@@ -250,12 +247,12 @@ CFCClass_destroy(CFCClass *self)
 }
 
 void
-CFCClass_register(CFCClass *self)
-{
+CFCClass_register(CFCClass *self) {
     if (registry_size == registry_cap) {
         size_t new_cap = registry_cap + 10;
-        registry = (CFCClassRegEntry*)REALLOCATE(registry,
-            (new_cap + 1) * sizeof(CFCClassRegEntry));
+        registry = (CFCClassRegEntry*)REALLOCATE(
+                       registry,
+                       (new_cap + 1) * sizeof(CFCClassRegEntry));
         size_t i;
         for (i = registry_cap; i <= new_cap; i++) {
             registry[i].key = NULL;
@@ -268,9 +265,9 @@ CFCClass_register(CFCClass *self)
     CFCClass *existing = CFCClass_fetch_singleton(parcel, class_name);
     const char *key = self->full_struct_sym;
     if (existing) {
-        croak("New class %s conflicts with existing class %s", 
-             CFCSymbol_get_class_name((CFCSymbol*)self),
-             CFCSymbol_get_class_name((CFCSymbol*)existing));
+        croak("New class %s conflicts with existing class %s",
+              CFCSymbol_get_class_name((CFCSymbol*)self),
+              CFCSymbol_get_class_name((CFCSymbol*)existing));
     }
     registry[registry_size].key   = CFCUtil_strdup(key);
     registry[registry_size].klass = (CFCClass*)CFCBase_incref((CFCBase*)self);
@@ -278,15 +275,14 @@ CFCClass_register(CFCClass *self)
 }
 
 CFCClass*
-CFCClass_fetch_singleton(CFCParcel *parcel, const char *class_name)
-{
+CFCClass_fetch_singleton(CFCParcel *parcel, const char *class_name) {
     CFCUTIL_NULL_CHECK(class_name);
 
     // Build up the key.
     const char *last_colon = strrchr(class_name, ':');
-    const char *struct_sym = last_colon 
-                           ? last_colon + 1
-                           : class_name;
+    const char *struct_sym = last_colon
+                             ? last_colon + 1
+                             : class_name;
     const char *prefix = parcel ? CFCParcel_get_prefix(parcel) : "";
     size_t prefix_len = strlen(prefix);
     size_t struct_sym_len = strlen(struct_sym);
@@ -307,8 +303,7 @@ CFCClass_fetch_singleton(CFCParcel *parc
 }
 
 void
-CFCClass_clear_registry(void)
-{
+CFCClass_clear_registry(void) {
     size_t i;
     for (i = 0; i < registry_size; i++) {
         CFCBase_decref((CFCBase*)registry[i].klass);
@@ -320,39 +315,36 @@ CFCClass_clear_registry(void)
 }
 
 void
-CFCClass_add_child(CFCClass *self, CFCClass *child)
-{
+CFCClass_add_child(CFCClass *self, CFCClass *child) {
     CFCUTIL_NULL_CHECK(child);
     if (self->tree_grown) { croak("Can't call add_child after grow_tree"); }
     self->num_kids++;
     size_t size = (self->num_kids + 1) * sizeof(CFCClass*);
     self->children = (CFCClass**)REALLOCATE(self->children, size);
-    self->children[self->num_kids - 1] 
+    self->children[self->num_kids - 1]
         = (CFCClass*)CFCBase_incref((CFCBase*)child);
     self->children[self->num_kids] = NULL;
 }
 
 void
-CFCClass_add_function(CFCClass *self, CFCFunction *func)
-{
+CFCClass_add_function(CFCClass *self, CFCFunction *func) {
     CFCUTIL_NULL_CHECK(func);
-    if (self->tree_grown) { 
-        croak("Can't call add_function after grow_tree"); 
+    if (self->tree_grown) {
+        croak("Can't call add_function after grow_tree");
     }
     self->num_functions++;
     size_t size = (self->num_functions + 1) * sizeof(CFCFunction*);
     self->functions = (CFCFunction**)REALLOCATE(self->functions, size);
-    self->functions[self->num_functions - 1] 
+    self->functions[self->num_functions - 1]
         = (CFCFunction*)CFCBase_incref((CFCBase*)func);
     self->functions[self->num_functions] = NULL;
 }
 
 void
-CFCClass_add_method(CFCClass *self, CFCMethod *method)
-{
+CFCClass_add_method(CFCClass *self, CFCMethod *method) {
     CFCUTIL_NULL_CHECK(method);
-    if (self->tree_grown) { 
-        croak("Can't call add_method after grow_tree"); 
+    if (self->tree_grown) {
+        croak("Can't call add_method after grow_tree");
     }
     if (self->is_inert) {
         croak("Can't add_method to an inert class");
@@ -360,49 +352,46 @@ CFCClass_add_method(CFCClass *self, CFCM
     self->num_methods++;
     size_t size = (self->num_methods + 1) * sizeof(CFCMethod*);
     self->methods = (CFCMethod**)REALLOCATE(self->methods, size);
-    self->methods[self->num_methods - 1] 
+    self->methods[self->num_methods - 1]
         = (CFCMethod*)CFCBase_incref((CFCBase*)method);
     self->methods[self->num_methods] = NULL;
 }
 
 void
-CFCClass_add_member_var(CFCClass *self, CFCVariable *var)
-{
+CFCClass_add_member_var(CFCClass *self, CFCVariable *var) {
     CFCUTIL_NULL_CHECK(var);
-    if (self->tree_grown) { 
-        croak("Can't call add_member_var after grow_tree"); 
+    if (self->tree_grown) {
+        croak("Can't call add_member_var after grow_tree");
     }
     self->num_member_vars++;
     size_t size = (self->num_member_vars + 1) * sizeof(CFCVariable*);
     self->member_vars = (CFCVariable**)REALLOCATE(self->member_vars, size);
-    self->member_vars[self->num_member_vars - 1] 
+    self->member_vars[self->num_member_vars - 1]
         = (CFCVariable*)CFCBase_incref((CFCBase*)var);
     self->member_vars[self->num_member_vars] = NULL;
 }
 
 void
-CFCClass_add_inert_var(CFCClass *self, CFCVariable *var)
-{
+CFCClass_add_inert_var(CFCClass *self, CFCVariable *var) {
     CFCUTIL_NULL_CHECK(var);
-    if (self->tree_grown) { 
-        croak("Can't call add_inert_var after grow_tree"); 
+    if (self->tree_grown) {
+        croak("Can't call add_inert_var after grow_tree");
     }
     self->num_inert_vars++;
     size_t size = (self->num_inert_vars + 1) * sizeof(CFCVariable*);
     self->inert_vars = (CFCVariable**)REALLOCATE(self->inert_vars, size);
-    self->inert_vars[self->num_inert_vars - 1] 
+    self->inert_vars[self->num_inert_vars - 1]
         = (CFCVariable*)CFCBase_incref((CFCBase*)var);
     self->inert_vars[self->num_inert_vars] = NULL;
 }
 
 void
-CFCClass_add_attribute(CFCClass *self, const char *name, const char *value)
-{
+CFCClass_add_attribute(CFCClass *self, const char *name, const char *value) {
     if (!name || !strlen(name)) { croak("'name' is required"); }
-    if (CFCClass_has_attribute(self, name)) { 
+    if (CFCClass_has_attribute(self, name)) {
         croak("Attribute '%s' already registered");
     }
-    CFCClassAttribute *attribute 
+    CFCClassAttribute *attribute
         = (CFCClassAttribute*)MALLOCATE(sizeof(CFCClassAttribute));
     attribute->name  = CFCUtil_strdup(name);
     attribute->value = CFCUtil_strdup(value);
@@ -411,12 +400,10 @@ CFCClass_add_attribute(CFCClass *self, c
     self->attributes = (CFCClassAttribute**)REALLOCATE(self->attributes, size);
     self->attributes[self->num_attributes - 1] = attribute;
     self->attributes[self->num_attributes] = NULL;
-
 }
 
 int
-CFCClass_has_attribute(CFCClass *self, const char *name)
-{
+CFCClass_has_attribute(CFCClass *self, const char *name) {
     CFCUTIL_NULL_CHECK(name);
     size_t i;
     for (i = 0; i < self->num_attributes; i++) {
@@ -428,8 +415,7 @@ CFCClass_has_attribute(CFCClass *self, c
 }
 
 static CFCFunction*
-S_find_func(CFCFunction **funcs, const char *sym)
-{
+S_find_func(CFCFunction **funcs, const char *sym) {
     const size_t MAX_LEN = 128;
     char lcsym[MAX_LEN + 1];
     size_t sym_len = strlen(sym);
@@ -449,24 +435,21 @@ S_find_func(CFCFunction **funcs, const c
 }
 
 CFCFunction*
-CFCClass_function(CFCClass *self, const char *sym)
-{
+CFCClass_function(CFCClass *self, const char *sym) {
     return S_find_func(self->functions, sym);
 }
 
 CFCMethod*
-CFCClass_method(CFCClass *self, const char *sym)
-{
+CFCClass_method(CFCClass *self, const char *sym) {
     return (CFCMethod*)S_find_func((CFCFunction**)self->methods, sym);
 }
 
 CFCMethod*
-CFCClass_novel_method(CFCClass *self, const char *sym)
-{
+CFCClass_novel_method(CFCClass *self, const char *sym) {
     CFCMethod *method = CFCClass_method(self, sym);
     if (method) {
         const char *cnick = CFCClass_get_cnick(self);
-        const char *meth_cnick 
+        const char *meth_cnick
             = CFCSymbol_get_class_cnick((CFCSymbol*)method);
         if (strcmp(cnick, meth_cnick) == 0) {
             return method;
@@ -477,20 +460,19 @@ CFCClass_novel_method(CFCClass *self, co
 
 // Pass down member vars to from parent to children.
 static void
-S_bequeath_member_vars(CFCClass *self)
-{
+S_bequeath_member_vars(CFCClass *self) {
     size_t i;
     for (i = 0; self->children[i] != NULL; i++) {
         CFCClass *child = self->children[i];
         size_t num_vars = self->num_member_vars + child->num_member_vars;
         size_t size = (num_vars + 1) * sizeof(CFCVariable*);
-        child->member_vars 
+        child->member_vars
             = (CFCVariable**)REALLOCATE(child->member_vars, size);
         memmove(child->member_vars + self->num_member_vars,
-            child->member_vars, 
-            child->num_member_vars * sizeof(CFCVariable*));
-        memcpy(child->member_vars, self->member_vars, 
-            self->num_member_vars * sizeof(CFCVariable*));
+                child->member_vars,
+                child->num_member_vars * sizeof(CFCVariable*));
+        memcpy(child->member_vars, self->member_vars,
+               self->num_member_vars * sizeof(CFCVariable*));
         size_t j;
         for (j = 0; self->member_vars[j] != NULL; j++) {
             CFCBase_incref((CFCBase*)child->member_vars[j]);
@@ -502,8 +484,7 @@ S_bequeath_member_vars(CFCClass *self)
 }
 
 static void
-S_bequeath_methods(CFCClass *self)
-{
+S_bequeath_methods(CFCClass *self) {
     size_t child_num;
     for (child_num = 0; self->children[child_num] != NULL; child_num++) {
         CFCClass *child = self->children[child_num];
@@ -512,7 +493,7 @@ S_bequeath_methods(CFCClass *self)
         size_t num_methods = 0;
         size_t max_methods = self->num_methods + child->num_methods;
         CFCMethod **methods = (CFCMethod**)MALLOCATE(
-            (max_methods + 1) * sizeof(CFCMethod*));
+                                  (max_methods + 1) * sizeof(CFCMethod*));
 
         // Gather methods which child inherits or overrides.
         size_t i;
@@ -538,7 +519,7 @@ S_bequeath_methods(CFCClass *self)
             }
         }
         methods[num_methods] = NULL;
-        
+
         // Manage refcounts and assign new array.  Transform to final methods
         // if child class is a final class.
         if (child->is_final) {
@@ -566,8 +547,7 @@ S_bequeath_methods(CFCClass *self)
 
 // Let the children know who their parent class is.
 static void
-S_establish_ancestry(CFCClass *self)
-{
+S_establish_ancestry(CFCClass *self) {
     size_t i;
     for (i = 0; i < self->num_kids; i++) {
         CFCClass *child = self->children[i];
@@ -579,8 +559,7 @@ S_establish_ancestry(CFCClass *self)
 }
 
 static size_t
-S_family_tree_size(CFCClass *self)
-{
+S_family_tree_size(CFCClass *self) {
     size_t count = 1; // self
     size_t i;
     for (i = 0; i < self->num_kids; i++) {
@@ -590,8 +569,7 @@ S_family_tree_size(CFCClass *self)
 }
 
 static void
-S_create_dumpables(CFCClass *self)
-{
+S_create_dumpables(CFCClass *self) {
     if (CFCClass_has_attribute(self, "dumpable")) {
         CFCDumpable *dumpable = CFCDumpable_new();
         CFCDumpable_add_dumpables(dumpable, self);
@@ -600,8 +578,7 @@ S_create_dumpables(CFCClass *self)
 }
 
 void
-CFCClass_grow_tree(CFCClass *self)
-{
+CFCClass_grow_tree(CFCClass *self) {
     if (self->tree_grown) {
         croak("Can't call grow_tree more than once");
     }
@@ -613,8 +590,7 @@ CFCClass_grow_tree(CFCClass *self)
 }
 
 static void
-S_generate_automethods(CFCClass *self) 
-{
+S_generate_automethods(CFCClass *self) {
     S_create_dumpables(self);
     size_t i;
     for (i = 0; i < self->num_kids; i++) {
@@ -625,8 +601,7 @@ S_generate_automethods(CFCClass *self) 
 // Return value is valid only so long as object persists (elements are not
 // refcounted).
 CFCClass**
-CFCClass_tree_to_ladder(CFCClass *self)
-{
+CFCClass_tree_to_ladder(CFCClass *self) {
     size_t ladder_len = S_family_tree_size(self);
     CFCClass **ladder = (CFCClass**)MALLOCATE((ladder_len + 1) * sizeof(CFCClass*));
     ladder[ladder_len] = NULL;
@@ -646,8 +621,7 @@ CFCClass_tree_to_ladder(CFCClass *self)
 }
 
 static CFCSymbol**
-S_novel_syms(CFCClass *self, CFCSymbol **syms)
-{
+S_novel_syms(CFCClass *self, CFCSymbol **syms) {
     const char *cnick = CFCSymbol_get_class_cnick((CFCSymbol*)self);
     size_t count = 0;
     while (syms[count] != NULL) { count++; }
@@ -667,143 +641,120 @@ S_novel_syms(CFCClass *self, CFCSymbol *
 }
 
 CFCMethod**
-CFCClass_novel_methods(CFCClass *self)
-{
+CFCClass_novel_methods(CFCClass *self) {
     return (CFCMethod**)S_novel_syms(self, (CFCSymbol**)self->methods);
 }
 
 CFCVariable**
-CFCClass_novel_member_vars(CFCClass *self)
-{
+CFCClass_novel_member_vars(CFCClass *self) {
     return (CFCVariable**)S_novel_syms(self, (CFCSymbol**)self->member_vars);
 }
 
 CFCClass**
-CFCClass_children(CFCClass *self)
-{
+CFCClass_children(CFCClass *self) {
     return self->children;
 }
 
 CFCFunction**
-CFCClass_functions(CFCClass *self)
-{
+CFCClass_functions(CFCClass *self) {
     return self->functions;
 }
 
 CFCMethod**
-CFCClass_methods(CFCClass *self)
-{
+CFCClass_methods(CFCClass *self) {
     return self->methods;
 }
 
 CFCVariable**
-CFCClass_member_vars(CFCClass *self)
-{
+CFCClass_member_vars(CFCClass *self) {
     return self->member_vars;
 }
 
 CFCVariable**
-CFCClass_inert_vars(CFCClass *self)
-{
+CFCClass_inert_vars(CFCClass *self) {
     return self->inert_vars;
 }
 
 const char*
-CFCClass_get_cnick(CFCClass *self)
-{
+CFCClass_get_cnick(CFCClass *self) {
     return CFCSymbol_get_class_cnick((CFCSymbol*)self);
 }
 
 void
-CFCClass_set_parent(CFCClass *self, CFCClass *parent)
-{
+CFCClass_set_parent(CFCClass *self, CFCClass *parent) {
     CFCBase_decref((CFCBase*)self->parent);
     self->parent = (CFCClass*)CFCBase_incref((CFCBase*)parent);
 }
 
 CFCClass*
-CFCClass_get_parent(CFCClass *self)
-{
+CFCClass_get_parent(CFCClass *self) {
     return self->parent;
 }
 
 void
-CFCClass_append_autocode(CFCClass *self, const char *autocode)
-{
+CFCClass_append_autocode(CFCClass *self, const char *autocode) {
     size_t size = strlen(self->autocode) + strlen(autocode) + 1;
     self->autocode = (char*)REALLOCATE(self->autocode, size);
     strcat(self->autocode, autocode);
 }
 
 const char*
-CFCClass_get_autocode(CFCClass *self)
-{
+CFCClass_get_autocode(CFCClass *self) {
     return self->autocode;
 }
 
 const char*
-CFCClass_get_source_class(CFCClass *self)
-{
+CFCClass_get_source_class(CFCClass *self) {
     return self->source_class;
 }
 
 const char*
-CFCClass_get_parent_class_name(CFCClass *self)
-{
+CFCClass_get_parent_class_name(CFCClass *self) {
     return self->parent_class_name;
 }
 
 int
-CFCClass_final(CFCClass *self)
-{
+CFCClass_final(CFCClass *self) {
     return self->is_final;
 }
 
 int
-CFCClass_inert(CFCClass *self)
-{
+CFCClass_inert(CFCClass *self) {
     return self->is_inert;
 }
 
 const char*
-CFCClass_get_struct_sym(CFCClass *self)
-{
+CFCClass_get_struct_sym(CFCClass *self) {
     return self->struct_sym;
 }
 
 const char*
-CFCClass_full_struct_sym(CFCClass *self)
-{
+CFCClass_full_struct_sym(CFCClass *self) {
     return self->full_struct_sym;
 }
 
 const char*
-CFCClass_short_vtable_var(CFCClass *self)
-{
+CFCClass_short_vtable_var(CFCClass *self) {
     return self->short_vtable_var;
 }
 
 const char*
-CFCClass_full_vtable_var(CFCClass *self)
-{
+CFCClass_full_vtable_var(CFCClass *self) {
     return self->full_vtable_var;
 }
 
 const char*
-CFCClass_full_vtable_type(CFCClass *self)
-{
+CFCClass_full_vtable_type(CFCClass *self) {
     return self->full_vtable_type;
 }
 
 const char*
-CFCClass_include_h(CFCClass *self)
-{
+CFCClass_include_h(CFCClass *self) {
     return self->include_h;
 }
 
 struct CFCDocuComment*
-CFCClass_get_docucomment(CFCClass *self)
-{
+CFCClass_get_docucomment(CFCClass *self) {
     return self->docucomment;
 }
 

Modified: incubator/lucy/trunk/clownfish/src/CFCClass.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCClass.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCClass.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCClass.h Sun May  1 23:50:24 2011
@@ -29,18 +29,18 @@ struct CFCMethod;
 struct CFCVariable;
 
 CFCClass*
-CFCClass_create(struct CFCParcel *parcel, const char *exposure, 
-                const char *class_name, const char *cnick, 
+CFCClass_create(struct CFCParcel *parcel, const char *exposure,
+                const char *class_name, const char *cnick,
                 const char *micro_sym, struct CFCDocuComment *docucomment,
-                const char *source_class, const char *parent_class_name, 
+                const char *source_class, const char *parent_class_name,
                 int is_final, int is_inert);
 
 CFCClass*
-CFCClass_do_create(CFCClass *self, struct CFCParcel *parcel, 
-                   const char *exposure, const char *class_name, 
+CFCClass_do_create(CFCClass *self, struct CFCParcel *parcel,
+                   const char *exposure, const char *class_name,
                    const char *cnick, const char *micro_sym,
-                   struct CFCDocuComment *docucomment, 
-                   const char *source_class, const char *parent_class_name, 
+                   struct CFCDocuComment *docucomment,
+                   const char *source_class, const char *parent_class_name,
                    int is_final, int is_inert);
 
 void

Modified: incubator/lucy/trunk/clownfish/src/CFCDocuComment.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCDocuComment.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCDocuComment.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCDocuComment.c Sun May  1 23:50:24 2011
@@ -38,30 +38,29 @@ struct CFCDocuComment {
 /** Remove comment open, close, and left border from raw comment text.
  */
 static void
-S_strip(char *comment)
-{
+S_strip(char *comment) {
     size_t len = strlen(comment);
     char *scratch = (char*)MALLOCATE(len + 1);
 
     // Establish that comment text begins with "/**" and ends with "*/".
-    if (   strstr(comment, "/**") != comment
+    if (strstr(comment, "/**") != comment
         || strstr(comment, "*/") != (comment + len - 2)
-    ) {
+       ) {
         croak("Malformed comment");
     }
 
     // Capture text minus beginning "/**", ending "*/", and left border.
     size_t i = 3;
     size_t max = len - 2;
-    while ((isspace(comment[i]) || comment[i] == '*') && i < max) { 
-        i++; 
+    while ((isspace(comment[i]) || comment[i] == '*') && i < max) {
+        i++;
     }
     size_t j = 0;
-    for ( ; i < max; i++) {
+    for (; i < max; i++) {
         while (comment[i] == '\n' && i < max) {
             scratch[j++] = comment[i];
             i++;
-            while (isspace(comment[i]) && comment[i] != '\n' && i < max) { 
+            while (isspace(comment[i]) && comment[i] != '\n' && i < max) {
                 i++;
             }
             if (comment[i] == '*') { i++; }
@@ -83,11 +82,11 @@ S_strip(char *comment)
 }
 
 CFCDocuComment*
-CFCDocuComment_parse(const char *raw_text)
-{
+CFCDocuComment_parse(const char *raw_text) {
     char *text = CFCUtil_strdup(raw_text);
-    CFCDocuComment *self = (CFCDocuComment*)CFCBase_allocate(
-        sizeof(CFCDocuComment), "Clownfish::DocuComment");
+    CFCDocuComment *self
+        = (CFCDocuComment*)CFCBase_allocate(sizeof(CFCDocuComment),
+                                            "Clownfish::DocuComment");
 
     // Strip whitespace, comment open, close, and left border.
     CFCUtil_trim_whitespace(text);
@@ -102,9 +101,9 @@ CFCDocuComment_parse(const char *raw_tex
             limit = text + len;
         }
         while (ptr < limit) {
-            if (   *ptr == '.' 
+            if (*ptr == '.'
                 && ((ptr == limit - 1) || isspace(*(ptr + 1)))
-            ) {
+               ) {
                 ptr++;
                 size_t brief_len = ptr - text;
                 self->brief = CFCUtil_strdup(text);
@@ -162,15 +161,15 @@ CFCDocuComment_parse(const char *raw_tex
             size_t size = (num_params + 1) * sizeof(char*);
             self->param_names = (char**)REALLOCATE(self->param_names, size);
             self->param_docs  = (char**)REALLOCATE(self->param_docs, size);
-            self->param_names[num_params - 1] 
+            self->param_names[num_params - 1]
                 = CFCUtil_strndup(param_name, param_name_len);
-            self->param_docs[num_params - 1] 
+            self->param_docs[num_params - 1]
                 = CFCUtil_strndup(param_doc, param_doc_len);
             CFCUtil_trim_whitespace(self->param_names[num_params - 1]);
             CFCUtil_trim_whitespace(self->param_docs[num_params - 1]);
             self->param_names[num_params] = NULL;
             self->param_docs[num_params]  = NULL;
-            
+
             if (ptr == limit) {
                 break;
             }
@@ -214,8 +213,7 @@ CFCDocuComment_parse(const char *raw_tex
 }
 
 void
-CFCDocuComment_destroy(CFCDocuComment *self)
-{
+CFCDocuComment_destroy(CFCDocuComment *self) {
     size_t i;
     if (self->param_names) {
         for (i = 0; self->param_names[i] != NULL; i++) {
@@ -237,38 +235,32 @@ CFCDocuComment_destroy(CFCDocuComment *s
 }
 
 const char*
-CFCDocuComment_get_description(CFCDocuComment *self)
-{
+CFCDocuComment_get_description(CFCDocuComment *self) {
     return self->description;
 }
 
 const char*
-CFCDocuComment_get_brief(CFCDocuComment *self)
-{
+CFCDocuComment_get_brief(CFCDocuComment *self) {
     return self->brief;
 }
 
 const char*
-CFCDocuComment_get_long(CFCDocuComment *self)
-{
+CFCDocuComment_get_long(CFCDocuComment *self) {
     return self->long_des;
 }
 
 const char**
-CFCDocuComment_get_param_names(CFCDocuComment *self)
-{
+CFCDocuComment_get_param_names(CFCDocuComment *self) {
     return (const char**)self->param_names;
 }
 
 const char**
-CFCDocuComment_get_param_docs(CFCDocuComment *self)
-{
+CFCDocuComment_get_param_docs(CFCDocuComment *self) {
     return (const char**)self->param_docs;
 }
 
 const char*
-CFCDocuComment_get_retval(CFCDocuComment *self)
-{
+CFCDocuComment_get_retval(CFCDocuComment *self) {
     return self->retval;
 }
 

Modified: incubator/lucy/trunk/clownfish/src/CFCDumpable.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCDumpable.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCDumpable.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCDumpable.c Sun May  1 23:50:24 2011
@@ -64,33 +64,29 @@ struct CFCDumpable {
 };
 
 CFCDumpable*
-CFCDumpable_new(void)
-{
+CFCDumpable_new(void) {
     CFCDumpable *self = (CFCDumpable*)CFCBase_allocate(sizeof(CFCDumpable),
-        "Clownfish::Dumpable");
+                                                       "Clownfish::Dumpable");
     return CFCDumpable_init(self);
 }
 
 CFCDumpable*
-CFCDumpable_init(CFCDumpable *self)
-{
+CFCDumpable_init(CFCDumpable *self) {
     return self;
 }
 
 void
-CFCDumpable_destroy(CFCDumpable *self)
-{
+CFCDumpable_destroy(CFCDumpable *self) {
     CFCBase_destroy((CFCBase*)self);
 }
 
 void
-CFCDumpable_add_dumpables(CFCDumpable *self, CFCClass *klass)
-{
+CFCDumpable_add_dumpables(CFCDumpable *self, CFCClass *klass) {
     (void)self;
 
     if (!CFCClass_has_attribute(klass, "dumpable")) {
-        croak("Class %s isn't dumpable", 
-            CFCSymbol_get_class_name((CFCSymbol*)klass));
+        croak("Class %s isn't dumpable",
+              CFCSymbol_get_class_name((CFCSymbol*)klass));
     }
 
     // Inherit Dump/Load from parent if no novel member vars.
@@ -111,19 +107,18 @@ CFCDumpable_add_dumpables(CFCDumpable *s
 }
 
 static CFCMethod*
-S_make_method_obj(CFCClass *klass, const char *method_name)
-{
+S_make_method_obj(CFCClass *klass, const char *method_name) {
     const char *klass_struct_sym = CFCClass_get_struct_sym(klass);
     const char *klass_name   = CFCSymbol_get_class_name((CFCSymbol*)klass);
     const char *klass_cnick  = CFCSymbol_get_class_cnick((CFCSymbol*)klass);
     CFCParcel  *klass_parcel = CFCSymbol_get_parcel((CFCSymbol*)klass);
     CFCParcel  *cf_parcel    = CFCParcel_clownfish_parcel();
 
-    CFCType *return_type 
+    CFCType *return_type
         = CFCType_new_object(CFCTYPE_INCREMENTED, cf_parcel, "Obj", 1);
     CFCType *self_type = CFCType_new_object(0, klass_parcel, klass_struct_sym, 1);
     CFCVariable *self_var = CFCVariable_new(klass_parcel, NULL, klass_name,
-        klass_cnick, "self", self_type);
+                                            klass_cnick, "self", self_type);
     CFCParamList *param_list = NULL;
 
     if (strcmp(method_name, "Dump") == 0) {
@@ -133,7 +128,7 @@ S_make_method_obj(CFCClass *klass, const
     else if (strcmp(method_name, "Load") == 0) {
         CFCType *dump_type = CFCType_new_object(0, cf_parcel, "Obj", 1);
         CFCVariable *dump_var = CFCVariable_new(cf_parcel, NULL, NULL,
-            NULL, "dump", dump_type);
+                                                NULL, "dump", dump_type);
         param_list = CFCParamList_new(false);
         CFCParamList_add_param(param_list, self_var, NULL);
         CFCParamList_add_param(param_list, dump_var, NULL);
@@ -145,8 +140,8 @@ S_make_method_obj(CFCClass *klass, const
     }
 
     CFCMethod *method = CFCMethod_new(klass_parcel, "public", klass_name,
-        klass_cnick, method_name, return_type, param_list, NULL, false, 
-        false);
+                                      klass_cnick, method_name, return_type,
+                                      param_list, NULL, false, false);
 
     CFCBase_decref((CFCBase*)param_list);
     CFCBase_decref((CFCBase*)self_type);
@@ -157,8 +152,7 @@ S_make_method_obj(CFCClass *klass, const
 }
 
 static void
-S_add_dump_method(CFCClass *klass)
-{
+S_add_dump_method(CFCClass *klass) {
     CFCMethod *method = S_make_method_obj(klass, "Dump");
     CFCClass_add_method(klass, method);
     CFCBase_decref((CFCBase*)method);
@@ -179,15 +173,15 @@ S_add_dump_method(CFCClass *klass)
             "    %s super_dump = (%s)SUPER_METHOD(%s, %s, Dump);\n"
             "    cfish_Hash *dump = (cfish_Hash*)super_dump(self);\n";
         size_t amount = sizeof(pattern)
-                      + strlen(full_func_sym)
-                      + strlen(full_struct)
-                      + strlen(full_typedef) * 2
-                      + strlen(vtable_var)
-                      + strlen(cnick)
-                      + 50;
+                        + strlen(full_func_sym)
+                        + strlen(full_struct)
+                        + strlen(full_typedef) * 2
+                        + strlen(vtable_var)
+                        + strlen(cnick)
+                        + 50;
         char *autocode = (char*)MALLOCATE(amount);
-        int check = sprintf(autocode, pattern, full_func_sym, full_struct, 
-            full_typedef, full_typedef, vtable_var, cnick);
+        int check = sprintf(autocode, pattern, full_func_sym, full_struct,
+                            full_typedef, full_typedef, vtable_var, cnick);
         if (check < 0) { CFCUtil_die("sprintf failed"); }
         CFCClass_append_autocode(klass, autocode);
         FREEMEM(autocode);
@@ -199,7 +193,7 @@ S_add_dump_method(CFCClass *klass)
         FREEMEM(novel);
     }
     else {
-        const char pattern[] = 
+        const char pattern[] =
             "cfish_Obj*\n"
             "%s(%s *self)\n"
             "{\n"
@@ -207,9 +201,9 @@ S_add_dump_method(CFCClass *klass)
             "    Cfish_Hash_Store_Str(dump, \"_class\", 6,\n"
             "        (cfish_Obj*)Cfish_CB_Clone(Cfish_Obj_Get_Class_Name((cfish_Obj*)self)));\n";
         size_t amount = sizeof(pattern)
-                      + strlen(full_func_sym)
-                      + strlen(full_struct)
-                      + 50;
+                        + strlen(full_func_sym)
+                        + strlen(full_struct)
+                        + 50;
         char *autocode = (char*)MALLOCATE(amount);
         int check = sprintf(autocode, pattern, full_func_sym, full_struct);
         if (check < 0) { croak("sprintf failed"); }
@@ -226,8 +220,7 @@ S_add_dump_method(CFCClass *klass)
 }
 
 static void
-S_add_load_method(CFCClass *klass)
-{
+S_add_load_method(CFCClass *klass) {
     CFCMethod *method = S_make_method_obj(klass, "Load");
     CFCClass_add_method(klass, method);
     CFCBase_decref((CFCBase*)method);
@@ -241,24 +234,24 @@ S_add_load_method(CFCClass *klass)
     char buf[BUF_SIZE];
 
     if (parent && CFCClass_has_attribute(parent, "dumpable")) {
-        const char pattern[] = 
+        const char pattern[] =
             "cfish_Obj*\n"
             "%s(%s *self, cfish_Obj *dump)\n"
             "{\n"
             "    cfish_Hash *source = (cfish_Hash*)CFISH_CERTIFY(dump, CFISH_HASH);\n"
             "    %s super_load = (%s)SUPER_METHOD(%s, %s, Load);\n"
             "    %s *loaded = (%s*)super_load(self, dump);\n";
-        size_t amount = sizeof(pattern) 
-                      + strlen(full_func_sym)
-                      + strlen(full_struct) * 3
-                      + strlen(full_typedef) * 2
-                      + strlen(vtable_var)
-                      + strlen(cnick)
-                      + 50;
+        size_t amount = sizeof(pattern)
+                        + strlen(full_func_sym)
+                        + strlen(full_struct) * 3
+                        + strlen(full_typedef) * 2
+                        + strlen(vtable_var)
+                        + strlen(cnick)
+                        + 50;
         char *autocode = (char*)MALLOCATE(amount);
         int check = sprintf(autocode, pattern, full_func_sym, full_struct,
-            full_typedef, full_typedef, vtable_var, cnick, full_struct,
-            full_struct);
+                            full_typedef, full_typedef, vtable_var, cnick,
+                            full_struct, full_struct);
         if (check < 0) { croak("sprintf failed"); }
         CFCClass_append_autocode(klass, autocode);
         FREEMEM(autocode);
@@ -270,7 +263,7 @@ S_add_load_method(CFCClass *klass)
         FREEMEM(novel);
     }
     else {
-        const char pattern[] = 
+        const char pattern[] =
             "cfish_Obj*\n"
             "%s(%s *self, cfish_Obj *dump)\n"
             "{\n"
@@ -281,12 +274,12 @@ S_add_load_method(CFCClass *klass)
             "    %s *loaded = (%s*)Cfish_VTable_Make_Obj(vtable);\n"
             "    CHY_UNUSED_VAR(self);\n";
         size_t amount = sizeof(pattern)
-                      + strlen(full_func_sym)
-                      + strlen(full_struct) * 3
-                      + 50;
+                        + strlen(full_func_sym)
+                        + strlen(full_struct) * 3
+                        + 50;
         char *autocode = (char*)MALLOCATE(amount);
-        int check = sprintf(autocode, pattern, full_func_sym, full_struct, 
-            full_struct, full_struct);
+        int check = sprintf(autocode, pattern, full_func_sym, full_struct,
+                            full_struct, full_struct);
         if (check < 0) { croak("sprintf failed"); }
         CFCClass_append_autocode(klass, autocode);
         FREEMEM(autocode);
@@ -302,8 +295,7 @@ S_add_load_method(CFCClass *klass)
 
 static void
 S_process_dump_member(CFCClass *klass, CFCVariable *member, char *buf,
-                      size_t buf_size)
-{
+                      size_t buf_size) {
     CFCUTIL_NULL_CHECK(member);
     CFCType *type = CFCVariable_get_type(member);
     const char *name = CFCSymbol_micro_sym((CFCSymbol*)member);
@@ -311,37 +303,37 @@ S_process_dump_member(CFCClass *klass, C
     const char *specifier = CFCType_get_specifier(type);
 
     // Skip the VTable and the refcount/host-object.
-    if (   strcmp(specifier, "lucy_VTable") == 0
+    if (strcmp(specifier, "lucy_VTable") == 0
         || strcmp(specifier, "lucy_ref_t") == 0
-    ) {
-        return; 
+       ) {
+        return;
     }
 
     if (CFCType_is_integer(type) || CFCType_is_floating(type)) {
-        char int_pattern[] = 
+        char int_pattern[] =
             "    Cfish_Hash_Store_Str(dump, \"%s\", %u, (cfish_Obj*)cfish_CB_newf(\"%%i64\", (int64_t)self->%s));\n";
-        char float_pattern[] = 
+        char float_pattern[] =
             "    Cfish_Hash_Store_Str(dump, \"%s\", %u, (cfish_Obj*)cfish_CB_newf(\"%%f64\", (double)self->%s));\n";
-        const char *pattern = CFCType_is_integer(type) 
-                             ? int_pattern : float_pattern;
+        const char *pattern = CFCType_is_integer(type)
+                              ? int_pattern : float_pattern;
         size_t needed = strlen(pattern) + name_len * 2 + 20;
         if (buf_size < needed) {
-            croak("Buffer not big enough (%lu < %lu)", 
-                (unsigned long)buf_size, (unsigned long)needed);
+            croak("Buffer not big enough (%lu < %lu)",
+                  (unsigned long)buf_size, (unsigned long)needed);
         }
         int check = sprintf(buf, pattern, name, name_len, name);
         if (check < 0) { croak("sprintf failed"); }
     }
     else if (CFCType_is_object(type)) {
-        char pattern[] = 
+        char pattern[] =
             "    if (self->%s) {\n"
             "        Cfish_Hash_Store_Str(dump, \"%s\", %u, Cfish_Obj_Dump((cfish_Obj*)self->%s));\n"
             "    }\n";
 
         size_t needed = strlen(pattern) + name_len * 3 + 20;
         if (buf_size < needed) {
-            croak("Buffer not big enough (%lu < %lu)", 
-                (unsigned long)buf_size, (unsigned long)needed);
+            croak("Buffer not big enough (%lu < %lu)",
+                  (unsigned long)buf_size, (unsigned long)needed);
         }
         int check = sprintf(buf, pattern, name, name, name_len, name);
         if (check < 0) { croak("sprintf failed"); }
@@ -355,8 +347,7 @@ S_process_dump_member(CFCClass *klass, C
 
 static void
 S_process_load_member(CFCClass *klass, CFCVariable *member, char *buf,
-                      size_t buf_size)
-{
+                      size_t buf_size) {
     CFCUTIL_NULL_CHECK(member);
     CFCType *type = CFCVariable_get_type(member);
     const char *type_str = CFCType_to_c(type);
@@ -367,10 +358,10 @@ S_process_load_member(CFCClass *klass, C
     size_t specifier_len = strlen(specifier);
 
     // Skip the VTable and the refcount/host-object.
-    if (   strcmp(specifier, "lucy_VTable") == 0
+    if (strcmp(specifier, "lucy_VTable") == 0
         || strcmp(specifier, "lucy_ref_t") == 0
-    ) {
-        return; 
+       ) {
+        return;
     }
 
     if (strlen(type_str) + 100 > sizeof(extraction)) { // play it safe
@@ -393,27 +384,27 @@ S_process_load_member(CFCClass *klass, C
         for (i = 0; i <= specifier_len; i++) {
             vtable_var[i] = toupper(specifier[i]);
         }
-        int check = sprintf(extraction, 
-             "(%s*)CFISH_CERTIFY(Cfish_Obj_Load(var, var), %s)",
-             specifier, vtable_var);
+        int check = sprintf(extraction,
+                            "(%s*)CFISH_CERTIFY(Cfish_Obj_Load(var, var), %s)",
+                            specifier, vtable_var);
         if (check < 0) { croak("sprintf failed"); }
     }
     else {
         croak("Don't know how to load %s", specifier);
     }
-    
-    const char *pattern = 
-    "    {\n"
-    "        cfish_Obj *var = Cfish_Hash_Fetch_Str(source, \"%s\", %u);\n"
-    "        if (var) { loaded->%s = %s; }\n"
-    "    }\n";
-    size_t needed = sizeof(pattern) 
-                  + (name_len * 2) 
-                  + strlen(extraction) 
-                  + 20;
+
+    const char *pattern =
+        "    {\n"
+        "        cfish_Obj *var = Cfish_Hash_Fetch_Str(source, \"%s\", %u);\n"
+        "        if (var) { loaded->%s = %s; }\n"
+        "    }\n";
+    size_t needed = sizeof(pattern)
+                    + (name_len * 2)
+                    + strlen(extraction)
+                    + 20;
     if (buf_size < needed) {
         croak("Buffer not big enough (%lu < %lu)", (unsigned long)buf_size,
-            (unsigned long)needed);
+              (unsigned long)needed);
     }
     int check = sprintf(buf, pattern, name, name_len, name, extraction);
     if (check < 0) { croak("sprintf failed"); }

Modified: incubator/lucy/trunk/clownfish/src/CFCFile.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCFile.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCFile.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCFile.c Sun May  1 23:50:24 2011
@@ -26,10 +26,10 @@
 
 #ifdef _WIN32
 #define PATH_SEP "\\"
-#define PATH_SEP_CHAR '\\' 
+#define PATH_SEP_CHAR '\\'
 #else
 #define PATH_SEP "/"
-#define PATH_SEP_CHAR '/' 
+#define PATH_SEP_CHAR '/'
 #endif
 
 #define CFC_NEED_BASE_STRUCT_DEF
@@ -51,17 +51,15 @@ struct CFCFile {
 };
 
 CFCFile*
-CFCFile_new(const char *source_class)
-{
+CFCFile_new(const char *source_class) {
 
     CFCFile *self = (CFCFile*)CFCBase_allocate(sizeof(CFCFile),
-        "Clownfish::File");
+                                               "Clownfish::File");
     return CFCFile_init(self, source_class);
 }
 
 CFCFile*
-CFCFile_init(CFCFile *self, const char *source_class) 
-{
+CFCFile_init(CFCFile *self, const char *source_class) {
     CFCUTIL_NULL_CHECK(source_class);
     self->modified = false;
     self->source_class = CFCUtil_strdup(source_class);
@@ -87,11 +85,11 @@ CFCFile_init(CFCFile *self, const char *
         }
     }
     self->guard_name[j] = '\0';
-    int check = sprintf(self->guard_start, "#ifndef %s\n#define %s 1\n", 
-        self->guard_name, self->guard_name);
+    int check = sprintf(self->guard_start, "#ifndef %s\n#define %s 1\n",
+                        self->guard_name, self->guard_name);
     if (check < 0) { croak("sprintf failed"); }
-    check = sprintf(self->guard_close, "#endif /* %s */\n", 
-        self->guard_name);
+    check = sprintf(self->guard_close, "#endif /* %s */\n",
+                    self->guard_name);
     if (check < 0) { croak("sprintf failed"); }
 
     // Cache partial path derived from source_class.
@@ -112,8 +110,7 @@ CFCFile_init(CFCFile *self, const char *
 }
 
 void
-CFCFile_destroy(CFCFile *self)
-{
+CFCFile_destroy(CFCFile *self) {
     size_t i;
     for (i = 0; self->blocks[i] != NULL; i++) {
         CFCBase_decref(self->blocks[i]);
@@ -132,32 +129,31 @@ CFCFile_destroy(CFCFile *self)
 }
 
 void
-CFCFile_add_block(CFCFile *self, CFCBase *block)
-{
+CFCFile_add_block(CFCFile *self, CFCBase *block) {
     CFCUTIL_NULL_CHECK(block);
     const char *cfc_class = CFCBase_get_cfc_class(block);
 
     // Add to classes array if the block is a CFCClass.
     if (strcmp(cfc_class, "Clownfish::Class") == 0) {
         size_t num_class_blocks = 0;
-        while (self->classes[num_class_blocks] != NULL) { 
+        while (self->classes[num_class_blocks] != NULL) {
             num_class_blocks++;
         }
         num_class_blocks++;
         size_t size = (num_class_blocks + 1) * sizeof(CFCClass*);
         self->classes = (CFCClass**)REALLOCATE(self->classes, size);
-        self->classes[num_class_blocks - 1] 
+        self->classes[num_class_blocks - 1]
             = (CFCClass*)CFCBase_incref(block);
         self->classes[num_class_blocks] = NULL;
     }
 
     // Add to blocks array.
-    if (   strcmp(cfc_class, "Clownfish::Class") == 0
+    if (strcmp(cfc_class, "Clownfish::Class") == 0
         || strcmp(cfc_class, "Clownfish::Parcel") == 0
         || strcmp(cfc_class, "Clownfish::CBlock") == 0
-    ) {
+       ) {
         size_t num_blocks = 0;
-        while (self->blocks[num_blocks] != NULL) { 
+        while (self->blocks[num_blocks] != NULL) {
             num_blocks++;
         }
         num_blocks++;
@@ -172,9 +168,8 @@ CFCFile_add_block(CFCFile *self, CFCBase
 }
 
 static void
-S_some_path(CFCFile *self, char *buf, size_t buf_size, const char *base_dir, 
-            const char *ext)
-{
+S_some_path(CFCFile *self, char *buf, size_t buf_size, const char *base_dir,
+            const char *ext) {
     size_t needed = CFCFile_path_buf_size(self, base_dir);
     if (strlen(ext) > 4) {
         croak("ext cannot be more than 4 characters.");
@@ -183,8 +178,8 @@ S_some_path(CFCFile *self, char *buf, si
         croak("Need buf_size of %lu, but got %lu", needed, buf_size);
     }
     if (base_dir) {
-        int check = sprintf(buf, "%s" PATH_SEP "%s%s", base_dir, 
-            self->path_part, ext);
+        int check = sprintf(buf, "%s" PATH_SEP "%s%s", base_dir,
+                            self->path_part, ext);
         if (check < 0) { croak("sprintf failed"); }
     }
     else {
@@ -202,12 +197,11 @@ S_some_path(CFCFile *self, char *buf, si
 }
 
 size_t
-CFCFile_path_buf_size(CFCFile *self, const char *base_dir)
-{
+CFCFile_path_buf_size(CFCFile *self, const char *base_dir) {
     size_t size = strlen(self->path_part);
     size += 4; // Max extension length.
     size += 1; // NULL-termination.
-    if (base_dir) { 
+    if (base_dir) {
         size += strlen(base_dir);
         size += strlen(PATH_SEP);
     }
@@ -215,71 +209,60 @@ CFCFile_path_buf_size(CFCFile *self, con
 }
 
 void
-CFCFile_c_path(CFCFile *self, char *buf, size_t buf_size, 
-               const char *base_dir)
-{
+CFCFile_c_path(CFCFile *self, char *buf, size_t buf_size,
+               const char *base_dir) {
     S_some_path(self, buf, buf_size, base_dir, ".c");
 }
 
 void
-CFCFile_h_path(CFCFile *self, char *buf, size_t buf_size, 
-               const char *base_dir)
-{
+CFCFile_h_path(CFCFile *self, char *buf, size_t buf_size,
+               const char *base_dir) {
     S_some_path(self, buf, buf_size, base_dir, ".h");
 }
 
 void
-CFCFile_cfh_path(CFCFile *self, char *buf, size_t buf_size, 
-                 const char *base_dir)
-{
+CFCFile_cfh_path(CFCFile *self, char *buf, size_t buf_size,
+                 const char *base_dir) {
     S_some_path(self, buf, buf_size, base_dir, ".cfh");
 }
 
 CFCBase**
-CFCFile_blocks(CFCFile *self)
-{
+CFCFile_blocks(CFCFile *self) {
     return self->blocks;
 }
 
 CFCClass**
-CFCFile_classes(CFCFile *self)
-{
+CFCFile_classes(CFCFile *self) {
     return self->classes;
 }
 
 void
-CFCFile_set_modified(CFCFile *self, int modified)
-{
+CFCFile_set_modified(CFCFile *self, int modified) {
     self->modified = !!modified;
 }
 
 int
-CFCFile_get_modified(CFCFile *self)
-{
+CFCFile_get_modified(CFCFile *self) {
     return self->modified;
 }
 
 const char*
-CFCFile_get_source_class(CFCFile *self)
-{
+CFCFile_get_source_class(CFCFile *self) {
     return self->source_class;
 }
 
 const char*
-CFCFile_guard_name(CFCFile *self)
-{
+CFCFile_guard_name(CFCFile *self) {
     return self->guard_name;
 }
 
 const char*
-CFCFile_guard_start(CFCFile *self)
-{
+CFCFile_guard_start(CFCFile *self) {
     return self->guard_start;
 }
 
 const char*
-CFCFile_guard_close(CFCFile *self)
-{
+CFCFile_guard_close(CFCFile *self) {
     return self->guard_close;
 }
 

Modified: incubator/lucy/trunk/clownfish/src/CFCFile.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCFile.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCFile.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCFile.h Sun May  1 23:50:24 2011
@@ -44,15 +44,15 @@ size_t
 CFCFile_path_buf_size(CFCFile *self, const char *base_dir);
 
 void
-CFCFile_c_path(CFCFile *self, char *buf, size_t buf_size, 
+CFCFile_c_path(CFCFile *self, char *buf, size_t buf_size,
                const char *base_dir);
 
 void
-CFCFile_h_path(CFCFile *self, char *buf, size_t buf_size, 
+CFCFile_h_path(CFCFile *self, char *buf, size_t buf_size,
                const char *base_dir);
 
 void
-CFCFile_cfh_path(CFCFile *self, char *buf, size_t buf_size, 
+CFCFile_cfh_path(CFCFile *self, char *buf, size_t buf_size,
                  const char *base_dir);
 
 struct CFCBase**

Modified: incubator/lucy/trunk/clownfish/src/CFCFunction.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCFunction.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCFunction.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCFunction.c Sun May  1 23:50:24 2011
@@ -35,19 +35,18 @@
 CFCFunction*
 CFCFunction_new(CFCParcel *parcel, const char *exposure,
                 const char *class_name, const char *class_cnick,
-                const char *micro_sym, CFCType *return_type, 
-                CFCParamList *param_list, CFCDocuComment *docucomment, 
-                int is_inline)
-{
+                const char *micro_sym, CFCType *return_type,
+                CFCParamList *param_list, CFCDocuComment *docucomment,
+                int is_inline) {
     CFCFunction *self = (CFCFunction*)CFCBase_allocate(sizeof(CFCFunction),
-        "Clownfish::Function");
+                                                       "Clownfish::Function");
     return CFCFunction_init(self, parcel, exposure, class_name, class_cnick,
-        micro_sym, return_type, param_list, docucomment, is_inline);
+                            micro_sym, return_type, param_list, docucomment,
+                            is_inline);
 }
 
 static int
-S_validate_micro_sym(const char *micro_sym)
-{
+S_validate_micro_sym(const char *micro_sym) {
     size_t i;
     size_t len = strlen(micro_sym);
     if (!len) { return false; }
@@ -60,15 +59,14 @@ S_validate_micro_sym(const char *micro_s
 
 CFCFunction*
 CFCFunction_init(CFCFunction *self, CFCParcel *parcel, const char *exposure,
-               const char *class_name, const char *class_cnick, 
-               const char *micro_sym, CFCType *return_type, 
-               CFCParamList *param_list, CFCDocuComment *docucomment, 
-               int is_inline)
-{
+                 const char *class_name, const char *class_cnick,
+                 const char *micro_sym, CFCType *return_type,
+                 CFCParamList *param_list, CFCDocuComment *docucomment,
+                 int is_inline) {
 
     exposure = exposure ? exposure : "parcel";
     CFCSymbol_init((CFCSymbol*)self, parcel, exposure, class_name,
-        class_cnick, micro_sym);
+                   class_cnick, micro_sym);
     CFCUTIL_NULL_CHECK(class_name);
     CFCUTIL_NULL_CHECK(return_type);
     CFCUTIL_NULL_CHECK(param_list);
@@ -83,8 +81,7 @@ CFCFunction_init(CFCFunction *self, CFCP
 }
 
 void
-CFCFunction_destroy(CFCFunction *self)
-{
+CFCFunction_destroy(CFCFunction *self) {
     CFCBase_decref((CFCBase*)self->return_type);
     CFCBase_decref((CFCBase*)self->param_list);
     CFCBase_decref((CFCBase*)self->docucomment);
@@ -92,44 +89,37 @@ CFCFunction_destroy(CFCFunction *self)
 }
 
 CFCType*
-CFCFunction_get_return_type(CFCFunction *self)
-{
+CFCFunction_get_return_type(CFCFunction *self) {
     return self->return_type;
 }
 
 CFCParamList*
-CFCFunction_get_param_list(CFCFunction *self)
-{
+CFCFunction_get_param_list(CFCFunction *self) {
     return self->param_list;
 }
 
 CFCDocuComment*
-CFCFunction_get_docucomment(CFCFunction *self)
-{
+CFCFunction_get_docucomment(CFCFunction *self) {
     return self->docucomment;
 }
 
 int
-CFCFunction_inline(CFCFunction *self)
-{
+CFCFunction_inline(CFCFunction *self) {
     return self->is_inline;
 }
 
 int
-CFCFunction_void(CFCFunction *self)
-{
+CFCFunction_void(CFCFunction *self) {
     return CFCType_is_void(self->return_type);
 }
 
 const char*
-CFCFunction_full_func_sym(CFCFunction *self)
-{
+CFCFunction_full_func_sym(CFCFunction *self) {
     return CFCSymbol_full_sym((CFCSymbol*)self);
 }
 
 const char*
-CFCFunction_short_func_sym(CFCFunction *self)
-{
+CFCFunction_short_func_sym(CFCFunction *self) {
     return CFCSymbol_short_sym((CFCSymbol*)self);
 }
 

Modified: incubator/lucy/trunk/clownfish/src/CFCFunction.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCFunction.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCFunction.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCFunction.h Sun May  1 23:50:24 2011
@@ -28,29 +28,29 @@ struct CFCDocuComment;
 struct CFCParamList;
 
 #ifdef CFC_NEED_FUNCTION_STRUCT_DEF
-    #define CFC_NEED_SYMBOL_STRUCT_DEF
-    #include "CFCSymbol.h"
-    struct CFCFunction {
-        CFCSymbol symbol;
-        struct CFCType *return_type;
-        struct CFCParamList *param_list;
-        struct CFCDocuComment *docucomment;
-        int   is_inline;
-    };
+#define CFC_NEED_SYMBOL_STRUCT_DEF
+#include "CFCSymbol.h"
+struct CFCFunction {
+    CFCSymbol symbol;
+    struct CFCType *return_type;
+    struct CFCParamList *param_list;
+    struct CFCDocuComment *docucomment;
+    int is_inline;
+};
 #endif
 
 
 CFCFunction*
-CFCFunction_new(struct CFCParcel *parcel, const char *exposure, 
-                const char *class_name, const char *class_cnick, 
-                const char *micro_sym, struct CFCType *return_type, 
-                struct CFCParamList *param_list, 
+CFCFunction_new(struct CFCParcel *parcel, const char *exposure,
+                const char *class_name, const char *class_cnick,
+                const char *micro_sym, struct CFCType *return_type,
+                struct CFCParamList *param_list,
                 struct CFCDocuComment *docucomment, int is_inline);
 
 CFCFunction*
-CFCFunction_init(CFCFunction *self, struct CFCParcel *parcel, 
-                 const char *exposure, const char *class_name, 
-                 const char *class_cnick, const char *micro_sym, 
+CFCFunction_init(CFCFunction *self, struct CFCParcel *parcel,
+                 const char *exposure, const char *class_name,
+                 const char *class_cnick, const char *micro_sym,
                  struct CFCType *return_type, struct CFCParamList *param_list,
                  struct CFCDocuComment *docucomment, int is_inline);
 

Modified: incubator/lucy/trunk/clownfish/src/CFCHierarchy.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCHierarchy.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCHierarchy.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCHierarchy.c Sun May  1 23:50:24 2011
@@ -82,13 +82,12 @@ S_closedir(void *dirhandle, const char *
 // Note: this has to be defined before including the Perl headers because they
 // redefine stat() in an incompatible way on certain systems (Windows).
 static int
-S_is_dir(const char *path)
-{
+S_is_dir(const char *path) {
     struct stat stat_buf;
     int stat_check = stat(path, &stat_buf);
     if (stat_check == -1) {
         CFCUtil_die("Stat failed for '%s': %s", path,
-            strerror(errno));
+                    strerror(errno));
     }
     return (stat_buf.st_mode & S_IFDIR) ? true : false;
 }
@@ -98,17 +97,16 @@ S_is_dir(const char *path)
 #include "XSUB.h"
 
 CFCHierarchy*
-CFCHierarchy_new(const char *source, const char *dest, void *parser)
-{
-    CFCHierarchy *self = (CFCHierarchy*)CFCBase_allocate(sizeof(CFCHierarchy),
-        "Clownfish::Hierarchy");
+CFCHierarchy_new(const char *source, const char *dest, void *parser) {
+    CFCHierarchy *self
+        = (CFCHierarchy*)CFCBase_allocate(sizeof(CFCHierarchy),
+                                          "Clownfish::Hierarchy");
     return CFCHierarchy_init(self, source, dest, parser);
 }
 
 CFCHierarchy*
 CFCHierarchy_init(CFCHierarchy *self, const char *source, const char *dest,
-                  void *parser) 
-{
+                  void *parser) {
     if (!source || !strlen(source) || !dest || !strlen(dest)) {
         croak("Both 'source' and 'dest' are required");
     }
@@ -123,8 +121,7 @@ CFCHierarchy_init(CFCHierarchy *self, co
 }
 
 void
-CFCHierarchy_destroy(CFCHierarchy *self)
-{
+CFCHierarchy_destroy(CFCHierarchy *self) {
     size_t i;
     for (i = 0; self->trees[i] != NULL; i++) {
         CFCBase_decref((CFCBase*)self->trees[i]);
@@ -141,8 +138,7 @@ CFCHierarchy_destroy(CFCHierarchy *self)
 }
 
 void
-CFCHierarchy_build(CFCHierarchy *self)
-{
+CFCHierarchy_build(CFCHierarchy *self) {
     S_parse_cf_files(self);
     size_t i;
     for (i = 0; self->trees[i] != NULL; i++) {
@@ -151,8 +147,7 @@ CFCHierarchy_build(CFCHierarchy *self)
 }
 
 static CFCFile*
-S_parse_file(void *parser, const char *content, const char *source_class)
-{
+S_parse_file(void *parser, const char *content, const char *source_class) {
     dSP;
     ENTER;
     SAVETMPS;
@@ -186,8 +181,7 @@ S_parse_file(void *parser, const char *c
 }
 
 static char**
-S_find_cfh(char *dir, char **cfh_list, size_t num_cfh)
-{
+S_find_cfh(char *dir, char **cfh_list, size_t num_cfh) {
     void *dirhandle = S_opendir(dir);
     size_t full_path_cap = strlen(dir) * 2;
     char *full_path = (char*)MALLOCATE(full_path_cap);
@@ -209,8 +203,8 @@ S_find_cfh(char *dir, char **cfh_list, s
         const char *cfh_suffix = strstr(full_path, ".cfh");
 
         if (cfh_suffix == full_path + (full_path_len - 4)) {
-            cfh_list = (char**)REALLOCATE(cfh_list, 
-                (num_cfh + 2) * sizeof(char*));
+            cfh_list = (char**)REALLOCATE(cfh_list,
+                                          (num_cfh + 2) * sizeof(char*));
             cfh_list[num_cfh++] = CFCUtil_strdup(full_path);
             cfh_list[num_cfh] = NULL;
         }
@@ -229,8 +223,7 @@ S_find_cfh(char *dir, char **cfh_list, s
 }
 
 static void
-S_parse_cf_files(CFCHierarchy *self)
-{
+S_parse_cf_files(CFCHierarchy *self) {
     char **all_source_paths = (char**)CALLOCATE(1, sizeof(char*));
     all_source_paths = S_find_cfh(self->source, all_source_paths, 0);
     const char *source_dir = self->source;
@@ -238,7 +231,7 @@ S_parse_cf_files(CFCHierarchy *self)
     size_t all_classes_cap = 10;
     size_t num_classes     = 0;
     CFCClass **all_classes = (CFCClass**)MALLOCATE(
-        (all_classes_cap + 1) * sizeof(CFCClass*));
+                                 (all_classes_cap + 1) * sizeof(CFCClass*));
     char *source_class = NULL;
     size_t source_class_max = 0;
 
@@ -250,7 +243,7 @@ S_parse_cf_files(CFCHierarchy *self)
         size_t source_path_len = strlen(source_path);
         if (strncmp(source_path, source_dir, source_dir_len) != 0) {
             CFCUtil_die("'%s' doesn't start with '%s'", source_path,
-                source_dir);
+                        source_dir);
         }
         size_t j;
         size_t source_class_len = 0;
@@ -280,13 +273,14 @@ S_parse_cf_files(CFCHierarchy *self)
             croak("parser error for %s", source_path);
         }
         S_add_file(self, file);
-        
+
         CFCClass **classes_in_file = CFCFile_classes(file);
         for (j = 0; classes_in_file[j] != NULL; j++) {
             if (num_classes == all_classes_cap) {
                 all_classes_cap += 10;
-                all_classes = (CFCClass**)REALLOCATE(all_classes, 
-                    (all_classes_cap + 1) * sizeof(CFCClass*));
+                all_classes = (CFCClass**)REALLOCATE(
+                                  all_classes,
+                                  (all_classes_cap + 1) * sizeof(CFCClass*));
             }
             all_classes[num_classes++] = classes_in_file[j];
         }
@@ -304,7 +298,7 @@ S_parse_cf_files(CFCHierarchy *self)
                 if (!maybe_parent) {
                     CFCUtil_die("Parent class '%s' not defined", parent_name);
                 }
-                const char *maybe_parent_name 
+                const char *maybe_parent_name
                     = CFCSymbol_get_class_name((CFCSymbol*)maybe_parent);
                 if (strcmp(parent_name, maybe_parent_name) == 0) {
                     CFCClass_add_child(maybe_parent, klass);
@@ -326,8 +320,7 @@ S_parse_cf_files(CFCHierarchy *self)
 }
 
 int
-CFCHierarchy_propagate_modified(CFCHierarchy *self, int modified)
-{
+CFCHierarchy_propagate_modified(CFCHierarchy *self, int modified) {
     // Seed the recursive write.
     int somebody_is_modified = false;
     size_t i;
@@ -337,8 +330,8 @@ CFCHierarchy_propagate_modified(CFCHiera
             somebody_is_modified = true;
         }
     }
-    if (somebody_is_modified || modified) { 
-        return true; 
+    if (somebody_is_modified || modified) {
+        return true;
     }
     else {
         return false;
@@ -346,8 +339,7 @@ CFCHierarchy_propagate_modified(CFCHiera
 }
 
 int
-S_do_propagate_modified(CFCHierarchy *self, CFCClass *klass, int modified)
-{
+S_do_propagate_modified(CFCHierarchy *self, CFCClass *klass, int modified) {
     const char *source_class = CFCClass_get_source_class(klass);
     CFCFile *file = S_fetch_file(self, source_class);
     size_t cfh_buf_size = CFCFile_path_buf_size(file, self->source);
@@ -372,8 +364,8 @@ S_do_propagate_modified(CFCHierarchy *se
         CFCClass *kid = children[i];
         if (CFCClass_final(klass)) {
             CFCUtil_die("Attempt to inherit from final class '%s' by '%s'",
-                CFCSymbol_get_class_name((CFCSymbol*)klass),
-                CFCSymbol_get_class_name((CFCSymbol*)kid));
+                        CFCSymbol_get_class_name((CFCSymbol*)klass),
+                        CFCSymbol_get_class_name((CFCSymbol*)kid));
         }
         if (S_do_propagate_modified(self, kid, modified)) {
             somebody_is_modified = 1;
@@ -384,8 +376,7 @@ S_do_propagate_modified(CFCHierarchy *se
 }
 
 static void
-S_add_tree(CFCHierarchy *self, CFCClass *klass)
-{
+S_add_tree(CFCHierarchy *self, CFCClass *klass) {
     CFCUTIL_NULL_CHECK(klass);
     const char *full_struct_sym = CFCClass_full_struct_sym(klass);
     size_t i;
@@ -398,17 +389,17 @@ S_add_tree(CFCHierarchy *self, CFCClass 
     self->num_trees++;
     size_t size = (self->num_trees + 1) * sizeof(CFCClass*);
     self->trees = (CFCClass**)REALLOCATE(self->trees, size);
-    self->trees[self->num_trees - 1] 
+    self->trees[self->num_trees - 1]
         = (CFCClass*)CFCBase_incref((CFCBase*)klass);
     self->trees[self->num_trees] = NULL;
 }
 
 CFCClass**
-CFCHierarchy_ordered_classes(CFCHierarchy *self)
-{
+CFCHierarchy_ordered_classes(CFCHierarchy *self) {
     size_t num_classes = 0;
     size_t max_classes = 10;
-    CFCClass **ladder = (CFCClass**)MALLOCATE((max_classes + 1) * sizeof(CFCClass*));
+    CFCClass **ladder = (CFCClass**)MALLOCATE(
+                            (max_classes + 1) * sizeof(CFCClass*));
     size_t i;
     for (i = 0; self->trees[i] != NULL; i++) {
         CFCClass *tree = self->trees[i];
@@ -417,8 +408,8 @@ CFCHierarchy_ordered_classes(CFCHierarch
         for (j = 0; child_ladder[j] != NULL; j++) {
             if (num_classes == max_classes) {
                 max_classes += 10;
-                ladder = (CFCClass**)REALLOCATE(ladder, 
-                    (max_classes + 1) * sizeof(CFCClass*));
+                ladder = (CFCClass**)REALLOCATE(
+                             ladder, (max_classes + 1) * sizeof(CFCClass*));
             }
             ladder[num_classes++] = child_ladder[j];
         }
@@ -429,8 +420,7 @@ CFCHierarchy_ordered_classes(CFCHierarch
 }
 
 static CFCFile*
-S_fetch_file(CFCHierarchy *self, const char *source_class)
-{
+S_fetch_file(CFCHierarchy *self, const char *source_class) {
     size_t i;
     for (i = 0; self->files[i] != NULL; i++) {
         const char *existing = CFCFile_get_source_class(self->files[i]);
@@ -442,8 +432,7 @@ S_fetch_file(CFCHierarchy *self, const c
 }
 
 static void
-S_add_file(CFCHierarchy *self, CFCFile *file)
-{
+S_add_file(CFCHierarchy *self, CFCFile *file) {
     CFCUTIL_NULL_CHECK(file);
     const char *source_class = CFCFile_get_source_class(file);
     CFCClass **classes = CFCFile_classes(file);
@@ -452,21 +441,21 @@ S_add_file(CFCHierarchy *self, CFCFile *
         CFCFile *existing = self->files[i];
         const char *old_source_class = CFCFile_get_source_class(existing);
         if (strcmp(source_class, old_source_class) == 0) {
-            CFCUtil_die("File for source class %s already registered", 
-                source_class);
+            CFCUtil_die("File for source class %s already registered",
+                        source_class);
         }
         CFCClass **existing_classes = CFCFile_classes(existing);
         size_t j;
         for (j = 0; classes[j] != NULL; j++) {
             const char *new_class_name
                 = CFCSymbol_get_class_name((CFCSymbol*)classes[j]);
-            size_t k; 
+            size_t k;
             for (k = 0; existing_classes[k] != NULL; k++) {
                 const char *existing_class_name
                     = CFCSymbol_get_class_name((CFCSymbol*)existing_classes[k]);
                 if (strcmp(new_class_name, existing_class_name) == 0) {
                     CFCUtil_die("Class '%s' already registered",
-                        new_class_name);
+                                new_class_name);
                 }
             }
         }
@@ -474,26 +463,23 @@ S_add_file(CFCHierarchy *self, CFCFile *
     self->num_files++;
     size_t size = (self->num_files + 1) * sizeof(CFCFile*);
     self->files = (CFCFile**)REALLOCATE(self->files, size);
-    self->files[self->num_files - 1] 
+    self->files[self->num_files - 1]
         = (CFCFile*)CFCBase_incref((CFCBase*)file);
     self->files[self->num_files] = NULL;
 }
 
 struct CFCFile**
-CFCHierarchy_files(CFCHierarchy *self)
-{
+CFCHierarchy_files(CFCHierarchy *self) {
     return self->files;
 }
 
 const char*
-CFCHierarchy_get_source(CFCHierarchy *self)
-{
+CFCHierarchy_get_source(CFCHierarchy *self) {
     return self->source;
 }
 
 const char*
-CFCHierarchy_get_dest(CFCHierarchy *self)
-{
+CFCHierarchy_get_dest(CFCHierarchy *self) {
     return self->dest;
 }
 
@@ -510,8 +496,7 @@ typedef struct WinDH {
 } WinDH;
 
 static void*
-S_opendir(const char *dir)
-{
+S_opendir(const char *dir) {
     size_t dirlen = strlen(dir);
     if (dirlen >= MAX_PATH - 2) {
         CFCUtil_die("Exceeded MAX_PATH(%d): %s", (int)MAX_PATH, dir);
@@ -533,8 +518,7 @@ S_opendir(const char *dir)
 }
 
 static const char*
-S_next_entry(void *dirhandle)
-{
+S_next_entry(void *dirhandle) {
     WinDH *dh = (WinDH*)dirhandle;
     if (dh->first_time) {
         dh->first_time = false;
@@ -542,8 +526,8 @@ S_next_entry(void *dirhandle)
     else {
         if ((FindNextFile(dh->handle, dh->find_data) == 0)) {
             if (GetLastError() != ERROR_NO_MORE_FILES) {
-                CFCUtil_die("Error occurred while reading '%s'", 
-                    dh->path);
+                CFCUtil_die("Error occurred while reading '%s'",
+                            dh->path);
             }
             return NULL;
         }
@@ -552,8 +536,7 @@ S_next_entry(void *dirhandle)
 }
 
 static void
-S_closedir(void *dirhandle, const char *dir)
-{
+S_closedir(void *dirhandle, const char *dir) {
     WinDH *dh = (WinDH*)dirhandle;
     if (!FindClose(dh->handle)) {
         CFCUtil_die("Error occurred while closing dir '%s'", dir);
@@ -563,13 +546,12 @@ S_closedir(void *dirhandle, const char *
 }
 
 /******************************** UNIXEN ***********************************/
-#else 
+#else
 
 #include <dirent.h>
 
 static void*
-S_opendir(const char *dir)
-{
+S_opendir(const char *dir) {
     DIR *dirhandle = opendir(dir);
     if (!dirhandle) {
         CFCUtil_die("Failed to opendir for '%s': %s", dir, strerror(errno));
@@ -578,15 +560,13 @@ S_opendir(const char *dir)
 }
 
 static const char*
-S_next_entry(void *dirhandle)
-{
+S_next_entry(void *dirhandle) {
     struct dirent *entry = readdir((DIR*)dirhandle);
     return entry ? entry->d_name : NULL;
 }
 
 static void
-S_closedir(void *dirhandle, const char *dir)
-{
+S_closedir(void *dirhandle, const char *dir) {
     if (closedir(dirhandle) == -1) {
         CFCUtil_die("Error closing dir '%s': %s", dir, strerror(errno));
     }

Modified: incubator/lucy/trunk/clownfish/src/CFCHierarchy.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCHierarchy.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCHierarchy.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCHierarchy.h Sun May  1 23:50:24 2011
@@ -29,7 +29,7 @@ CFCHierarchy*
 CFCHierarchy_new(const char *source, const char *dest, void *parser);
 
 CFCHierarchy*
-CFCHierarchy_init(CFCHierarchy *self, const char *source, const char *dest, 
+CFCHierarchy_init(CFCHierarchy *self, const char *source, const char *dest,
                   void *parser);
 
 void

Modified: incubator/lucy/trunk/clownfish/src/CFCMethod.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCMethod.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCMethod.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCMethod.c Sun May  1 23:50:24 2011
@@ -51,20 +51,18 @@ S_update_typedefs(CFCMethod *self, const
 
 CFCMethod*
 CFCMethod_new(CFCParcel *parcel, const char *exposure, const char *class_name,
-              const char *class_cnick, const char *macro_sym, 
-              CFCType *return_type, CFCParamList *param_list, 
-              CFCDocuComment *docucomment, int is_final, int is_abstract)
-{
+              const char *class_cnick, const char *macro_sym,
+              CFCType *return_type, CFCParamList *param_list,
+              CFCDocuComment *docucomment, int is_final, int is_abstract) {
     CFCMethod *self = (CFCMethod*)CFCBase_allocate(sizeof(CFCMethod),
-        "Clownfish::Method");
+                                                   "Clownfish::Method");
     return CFCMethod_init(self, parcel, exposure, class_name, class_cnick,
-        macro_sym, return_type, param_list, docucomment, is_final, 
-        is_abstract);
+                          macro_sym, return_type, param_list, docucomment,
+                          is_final, is_abstract);
 }
 
 static int
-S_validate_macro_sym(const char *macro_sym)
-{
+S_validate_macro_sym(const char *macro_sym) {
     if (!macro_sym || !strlen(macro_sym)) { return false; }
 
     int need_upper  = true;
@@ -76,7 +74,7 @@ S_validate_macro_sym(const char *macro_s
         need_letter = false;
 
         // We've reached NULL-termination without problems, so succeed.
-        if (!*macro_sym) { return true; } 
+        if (!*macro_sym) { return true; }
 
         if (!isalnum(*macro_sym)) {
             if (*macro_sym != '_') { return false; }
@@ -86,12 +84,11 @@ S_validate_macro_sym(const char *macro_s
 }
 
 CFCMethod*
-CFCMethod_init(CFCMethod *self, CFCParcel *parcel, const char *exposure, 
-               const char *class_name, const char *class_cnick, 
-               const char *macro_sym, CFCType *return_type, 
-               CFCParamList *param_list, CFCDocuComment *docucomment, 
-               int is_final, int is_abstract)
-{
+CFCMethod_init(CFCMethod *self, CFCParcel *parcel, const char *exposure,
+               const char *class_name, const char *class_cnick,
+               const char *macro_sym, CFCType *return_type,
+               CFCParamList *param_list, CFCDocuComment *docucomment,
+               int is_final, int is_abstract) {
     // Validate macro_sym, derive micro_sym.
     if (!S_validate_macro_sym(macro_sym)) {
         croak("Invalid macro_sym: '%s'", macro_sym ? macro_sym : "[NULL]");
@@ -104,8 +101,8 @@ CFCMethod_init(CFCMethod *self, CFCParce
 
     // Super-init and clean up derived micro_sym.
     CFCFunction_init((CFCFunction*)self, parcel, exposure, class_name,
-        class_cnick, micro_sym, return_type, param_list, docucomment,
-        false);
+                     class_cnick, micro_sym, return_type, param_list,
+                     docucomment, false);
     FREEMEM(micro_sym);
 
     // Verify that the first element in the arg list is a self.
@@ -120,9 +117,9 @@ CFCMethod_init(CFCMethod *self, CFCParce
     sprintf(wanted, "%s%s", prefix, struct_sym);
     int mismatch = strcmp(wanted, specifier);
     FREEMEM(wanted);
-    if (mismatch) { 
+    if (mismatch) {
         croak("First arg type doesn't match class: '%s' '%s", class_name,
-            specifier);
+              specifier);
     }
 
     self->macro_sym     = CFCUtil_strdup(macro_sym);
@@ -136,8 +133,8 @@ CFCMethod_init(CFCMethod *self, CFCParce
     size_t amount = strlen(full_func_sym) + sizeof("_OVERRIDE") + 1;
     self->full_callback_sym = (char*)MALLOCATE(amount);
     self->full_override_sym = (char*)MALLOCATE(amount);
-    int check = sprintf(self->full_callback_sym, "%s_CALLBACK", 
-        full_func_sym);
+    int check = sprintf(self->full_callback_sym, "%s_CALLBACK",
+                        full_func_sym);
     if (check < 0) { croak("sprintf failed"); }
     check = sprintf(self->full_override_sym, "%s_OVERRIDE", full_func_sym);
     if (check < 0) { croak("sprintf failed"); }
@@ -153,8 +150,7 @@ CFCMethod_init(CFCMethod *self, CFCParce
 }
 
 void
-CFCMethod_destroy(CFCMethod *self)
-{
+CFCMethod_destroy(CFCMethod *self) {
     FREEMEM(self->macro_sym);
     FREEMEM(self->short_typedef);
     FREEMEM(self->full_typedef);
@@ -164,8 +160,7 @@ CFCMethod_destroy(CFCMethod *self)
 }
 
 int
-CFCMethod_compatible(CFCMethod *self, CFCMethod *other)
-{
+CFCMethod_compatible(CFCMethod *self, CFCMethod *other) {
     if (!other) { return false; }
     if (strcmp(self->macro_sym, other->macro_sym)) { return false; }
     int my_public = CFCSymbol_public((CFCSymbol*)self);
@@ -187,8 +182,8 @@ CFCMethod_compatible(CFCMethod *self, CF
             if (strcmp(my_vals[i], other_vals[i])) { return false; }
         }
         if (my_args[i]) {
-            if (!CFCVariable_equals(my_args[i], other_args[i])) { 
-                return false; 
+            if (!CFCVariable_equals(my_args[i], other_args[i])) {
+                return false;
             }
         }
         else {
@@ -212,14 +207,13 @@ CFCMethod_compatible(CFCMethod *self, CF
 }
 
 void
-CFCMethod_override(CFCMethod *self, CFCMethod *orig)
-{
+CFCMethod_override(CFCMethod *self, CFCMethod *orig) {
     // Check that the override attempt is legal.
     if (CFCMethod_final(orig)) {
         const char *orig_class = CFCSymbol_get_class_name((CFCSymbol*)orig);
         const char *my_class   = CFCSymbol_get_class_name((CFCSymbol*)self);
         croak("Attempt to override final method '%s' from '%s' by '%s'",
-            orig->macro_sym, orig_class, my_class);
+              orig->macro_sym, orig_class, my_class);
     }
     if (!CFCMethod_compatible(self, orig)) {
         const char *func      = CFCFunction_full_func_sym((CFCFunction*)self);
@@ -232,26 +226,26 @@ CFCMethod_override(CFCMethod *self, CFCM
 }
 
 CFCMethod*
-CFCMethod_finalize(CFCMethod *self)
-{
-    CFCSymbol *self_sym = (CFCSymbol*)self;
-    CFCParcel *parcel = CFCSymbol_get_parcel(self_sym);
-    const char *exposure = CFCSymbol_get_exposure(self_sym);
-    const char *class_name = CFCSymbol_get_class_name(self_sym);
+CFCMethod_finalize(CFCMethod *self) {
+    CFCSymbol  *self_sym    = (CFCSymbol*)self;
+    CFCParcel  *parcel      = CFCSymbol_get_parcel(self_sym);
+    const char *exposure    = CFCSymbol_get_exposure(self_sym);
+    const char *class_name  = CFCSymbol_get_class_name(self_sym);
     const char *class_cnick = CFCSymbol_get_class_cnick(self_sym);
-    CFCMethod *finalized = CFCMethod_new(parcel, exposure, class_name,
-        class_cnick, self->macro_sym, self->function.return_type,
-        self->function.param_list, self->function.docucomment, true,
-        self->is_abstract);
+    CFCMethod  *finalized
+        = CFCMethod_new(parcel, exposure, class_name, class_cnick,
+                        self->macro_sym, self->function.return_type,
+                        self->function.param_list,
+                        self->function.docucomment, true,
+                        self->is_abstract);
     finalized->is_novel = self->is_final; // Is this right?
     S_update_typedefs(finalized, CFCSymbol_short_sym((CFCSymbol*)self));
     return finalized;
 }
 
 size_t
-CFCMethod_short_method_sym(CFCMethod *self, const char *invoker, char *buf, 
-                           size_t buf_size)
-{
+CFCMethod_short_method_sym(CFCMethod *self, const char *invoker, char *buf,
+                           size_t buf_size) {
     CFCUTIL_NULL_CHECK(invoker);
     size_t needed = strlen(invoker) + 1 + strlen(self->macro_sym) + 1;
     if (buf_size >= needed) {
@@ -262,13 +256,15 @@ CFCMethod_short_method_sym(CFCMethod *se
 }
 
 size_t
-CFCMethod_full_method_sym(CFCMethod *self, const char *invoker, char *buf, 
-                          size_t buf_size)
-{
+CFCMethod_full_method_sym(CFCMethod *self, const char *invoker, char *buf,
+                          size_t buf_size) {
     CFCUTIL_NULL_CHECK(invoker);
     const char *Prefix = CFCSymbol_get_Prefix((CFCSymbol*)self);
-    size_t needed = strlen(Prefix) + strlen(invoker) + 1 
-                  + strlen(self->macro_sym) + 1;
+    size_t needed = strlen(Prefix)
+                    + strlen(invoker)
+                    + 1
+                    + strlen(self->macro_sym)
+                    + 1;
     if (buf_size >= needed) {
         int check = sprintf(buf, "%s%s_%s", Prefix, invoker, self->macro_sym);
         if (check < 0) { croak("sprintf failed"); }
@@ -277,12 +273,11 @@ CFCMethod_full_method_sym(CFCMethod *sel
 }
 
 size_t
-CFCMethod_full_offset_sym(CFCMethod *self, const char *invoker, char *buf, 
-                          size_t buf_size)
-{
+CFCMethod_full_offset_sym(CFCMethod *self, const char *invoker, char *buf,
+                          size_t buf_size) {
     CFCUTIL_NULL_CHECK(invoker);
-    size_t needed = CFCMethod_full_method_sym(self, invoker, NULL, 0) 
-                  + strlen("_OFFSET");
+    size_t needed = CFCMethod_full_method_sym(self, invoker, NULL, 0)
+                    + strlen("_OFFSET");
     if (buf_size >= needed) {
         CFCMethod_full_method_sym(self, invoker, buf, buf_size);
         strcat(buf, "_OFFSET");
@@ -291,14 +286,12 @@ CFCMethod_full_offset_sym(CFCMethod *sel
 }
 
 const char*
-CFCMethod_get_macro_sym(CFCMethod *self)
-{
+CFCMethod_get_macro_sym(CFCMethod *self) {
     return self->macro_sym;
 }
 
 static void
-S_update_typedefs(CFCMethod *self, const char *short_sym)
-{
+S_update_typedefs(CFCMethod *self, const char *short_sym) {
     FREEMEM(self->short_typedef);
     FREEMEM(self->full_typedef);
     if (short_sym) {
@@ -319,50 +312,42 @@ S_update_typedefs(CFCMethod *self, const
 }
 
 const char*
-CFCMethod_short_typedef(CFCMethod *self)
-{
+CFCMethod_short_typedef(CFCMethod *self) {
     return self->short_typedef;
 }
 
 const char*
-CFCMethod_full_typedef(CFCMethod *self)
-{
+CFCMethod_full_typedef(CFCMethod *self) {
     return self->full_typedef;
 }
 
 const char*
-CFCMethod_full_callback_sym(CFCMethod *self)
-{
+CFCMethod_full_callback_sym(CFCMethod *self) {
     return self->full_callback_sym;
 }
 
 const char*
-CFCMethod_full_override_sym(CFCMethod *self)
-{
+CFCMethod_full_override_sym(CFCMethod *self) {
     return self->full_override_sym;
 }
 
 int
-CFCMethod_final(CFCMethod *self)
-{
+CFCMethod_final(CFCMethod *self) {
     return self->is_final;
 }
 
 int
-CFCMethod_abstract(CFCMethod *self)
-{
+CFCMethod_abstract(CFCMethod *self) {
     return self->is_abstract;
 }
 
 int
-CFCMethod_novel(CFCMethod *self)
-{
+CFCMethod_novel(CFCMethod *self) {
     return self->is_novel;
 }
 
 CFCType*
-CFCMethod_self_type(CFCMethod *self)
-{
+CFCMethod_self_type(CFCMethod *self) {
     CFCVariable **vars = CFCParamList_get_variables(self->function.param_list);
     return CFCVariable_get_type(vars[0]);
 }

Modified: incubator/lucy/trunk/clownfish/src/CFCMethod.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCMethod.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCMethod.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCMethod.h Sun May  1 23:50:24 2011
@@ -28,19 +28,19 @@ struct CFCParamList;
 struct CFCDocuComment;
 
 CFCMethod*
-CFCMethod_new(struct CFCParcel *parcel, const char *exposure, 
-              const char *class_name, const char *class_cnick, 
-              const char *macro_sym, struct CFCType *return_type, 
-              struct CFCParamList *param_list, 
-              struct CFCDocuComment *docucomment, int is_final, 
+CFCMethod_new(struct CFCParcel *parcel, const char *exposure,
+              const char *class_name, const char *class_cnick,
+              const char *macro_sym, struct CFCType *return_type,
+              struct CFCParamList *param_list,
+              struct CFCDocuComment *docucomment, int is_final,
               int is_abstract);
 
 CFCMethod*
 CFCMethod_init(CFCMethod *self, struct CFCParcel *parcel,
-               const char *exposure, const char *class_name, 
-               const char *class_cnick, const char *macro_sym, 
+               const char *exposure, const char *class_name,
+               const char *class_cnick, const char *macro_sym,
                struct CFCType *return_type, struct CFCParamList *param_list,
-               struct CFCDocuComment *docucomment, int is_final, 
+               struct CFCDocuComment *docucomment, int is_final,
                int is_abstract);
 
 void
@@ -59,21 +59,21 @@ CFCMethod_finalize(CFCMethod *self);
  * @return the number of bytes which the symbol would occupy.
  */
 size_t
-CFCMethod_short_method_sym(CFCMethod *self, const char *invoker, char *buf, 
+CFCMethod_short_method_sym(CFCMethod *self, const char *invoker, char *buf,
                            size_t buf_size);
 
 /**
  * @return the number of bytes which the symbol would occupy.
  */
 size_t
-CFCMethod_full_method_sym(CFCMethod *self, const char *invoker, char *buf, 
+CFCMethod_full_method_sym(CFCMethod *self, const char *invoker, char *buf,
                           size_t buf_size);
 
 /**
  * @return the number of bytes which the symbol would occupy.
  */
 size_t
-CFCMethod_full_offset_sym(CFCMethod *self, const char *invoker, char *buf, 
+CFCMethod_full_offset_sym(CFCMethod *self, const char *invoker, char *buf,
                           size_t buf_size);
 
 const char*

Modified: incubator/lucy/trunk/clownfish/src/CFCParamList.c
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCParamList.c?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCParamList.c (original)
+++ incubator/lucy/trunk/clownfish/src/CFCParamList.c Sun May  1 23:50:24 2011
@@ -41,16 +41,14 @@ static void
 S_generate_c_strings(CFCParamList *self);
 
 CFCParamList*
-CFCParamList_new(int variadic)
-{
-    CFCParamList *self = (CFCParamList*)CFCBase_allocate(sizeof(CFCParamList), 
-        "Clownfish::ParamList");
+CFCParamList_new(int variadic) {
+    CFCParamList *self = (CFCParamList*)CFCBase_allocate(sizeof(CFCParamList),
+                                                         "Clownfish::ParamList");
     return CFCParamList_init(self, variadic);
 }
 
 CFCParamList*
-CFCParamList_init(CFCParamList *self, int variadic)
-{
+CFCParamList_init(CFCParamList *self, int variadic) {
     self->variadic  = variadic;
     self->num_vars  = 0;
     self->variables = (CFCVariable**)CALLOCATE(1, sizeof(void*));
@@ -60,15 +58,14 @@ CFCParamList_init(CFCParamList *self, in
 }
 
 void
-CFCParamList_add_param(CFCParamList *self, CFCVariable *variable, 
-                       const char *value)
-{
+CFCParamList_add_param(CFCParamList *self, CFCVariable *variable,
+                       const char *value) {
     CFCUTIL_NULL_CHECK(variable);
     self->num_vars++;
     size_t amount = (self->num_vars + 1) * sizeof(void*);
     self->variables = (CFCVariable**)REALLOCATE(self->variables, amount);
     self->values    = (char**)REALLOCATE(self->values, amount);
-    self->variables[self->num_vars - 1] 
+    self->variables[self->num_vars - 1]
         = (CFCVariable*)CFCBase_incref((CFCBase*)variable);
     self->values[self->num_vars - 1] = value ? CFCUtil_strdup(value) : NULL;
     self->variables[self->num_vars] = NULL;
@@ -78,8 +75,7 @@ CFCParamList_add_param(CFCParamList *sel
 }
 
 void
-CFCParamList_destroy(CFCParamList *self)
-{
+CFCParamList_destroy(CFCParamList *self) {
     size_t i;
     for (i = 0; i < self->num_vars; i++) {
         CFCBase_decref((CFCBase*)self->variables[i]);
@@ -93,8 +89,7 @@ CFCParamList_destroy(CFCParamList *self)
 }
 
 static void
-S_generate_c_strings(CFCParamList *self)
-{
+S_generate_c_strings(CFCParamList *self) {
     size_t c_string_size = 1;
     size_t name_list_size = 1;
     size_t i;
@@ -135,38 +130,32 @@ S_generate_c_strings(CFCParamList *self)
 }
 
 CFCVariable**
-CFCParamList_get_variables(CFCParamList *self)
-{
+CFCParamList_get_variables(CFCParamList *self) {
     return self->variables;
 }
 
 const char**
-CFCParamList_get_initial_values(CFCParamList *self)
-{
+CFCParamList_get_initial_values(CFCParamList *self) {
     return (const char**)self->values;
 }
 
 size_t
-CFCParamList_num_vars(CFCParamList *self)
-{
+CFCParamList_num_vars(CFCParamList *self) {
     return self->num_vars;
 }
 
 int
-CFCParamList_variadic(CFCParamList *self)
-{
+CFCParamList_variadic(CFCParamList *self) {
     return self->variadic;
 }
 
 const char*
-CFCParamList_to_c(CFCParamList *self)
-{
+CFCParamList_to_c(CFCParamList *self) {
     return self->c_string;
 }
 
 const char*
-CFCParamList_name_list(CFCParamList *self)
-{
+CFCParamList_name_list(CFCParamList *self) {
     return self->name_list;
 }
 

Modified: incubator/lucy/trunk/clownfish/src/CFCParamList.h
URL: http://svn.apache.org/viewvc/incubator/lucy/trunk/clownfish/src/CFCParamList.h?rev=1098445&r1=1098444&r2=1098445&view=diff
==============================================================================
--- incubator/lucy/trunk/clownfish/src/CFCParamList.h (original)
+++ incubator/lucy/trunk/clownfish/src/CFCParamList.h Sun May  1 23:50:24 2011
@@ -34,7 +34,7 @@ void
 CFCParamList_destroy(CFCParamList *self);
 
 void
-CFCParamList_add_param(CFCParamList *self, struct CFCVariable *variable,  
+CFCParamList_add_param(CFCParamList *self, struct CFCVariable *variable,
                        const char *value);
 
 struct CFCVariable**



Mime
View raw message