← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to src/extras/libc.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/extras/libc.c
 
1
/*****************************************************************************
 
2
 * libc.c: Extra libc function for some systems.
 
3
 *****************************************************************************
 
4
 * Copyright (C) 2002 VideoLAN
 
5
 * $Id: libc.c 6961 2004-03-05 17:34:23Z sam $
 
6
 *
 
7
 * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
 
8
 *          Samuel Hocevar <sam@zoy.org>
 
9
 *
 
10
 * This program is free software; you can redistribute it and/or modify
 
11
 * it under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation; either version 2 of the License, or
 
13
 * (at your option) any later version.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 * GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with this program; if not, write to the Free Software
 
22
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 
23
 *****************************************************************************/
 
24
#include <string.h>                                              /* strdup() */
 
25
#include <stdlib.h>
 
26
 
 
27
#include <vlc/vlc.h>
 
28
 
 
29
/*****************************************************************************
 
30
 * getenv: just in case, but it should never be called
 
31
 *****************************************************************************/
 
32
#if !defined( HAVE_GETENV )
 
33
char *vlc_getenv( const char *name )
 
34
{
 
35
    return NULL;
 
36
}
 
37
#endif
 
38
 
 
39
/*****************************************************************************
 
40
 * strdup: returns a malloc'd copy of a string
 
41
 *****************************************************************************/
 
42
#if !defined( HAVE_STRDUP )
 
43
char *vlc_strdup( const char *string )
 
44
{
 
45
    return strndup( string, strlen( string ) );
 
46
}
 
47
#endif
 
48
 
 
49
/*****************************************************************************
 
50
 * strndup: returns a malloc'd copy of at most n bytes of string
 
51
 * Does anyone know whether or not it will be present in Jaguar?
 
52
 *****************************************************************************/
 
53
#if !defined( HAVE_STRNDUP )
 
54
char *vlc_strndup( const char *string, size_t n )
 
55
{
 
56
    char *psz;
 
57
    size_t len = strlen( string );
 
58
 
 
59
    len = __MIN( len, n );
 
60
    psz = (char*)malloc( len + 1 );
 
61
 
 
62
    if( psz != NULL )
 
63
    {
 
64
        memcpy( (void*)psz, (const void*)string, len );
 
65
        psz[ len ] = 0;
 
66
    }
 
67
 
 
68
    return psz;
 
69
}
 
70
#endif
 
71
 
 
72
/*****************************************************************************
 
73
 * strcasecmp: compare two strings ignoring case
 
74
 *****************************************************************************/
 
75
#if !defined( HAVE_STRCASECMP ) && !defined( HAVE_STRICMP )
 
76
int vlc_strcasecmp( const char *s1, const char *s2 )
 
77
{
 
78
    int i_delta = 0;
 
79
 
 
80
    while( !i_delta && *s1 && *s2 )
 
81
    {
 
82
        i_delta = *s1 - *s2;
 
83
 
 
84
        if( *s1 >= 'A' && *s1 <= 'Z' )
 
85
        {
 
86
            i_delta -= 'A' - 'a';
 
87
        }
 
88
 
 
89
        if( *s2 >= 'A' && *s2 <= 'Z' )
 
90
        {
 
91
            i_delta += 'A' - 'a';
 
92
        }
 
93
 
 
94
        s1++; s2++;
 
95
    }
 
96
 
 
97
    return i_delta;
 
98
}
 
99
#endif
 
100
 
 
101
/*****************************************************************************
 
102
 * strncasecmp: compare n chars from two strings ignoring case
 
103
 *****************************************************************************/
 
104
#if !defined( HAVE_STRNCASECMP ) && !defined( HAVE_STRNICMP )
 
105
int vlc_strncasecmp( const char *s1, const char *s2, size_t n )
 
106
{
 
107
    int i_delta = 0;
 
108
 
 
109
    while( n-- && !i_delta && *s1 )
 
110
    {
 
111
        i_delta = *s1 - *s2;
 
112
 
 
113
        if( *s1 >= 'A' && *s1 <= 'Z' )
 
114
        {
 
115
            i_delta -= 'A' - 'a';
 
116
        }
 
117
 
 
118
        if( *s2 >= 'A' && *s2 <= 'Z' )
 
119
        {
 
120
            i_delta += 'A' - 'a';
 
121
        }
 
122
 
 
123
        s1++; s2++;
 
124
    }
 
125
 
 
126
    return i_delta;
 
127
}
 
