Skip to contentSkip to conversation

lib: Cleanups

PATCH Superseded Andrew Jones 2 participants 7 messages May 19, 2022 – May 20, 2022

Subsystems (3)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover lib: Cleanups

1) Finally, finally, finally reformat printf.c and string.c, the last two files that had weird formatting.

2) Collect is* ctype functions into a new lib/ctype.h file.

Andrew Jones (2):
lib: Fix whitespace
lib: Add ctype.h and collect is* functions

 lib/argv.c   |   7 +-
 lib/ctype.h  |  40 +++++
 lib/printf.c | 427 +++++++++++++++++++++++++--------------------------
 lib/string.c | 356 +++++++++++++++++++++---------------------
 4 files changed, 431 insertions(+), 399 deletions(-)
 create mode 100644 lib/ctype.h
Signature · 1 line
2.34.3
#1 lore raw

PATCH 1/2 lib: Fix whitespace

printf.c and string.c are a couple of the original files and are the last that still have the original formatting. Let's finally clean them up!

The change was done by modifying Linux's scripts/Lindent to use 100 columns instead of 80 and then manually reverting a few changes that I didn't like, which I found by diffing with -b.

---
 lib/printf.c | 427 +++++++++++++++++++++++++--------------------------
 lib/string.c | 354 +++++++++++++++++++++---------------------
 2 files changed, 390 insertions(+), 391 deletions(-)
