* libc.c: Extra libc function for some systems.
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: libc.c,v 1.16 2004/02/09 16:12:25 sigmunau Exp $
+ * $Id$
*
* Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
* Samuel Hocevar <sam@zoy.org>
+ * Gildas Bazin <gbazin@videolan.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*****************************************************************************/
#include <string.h> /* strdup() */
#include <stdlib.h>
+#include <ctype.h>
#include <vlc/vlc.h>
+#undef iconv_t
+#undef iconv_open
+#undef iconv
+#undef iconv_close
+
+#if defined(HAVE_ICONV)
+# include <iconv.h>
+#endif
+
/*****************************************************************************
* getenv: just in case, but it should never be called
*****************************************************************************/
}
#endif
+/******************************************************************************
+ * strcasestr: find a substring (little) in another substring (big)
+ * Case sensitive. Return NULL if not found, return big if little == null
+ *****************************************************************************/
+#if !defined( HAVE_STRCASESTR ) && !defined( HAVE_STRISTR )
+char * vlc_strcasestr( const char *psz_big, const char *psz_little )
+{
+ char *p_pos = (char *)psz_big;
+
+ if( !psz_big || !psz_little || !*psz_little ) return p_pos;
+
+ while( *p_pos )
+ {
+ if( toupper( *p_pos ) == toupper( *psz_little ) )
+ {
+ char * psz_cur1 = p_pos + 1;
+ char * psz_cur2 = (char *)psz_little + 1;
+ while( *psz_cur1 && *psz_cur2 &&
+ toupper( *psz_cur1 ) == toupper( *psz_cur2 ) )
+ {
+ psz_cur1++;
+ psz_cur2++;
+ }
+ if( !*psz_cur2 ) return p_pos;
+ }
+ p_pos++;
+ }
+ return NULL;
+}
+#endif
+
/*****************************************************************************
* vasprintf:
*****************************************************************************/
#endif
/*****************************************************************************
- * atoll: convert a string to a 64 bits int.
+ * strtoll: convert a string to a 64 bits int.
*****************************************************************************/
-#if !defined( HAVE_ATOLL )
-int64_t vlc_atoll( const char *str )
+#if !defined( HAVE_STRTOLL )
+int64_t vlc_strtoll( const char *nptr, char **endptr, int base )
{
int64_t i_value = 0;
- int sign = 1;
+ int sign = 1, newbase = base ? base : 10;
+
+ while( isspace(*nptr) ) nptr++;
- if( *str == '-' )
+ if( *nptr == '-' )
{
sign = -1;
+ nptr++;
+ }
+
+ /* Try to detect base */
+ if( *nptr == '0' )
+ {
+ newbase = 8;
+ nptr++;
+
+ if( *nptr == 'x' )
+ {
+ newbase = 16;
+ nptr++;
+ }
+ }
+
+ if( base && newbase != base )
+ {
+ if( endptr ) *endptr = (char *)nptr;
+ return i_value;
}
- while( *str >= '0' && *str <= '9' )
+ switch( newbase )
{
- i_value = i_value * 10 + ( *str++ - '0' );
+ case 10:
+ while( *nptr >= '0' && *nptr <= '9' )
+ {
+ i_value *= 10;
+ i_value += ( *nptr++ - '0' );
+ }
+ if( endptr ) *endptr = (char *)nptr;
+ break;
+
+ case 16:
+ while( (*nptr >= '0' && *nptr <= '9') ||
+ (*nptr >= 'a' && *nptr <= 'f') ||
+ (*nptr >= 'A' && *nptr <= 'F') )
+ {
+ int i_valc = 0;
+ if(*nptr >= '0' && *nptr <= '9') i_valc = *nptr - '0';
+ else if(*nptr >= 'a' && *nptr <= 'f') i_valc = *nptr - 'a' +10;
+ else if(*nptr >= 'A' && *nptr <= 'F') i_valc = *nptr - 'A' +10;
+ i_value *= 16;
+ i_value += i_valc;
+ nptr++;
+ }
+ if( endptr ) *endptr = (char *)nptr;
+ break;
+
+ default:
+ i_value = strtol( nptr, endptr, newbase );
+ break;
}
return i_value * sign;
}
#endif
+/*****************************************************************************
+ * atoll: convert a string to a 64 bits int.
+ *****************************************************************************/
+#if !defined( HAVE_ATOLL )
+int64_t vlc_atoll( const char *nptr )
+{
+ return strtoll( nptr, (char **)NULL, 10 );
+}
+#endif
+
/*****************************************************************************
* lseek: reposition read/write file offset.
*****************************************************************************
return psz_new_text;
}
+
+/*****************************************************************************
+ * iconv wrapper
+ *****************************************************************************/
+vlc_iconv_t vlc_iconv_open( const char *tocode, const char *fromcode )
+{
+#if defined(HAVE_ICONV)
+ return iconv_open( tocode, fromcode );
+#else
+ return NULL;
+#endif
+}
+
+size_t vlc_iconv( vlc_iconv_t cd, char **inbuf, size_t *inbytesleft,
+ char **outbuf, size_t *outbytesleft )
+{
+#if defined(HAVE_ICONV)
+ return iconv( cd, inbuf, inbytesleft, outbuf, outbytesleft );
+#else
+ int i_bytes = __MIN(*inbytesleft, *outbytesleft);
+ if( !inbuf || !outbuf || !i_bytes ) return (size_t)(-1);
+ memcpy( *outbuf, *inbuf, i_bytes );
+ inbuf += i_bytes;
+ outbuf += i_bytes;
+ inbytesleft -= i_bytes;
+ outbytesleft -= i_bytes;
+ return i_bytes;
+#endif
+}
+
+int vlc_iconv_close( vlc_iconv_t cd )
+{
+#if defined(HAVE_ICONV)
+ return iconv_close( cd );
+#else
+ return 0;
+#endif
+}
+
+/*****************************************************************************
+ * reduce a fraction
+ * (adapted from libavcodec, author Michael Niedermayer <michaelni@gmx.at>)
+ *****************************************************************************/
+vlc_bool_t vlc_reduce( int *pi_dst_nom, int *pi_dst_den,
+ int64_t i_nom, int64_t i_den, int64_t i_max )
+{
+ vlc_bool_t b_exact = 1, b_sign = 0;
+ int64_t i_gcd;
+
+ if( i_den == 0 )
+ {
+ *pi_dst_nom = 0;
+ *pi_dst_den = 1;
+ return 1;
+ }
+
+ if( i_den < 0 )
+ {
+ i_den = - i_den;
+ i_nom = - i_nom;
+ }
+
+ if( i_nom < 0 )
+ {
+ i_nom = - i_nom;
+ b_sign = 1;
+ }
+
+ i_gcd = GCD( i_nom, i_den );
+ i_nom /= i_gcd;
+ i_den /= i_gcd;
+
+ if( i_max == 0 ) i_max = I64C(0xFFFFFFFF);
+
+ if( i_nom > i_max || i_den > i_max )
+ {
+ int i_a0_num = 0, i_a0_den = 1, i_a1_num = 1, i_a1_den = 0;
+ b_exact = 0;
+
+ for( ; ; )
+ {
+ int64_t i_x = i_nom / i_den;
+ int64_t i_a2n = i_x * i_a1_num + i_a0_num;
+ int64_t i_a2d = i_x * i_a1_den + i_a0_den;
+
+ if( i_a2n > i_max || i_a2d > i_max ) break;
+
+ i_nom %= i_den;
+
+ i_a0_num = i_a1_num; i_a0_den = i_a1_den;
+ i_a1_num = i_a2n; i_a1_den = i_a2d;
+ if( i_nom == 0 ) break;
+ i_x = i_nom; i_nom = i_den; i_den = i_x;
+ }
+ i_nom = i_a1_num;
+ i_den = i_a1_den;
+ }
+
+ if( b_sign ) i_nom = - i_nom;
+
+ *pi_dst_nom = i_nom;
+ *pi_dst_den = i_den;
+
+ return b_exact;
+}