128
#endif
 
129
 
 
130
/*****************************************************************************
 
131
 * vasprintf:
 
132
 *****************************************************************************/
 
133
#if !defined(HAVE_VASPRINTF) || defined(SYS_DARWIN) || defined(SYS_BEOS)
 
134
int vlc_vasprintf(char **strp, const char *fmt, va_list ap)
 
135
{
 
136
    /* Guess we need no more than 100 bytes. */
 
137
    int     i_size = 100;
 
138
    char    *p = malloc( i_size );
 
139
    int     n;
 
140
 
 
141
    if( p == NULL )
 
142
    {
 
143
        *strp = NULL;
 
144
        return -1;
 
145
    }
 
146
 
 
147
    for( ;; )
 
148
    {
 
149
        /* Try to print in the allocated space. */
 
150
        n = vsnprintf( p, i_size, fmt, ap );
 
151
 
 
152
        /* If that worked, return the string. */
 
153
        if (n > -1 && n < i_size)
 
154
        {
 
155
            *strp = p;
 
156
            return strlen( p );
 
157
        }
 
158
        /* Else try again with more space. */
 
159
        if (n > -1)    /* glibc 2.1 */
 
160
        {
 
161
           i_size = n+1; /* precisely what is needed */
 
162
        }
 
163
        else           /* glibc 2.0 */
 
164
        {
 
165
           i_size *= 2;  /* twice the old size */
 
166
        }
 
167
        if( (p = realloc( p, i_size ) ) == NULL)
 
168
        {
 
169
            *strp = NULL;
 
170
            return -1;
 
171
        }
 
172
    }
 
173
}
 
174
#endif
 
175
 
 
176
/*****************************************************************************
 
177
 * asprintf:
 
178
 *****************************************************************************/
 
179
#if !defined(HAVE_ASPRINTF) || defined(SYS_DARWIN) || defined(SYS_BEOS)
 
180
int vlc_asprintf( char **strp, const char *fmt, ... )
 
181
{
 
182
    va_list args;
 
183
    int i_ret;
 
184
 
 
185
    va_start( args, fmt );
 
186
    i_ret = vasprintf( strp, fmt, args );
 
187
    va_end( args );
 
188
 
 
189
    return i_ret;
 
190
}
 
191
#endif
 
192
 
 
193
/*****************************************************************************
 
194
 * atof: convert a string to a double.
 
195
 *****************************************************************************/
 
196
#if !defined( HAVE_ATOF )
 
197
double vlc_atof( const char *nptr )
 
198
{
 
199
    double f_result;
 
200
    wchar_t *psz_tmp;
 
201
    int i_len = strlen( nptr ) + 1;
 
202
 
 
203
    psz_tmp = malloc( i_len * sizeof(wchar_t) );
 
204
    MultiByteToWideChar( CP_ACP, 0, nptr, -1, psz_tmp, i_len );
 
205
    f_result = wcstod( psz_tmp, NULL );
 
206
    free( psz_tmp );
 
207
 
 
208
    return f_result;
 
209
}
 
210
#endif
 
211
 
 
212
/*****************************************************************************
 
213
 * atoll: convert a string to a 64 bits int.
 
214
 *****************************************************************************/
 
215
#if !defined( HAVE_ATOLL )
 
216
int64_t vlc_atoll( const char *str )
 
217
{
 
218
    int64_t i_value = 0;
 
219
    int sign = 1;
 
220
 
 
221
    if( *str == '-' )
 
222
    {
 
223
        sign = -1;
 
224
    }
 
225
 
 
226
    while( *str >= '0' && *str <= '9' )
 
227
    {
 
228
        i_value = i_value * 10 + ( *str++ - '0' );
 
229
    }
 
230
 
 
231
    return i_value * sign;
 
232
}
 
233
#endif
 
