about summary refs log tree commit diff
path: root/string
diff options
context:
space:
mode:
authorJoseph Myers <joseph@codesourcery.com>2019-02-27 13:55:45 +0000
committerJoseph Myers <joseph@codesourcery.com>2019-02-27 13:55:45 +0000
commitc4f50205e10b066654cf59ecde4fd1c2a674f19e (patch)
treea0f3f40e959a0b0c98d125ed9728ecd6c3d90e4a /string
parent457208b1e9498c1238b7af4387529388df0414c1 (diff)
downloadglibc-c4f50205e10b066654cf59ecde4fd1c2a674f19e.tar.gz
glibc-c4f50205e10b066654cf59ecde4fd1c2a674f19e.tar.xz
glibc-c4f50205e10b066654cf59ecde4fd1c2a674f19e.zip
Add some spaces before '('.
This patch fixes various places where a space should have been present
before '(' in accordance with the GNU Coding Standards.  Most but not
all of the fixes in this patch are for calls to sizeof (but it's not
exhaustive regarding such calls that should be fixed).

Tested for x86_64, and with build-many-glibcs.py.

	* benchtests/bench-strcpy.c (do_test): Use space before '('.
	* benchtests/bench-string.h (cmdline_process_function): Likewise.
	* benchtests/bench-strlen.c (do_test): Likewise.
	(test_main): Likewise.
	* catgets/gencat.c (read_old): Likewise.
	* elf/cache.c (load_aux_cache): Likewise.
	* iconvdata/bug-iconv8.c (do_test): Likewise.
	* math/test-tgmath-ret.c (do_test): Likewise.
	* nis/nis_call.c (rec_dirsearch): Likewise.
	* nis/nis_findserv.c (__nis_findfastest_with_timeout): Likewise.
	* nptl/tst-audit-threads.c (do_test): Likewise.
	* nptl/tst-cancel4-common.h (set_socket_buffer): Likewise.
	* nss/nss_test1.c (init): Likewise.
	* nss/test-netdb.c (test_hosts): Likewise.
	* posix/execvpe.c (maybe_script_execute): Likewise.
	* stdio-common/tst-fmemopen4.c (do_test): Likewise.
	* stdio-common/tst-printf.c (do_test): Likewise.
	* stdio-common/vfscanf-internal.c (__vfscanf_internal): Likewise.
	* stdlib/fmtmsg.c (NKEYWORDS): Likewise.
	* stdlib/qsort.c (STACK_SIZE): Likewise.
	* stdlib/test-canon.c (do_test): Likewise.
	* stdlib/tst-swapcontext1.c (do_test): Likewise.
	* string/memcmp.c (OPSIZ): Likewise.
	* string/test-strcpy.c (do_test): Likewise.
	(do_random_tests): Likewise.
	* string/test-strlen.c (do_test): Likewise.
	(test_main): Likewise.
	* string/test-strrchr.c (do_test): Likewise.
	(do_random_tests): Likewise.
	* string/tester.c (test_memrchr): Likewise.
	(test_memchr): Likewise.
	* sysdeps/generic/memcopy.h (OPSIZ): Likewise.
	* sysdeps/generic/unwind-dw2.c (execute_stack_op): Likewise.
	* sysdeps/generic/unwind-pe.h (read_sleb128): Likewise.
	(read_encoded_value_with_base): Likewise.
	* sysdeps/hppa/dl-machine.h (elf_machine_runtime_setup): Likewise.
	* sysdeps/hppa/fpu/feupdateenv.c (__feupdateenv): Likewise.
	* sysdeps/ia64/fpu/sfp-machine.h (TI_BITS): Likewise.
	* sysdeps/mach/hurd/spawni.c (__spawni): Likewise.
	* sysdeps/posix/spawni.c (maybe_script_execute): Likewise.
	* sysdeps/powerpc/fpu/tst-setcontext-fpscr.c (query_auxv):
	Likewise.
	* sysdeps/unix/sysv/linux/aarch64/bits/procfs.h (ELF_NGREG):
	Likewise.
	* sysdeps/unix/sysv/linux/arm/bits/procfs.h (ELF_NGREG): Likewise.
	* sysdeps/unix/sysv/linux/arm/ioperm.c (init_iosys): Likewise.
	* sysdeps/unix/sysv/linux/csky/bits/procfs.h (ELF_NGREG):
	Likewise.
	* sysdeps/unix/sysv/linux/m68k/bits/procfs.h (ELF_NGREG):
	Likewise.
	* sysdeps/unix/sysv/linux/nios2/bits/procfs.h (ELF_NGREG):
	Likewise.
	* sysdeps/unix/sysv/linux/spawni.c (maybe_script_execute):
	Likewise.
	* sysdeps/unix/sysv/linux/x86/bits/procfs.h (ELF_NGREG): Likewise.
	* sysdeps/unix/sysv/linux/x86/bits/sigcontext.h
	(FP_XSTATE_MAGIC2_SIZE): Likewise.
	* sysdeps/x86/fpu/sfp-machine.h (TI_BITS): Likewise.
	* time/test_time.c (main): Likewise.
