- Fix more style(9)-related issues (copyright header, spaces after function

  names, unnecessary casts)
- Change type of boolean variable from char to bool

Suggested by:	jhb, zont, jmallett
Reviewed by:	cognet
Approved by:	cognet

2 files changed, 126 insertions, 127 deletions

diff --git a/lib/libc/stdio/fmemopen.c b/lib/libc/stdio/fmemopen.c
index dec2c86..581a91e 100644
--- a/lib/libc/stdio/fmemopen.c
+++ b/lib/libc/stdio/fmemopen.c
@@ -1,32 +1,33 @@
 /*-
-Copyright (C) 2013 Pietro Cerutti <gahr@FreeBSD.org>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-*/
+ * Copyright (C) 2013 Pietro Cerutti <gahr@FreeBSD.org>
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <fcntl.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -36,36 +37,36 @@ __FBSDID("$FreeBSD$");
 struct fmemopen_cookie
 {
 	char	*buf;	/* pointer to the memory region */
-	char	 own;	/* did we allocate the buffer ourselves? */
+	bool	 own;	/* did we allocate the buffer ourselves? */
 	char     bin;   /* is this a binary buffer? */
 	size_t	 size;	/* buffer length in bytes */
 	size_t	 len;	/* data length in bytes */
 	size_t	 off;	/* current offset into the buffer */
 };
 
-static int	fmemopen_read  (void *cookie, char *buf, int nbytes);
-static int	fmemopen_write (void *cookie, const char *buf, int nbytes);
-static fpos_t	fmemopen_seek  (void *cookie, fpos_t offset, int whence);
-static int	fmemopen_close (void *cookie);
+static int	fmemopen_read(void *cookie, char *buf, int nbytes);
+static int	fmemopen_write(void *cookie, const char *buf, int nbytes);
+static fpos_t	fmemopen_seek(void *cookie, fpos_t offset, int whence);
+static int	fmemopen_close(void *cookie);
 
 FILE *
-fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
+fmemopen(void * __restrict buf, size_t size, const char * __restrict mode)
 {
 	struct fmemopen_cookie *ck;
 	FILE *f;
 	int flags, rc;
 
-	/* 
+	/*
 	 * Retrieve the flags as used by open(2) from the mode argument, and
 	 * validate them.
-	 * */
-	rc = __sflags (mode, &flags);
+	 */
+	rc = __sflags(mode, &flags);
 	if (rc == 0) {
 		errno = EINVAL;
 		return (NULL);
 	}
 
-	/* 
+	/*
 	 * There's no point in requiring an automatically allocated buffer
 	 * in write-only mode.
 	 */
@@ -74,8 +75,7 @@ fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
 		return (NULL);
 	}
 	
-	/* Allocate a cookie. */
-	ck = malloc (sizeof (struct fmemopen_cookie));
+	ck = malloc(sizeof(struct fmemopen_cookie));
 	if (ck == NULL) {
 		return (NULL);
 	}
@@ -86,9 +86,9 @@ fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
 	/* Check whether we have to allocate the buffer ourselves. */
 	ck->own = ((ck->buf = buf) == NULL);
 	if (ck->own) {
-		ck->buf = malloc (size);
+		ck->buf = malloc(size);
 		if (ck->buf == NULL) {
-			free (ck);
+			free(ck);
 			return (NULL);
 		}
 	}
@@ -107,22 +107,22 @@ fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
 	/*
 	 * The size of the current buffer contents is set depending on the
 	 * mode:
-	 *
+	 * 
 	 * for append (text-mode), the position of the first NULL byte, or the
 	 * size of the buffer if none is found
 	 *
 	 * for append (binary-mode), the size of the buffer
-	 *
+	 * 
 	 * for read, the size of the buffer
-	 *
+	 * 
 	 * for write, 0
 	 */
 	switch (mode[0]) {
 	case 'a':
 		if (ck->bin) {
-			/* 
-			 * This isn't useful, since the buffer isn't
-			 * allowed to grow.
+			/*
+			 * This isn't useful, since the buffer isn't allowed
+			 * to grow.
 			 */
 			ck->off = ck->len = size;
 		} else
@@ -136,16 +136,15 @@ fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
 		break;
 	}
 