234
 
 
235
/*****************************************************************************
 
236
 * lseek: reposition read/write file offset.
 
237
 *****************************************************************************
 
238
 * FIXME: this cast sucks!
 
239
 *****************************************************************************/
 
240
#if !defined( HAVE_LSEEK )
 
241
off_t vlc_lseek( int fildes, off_t offset, int whence )
 
242
{
 
243
    return SetFilePointer( (HANDLE)fildes, (long)offset, NULL, whence );
 
244
}
 
245
#endif
 
246
 
 
247
/*****************************************************************************
 
248
 * dgettext: gettext for plugins.
 
249
 *****************************************************************************/
 
250
char *vlc_dgettext( const char *package, const char *msgid )
 
251
{
 
252
#if defined( ENABLE_NLS ) \
 
253
     && ( defined(HAVE_GETTEXT) || defined(HAVE_INCLUDED_GETTEXT) )
 
254
    return dgettext( package, msgid );
 
255
#else
 
256
    return (char *)msgid;
 
257
#endif
 
258
}
 
259
 
 
260
/*****************************************************************************
 
261
 * count_utf8_string: returns the number of characters in the string.
 
262
 *****************************************************************************/
 
263
static int count_utf8_string( const char *psz_string )
 
264
{
 
265
    int i = 0, i_count = 0;
 
266
    while( psz_string[ i ] != 0 )
 
267
    {
 
268
        if( ((unsigned char *)psz_string)[ i ] <  0x80UL ) i_count++;
 
269
        i++;
 
270
    }
 
271
    return i_count;
 
272
}
 
273
 
 
274
/*****************************************************************************
 
275
 * wraptext: inserts \n at convenient places to wrap the text.
 
276
 *           Returns the modified string in a new buffer.
 
277
 *****************************************************************************/
 
278
char *vlc_wraptext( const char *psz_text, int i_line, vlc_bool_t b_utf8 )
 
279
{
 
280
    int i_len;
 
281
    char *psz_line, *psz_new_text;
 
282
 
 
283
    psz_line = psz_new_text = strdup( psz_text );
 
284
 
 
285
    if( b_utf8 )
 
286
        i_len = count_utf8_string( psz_text );
 
287
    else
 
288
        i_len = strlen( psz_text );
 
289
 
 
290
    while( i_len > i_line )
 
291
    {
 
292
        /* Look if there is a newline somewhere. */
 
293
        char *psz_parser = psz_line;
 
294
        int i_count = 0;
 
295
        while( i_count <= i_line && *psz_parser != '\n' )
 
296
        {
 
297
            if( b_utf8 )
 
298
            {
 
299
                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
 
300
            }
 
301
            psz_parser++;
 
302
            i_count++;
 
303
        }
 
304
        if( *psz_parser == '\n' )
 
305
        {
 
306
            i_len -= (i_count + 1);
 
307
            psz_line = psz_parser + 1;
 
308
            continue;
 
309
        }
 
310
 
 
311
        /* Find the furthest space. */
 
312
        while( psz_parser > psz_line && *psz_parser != ' ' )
 
313
        {
 
314
            if( b_utf8 )
 
315
            {
 
316
                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser--;
 
317
            }
 
318
            psz_parser--;
 
319
            i_count--;
 
320
        }
 
321
        if( *psz_parser == ' ' )
 
322
        {
 
323
            *psz_parser = '\n';
 
324
            i_len -= (i_count + 1);
 
325
            psz_line = psz_parser + 1;
 
326
            continue;
 
327
        }
 
328
 
 
329
        /* Wrapping has failed. Find the first space or newline */
 
330
        while( i_count < i_len && *psz_parser != ' ' && *psz_parser != '\n' )
 
331
        {
 
332
            if( b_utf8 )
 
333
            {
 
334
                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
 
335
            }
 
336
            psz_parser++;
 
337
            i_count++;
 
338
        }
 
339
        if( i_count < i_len ) *psz_parser = '\n';
 
340
        i_len -= (i_count + 1);
 
341
        psz_line = psz_parser + 1;
 
342
    }
 
343
 
 
344
    return psz_new_text;
 
345
}