1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* Copyright (C) 2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
*/
#ifndef _ANDROID_UTILS_SYSTEM_H
#define _ANDROID_UTILS_SYSTEM_H
#include <string.h>
#include <stdint.h>
#include <inttypes.h> /* for PRId64 et al. */
#include "android/utils/assert.h"
/* internal helpers */
void* _android_array_alloc( size_t itemSize, size_t count );
void* _android_array_alloc0( size_t itemSize, size_t count );
void* _android_array_realloc( void* block, size_t itemSize, size_t count );
/* the following functions perform 'checked allocations', i.e.
* they abort if there is not enough memory.
*/
/* checked malloc, only returns NULL if size is 0 */
void* android_alloc( size_t size );
/* checked calloc, only returns NULL if size is 0 */
void* android_alloc0( size_t size );
/* checked realloc, only returns NULL if size if 0 */
void* android_realloc( void* block, size_t size );
/* free memory block */
void android_free( void* block );
/* convenience macros */
#define AZERO(p) memset((char*)(p),0,sizeof(*(p)))
#define ANEW(p) (p = android_alloc(sizeof(*p)))
#define ANEW0(p) (p = android_alloc0(sizeof(*p)))
#define AFREE(p) android_free(p)
#define AMEM_ZERO(dst,size) memset((char*)(dst), 0, (size_t)(size))
#define AMEM_COPY(dst,src,size) memcpy((char*)(dst),(const char*)(src),(size_t)(size))
#define AMEM_MOVE(dst,src,size) memmove((char*)(dst),(const char*)(src),(size_t)(size))
#define AARRAY_NEW(p,count) (AASSERT_LOC(), (p) = _android_array_alloc(sizeof(*p),(count)))
#define AARRAY_NEW0(p,count) (AASSERT_LOC(), (p) = _android_array_alloc0(sizeof(*p),(count)))
#define AARRAY_RENEW(p,count) (AASSERT_LOC(), (p) = _android_array_realloc((p),sizeof(*(p)),(count)))
#define AARRAY_COPY(dst,src,count) AMEM_COPY(dst,src,(count)*sizeof((dst)[0]))
#define AARRAY_MOVE(dst,src,count) AMEM_MOVE(dst,src,(count)*sizeof((dst)[0]))
#define AARRAY_ZERO(dst,count) AMEM_ZERO(dst,(count)*sizeof((dst)[0]))
#define AARRAY_STATIC_LEN(a) (sizeof((a))/sizeof((a)[0]))
#define AINLINED static __inline__
/* unlike strdup(), this accepts NULL as valid input (and will return NULL then) */
char* android_strdup(const char* src);
#define ASTRDUP(str) android_strdup(str)
/* used for functions that return a Posix-style status code, i.e.
* 0 means success, -1 means failure with the error code in 'errno'
*/
typedef int APosixStatus;
/* used for functions that return or accept a boolean type */
typedef int ABool;
/** Stringification macro
**/
#ifndef STRINGIFY
#define _STRINGIFY(x) #x
#define STRINGIFY(x) _STRINGIFY(x)
#endif
/** Concatenation macros
**/
#ifndef GLUE
#define _GLUE(x,y) x##y
#define GLUE(x,y) _GLUE(x,y)
#define _GLUE3(x,y,z) x##y##z
#define GLUE3(x,y,z) _GLUE3(x,y,z)
#endif
/** Handle strsep() on Win32
**/
#ifdef _WIN32
# undef strsep
# define strsep win32_strsep
extern char* win32_strsep(char** pline, const char* delim);
#endif
/** Handle strcasecmp on Windows
**/
#ifdef _WIN32
# define strcasecmp stricmp
#endif
/** EINTR HANDLING
**
** since QEMU uses SIGALRM pretty extensively, having a system call returning
** EINTR on Unix happens very frequently. provide a simple macro to guard against
** this.
**/
#ifdef _WIN32
# define CHECKED(ret, call) (ret) = (call)
#else
# define CHECKED(ret, call) do { (ret) = (call); } while ((ret) < 0 && errno == EINTR)
#endif
/** SIGNAL HANDLING
**
** the following can be used to block SIGALRM for a given period of time.
** use with caution, the QEMU execution loop uses SIGALRM extensively
**
**/
#ifdef _WIN32
typedef struct { int dumy; } signal_state_t;
#else
#include <signal.h>
typedef struct { sigset_t old; } signal_state_t;
#endif
extern void disable_sigalrm( signal_state_t *state );
extern void restore_sigalrm( signal_state_t *state );
#ifdef _WIN32
#define BEGIN_NOSIGALRM \
{
#define END_NOSIGALRM \
}
#else /* !WIN32 */
#define BEGIN_NOSIGALRM \
{ signal_state_t __sigalrm_state; \
disable_sigalrm( &__sigalrm_state );
#define END_NOSIGALRM \
restore_sigalrm( &__sigalrm_state ); \
}
#endif /* !WIN32 */
/** TIME HANDLING
**
** sleep for a given time in milliseconds. note: this uses
** disable_sigalrm()/restore_sigalrm()
**/
extern void sleep_ms( int timeout );
/** FORMATTING int64_t in printf() statements
**
** Normally defined in <inttypes.h> except on Windows and maybe others.
**/
#ifndef PRId64
# define PRId64 "lld"
#endif
#ifndef PRIx64
# define PRIx64 "llx"
#endif
#ifndef PRUd64
# define PRUd64 "llu"
#endif
#ifndef PRUx64
# define PRUx64 "llx"
#endif
/* */
#endif /* _ANDROID_UTILS_SYSTEM_H */
|
