15 files changed, 439 insertions, 439 deletions

diff --git a/firmware/common/memchr.c b/firmware/common/memchr.c
index a7ff222a61..26bdb9eea3 100644
--- a/firmware/common/memchr.c
+++ b/firmware/common/memchr.c
@@ -1,28 +1,28 @@
 /*
 FUNCTION
-        <<memchr>>---search for character in memory
+        <<memchr>>---search for character in memory
 
 INDEX
-        memchr
+        memchr
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        void * memchr(const void *<[s1]>, int <[c]>, size_t <[n]>);
+        #include <string.h>
+        void * memchr(const void *<[s1]>, int <[c]>, size_t <[n]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        void * memchr(<[s1]>, <[c]>, <[n]>);
-        void *<[string]>;
-        int *<[c]>;
-        size_t *<[n]>;
+        #include <string.h>
+        void * memchr(<[s1]>, <[c]>, <[n]>);
+        void *<[string]>;
+        int *<[c]>;
+        size_t *<[n]>;
 
 DESCRIPTION
-        This function scans the first <[n]> bytes of the memory pointed
-        to by <[s1]> for the character <[c]> (converted to a char).
+        This function scans the first <[n]> bytes of the memory pointed
+        to by <[s1]> for the character <[c]> (converted to a char).
 
 RETURNS
-        Returns a pointer to the matching byte, or a null pointer if
-        <[c]> does not occur in <[s1]>.
+        Returns a pointer to the matching byte, or a null pointer if
+        <[c]> does not occur in <[s1]>.
 
 PORTABILITY
 <<memchr>> is ANSI C.
@@ -30,7 +30,7 @@ PORTABILITY
 <<memchr>> requires no supporting OS subroutines.
 
 QUICKREF
-        memchr ansi pure
+        memchr ansi pure
 */
 
 #include <string.h>
