summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorRichard Braun <rbraun@sceen.net>2018-04-14 22:03:50 +0200
committerRichard Braun <rbraun@sceen.net>2018-04-14 22:08:47 +0200
commitd4a39d61e853f570ec8d599e9500a80b035fb61f (patch)
tree5a5d7720c9e4d93a5f63beec9d7a0cedd1dcd62d
parent4033816a7ce4a24230f462b5c22183c1b45e24df (diff)
Rename variables in function-like macros
Diffstat
-rw-r--r--arch/x86/machine/atomic.h56
-rw-r--r--arch/x86/machine/cpu.h12
-rw-r--r--doc/style.9.txt11
-rw-r--r--kern/atomic.h18
-rw-r--r--kern/hlist.h30
-rw-r--r--kern/list.h24
-rw-r--r--kern/rbtree.h94
-rw-r--r--kern/shell.h10
-rw-r--r--kern/slist.h36
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
/*
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-24 19:32:31 +0000