From d4a39d61e853f570ec8d599e9500a80b035fb61f Mon Sep 17 00:00:00 2001 From: Richard Braun Date: Sat, 14 Apr 2018 22:03:50 +0200 Subject: Rename variables in function-like macros --- arch/x86/machine/atomic.h | 56 ++++++++++++++-------------- arch/x86/machine/cpu.h | 12 +++--- doc/style.9.txt | 11 ++---- kern/atomic.h | 18 ++++----- kern/hlist.h | 30 +++++++-------- kern/list.h | 24 ++++++------ kern/rbtree.h | 94 +++++++++++++++++++++++------------------------ kern/shell.h | 10 ++--- kern/slist.h | 36 +++++++++--------- 9 files changed, 144 insertions(+), 147 deletions(-) diff --git a/arch/x86/machine/atomic.h b/arch/x86/machine/atomic.h index 344a029..36f0067 100644 --- a/arch/x86/machine/atomic.h +++ b/arch/x86/machine/atomic.h @@ -46,38 +46,38 @@ * Temporarily discard qualifiers when loading 64-bits values with a * compare-and-swap operation. */ -#define atomic_load_64(ptr, mo) \ -MACRO_BEGIN \ - uint64_t ret___ = 0; \ - \ - __atomic_compare_exchange_n((uint64_t *)(ptr), &ret___, 0, \ - false, mo, __ATOMIC_RELAXED); \ - ret___; \ +#define atomic_load_64(ptr, mo) \ +MACRO_BEGIN \ + uint64_t ret_ = 0; \ + \ + __atomic_compare_exchange_n((uint64_t *)(ptr), &ret_, 0, \ + false, mo, __ATOMIC_RELAXED); \ + ret_; \ MACRO_END -#define atomic_load(ptr, mo) \ - (typeof(*(ptr)))__builtin_choose_expr(sizeof(*(ptr)) == 8, \ - atomic_load_64(ptr, mo), \ +#define atomic_load(ptr, mo) \ + (typeof(*(ptr)))__builtin_choose_expr(sizeof(*(ptr)) == 8, \ + atomic_load_64(ptr, mo), \ __atomic_load_n(ptr, mo)) -#define atomic_store(ptr, val, mo) \ -MACRO_BEGIN \ - if (sizeof(*(ptr)) != 8) { \ - __atomic_store_n(ptr, val, mo); \ - } else { \ - typeof(*(ptr)) oval___, nval___; \ - bool done___; \ - \ - oval___ = *(ptr); \ - nval___ = (val); \ - \ - do { \ - done___ = __atomic_compare_exchange_n(ptr, &oval___, nval___, \ - false, mo, \ - __ATOMIC_RELAXED); \ - } while (!done___); \ - \ - } \ +#define atomic_store(ptr, val, mo) \ +MACRO_BEGIN \ + if (sizeof(*(ptr)) != 8) { \ + __atomic_store_n(ptr, val, mo); \ + } else { \ + typeof(*(ptr)) oval_, nval_; \ + bool done_; \ + \ + oval_ = *(ptr); \ + nval_ = (val); \ + \ + do { \ + done_ = __atomic_compare_exchange_n(ptr, &oval_, nval_, \ + false, mo, \ + __ATOMIC_RELAXED); \ + } while (!done_); \ + \ + } \ MACRO_END /* diff --git a/arch/x86/machine/cpu.h b/arch/x86/machine/cpu.h index 0023349..8f9b23c 100644 --- a/arch/x86/machine/cpu.h +++ b/arch/x86/machine/cpu.h @@ -435,13 +435,13 @@ extern void *cpu_local_area; #define cpu_local_ptr(var) \ MACRO_BEGIN \ - typeof(var) *ptr___ = &(var); \ + typeof(var) *ptr_ = &(var); \ \ asm("add %%fs:%1, %0" \ - : "+r" (ptr___) \ + : "+r" (ptr_) \ : "m" (cpu_local_area)); \ \ - ptr___; \ + ptr_; \ MACRO_END #define cpu_local_var(var) (*cpu_local_ptr(var)) @@ -454,13 +454,13 @@ MACRO_END #define cpu_local_read(var) \ MACRO_BEGIN \ - typeof(var) val___; \ + typeof(var) val_; \ \ asm("mov %%fs:%1, %0" \ - : "=r" (val___) \ + : "=r" (val_) \ : "m" (var)); \ \ - val___; \ + val_; \ MACRO_END static inline struct cpu * diff --git a/doc/style.9.txt b/doc/style.9.txt index d5b8b3f..efbead0 100644 --- a/doc/style.9.txt +++ b/doc/style.9.txt @@ -680,13 +680,10 @@ matching the object.method() syntax. Function-like macros with local variables ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Such macros may cause variable shadowing if one of their local variables has -the same name as one of the arguments. To avoid such situations, local -variables in function-like macros should be named with a prefix of underscores. -The C specification describes the use of single and double underscore prefixes -for file-scope specifiers and names reserved for the implementation. It's -therefore recommended to use three underscores when naming the local variables -of function-like macros. +Variable shadowing occurs in function-like macros if one of their local +variables has the same name as one of the arguments. To avoid such situations, +local variables in function-like macros must be named with an underscore +suffix. This naming scheme is reserved for function-like macro variables. SEE --- diff --git a/kern/atomic.h b/kern/atomic.h index e106dac..6b4ebf3 100644 --- a/kern/atomic.h +++ b/kern/atomic.h @@ -89,15 +89,15 @@ * value, some compilers seem to have trouble when all parameters don't * have the same type. */ -#define atomic_cas(ptr, oval, nval, mo) \ -MACRO_BEGIN \ - typeof(*(ptr)) oval___, nval___; \ - \ - oval___ = (oval); \ - nval___ = (nval); \ - __atomic_compare_exchange_n(ptr, &oval___, nval___, false, \ - mo, ATOMIC_RELAXED); \ - oval___; \ +#define atomic_cas(ptr, oval, nval, mo) \ +MACRO_BEGIN \ + typeof(*(ptr)) oval_, nval_; \ + \ + oval_ = (oval); \ + nval_ = (nval); \ + __atomic_compare_exchange_n(ptr, &oval_, nval_, false, \ + mo, ATOMIC_RELAXED); \ + oval_; \ MACRO_END /* diff --git a/kern/hlist.h b/kern/hlist.h index 61fad4f..739ea83 100644 --- a/kern/hlist.h +++ b/kern/hlist.h @@ -200,23 +200,23 @@ hlist_remove(struct hlist_node *node) */ #define hlist_first_entry(list, type, member) \ MACRO_BEGIN \ - struct hlist_node *first___; \ + struct hlist_node *first_; \ \ - first___ = (list)->first; \ - hlist_end(first___) ? NULL : hlist_entry(first___, type, member); \ + first_ = (list)->first; \ + hlist_end(first_) ? NULL : hlist_entry(first_, type, member); \ MACRO_END /* * Get the entry next to the given entry. */ -#define hlist_next_entry(entry, member) \ +#define hlist_next_entry(entry, member) \ MACRO_BEGIN \ - struct hlist_node *next___; \ + struct hlist_node *next_; \ \ - next___ = (entry)->member.next; \ - hlist_end(next___) \ + next_ = (entry)->member.next; \ + hlist_end(next_) \ ? NULL \ - : hlist_entry(next___, typeof(*entry), member); \ + : hlist_entry(next_, typeof(*entry), member); \ MACRO_END /* @@ -355,10 +355,10 @@ hlist_rcu_remove(struct hlist_node *node) */ #define hlist_rcu_first_entry(list, type, member) \ MACRO_BEGIN \ - struct hlist_node *first___; \ + struct hlist_node *first_; \ \ - first___ = hlist_rcu_first(list); \ - hlist_end(first___) ? NULL : hlist_entry(first___, type, member); \ + first_ = hlist_rcu_first(list); \ + hlist_end(first_) ? NULL : hlist_entry(first_, type, member); \ MACRO_END /* @@ -366,12 +366,12 @@ MACRO_END */ #define hlist_rcu_next_entry(entry, member) \ MACRO_BEGIN \ - struct hlist_node *next___; \ + struct hlist_node *next_; \ \ - next___ = hlist_rcu_next(&entry->member); \ - hlist_end(next___) \ + next_ = hlist_rcu_next(&entry->member); \ + hlist_end(next_) \ ? NULL \ - : hlist_entry(next___, typeof(*entry), member); \ + : hlist_entry(next_, typeof(*entry), member); \ MACRO_END /* diff --git a/kern/list.h b/kern/list.h index 8163176..2ba7f09 100644 --- a/kern/list.h +++ b/kern/list.h @@ -480,14 +480,14 @@ list_rcu_remove(struct list *node) */ #define list_rcu_first_entry(head, type, member) \ MACRO_BEGIN \ - struct list *list___; \ - struct list *first___; \ + struct list *list_; \ + struct list *first_; \ \ - list___ = (head); \ - first___ = list_rcu_first(list___); \ - list_end(list___, first___) \ + list_ = (head); \ + first_ = list_rcu_first(list_); \ + list_end(list_, first_) \ ? NULL \ - : list_entry(first___, type, member); \ + : list_entry(first_, type, member); \ MACRO_END /* @@ -499,14 +499,14 @@ MACRO_END */ #define list_rcu_next_entry(head, entry, member) \ MACRO_BEGIN \ - struct list *list___; \ - struct list *next___; \ + struct list *list_; \ + struct list *next_; \ \ - list___ = (head); \ - next___ = list_rcu_next(&entry->member); \ - list_end(list___, next___) \ + list_ = (head); \ + next_ = list_rcu_next(&entry->member); \ + list_end(list_, next_) \ ? NULL \ - : list_entry(next___, typeof(*entry), member); \ + : list_entry(next_, typeof(*entry), member); \ MACRO_END /* diff --git a/kern/rbtree.h b/kern/rbtree.h index 7ec83fe..1eafebb 100644 --- a/kern/rbtree.h +++ b/kern/rbtree.h @@ -120,22 +120,22 @@ rbtree_empty(const struct rbtree *tree) */ #define rbtree_lookup(tree, key, cmp_fn) \ MACRO_BEGIN \ - struct rbtree_node *cur___; \ - int diff___; \ + struct rbtree_node *cur_; \ + int diff_; \ \ - cur___ = (tree)->root; \ + cur_ = (tree)->root; \ \ - while (cur___ != NULL) { \ - diff___ = cmp_fn(key, cur___); \ + while (cur_ != NULL) { \ + diff_ = cmp_fn(key, cur_); \ \ - if (diff___ == 0) { \ + if (diff_ == 0) { \ break; \ } \ \ - cur___ = cur___->children[rbtree_d2i(diff___)]; \ + cur_ = cur_->children[rbtree_d2i(diff_)]; \ } \ \ - cur___; \ + cur_; \ MACRO_END /* @@ -150,30 +150,30 @@ MACRO_END */ #define rbtree_lookup_nearest(tree, key, cmp_fn, dir) \ MACRO_BEGIN \ - struct rbtree_node *cur___, *prev___; \ - int diff___, index___; \ + struct rbtree_node *cur_, *prev_; \ + int diff_, index_; \ \ - prev___ = NULL; \ - index___ = -1; \ - cur___ = (tree)->root; \ + prev_ = NULL; \ + index_ = -1; \ + cur_ = (tree)->root; \ \ - while (cur___ != NULL) { \ - diff___ = cmp_fn(key, cur___); \ + while (cur_ != NULL) { \ + diff_ = cmp_fn(key, cur_); \ \ - if (diff___ == 0) { \ + if (diff_ == 0) { \ break; \ } \ \ - prev___ = cur___; \ - index___ = rbtree_d2i(diff___); \ - cur___ = cur___->children[index___]; \ + prev_ = cur_; \ + index_ = rbtree_d2i(diff_); \ + cur_ = cur_->children[index_]; \ } \ \ - if (cur___ == NULL) { \ - cur___ = rbtree_nearest(prev___, index___, dir); \ + if (cur_ == NULL) { \ + cur_ = rbtree_nearest(prev_, index_, dir); \ } \ \ - cur___; \ + cur_; \ MACRO_END /* @@ -194,22 +194,22 @@ MACRO_END */ #define rbtree_insert(tree, node, cmp_fn) \ MACRO_BEGIN \ - struct rbtree_node *cur___, *prev___; \ - int diff___, index___; \ + struct rbtree_node *cur_, *prev_; \ + int diff_, index_; \ \ - prev___ = NULL; \ - index___ = -1; \ - cur___ = (tree)->root; \ + prev_ = NULL; \ + index_ = -1; \ + cur_ = (tree)->root; \ \ - while (cur___ != NULL) { \ - diff___ = cmp_fn(node, cur___); \ - assert(diff___ != 0); \ - prev___ = cur___; \ - index___ = rbtree_d2i(diff___); \ - cur___ = cur___->children[index___]; \ + while (cur_ != NULL) { \ + diff_ = cmp_fn(node, cur_); \ + assert(diff_ != 0); \ + prev_ = cur_; \ + index_ = rbtree_d2i(diff_); \ + cur_ = cur_->children[index_]; \ } \ \ - rbtree_insert_rebalance(tree, prev___, index___, node); \ + rbtree_insert_rebalance(tree, prev_, index_, node); \ MACRO_END /* @@ -225,27 +225,27 @@ MACRO_END */ #define rbtree_lookup_slot(tree, key, cmp_fn, slot) \ MACRO_BEGIN \ - struct rbtree_node *cur___, *prev___; \ - int diff___, index___; \ + struct rbtree_node *cur_, *prev_; \ + int diff_, index_; \ \ - prev___ = NULL; \ - index___ = 0; \ - cur___ = (tree)->root; \ + prev_ = NULL; \ + index_ = 0; \ + cur_ = (tree)->root; \ \ - while (cur___ != NULL) { \ - diff___ = cmp_fn(key, cur___); \ + while (cur_ != NULL) { \ + diff_ = cmp_fn(key, cur_); \ \ - if (diff___ == 0) { \ + if (diff_ == 0) { \ break; \ } \ \ - prev___ = cur___; \ - index___ = rbtree_d2i(diff___); \ - cur___ = cur___->children[index___]; \ + prev_ = cur_; \ + index_ = rbtree_d2i(diff_); \ + cur_ = cur_->children[index_]; \ } \ \ - (slot) = rbtree_slot(prev___, index___); \ - cur___; \ + (slot) = rbtree_slot(prev_, index_); \ + cur_; \ MACRO_END /* diff --git a/kern/shell.h b/kern/shell.h index db055e7..0526019 100644 --- a/kern/shell.h +++ b/kern/shell.h @@ -32,12 +32,12 @@ #define SHELL_REGISTER_CMDS(cmds) \ MACRO_BEGIN \ - size_t i___; \ - int error___; \ + size_t i_; \ + int error_; \ \ - for (i___ = 0; i___ < ARRAY_SIZE(cmds); i___++) { \ - error___ = shell_cmd_register(&(cmds)[i___]); \ - error_check(error___, __func__); \ + for (i_ = 0; i_ < ARRAY_SIZE(cmds); i_++) { \ + error_ = shell_cmd_register(&(cmds)[i_]); \ + error_check(error_, __func__); \ } \ MACRO_END diff --git a/kern/slist.h b/kern/slist.h index 424cdb2..8fd0a21 100644 --- a/kern/slist.h +++ b/kern/slist.h @@ -226,10 +226,10 @@ slist_remove(struct slist *list, struct slist_node *prev) */ #define slist_first_entry(list, type, member) \ MACRO_BEGIN \ - struct slist_node *first___; \ + struct slist_node *first_; \ \ - first___ = (list)->first; \ - slist_end(first___) ? NULL : slist_entry(first___, type, member); \ + first_ = (list)->first; \ + slist_end(first_) ? NULL : slist_entry(first_, type, member); \ MACRO_END /* @@ -237,23 +237,23 @@ MACRO_END */ #define slist_last_entry(list, type, member) \ MACRO_BEGIN \ - struct slist_node *last___; \ + struct slist_node *last_; \ \ - last___ = (list)->last; \ - slist_end(last___) ? NULL : slist_entry(last___, type, member); \ + last_ = (list)->last; \ + slist_end(last_) ? NULL : slist_entry(last_, type, member); \ MACRO_END /* * Get the entry next to the given entry. */ -#define slist_next_entry(entry, member) \ +#define slist_next_entry(entry, member) \ MACRO_BEGIN \ - struct slist_node *next___; \ + struct slist_node *next_; \ \ - next___ = (entry)->member.next; \ - slist_end(next___) \ + next_ = (entry)->member.next; \ + slist_end(next_) \ ? NULL \ - : slist_entry(next___, typeof(*entry), member); \ + : slist_entry(next_, typeof(*entry), member); \ MACRO_END /* @@ -409,10 +409,10 @@ slist_rcu_remove(struct slist *list, struct slist_node *prev) */ #define slist_rcu_first_entry(list, type, member) \ MACRO_BEGIN \ - struct slist_node *first___; \ + struct slist_node *first_; \ \ - first___ = slist_rcu_first(list); \ - slist_end(first___) ? NULL : slist_entry(first___, type, member); \ + first_ = slist_rcu_first(list); \ + slist_end(first_) ? NULL : slist_entry(first_, type, member); \ MACRO_END /* @@ -420,12 +420,12 @@ MACRO_END */ #define slist_rcu_next_entry(entry, member) \ MACRO_BEGIN \ - struct slist_node *next___; \ + struct slist_node *next_; \ \ - next___ = slist_rcu_next(&entry->member); \ - slist_end(next___) \ + next_ = slist_rcu_next(&entry->member); \ + slist_end(next_) \ ? NULL \ - : slist_entry(next___, typeof(*entry), member); \ + : slist_entry(next_, typeof(*entry), member); \ MACRO_END /* -- cgit v1.2.3