--- rxvt-unicode/src/strings.C	2004/01/31 00:20:21	1.3
+++ rxvt-unicode/src/strings.C	2004/02/01 01:34:41	1.4
@@ -1,7 +1,7 @@
 /*--------------------------------*-C-*---------------------------------*
  * File:	strings.c
  *----------------------------------------------------------------------*
- * $Id: strings.C,v 1.3 2004/01/31 00:20:21 pcg Exp $
+ * $Id: strings.C,v 1.4 2004/02/01 01:34:41 pcg Exp $
  *
  * All portions of code are copyright by their respective author/s.
  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
@@ -34,160 +34,165 @@
 int
 strcasecmp(const char *s1, const char *s2)
 {
-    for ( ; tolower(*s1) == tolower(*s2); s1++, s2++)
-	if (!*s1)
-	    return 0;
-    return (int)(tolower(*s1) - tolower(*s2));
+  for ( ; tolower(*s1) == tolower(*s2); s1++, s2++)
+    if (!*s1)
+      return 0;
+  return (int)(tolower(*s1) - tolower(*s2));
 }
 
 int
 strncasecmp(const char *s1, const char *s2, size_t n)
 {
-    for ( ; n-- && (tolower(*s1) == tolower(*s2)); s1++, s2++)
-	if (!*s1)
-	    return 0;
-    if (n == 0)
-	return 0;
-    return (int)(tolower(*s1) - tolower(*s2));
+  for ( ; n-- && (tolower(*s1) == tolower(*s2)); s1++, s2++)
+    if (!*s1)
+      return 0;
+  if (n == 0)
+    return 0;
+  return (int)(tolower(*s1) - tolower(*s2));
 }
 
 char           *
 strcpy(char *d, const char *s)
 {
-    char          *r = d;
+  char          *r = d;
 
-    for ( ; (*r++ = *s++) != '\0'; ) ;
-    return d;
+  for ( ; (*r++ = *s++) != '\0'; ) ;
+  return d;
 }
 
 char           *
 strncpy(char *d, const char *s, size_t len)
 {
-    char          *r = d;
+  char          *r = d;
 
-    if (len)
-	for ( ; len; len--)
-	    if ((*r++ = *s++) == '\0') {
-		for ( ; --len; )
-		    *r++ = '\0';
-		break;
-	    }
-    return d;
+  if (len)
+    for ( ; len; len--)
+      if ((*r++ = *s++) == '\0')
+        {
+          for ( ; --len; )
+            *r++ = '\0';
+          break;
+        }
+  return d;
 }
 
 int
 strcmp(const char *s1, const char *s2)
 {
-    for ( ; (*s1 == *s2++); )
-	if (*s1++ == '\0')
-	    return 0;
-    return (int) ((unsigned char) *s1 - (unsigned char) *--s2);
+  for ( ; (*s1 == *s2++); )
+    if (*s1++ == '\0')
+      return 0;
+  return (int) ((unsigned char) *s1 - (unsigned char) *--s2);
 }
 
 int
 strncmp(const char *s1, const char *s2, size_t len)
 {
-    if (len) {
-	for ( ; len-- && (*s1++ == *s2++); ) ;
-	if (++len)
-	    return (int) ((unsigned char) *--s1 - (unsigned char) *--s2);
+  if (len)
+    {
+      for ( ; len-- && (*s1++ == *s2++); ) ;
+      if (++len)
+        return (int) ((unsigned char) *--s1 - (unsigned char) *--s2);
     }
-    return 0;
+  return 0;
 }
 
 char           *
 strcat(char *s1, const char *s2)
 {
-    char           *r = s1;
+  char           *r = s1;
 
-    if (*r != '\0')
-	for ( ; *++r != '\0'; ) ;
-    for ( ; (*r++ = *s2++) != '\0'; ) ;
+  if (*r != '\0')
+    for ( ; *++r != '\0'; ) ;
+  for ( ; (*r++ = *s2++) != '\0'; ) ;
 
-    return s1;
+  return s1;
 }
 
 char           *
 strncat(char *s1, const char *s2, size_t len)
 {
-    char           *r = s1;
+  char           *r = s1;
 
-    if (*r != '\0')
-	for ( ; *++r != '\0'; ) ;
-    for ( ; len-- && ((*r++ = *s2++) != '\0'); ) ;
-    *r = '\0';
+  if (*r != '\0')
+    for ( ; *++r != '\0'; ) ;
+  for ( ; len-- && ((*r++ = *s2++) != '\0'); ) ;
+  *r = '\0';
 
-    return s1;
+  return s1;
 }
 
 size_t
 strlen(const char *s)
 {
-    size_t         len = 0;
+  size_t         len = 0;
 
-    for ( ; *s++ != '\0'; len++) ;
-    return len;
+  for ( ; *s++ != '\0'; len++) ;
+  return len;
 }
 
 char           *
 strdup(const char *s)
 {
-    size_t         len = STRLEN(s) + 1;
-    char          *c;
+  size_t         len = STRLEN(s) + 1;
+  char          *c;
 
-    if ((c = malloc(len)) != NULL)
-	MEMCPY(c, s, len);
-    return c;
+  if ((c = malloc(len)) != NULL)
+    MEMCPY(c, s, len);
+  return c;
 }
 
 char           *
 index(const char *s, int c)
 {
-    return STRCHR(s, c);
+  return STRCHR(s, c);
 }
 
 char           *
 strchr(const char *s, int c)
 {
-    char          *p = NULL;
+  char          *p = NULL;
 
-    for (;;) {
-	if (*s == (char)c) {
-	    p = (char *)s;
-	    break;
-	}
-	if (*s++ == '\0')
-	    break;
+  for (;;)
+    {
+      if (*s == (char)c)
+        {
+          p = (char *)s;
+          break;
+        }
+      if (*s++ == '\0')
+        break;
     }
-    return p;
+  return p;
 
 }
 
 char           *
 rindex(const char *s, int c)
 {
-    return STRRCHR(s, c);
+  return STRRCHR(s, c);
 }
 
 char           *
 strrchr(const char *s, int c)
 {
-    char          *p = NULL;
+  char          *p = NULL;
 
-    for (;;) {
-	if (*s == (char)c)
-	    p = (char *)s;
-	if (*s++ == '\0')
-	    break;
+  for (;;)
+    {
+      if (*s == (char)c)
+        p = (char *)s;
+      if (*s++ == '\0')
+        break;
     }
-    return p;
+  return p;
 }
 
 void           *
 memcpy(void *s1, const void *s2, size_t len)
 {
-    /* has extra stack and time but less code space */
-    return MEMMOVE(s1, s2, len);
+  /* has extra stack and time but less code space */
+  return MEMMOVE(s1, s2, len);
 }
 
 /*--------------------------------------------------------------------------*
@@ -196,44 +201,50 @@
 void           *
 memmove(void *d, const void *s, size_t len)
 {
-    u_intp_t        i;
-    unsigned char  *dst = (unsigned char *)d;
-    const unsigned char *src = (const unsigned char *)s;
-
-    if (len && d != s) {
-	if ((u_intp_t)d < (u_intp_t)s) {
-	/* forwards */
-	    i = (-(u_intp_t)dst) & (SIZEOF_INT_P - 1);
-	    if (len >= 16 && i == ((-(u_intp_t)src) & (SIZEOF_INT_P - 1))) {
-	    /* speed up since src & dst are offset correctly */
-		len -= (size_t)i;
-		for ( ; i--; )
-		    *dst++ = *src++;
-		for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
-		    *((u_intp_t *)dst)++ = *((const u_intp_t *)src)++;
-		len &= (SIZEOF_INT_P - 1);
-	    }
-	    for ( ; len--; )
-		*dst++ = *src++;
-	} else {
-	/* backwards */
-	    dst += len;
-	    src += len;
-	    i = ((u_intp_t)dst) & (SIZEOF_INT_P - 1);
-	    if (len >= 16 && i == (((u_intp_t)src) & (SIZEOF_INT_P - 1))) {
-	    /* speed up since src & dst are offset correctly */
-		len -= (size_t)i;
-		for ( ; i--; )
-		    *--dst = *--src;
-		for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
-		    *--((u_intp_t *)dst) = *--((const u_intp_t *)src);
-		len &= (SIZEOF_INT_P - 1);
-	    }
-	    for ( ; len--; )
-		*--dst = *--src;
-	}
+  u_intp_t        i;
+  unsigned char  *dst = (unsigned char *)d;
+  const unsigned char *src = (const unsigned char *)s;
+
+  if (len && d != s)
+    {
+      if ((u_intp_t)d < (u_intp_t)s)
+        {
+          /* forwards */
+          i = (-(u_intp_t)dst) & (SIZEOF_INT_P - 1);
+          if (len >= 16 && i == ((-(u_intp_t)src) & (SIZEOF_INT_P - 1)))
+            {
+              /* speed up since src & dst are offset correctly */
+              len -= (size_t)i;
+              for ( ; i--; )
+                *dst++ = *src++;
+              for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
+                *((u_intp_t *)dst)++ = *((const u_intp_t *)src)++;
+              len &= (SIZEOF_INT_P - 1);
+            }
+          for ( ; len--; )
+            *dst++ = *src++;
+        }
+      else
+        {
+          /* backwards */
+          dst += len;
+          src += len;
+          i = ((u_intp_t)dst) & (SIZEOF_INT_P - 1);
+          if (len >= 16 && i == (((u_intp_t)src) & (SIZEOF_INT_P - 1)))
+            {
+              /* speed up since src & dst are offset correctly */
+              len -= (size_t)i;
+              for ( ; i--; )
+                *--dst = *--src;
+              for (i = (u_intp_t)(len / SIZEOF_INT_P); i--; )
+                *--((u_intp_t *)dst) = *--((const u_intp_t *)src);
+              len &= (SIZEOF_INT_P - 1);
+            }
+          for ( ; len--; )
+            *--dst = *--src;
+        }
     }
