change bit utils to not be __*

5 files changed, 74 insertions, 73 deletions

diff --git a/common/debug.c b/common/debug.c
index 0382ba4..e7bcc50 100644
--- a/common/debug.c
+++ b/common/debug.c
@@ -174,15 +174,15 @@ static size_t __integral_val(ssize_t value, size_t base, size_t flags,
 	c = (x)value % (x)base;                                                \
 	value = (x)value / (x)base;
 
-	if (!__is_set(flags, UNSIGN_FLAG)) {
+	if (!is_set(flags, UNSIGN_FLAG)) {
 		/* signed values, only with i format */
-		if (__is_set(flags, LLONG_FLAG)) {
+		if (is_set(flags, LLONG_FLAG)) {
 			handle_type(signed long long);
-		} else if (__is_set(flags, LONG_FLAG)) {
+		} else if (is_set(flags, LONG_FLAG)) {
 			handle_type(signed long);
-		} else if (__is_set(flags, SHORT_FLAG)) {
+		} else if (is_set(flags, SHORT_FLAG)) {
 			handle_type(signed short);
-		} else if (__is_set(flags, CHAR_FLAG)) {
+		} else if (is_set(flags, CHAR_FLAG)) {
 			handle_type(signed char);
 		} else {
 			handle_type(signed int);
@@ -193,13 +193,13 @@ static size_t __integral_val(ssize_t value, size_t base, size_t flags,
 
 	} else {
 		/* unsigned values, everything else */
-		if (__is_set(flags, LLONG_FLAG)) {
+		if (is_set(flags, LLONG_FLAG)) {
 			handle_type(unsigned long long);
-		} else if (__is_set(flags, LONG_FLAG)) {
+		} else if (is_set(flags, LONG_FLAG)) {
 			handle_type(unsigned long);
-		} else if (__is_set(flags, SHORT_FLAG)) {
+		} else if (is_set(flags, SHORT_FLAG)) {
 			handle_type(unsigned short);
-		} else if (__is_set(flags, CHAR_FLAG)) {
+		} else if (is_set(flags, CHAR_FLAG)) {
 			handle_type(unsigned char);
 		} else {
 			handle_type(unsigned int);
@@ -260,13 +260,13 @@ static size_t __print_padding(size_t pad, char pad_char)
 
 static size_t __print_sign(ssize_t value, size_t flags)
 {
-	if (__is_set(flags, LLONG_FLAG))
+	if (is_set(flags, LLONG_FLAG))
 		value = (signed long long)value;
-	else if (__is_set(flags, LONG_FLAG))
+	else if (is_set(flags, LONG_FLAG))
 		value = (signed long)value;
-	else if (__is_set(flags, SHORT_FLAG))
+	else if (is_set(flags, SHORT_FLAG))
 		value = (signed short)value;
-	else if (__is_set(flags, CHAR_FLAG))
+	else if (is_set(flags, CHAR_FLAG))
 		value = (signed char)value;
 	else
 		value = (signed int)value;
@@ -290,34 +290,34 @@ static size_t __print_integral(ssize_t value, size_t base, size_t flags,
 
 	size_t ret = 0;
 	size_t raw_len = __integral_len(value, base, flags);
-	ssize_t pad = __is_set(flags, PAD_FLAG) ? width - raw_len : 0;
+	ssize_t pad = is_set(flags, PAD_FLAG) ? width - raw_len : 0;
 
 	/* depending on which flags are set, the prefix, sign and right justify has to
 	 * be ordereder differently. */
-	if (__is_set(flags, ZERO_FLAG)) {
-		if (!__is_set(flags, UNSIGN_FLAG))
+	if (is_set(flags, ZERO_FLAG)) {
+		if (!is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if (__is_set(flags, HASH_FLAG))
+		if (is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 
-		if (pad > 0 && !__is_set(flags, LEFT_FLAG))
+		if (pad > 0 && !is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, '0');
 
-	} else if (__is_set(flags, SPACE_FLAG)) {
-		if (pad > 0 && !__is_set(flags, LEFT_FLAG))
+	} else if (is_set(flags, SPACE_FLAG)) {
+		if (pad > 0 && !is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, ' ');
 
-		if (!__is_set(flags, UNSIGN_FLAG))
+		if (!is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if (__is_set(flags, HASH_FLAG))
+		if (is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 	} else {
-		if (!__is_set(flags, UNSIGN_FLAG))
+		if (!is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if (__is_set(flags, HASH_FLAG))
+		if (is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 	}
 
@@ -325,11 +325,11 @@ static size_t __print_integral(ssize_t value, size_t base, size_t flags,
 	ret += __integral_print(value, base, flags);
 
 	/* left-justify */
-	if (__is_set(flags, ZERO_FLAG)) {
-		if (pad > 0 && __is_set(flags, LEFT_FLAG))
+	if (is_set(flags, ZERO_FLAG)) {
+		if (pad > 0 && is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, '0');
-	} else if (__is_set(flags, SPACE_FLAG)) {
-		if (pad > 0 && __is_set(flags, LEFT_FLAG))
+	} else if (is_set(flags, SPACE_FLAG)) {
+		if (pad > 0 && is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, ' ');
 	}
 
@@ -374,37 +374,37 @@ void dbg(const char *fmt, ...)
 		do {
 			switch (*fmt) {
 			case ' ':
-				__set_bit(flags, SPACE_FLAG);
+				set_bit(flags, SPACE_FLAG);
 				fmt++;
 				a = CONT;
 				break;
 
 			case '-':
-				__set_bit(flags, LEFT_FLAG);
+				set_bit(flags, LEFT_FLAG);
 				fmt++;
 				a = CONT;
 				break;
 
 			case '+':
-				__set_bit(flags, SIGN_FLAG);
+				set_bit(flags, SIGN_FLAG);
 				fmt++;
 				a = CONT;
 				break;
 
 			case '#':
-				__set_bit(flags, HASH_FLAG);
+				set_bit(flags, HASH_FLAG);
 				fmt++;
 				a = CONT;
 				break;
 
 			case '0':
-				__set_bit(flags, ZERO_FLAG);
+				set_bit(flags, ZERO_FLAG);
 				fmt++;
 				a = CONT;
 				break;
 
 			case '\'':
-				__set_bit(flags, FMT_FLAG);
+				set_bit(flags, FMT_FLAG);
 				fmt++;
 				a = CONT;
 				break;
@@ -419,16 +419,16 @@ void dbg(const char *fmt, ...)
 		size_t width = 0;
 		if (__is_digit(*fmt)) {
 			width = __atoi(fmt++);
-			__set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG);
+			set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG);
 		} else if (*fmt == '*') {
 			int w = va_arg(vl, int);
 			if (w < 0) {
 				width = -w;
-				__set_bit(flags, LEFT_FLAG);
+				set_bit(flags, LEFT_FLAG);
 			} else {
 				width = w;
 			}
-			__set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG);
+			set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG);
 			fmt++;
 		}
 
@@ -436,7 +436,7 @@ void dbg(const char *fmt, ...)
 		size_t precision = 0;
 		if (*fmt == '.') {
 			fmt++;
-			__set_bit(flags, PRECS_FLAG | PAD_FLAG | ZERO_FLAG);
+			set_bit(flags, PRECS_FLAG | PAD_FLAG | ZERO_FLAG);
 			if (__is_digit(*fmt)) {
 				precision = __atoi(fmt++);
 			} else if (*fmt == '*') {
@@ -450,45 +450,45 @@ void dbg(const char *fmt, ...)
 		case 'l':
 			fmt++;
 			if (*fmt == 'l') {
-				__set_bit(flags, LLONG_FLAG);
+				set_bit(flags, LLONG_FLAG);
 				fmt++;
 			} else {
-				__set_bit(flags, LONG_FLAG);
+				set_bit(flags, LONG_FLAG);
 			}
 			break;
 
 		case 'h':
 			fmt++;
 			if (*fmt == 'h') {
-				__set_bit(flags, CHAR_FLAG);
+				set_bit(flags, CHAR_FLAG);
 				fmt++;
 			} else {
-				__set_bit(flags, SHORT_FLAG);
+				set_bit(flags, SHORT_FLAG);
 			}
 			break;
 
 		case 'j':
 			fmt++;
 			if (sizeof(intmax_t) == sizeof(long))
-				__set_bit(flags, LONG_FLAG);
+				set_bit(flags, LONG_FLAG);
 			else
-				__set_bit(flags, LLONG_FLAG);
+				set_bit(flags, LLONG_FLAG);
 			break;
 
 		case 'z':
 			fmt++;
 			if (sizeof(size_t) == sizeof(long))
-				__set_bit(flags, LONG_FLAG);
+				set_bit(flags, LONG_FLAG);
 			else
-				__set_bit(flags, LLONG_FLAG);
+				set_bit(flags, LLONG_FLAG);
 			break;
 
 		case 't':
 			fmt++;
 			if (sizeof(ptrdiff_t) == sizeof(long))
-				__set_bit(flags, LONG_FLAG);
+				set_bit(flags, LONG_FLAG);
 			else
-				__set_bit(flags, LLONG_FLAG);
+				set_bit(flags, LLONG_FLAG);
 			break;
 		}
 
@@ -526,22 +526,22 @@ void dbg(const char *fmt, ...)
 			}
 
 			if (base == 10)
-				__clear_bit(flags, HASH_FLAG);
+				clear_bit(flags, HASH_FLAG);
 
 			/* precision takes precedence */
-			if (__is_set(flags, PRECS_FLAG))
+			if (is_set(flags, PRECS_FLAG))
 				width = precision;
 
 			/* formatting doesn't apply to decimal integers
 			 * */
 			if (*fmt != 'i' && *fmt != 'd') {
-				__clear_bit(flags, SIGN_FLAG);
-				__set_bit(flags, UNSIGN_FLAG);
+				clear_bit(flags, SIGN_FLAG);
+				set_bit(flags, UNSIGN_FLAG);
 			}
 
-			if (__is_set(flags, LLONG_FLAG))
+			if (is_set(flags, LLONG_FLAG))
 				value = va_arg(vl, long long);
-			else if (__is_set(flags, LONG_FLAG))
+			else if (is_set(flags, LONG_FLAG))
 				value = va_arg(vl, long);
 			else
 				value = va_arg(vl, int);
@@ -561,7 +561,7 @@ void dbg(const char *fmt, ...)
 		case 's':
 			s = va_arg(vl, const char *);
 
-			if (__is_set(flags, PRECS_FLAG))
+			if (is_set(flags, PRECS_FLAG))
 				i = precision;
 
 			for (; *s && i--;) {
@@ -573,12 +573,12 @@ void dbg(const char *fmt, ...)
 
 		case 'p':
 			p = va_arg(vl, void *);
-			__set_bit(flags, UNSIGN_FLAG | HASH_FLAG);
+			set_bit(flags, UNSIGN_FLAG | HASH_FLAG);
 
 			if (sizeof(void *) == sizeof(long))
-				__set_bit(flags, LONG_FLAG);
+				set_bit(flags, LONG_FLAG);
 			else
-				__set_bit(flags, LLONG_FLAG);
+				set_bit(flags, LLONG_FLAG);
 
 			chars_written +=
 				__print_integral((ssize_t)p, 16, flags, width);
diff --git a/common/mem_regions.c b/common/mem_regions.c
index e1eff0d..e4d6098 100644
--- a/common/mem_regions.c
+++ b/common/mem_regions.c
@@ -10,8 +10,8 @@
 #include <apos/bits.h>
 #include <apos/mem.h>
 
-#define mark_region_used(r)   __set_bit(r, MR_USED)
-#define mark_region_unused(r) __clear_bit(r, MR_USED)
+#define mark_region_used(r)   set_bit(r, MR_USED)
+#define mark_region_unused(r) clear_bit(r, MR_USED)
 
 /* pretty major slowdown when we get to some really massive numbers, not
  * entirely sure why. Will need to check up on this at some point, have I
diff --git a/common/pmem.c b/common/pmem.c
index 725a9ff..197a0b8 100644
--- a/common/pmem.c
+++ b/common/pmem.c
@@ -26,7 +26,7 @@
 #include <apos/debug.h>
 #include <apos/initrd.h>
 #include <apos/string.h> /* memset */
-#include <apos/bits.h> /* __is_nset etc */
+#include <apos/bits.h> /* is_nset etc */
 #include <libfdt.h>
 
 /* NOTE: these are all for pnum_t, i.e. O0_SHIFT is from 0 */
@@ -39,7 +39,7 @@
 	     j < (pnum_t)MIN((end)-i * MM_OINFO_WIDTH,         \
 	                     MM_OINFO_WIDTH);                  \
 	     ++j, ++page)                                      \
-	if (neg(__is_nset(var->attr[i], j)))
+	if (neg(is_nset(var->attr[i], j)))
 
 #define NEG !
 #define foreach_full_page(var, start, order)                                   \
@@ -87,7 +87,7 @@ static void __mark_free(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
 
 	if (src == dst) {
 		struct mm_leaf_t *o = (struct mm_leaf_t *)op;
-		__clear_nbit(o->used[__o_container(idx)], __o_bit(idx));
+		clear_nbit(o->used[__o_container(idx)], __o_bit(idx));
 		return;
 	}
 
@@ -96,7 +96,7 @@ static void __mark_free(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
 		__mark_free(o->next[idx], pnum, tgt, src - 1, dst);
 
 	/* freeing a page results in always clearing a full bit? */
-	__clear_nbit(o->full[__o_container(idx)], __o_bit(idx));
+	clear_nbit(o->full[__o_container(idx)], __o_bit(idx));
 }
 
 /* this could probably use an int for status, but eh */
@@ -126,7 +126,7 @@ static bool __mark_used(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
 
 	if (src == dst) {
 		struct mm_leaf_t *o = (struct mm_leaf_t *)op;
-		__set_nbit(o->used[__o_container(idx)], __o_bit(idx));
+		set_nbit(o->used[__o_container(idx)], __o_bit(idx));
 
 		if (idx == max_index(src))
 			return true;
@@ -136,7 +136,7 @@ static bool __mark_used(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
 
 	struct mm_branch_t *o = (struct mm_branch_t *)op;
 	if (src == tgt) {
-		__set_nbit(o->full[__o_container(idx)], __o_bit(idx));
+		set_nbit(o->full[__o_container(idx)], __o_bit(idx));
 
 		if (idx == max_index(src))
 			return true;
@@ -145,7 +145,7 @@ static bool __mark_used(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
 	}
 
 	if (__mark_used(o->next[idx], pnum, tgt, src - 1, dst)) {
-		__set_nbit(o->full[__o_container(idx)], __o_bit(idx));
+		set_nbit(o->full[__o_container(idx)], __o_bit(idx));
 
 		if (idx == max_index(src))
 			return true;
diff --git a/common/uapi/proc.c b/common/uapi/proc.c
index 3f715af..c898339 100644
--- a/common/uapi/proc.c
+++ b/common/uapi/proc.c
@@ -3,6 +3,7 @@
  * Process/thread handling syscall implementations.
  */
 
+#include <apos/elf.h>
 #include <apos/uapi.h>
 #include <apos/bits.h>
 #include <apos/mem_regions.h>
@@ -33,7 +34,7 @@ SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
 	struct mem_region *b = find_used_region(&r->sp_r, bin);
 	if (!b)
 		return (struct sys_ret){ERR_INVAL, 0};
-	__set_bit(b->flags, MR_KEEP);
+	set_bit(b->flags, MR_KEEP);
 
 	struct mem_region *i = 0;
 	if (interp) {
@@ -41,16 +42,16 @@ SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
 		i = find_used_region(&r->sp_r, interp);
 		if (!i)
 			return (struct sys_ret){ERR_INVAL, 1};
-		__set_bit(i->flags, MR_KEEP);
+		set_bit(i->flags, MR_KEEP);
 	}
 
 	/* free everything except regions to be kept */
 	clear_uvmem(r, false);
 
 	/* restore to normal */
-	__clear_bit(b->flags, MR_KEEP);
+	clear_bit(b->flags, MR_KEEP);
 	if (interp)
-		__clear_bit(b->flags, MR_KEEP);
+		clear_bit(b->flags, MR_KEEP);
 
 	/* TODO: set entry? */
 	load_elf(r, b, i);
diff --git a/common/vmem.c b/common/vmem.c
index 3ea9ed7..74701d8 100644
--- a/common/vmem.c
+++ b/common/vmem.c
@@ -99,7 +99,7 @@ vm_t ref_shared_uvmem(struct tcb *t1, struct tcb *t2, vm_t va, vmflags_t flags)
 	if (!m)
 		return 0;
 
-	if (!__is_set(m->flags, MR_OWNED))
+	if (!is_set(m->flags, MR_OWNED))
 		return 0;
 
 	/* loop over all pages in this region */
@@ -182,7 +182,7 @@ stat_t free_uvmem_wrapper(struct vmem *b, pm_t *offset, vm_t vaddr,
 		*status = ret;
 
 	/* don't free shared pages, unless they're owned */
-	if (!__is_set(flags, MR_SHARED) || __is_set(flags, MR_OWNED))
+	if (!is_set(flags, MR_SHARED) || is_set(flags, MR_OWNED))
 		free_page(order, paddr);
 
 	return (ret == INFO_SEFF) ? OK : ret;