Diffstat (limited to 'string')
-rw-r--r--string/memcmp.c2
-rw-r--r--string/test-strcpy.c8
-rw-r--r--string/test-strlen.c12
-rw-r--r--string/test-strrchr.c4
-rw-r--r--string/tester.c12
5 files changed, 19 insertions, 19 deletions
diff --git a/string/memcmp.c b/string/memcmp.c
index 0fbc96ccfa..30da4e8bdc 100644
--- a/string/memcmp.c
+++ b/string/memcmp.c
@@ -47,7 +47,7 @@
    This should normally be the biggest type supported by a single load
    and store.  Must be an unsigned type.  */
 # define op_t	unsigned long int
-# define OPSIZ	(sizeof(op_t))
+# define OPSIZ	(sizeof (op_t))
 
 /* Threshold value for when to enter the unrolled loops.  */
 # define OP_T_THRES	16
diff --git a/string/test-strcpy.c b/string/test-strcpy.c
index 2cb5ac94ef..75220dc131 100644
--- a/string/test-strcpy.c
+++ b/string/test-strcpy.c
@@ -103,11 +103,11 @@ do_test (size_t align1, size_t align2, size_t len, int max_char)
    but in wchar_ts, in bytes it will equal to align * (sizeof (wchar_t))
    len for wcschr here isn't in bytes but it's number of wchar_t symbols.  */
   align1 &= 7;
-  if ((align1 + len) * sizeof(CHAR) >= page_size)
+  if ((align1 + len) * sizeof (CHAR) >= page_size)
     return;
 
   align2 &= 7;
-  if ((align2 + len) * sizeof(CHAR) >= page_size)
+  if ((align2 + len) * sizeof (CHAR) >= page_size)
     return;
 
   s1 = (CHAR *) (buf1) + align1;
@@ -137,9 +137,9 @@ do_random_tests (void)
 	 0 to 63 since some assembly implementations have separate
 	 prolog for alignments more 48. */
 
-      align1 = random () & (63 / sizeof(CHAR));
+      align1 = random () & (63 / sizeof (CHAR));
       if (random () & 1)
-	align2 = random () & (63 / sizeof(CHAR));
+	align2 = random () & (63 / sizeof (CHAR));
       else
 	align2 = align1 + (random () & 24);
       len = random () & 511;
diff --git a/string/test-strlen.c b/string/test-strlen.c
index a474c1086f..2cd2f66205 100644
--- a/string/test-strlen.c
+++ b/string/test-strlen.c
@@ -80,7 +80,7 @@ do_test (size_t align, size_t len)
   size_t i;
 
   align &= 63;
-  if (align + sizeof(CHAR) * len >= page_size)
+  if (align + sizeof (CHAR) * len >= page_size)
     return;
 
   CHAR *buf = (CHAR *) (buf1);
