Return to stdlib.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / include

Annotation of qemu/roms/ipxe/src/include/stdlib.h, revision 1.1.1.1

1.1       root        1: #ifndef STDLIB_H
                      2: #define STDLIB_H
                      3: 
                      4: FILE_LICENCE ( GPL2_OR_LATER );
                      5: 
                      6: #include <stdint.h>
                      7: #include <assert.h>
                      8: #include <ctype.h>
                      9: 
                     10: /*****************************************************************************
                     11:  *
                     12:  * Numeric parsing
                     13:  *
                     14:  ****************************************************************************
                     15:  */
                     16: 
                     17: static inline int strtoul_base ( const char **pp, int base )
                     18: {
                     19:        const char *p = *pp;
                     20: 
                     21:        while ( isspace ( *p ) )
                     22:                p++;
                     23: 
                     24:        if ( base == 0 ) {
                     25:                base = 10;
                     26:                if ( *p == '0' ) {
                     27:                        p++;
                     28:                        base = 8;
                     29:                        if ( ( *p | 0x20 ) == 'x' ) {
                     30:                                p++;
                     31:                                base = 16;
                     32:                        }
                     33:                }
                     34:        }
                     35: 
                     36:        *pp = p;
                     37: 
                     38:        return base;
                     39: }
                     40: 
                     41: static inline unsigned int strtoul_charval ( unsigned int charval )
                     42: {
                     43:        if ( charval >= 'a' ) {
                     44:                charval = ( charval - 'a' + 10 );
                     45:        } else if ( charval >= 'A' ) {
                     46:                charval = ( charval - 'A' + 10 );
                     47:        } else if ( charval <= '9' ) {
                     48:                charval = ( charval - '0' );
                     49:        }
                     50: 
                     51:        return charval;
                     52: }
                     53: 
                     54: extern unsigned long strtoul ( const char *p, char **endp, int base );
                     55: extern unsigned long long strtoull ( const char *p, char **endp, int base );
                     56: 
                     57: 
                     58: /*****************************************************************************
                     59:  *
                     60:  * Memory allocation
                     61:  *
                     62:  ****************************************************************************
                     63:  */
                     64: 
                     65: extern void * __malloc malloc ( size_t size );
                     66: extern void * realloc ( void *old_ptr, size_t new_size );
                     67: extern void free ( void *ptr );
                     68: extern void * __malloc zalloc ( size_t len );
                     69: 
                     70: /**
                     71:  * Allocate cleared memory
                     72:  *
                     73:  * @v nmemb            Number of members
                     74:  * @v size             Size of each member
                     75:  * @ret ptr            Allocated memory
                     76:  *
                     77:  * Allocate memory as per malloc(), and zero it.
                     78:  *
                     79:  * This is implemented as a static inline, with the body of the
                     80:  * function in zalloc(), since in most cases @c nmemb will be 1 and
                     81:  * doing the multiply is just wasteful.
                     82:  */
                     83: static inline void * __malloc calloc ( size_t nmemb, size_t size ) {
                     84:        return zalloc ( nmemb * size );
                     85: }
                     86: 
                     87: /*****************************************************************************
                     88:  *
                     89:  * Random number generation
                     90:  *
                     91:  ****************************************************************************
                     92:  */
                     93: 
                     94: extern long int random ( void );
                     95: extern void srandom ( unsigned int seed );
                     96: 
                     97: static inline int rand ( void ) {
                     98:        return random();
                     99: }
                    100: 
                    101: static inline void srand ( unsigned int seed ) {
                    102:        srandom ( seed );
                    103: }
                    104: 
                    105: /*****************************************************************************
                    106:  *
                    107:  * Miscellaneous
                    108:  *
                    109:  ****************************************************************************
                    110:  */
                    111: 
                    112: extern int system ( const char *command );
                    113: extern __asmcall int main ( void );
                    114: 
                    115: #endif /* STDLIB_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.