-	/* Actuall wrapper. */
-	f = funopen ((void *)ck,
+	f = funopen(ck,
 	    flags & O_WRONLY ? NULL : fmemopen_read, 
 	    flags & O_RDONLY ? NULL : fmemopen_write,
 	    fmemopen_seek, fmemopen_close);
 
 	if (f == NULL) {
 		if (ck->own)
-			free (ck->buf);
-		free (ck);
+			free(ck->buf);
+		free(ck);
 		return (NULL);
 	}
 
@@ -153,13 +152,13 @@ fmemopen (void * __restrict buf, size_t size, const char * __restrict mode)
 	 * Turn off buffering, so a write past the end of the buffer
 	 * correctly returns a short object count.
 	 */
-	setvbuf (f, (char *) NULL, _IONBF, 0);
+	setvbuf(f, NULL, _IONBF, 0);
 
 	return (f);
 }
 
 static int
-fmemopen_read (void *cookie, char *buf, int nbytes)
+fmemopen_read(void *cookie, char *buf, int nbytes)
 {
 	struct fmemopen_cookie *ck = cookie;
 
@@ -169,7 +168,7 @@ fmemopen_read (void *cookie, char *buf, int nbytes)
 	if (nbytes == 0)
 		return (0);
 
-	memcpy (buf, ck->buf + ck->off, nbytes);
+	memcpy(buf, ck->buf + ck->off, nbytes);
 
 	ck->off += nbytes;
 
@@ -177,7 +176,7 @@ fmemopen_read (void *cookie, char *buf, int nbytes)
 }
 
 static int
-fmemopen_write (void *cookie, const char *buf, int nbytes)
+fmemopen_write(void *cookie, const char *buf, int nbytes)
 {
 	struct fmemopen_cookie *ck = cookie;
 
@@ -187,7 +186,7 @@ fmemopen_write (void *cookie, const char *buf, int nbytes)
 	if (nbytes == 0)
 		return (0);
 
-	memcpy (ck->buf + ck->off, buf, nbytes);
+	memcpy(ck->buf + ck->off, buf, nbytes);
 
 	ck->off += nbytes;
 
@@ -207,7 +206,7 @@ fmemopen_write (void *cookie, const char *buf, int nbytes)
 }
 
 static fpos_t
-fmemopen_seek (void *cookie, fpos_t offset, int whence)
+fmemopen_seek(void *cookie, fpos_t offset, int whence)
 {
 	struct fmemopen_cookie *ck = cookie;
 
@@ -246,14 +245,14 @@ fmemopen_seek (void *cookie, fpos_t offset, int whence)
 }
 
 static int
-fmemopen_close (void *cookie)
+fmemopen_close(void *cookie)
 {
 	struct fmemopen_cookie *ck = cookie;
 
 	if (ck->own)
-		free (ck->buf);
+		free(ck->buf);
 
-	free (ck);
+	free(ck);
 
 	return (0);
 }
diff --git a/tools/regression/lib/libc/stdio/test-fmemopen.c b/tools/regression/lib/libc/stdio/test-fmemopen.c
index ca5f1a0..2788279 100644
--- a/tools/regression/lib/libc/stdio/test-fmemopen.c
+++ b/tools/regression/lib/libc/stdio/test-fmemopen.c
@@ -38,7 +38,7 @@ __FBSDID("$FreeBSD$");
 #include <strings.h>
 
 void