@@ -97,7 +97,7 @@ static void
 do_random_tests (void)
 {
   size_t i, j, n, align, len;
-  CHAR *p = (CHAR *) (buf1 + page_size - 512 * sizeof(CHAR));
+  CHAR *p = (CHAR *) (buf1 + page_size - 512 * sizeof (CHAR));
 
   for (n = 0; n < ITERATIONS; n++)
     {
@@ -148,16 +148,16 @@ test_main (void)
 
   for (i = 1; i < 8; ++i)
   {
-    do_test (sizeof(CHAR) * i, i);
+    do_test (sizeof (CHAR) * i, i);
     do_test (0, i);
   }
 
   for (i = 2; i <= 12; ++i)
     {
       do_test (0, 1 << i);
-      do_test (sizeof(CHAR) * 7, 1 << i);
-      do_test (sizeof(CHAR) * i, 1 << i);
-      do_test (sizeof(CHAR) * i, (size_t)((1 << i) / 1.5));
+      do_test (sizeof (CHAR) * 7, 1 << i);
+      do_test (sizeof (CHAR) * i, 1 << i);
+      do_test (sizeof (CHAR) * i, (size_t)((1 << i) / 1.5));
     }
 
   do_random_tests ();
diff --git a/string/test-strrchr.c b/string/test-strrchr.c
index bdf70b11e8..b0286d49ae 100644
--- a/string/test-strrchr.c
+++ b/string/test-strrchr.c
@@ -86,7 +86,7 @@ do_test (size_t align, size_t pos, size_t len, int seek_char, int max_char)
   CHAR *buf = (CHAR *) buf1;
 
   align &= 7;
-  if ( (align + len) * sizeof(CHAR) >= page_size)
+  if ( (align + len) * sizeof (CHAR) >= page_size)
     return;
 
   for (i = 0; i < len; ++i)
@@ -125,7 +125,7 @@ do_random_tests (void)
 
   for (n = 0; n < ITERATIONS; n++)
     {
-      align = random () & (63 / sizeof(CHAR));
+      align = random () & (63 / sizeof (CHAR));
       /* For wcsrchr: align here means align not in bytes, but in wchar_ts,
 	 in bytes it will equal to align * (sizeof (wchar_t)).
 	 For strrchr we need to check all alignments from 0 to 63 since
diff --git a/string/tester.c b/string/tester.c
index d2a85d572a..bfc9ad0c01 100644
--- a/string/tester.c
+++ b/string/tester.c
@@ -811,11 +811,11 @@ test_memrchr (void)
      bugs due to unrolled loops (assuming unrolling is limited to no
      more than 128 byte chunks: */
   {
-    char buf[128 + sizeof(long)];
+    char buf[128 + sizeof (long)];
     long align, len, i, pos, n = 9;
 
-    for (align = 0; align < (long) sizeof(long); ++align) {
-      for (len = 0; len < (long) (sizeof(buf) - align); ++len) {
+    for (align = 0; align < (long) sizeof (long); ++align) {
+      for (len = 0; len < (long) (sizeof (buf) - align); ++len) {
 	for (i = 0; i < len; ++i)
 	  buf[align + i] = 'x';		/* don't depend on memset... */
 
@@ -1230,11 +1230,11 @@ test_memchr (void)
      bugs due to unrolled loops (assuming unrolling is limited to no
      more than 128 byte chunks: */
   {
-    char buf[128 + sizeof(long)];
+    char buf[128 + sizeof (long)];
     long align, len, i, pos;
 
-    for (align = 0; align < (long) sizeof(long); ++align) {
-      for (len = 0; len < (long) (sizeof(buf) - align); ++len) {
+    for (align = 0; align < (long) sizeof (long); ++align) {
+      for (len = 0; len < (long) (sizeof (buf) - align); ++len) {
 	for (i = 0; i < len; ++i) {
 	  buf[align + i] = 'x';		/* don't depend on memset... */
 	}