Home | History | Annotate | Download | only in utils 
      1 /* Copyright (C) 2008 The Android Open Source Project
      2 **
      3 ** This software is licensed under the terms of the GNU General Public
      4 ** License version 2, as published by the Free Software Foundation, and
      5 ** may be copied, distributed, and modified under those terms.
      6 **
      7 ** This program is distributed in the hope that it will be useful,
      8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
      9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     10 ** GNU General Public License for more details.
     11 */
     12 #include "android/utils/system.h"
     13 #include "android/utils/assert.h"
     14 #include <stdlib.h>
     15 #include <stdio.h>
     16 #ifdef _WIN32
     17 #  define WIN32_LEAN_AND_MEAN
     18 #  include <windows.h>  /* for Sleep */
     19 #else
     20 #  include <unistd.h>  /* for usleep */
     21 #endif
     22 
     23 void*
     24 android_alloc( size_t  size )
     25 {
     26     void*   block;
     27 
     28     if (size == 0)
     29         return NULL;
     30 
     31     block = malloc(size);
     32     if (block != NULL)
     33         return block;
     34 
     35     fprintf(stderr, "PANIC: not enough memory\n");
     36     exit(1);
     37     return NULL;
     38 }
     39 
     40 void*
     41 android_alloc0( size_t  size )
     42 {
     43     void*   block;
     44 
     45     if (size == 0)
     46         return NULL;
     47 
     48     block = calloc(1, size);
     49     if (block != NULL)
     50         return block;
     51 
     52     fprintf(stderr, "PANIC: not enough memory\n");
     53     exit(1);
     54     return NULL;
     55 }
     56 
     57 void*
     58 android_realloc( void*  block, size_t  size )
     59 {
     60     void*   block2;
     61 
     62     if (size == 0) {
     63         free(block);
     64         return NULL;
     65     }
     66     block2 = realloc(block, size);
     67     if (block2 != NULL)
     68         return block2;
     69 
     70     fprintf(stderr, "PANIC: not enough memory to reallocate %u bytes\n",
     71             (unsigned)size);
     72     exit(1);
     73     return NULL;
     74 }
     75 
     76 void
     77 android_free( void*  block )
     78 {
     79     if (block)
     80         free(block);
     81 }
     82 
     83 void*
     84 _android_array_alloc( size_t  itemSize, size_t  count )
     85 {
     86 #if ACONFIG_USE_ASSERT
     87     size_t  maxSize;
     88 
     89     if (itemSize == 0)
     90         AASSERT_FAIL("item size is 0\n");
     91 
     92     maxSize = (~(size_t)0) / itemSize;
     93     if (count > maxSize)
     94         AASSERT_FAIL("allocation too large (%d > %d)\n", count, maxSize);
     95 #endif
     96     return android_alloc(itemSize * count);
     97 }
     98 
     99 void*
    100 _android_array_alloc0( size_t  itemSize, size_t  count )
    101 {
    102     void*  block = _android_array_alloc(itemSize, count);
    103     memset(block, 0, itemSize*count);
    104     return block;
    105 }
    106 
    107 void*
    108 _android_array_realloc( void* block, size_t  itemSize, size_t  count )
    109 {
    110 #if ACONFIG_USE_ASSERT
    111     size_t  maxSize;
    112 
    113     if (itemSize == 0)
    114         AASSERT_FAIL("item size is 0\n");
    115 
    116     maxSize = (~(size_t)0) / itemSize;
    117     if (count > maxSize)
    118         AASSERT_FAIL("reallocation of %d-bytes array too large (%d > %d)\n",
    119                      itemSize, count, maxSize);
    120 #endif
    121     return android_realloc(block, itemSize*count);
    122 }
    123 
    124 char*
    125 android_strdup( const char*  str )
    126 {
    127     int    len;
    128     char*  copy;
    129 
    130     if (str == NULL)
    131         return NULL;
    132 
    133     len  = strlen(str);
    134     copy = malloc(len+1);
    135     memcpy(copy, str, len);
    136     copy[len] = 0;
    137 
    138     return copy;
    139 }
    140 
    141 #ifdef _WIN32
    142 char*
    143 win32_strsep(char**  pline, const char*  delim)
    144 {
    145     char*  line = *pline;
    146     char*  p    = line;
    147 
    148     if (p == NULL)
    149         return NULL;
    150 
    151     for (;;) {
    152         int          c = *p++;
    153         const char*  q = delim;
    154 
    155         if (c == 0) {
    156             p = NULL;
    157             break;
    158         }
    159 
    160         while (*q) {
    161             if (*q == c) {
    162                 p[-1] = 0;
    163                 goto Exit;
    164             }
    165             q++;
    166         }
    167     }
    168 Exit:
    169     *pline = p;
    170     return line;
    171 }
    172 #endif
    173 
    174 
    175 void
    176 disable_sigalrm( signal_state_t  *state )
    177 {
    178 #ifdef _WIN32
    179     (void)state;
    180 #else
    181     sigset_t  set;
    182 
    183     sigemptyset(&set);
    184     sigaddset(&set, SIGALRM);
    185     pthread_sigmask (SIG_BLOCK, &set, &state->old);
    186 #endif
    187 }
    188 
    189 void
    190 restore_sigalrm( signal_state_t  *state )
    191 {
    192 #ifdef _WIN32
    193     (void)state;
    194 #else
    195     pthread_sigmask (SIG_SETMASK, &state->old, NULL);
    196 #endif
    197 }
    198 
    199 void
    200 sleep_ms( int  timeout_ms )
    201 {
    202 #ifdef _WIN32
    203     if (timeout_ms <= 0)
    204         return;
    205 
    206     Sleep( timeout_ms );
    207 #else
    208     if (timeout_ms <= 0)
    209         return;
    210 
    211     BEGIN_NOSIGALRM
    212     usleep( timeout_ms*1000 );
    213     END_NOSIGALRM
    214 #endif
    215 }
    216