Improve syntax style consistency in shape.c and shape.h

byroot · byroot · commit 18dac125cb48 · 2025-04-30T08:10:55.000+02:00
Most of this code use the `type * name` style, while the
overwhemling majority of the rest of ruby use the `type *name`
style.

This is a cosmetic change, but helps with readability.
diff --git a/object.c b/object.c
@@ -329,7 +329,7 @@ rb_obj_copy_ivar(VALUE dest, VALUE obj)
     RUBY_ASSERT(!RB_TYPE_P(obj, T_CLASS) && !RB_TYPE_P(obj, T_MODULE));
 
     RUBY_ASSERT(BUILTIN_TYPE(dest) == BUILTIN_TYPE(obj));
-    rb_shape_t * src_shape = rb_shape_get_shape(obj);
+    rb_shape_t *src_shape = rb_shape_get_shape(obj);
 
     if (rb_shape_obj_too_complex(obj)) {
         // obj is TOO_COMPLEX so we can copy its iv_hash
@@ -340,7 +340,7 @@ rb_obj_copy_ivar(VALUE dest, VALUE obj)
     }
 
     uint32_t src_num_ivs = RBASIC_IV_COUNT(obj);
-    rb_shape_t * shape_to_set_on_dest = src_shape;
+    rb_shape_t *shape_to_set_on_dest = src_shape;
     VALUE * src_buf;
     VALUE * dest_buf;
 
@@ -356,7 +356,7 @@ rb_obj_copy_ivar(VALUE dest, VALUE obj)
     src_buf = ROBJECT_IVPTR(obj);
     dest_buf = ROBJECT_IVPTR(dest);
 
