OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [ColdFire_MCF52221_CodeWarrior/] [sources/] [stdlib.c] - Blame information for rev 578

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 jeremybenn
/* FILENAME: stdlib.c
2
 *
3
 * Functions normally found in a standard C lib.
4
 *
5
 * 12/28/2005 - added memcmp and memmove
6
 *
7
 * Notes: These functions support ASCII only!!!
8
 */
9
 
10
#include "support_common.h"
11
#include "stdlib.h"
12
 
13
/***********************************************************************/
14
/*
15
 * Misc. Defines
16
 */
17
#ifdef  FALSE
18
#undef  FALSE
19
#endif
20
#define FALSE   (0)
21
 
22
#ifdef  TRUE
23
#undef  TRUE
24
#endif
25
#define TRUE    (1)
26
 
27
#ifdef  NULL
28
#undef  NULL
29
#endif
30
#define NULL    (0)
31
 
32
#ifdef  ON
33
#undef  ON
34
#endif
35
#define ON      (1)
36
 
37
#ifdef  OFF
38
#undef  OFF
39
#endif
40
#define OFF     (0)
41
 
42
 
43
/****************************************************************/
44
int
45
isspace (int ch)
46
{
47
        if ((ch == ' ') || (ch == '\t'))        /* \n ??? */
48
                return TRUE;
49
        else
50
                return FALSE;
51
}
52
 
53
/****************************************************************/
54
int
55
isalnum (int ch)
56
{
57
        /* ASCII only */
58
        if (((ch >= '0') && (ch <= '9')) ||
59
                ((ch >= 'A') && (ch <= 'Z')) ||
60
                ((ch >= 'a') && (ch <= 'z')))
61
                return TRUE;
62
        else
63
                return FALSE;
64
}
65
 
66
/****************************************************************/
67
int
68
isdigit (int ch)
69
{
70
        /* ASCII only */
71
        if ((ch >= '0') && (ch <= '9'))
72
                return TRUE;
73
        else
74
                return FALSE;
75
}
76
 
77
/****************************************************************/
78
int
79
isupper (int ch)
80
{
81
        /* ASCII only */
82
        if ((ch >= 'A') && (ch <= 'Z'))
83
                return TRUE;
84
        else
85
                return FALSE;
86
}
87
 
88
/****************************************************************/
89
int
90
strcasecmp (const char *s1, const char *s2)
91
{
92
        char    c1, c2;
93
        int             result = 0;
94
 
95
        while (result == 0)
96
        {
97
                c1 = *s1++;
98
                c2 = *s2++;
99
                if ((c1 >= 'a') && (c1 <= 'z'))
100
                        c1 = (char)(c1 - ' ');
101
                if ((c2 >= 'a') && (c2 <= 'z'))
102
                        c2 = (char)(c2 - ' ');
103
                if ((result = (c1 - c2)) != 0)
104
                        break;
105
                if ((c1 == 0) || (c2 == 0))
106
                        break;
107
        }
108
        return result;
109
}
110
 
111
 
112
/****************************************************************/
113
int
114
stricmp (const char *s1, const char *s2)
115
{
116
   return (strcasecmp(s1, s2));
117
}
118
 
119
/****************************************************************/
120
int
121
strncasecmp (const char *s1, const char *s2, int n)
122
{
123
        char    c1, c2;
124
        int             k = 0;
125
        int             result = 0;
126
 
127
        while ( k++ < n )
128
        {
129
                c1 = *s1++;
130
                c2 = *s2++;
131
                if ((c1 >= 'a') && (c1 <= 'z'))
132
                        c1 = (char)(c1 - ' ');
133
                if ((c2 >= 'a') && (c2 <= 'z'))
134
                        c2 = (char)(c2 - ' ');
135
                if ((result = (c1 - c2)) != 0)
136
                        break;
137
                if ((c1 == 0) || (c2 == 0))
138
                        break;
139
        }
140
        return result;
141
}
142
 
143
/****************************************************************/
144
int
145
strnicmp (const char *s1, const char *s2, int n)
146
{
147
   return (strncasecmp(s1, s2, n));
148
}
149
 