@@ -59,8 +59,8 @@ QUICKREF
 
 void *
 _DEFUN (memchr, (s1, i, n),
-        _CONST void *s1 _AND
-        int i _AND size_t n)
+        _CONST void *s1 _AND
+        int i _AND size_t n)
 {
   _CONST unsigned char *s = (_CONST unsigned char *)s1;
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
@@ -69,9 +69,9 @@ _DEFUN (memchr, (s1, i, n),
   while (n-- > 0)
     {
       if (*s == c)
-        {
+        {
           return (void *)s;
-        }
+        }
       s++;
     }
 
@@ -89,15 +89,15 @@ _DEFUN (memchr, (s1, i, n),
 
       aligned_addr = (unsigned long*)s;
       while ((!DETECTCHAR (*aligned_addr, mask)) && (n>LBLOCKSIZE))
-        {
+        {
           aligned_addr++;
-          n -= LBLOCKSIZE;
-        }
+          n -= LBLOCKSIZE;
+        }
 
       /* The block of bytes currently pointed to by aligned_addr
          may contain the target character or there may be less than
-         LBLOCKSIZE bytes left to search. We check the last few
-         bytes using the bytewise search.  */
+         LBLOCKSIZE bytes left to search. We check the last few
+         bytes using the bytewise search.  */
 
       s = (unsigned char*)aligned_addr;
     }
@@ -105,9 +105,9 @@ _DEFUN (memchr, (s1, i, n),
   while (n-- > 0)
     {
       if (*s == c)
-        {
+        {
           return (void *)s;
-        }
+        }
       s++;
     }
 
diff --git a/firmware/common/memcmp.c b/firmware/common/memcmp.c
index 4a871fa601..1535fcf5b5 100644
--- a/firmware/common/memcmp.c
+++ b/firmware/common/memcmp.c
@@ -1,31 +1,31 @@
 /*
 FUNCTION
-        <<memcmp>>---compare two memory areas
+        <<memcmp>>---compare two memory areas
 
 INDEX
-        memcmp
+        memcmp
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
+        #include <string.h>
+        int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        int memcmp(<[s1]>, <[s2]>, <[n]>)
-        void *<[s1]>;
-        void *<[s2]>;
-        size_t <[n]>;
+        #include <string.h>
+        int memcmp(<[s1]>, <[s2]>, <[n]>)
+        void *<[s1]>;
+        void *<[s2]>;
+        size_t <[n]>;
 
 DESCRIPTION
-        This function compares not more than <[n]> characters of the
-        object pointed to by <[s1]> with the object pointed to by <[s2]>.
+        This function compares not more than <[n]> characters of the
+        object pointed to by <[s1]> with the object pointed to by <[s2]>.
 
 
 RETURNS
-        The function returns an integer greater than, equal to or
-        less than zero  according to whether the object pointed to by
-        <[s1]> is greater than, equal to or less than the object
-        pointed to by <[s2]>.
+        The function returns an integer greater than, equal to or
+        less than zero  according to whether the object pointed to by
+        <[s1]> is greater than, equal to or less than the object
+        pointed to by <[s2]>.
 
 PORTABILITY
 <<memcmp>> is ANSI C.
@@ -33,7 +33,7 @@ PORTABILITY
 <<memcmp>> requires no supporting OS subroutines.
 
 QUICKREF
-        memcmp ansi pure
+        memcmp ansi pure
 */
 
 #include <string.h>
@@ -51,9 +51,9 @@ QUICKREF
 
 int
 _DEFUN (memcmp, (m1, m2, n),
-        _CONST _PTR m1 _AND
-        _CONST _PTR m2 _AND
-        size_t n)
+        _CONST _PTR m1 _AND
+        _CONST _PTR m2 _AND
+        size_t n)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   unsigned char *s1 = (unsigned char *) m1;
@@ -62,9 +62,9 @@ _DEFUN (memcmp, (m1, m2, n),
   while (n--)
     {
       if (*s1 != *s2)
-        {
-          return *s1 - *s2;
-        }
+        {
+          return *s1 - *s2;
+        }
       s1++;
       s2++;
     }
@@ -87,7 +87,7 @@ _DEFUN (memcmp, (m1, m2, n),
       while (n >= LBLOCKSIZE)
         {
           if (*a1 != *a2) 
-            break;
+            break;
           a1++;
           a2++;
           n -= LBLOCKSIZE;
@@ -102,7 +102,7 @@ _DEFUN (memcmp, (m1, m2, n),
   while (n--)
     {
       if (*s1 != *s2)
-        return *s1 - *s2;
+        return *s1 - *s2;
       s1++;
       s2++;
     }
diff --git a/firmware/common/memcpy.c b/firmware/common/memcpy.c
index b77f27379d..a89ac3c557 100644
--- a/firmware/common/memcpy.c
+++ b/firmware/common/memcpy.c
@@ -30,7 +30,7 @@ PORTABILITY
 
 QUICKREF
         memcpy ansi pure
-        */
+        */
 
 #include "config.h"
 #include <_ansi.h>
@@ -51,15 +51,15 @@ QUICKREF
 
 _PTR
 _DEFUN (memcpy, (dst0, src0, len0),
-        _PTR dst0 _AND
-        _CONST _PTR src0 _AND
-        size_t len0) ICODE_ATTR;
+        _PTR dst0 _AND
+        _CONST _PTR src0 _AND
+        size_t len0) ICODE_ATTR;
 
 _PTR
 _DEFUN (memcpy, (dst0, src0, len0),
-        _PTR dst0 _AND
-        _CONST _PTR src0 _AND
-        size_t len0)
+        _PTR dst0 _AND
+        _CONST _PTR src0 _AND
+        size_t len0)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   char *dst = (char *) dst0;
diff --git a/firmware/common/memmove.c b/firmware/common/memmove.c
index 599cbc9c01..5f423964bb 100644
--- a/firmware/common/memmove.c
+++ b/firmware/common/memmove.c
@@ -1,30 +1,30 @@
 /*
 FUNCTION
-        <<memmove>>---move possibly overlapping memory
+        <<memmove>>---move possibly overlapping memory
 
 INDEX
-        memmove
+        memmove
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        void *memmove(void *<[dst]>, const void *<[src]>, size_t <[length]>);
+        #include <string.h>
+        void *memmove(void *<[dst]>, const void *<[src]>, size_t <[length]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        void *memmove(<[dst]>, <[src]>, <[length]>)
-        void *<[dst]>;
-        void *<[src]>;
-        size_t <[length]>;
+        #include <string.h>
+        void *memmove(<[dst]>, <[src]>, <[length]>)
+        void *<[dst]>;
+        void *<[src]>;
+        size_t <[length]>;
 
 DESCRIPTION
-        This function moves <[length]> characters from the block of
-        memory starting at <<*<[src]>>> to the memory starting at
-        <<*<[dst]>>>. <<memmove>> reproduces the characters correctly
-        at <<*<[dst]>>> even if the two areas overlap.
+        This function moves <[length]> characters from the block of
+        memory starting at <<*<[src]>>> to the memory starting at
+        <<*<[dst]>>>. <<memmove>> reproduces the characters correctly
+        at <<*<[dst]>>> even if the two areas overlap.
 
 
 RETURNS
-        The function returns <[dst]> as passed.
+        The function returns <[dst]> as passed.
 
 PORTABILITY
 <<memmove>> is ANSI C.
@@ -32,7 +32,7 @@ PORTABILITY
 <<memmove>> requires no supporting OS subroutines.
 
 QUICKREF
-        memmove ansi pure
+        memmove ansi pure
 */
 
 #include "config.h"
@@ -54,15 +54,15 @@ QUICKREF
 
 _PTR
 _DEFUN (memmove, (dst_void, src_void, length),
-        _PTR dst_void _AND
-        _CONST _PTR src_void _AND
-        size_t length) ICODE_ATTR;
+        _PTR dst_void _AND
+        _CONST _PTR src_void _AND
+        size_t length) ICODE_ATTR;
 
 _PTR
 _DEFUN (memmove, (dst_void, src_void, length),
-        _PTR dst_void _AND
-        _CONST _PTR src_void _AND
-        size_t length)
+        _PTR dst_void _AND
+        _CONST _PTR src_void _AND
+        size_t length)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   char *dst = dst_void;
@@ -74,16 +74,16 @@ _DEFUN (memmove, (dst_void, src_void, length),
       src += length;
       dst += length;
       while (length--)
-        {
-          *--dst = *--src;
-        }
+        {
+          *--dst = *--src;
+        }
     }
   else
     {
       while (length--)
-        {
-          *dst++ = *src++;
-        }
+        {
+          *dst++ = *src++;
+        }
     }
 
   return dst_void;
@@ -100,9 +100,9 @@ _DEFUN (memmove, (dst_void, src_void, length),
       src += len;
       dst += len;
       while (len--)
-        {
-          *--dst = *--src;
-        }
+        {
+          *--dst = *--src;
+        }
     }
   else
     {
diff --git a/firmware/common/memset.c b/firmware/common/memset.c
index c370191cda..6c4a66bf13 100644
--- a/firmware/common/memset.c
+++ b/firmware/common/memset.c
@@ -1,28 +1,28 @@
 /*
 FUNCTION
-        <<memset>>---set an area of memory
+        <<memset>>---set an area of memory
 
 INDEX
-        memset
+        memset
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
+        #include <string.h>
+        void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        void *memset(<[dst]>, <[c]>, <[length]>)
-        void *<[dst]>;
-        int <[c]>;
-        size_t <[length]>;
+        #include <string.h>
+        void *memset(<[dst]>, <[c]>, <[length]>)
+        void *<[dst]>;
+        int <[c]>;
+        size_t <[length]>;
 
 DESCRIPTION
-        This function converts the argument <[c]> into an unsigned
-        char and fills the first <[length]> characters of the array
-        pointed to by <[dst]> to the value.
+        This function converts the argument <[c]> into an unsigned
+        char and fills the first <[length]> characters of the array
+        pointed to by <[dst]> to the value.
 
 RETURNS
-        <<memset>> returns the value of <[m]>.
+        <<memset>> returns the value of <[m]>.
 
 PORTABILITY
 <<memset>> is ANSI C.
@@ -30,7 +30,7 @@ PORTABILITY
     <<memset>> requires no supporting OS subroutines.
 
 QUICKREF
-        memset ansi pure
+        memset ansi pure
 */
 
 #include <string.h>
@@ -41,9 +41,9 @@ QUICKREF
 
 _PTR 
 _DEFUN (memset, (m, c, n),
-        _PTR m _AND
-        int c _AND
-        size_t n)
+        _PTR m _AND
+        int c _AND
+        size_t n)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   char *s = (char *) m;
@@ -78,7 +78,7 @@ _DEFUN (memset, (m, c, n),
         {
           buffer = 0;
           for (i = 0; i < LBLOCKSIZE; i++)
-            buffer = (buffer << 8) | c;
+            buffer = (buffer << 8) | c;
         }
 
       while (n >= LBLOCKSIZE*4)
diff --git a/firmware/common/qsort.c b/firmware/common/qsort.c
index b2071d447f..8c4d1ad511 100644
--- a/firmware/common/qsort.c
+++ b/firmware/common/qsort.c
@@ -3,20 +3,20 @@ FUNCTION
 <<qsort>>---sort an array
 
 INDEX
-        qsort
+        qsort
 
 ANSI_SYNOPSIS
-        #include <stdlib.h>
-        void qsort(void *<[base]>, size_t <[nmemb]>, size_t <[size]>,
-                   int (*<[compar]>)(const void *, const void *) );
+        #include <stdlib.h>
+        void qsort(void *<[base]>, size_t <[nmemb]>, size_t <[size]>,
+                   int (*<[compar]>)(const void *, const void *) );
 
 TRAD_SYNOPSIS
-        #include <stdlib.h>
-        qsort(<[base]>, <[nmemb]>, <[size]>, <[compar]> )
-        char *<[base]>;
-        size_t <[nmemb]>;
-        size_t <[size]>;
-        int (*<[compar]>)();
+        #include <stdlib.h>
+        qsort(<[base]>, <[nmemb]>, <[size]>, <[compar]> )
+        char *<[base]>;
+        size_t <[nmemb]>;
+        size_t <[size]>;
+        int (*<[compar]>)();
 
 DESCRIPTION
 <<qsort>> sorts an array (beginning at <[base]>) of <[nmemb]> objects.
@@ -43,7 +43,7 @@ PORTABILITY
 
 /*-
  * Copyright (c) 1992, 1993
- *      The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -55,8 +55,8 @@ PORTABILITY
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
@@ -81,142 +81,142 @@ PORTABILITY
 #define inline
 #endif
 
-static inline char      *med3 _PARAMS((char *, char *, char *, int (*cmp)(const _PTR,const _PTR)));
-static inline void       swapfunc _PARAMS((char *, char *, int, int));
+static inline char      *med3 _PARAMS((char *, char *, char *, int (*cmp)(const _PTR,const _PTR)));
+static inline void       swapfunc _PARAMS((char *, char *, int, int));
 
-#define min(a, b)       (a) < (b) ? a : b
+#define min(a, b)       (a) < (b) ? a : b
 
 /*
  * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
  */
-#define swapcode(TYPE, parmi, parmj, n) {               \
-        long i = (n) / sizeof (TYPE);                   \
-        register TYPE *pi = (TYPE *) (parmi);           \
-        register TYPE *pj = (TYPE *) (parmj);           \
-        do {                                            \
-                register TYPE   t = *pi;                \
-                *pi++ = *pj;                            \
-                *pj++ = t;                              \
-        } while (--i > 0);                              \
+#define swapcode(TYPE, parmi, parmj, n) {               \
+        long i = (n) / sizeof (TYPE);                   \
+        register TYPE *pi = (TYPE *) (parmi);           \
+        register TYPE *pj = (TYPE *) (parmj);           \
+        do {                                            \
+                register TYPE   t = *pi;                \
+                *pi++ = *pj;                            \
+                *pj++ = t;                              \
+        } while (--i > 0);                              \
 }
 
 #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
-        es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+        es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
 
 static inline void
 _DEFUN(swapfunc, (a, b, n, swaptype),
-        char *a _AND
-        char *b _AND
-        int n _AND
-        int swaptype)
+        char *a _AND
+        char *b _AND
+        int n _AND
+        int swaptype)
 {
-        if(swaptype <= 1) 
-                swapcode(long, a, b, n)
-        else
-                swapcode(char, a, b, n)
+        if(swaptype <= 1) 
+                swapcode(long, a, b, n)
+        else
+                swapcode(char, a, b, n)
 }
 
-#define swap(a, b)                                      \
-        if (swaptype == 0) {                            \
-                long t = *(long *)(a);                  \
-                *(long *)(a) = *(long *)(b);            \
-                *(long *)(b) = t;                       \
-        } else                                          \
-                swapfunc(a, b, es, swaptype)
+#define swap(a, b)                                      \
+        if (swaptype == 0) {                            \
+                long t = *(long *)(a);                  \
+                *(long *)(a) = *(long *)(b);            \
+                *(long *)(b) = t;                       \
+        } else                                          \
+                swapfunc(a, b, es, swaptype)
 
-#define vecswap(a, b, n)        if ((n) > 0) swapfunc(a, b, n, swaptype)
+#define vecswap(a, b, n)        if ((n) > 0) swapfunc(a, b, n, swaptype)
 
 static inline char *
 _DEFUN(med3, (a, b, c, cmp),
-        char *a _AND
-        char *b _AND
-        char *c _AND
-        int (*cmp)(const _PTR,const _PTR))
+        char *a _AND
+        char *b _AND
+        char *c _AND
+        int (*cmp)(const _PTR,const _PTR))
 {
-        return cmp(a, b) < 0 ?
-               (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
+        return cmp(a, b) < 0 ?
+               (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
               :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
 }
 
 void
 _DEFUN(qsort, (a, n, es, cmp),
-        void *a _AND
-        size_t n _AND
-        size_t es _AND
-        int (*cmp)(const _PTR,const _PTR))
+        void *a _AND
+        size_t n _AND
+        size_t es _AND
+        int (*cmp)(const _PTR,const _PTR))
 {
-        char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
-        int d, r, swaptype, swap_cnt;
-
-loop:   SWAPINIT(a, es);
-        swap_cnt = 0;
-        if (n < 7) {
-                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
-                             pl -= es)
-                                swap(pl, pl - es);
-                return;
-        }
-        pm = (char *) a + (n / 2) * es;
-        if (n > 7) {
-                pl = a;
-                pn = (char *) a + (n - 1) * es;
-                if (n > 40) {
-                        d = (n / 8) * es;
-                        pl = med3(pl, pl + d, pl + 2 * d, cmp);
-                        pm = med3(pm - d, pm, pm + d, cmp);
-                        pn = med3(pn - 2 * d, pn - d, pn, cmp);
-                }
-                pm = med3(pl, pm, pn, cmp);
-        }
-        swap(a, pm);
-        pa = pb = (char *) a + es;
-
-        pc = pd = (char *) a + (n - 1) * es;
-        for (;;) {
-                while (pb <= pc && (r = cmp(pb, a)) <= 0) {
-                        if (r == 0) {
-                                swap_cnt = 1;
-                                swap(pa, pb);
-                                pa += es;
-                        }
-                        pb += es;
-                }
-                while (pb <= pc && (r = cmp(pc, a)) >= 0) {
-                        if (r == 0) {
-                                swap_cnt = 1;
-                                swap(pc, pd);
-                                pd -= es;
-                        }
-                        pc -= es;
-                }
-                if (pb > pc)
-                        break;
-                swap(pb, pc);
-                swap_cnt = 1;
-                pb += es;
-                pc -= es;
-        }
-        if (swap_cnt == 0) {  /* Switch to insertion sort */
-                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
-                             pl -= es)
-                                swap(pl, pl - es);
-                return;
-        }
-
-        pn = (char *) a + n * es;
-        r = min(pa - (char *)a, pb - pa);
-        vecswap(a, pb - r, r);
-        r = min((unsigned int)(pd - pc), pn - pd - es);
-        vecswap(pb, pn - r, r);
-        if ((unsigned int)(r = pb - pa) > es)
-                qsort(a, r / es, es, cmp);
-        if ((unsigned int)(r = pd - pc) > es) { 
-                /* Iterate rather than recurse to save stack space */
-                a = pn - r;
-                n = r / es;
-                goto loop;
-        }
-/*              qsort(pn - r, r / es, es, cmp);*/
+        char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+        int d, r, swaptype, swap_cnt;
+
+loop:   SWAPINIT(a, es);
+        swap_cnt = 0;
+        if (n < 7) {
+                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
+                             pl -= es)
+                                swap(pl, pl - es);
+                return;
+        }
+        pm = (char *) a + (n / 2) * es;
+        if (n > 7) {
+                pl = a;
+                pn = (char *) a + (n - 1) * es;
+                if (n > 40) {
+                        d = (n / 8) * es;
+                        pl = med3(pl, pl + d, pl + 2 * d, cmp);
+                        pm = med3(pm - d, pm, pm + d, cmp);
+                        pn = med3(pn - 2 * d, pn - d, pn, cmp);
+                }
+                pm = med3(pl, pm, pn, cmp);
+        }
+        swap(a, pm);
+        pa = pb = (char *) a + es;
+
+        pc = pd = (char *) a + (n - 1) * es;
+        for (;;) {
+                while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+                        if (r == 0) {
+                                swap_cnt = 1;
+                                swap(pa, pb);
+                                pa += es;
+                        }
+                        pb += es;
+                }
+                while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+                        if (r == 0) {
+                                swap_cnt = 1;
+                                swap(pc, pd);
+                                pd -= es;
+                        }
+                        pc -= es;
+                }
+                if (pb > pc)
+                        break;
+                swap(pb, pc);
+                swap_cnt = 1;
+                pb += es;
+                pc -= es;
+        }
+        if (swap_cnt == 0) {  /* Switch to insertion sort */
+                for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+                        for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; 
+                             pl -= es)
+                                swap(pl, pl - es);
+                return;
+        }
+
+        pn = (char *) a + n * es;
+        r = min(pa - (char *)a, pb - pa);
+        vecswap(a, pb - r, r);
+        r = min((unsigned int)(pd - pc), pn - pd - es);
+        vecswap(pb, pn - r, r);
+        if ((unsigned int)(r = pb - pa) > es)
+                qsort(a, r / es, es, cmp);
+        if ((unsigned int)(r = pd - pc) > es) { 
+                /* Iterate rather than recurse to save stack space */
+                a = pn - r;
+                n = r / es;
+                goto loop;
+        }
+/*              qsort(pn - r, r / es, es, cmp);*/
 }