-    return d;
+  return d;
 }
 
 /*--------------------------------------------------------------------------*
@@ -246,45 +257,48 @@
 void
 bzero(void *b, size_t len)
 {
-    MEMSET(b, 0, len);
+  MEMSET(b, 0, len);
 }
 
 void           *
 memset(void *p, int c1, size_t len)
 {
-    u_intp_t        i, val;
-    unsigned char   c = (unsigned char) c1;
-    unsigned char  *lp = (unsigned char *) p;
-
-    if (len) {
-	if (len >= 16) { /* < 16 probably not worth all the calculations */
-/* write out preceding characters so we align on an integer boundary */
-	    if ((i = ((-(u_intp_t)p) & (SIZEOF_INT_P - 1)))) {
-		len -= (size_t)i;
-		for (; i--;)
-		    *lp++ = c;
-	    }
+  u_intp_t        i, val;
+  unsigned char   c = (unsigned char) c1;
+  unsigned char  *lp = (unsigned char *) p;
+
+  if (len)
+    {
+      if (len >= 16)
+        { /* < 16 probably not worth all the calculations */
+          /* write out preceding characters so we align on an integer boundary */
+          if ((i = ((-(u_intp_t)p) & (SIZEOF_INT_P - 1))))
+            {
+              len -= (size_t)i;
+              for (; i--;)
+                *lp++ = c;
+            }
 
-/* do the fast writing */
-	    val = (c << 8) + c;
+          /* do the fast writing */
+          val = (c << 8) + c;
 #if SIZEOF_INT_P >= 4
-	    val |= (val << 16);
+          val |= (val << 16);
 #endif
 #if SIZEOF_INT_P >= 8
-	    val |= (val << 32);
+          val |= (val << 32);
 #endif
 #if SIZEOF_INT_P == 16
-	    val |= (val << 64);
+          val |= (val << 64);
 #endif
-	    for (i = (u_intp_t)(len / SIZEOF_INT_P); i--;)
-		*((u_intp_t *)lp)++ = val;
-	    len &= (SIZEOF_INT_P - 1);
-	}
-/* write trailing characters */
-	for (; len--;)
-	    *lp++ = c;
+          for (i = (u_intp_t)(len / SIZEOF_INT_P); i--;)
+            *((u_intp_t *)lp)++ = val;
+          len &= (SIZEOF_INT_P - 1);
+        }
+      /* write trailing characters */
+      for (; len--;)
+        *lp++ = c;
     }
-    return p;
+  return p;
 }
 #endif
 /*----------------------- end-of-file (C source) -----------------------*/