150
/****************************************************************/
151
uint32
152
strtoul (char *str, char **ptr, int base)
153
{
154
   unsigned long rvalue = 0;
155
   int neg = 0;
156
   int c;
157
 
158
   /* Validate parameters */
159
   if ((str != NULL) && (base >= 0) && (base <= 36))
160
   {
161
      /* Skip leading white spaces */
162
      while (isspace(*str))
163
      {
164
         ++str;
165
        }
166
 
167
        /* Check for notations */
168
       switch (str[0])
169
        {
170
                case '0':
171
          if (base == 0)
172
          {
173
             if ((str[1] == 'x') || (str[1] == 'X'))
174
                                {
175
                                        base = 16;
176
                str += 2;
177
             }
178
             else
179
             {
180
                base = 8;
181
                str++;
182
                                }
183
                        }
184
                        break;
185
 
186
                case '-':
187
                        neg = 1;
188
          str++;
189
          break;
190
 
191
       case '+':
192
          str++;
193
                        break;
194
 
195
                default:
196
                        break;
197
        }
198
 
199
        if (base == 0)
200
                base = 10;
201
 
202
      /* Valid "digits" are 0..9, A..Z, a..z */
203
      while (isalnum(c = *str))
204
      {
205
                /* Convert char to num in 0..36 */
206
         if ((c -= ('a' - 10)) < 10)         /* 'a'..'z' */
207
         {
208
            if ((c += ('a' - 'A')) < 10)     /* 'A'..'Z' */
209
            {
210
               c += ('A' - '0' - 10);        /* '0'..'9' */
211
                        }
212
                }
213
 
214
                /* check c against base */
215
                if (c >= base)
216
                {
217
                        break;
218
                }
219
 
220
                if (neg)
221
                {
222
                        rvalue = (rvalue * base) - c;
223
                }
224
                else
225
                {
226
                        rvalue = (rvalue * base) + c;
227
         }
228
 
229
         ++str;
230
                }
231
        }
232
 
233
   /* Upon exit, 'str' points to the character at which valid info */
234
   /* STOPS.  No chars including and beyond 'str' are used.        */
235
 
236
        if (ptr != NULL)
237
                        *ptr = str;
238
 
239
                return rvalue;
240
        }
241
 
242
/****************************************************************/
243
int
244
atoi (const char *str)
245
{
246
   char *s = (char *)str;
247
 
248
   return ((int)strtoul(s, NULL, 10));
249
}
250
 
251
/****************************************************************/
252
int
253
strlen (const char *str)
254
{
255
        char *s = (char *)str;
256
        int len = 0;
257
 
258
        if (s == NULL)
259
                return 0;
260
 
261
        while (*s++ != '\0')
262
                ++len;
263
 
264
        return len;
265
}
266
 
267
/****************************************************************/
268
char *
269
strcat (char *dest, const char *src)
270
{
271
        char *dp;
272
        char *sp = (char *)src;
273
 
274
        if ((dest != NULL) && (src != NULL))
275
        {
276
                dp = &dest[strlen(dest)];
277
 
278
                while (*sp != '\0')
279
                {
280
                        *dp++ = *sp++;
281
                }
282
                *dp = '\0';
283
        }
284
        return dest;
285
}
286
 
287
/****************************************************************/
288
char *
289
strncat (char *dest, const char *src, int n)
290
{
291
        char *dp;
292
        char *sp = (char *)src;
293
 
294
        if ((dest != NULL) && (src != NULL) && (n > 0))
295
        {
296
                dp = &dest[strlen(dest)];
297
 
298
                while ((*sp != '\0') && (n-- > 0))
299
                {
300
                        *dp++ = *sp++;
301
                }
302
                *dp = '\0';
303
        }
304
        return dest;
305
}
306
 
307
/****************************************************************/
308
char *
309
strcpy (char *dest, const char *src)
310
{
311
        char *dp = (char *)dest;
312
        char *sp = (char *)src;
313
 
314
        if ((dest != NULL) && (src != NULL))
315
        {
316
                while (*sp != '\0')
317
                {
318
                        *dp++ = *sp++;
319
                }
320
                *dp = '\0';
321
        }
322
        return dest;
323
}
324
 
325
/****************************************************************/
326
char *
327
strncpy (char *dest, const char *src, int n)
328
{
329
        char *dp = (char *)dest;
330
        char *sp = (char *)src;
331
 
332
        if ((dest != NULL) && (src != NULL) && (n > 0))
333
        {
334
                while ((*sp != '\0') && (n-- > 0))
335
                {
336
                        *dp++ = *sp++;
337
                }
338
                *dp = '\0';
339
        }
340
        return dest;
341
}
342
 