diff --git a/firmware/common/strchr.c b/firmware/common/strchr.c
index de4585f758..96acf5edf6 100644
--- a/firmware/common/strchr.c
+++ b/firmware/common/strchr.c
@@ -1,28 +1,28 @@
 /*
 FUNCTION
-        <<strchr>>---search for character in string
+        <<strchr>>---search for character in string
 
 INDEX
-        strchr
+        strchr
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        char * strchr(const char *<[string]>, int <[c]>);
+        #include <string.h>
+        char * strchr(const char *<[string]>, int <[c]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        char * strchr(<[string]>, <[c]>);
-        char *<[string]>;
-        int *<[c]>;
+        #include <string.h>
+        char * strchr(<[string]>, <[c]>);
+        char *<[string]>;
+        int *<[c]>;
 
 DESCRIPTION
-        This function finds the first occurence of <[c]> (converted to
-        a char) in the string pointed to by <[string]> (including the
-        terminating null character).
+        This function finds the first occurence of <[c]> (converted to
+        a char) in the string pointed to by <[string]> (including the
+        terminating null character).
 
 RETURNS
-        Returns a pointer to the located character, or a null pointer
-        if <[c]> does not occur in <[string]>.
+        Returns a pointer to the located character, or a null pointer
+        if <[c]> does not occur in <[string]>.
 
 PORTABILITY
 <<strchr>> is ANSI C.
@@ -30,7 +30,7 @@ PORTABILITY
 <<strchr>> requires no supporting OS subroutines.
 
 QUICKREF
-        strchr ansi pure
+        strchr ansi pure
 */
 
 #include <string.h>
