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
 115 template<class T>
 116 inline void
 117 my_swap (T &t1, T &t2, T &tmp)
 118 {
 119   tmp = t1;
 120   t1 = t2;
 121   t2 = tmp;
 122 }
 123
 124 unsigned char *
 125 strrev (unsigned char *byte, int length)
 126 {
 127   unsigned char tmp_byte;
 128   unsigned char *left = byte;
 129   unsigned char *right = byte + length;
 130
 131   while (right > left)
 132     my_swap (*right--, *left++ , tmp_byte);
 133   return byte;
 134 }
 135
 136 #if ! HAVE_SNPRINTF
 137 int
 138 snprintf (char *str, size_t, char const *format, ...)
 139 {
 140   va_list ap;
 141   va_start (ap, format);
 142   int i = vsprintf (str, format, ap);
 143   va_end (ap);
 144   return i;
 145 }
 146 #endif
 147
 148 #if ! HAVE_VSNPRINTF
 149 int
 150 vsnprintf (char *str, size_t, char const *format, va_list args)
 151 {
 152   int i = vsprintf (str, format, args);
 153   return i;
 154 }
 155 #endif
 156
 157 #include <assert.h>
 158
 159 extern "C" {
 160
 161 #if ! HAVE_FOPENCOOKIE
 162 #if HAVE_FUNOPEN
 163
 164   FILE *
 165   fopencookie (void *cookie, char const *mode, cookie_io_functions_t fun)
 166   {
 167     return funopen (cookie, fun.read, fun.write, fun.seek, fun.close);
 168   }
 169
 170 #else /* ! HAVE_FUNOPEN */
 171
 172 #include <cstdio>
 173 #include "memory-stream.hh"
 174
 175   static bool
 176   is_memory_stream (void *foo)
 177   {
 178     Memory_out_stream* cookie = (Memory_out_stream*) foo;
 179     return dynamic_cast<Memory_out_stream*> (cookie);
 180   }
 181
 182   FILE *
 183   fopencookie (void *cookie, char const *modes, cookie_io_functions_t io_funcs)
 184   {
 185     (void) cookie;
 186     (void) modes;
 187     (void) io_funcs;
 188     if (is_memory_stream (cookie))
 189       return (FILE*) cookie;
 190     assert (false);
 191     return 0;
 192   }
 193
 194   int
 195   handle_cookie_io_fclose (FILE *file)
 196   {
 197     if (is_memory_stream (file))
 198       return Memory_out_stream::cleaner (file);
 199     return fclose (file);
 200   }
 201
 202   int
 203   handle_cookie_io_fprintf (FILE *file, char const *format, ...)
 204   {
 205     va_list ap;
 206     va_start (ap, format);
 207     if (is_memory_stream (file))
 208       {
 209         static char buf[1024];
 210         int i = vsnprintf (buf, sizeof (buf), format, ap);
 211         if (i == -1)
 212           assert (false);
 213         return Memory_out_stream::writer (file, buf, i);
 214       }
 215     int i = vfprintf (file, format, ap);
 216     va_end (ap);
 217     return i;
 218   }
 219
 220   int
 221   handle_cookie_io_putc (int c, FILE *file)
 222   {
 223     if (is_memory_stream (file))
 224       {
 225         char buf[1];
 226         buf[0] = (char) c;
 227         return Memory_out_stream::writer (file, buf, 1);
 228       }
 229     return putc (c, file);
 230   }
 231
 232 #endif /* ! HAVE_FUNOPEN */
 233 #endif /* ! HAVE_FOPENCOOKIE */
 234
 235 } /* extern C */