-test_preexisting ()
+test_preexisting()
 {
 	/* 
 	 * Use a pre-existing buffer.
@@ -54,56 +54,56 @@ test_preexisting ()
 	int rc;
 
 	/* Open a FILE * using fmemopen. */
-	fp = fmemopen (buf, sizeof(buf), "w");
-	assert (fp != NULL);
+	fp = fmemopen(buf, sizeof(buf), "w");
+	assert(fp != NULL);
 
 	/* Write to the buffer. */
-	nofw = fwrite (str, 1, sizeof(str), fp);
-	assert (nofw == sizeof(str));
+	nofw = fwrite(str, 1, sizeof(str), fp);
+	assert(nofw == sizeof(str));
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 
 	/* Re-open the FILE * to read back the data. */
-	fp = fmemopen (buf, sizeof(buf), "r");
-	assert (fp != NULL);
+	fp = fmemopen(buf, sizeof(buf), "r");
+	assert(fp != NULL);
 
 	/* Read from the buffer. */
-	bzero (buf2, sizeof(buf2));
-	nofr = fread (buf2, 1, sizeof(buf2), fp);
-	assert (nofr == sizeof(buf2));
+	bzero(buf2, sizeof(buf2));
+	nofr = fread(buf2, 1, sizeof(buf2), fp);
+	assert(nofr == sizeof(buf2));
 
 	/* 
 	 * Since a write on a FILE * retrieved by fmemopen
 	 * will add a '\0' (if there's space), we can check
 	 * the strings for equality.
 	 */
-	assert (strcmp(str, buf2) == 0);
+	assert(strcmp(str, buf2) == 0);
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 
 	/* Now open a FILE * on the first 4 bytes of the string. */
-	fp = fmemopen (str, 4, "w");
-	assert (fp != NULL);
+	fp = fmemopen(str, 4, "w");
+	assert(fp != NULL);
 
 	/*
 	 * Try to write more bytes than we shoud, we'll get a short count (4).
 	 */
-	nofw = fwrite (str2, 1, sizeof(str2), fp);
-	assert (nofw == 4);
+	nofw = fwrite(str2, 1, sizeof(str2), fp);
+	assert(nofw == 4);
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
+	rc = fclose(fp);
 
 	/* Check that the string was not modified after the first 4 bytes. */
-	assert (strcmp (str, str3) == 0);
+	assert(strcmp(str, str3) == 0);
 }
 
 void
-test_autoalloc ()
+test_autoalloc()
 {
 	/* 
 	 * Let fmemopen allocate the buffer.
@@ -116,32 +116,32 @@ test_autoalloc ()
 	int rc;
 
 	/* Open a FILE * using fmemopen. */
-	fp = fmemopen (NULL, 512, "w+");
-	assert (fp != NULL);
+	fp = fmemopen(NULL, 512, "w+");
+	assert(fp != NULL);
 
 	/* fill the buffer */
 	for (i = 0; i < 512; i++) {
-		nofw = fwrite ("a", 1, 1, fp);
-		assert (nofw == 1);
+		nofw = fwrite("a", 1, 1, fp);
+		assert(nofw == 1);
 	}
 
 	/* Get the current position into the stream. */
-	pos = ftell (fp);
-	assert (pos == 512);
+	pos = ftell(fp);
+	assert(pos == 512);
 
 	/* 
 	 * Try to write past the end, we should get a short object count (0)
 	 */
-	nofw = fwrite ("a", 1, 1, fp);
-	assert (nofw == 0);
+	nofw = fwrite("a", 1, 1, fp);
+	assert(nofw == 0);
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 }
 
 void