@@ -59,8 +59,8 @@ QUICKREF
 
 char *
 _DEFUN (strchr, (s1, i),
-        _CONST char *s1 _AND
-        int i)
+        _CONST char *s1 _AND
+        int i)
 {
   _CONST unsigned char *s = (_CONST unsigned char *)s1;
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
diff --git a/firmware/common/strcmp.c b/firmware/common/strcmp.c
index 81d65272ec..bbbf4b174a 100644
--- a/firmware/common/strcmp.c
+++ b/firmware/common/strcmp.c
@@ -1,30 +1,30 @@
 /*
 FUNCTION
-        <<strcmp>>---character string compare
-        
+        <<strcmp>>---character string compare
+        
 INDEX
-        strcmp
+        strcmp
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        int strcmp(const char *<[a]>, const char *<[b]>);
+        #include <string.h>
+        int strcmp(const char *<[a]>, const char *<[b]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        int strcmp(<[a]>, <[b]>)
-        char *<[a]>;
-        char *<[b]>;
+        #include <string.h>
+        int strcmp(<[a]>, <[b]>)
+        char *<[a]>;
+        char *<[b]>;
 
 DESCRIPTION
-        <<strcmp>> compares the string at <[a]> to
-        the string at <[b]>.
+        <<strcmp>> compares the string at <[a]> to
+        the string at <[b]>.
 
 RETURNS
-        If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
-        <<strcmp>> returns a number greater than zero.  If the two
-        strings match, <<strcmp>> returns zero.  If <<*<[a]>>>
-        sorts lexicographically before <<*<[b]>>>, <<strcmp>> returns a
-        number less than zero.
+        If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
+        <<strcmp>> returns a number greater than zero.  If the two
+        strings match, <<strcmp>> returns zero.  If <<*<[a]>>>
+        sorts lexicographically before <<*<[b]>>>, <<strcmp>> returns a
+        number less than zero.
 
 PORTABILITY
 <<strcmp>> is ANSI C.
@@ -32,7 +32,7 @@ PORTABILITY
 <<strcmp>> requires no supporting OS subroutines.
 
 QUICKREF
-        strcmp ansi pure
+        strcmp ansi pure
 */
 
 #include <string.h>
@@ -59,8 +59,8 @@ QUICKREF
 
 int
 _DEFUN (strcmp, (s1, s2),
-        _CONST char *s1 _AND
-        _CONST char *s2)
+        _CONST char *s1 _AND
+        _CONST char *s2)
 { 
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   while (*s1 != '\0' && *s1 == *s2)
@@ -83,9 +83,9 @@ _DEFUN (strcmp, (s1, s2),
       while (*a1 == *a2)
         {
           /* To get here, *a1 == *a2, thus if we find a null in *a1,
-             then the strings must be equal, so return zero.  */
+             then the strings must be equal, so return zero.  */
           if (DETECTNULL (*a1))
-            return 0;
+            return 0;
 
           a1++;
           a2++;
diff --git a/firmware/common/strcpy.c b/firmware/common/strcpy.c
index 0580d88cb8..077ae73cc6 100644
--- a/firmware/common/strcpy.c
+++ b/firmware/common/strcpy.c
@@ -1,27 +1,27 @@
 /*
 FUNCTION
-        <<strcpy>>---copy string
+        <<strcpy>>---copy string
 
 INDEX
-        strcpy
+        strcpy
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        char *strcpy(char *<[dst]>, const char *<[src]>);
+        #include <string.h>
+        char *strcpy(char *<[dst]>, const char *<[src]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        char *strcpy(<[dst]>, <[src]>)
-        char *<[dst]>;
-        char *<[src]>;
+        #include <string.h>
+        char *strcpy(<[dst]>, <[src]>)
+        char *<[dst]>;
+        char *<[src]>;
 
 DESCRIPTION
-        <<strcpy>> copies the string pointed to by <[src]>
-        (including the terminating null character) to the array
-        pointed to by <[dst]>.
+        <<strcpy>> copies the string pointed to by <[src]>
+        (including the terminating null character) to the array
+        pointed to by <[dst]>.
 
 RETURNS
-        This function returns the initial value of <[dst]>.
+        This function returns the initial value of <[dst]>.
 
 PORTABILITY
 <<strcpy>> is ANSI C.
@@ -29,7 +29,7 @@ PORTABILITY
 <<strcpy>> requires no supporting OS subroutines.
 
 QUICKREF
-        strcpy ansi pure
+        strcpy ansi pure
 */
 
 #include <string.h>
@@ -59,8 +59,8 @@ QUICKREF
 
 char*
 _DEFUN (strcpy, (dst0, src0),
-        char *dst0 _AND
-        _CONST char *src0)
+        char *dst0 _AND
+        _CONST char *src0)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   char *s = dst0;
diff --git a/firmware/common/strlcat.c b/firmware/common/strlcat.c
index 0a113dd134..da0d253e79 100644
--- a/firmware/common/strlcat.c
+++ b/firmware/common/strlcat.c
@@ -29,28 +29,28 @@
 size_t
 strlcat(char *dst, const char *src, size_t siz)
 {
-        char *d = dst;
-        const char *s = src;
-        size_t n = siz;
-        size_t dlen;
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
+        size_t dlen;
 
-        /* Find the end of dst and adjust bytes left but don't go past end */
-        while (n-- != 0 && *d != '\0')
-                d++;
-        dlen = d - dst;
-        n = siz - dlen;
+        /* Find the end of dst and adjust bytes left but don't go past end */
+        while (n-- != 0 && *d != '\0')
+                d++;
+        dlen = d - dst;
+        n = siz - dlen;
 
-        if (n == 0)
-                return(dlen + strlen(s));
-        while (*s != '\0') {
-                if (n != 1) {
-                        *d++ = *s;
-                        n--;
-                }
-                s++;
-        }
-        *d = '\0';
+        if (n == 0)
+                return(dlen + strlen(s));
+        while (*s != '\0') {
+                if (n != 1) {
+                        *d++ = *s;
+                        n--;
+                }
+                s++;
+        }
+        *d = '\0';
 
-        return(dlen + (s - src));       /* count does not include NUL */
+        return(dlen + (s - src));       /* count does not include NUL */
 }
 
diff --git a/firmware/common/strlcpy.c b/firmware/common/strlcpy.c
index ac30ef01fe..6e06eb81d2 100644
--- a/firmware/common/strlcpy.c
+++ b/firmware/common/strlcpy.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $    */
+/*      $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $    */
 
 /*
  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
@@ -27,26 +27,26 @@
 size_t
 strlcpy(char *dst, const char *src, size_t siz)
 {
-        char *d = dst;
-        const char *s = src;
-        size_t n = siz;
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
 
-        /* Copy as many bytes as will fit */
-        if (n != 0) {
-                while (--n != 0) {
-                        if ((*d++ = *s++) == '\0')
-                                break;
-                }
-        }
+        /* Copy as many bytes as will fit */
+        if (n != 0) {
+                while (--n != 0) {
+                        if ((*d++ = *s++) == '\0')
+                                break;
+                }
+        }
 
-        /* Not enough room in dst, add NUL and traverse rest of src */
-        if (n == 0) {
-                if (siz != 0)
-                        *d = '\0';              /* NUL-terminate dst */
-                while (*s++)
-                        ;
-        }
+        /* Not enough room in dst, add NUL and traverse rest of src */
+        if (n == 0) {
+                if (siz != 0)
+                        *d = '\0';              /* NUL-terminate dst */
+                while (*s++)
+                        ;
+        }
 
-        return(s - src - 1);    /* count does not include NUL */
+        return(s - src - 1);    /* count does not include NUL */
 }
 
diff --git a/firmware/common/strlen.c b/firmware/common/strlen.c
index 2e2c62eb75..4d33eafce6 100644
--- a/firmware/common/strlen.c
+++ b/firmware/common/strlen.c
@@ -1,26 +1,26 @@
 /*
 FUNCTION
-        <<strlen>>---character string length
-        
+        <<strlen>>---character string length
+        
 INDEX
-        strlen
+        strlen
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        size_t strlen(const char *<[str]>);
+        #include <string.h>
+        size_t strlen(const char *<[str]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        size_t strlen(<[str]>)
-        char *<[src]>;
+        #include <string.h>
+        size_t strlen(<[str]>)
+        char *<[src]>;
 
 DESCRIPTION
-        The <<strlen>> function works out the length of the string
-        starting at <<*<[str]>>> by counting chararacters until it
-        reaches a <<NULL>> character.
+        The <<strlen>> function works out the length of the string
+        starting at <<*<[str]>>> by counting chararacters until it
+        reaches a <<NULL>> character.
 
 RETURNS
-        <<strlen>> returns the character count.
+        <<strlen>> returns the character count.
 
 PORTABILITY
 <<strlen>> is ANSI C.
@@ -28,7 +28,7 @@ PORTABILITY
 <<strlen>> requires no supporting OS subroutines.
 
 QUICKREF
-        strlen ansi pure
+        strlen ansi pure
 */
 
 #include "config.h"
@@ -56,11 +56,11 @@ QUICKREF
 
 size_t
 _DEFUN (strlen, (str),
-        _CONST char *str) ICODE_ATTR;
+        _CONST char *str) ICODE_ATTR;
 
 size_t
 _DEFUN (strlen, (str),
-        _CONST char *str)
+        _CONST char *str)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   _CONST char *start = str;
diff --git a/firmware/common/strnatcmp.c b/firmware/common/strnatcmp.c
index 93a649358f..0084ff3582 100644
--- a/firmware/common/strnatcmp.c
+++ b/firmware/common/strnatcmp.c
@@ -75,26 +75,26 @@ compare_right(char const *a, char const *b)
      int ca, cb;
      
      /* The longest run of digits wins.  That aside, the greatest
-        value wins, but we can't know that it will until we've scanned
-        both numbers to know that they have the same magnitude, so we
-        remember it in BIAS. */
+        value wins, but we can't know that it will until we've scanned
+        both numbers to know that they have the same magnitude, so we
+        remember it in BIAS. */
      for (;; a++, b++) {
       ca = to_int(*a);
       cb = to_int(*b);
-          if (!nat_isdigit(ca)  &&  !nat_isdigit(cb))
-               return bias;
-          else if (!nat_isdigit(ca))
-               return -1;
-          else if (!nat_isdigit(cb))
-               return +1;
-          else if (ca < cb) {
-               if (!bias)
-                    bias = -1;
-          } else if (ca > cb) {
-               if (!bias)
-                    bias = +1;
-          } else if (!ca  &&  !cb)
-               return bias;
+          if (!nat_isdigit(ca)  &&  !nat_isdigit(cb))
+               return bias;
+          else if (!nat_isdigit(ca))
+               return -1;
+          else if (!nat_isdigit(cb))
+               return +1;
+          else if (ca < cb) {
+               if (!bias)
+                    bias = -1;
+          } else if (ca > cb) {
+               if (!bias)
+                    bias = +1;
+          } else if (!ca  &&  !cb)
+               return bias;
      }
 
      return 0;
