nstring.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include "naev.h"
#include "nstring.h"
 
#include "log.h"
 
#if !HAVE_STRNSTR
char *strnstr( const char *haystack, const char *needle, size_t size )
{
   size_t needlesize;
   const char *end, *giveup;
 
   needlesize = strlen(needle);
   /* We can give up if needle is empty, or haystack can never contain it */
   if (needlesize == 0 || needlesize > size)
      return NULL;
   /* The pointer value that marks the end of haystack */
   end = haystack + size;
   /* The maximum value of i, because beyond this haystack cannot contain needle */
   giveup = end - needlesize + 1;
 
   /* i is used to iterate over haystack */
   for (const char *i = haystack; i != giveup; i++) {
      const char *j, *k;
      /* j is used to iterate over part of haystack during comparison */
      /* k is used to iterate over needle during comparison */
      for (j = i, k = needle; j != end && *k != '\0'; j++, k++) {
         /* Bail on the first character that doesn't match */
         if (*j != *k)
            break;
      }
      /* If we've reached the end of needle, we've found a match */
      /* i contains the start of our match */
      if (*k == '\0')
         return (char*) i;
   }
   /* Fell through the loops, nothing found */
   return NULL;
}
#endif /* !HAVE_STRNSTR */
 
#if !HAVE_STRCASESTR
char *strcasestr( const char *haystack, const char *needle )
{
   /* Get lengths. */
   size_t hay_len     = strlen(haystack);
   size_t needle_len  = strlen(needle);
 
   /* Slow search. */
   while (hay_len >= needle_len) {
      if (strncasecmp(haystack, needle, needle_len) == 0)
         return (char*)haystack;
 
      haystack++;
      hay_len--;
   }
 
   return NULL;
}
#endif /* !HAVE_STRCASESTR */
 
#if !HAVE_STRNDUP
char* strndup( const char *s, size_t n )
{
   size_t len = MIN( strlen(s), n );
   char *new = (char *) malloc (len + 1);
   if (new == NULL)
      return NULL;
   new[len] = '\0';
   return (char *) memcpy (new, s, len);
}
#endif /* !HAVE_STRNDUP */
 
int strsort( const void *p1, const void *p2 )
{
   return strcmp(*(const char **) p1, *(const char **) p2);
}
 
int strsort_reverse( const void *p1, const void *p2 )
{
   return strsort( p2, p1 );
}
 
#if !HAVE_VASPRINTF
int vasprintf( char** strp, const char* fmt, va_list ap )
{
   int n;
   va_list ap1;
 
   va_copy( ap1, ap );
   n = vsnprintf( NULL, 0, fmt, ap1 );
   va_end( ap1 );
 
   if (n < 0)
      return -1;
   *strp = malloc( n+1 );
   if (strp == NULL )
      return -1; /* Not that we'll check. We're Linux fans. We've never heard of malloc() failing. */
 
   return vsnprintf( *strp, n+1, fmt, ap );
}
#endif /* !HAVE_VASPRINTF */
 
#if !HAVE_ASPRINTF
int asprintf( char** strp, const char* fmt, ... )
{
   int n;
   va_list ap;
 
   va_start( ap, fmt );
   n = vasprintf( strp, fmt, ap );
   va_end( ap );
   return n;
}
#endif /* !HAVE_ASPRINTF */
 
int scnprintf( char* text, size_t maxlen, const char* fmt, ... )
{
   int n;
   va_list ap;
 
   if (!maxlen)
      return 0;
 
   va_start( ap, fmt );
   n = vsnprintf( text, maxlen, fmt, ap );
   va_end( ap );
   return MIN( maxlen-1, (size_t)n );
}
 
int num2str( char dest[NUM2STRLEN], double n, int decimals )
{
   if (n >= 1e12)
      return snprintf( dest, NUM2STRLEN, "%.*f", decimals, n );
   else if (n >= 1e9)
      return snprintf( dest, NUM2STRLEN,
            _("%.0f,%03.0f,%03.0f,%03.*f"),
            floor(n/1e9),
            floor(fmod(floor(fabs(n/1e6)),1e3)),
            floor(fmod(floor(fabs(n/1e3)),1e3)),
            decimals, fmod(floor(fabs(n)),1e3) );
   else if (n >= 1e6)
      return snprintf( dest, NUM2STRLEN,
            _("%.0f,%03.0f,%03.*f"),
            floor(n/1e6),
            floor(fmod(floor(fabs(n/1e3)),1e3)),
            decimals, fmod(floor(fabs(n)),1e3) );
   else if (n >= 1e3)
      return snprintf( dest, NUM2STRLEN,
            _("%.0f,%03.*f"),
            floor(n/1e3), decimals, fmod(floor(fabs(n)),1e3) );
   return snprintf( dest, NUM2STRLEN, "%.*f", decimals, n );
}
 
const char* num2strU( double n, int decimals )
{
   static char num2strU_buf[NUM2STRLEN];
   num2str( num2strU_buf, n, decimals );
   return num2strU_buf;
}