lib/printf.c +213 -214
index 1269723ef720..383799ec0717 100644
@@ -10,285 +10,284 @@
 #define BUFSZ 2000
 
 typedef struct pstream {
-    char *buffer;
-    int remain;
-    int added;
+	char *buffer;
+	int remain;
+	int added;
 } pstream_t;
 
 typedef struct strprops {
-    char pad;
-    int npad;
-    bool alternate;
+	char pad;
+	int npad;
+	bool alternate;
 } strprops_t;
 
 static void addchar(pstream_t *p, char c)
 {
-    if (p->remain) {
-	*p->buffer++ = c;
-	--p->remain;
-    }
-    ++p->added;
+	if (p->remain) {
+		*p->buffer++ = c;
+		--p->remain;
+	}
+	++p->added;
 }
 
 static void print_str(pstream_t *p, const char *s, strprops_t props)
 {
-    const char *s_orig = s;
-    int npad = props.npad;
-
-    if (npad > 0) {
-	npad -= strlen(s_orig);
-	while (npad > 0) {
-	    addchar(p, props.pad);
-	    --npad;
+	const char *s_orig = s;
+	int npad = props.npad;
+
+	if (npad > 0) {
+		npad -= strlen(s_orig);
+		while (npad > 0) {
+			addchar(p, props.pad);
+			--npad;
+		}
 	}
-    }
 
-    while (*s)
-	addchar(p, *s++);
+	while (*s)
+		addchar(p, *s++);
 
-    if (npad < 0) {
-	props.pad = ' '; /* ignore '0' flag with '-' flag */
-	npad += strlen(s_orig);
-	while (npad < 0) {
-	    addchar(p, props.pad);
-	    ++npad;
+	if (npad < 0) {
+		props.pad = ' ';	/* ignore '0' flag with '-' flag */
+		npad += strlen(s_orig);
+		while (npad < 0) {
+			addchar(p, props.pad);
+			++npad;
+		}
 	}
-    }
 }
 
 static char digits[16] = "0123456789abcdef";
 
 static void print_int(pstream_t *ps, long long n, int base, strprops_t props)
 {
-    char buf[sizeof(long) * 3 + 2], *p = buf;
-    int s = 0, i;
+	char buf[sizeof(long) * 3 + 2], *p = buf;
+	int s = 0, i;
 
-    if (n < 0) {
-	n = -n;
-	s = 1;
-    }
+	if (n < 0) {
+		n = -n;
+		s = 1;
+	}
 
-    while (n) {
-	*p++ = digits[n % base];
-	n /= base;
-    }
+	while (n) {
+		*p++ = digits[n % base];
+		n /= base;
+	}
 
-    if (s)
-	*p++ = '-';
+	if (s)
+		*p++ = '-';
 
-    if (p == buf)
-	*p++ = '0';
+	if (p == buf)
+		*p++ = '0';
 
-    for (i = 0; i < (p - buf) / 2; ++i) {
-	char tmp;
+	for (i = 0; i < (p - buf) / 2; ++i) {
+		char tmp;
 
-	tmp = buf[i];
-	buf[i] = p[-1-i];
-	p[-1-i] = tmp;
-    }
+		tmp = buf[i];
+		buf[i] = p[-1 - i];
+		p[-1 - i] = tmp;
+	}
 
-    *p = 0;
+	*p = 0;
 
-    print_str(ps, buf, props);
+	print_str(ps, buf, props);
 }
 
 static void print_unsigned(pstream_t *ps, unsigned long long n, int base,
 			   strprops_t props)
 {
-    char buf[sizeof(long) * 3 + 3], *p = buf;
-    int i;
-
-    while (n) {
-	*p++ = digits[n % base];
-	n /= base;
-    }
-
-    if (p == buf)
-	*p++ = '0';
-    else if (props.alternate && base == 16) {
-	if (props.pad == '0') {
-	    addchar(ps, '0');
-	    addchar(ps, 'x');
-
-	    if (props.npad > 0)
-		props.npad = MAX(props.npad - 2, 0);
-	} else {
-	    *p++ = 'x';
-	    *p++ = '0';
+	char buf[sizeof(long) * 3 + 3], *p = buf;
+	int i;
+
+	while (n) {
+		*p++ = digits[n % base];
+		n /= base;
+	}
+
+	if (p == buf)
+		*p++ = '0';
+	else if (props.alternate && base == 16) {
+		if (props.pad == '0') {
+			addchar(ps, '0');
+			addchar(ps, 'x');
+
+			if (props.npad > 0)
+				props.npad = MAX(props.npad - 2, 0);
+		} else {
+			*p++ = 'x';
+			*p++ = '0';
+		}
 	}
-    }
 
-    for (i = 0; i < (p - buf) / 2; ++i) {
-	char tmp;
+	for (i = 0; i < (p - buf) / 2; ++i) {
+		char tmp;
 
-	tmp = buf[i];
-	buf[i] = p[-1-i];
-	p[-1-i] = tmp;
-    }
+		tmp = buf[i];
+		buf[i] = p[-1 - i];
+		p[-1 - i] = tmp;
+	}
 
-    *p = 0;
+	*p = 0;
 
-    print_str(ps, buf, props);
+	print_str(ps, buf, props);
 }
 
 static int fmtnum(const char **fmt)
 {
-    const char *f = *fmt;
-    int len = 0, num;
+	const char *f = *fmt;
+	int len = 0, num;
 
-    if (*f == '-')
-	++f, ++len;
+	if (*f == '-')
+		++f, ++len;
 
-    while (*f >= '0' && *f <= '9')
-	++f, ++len;
+	while (*f >= '0' && *f <= '9')
+		++f, ++len;
 
-    num = atol(*fmt);
-    *fmt += len;
-    return num;
+	num = atol(*fmt);
+	*fmt += len;
+	return num;
 }
 
 int vsnprintf(char *buf, int size, const char *fmt, va_list va)
 {
-    pstream_t s;
-
-    s.buffer = buf;
-    s.remain = size - 1;
-    s.added = 0;
-    while (*fmt) {
-	char f = *fmt++;
-	int nlong = 0;
-	strprops_t props;
-	memset(&props, 0, sizeof(props));
-	props.pad = ' ';
-
-	if (f != '%') {
-	    addchar(&s, f);
-	    continue;
-	}
-    morefmt:
-	f = *fmt++;
-	switch (f) {
-	case '%':
-	    addchar(&s, '%');
-	    break;
-	case 'c':
-            addchar(&s, va_arg(va, int));
-	    break;
-	case '\0':
-	    --fmt;
-	    break;
-	case '#':
-	    props.alternate = true;
-	    goto morefmt;
-	case '0':
-	    props.pad = '0';
-	    ++fmt;
-	    /* fall through */
-	case '1'...'9':
-	case '-':
-	    --fmt;
-	    props.npad = fmtnum(&fmt);
-	    goto morefmt;
-	case 'l':
-	    ++nlong;
-	    goto morefmt;
-	case 't':
-	case 'z':
-	    /* Here we only care that sizeof(size_t) == sizeof(long).
-	     * On a 32-bit platform it doesn't matter that size_t is
-	     * typedef'ed to int or long; va_arg will work either way.
-	     * Same for ptrdiff_t (%td).
-	     */
-	    nlong = 1;
-	    goto morefmt;
-	case 'd':
-	    switch (nlong) {
-	    case 0:
-		print_int(&s, va_arg(va, int), 10, props);
-		break;
-	    case 1:
-		print_int(&s, va_arg(va, long), 10, props);
-		break;
-	    default:
-		print_int(&s, va_arg(va, long long), 10, props);
-		break;
-	    }
-	    break;
-	case 'u':
-	    switch (nlong) {
-	    case 0:
-		print_unsigned(&s, va_arg(va, unsigned), 10, props);
-		break;
-	    case 1:
-		print_unsigned(&s, va_arg(va, unsigned long), 10, props);
-		break;
-	    default:
-		print_unsigned(&s, va_arg(va, unsigned long long), 10, props);
-		break;
-	    }
-	    break;
-	case 'x':
-	    switch (nlong) {
-	    case 0:
-		print_unsigned(&s, va_arg(va, unsigned), 16, props);
-		break;
-	    case 1:
-		print_unsigned(&s, va_arg(va, unsigned long), 16, props);
-		break;
-	    default:
-		print_unsigned(&s, va_arg(va, unsigned long long), 16, props);
-		break;
-	    }
-	    break;
-	case 'p':
-	    props.alternate = true;
-	    print_unsigned(&s, (unsigned long)va_arg(va, void *), 16, props);
-	    break;
-	case 's':
-	    print_str(&s, va_arg(va, const char *), props);
-	    break;
-	default:
-	    addchar(&s, f);
-	    break;
+	pstream_t s;
+
+	s.buffer = buf;
+	s.remain = size - 1;
+	s.added = 0;
+	while (*fmt) {
+		char f = *fmt++;
+		int nlong = 0;
+		strprops_t props;
+		memset(&props, 0, sizeof(props));
+		props.pad = ' ';
+
+		if (f != '%') {
+			addchar(&s, f);
+			continue;
+		}
+morefmt:
+		f = *fmt++;
+		switch (f) {
+		case '%':
+			addchar(&s, '%');
+			break;
+		case 'c':
+			addchar(&s, va_arg(va, int));
+			break;
+		case '\0':
+			--fmt;
+			break;
+		case '#':
+			props.alternate = true;
+			goto morefmt;
+		case '0':
+			props.pad = '0';
+			++fmt;
+			/* fall through */
+		case '1' ... '9':
+		case '-':
+			--fmt;
+			props.npad = fmtnum(&fmt);
+			goto morefmt;
+		case 'l':
+			++nlong;
+			goto morefmt;
+		case 't':
+		case 'z':
+			/* Here we only care that sizeof(size_t) == sizeof(long).
+			 * On a 32-bit platform it doesn't matter that size_t is
+			 * typedef'ed to int or long; va_arg will work either way.
+			 * Same for ptrdiff_t (%td).
+			 */
+			nlong = 1;
+			goto morefmt;
+		case 'd':
+			switch (nlong) {
+			case 0:
+				print_int(&s, va_arg(va, int), 10, props);
+				break;
+			case 1:
+				print_int(&s, va_arg(va, long), 10, props);
+				break;
+			default:
+				print_int(&s, va_arg(va, long long), 10, props);
+				break;
+			}
+			break;
+		case 'u':
+			switch (nlong) {
+			case 0:
+				print_unsigned(&s, va_arg(va, unsigned), 10, props);
+				break;
+			case 1:
+				print_unsigned(&s, va_arg(va, unsigned long), 10, props);
+				break;
+			default:
+				print_unsigned(&s, va_arg(va, unsigned long long), 10, props);
+				break;
+			}
+			break;
+		case 'x':
+			switch (nlong) {
+			case 0:
+				print_unsigned(&s, va_arg(va, unsigned), 16, props);
+				break;
+			case 1:
+				print_unsigned(&s, va_arg(va, unsigned long), 16, props);
+				break;
+			default:
+				print_unsigned(&s, va_arg(va, unsigned long long), 16, props);
+				break;
+			}
+			break;
+		case 'p':
+			props.alternate = true;
+			print_unsigned(&s, (unsigned long)va_arg(va, void *), 16, props);
+			break;
+		case 's':
+			print_str(&s, va_arg(va, const char *), props);
+			break;
+		default:
+			addchar(&s, f);
+			break;
+		}
 	}
-    }
-    *s.buffer = 0;
-    return s.added;
+	*s.buffer = 0;
+	return s.added;
 }
 
-
 int snprintf(char *buf, int size, const char *fmt, ...)
 {
-    va_list va;
-    int r;
+	va_list va;
+	int r;
 
-    va_start(va, fmt);
-    r = vsnprintf(buf, size, fmt, va);
-    va_end(va);
-    return r;
+	va_start(va, fmt);
+	r = vsnprintf(buf, size, fmt, va);
+	va_end(va);
+	return r;
 }
 
 int vprintf(const char *fmt, va_list va)
 {
-    char buf[BUFSZ];
-    int r;
+	char buf[BUFSZ];
+	int r;
 
-    r = vsnprintf(buf, sizeof(buf), fmt, va);
-    puts(buf);
-    return r;
+	r = vsnprintf(buf, sizeof(buf), fmt, va);
+	puts(buf);
+	return r;
 }
 
 int printf(const char *fmt, ...)
 {
-    va_list va;
-    char buf[BUFSZ];
-    int r;
-
-    va_start(va, fmt);
-    r = vsnprintf(buf, sizeof buf, fmt, va);
-    va_end(va);
-    puts(buf);
-    return r;
+	va_list va;
+	char buf[BUFSZ];
+	int r;
+
+	va_start(va, fmt);
+	r = vsnprintf(buf, sizeof buf, fmt, va);
+	va_end(va);
+	puts(buf);
+	return r;
 }
 
 void binstr(unsigned long x, char out[BINSTR_SZ])
lib/string.c +177 -177

458 lines not on this page · raw message

Signature · 1 line
2.34.3
#2 lore raw

Re: [PATCH kvm-unit-tests 1/2] lib: Fix whitespace

Quoted 9 lines · Andrew Jones

printf.c and string.c are a couple of the original files and are the last that still have the original formatting. Let's finally clean them up!

The change was done by modifying Linux's scripts/Lindent to use 100 columns instead of 80 and then manually reverting a few changes that I didn't like, which I found by diffing with -b.

Looks good to me.

Reviewed-by: Nikos Nikoleris <[email protected]> 

Quoted 971 lines
---
  lib/printf.c | 427 +++++++++++++++++++++++++--------------------------
  lib/string.c | 354 +++++++++++++++++++++---------------------
  2 files changed, 390 insertions(+), 391 deletions(-)
lib/printf.c +213 -214
index 1269723ef720..383799ec0717 100644
@@ -10,285 +10,284 @@
  #define BUFSZ 2000
 
  typedef struct pstream {
-    char *buffer;
-    int remain;
-    int added;
+	char *buffer;
+	int remain;
+	int added;
  } pstream_t;
 
  typedef struct strprops {
-    char pad;
-    int npad;
-    bool alternate;
+	char pad;
+	int npad;
+	bool alternate;
  } strprops_t;
 
  static void addchar(pstream_t *p, char c)
  {
-    if (p->remain) {
-	*p->buffer++ = c;
-	--p->remain;
-    }
-    ++p->added;
+	if (p->remain) {
+		*p->buffer++ = c;
+		--p->remain;
+	}
+	++p->added;
  }
 
  static void print_str(pstream_t *p, const char *s, strprops_t props)
  {
-    const char *s_orig = s;
-    int npad = props.npad;
-
-    if (npad > 0) {
-	npad -= strlen(s_orig);
-	while (npad > 0) {
-	    addchar(p, props.pad);
-	    --npad;
+	const char *s_orig = s;
+	int npad = props.npad;
+
+	if (npad > 0) {
+		npad -= strlen(s_orig);
+		while (npad > 0) {
+			addchar(p, props.pad);
+			--npad;
+		}
  	}
-    }
 
-    while (*s)
-	addchar(p, *s++);
+	while (*s)
+		addchar(p, *s++);
 
-    if (npad < 0) {
-	props.pad = ' '; /* ignore '0' flag with '-' flag */
-	npad += strlen(s_orig);
-	while (npad < 0) {
-	    addchar(p, props.pad);
-	    ++npad;
+	if (npad < 0) {
+		props.pad = ' ';	/* ignore '0' flag with '-' flag */
+		npad += strlen(s_orig);
+		while (npad < 0) {
+			addchar(p, props.pad);
+			++npad;
+		}
  	}
-    }
  }
 
  static char digits[16] = "0123456789abcdef";
 
  static void print_int(pstream_t *ps, long long n, int base, strprops_t props)
  {
-    char buf[sizeof(long) * 3 + 2], *p = buf;
-    int s = 0, i;
+	char buf[sizeof(long) * 3 + 2], *p = buf;
+	int s = 0, i;
 
-    if (n < 0) {
-	n = -n;
-	s = 1;
-    }
+	if (n < 0) {
+		n = -n;
+		s = 1;
+	}
 
-    while (n) {
-	*p++ = digits[n % base];
-	n /= base;
-    }
+	while (n) {
+		*p++ = digits[n % base];
+		n /= base;
+	}
 
-    if (s)
-	*p++ = '-';
+	if (s)
+		*p++ = '-';
 
-    if (p == buf)
-	*p++ = '0';
+	if (p == buf)
+		*p++ = '0';
 
-    for (i = 0; i < (p - buf) / 2; ++i) {
-	char tmp;
+	for (i = 0; i < (p - buf) / 2; ++i) {
+		char tmp;
 
-	tmp = buf[i];
-	buf[i] = p[-1-i];
-	p[-1-i] = tmp;
-    }
+		tmp = buf[i];
+		buf[i] = p[-1 - i];
+		p[-1 - i] = tmp;
+	}
 
-    *p = 0;
+	*p = 0;
 
-    print_str(ps, buf, props);
+	print_str(ps, buf, props);
  }
 
  static void print_unsigned(pstream_t *ps, unsigned long long n, int base,
  			   strprops_t props)
  {
-    char buf[sizeof(long) * 3 + 3], *p = buf;
-    int i;
-
-    while (n) {
-	*p++ = digits[n % base];
-	n /= base;
-    }
-
-    if (p == buf)
-	*p++ = '0';
-    else if (props.alternate && base == 16) {
-	if (props.pad == '0') {
-	    addchar(ps, '0');
-	    addchar(ps, 'x');
-
-	    if (props.npad > 0)
-		props.npad = MAX(props.npad - 2, 0);
-	} else {
-	    *p++ = 'x';
-	    *p++ = '0';
+	char buf[sizeof(long) * 3 + 3], *p = buf;
+	int i;
+
+	while (n) {
+		*p++ = digits[n % base];
+		n /= base;
+	}
+
+	if (p == buf)
+		*p++ = '0';
+	else if (props.alternate && base == 16) {
+		if (props.pad == '0') {
+			addchar(ps, '0');
+			addchar(ps, 'x');
+
+			if (props.npad > 0)
+				props.npad = MAX(props.npad - 2, 0);
+		} else {
+			*p++ = 'x';
+			*p++ = '0';
+		}
  	}
-    }
 
-    for (i = 0; i < (p - buf) / 2; ++i) {
-	char tmp;
+	for (i = 0; i < (p - buf) / 2; ++i) {
+		char tmp;
 
-	tmp = buf[i];
-	buf[i] = p[-1-i];
-	p[-1-i] = tmp;
-    }
+		tmp = buf[i];
+		buf[i] = p[-1 - i];
+		p[-1 - i] = tmp;
+	}
 
-    *p = 0;
+	*p = 0;
 
-    print_str(ps, buf, props);
+	print_str(ps, buf, props);
  }
 
  static int fmtnum(const char **fmt)
  {
-    const char *f = *fmt;
-    int len = 0, num;
+	const char *f = *fmt;
+	int len = 0, num;
 
-    if (*f == '-')
-	++f, ++len;
+	if (*f == '-')
+		++f, ++len;
 
-    while (*f >= '0' && *f <= '9')
-	++f, ++len;
+	while (*f >= '0' && *f <= '9')
+		++f, ++len;
 
-    num = atol(*fmt);
-    *fmt += len;
-    return num;
+	num = atol(*fmt);
+	*fmt += len;
+	return num;
  }
 
  int vsnprintf(char *buf, int size, const char *fmt, va_list va)
  {
-    pstream_t s;
-
-    s.buffer = buf;
-    s.remain = size - 1;
-    s.added = 0;
-    while (*fmt) {
-	char f = *fmt++;
-	int nlong = 0;
-	strprops_t props;
-	memset(&props, 0, sizeof(props));
-	props.pad = ' ';
-
-	if (f != '%') {
-	    addchar(&s, f);
-	    continue;
-	}
-    morefmt:
-	f = *fmt++;
-	switch (f) {
-	case '%':
-	    addchar(&s, '%');
-	    break;
-	case 'c':
-            addchar(&s, va_arg(va, int));
-	    break;
-	case '\0':
-	    --fmt;
-	    break;
-	case '#':
-	    props.alternate = true;
-	    goto morefmt;
-	case '0':
-	    props.pad = '0';
-	    ++fmt;
-	    /* fall through */
-	case '1'...'9':
-	case '-':
-	    --fmt;
-	    props.npad = fmtnum(&fmt);
-	    goto morefmt;
-	case 'l':
-	    ++nlong;
-	    goto morefmt;
-	case 't':
-	case 'z':
-	    /* Here we only care that sizeof(size_t) == sizeof(long).
-	     * On a 32-bit platform it doesn't matter that size_t is
-	     * typedef'ed to int or long; va_arg will work either way.
-	     * Same for ptrdiff_t (%td).
-	     */
-	    nlong = 1;
-	    goto morefmt;
-	case 'd':
-	    switch (nlong) {
-	    case 0:
-		print_int(&s, va_arg(va, int), 10, props);
-		break;
-	    case 1:
-		print_int(&s, va_arg(va, long), 10, props);
-		break;
-	    default:
-		print_int(&s, va_arg(va, long long), 10, props);
-		break;
-	    }
-	    break;
-	case 'u':
-	    switch (nlong) {
-	    case 0:
-		print_unsigned(&s, va_arg(va, unsigned), 10, props);
-		break;
-	    case 1:
-		print_unsigned(&s, va_arg(va, unsigned long), 10, props);
-		break;
-	    default:
-		print_unsigned(&s, va_arg(va, unsigned long long), 10, props);
-		break;
-	    }
-	    break;
-	case 'x':
-	    switch (nlong) {
-	    case 0:
-		print_unsigned(&s, va_arg(va, unsigned), 16, props);
-		break;
-	    case 1:
-		print_unsigned(&s, va_arg(va, unsigned long), 16, props);
-		break;
-	    default:
-		print_unsigned(&s, va_arg(va, unsigned long long), 16, props);
-		break;
-	    }
-	    break;
-	case 'p':
-	    props.alternate = true;
-	    print_unsigned(&s, (unsigned long)va_arg(va, void *), 16, props);
-	    break;
-	case 's':
-	    print_str(&s, va_arg(va, const char *), props);
-	    break;
-	default:
-	    addchar(&s, f);
-	    break;
+	pstream_t s;
+
+	s.buffer = buf;
+	s.remain = size - 1;
+	s.added = 0;
+	while (*fmt) {
+		char f = *fmt++;
+		int nlong = 0;
+		strprops_t props;
+		memset(&props, 0, sizeof(props));
+		props.pad = ' ';
+
+		if (f != '%') {
+			addchar(&s, f);
+			continue;
+		}
+morefmt:
+		f = *fmt++;
+		switch (f) {
+		case '%':
+			addchar(&s, '%');
+			break;
+		case 'c':
+			addchar(&s, va_arg(va, int));
+			break;
+		case '\0':
+			--fmt;
+			break;
+		case '#':
+			props.alternate = true;
+			goto morefmt;
+		case '0':
+			props.pad = '0';
+			++fmt;
+			/* fall through */
+		case '1' ... '9':
+		case '-':
+			--fmt;
+			props.npad = fmtnum(&fmt);
+			goto morefmt;
+		case 'l':
+			++nlong;
+			goto morefmt;
+		case 't':
+		case 'z':
+			/* Here we only care that sizeof(size_t) == sizeof(long).
+			 * On a 32-bit platform it doesn't matter that size_t is
+			 * typedef'ed to int or long; va_arg will work either way.
+			 * Same for ptrdiff_t (%td).
+			 */
+			nlong = 1;
+			goto morefmt;
+		case 'd':
+			switch (nlong) {
+			case 0:
+				print_int(&s, va_arg(va, int), 10, props);
+				break;
+			case 1:
+				print_int(&s, va_arg(va, long), 10, props);
+				break;
+			default:
+				print_int(&s, va_arg(va, long long), 10, props);
+				break;
+			}
+			break;
+		case 'u':
+			switch (nlong) {
+			case 0:
+				print_unsigned(&s, va_arg(va, unsigned), 10, props);
+				break;
+			case 1:
+				print_unsigned(&s, va_arg(va, unsigned long), 10, props);
+				break;
+			default:
+				print_unsigned(&s, va_arg(va, unsigned long long), 10, props);
+				break;
+			}
+			break;
+		case 'x':
+			switch (nlong) {
+			case 0:
+				print_unsigned(&s, va_arg(va, unsigned), 16, props);
+				break;
+			case 1:
+				print_unsigned(&s, va_arg(va, unsigned long), 16, props);
+				break;
+			default:
+				print_unsigned(&s, va_arg(va, unsigned long long), 16, props);
+				break;
+			}
+			break;
+		case 'p':
+			props.alternate = true;
+			print_unsigned(&s, (unsigned long)va_arg(va, void *), 16, props);
+			break;
+		case 's':
+			print_str(&s, va_arg(va, const char *), props);
+			break;
+		default:
+			addchar(&s, f);
+			break;
+		}
  	}
-    }
-    *s.buffer = 0;
-    return s.added;
+	*s.buffer = 0;
+	return s.added;
  }
 
-
  int snprintf(char *buf, int size, const char *fmt, ...)
  {
-    va_list va;
-    int r;
+	va_list va;
+	int r;
 
-    va_start(va, fmt);
-    r = vsnprintf(buf, size, fmt, va);
-    va_end(va);
-    return r;
+	va_start(va, fmt);
+	r = vsnprintf(buf, size, fmt, va);
+	va_end(va);
+	return r;
  }
 
  int vprintf(const char *fmt, va_list va)
  {
-    char buf[BUFSZ];
-    int r;
+	char buf[BUFSZ];
+	int r;
 
-    r = vsnprintf(buf, sizeof(buf), fmt, va);
-    puts(buf);
-    return r;
+	r = vsnprintf(buf, sizeof(buf), fmt, va);
+	puts(buf);
+	return r;
  }
 
  int printf(const char *fmt, ...)
  {
-    va_list va;
-    char buf[BUFSZ];
-    int r;
-
-    va_start(va, fmt);
-    r = vsnprintf(buf, sizeof buf, fmt, va);
-    va_end(va);
-    puts(buf);
-    return r;
+	va_list va;
+	char buf[BUFSZ];
+	int r;
+
+	va_start(va, fmt);
+	r = vsnprintf(buf, sizeof buf, fmt, va);
+	va_end(va);
+	puts(buf);
+	return r;
  }
 
  void binstr(unsigned long x, char out[BINSTR_SZ])
lib/string.c +177 -177
index 27106dae0b0b..a3a8f3b1ce0b 100644
@@ -11,281 +11,281 @@
 
  size_t strlen(const char *buf)
  {
-    size_t len = 0;
+	size_t len = 0;
 
-    while (*buf++)
-	++len;
-    return len;
+	while (*buf++)
+		++len;
+	return len;
  }
 
  size_t strnlen(const char *buf, size_t maxlen)
  {
-    const char *sc;
+	const char *sc;
 
-    for (sc = buf; maxlen-- && *sc != '\0'; ++sc)
-        /* nothing */;
-    return sc - buf;
+	for (sc = buf; maxlen-- && *sc != '\0'; ++sc)
+		/* nothing */ ;
+	return sc - buf;
  }
 
  char *strcat(char *dest, const char *src)
  {
-    char *p = dest;
+	char *p = dest;
 
-    while (*p)
-	++p;
-    while ((*p++ = *src++) != 0)
-	;
-    return dest;
+	while (*p)
+		++p;
+	while ((*p++ = *src++) != 0)
+		;
+	return dest;
  }
 
  char *strcpy(char *dest, const char *src)
  {
-    *dest = 0;
-    return strcat(dest, src);
+	*dest = 0;
+	return strcat(dest, src);
  }
 
  int strncmp(const char *a, const char *b, size_t n)
  {
-    for (; n--; ++a, ++b)
-        if (*a != *b || *a == '\0')
-            return *a - *b;
+	for (; n--; ++a, ++b)
+		if (*a != *b || *a == '\0')
+			return *a - *b;
 
-    return 0;
+	return 0;
  }
 
  int strcmp(const char *a, const char *b)
  {
-    return strncmp(a, b, SIZE_MAX);
+	return strncmp(a, b, SIZE_MAX);
  }
 
  char *strchr(const char *s, int c)
  {
-    while (*s != (char)c)
-	if (*s++ == '\0')
-	    return NULL;
-    return (char *)s;
+	while (*s != (char)c)
+		if (*s++ == '\0')
+			return NULL;
+	return (char *)s;
  }
 
  char *strrchr(const char *s, int c)
  {
-    const char *last = NULL;
-    do {
-        if (*s == (char)c)
-            last = s;
-    } while (*s++);
-    return (char *)last;
+	const char *last = NULL;
+	do {
+		if (*s == (char)c)
+			last = s;
+	} while (*s++);
+	return (char *)last;
  }
 
  char *strchrnul(const char *s, int c)
  {
-    while (*s && *s != (char)c)
-        s++;
-    return (char *)s;
+	while (*s && *s != (char)c)
+		s++;
+	return (char *)s;
  }
 
  char *strstr(const char *s1, const char *s2)
  {
-    size_t l1, l2;
-
-    l2 = strlen(s2);
-    if (!l2)
-	return (char *)s1;
-    l1 = strlen(s1);
-    while (l1 >= l2) {
-	l1--;
-	if (!memcmp(s1, s2, l2))
-	    return (char *)s1;
-	s1++;
-    }
-    return NULL;
+	size_t l1, l2;
+
+	l2 = strlen(s2);
+	if (!l2)
+		return (char *)s1;
+	l1 = strlen(s1);
+	while (l1 >= l2) {
+		l1--;
+		if (!memcmp(s1, s2, l2))
+			return (char *)s1;
+		s1++;
+	}
+	return NULL;
  }
 
  void *memset(void *s, int c, size_t n)
  {
-    size_t i;
-    char *a = s;
+	size_t i;
+	char *a = s;
 
-    for (i = 0; i < n; ++i)
-        a[i] = c;
+	for (i = 0; i < n; ++i)
+		a[i] = c;
 
-    return s;
+	return s;
  }
 
  void *memcpy(void *dest, const void *src, size_t n)
  {
-    size_t i;
-    char *a = dest;
-    const char *b = src;
+	size_t i;
+	char *a = dest;
+	const char *b = src;
 
-    for (i = 0; i < n; ++i)
-        a[i] = b[i];
+	for (i = 0; i < n; ++i)
+		a[i] = b[i];
 
-    return dest;
+	return dest;
  }
 
  int memcmp(const void *s1, const void *s2, size_t n)
  {
-    const unsigned char *a = s1, *b = s2;
-    int ret = 0;
-
-    while (n--) {
-	ret = *a - *b;
-	if (ret)
-	    break;
-	++a, ++b;
-    }
-    return ret;
+	const unsigned char *a = s1, *b = s2;
+	int ret = 0;
+
+	while (n--) {
+		ret = *a - *b;
+		if (ret)
+			break;
+		++a, ++b;
+	}
+	return ret;
  }
 
  void *memmove(void *dest, const void *src, size_t n)
  {
-    const unsigned char *s = src;
-    unsigned char *d = dest;
-
-    if (d <= s) {
-	while (n--)
-	    *d++ = *s++;
-    } else {
-	d += n, s += n;
-	while (n--)
-	    *--d = *--s;
-    }
-    return dest;
+	const unsigned char *s = src;
+	unsigned char *d = dest;
+
+	if (d <= s) {
+		while (n--)
+			*d++ = *s++;
+	} else {
+		d += n, s += n;
+		while (n--)
+			*--d = *--s;
+	}
+	return dest;
  }
 
  void *memchr(const void *s, int c, size_t n)
  {
-    const unsigned char *str = s, chr = (unsigned char)c;
+	const unsigned char *str = s, chr = (unsigned char)c;
 
-    while (n--)
-	if (*str++ == chr)
-	    return (void *)(str - 1);
-    return NULL;
+	while (n--)
+		if (*str++ == chr)
+			return (void *)(str - 1);
+	return NULL;
  }
 
  static int isspace(int c)
  {
-    return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
+	return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
  }
 
  static unsigned long long __strtoll(const char *nptr, char **endptr,
-                                    int base, bool is_signed,
-                                    bool is_longlong) {
-    unsigned long long ull = 0;
-    const char *s = nptr;
-    int neg, c;
-
-    assert(base == 0 || (base >= 2 && base <= 36));
-
-    while (isspace(*s))
-        s++;
-
-    if (*s == '-') {
-        neg = 1;
-        s++;
-    } else {
-        neg = 0;
-        if (*s == '+')
-            s++;
-    }
-
-    if (base == 0 || base == 16) {
-        if (*s == '0') {
-            s++;
-            if (*s == 'x' || *s == 'X') {
-                 s++;
-                 base = 16;
-            } else if (base == 0)
-                 base = 8;
-        } else if (base == 0)
-            base = 10;
-    }
-
-    while (*s) {
-        if (*s >= '0' && *s < '0' + base && *s <= '9')
-            c = *s - '0';
-        else if (*s >= 'a' && *s < 'a' + base - 10)
-            c = *s - 'a' + 10;
-        else if (*s >= 'A' && *s < 'A' + base - 10)
-            c = *s - 'A' + 10;
-        else
-            break;
-
-        if (!is_longlong) {
-            if (is_signed) {
-                long sl = (long)ull;
-                assert(!check_mul_overflow(sl, base));
-                assert(!check_add_overflow(sl * base, c));
-            } else {
-                unsigned long ul = (unsigned long)ull;
-                assert(!check_mul_overflow(ul, base));
-                assert(!check_add_overflow(ul * base, c));
-            }
-        } else {
-            if (is_signed) {
-                long long sll = (long long)ull;
-                assert(!check_mul_overflow(sll, base));
-                assert(!check_add_overflow(sll * base, c));
-            } else {
-                assert(!check_mul_overflow(ull, base));
-                assert(!check_add_overflow(ull * base, c));
-            }
-        }
-
-        ull = ull * base + c;
-        s++;
-    }
-
-    if (neg)
-        ull = -ull;
-
-    if (endptr)
-        *endptr = (char *)s;
-
-    return ull;
+				    int base, bool is_signed, bool is_longlong)
+{
+	unsigned long long ull = 0;
+	const char *s = nptr;
+	int neg, c;
+
+	assert(base == 0 || (base >= 2 && base <= 36));
+
+	while (isspace(*s))
+		s++;
+
+	if (*s == '-') {
+		neg = 1;
+		s++;
+	} else {
+		neg = 0;
+		if (*s == '+')
+			s++;
+	}
+
+	if (base == 0 || base == 16) {
+		if (*s == '0') {
+			s++;
+			if (*s == 'x' || *s == 'X') {
+				s++;
+				base = 16;
+			} else if (base == 0)
+				base = 8;
+		} else if (base == 0)
+			base = 10;
+	}
+
+	while (*s) {
+		if (*s >= '0' && *s < '0' + base && *s <= '9')
+			c = *s - '0';
+		else if (*s >= 'a' && *s < 'a' + base - 10)
+			c = *s - 'a' + 10;
+		else if (*s >= 'A' && *s < 'A' + base - 10)
+			c = *s - 'A' + 10;
+		else
+			break;
+
+		if (!is_longlong) {
+			if (is_signed) {
+				long sl = (long)ull;
+				assert(!check_mul_overflow(sl, base));
+				assert(!check_add_overflow(sl * base, c));
+			} else {
+				unsigned long ul = (unsigned long)ull;
+				assert(!check_mul_overflow(ul, base));
+				assert(!check_add_overflow(ul * base, c));
+			}
+		} else {
+			if (is_signed) {
+				long long sll = (long long)ull;
+				assert(!check_mul_overflow(sll, base));
+				assert(!check_add_overflow(sll * base, c));
+			} else {
+				assert(!check_mul_overflow(ull, base));
+				assert(!check_add_overflow(ull * base, c));
+			}
+		}
+
+		ull = ull * base + c;
+		s++;
+	}
+
+	if (neg)
+		ull = -ull;
+
+	if (endptr)
+		*endptr = (char *)s;
+
+	return ull;
  }
 
  long int strtol(const char *nptr, char **endptr, int base)
  {
-    return __strtoll(nptr, endptr, base, true, false);
+	return __strtoll(nptr, endptr, base, true, false);
  }
 
  unsigned long int strtoul(const char *nptr, char **endptr, int base)
  {
-    return __strtoll(nptr, endptr, base, false, false);
+	return __strtoll(nptr, endptr, base, false, false);
  }
 
  long long int strtoll(const char *nptr, char **endptr, int base)
  {
-    return __strtoll(nptr, endptr, base, true, true);
+	return __strtoll(nptr, endptr, base, true, true);
  }
 
  unsigned long long int strtoull(const char *nptr, char **endptr, int base)
  {
-    return __strtoll(nptr, endptr, base, false, true);
+	return __strtoll(nptr, endptr, base, false, true);
  }
 
  long atol(const char *ptr)
  {
-    return strtol(ptr, NULL, 10);
+	return strtol(ptr, NULL, 10);
  }
 
  extern char **environ;
 
  char *getenv(const char *name)
  {
-    char **envp = environ, *delim;
-    int len;
-
-    while (*envp) {
-        delim = strchr(*envp, '=');
-        assert(delim);
-        len = delim - *envp;
-        if (memcmp(name, *envp, len) == 0 && !name[len])
-            return delim + 1;
-        ++envp;
-    }
-    return NULL;
+	char **envp = environ, *delim;
+	int len;
+
+	while (*envp) {
+		delim = strchr(*envp, '=');
+		assert(delim);
+		len = delim - *envp;
+		if (memcmp(name, *envp, len) == 0 && !name[len])
+			return delim + 1;
+		++envp;
+	}
+	return NULL;
  }
 
  /* Very simple glob matching. Allows '*' at beginning and end of pattern. */
#3 lore raw

PATCH 2/2 lib: Add ctype.h and collect is* functions

In reply to Andrew Jones

We've been slowly adding ctype functions to different files without even exporting them. Let's change that.

---
 lib/argv.c   |  7 ++-----
 lib/ctype.h  | 40 ++++++++++++++++++++++++++++++++++++++++
 lib/string.c |  6 +-----
 3 files changed, 43 insertions(+), 10 deletions(-)
 create mode 100644 lib/ctype.h
lib/argv.c +2 -5
index 0312d74011d3..951b176ae8b1 100644
@@ -6,6 +6,7 @@
  */
 
 #include "libcflat.h"
+#include "ctype.h"
 #include "argv.h"
 #include "auxinfo.h"
 
@@ -19,10 +20,6 @@ char **environ = __environ;
 static char args_copy[1000];
 static char *copy_ptr = args_copy;
 
-#define isblank(c) ((c) == ' ' || (c) == '\t')
-#define isalpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z') || (c) == '_')
-#define isalnum(c) (isalpha(c) || ((c) >= '0' && (c) <= '9'))
-
 static const char *skip_blanks(const char *p)
 {
 	while (isblank(*p))
@@ -92,7 +89,7 @@ static char *env_next(char *env)
 	if (!*env)
 		return env;
 
-	if (isalpha(*env)) {
+	if (isalpha(*env) || *env == '_') {
 		bool invalid = false;
 
 		p = env + 1;
lib/ctype.h new file +40 -0
new file mode 100644
index 000000000000..ce787a60cdf3
@@ -0,0 +1,40 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+#ifndef _CTYPE_H_
+#define _CTYPE_H_
+
+static inline int isblank(int c)
+{
+	return c == ' ' || c == '\t';
+}
+
+static inline int islower(int c)
+{
+	return c >= 'a' && c <= 'z';
+}
+
+static inline int isupper(int c)
+{
+	return c >= 'A' && c <= 'Z';
+}
+
+static inline int isalpha(int c) 
+{
+	return isupper(c) || islower(c);
+}
+
+static inline int isdigit(int c)
+{
+	return c >= '0' && c <= '9';
+}
+
+static inline int isalnum(int c)
+{
+	return isalpha(c) || isdigit(c);
+}
+
+static inline int isspace(int c)
+{
+        return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
+}
+
+#endif /* _CTYPE_H_ */
lib/string.c +1 -5
index a3a8f3b1ce0b..6d8a6380db92 100644
@@ -6,6 +6,7 @@
  */
 
 #include "libcflat.h"
+#include "ctype.h"
 #include "stdlib.h"
 #include "linux/compiler.h"
 
@@ -163,11 +164,6 @@ void *memchr(const void *s, int c, size_t n)
 	return NULL;
 }
 
-static int isspace(int c)
-{
-	return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
-}
-
 static unsigned long long __strtoll(const char *nptr, char **endptr,
 				    int base, bool is_signed, bool is_longlong)
 {
Signature · 1 line
2.34.3
Reviewed-by on v1 2/2
#4 lore raw

Re: [PATCH kvm-unit-tests 2/2] lib: Add ctype.h and collect is* functions

Quoted 59 lines · Andrew Jones

We've been slowly adding ctype functions to different files without even exporting them. Let's change that.

---
  lib/argv.c   |  7 ++-----
  lib/ctype.h  | 40 ++++++++++++++++++++++++++++++++++++++++
  lib/string.c |  6 +-----
  3 files changed, 43 insertions(+), 10 deletions(-)

create mode 100644 lib/ctype.h

lib/argv.c +2 -5
index 0312d74011d3..951b176ae8b1 100644
@@ -6,6 +6,7 @@
   */
 
  #include "libcflat.h"
+#include "ctype.h"
  #include "argv.h"
  #include "auxinfo.h"
 
@@ -19,10 +20,6 @@ char **environ = __environ;
  static char args_copy[1000];
  static char *copy_ptr = args_copy;
 
-#define isblank(c) ((c) == ' ' || (c) == '\t')
-#define isalpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z') || (c) == '_')
-#define isalnum(c) (isalpha(c) || ((c) >= '0' && (c) <= '9'))
-
  static const char *skip_blanks(const char *p)
  {
      while (isblank(*p))
@@ -92,7 +89,7 @@ static char *env_next(char *env)
      if (!*env)
              return env;
 
-     if (isalpha(*env)) {
+     if (isalpha(*env) || *env == '_') {
              bool invalid = false;
 
              p = env + 1;
lib/ctype.h new file +10 -0
new file mode 100644
index 000000000000..ce787a60cdf3
@@ -0,0 +1,40 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+#ifndef _CTYPE_H_
+#define _CTYPE_H_
+
+static inline int isblank(int c)
+{
+     return c == ' ' || c == '\t';
+}
+
+static inline int islower(int c)

lib/ctype.h line 20

Quoted 10 lines
lib/ctype.h new file +10 -0
+{
+     return c >= 'a' && c <= 'z';
+}
+
+static inline int isupper(int c)
+{
+     return c >= 'A' && c <= 'Z';
+}
+
+static inline int isalpha(int c)

minor nit: I think there is a trailing whitespace in the line above, otherwise:

Thanks,

Nikos

Quoted 34 lines
lib/ctype.h new file +20 -0
+{
+     return isupper(c) || islower(c);
+}
+
+static inline int isdigit(int c)
+{
+     return c >= '0' && c <= '9';
+}
+
+static inline int isalnum(int c)
+{
+     return isalpha(c) || isdigit(c);
+}
+
+static inline int isspace(int c)
+{
+        return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
+}
+
+#endif /* _CTYPE_H_ */
lib/string.c +1 -0
index a3a8f3b1ce0b..6d8a6380db92 100644
@@ -6,6 +6,7 @@
   */
 
  #include "libcflat.h"
+#include "ctype.h"
  #include "stdlib.h"
  #include "linux/compiler.h"
 
@@ -163,11 +164,6 @@ void *memchr(const void *s, int c, size_t n)
      return NULL;

lib/string.c void *memchr(const void *s, int c, size_t n) · line 169

Quoted 10 lines
lib/string.c +0 -5
  }
 
-static int isspace(int c)
-{
-     return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f';
-}
-
  static unsigned long long __strtoll(const char *nptr, char **endptr,
                                  int base, bool is_signed, bool is_longlong)
  {

IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you.

#5 lore raw

Re: [PATCH kvm-unit-tests 2/2] lib: Add ctype.h and collect is* functions

Quoted 4 lines · Nikos Nikoleris

Review

Quoted 2 lines
(quoted diff) +2 -0
+
+static inline int isalpha(int c)

minor nit: I think there is a trailing whitespace in the line above,

You're right and I've fixed it now.

Quoted 3 lines

otherwise:

Thanks,
drew

#6 lore raw

Re: [PATCH kvm-unit-tests 2/2] lib: Add ctype.h and collect is* functions

In reply to Andrew Jones
Quoted 4 lines · Andrew Jones

We've been slowly adding ctype functions to different files without even exporting them. Let's change that.

I need to send a v2 of this series, because besides the trailing space Nikos points out, I just noticed that I forgot a check for '_' in argv.c.

Thanks,
drew