@@ -107,18 +107,18 @@ compare_left(char const *a, char const *b)
      /* Compare two left-aligned numbers: the first to have a
         different value wins. */
      for (;; a++, b++) {
-          if (!nat_isdigit(*a)  &&  !nat_isdigit(*b))
-               return 0;
-          else if (!nat_isdigit(*a))
-               return -1;
-          else if (!nat_isdigit(*b))
-               return +1;
-          else if (*a < *b)
-               return -1;
-          else if (*a > *b)
-               return +1;
+          if (!nat_isdigit(*a)  &&  !nat_isdigit(*b))
+               return 0;
+          else if (!nat_isdigit(*a))
+               return -1;
+          else if (!nat_isdigit(*b))
+               return +1;
+          else if (*a < *b)
+               return -1;
+          else if (*a > *b)
+               return +1;
      }
-          
+          
      return 0;
 }
 
@@ -134,39 +134,39 @@ static int strnatcmp0(char const *a, char const *b, int fold_case)
       ca = to_int(a[ai]);
       cb = to_int(b[bi]);
 
-          /* process run of digits */
-          if (nat_isdigit(ca)  &&  nat_isdigit(cb)) {
-               fractional = (ca == '0' || cb == '0');
-
-               if (fractional) {
-                    if ((result = compare_left(a+ai, b+bi)) != 0)
-                         return result;
-               } else {
-                    if ((result = compare_right(a+ai, b+bi)) != 0)
-                         return result;
-               }
-          }
-
-          if (!ca && !cb) {
-               /* The strings compare the same.  Call str[case]cmp() to ensure
+          /* process run of digits */
+          if (nat_isdigit(ca)  &&  nat_isdigit(cb)) {
+               fractional = (ca == '0' || cb == '0');
+
+               if (fractional) {
+                    if ((result = compare_left(a+ai, b+bi)) != 0)
+                         return result;
+               } else {
+                    if ((result = compare_right(a+ai, b+bi)) != 0)
+                         return result;
+               }
+          }
+
+          if (!ca && !cb) {
+               /* The strings compare the same.  Call str[case]cmp() to ensure
                   consistent results. */
                if(fold_case)
                    return strcasecmp(a,b);
                else
                    return strcmp(a,b);
-          }
-
-          if (fold_case) {
-               ca = nat_unify_case(ca);
-               cb = nat_unify_case(cb);
-          }
-          
-          if (ca < cb)
-               return -1;
-          else if (ca > cb)
-               return +1;
-
-          ++ai; ++bi;
+          }
+
+          if (fold_case) {
+               ca = nat_unify_case(ca);
+               cb = nat_unify_case(cb);
+          }
+          
+          if (ca < cb)
+               return -1;
+          else if (ca > cb)
+               return +1;
+
+          ++ai; ++bi;
      }
 }
 