-    rb_shape_t * initial_shape = rb_shape_get_shape(dest);
+    rb_shape_t *initial_shape = rb_shape_get_shape(dest);
 
     if (initial_shape->heap_index != src_shape->heap_index) {
         RUBY_ASSERT(initial_shape->type == SHAPE_T_OBJECT);
@@ -506,7 +506,7 @@ rb_obj_clone_setup(VALUE obj, VALUE clone, VALUE kwfreeze)
         }
 
         if (RB_OBJ_FROZEN(obj)) {
-            rb_shape_t * next_shape = rb_shape_transition_shape_frozen(clone);
+            rb_shape_t *next_shape = rb_shape_transition_shape_frozen(clone);
             if (!rb_shape_obj_too_complex(clone) && next_shape->type == SHAPE_OBJ_TOO_COMPLEX) {
                 rb_evict_ivars_to_hash(clone);
             }
@@ -528,7 +528,7 @@ rb_obj_clone_setup(VALUE obj, VALUE clone, VALUE kwfreeze)
         argv[1] = freeze_true_hash;
         rb_funcallv_kw(clone, id_init_clone, 2, argv, RB_PASS_KEYWORDS);
         RBASIC(clone)->flags |= FL_FREEZE;
-        rb_shape_t * next_shape = rb_shape_transition_shape_frozen(clone);
+        rb_shape_t *next_shape = rb_shape_transition_shape_frozen(clone);
         // If we're out of shapes, but we want to freeze, then we need to
         // evacuate this clone to a hash
         if (!rb_shape_obj_too_complex(clone) && next_shape->type == SHAPE_OBJ_TOO_COMPLEX) {
diff --git a/shape.c b/shape.c
@@ -51,33 +51,33 @@ static ID id_t_object;
 #define RED 0x1
 
 static redblack_node_t *
-redblack_left(redblack_node_t * node)
+redblack_left(redblack_node_t *node)
 {
     if (node->l == LEAF) {
         return LEAF;
     }
     else {
         RUBY_ASSERT(node->l < GET_SHAPE_TREE()->cache_size);
-        redblack_node_t * left = &GET_SHAPE_TREE()->shape_cache[node->l - 1];
+        redblack_node_t *left = &GET_SHAPE_TREE()->shape_cache[node->l - 1];
         return left;
     }
 }
 
 static redblack_node_t *
-redblack_right(redblack_node_t * node)
+redblack_right(redblack_node_t *node)
 {
     if (node->r == LEAF) {
         return LEAF;
     }
     else {
         RUBY_ASSERT(node->r < GET_SHAPE_TREE()->cache_size);
-        redblack_node_t * right = &GET_SHAPE_TREE()->shape_cache[node->r - 1];
+        redblack_node_t *right = &GET_SHAPE_TREE()->shape_cache[node->r - 1];
         return right;
     }
 }
 
 static redblack_node_t *
-redblack_find(redblack_node_t * tree, ID key)
+redblack_find(redblack_node_t *tree, ID key)
 {
     if (tree == LEAF) {
         return LEAF;
@@ -101,7 +101,7 @@ redblack_find(redblack_node_t * tree, ID key)
 }
 
 static inline rb_shape_t *
-redblack_value(redblack_node_t * node)
+redblack_value(redblack_node_t *node)
 {
     // Color is stored in the bottom bit of the shape pointer
     // Mask away the bit so we get the actual pointer back
@@ -110,33 +110,33 @@ redblack_value(redblack_node_t * node)
 
 #ifdef HAVE_MMAP
 static inline char
-redblack_color(redblack_node_t * node)
+redblack_color(redblack_node_t *node)
 {
     return node && ((uintptr_t)node->value & RED);
 }
 
 static inline bool
-redblack_red_p(redblack_node_t * node)
+redblack_red_p(redblack_node_t *node)
 {
     return redblack_color(node) == RED;
 }
 
 static redblack_id_t
-redblack_id_for(redblack_node_t * node)
+redblack_id_for(redblack_node_t *node)
 {
     RUBY_ASSERT(node || node == LEAF);
     if (node == LEAF) {
         return 0;
     }
     else {
-        redblack_node_t * redblack_nodes = GET_SHAPE_TREE()->shape_cache;
+        redblack_node_t *redblack_nodes = GET_SHAPE_TREE()->shape_cache;
         redblack_id_t id = (redblack_id_t)(node - redblack_nodes);
         return id + 1;
     }
 }
 
 static redblack_node_t *
-redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, redblack_node_t * right)
+redblack_new(char color, ID key, rb_shape_t *value, redblack_node_t *left, redblack_node_t *right)
 {
     if (GET_SHAPE_TREE()->cache_size + 1 >= REDBLACK_CACHE_SIZE) {
         // We're out of cache, just quit
@@ -146,8 +146,8 @@ redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, red
     RUBY_ASSERT(left == LEAF || left->key < key);
     RUBY_ASSERT(right == LEAF || right->key > key);
 
-    redblack_node_t * redblack_nodes = GET_SHAPE_TREE()->shape_cache;
-    redblack_node_t * node = &redblack_nodes[(GET_SHAPE_TREE()->cache_size)++];
+    redblack_node_t *redblack_nodes = GET_SHAPE_TREE()->shape_cache;
+    redblack_node_t *node = &redblack_nodes[(GET_SHAPE_TREE()->cache_size)++];
     node->key = key;
     node->value = (rb_shape_t *)((uintptr_t)value | color);
     node->l = redblack_id_for(left);
@@ -156,7 +156,7 @@ redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, red
 }
 
 static redblack_node_t *
-redblack_balance(char color, ID key, rb_shape_t * value, redblack_node_t * left, redblack_node_t * right)
+redblack_balance(char color, ID key, rb_shape_t *value, redblack_node_t *left, redblack_node_t *right)
 {
     if (color == BLACK) {
         ID new_key, new_left_key, new_right_key;
@@ -243,7 +243,7 @@ redblack_balance(char color, ID key, rb_shape_t * value, redblack_node_t * left,
 }
 
 static redblack_node_t *
-redblack_insert_aux(redblack_node_t * tree, ID key, rb_shape_t * value)
+redblack_insert_aux(redblack_node_t *tree, ID key, rb_shape_t *value)
 {
     if (tree == LEAF) {
         return redblack_new(RED, key, value, LEAF, LEAF);
@@ -277,16 +277,16 @@ redblack_insert_aux(redblack_node_t * tree, ID key, rb_shape_t * value)
 }
 
 static redblack_node_t *
-redblack_force_black(redblack_node_t * node)
+redblack_force_black(redblack_node_t *node)
 {
     node->value = redblack_value(node);
     return node;
 }
 
 static redblack_node_t *
-redblack_insert(redblack_node_t * tree, ID key, rb_shape_t * value)
+redblack_insert(redblack_node_t *tree, ID key, rb_shape_t *value)
 {
-    redblack_node_t * root = redblack_insert_aux(tree, key, value);
+    redblack_node_t *root = redblack_insert_aux(tree, key, value);
 
     if (redblack_red_p(root)) {
         return redblack_force_black(root);
@@ -309,7 +309,7 @@ rb_shape_get_root_shape(void)
 }
 
 shape_id_t
-rb_shape_id(rb_shape_t * shape)
+rb_shape_id(rb_shape_t *shape)
 {
     return (shape_id_t)(shape - GET_SHAPE_TREE()->shape_list);
 }
@@ -335,7 +335,7 @@ rb_shape_get_shape_by_id(shape_id_t shape_id)
 }
 
 rb_shape_t *
-rb_shape_get_parent(rb_shape_t * shape)
+rb_shape_get_parent(rb_shape_t *shape)
 {
     return rb_shape_get_shape_by_id(shape->parent_id);
 }
@@ -368,7 +368,7 @@ rb_shape_get_shape_id(VALUE obj)
 }
 
 size_t
-rb_shape_depth(rb_shape_t * shape)
+rb_shape_depth(rb_shape_t *shape)
 {
     size_t depth = 1;
 
@@ -403,7 +403,7 @@ shape_alloc(void)
 static rb_shape_t *
 rb_shape_alloc_with_parent_id(ID edge_name, shape_id_t parent_id)
 {
-    rb_shape_t * shape = shape_alloc();
+    rb_shape_t *shape = shape_alloc();
 
     shape->edge_name = edge_name;
     shape->next_iv_index = 0;
@@ -414,9 +414,9 @@ rb_shape_alloc_with_parent_id(ID edge_name, shape_id_t parent_id)
 }
 
 static rb_shape_t *
-rb_shape_alloc(ID edge_name, rb_shape_t * parent, enum shape_type type)
+rb_shape_alloc(ID edge_name, rb_shape_t *parent, enum shape_type type)
 {
-    rb_shape_t * shape = rb_shape_alloc_with_parent_id(edge_name, rb_shape_id(parent));
+    rb_shape_t *shape = rb_shape_alloc_with_parent_id(edge_name, rb_shape_id(parent));
     shape->type = (uint8_t)type;
     shape->heap_index = parent->heap_index;
     shape->capacity = parent->capacity;
@@ -426,10 +426,10 @@ rb_shape_alloc(ID edge_name, rb_shape_t * parent, enum shape_type type)
 
 #ifdef HAVE_MMAP
 static redblack_node_t *
-redblack_cache_ancestors(rb_shape_t * shape)
+redblack_cache_ancestors(rb_shape_t *shape)
 {
     if (!(shape->ancestor_index || shape->parent_id == INVALID_SHAPE_ID)) {
-        redblack_node_t * parent_index;
+        redblack_node_t *parent_index;
 
         parent_index = redblack_cache_ancestors(rb_shape_get_parent(shape));
 
@@ -453,16 +453,16 @@ redblack_cache_ancestors(rb_shape_t * shape)
 }
 #else
 static redblack_node_t *
-redblack_cache_ancestors(rb_shape_t * shape)
+redblack_cache_ancestors(rb_shape_t *shape)
 {
     return LEAF;
 }
 #endif
 
 static rb_shape_t *
-rb_shape_alloc_new_child(ID id, rb_shape_t * shape, enum shape_type shape_type)
+rb_shape_alloc_new_child(ID id, rb_shape_t *shape, enum shape_type shape_type)
 {
-    rb_shape_t * new_shape = rb_shape_alloc(id, shape, shape_type);
+    rb_shape_t *new_shape = rb_shape_alloc(id, shape, shape_type);
 
     switch (shape_type) {
       case SHAPE_IVAR:
@@ -490,7 +490,7 @@ rb_shape_alloc_new_child(ID id, rb_shape_t * shape, enum shape_type shape_type)
 }
 
 static rb_shape_t*
-get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, bool * variation_created, bool new_variations_allowed)
+get_next_shape_internal(rb_shape_t *shape, ID id, enum shape_type shape_type, bool *variation_created, bool new_variations_allowed)
 {
     rb_shape_t *res = NULL;
 
@@ -505,7 +505,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b
         if (shape->edges) {
             // Check if it only has one child
             if (SINGLE_CHILD_P(shape->edges)) {
-                rb_shape_t * child = SINGLE_CHILD(shape->edges);
+                rb_shape_t *child = SINGLE_CHILD(shape->edges);
                 // If the one child has a matching edge name, then great,
                 // we found what we want.
                 if (child->edge_name == id) {
@@ -529,7 +529,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b
                 res = rb_shape_get_shape_by_id(OBJ_TOO_COMPLEX_SHAPE_ID);
             }
             else {
-                rb_shape_t * new_shape = rb_shape_alloc_new_child(id, shape, shape_type);
+                rb_shape_t *new_shape = rb_shape_alloc_new_child(id, shape, shape_type);
 
                 if (!shape->edges) {
                     // If the shape had no edge yet, we can directly set the new child
@@ -538,7 +538,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b
                 else {
                     // If the edge was single child we need to allocate a table.
                     if (SINGLE_CHILD_P(shape->edges)) {
-                        rb_shape_t * old_child = SINGLE_CHILD(shape->edges);
+                        rb_shape_t *old_child = SINGLE_CHILD(shape->edges);
                         shape->edges = rb_id_table_create(2);
                         rb_id_table_insert(shape->edges, old_child->edge_name, (VALUE)old_child);
                     }
@@ -691,7 +691,7 @@ rb_shape_transition_shape_frozen(VALUE obj)
  * max_iv_count
  */
 rb_shape_t *
-rb_shape_get_next_iv_shape(rb_shape_t* shape, ID id)
+rb_shape_get_next_iv_shape(rb_shape_t *shape, ID id)
 {
     RUBY_ASSERT(!is_instance_id(id) || RTEST(rb_sym2str(ID2SYM(id))));
     bool dont_care;
@@ -775,7 +775,7 @@ rb_shape_get_iv_index_with_hint(shape_id_t shape_id, ID id, attr_index_t *value,
         return rb_shape_get_iv_index(shape, id, value);
     }
 
-    rb_shape_t * shape_hint = rb_shape_get_shape_by_id(*shape_id_hint);
+    rb_shape_t *shape_hint = rb_shape_get_shape_by_id(*shape_id_hint);
 
     // We assume it's likely shape_id_hint and shape_id have a close common
     // ancestor, so we check up to ANCESTOR_SEARCH_MAX_DEPTH ancestors before
@@ -925,7 +925,7 @@ rb_shape_traverse_from_new_root(rb_shape_t *initial_shape, rb_shape_t *dest_shap
 
         VALUE lookup_result;
         if (SINGLE_CHILD_P(next_shape->edges)) {
-            rb_shape_t * child = SINGLE_CHILD(next_shape->edges);
+            rb_shape_t *child = SINGLE_CHILD(next_shape->edges);
             if (child->edge_name == dest_shape->edge_name) {
                 return child;
             }
@@ -954,12 +954,12 @@ rb_shape_traverse_from_new_root(rb_shape_t *initial_shape, rb_shape_t *dest_shap
 }
 
 rb_shape_t *
-rb_shape_rebuild_shape(rb_shape_t * initial_shape, rb_shape_t * dest_shape)
+rb_shape_rebuild_shape(rb_shape_t *initial_shape, rb_shape_t *dest_shape)
 {
     RUBY_ASSERT(rb_shape_id(initial_shape) != OBJ_TOO_COMPLEX_SHAPE_ID);
     RUBY_ASSERT(rb_shape_id(dest_shape) != OBJ_TOO_COMPLEX_SHAPE_ID);
 
-    rb_shape_t * midway_shape;
+    rb_shape_t *midway_shape;
 
     RUBY_ASSERT(initial_shape->type == SHAPE_T_OBJECT);
 
@@ -1027,7 +1027,7 @@ rb_shape_memsize(rb_shape_t *shape)
 static VALUE
 rb_shape_too_complex(VALUE self)
 {
-    rb_shape_t * shape;
+    rb_shape_t *shape;
     shape = rb_shape_get_shape_by_id(NUM2INT(rb_struct_getmember(self, rb_intern("id"))));
     if (rb_shape_id(shape) == OBJ_TOO_COMPLEX_SHAPE_ID) {
         return Qtrue;
@@ -1046,7 +1046,7 @@ parse_key(ID key)
     return LONG2NUM(key);
 }
 
-static VALUE rb_shape_edge_name(rb_shape_t * shape);
+static VALUE rb_shape_edge_name(rb_shape_t *shape);
 
 static VALUE
 rb_shape_t_to_rb_cShape(rb_shape_t *shape)
@@ -1083,7 +1083,7 @@ rb_shape_edges(VALUE self)
 
     if (shape->edges) {
         if (SINGLE_CHILD_P(shape->edges)) {
-            rb_shape_t * child = SINGLE_CHILD(shape->edges);
+            rb_shape_t *child = SINGLE_CHILD(shape->edges);
             rb_edges_to_hash(child->edge_name, (VALUE)child, &hash);
         }
         else {
@@ -1095,7 +1095,7 @@ rb_shape_edges(VALUE self)
 }
 
 static VALUE
-rb_shape_edge_name(rb_shape_t * shape)
+rb_shape_edge_name(rb_shape_t *shape)
 {
     if (shape->edge_name) {
         if (is_instance_id(shape->edge_name)) {
@@ -1117,7 +1117,7 @@ rb_shape_export_depth(VALUE self)
 static VALUE
 rb_shape_parent(VALUE self)
 {
-    rb_shape_t * shape;
+    rb_shape_t *shape;
     shape = rb_shape_get_shape_by_id(NUM2INT(rb_struct_getmember(self, rb_intern("id"))));
     if (shape->parent_id != INVALID_SHAPE_ID) {
         return rb_shape_t_to_rb_cShape(rb_shape_get_parent(shape));
@@ -1166,7 +1166,7 @@ static VALUE edges(struct rb_id_table* edges)
 {
     VALUE hash = rb_hash_new();
     if (SINGLE_CHILD_P(edges)) {
-        rb_shape_t * child = SINGLE_CHILD(edges);
+        rb_shape_t *child = SINGLE_CHILD(edges);
         collect_keys_and_values(child->edge_name, (VALUE)child, &hash);
     }
     else {
diff --git a/shape.h b/shape.h

Original file line number	Diff line number	Diff line change
`@@ -51,33 +51,33 @@ static ID id_t_object;`
`51`	`51`	`#define RED 0x1`
`52`	`52`
`53`	`53`	`static redblack_node_t *`
`54`		`-redblack_left(redblack_node_t * node)`
	`54`	`+redblack_left(redblack_node_t *node)`
`55`	`55`	`{`
`56`	`56`	`if (node->l == LEAF) {`
`57`	`57`	`return LEAF;`
`58`	`58`	`}`
`59`	`59`	`else {`
`60`	`60`	`RUBY_ASSERT(node->l < GET_SHAPE_TREE()->cache_size);`
`61`		`- redblack_node_t * left = &GET_SHAPE_TREE()->shape_cache[node->l - 1];`
	`61`	`+ redblack_node_t *left = &GET_SHAPE_TREE()->shape_cache[node->l - 1];`
`62`	`62`	`return left;`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`static redblack_node_t *`
`67`		`-redblack_right(redblack_node_t * node)`
	`67`	`+redblack_right(redblack_node_t *node)`
`68`	`68`	`{`
`69`	`69`	`if (node->r == LEAF) {`
`70`	`70`	`return LEAF;`
`71`	`71`	`}`
`72`	`72`	`else {`
`73`	`73`	`RUBY_ASSERT(node->r < GET_SHAPE_TREE()->cache_size);`
`74`		`- redblack_node_t * right = &GET_SHAPE_TREE()->shape_cache[node->r - 1];`
	`74`	`+ redblack_node_t *right = &GET_SHAPE_TREE()->shape_cache[node->r - 1];`
`75`	`75`	`return right;`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`static redblack_node_t *`
`80`		`-redblack_find(redblack_node_t * tree, ID key)`
	`80`	`+redblack_find(redblack_node_t *tree, ID key)`
`81`	`81`	`{`
`82`	`82`	`if (tree == LEAF) {`
`83`	`83`	`return LEAF;`
`@@ -101,7 +101,7 @@ redblack_find(redblack_node_t * tree, ID key)`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`static inline rb_shape_t *`
`104`		`-redblack_value(redblack_node_t * node)`
	`104`	`+redblack_value(redblack_node_t *node)`
`105`	`105`	`{`
`106`	`106`	`// Color is stored in the bottom bit of the shape pointer`
`107`	`107`	`// Mask away the bit so we get the actual pointer back`
`@@ -110,33 +110,33 @@ redblack_value(redblack_node_t * node)`
`110`	`110`
`111`	`111`	`#ifdef HAVE_MMAP`
`112`	`112`	`static inline char`
`113`		`-redblack_color(redblack_node_t * node)`
	`113`	`+redblack_color(redblack_node_t *node)`
`114`	`114`	`{`
`115`	`115`	`return node && ((uintptr_t)node->value & RED);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`static inline bool`
`119`		`-redblack_red_p(redblack_node_t * node)`
	`119`	`+redblack_red_p(redblack_node_t *node)`
`120`	`120`	`{`
`121`	`121`	`return redblack_color(node) == RED;`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`static redblack_id_t`
`125`		`-redblack_id_for(redblack_node_t * node)`
	`125`	`+redblack_id_for(redblack_node_t *node)`
`126`	`126`	`{`
`127`	`127`	`RUBY_ASSERT(node \|\| node == LEAF);`
`128`	`128`	`if (node == LEAF) {`
`129`	`129`	`return 0;`
`130`	`130`	`}`
`131`	`131`	`else {`
`132`		`- redblack_node_t * redblack_nodes = GET_SHAPE_TREE()->shape_cache;`
	`132`	`+ redblack_node_t *redblack_nodes = GET_SHAPE_TREE()->shape_cache;`
`133`	`133`	`redblack_id_t id = (redblack_id_t)(node - redblack_nodes);`
`134`	`134`	`return id + 1;`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`static redblack_node_t *`
`139`		`-redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, redblack_node_t * right)`
	`139`	`+redblack_new(char color, ID key, rb_shape_t value, redblack_node_t left, redblack_node_t *right)`
`140`	`140`	`{`
`141`	`141`	`if (GET_SHAPE_TREE()->cache_size + 1 >= REDBLACK_CACHE_SIZE) {`
`142`	`142`	`// We're out of cache, just quit`
`@@ -146,8 +146,8 @@ redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, red`
`146`	`146`	`RUBY_ASSERT(left == LEAF \|\| left->key < key);`
`147`	`147`	`RUBY_ASSERT(right == LEAF \|\| right->key > key);`
`148`	`148`
`149`		`- redblack_node_t * redblack_nodes = GET_SHAPE_TREE()->shape_cache;`
`150`		`- redblack_node_t * node = &redblack_nodes[(GET_SHAPE_TREE()->cache_size)++];`
	`149`	`+ redblack_node_t *redblack_nodes = GET_SHAPE_TREE()->shape_cache;`
	`150`	`+ redblack_node_t *node = &redblack_nodes[(GET_SHAPE_TREE()->cache_size)++];`
`151`	`151`	`node->key = key;`
`152`	`152`	`node->value = (rb_shape_t *)((uintptr_t)value \| color);`
`153`	`153`	`node->l = redblack_id_for(left);`
`@@ -156,7 +156,7 @@ redblack_new(char color, ID key, rb_shape_t * value, redblack_node_t * left, red`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`static redblack_node_t *`
`159`		`-redblack_balance(char color, ID key, rb_shape_t * value, redblack_node_t * left, redblack_node_t * right)`
	`159`	`+redblack_balance(char color, ID key, rb_shape_t value, redblack_node_t left, redblack_node_t *right)`
`160`	`160`	`{`
`161`	`161`	`if (color == BLACK) {`
`162`	`162`	`ID new_key, new_left_key, new_right_key;`
`@@ -243,7 +243,7 @@ redblack_balance(char color, ID key, rb_shape_t * value, redblack_node_t * left,`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`static redblack_node_t *`
`246`		`-redblack_insert_aux(redblack_node_t * tree, ID key, rb_shape_t * value)`
	`246`	`+redblack_insert_aux(redblack_node_t tree, ID key, rb_shape_t value)`
`247`	`247`	`{`
`248`	`248`	`if (tree == LEAF) {`
`249`	`249`	`return redblack_new(RED, key, value, LEAF, LEAF);`
`@@ -277,16 +277,16 @@ redblack_insert_aux(redblack_node_t * tree, ID key, rb_shape_t * value)`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`static redblack_node_t *`
`280`		`-redblack_force_black(redblack_node_t * node)`
	`280`	`+redblack_force_black(redblack_node_t *node)`
`281`	`281`	`{`
`282`	`282`	`node->value = redblack_value(node);`
`283`	`283`	`return node;`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`static redblack_node_t *`
`287`		`-redblack_insert(redblack_node_t * tree, ID key, rb_shape_t * value)`
	`287`	`+redblack_insert(redblack_node_t tree, ID key, rb_shape_t value)`
`288`	`288`	`{`
`289`		`- redblack_node_t * root = redblack_insert_aux(tree, key, value);`
	`289`	`+ redblack_node_t *root = redblack_insert_aux(tree, key, value);`
`290`	`290`
`291`	`291`	`if (redblack_red_p(root)) {`
`292`	`292`	`return redblack_force_black(root);`
`@@ -309,7 +309,7 @@ rb_shape_get_root_shape(void)`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`shape_id_t`
`312`		`-rb_shape_id(rb_shape_t * shape)`
	`312`	`+rb_shape_id(rb_shape_t *shape)`
`313`	`313`	`{`
`314`	`314`	`return (shape_id_t)(shape - GET_SHAPE_TREE()->shape_list);`
`315`	`315`	`}`
`@@ -335,7 +335,7 @@ rb_shape_get_shape_by_id(shape_id_t shape_id)`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`rb_shape_t *`
`338`		`-rb_shape_get_parent(rb_shape_t * shape)`
	`338`	`+rb_shape_get_parent(rb_shape_t *shape)`
`339`	`339`	`{`
`340`	`340`	`return rb_shape_get_shape_by_id(shape->parent_id);`
`341`	`341`	`}`
`@@ -368,7 +368,7 @@ rb_shape_get_shape_id(VALUE obj)`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`size_t`
`371`		`-rb_shape_depth(rb_shape_t * shape)`
	`371`	`+rb_shape_depth(rb_shape_t *shape)`
`372`	`372`	`{`
`373`	`373`	`size_t depth = 1;`
`374`	`374`
`@@ -403,7 +403,7 @@ shape_alloc(void)`
`403`	`403`	`static rb_shape_t *`
`404`	`404`	`rb_shape_alloc_with_parent_id(ID edge_name, shape_id_t parent_id)`
`405`	`405`	`{`
`406`		`- rb_shape_t * shape = shape_alloc();`
	`406`	`+ rb_shape_t *shape = shape_alloc();`
`407`	`407`
`408`	`408`	`shape->edge_name = edge_name;`
`409`	`409`	`shape->next_iv_index = 0;`
`@@ -414,9 +414,9 @@ rb_shape_alloc_with_parent_id(ID edge_name, shape_id_t parent_id)`
`414`	`414`	`}`
`415`	`415`
`416`	`416`	`static rb_shape_t *`
`417`		`-rb_shape_alloc(ID edge_name, rb_shape_t * parent, enum shape_type type)`
	`417`	`+rb_shape_alloc(ID edge_name, rb_shape_t *parent, enum shape_type type)`
`418`	`418`	`{`
`419`		`- rb_shape_t * shape = rb_shape_alloc_with_parent_id(edge_name, rb_shape_id(parent));`
	`419`	`+ rb_shape_t *shape = rb_shape_alloc_with_parent_id(edge_name, rb_shape_id(parent));`
`420`	`420`	`shape->type = (uint8_t)type;`
`421`	`421`	`shape->heap_index = parent->heap_index;`
`422`	`422`	`shape->capacity = parent->capacity;`
`@@ -426,10 +426,10 @@ rb_shape_alloc(ID edge_name, rb_shape_t * parent, enum shape_type type)`
`426`	`426`
`427`	`427`	`#ifdef HAVE_MMAP`
`428`	`428`	`static redblack_node_t *`
`429`		`-redblack_cache_ancestors(rb_shape_t * shape)`
	`429`	`+redblack_cache_ancestors(rb_shape_t *shape)`
`430`	`430`	`{`
`431`	`431`	`if (!(shape->ancestor_index \|\| shape->parent_id == INVALID_SHAPE_ID)) {`
`432`		`- redblack_node_t * parent_index;`
	`432`	`+ redblack_node_t *parent_index;`
`433`	`433`
`434`	`434`	`parent_index = redblack_cache_ancestors(rb_shape_get_parent(shape));`
`435`	`435`
`@@ -453,16 +453,16 @@ redblack_cache_ancestors(rb_shape_t * shape)`
`453`	`453`	`}`
`454`	`454`	`#else`
`455`	`455`	`static redblack_node_t *`
`456`		`-redblack_cache_ancestors(rb_shape_t * shape)`
	`456`	`+redblack_cache_ancestors(rb_shape_t *shape)`
`457`	`457`	`{`
`458`	`458`	`return LEAF;`
`459`	`459`	`}`
`460`	`460`	`#endif`
`461`	`461`
`462`	`462`	`static rb_shape_t *`
`463`		`-rb_shape_alloc_new_child(ID id, rb_shape_t * shape, enum shape_type shape_type)`
	`463`	`+rb_shape_alloc_new_child(ID id, rb_shape_t *shape, enum shape_type shape_type)`
`464`	`464`	`{`
`465`		`- rb_shape_t * new_shape = rb_shape_alloc(id, shape, shape_type);`
	`465`	`+ rb_shape_t *new_shape = rb_shape_alloc(id, shape, shape_type);`
`466`	`466`
`467`	`467`	`switch (shape_type) {`
`468`	`468`	`case SHAPE_IVAR:`
`@@ -490,7 +490,7 @@ rb_shape_alloc_new_child(ID id, rb_shape_t * shape, enum shape_type shape_type)`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`static rb_shape_t*`
`493`		`-get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, bool * variation_created, bool new_variations_allowed)`
	`493`	`+get_next_shape_internal(rb_shape_t shape, ID id, enum shape_type shape_type, bool variation_created, bool new_variations_allowed)`
`494`	`494`	`{`
`495`	`495`	`rb_shape_t *res = NULL;`
`496`	`496`
`@@ -505,7 +505,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b`
`505`	`505`	`if (shape->edges) {`
`506`	`506`	`// Check if it only has one child`
`507`	`507`	`if (SINGLE_CHILD_P(shape->edges)) {`
`508`		`- rb_shape_t * child = SINGLE_CHILD(shape->edges);`
	`508`	`+ rb_shape_t *child = SINGLE_CHILD(shape->edges);`
`509`	`509`	`// If the one child has a matching edge name, then great,`
`510`	`510`	`// we found what we want.`
`511`	`511`	`if (child->edge_name == id) {`
`@@ -529,7 +529,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b`
`529`	`529`	`res = rb_shape_get_shape_by_id(OBJ_TOO_COMPLEX_SHAPE_ID);`
`530`	`530`	`}`
`531`	`531`	`else {`
`532`		`- rb_shape_t * new_shape = rb_shape_alloc_new_child(id, shape, shape_type);`
	`532`	`+ rb_shape_t *new_shape = rb_shape_alloc_new_child(id, shape, shape_type);`
`533`	`533`
`534`	`534`	`if (!shape->edges) {`
`535`	`535`	`// If the shape had no edge yet, we can directly set the new child`
`@@ -538,7 +538,7 @@ get_next_shape_internal(rb_shape_t * shape, ID id, enum shape_type shape_type, b`
`538`	`538`	`else {`
`539`	`539`	`// If the edge was single child we need to allocate a table.`
`540`	`540`	`if (SINGLE_CHILD_P(shape->edges)) {`
`541`		`- rb_shape_t * old_child = SINGLE_CHILD(shape->edges);`
	`541`	`+ rb_shape_t *old_child = SINGLE_CHILD(shape->edges);`
`542`	`542`	`shape->edges = rb_id_table_create(2);`
`543`	`543`	`rb_id_table_insert(shape->edges, old_child->edge_name, (VALUE)old_child);`
`544`	`544`	`}`
`@@ -691,7 +691,7 @@ rb_shape_transition_shape_frozen(VALUE obj)`
`691`	`691`	`* max_iv_count`
`692`	`692`	`*/`
`693`	`693`	`rb_shape_t *`
`694`		`-rb_shape_get_next_iv_shape(rb_shape_t* shape, ID id)`
	`694`	`+rb_shape_get_next_iv_shape(rb_shape_t *shape, ID id)`
`695`	`695`	`{`
`696`	`696`	`RUBY_ASSERT(!is_instance_id(id) \|\| RTEST(rb_sym2str(ID2SYM(id))));`
`697`	`697`	`bool dont_care;`
`@@ -775,7 +775,7 @@ rb_shape_get_iv_index_with_hint(shape_id_t shape_id, ID id, attr_index_t *value,`
`775`	`775`	`return rb_shape_get_iv_index(shape, id, value);`
`776`	`776`	`}`
`777`	`777`
`778`		`- rb_shape_t * shape_hint = rb_shape_get_shape_by_id(*shape_id_hint);`
	`778`	`+ rb_shape_t shape_hint = rb_shape_get_shape_by_id(shape_id_hint);`
`779`	`779`
`780`	`780`	`// We assume it's likely shape_id_hint and shape_id have a close common`
`781`	`781`	`// ancestor, so we check up to ANCESTOR_SEARCH_MAX_DEPTH ancestors before`
`@@ -925,7 +925,7 @@ rb_shape_traverse_from_new_root(rb_shape_t initial_shape, rb_shape_t dest_shap`
`925`	`925`
`926`	`926`	`VALUE lookup_result;`
`927`	`927`	`if (SINGLE_CHILD_P(next_shape->edges)) {`
`928`		`- rb_shape_t * child = SINGLE_CHILD(next_shape->edges);`
	`928`	`+ rb_shape_t *child = SINGLE_CHILD(next_shape->edges);`
`929`	`929`	`if (child->edge_name == dest_shape->edge_name) {`
`930`	`930`	`return child;`
`931`	`931`	`}`
`@@ -954,12 +954,12 @@ rb_shape_traverse_from_new_root(rb_shape_t initial_shape, rb_shape_t dest_shap`
`954`	`954`	`}`
`955`	`955`
`956`	`956`	`rb_shape_t *`
`957`		`-rb_shape_rebuild_shape(rb_shape_t * initial_shape, rb_shape_t * dest_shape)`
	`957`	`+rb_shape_rebuild_shape(rb_shape_t initial_shape, rb_shape_t dest_shape)`
`958`	`958`	`{`
`959`	`959`	`RUBY_ASSERT(rb_shape_id(initial_shape) != OBJ_TOO_COMPLEX_SHAPE_ID);`
`960`	`960`	`RUBY_ASSERT(rb_shape_id(dest_shape) != OBJ_TOO_COMPLEX_SHAPE_ID);`
`961`	`961`
`962`		`- rb_shape_t * midway_shape;`
	`962`	`+ rb_shape_t *midway_shape;`
`963`	`963`
`964`	`964`	`RUBY_ASSERT(initial_shape->type == SHAPE_T_OBJECT);`
`965`	`965`
`@@ -1027,7 +1027,7 @@ rb_shape_memsize(rb_shape_t *shape)`
`1027`	`1027`	`static VALUE`
`1028`	`1028`	`rb_shape_too_complex(VALUE self)`
`1029`	`1029`	`{`
`1030`		`- rb_shape_t * shape;`
	`1030`	`+ rb_shape_t *shape;`
`1031`	`1031`	`shape = rb_shape_get_shape_by_id(NUM2INT(rb_struct_getmember(self, rb_intern("id"))));`
`1032`	`1032`	`if (rb_shape_id(shape) == OBJ_TOO_COMPLEX_SHAPE_ID) {`
`1033`	`1033`	`return Qtrue;`
`@@ -1046,7 +1046,7 @@ parse_key(ID key)`
`1046`	`1046`	`return LONG2NUM(key);`
`1047`	`1047`	`}`
`1048`	`1048`
`1049`		`-static VALUE rb_shape_edge_name(rb_shape_t * shape);`
	`1049`	`+static VALUE rb_shape_edge_name(rb_shape_t *shape);`
`1050`	`1050`
`1051`	`1051`	`static VALUE`
`1052`	`1052`	`rb_shape_t_to_rb_cShape(rb_shape_t *shape)`
`@@ -1083,7 +1083,7 @@ rb_shape_edges(VALUE self)`
`1083`	`1083`
`1084`	`1084`	`if (shape->edges) {`
`1085`	`1085`	`if (SINGLE_CHILD_P(shape->edges)) {`
`1086`		`- rb_shape_t * child = SINGLE_CHILD(shape->edges);`
	`1086`	`+ rb_shape_t *child = SINGLE_CHILD(shape->edges);`
`1087`	`1087`	`rb_edges_to_hash(child->edge_name, (VALUE)child, &hash);`
`1088`	`1088`	`}`
`1089`	`1089`	`else {`
`@@ -1095,7 +1095,7 @@ rb_shape_edges(VALUE self)`
`1095`	`1095`	`}`
`1096`	`1096`
`1097`	`1097`	`static VALUE`
`1098`		`-rb_shape_edge_name(rb_shape_t * shape)`
	`1098`	`+rb_shape_edge_name(rb_shape_t *shape)`
`1099`	`1099`	`{`
`1100`	`1100`	`if (shape->edge_name) {`
`1101`	`1101`	`if (is_instance_id(shape->edge_name)) {`
`@@ -1117,7 +1117,7 @@ rb_shape_export_depth(VALUE self)`
`1117`	`1117`	`static VALUE`
`1118`	`1118`	`rb_shape_parent(VALUE self)`
`1119`	`1119`	`{`
`1120`		`- rb_shape_t * shape;`
	`1120`	`+ rb_shape_t *shape;`
`1121`	`1121`	`shape = rb_shape_get_shape_by_id(NUM2INT(rb_struct_getmember(self, rb_intern("id"))));`
`1122`	`1122`	`if (shape->parent_id != INVALID_SHAPE_ID) {`
`1123`	`1123`	`return rb_shape_t_to_rb_cShape(rb_shape_get_parent(shape));`
`@@ -1166,7 +1166,7 @@ static VALUE edges(struct rb_id_table* edges)`
`1166`	`1166`	`{`
`1167`	`1167`	`VALUE hash = rb_hash_new();`
`1168`	`1168`	`if (SINGLE_CHILD_P(edges)) {`
`1169`		`- rb_shape_t * child = SINGLE_CHILD(edges);`
	`1169`	`+ rb_shape_t *child = SINGLE_CHILD(edges);`
`1170`	`1170`	`collect_keys_and_values(child->edge_name, (VALUE)child, &hash);`
`1171`	`1171`	`}`
`1172`	`1172`	`else {`