flower/libc-extension.cc

   1 /*
   2   libc-extension.cc --  compensate for lacking libc functions.
   3
   4   source file of the flowerlib
   5
   6   (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7   Jan Nieuwenhuizen <janneke@gnu.org>
   8 */
   9
  10 #include <cmath>
  11 #include <cstdio>
  12 #include <cstring>
  13 #include <cctype>
  14
  15 #include "libc-extension.hh"
  16
  17 char *
  18 strnlwr (char *start, int n)
  19 {
  20   char *p = start + n;
  21   while (--p >= start)
  22     {
  23       *p = tolower (*p);    /* a macro on some compilers */
  24     }
  25   return start;
  26 }
  27
  28 char *
  29 strnupr (char *start, int n)
  30 {
  31   char *p = start + n;
  32   while (--p >= start)
  33     {
  34       *p = toupper (*p);    /* a macro on some compilers */
  35     }
  36   return start;
  37 }
  38
  39 /*
  40   There are some strange problems with round() on early glibcs.
  41 */
  42 double
  43 my_round (double x)
  44 {
  45   return floor (x -0.5)+ 1.0;
  46 }
  47
  48 #ifndef isinf
  49 #if !HAVE_ISINF
  50 int
  51 isinf (double x)
  52 {
  53   return x && (x == x/ 2);
  54 }
  55 #endif
  56 #endif
  57
  58 #if !HAVE_MEMMEM
  59
  60 /** locate a substring. #memmem# finds the first occurrence of
  61     #needle# in #haystack#.  This is not ANSI-C.
  62
  63     The prototype is not in accordance with the Linux Programmer's
  64     Manual v1.15, but it is with /usr/include/string.h   */
  65
  66 unsigned char *
  67 _memmem (unsigned char const *haystack, int haystack_len,
  68          unsigned char const *needle, int needle_len)
  69 {
  70   unsigned char const *end_haystack = haystack + haystack_len - needle_len + 1;
  71   unsigned char const *end_needle = needle + needle_len;
  72
  73   /* Ahhh ... Some minimal lowlevel stuff. This *is* nice; Varation
  74      is the spice of life */
  75   while (haystack < end_haystack)
  76     {
  77       unsigned char const *subneedle = needle;
  78       unsigned char const *subhaystack = haystack;
  79       while (subneedle < end_needle)
  80         if (*subneedle++ != *subhaystack++)
  81           goto next;
  82
  83       /* Completed the needle.  Gotcha.  */
  84       return (unsigned char *) haystack;
  85     next:
  86       haystack++;
  87     }
  88   return 0;
  89 }
  90
  91 void *
  92 memmem (void const *haystack, int haystack_len,
  93         void const *needle, int needle_len)
  94 {
  95   unsigned char const *haystack_byte_c = (unsigned char const *)haystack;
  96   unsigned char const *needle_byte_c = (unsigned char const *)needle;
  97   return _memmem (haystack_byte_c, haystack_len, needle_byte_c, needle_len);
  98 }
  99
 100 #endif
 101
 102 unsigned char *
 103 memrchr (unsigned char const *p, int n, char c)
 104 {
 105   const unsigned char *q = p + n;
 106   while (q > p)
 107     {
 108       if (*--q == c)
 109         return (unsigned char *)q;
 110     }
 111   return 0;
 112 }
 113
 114 template<class T>
 115 inline void
 116 my_swap (T &t1, T &t2, T &tmp)
 117 {
 118   tmp = t1;
 119   t1 = t2;
 120   t2 = tmp;
 121 }
 122
 123 unsigned char *
 124 strrev (unsigned char *byte, int length)
 125 {
 126   unsigned char tmp_byte;
 127   unsigned char *left = byte;
 128   unsigned char *right = byte + length;
 129
 130   while (right > left)
 131     my_swap (*right--, *left++, tmp_byte);
 132   return byte;
 133 }
 134
 135 #if ! HAVE_SNPRINTF
 136 int
 137 snprintf (char *str, size_t, char const *format, ...)
 138 {
 139   va_list ap;
 140   va_start (ap, format);
 141   int i = vsprintf (str, format, ap);
 142   va_end (ap);
 143   return i;
 144 }
 145 #endif
 146
 147 #if ! HAVE_VSNPRINTF
 148 int
 149 vsnprintf (char *str, size_t, char const *format, va_list args)
 150 {
 151   int i = vsprintf (str, format, args);
 152   return i;
 153 }
 154 #endif
 155
 156 #include <assert.h>
 157
 158 extern "C" {
 159
 160 #if ! HAVE_FOPENCOOKIE
 161 #if HAVE_FUNOPEN
 162
 163   FILE *
 164   fopencookie (void *cookie, char const *mode, cookie_io_functions_t fun)
 165   {
 166     (void) mode;
 167 #if 0
 168     return funopen (cookie, fun.read, fun.write, fun.seek, fun.close);
 169 #else
 170     return funopen (cookie,
 171                     (int (*) (void *, char *, int)) fun.read,
 172                     (int (*) (void *, char const *, int)) fun.write,
 173                     (fpos_t (*) (void *, fpos_t, int)) fun.seek,
 174                     (int (*) (void *)) fun.close);
 175
 176 #endif
 177   }
 178
 179 #else /* ! HAVE_FUNOPEN */
 180
 181 #include <cstdio>
 182 #include "memory-stream.hh"
 183
 184   static bool
 185   is_memory_stream (void *foo)
 186   {
 187     Memory_out_stream *cookie = (Memory_out_stream *) foo;
 188     return dynamic_cast<Memory_out_stream *> (cookie);
 189   }
 190
 191   FILE *
 192   fopencookie (void *cookie, char const *modes, cookie_io_functions_t io_funcs)
 193   {
 194     (void) cookie;
 195     (void) modes;
 196     (void) io_funcs;
 197     if (is_memory_stream (cookie))
 198       return (FILE *) cookie;
 199     assert (false);
 200     return 0;
 201   }
 202
 203   int
 204   handle_cookie_io_fclose (FILE *file)
 205   {
 206     if (is_memory_stream (file))
 207       return Memory_out_stream::cleaner (file);
 208     return fclose (file);
 209   }
 210
 211   int
 212   handle_cookie_io_fprintf (FILE *file, char const *format, ...)
 213   {
 214     va_list ap;
 215     va_start (ap, format);
 216     if (is_memory_stream (file))
 217       {
 218         static char buf[1024];
 219         int i = vsnprintf (buf, sizeof (buf), format, ap);
 220         if (i == -1)
 221           assert (false);
 222         return Memory_out_stream::writer (file, buf, i);
 223       }
 224     int i = vfprintf (file, format, ap);
 225     va_end (ap);
 226     return i;
 227   }
 228
 229   int
 230   handle_cookie_io_putc (int c, FILE *file)
 231   {
 232     if (is_memory_stream (file))
 233       {
 234         char buf[1];
 235         buf[0] = (char) c;
 236         return Memory_out_stream::writer (file, buf, 1);
 237       }
 238     return putc (c, file);
 239   }
 240
 241 #endif /* ! HAVE_FUNOPEN */
 242 #endif /* ! HAVE_FOPENCOOKIE */
 243 } /* extern C */