diff --git a/firmware/common/strncmp.c b/firmware/common/strncmp.c
index 9801b7d924..b1d8d9d43a 100644
--- a/firmware/common/strncmp.c
+++ b/firmware/common/strncmp.c
@@ -1,31 +1,31 @@
 /*
 FUNCTION
-        <<strncmp>>---character string compare
-        
+        <<strncmp>>---character string compare
+        
 INDEX
-        strncmp
+        strncmp
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        int strncmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
+        #include <string.h>
+        int strncmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        int strncmp(<[a]>, <[b]>, <[length]>)
-        char *<[a]>;
-        char *<[b]>;
-        size_t <[length]>
+        #include <string.h>
+        int strncmp(<[a]>, <[b]>, <[length]>)
+        char *<[a]>;
+        char *<[b]>;
+        size_t <[length]>
 
 DESCRIPTION
-        <<strncmp>> compares up to <[length]> characters
-        from the string at <[a]> to the string at <[b]>.
+        <<strncmp>> compares up to <[length]> characters
+        from the string at <[a]> to the string at <[b]>.
 
 RETURNS
-        If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
-        <<strncmp>> returns a number greater than zero.  If the two
-        strings are equivalent, <<strncmp>> returns zero.  If <<*<[a]>>>
-        sorts lexicographically before <<*<[b]>>>, <<strncmp>> returns a
-        number less than zero.
+        If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
+        <<strncmp>> returns a number greater than zero.  If the two
+        strings are equivalent, <<strncmp>> returns zero.  If <<*<[a]>>>
+        sorts lexicographically before <<*<[b]>>>, <<strncmp>> returns a
+        number less than zero.
 
 PORTABILITY
 <<strncmp>> is ANSI C.
@@ -33,7 +33,7 @@ PORTABILITY
 <<strncmp>> requires no supporting OS subroutines.
 
 QUICKREF
-        strncmp ansi pure
+        strncmp ansi pure
 */
 
 #include <string.h>