343
/****************************************************************/
344
int
345
strcmp (const char *s1, const char *s2)
346
{
347
        /* No checks for NULL */
348
        char *s1p = (char *)s1;
349
        char *s2p = (char *)s2;
350
 
351
        while (*s2p != '\0')
352
        {
353
                if (*s1p != *s2p)
354
                        break;
355
 
356
                ++s1p;
357
                ++s2p;
358
        }
359
        return (*s1p - *s2p);
360
}
361
 
362
/****************************************************************/
363
int
364
strncmp (const char *s1, const char *s2, int n)
365
{
366
        /* No checks for NULL */
367
        char *s1p = (char *)s1;
368
        char *s2p = (char *)s2;
369
 
370
        if (n <= 0)
371
                return 0;
372
 
373
        while (*s2p != '\0')
374
        {
375
                if (*s1p != *s2p)
376
                        break;
377
 
378
                if (--n == 0)
379
                        break;
380
 
381
                ++s1p;
382
                ++s2p;
383
        }
384
        return (*s1p - *s2p);
385
}
386
 
387
/****************************************************************/
388
char *
389
strstr(const char *s1, const char *s2)
390
{
391
   char *sp = (char *)s1;
392
   int  len1 = strlen(s1);
393
   int  len2 = strlen(s2);
394
 
395
   while (len1 >= len2)
396
   {
397
      if (strncmp(sp, s2, len2) == 0)
398
      {
399
         return (sp);
400
      }
401
      ++sp;
402
      --len1;
403
   }
404
 
405
   return (NULL);
406
}
407
 
408
/****************************************************************/
409
char *
410
strchr(const char *str, int c)
411
{
412
   char *sp = (char *)str;
413
   char  ch = (char)(c & 0xff);
414
 
415
   while (*sp != '\0')
416
   {
417
      if (*sp == ch)
418
      {
419
         return (sp);
420
      }
421
      ++sp;
422
   }
423
 
424
   return (NULL);
425
}
426
 
427
/****************************************************************/
428
void *
429
memcpy (void *dest, const void *src, unsigned n)
430
{
431
        unsigned char *dbp = (unsigned char *)dest;
432
        unsigned char *sbp = (unsigned char *)src;
433
 
434
        if ((dest != NULL) && (src != NULL) && (n > 0))
435
        {
436
      while (n--)
437
                        *dbp++ = *sbp++;
438
        }
439
        return dest;
440
}
441
 
442
/****************************************************************/
443
void *
444
memset (void *s, int c, unsigned n)
445
{
446
        /* Not optimized, but very portable */
447
        unsigned char *sp = (unsigned char *)s;
448
 
449
        if ((s != NULL) && (n > 0))
450
        {
451
                while (n--)
452
                {
453
                        *sp++ = (unsigned char)c;
454
                }
455
        }
456
        return s;
457
}
458
 
459
/****************************************************************/
460
int
461
memcmp (const void *s1, const void *s2, unsigned n)
462
{
463
   unsigned char *s1p, *s2p;
464
 
465
   if (s1 && s2 && (n > 0))
466
   {
467
      s1p = (unsigned char *)s1;
468
      s2p = (unsigned char *)s2;
469
 
470
      while ((--n >= 0) && (*s1p == *s2p))
471
      {
472
         if (*s1p != *s2p)
473
            return (*s1p - *s2p);
474
         ++s1p;
475
         ++s2p;
476
      }
477
   }
478
 
479
   return (0);
480
}
481
 
482
/****************************************************************/
483
void *
484
memmove (void *dest, const void *src, unsigned n)
485
{
486
   unsigned char *dbp = (unsigned char *)dest;
487
   unsigned char *sbp = (unsigned char *)src;
488
   unsigned char *dend = dbp + n;
489
   unsigned char *send = sbp + n;
490
 
491
   if ((dest != NULL) && (src != NULL) && (n > 0))
492
   {
493
      /* see if a memcpy would overwrite source buffer */
494
      if ((sbp < dbp) && (dbp < send))
495
      {
496
         while (n--)
497
            *(--dend) = *(--send);
498
      }
499
      else
500
      {
501
         while (n--)
502
            *dbp++ = *sbp++;
503
      }
504
   }
505
 
506
   return dest;
507
}
508
 
509
/****************************************************************/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.