-test_data_length ()
+test_data_length()
 {
 	/*
 	 * Here we test that a read operation doesn't go past the end of the
@@ -158,57 +158,57 @@ test_data_length ()
 	int rc;
 
 	/* Open a FILE * for updating our buffer. */
-	fp = fmemopen (buf, sizeof(buf), "w+");
-	assert (fp != NULL);
+	fp = fmemopen(buf, sizeof(buf), "w+");
+	assert(fp != NULL);
 
 	/* Write our string into the buffer. */
-	nofw = fwrite (str, 1, sizeof(str), fp);
-	assert (nofw == sizeof(str));
+	nofw = fwrite(str, 1, sizeof(str), fp);
+	assert(nofw == sizeof(str));
 
 	/* 
 	 * Now seek to the end and check that ftell
 	 * gives us sizeof(str).
 	 */
-	rc = fseek (fp, 0, SEEK_END);
-	assert (rc == 0);
-	pos = ftell (fp);
-	assert (pos == sizeof(str));
+	rc = fseek(fp, 0, SEEK_END);
+	assert(rc == 0);
+	pos = ftell(fp);
+	assert(pos == sizeof(str));
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 
 	/* Reopen the buffer for appending. */
-	fp = fmemopen (buf, sizeof(buf), "a+");
-	assert (fp != NULL);
+	fp = fmemopen(buf, sizeof(buf), "a+");
+	assert(fp != NULL);
 
 	/* We should now be writing after the first string. */
-	nofw = fwrite (str2, 1, sizeof(str2), fp);
-	assert (nofw == sizeof(str2));
+	nofw = fwrite(str2, 1, sizeof(str2), fp);
+	assert(nofw == sizeof(str2));
 
 	/* Rewind the FILE *. */
-	rc = fseek (fp, 0, SEEK_SET);
-	assert (rc == 0);
+	rc = fseek(fp, 0, SEEK_SET);
+	assert(rc == 0);
 
 	/* Make sure we're at the beginning. */
-	pos = ftell (fp);
-	assert (pos == 0);
+	pos = ftell(fp);
+	assert(pos == 0);
 
 	/* Read the whole buffer. */
-	nofr = fread (str3, 1, sizeof(buf), fp);
-	assert (nofr == sizeof(str3));
+	nofr = fread(str3, 1, sizeof(buf), fp);
+	assert(nofr == sizeof(str3));
 
 	/* Make sure the two strings are there. */
-	assert (strncmp (str3, str, sizeof(str) - 1) == 0);
-	assert (strncmp (str3 + sizeof(str) - 1, str2, sizeof(str2)) == 0);
+	assert(strncmp(str3, str, sizeof(str) - 1) == 0);
+	assert(strncmp(str3 + sizeof(str) - 1, str2, sizeof(str2)) == 0);
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 }
 
 void
-test_binary ()
+test_binary()
 {
 	/*
 	 * Make sure that NULL bytes are never appended when opening a buffer
@@ -222,31 +222,31 @@ test_binary ()
 	int rc, i;
 
 	/* Pre-fill the buffer. */
-	memset (buf, 'A', sizeof(buf));
+	memset(buf, 'A', sizeof(buf));
 
 	/* Open a FILE * in binary mode. */
-	fp = fmemopen (buf, sizeof(buf), "w+b");
-	assert (fp != NULL);
+	fp = fmemopen(buf, sizeof(buf), "w+b");
+	assert(fp != NULL);
 
 	/* Write some data into it. */
-	nofw = fwrite (str, 1, strlen(str), fp);
-	assert (nofw == strlen(str));
+	nofw = fwrite(str, 1, strlen(str), fp);
+	assert(nofw == strlen(str));
 
 	/* Make sure that the buffer doesn't contain any NULL bytes. */
 	for (i = 0; i < sizeof(buf); i++)
-		assert (buf[i] != '\0');
+		assert(buf[i] != '\0');
 
 	/* Close the FILE *. */
-	rc = fclose (fp);
-	assert (rc == 0);
+	rc = fclose(fp);
+	assert(rc == 0);
 }
 
 int
-main (void)
+main(void)
 {
-	test_autoalloc   ();
-	test_preexisting ();
-	test_data_length ();
-	test_binary      ();
+	test_autoalloc();
+	test_preexisting();
+	test_data_length();
+	test_binary();
 	return (0);
 }