@@ -60,9 +60,9 @@ QUICKREF
 
 int 
 _DEFUN (strncmp, (s1, s2, n),
-        _CONST char *s1 _AND
-        _CONST char *s2 _AND
-        size_t n)
+        _CONST char *s1 _AND
+        _CONST char *s2 _AND
+        size_t n)
 {
 #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
   if (n == 0)
@@ -71,7 +71,7 @@ _DEFUN (strncmp, (s1, s2, n),
   while (n-- != 0 && *s1 == *s2)
     {
       if (n == 0 || *s1 == '\0')
-        break;
+        break;
       s1++;
       s2++;
     }
@@ -95,9 +95,9 @@ _DEFUN (strncmp, (s1, s2, n),
           n -= sizeof (long);
 
           /* If we've run out of bytes or hit a null, return zero
-             since we already know *a1 == *a2.  */
+             since we already know *a1 == *a2.  */
           if (n == 0 || DETECTNULL (*a1))
-            return 0;
+            return 0;
 
           a1++;
           a2++;
@@ -111,9 +111,9 @@ _DEFUN (strncmp, (s1, s2, n),
   while (n-- > 0 && *s1 == *s2)
     {
       /* If we've run out of bytes or hit a null, return zero
-         since we already know *s1 == *s2.  */
+         since we already know *s1 == *s2.  */
       if (n == 0 || *s1 == '\0')
-        return 0;
+        return 0;
       s1++;
       s2++;
     }
diff --git a/firmware/common/strrchr.c b/firmware/common/strrchr.c
index 4f903afe2b..31b0d049b3 100644
--- a/firmware/common/strrchr.c
+++ b/firmware/common/strrchr.c
@@ -1,28 +1,28 @@
 /*
 FUNCTION
-        <<strrchr>>---reverse search for character in string
+        <<strrchr>>---reverse search for character in string
 
 INDEX
-        strrchr
+        strrchr
 
 ANSI_SYNOPSIS
-        #include <string.h>
-        char * strrchr(const char *<[string]>, int <[c]>);
+        #include <string.h>
+        char * strrchr(const char *<[string]>, int <[c]>);
 
 TRAD_SYNOPSIS
-        #include <string.h>
-        char * strrchr(<[string]>, <[c]>);
-        char *<[string]>;
-        int *<[c]>;
+        #include <string.h>
+        char * strrchr(<[string]>, <[c]>);
+        char *<[string]>;
+        int *<[c]>;
 
 DESCRIPTION
-        This function finds the last occurence of <[c]> (converted to
-        a char) in the string pointed to by <[string]> (including the
-        terminating null character).
+        This function finds the last occurence of <[c]> (converted to
+        a char) in the string pointed to by <[string]> (including the
+        terminating null character).
 
 RETURNS
-        Returns a pointer to the located character, or a null pointer
-        if <[c]> does not occur in <[string]>.
+        Returns a pointer to the located character, or a null pointer
+        if <[c]> does not occur in <[string]>.
 
 PORTABILITY
 <<strrchr>> is ANSI C.
@@ -30,30 +30,30 @@ PORTABILITY
 <<strrchr>> requires no supporting OS subroutines.
 
 QUICKREF
-        strrchr ansi pure
+        strrchr ansi pure
 */
 
 #include <string.h>
 
 char *
 _DEFUN (strrchr, (s, i),
-        _CONST char *s _AND
-        int i)
+        _CONST char *s _AND
+        int i)
 {
   _CONST char *last = NULL;
 
   if (i)
     {
       while ((s=strchr(s, i)))
-        {
-          last = s;
-          s++;
-        }
+        {
+          last = s;
+          s++;
+        }
     }
   else
     {
       last = strchr(s, i);
     }
-                  
+                  
   return (char *) last;
 }