summaryrefslogtreecommitdiff
path: root/src/stdlib
diff options
context:
space:
mode:
authorSam Lantinga <slouken@libsdl.org>2006-07-10 21:04:37 +0000
committerSam Lantinga <slouken@libsdl.org>2006-07-10 21:04:37 +0000
commit0f030a1802c6205f4782adf086fcc6ad416aa52a (patch)
treed6fe19c1f8605151b3b800a9158e26f979b96563 /src/stdlib
parent91a32b77a24e61974f415d0c9d7aee208c29b2b5 (diff)
SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
--HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401938
Diffstat (limited to 'src/stdlib')
-rw-r--r--src/stdlib/SDL_getenv.c370
-rw-r--r--src/stdlib/SDL_iconv.c1485
-rw-r--r--src/stdlib/SDL_malloc.c4116
-rw-r--r--src/stdlib/SDL_qsort.c290
-rw-r--r--src/stdlib/SDL_stdlib.c1054
-rw-r--r--src/stdlib/SDL_string.c1005
6 files changed, 4304 insertions, 4016 deletions
diff --git a/src/stdlib/SDL_getenv.c b/src/stdlib/SDL_getenv.c
index 74116cc9..c06af7fc 100644
--- a/src/stdlib/SDL_getenv.c
+++ b/src/stdlib/SDL_getenv.c
@@ -32,143 +32,148 @@
/* Note this isn't thread-safe! */
-static char *SDL_envmem = NULL; /* Ugh, memory leak */
+static char *SDL_envmem = NULL; /* Ugh, memory leak */
static size_t SDL_envmemlen = 0;
/* Put a variable of the form "name=value" into the environment */
-int SDL_putenv(const char *variable)
+int
+SDL_putenv(const char *variable)
{
- size_t bufferlen;
- char *value;
- const char *sep;
-
- sep = SDL_strchr(variable, '=');
- if ( sep == NULL ) {
- return -1;
- }
- bufferlen = SDL_strlen(variable)+1;
- if ( bufferlen > SDL_envmemlen ) {
- char *newmem = (char *)SDL_realloc(SDL_envmem, bufferlen);
- if ( newmem == NULL ) {
- return -1;
- }
- SDL_envmem = newmem;
- SDL_envmemlen = bufferlen;
- }
- SDL_strlcpy(SDL_envmem, variable, bufferlen);
- value = SDL_envmem + (sep - variable);
- *value++ = '\0';
- if ( !SetEnvironmentVariable(SDL_envmem, *value ? value : NULL) ) {
- return -1;
- }
- return 0;
+ size_t bufferlen;
+ char *value;
+ const char *sep;
+
+ sep = SDL_strchr(variable, '=');
+ if (sep == NULL) {
+ return -1;
+ }
+ bufferlen = SDL_strlen(variable) + 1;
+ if (bufferlen > SDL_envmemlen) {
+ char *newmem = (char *) SDL_realloc(SDL_envmem, bufferlen);
+ if (newmem == NULL) {
+ return -1;
+ }
+ SDL_envmem = newmem;
+ SDL_envmemlen = bufferlen;
+ }
+ SDL_strlcpy(SDL_envmem, variable, bufferlen);
+ value = SDL_envmem + (sep - variable);
+ *value++ = '\0';
+ if (!SetEnvironmentVariable(SDL_envmem, *value ? value : NULL)) {
+ return -1;
+ }
+ return 0;
}
/* Retrieve a variable named "name" from the environment */
-char *SDL_getenv(const char *name)
+char *
+SDL_getenv(const char *name)
{
- size_t bufferlen;
-
- bufferlen = GetEnvironmentVariable(name, SDL_envmem, (DWORD)SDL_envmemlen);
- if ( bufferlen == 0 ) {
- return NULL;
- }
- if ( bufferlen > SDL_envmemlen ) {
- char *newmem = (char *)SDL_realloc(SDL_envmem, bufferlen);
- if ( newmem == NULL ) {
- return NULL;
- }
- SDL_envmem = newmem;
- SDL_envmemlen = bufferlen;
- GetEnvironmentVariable(name, SDL_envmem, (DWORD)SDL_envmemlen);
- }
- return SDL_envmem;
+ size_t bufferlen;
+
+ bufferlen =
+ GetEnvironmentVariable(name, SDL_envmem, (DWORD) SDL_envmemlen);
+ if (bufferlen == 0) {
+ return NULL;
+ }
+ if (bufferlen > SDL_envmemlen) {
+ char *newmem = (char *) SDL_realloc(SDL_envmem, bufferlen);
+ if (newmem == NULL) {
+ return NULL;
+ }
+ SDL_envmem = newmem;
+ SDL_envmemlen = bufferlen;
+ GetEnvironmentVariable(name, SDL_envmem, (DWORD) SDL_envmemlen);
+ }
+ return SDL_envmem;
}
#else /* roll our own */
-static char **SDL_env = (char **)0;
+static char **SDL_env = (char **) 0;
/* Put a variable of the form "name=value" into the environment */
-int SDL_putenv(const char *variable)
+int
+SDL_putenv(const char *variable)
{
- const char *name, *value;
- int added;
- int len, i;
- char **new_env;
- char *new_variable;
-
- /* A little error checking */
- if ( ! variable ) {
- return(-1);
- }
- name = variable;
- for ( value=variable; *value && (*value != '='); ++value ) {
- /* Keep looking for '=' */ ;
- }
- if ( *value ) {
- ++value;
- } else {
- return(-1);
- }
-
- /* Allocate memory for the variable */
- new_variable = SDL_strdup(variable);
- if ( ! new_variable ) {
- return(-1);
- }
-
- /* Actually put it into the environment */
- added = 0;
- i = 0;
- if ( SDL_env ) {
- /* Check to see if it's already there... */
- len = (value - name);
- for ( ; SDL_env[i]; ++i ) {
- if ( SDL_strncmp(SDL_env[i], name, len) == 0 ) {
- break;
- }
- }
- /* If we found it, just replace the entry */
- if ( SDL_env[i] ) {
- SDL_free(SDL_env[i]);
- SDL_env[i] = new_variable;
- added = 1;
- }
- }
-
- /* Didn't find it in the environment, expand and add */
- if ( ! added ) {
- new_env = SDL_realloc(SDL_env, (i+2)*sizeof(char *));
- if ( new_env ) {
- SDL_env = new_env;
- SDL_env[i++] = new_variable;
- SDL_env[i++] = (char *)0;
- added = 1;
- } else {
- SDL_free(new_variable);
- }
- }
- return (added ? 0 : -1);
+ const char *name, *value;
+ int added;
+ int len, i;
+ char **new_env;
+ char *new_variable;
+
+ /* A little error checking */
+ if (!variable) {
+ return (-1);
+ }
+ name = variable;
+ for (value = variable; *value && (*value != '='); ++value) {
+ /* Keep looking for '=' */ ;
+ }
+ if (*value) {
+ ++value;
+ } else {
+ return (-1);
+ }
+
+ /* Allocate memory for the variable */
+ new_variable = SDL_strdup(variable);
+ if (!new_variable) {
+ return (-1);
+ }
+
+ /* Actually put it into the environment */
+ added = 0;
+ i = 0;
+ if (SDL_env) {
+ /* Check to see if it's already there... */
+ len = (value - name);
+ for (; SDL_env[i]; ++i) {
+ if (SDL_strncmp(SDL_env[i], name, len) == 0) {
+ break;
+ }
+ }
+ /* If we found it, just replace the entry */
+ if (SDL_env[i]) {
+ SDL_free(SDL_env[i]);
+ SDL_env[i] = new_variable;
+ added = 1;
+ }
+ }
+
+ /* Didn't find it in the environment, expand and add */
+ if (!added) {
+ new_env = SDL_realloc(SDL_env, (i + 2) * sizeof(char *));
+ if (new_env) {
+ SDL_env = new_env;
+ SDL_env[i++] = new_variable;
+ SDL_env[i++] = (char *) 0;
+ added = 1;
+ } else {
+ SDL_free(new_variable);
+ }
+ }
+ return (added ? 0 : -1);
}
/* Retrieve a variable named "name" from the environment */
-char *SDL_getenv(const char *name)
+char *
+SDL_getenv(const char *name)
{
- int len, i;
- char *value;
-
- value = (char *)0;
- if ( SDL_env ) {
- len = SDL_strlen(name);
- for ( i=0; SDL_env[i] && !value; ++i ) {
- if ( (SDL_strncmp(SDL_env[i], name, len) == 0) &&
- (SDL_env[i][len] == '=') ) {
- value = &SDL_env[i][len+1];
- }
- }
- }
- return value;
+ int len, i;
+ char *value;
+
+ value = (char *) 0;
+ if (SDL_env) {
+ len = SDL_strlen(name);
+ for (i = 0; SDL_env[i] && !value; ++i) {
+ if ((SDL_strncmp(SDL_env[i], name, len) == 0) &&
+ (SDL_env[i][len] == '=')) {
+ value = &SDL_env[i][len + 1];
+ }
+ }
+ }
+ return value;
}
#endif /* __WIN32__ */
@@ -178,70 +183,71 @@ char *SDL_getenv(const char *name)
#ifdef TEST_MAIN
#include <stdio.h>
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
{
- char *value;
-
- printf("Checking for non-existent variable... ");
- fflush(stdout);
- if ( ! SDL_getenv("EXISTS") ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Setting FIRST=VALUE1 in the environment... ");
- fflush(stdout);
- if ( SDL_putenv("FIRST=VALUE1") == 0 ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Getting FIRST from the environment... ");
- fflush(stdout);
- value = SDL_getenv("FIRST");
- if ( value && (SDL_strcmp(value, "VALUE1") == 0) ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Setting SECOND=VALUE2 in the environment... ");
- fflush(stdout);
- if ( SDL_putenv("SECOND=VALUE2") == 0 ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Getting SECOND from the environment... ");
- fflush(stdout);
- value = SDL_getenv("SECOND");
- if ( value && (SDL_strcmp(value, "VALUE2") == 0) ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Setting FIRST=NOVALUE in the environment... ");
- fflush(stdout);
- if ( SDL_putenv("FIRST=NOVALUE") == 0 ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Getting FIRST from the environment... ");
- fflush(stdout);
- value = SDL_getenv("FIRST");
- if ( value && (SDL_strcmp(value, "NOVALUE") == 0) ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- printf("Checking for non-existent variable... ");
- fflush(stdout);
- if ( ! SDL_getenv("EXISTS") ) {
- printf("okay\n");
- } else {
- printf("failed\n");
- }
- return(0);
+ char *value;
+
+ printf("Checking for non-existent variable... ");
+ fflush(stdout);
+ if (!SDL_getenv("EXISTS")) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Setting FIRST=VALUE1 in the environment... ");
+ fflush(stdout);
+ if (SDL_putenv("FIRST=VALUE1") == 0) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Getting FIRST from the environment... ");
+ fflush(stdout);
+ value = SDL_getenv("FIRST");
+ if (value && (SDL_strcmp(value, "VALUE1") == 0)) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Setting SECOND=VALUE2 in the environment... ");
+ fflush(stdout);
+ if (SDL_putenv("SECOND=VALUE2") == 0) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Getting SECOND from the environment... ");
+ fflush(stdout);
+ value = SDL_getenv("SECOND");
+ if (value && (SDL_strcmp(value, "VALUE2") == 0)) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Setting FIRST=NOVALUE in the environment... ");
+ fflush(stdout);
+ if (SDL_putenv("FIRST=NOVALUE") == 0) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Getting FIRST from the environment... ");
+ fflush(stdout);
+ value = SDL_getenv("FIRST");
+ if (value && (SDL_strcmp(value, "NOVALUE") == 0)) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ printf("Checking for non-existent variable... ");
+ fflush(stdout);
+ if (!SDL_getenv("EXISTS")) {
+ printf("okay\n");
+ } else {
+ printf("failed\n");
+ }
+ return (0);
}
#endif /* TEST_MAIN */
-
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/stdlib/SDL_iconv.c b/src/stdlib/SDL_iconv.c
index 1a94e0f3..d5b8fa80 100644
--- a/src/stdlib/SDL_iconv.c
+++ b/src/stdlib/SDL_iconv.c
@@ -30,24 +30,25 @@
#include <errno.h>
-size_t SDL_iconv(SDL_iconv_t cd,
- char **inbuf, size_t *inbytesleft,
- char **outbuf, size_t *outbytesleft)
+size_t
+SDL_iconv(SDL_iconv_t cd,
+ char **inbuf, size_t * inbytesleft,
+ char **outbuf, size_t * outbytesleft)
{
- size_t retCode = iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft);
- if ( retCode == (size_t)-1 ) {
- switch(errno) {
- case E2BIG:
- return SDL_ICONV_E2BIG;
- case EILSEQ:
- return SDL_ICONV_EILSEQ;
- case EINVAL:
- return SDL_ICONV_EINVAL;
- default:
- return SDL_ICONV_ERROR;
- }
- }
- return retCode;
+ size_t retCode = iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft);
+ if (retCode == (size_t) - 1) {
+ switch (errno) {
+ case E2BIG:
+ return SDL_ICONV_E2BIG;
+ case EILSEQ:
+ return SDL_ICONV_EILSEQ;
+ case EINVAL:
+ return SDL_ICONV_EINVAL;
+ default:
+ return SDL_ICONV_ERROR;
+ }
+ }
+ return retCode;
}
#else
@@ -61,19 +62,20 @@ size_t SDL_iconv(SDL_iconv_t cd,
#define UNKNOWN_ASCII '?'
#define UNKNOWN_UNICODE 0xFFFD
-enum {
- ENCODING_UNKNOWN,
- ENCODING_ASCII,
- ENCODING_LATIN1,
- ENCODING_UTF8,
- ENCODING_UTF16, /* Needs byte order marker */
- ENCODING_UTF16BE,
- ENCODING_UTF16LE,
- ENCODING_UTF32, /* Needs byte order marker */
- ENCODING_UTF32BE,
- ENCODING_UTF32LE,
- ENCODING_UCS2, /* Native byte order assumed */
- ENCODING_UCS4, /* Native byte order assumed */
+enum
+{
+ ENCODING_UNKNOWN,
+ ENCODING_ASCII,
+ ENCODING_LATIN1,
+ ENCODING_UTF8,
+ ENCODING_UTF16, /* Needs byte order marker */
+ ENCODING_UTF16BE,
+ ENCODING_UTF16LE,
+ ENCODING_UTF32, /* Needs byte order marker */
+ ENCODING_UTF32BE,
+ ENCODING_UTF32LE,
+ ENCODING_UCS2, /* Native byte order assumed */
+ ENCODING_UCS4, /* Native byte order assumed */
};
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
#define ENCODING_UTF16NATIVE ENCODING_UTF16BE
@@ -85,730 +87,731 @@ enum {
struct _SDL_iconv_t
{
- int src_fmt;
- int dst_fmt;
+ int src_fmt;
+ int dst_fmt;
};
-static struct {
- const char *name;
- int format;
+static struct
+{
+ const char *name;
+ int format;
} encodings[] = {
- { "ASCII", ENCODING_ASCII },
- { "US-ASCII", ENCODING_ASCII },
- { "LATIN1", ENCODING_LATIN1 },
- { "ISO-8859-1", ENCODING_LATIN1 },
- { "UTF8", ENCODING_UTF8 },
- { "UTF-8", ENCODING_UTF8 },
- { "UTF16", ENCODING_UTF16 },
- { "UTF-16", ENCODING_UTF16 },
- { "UTF16BE", ENCODING_UTF16BE },
- { "UTF-16BE", ENCODING_UTF16BE },
- { "UTF16LE", ENCODING_UTF16LE },
- { "UTF-16LE", ENCODING_UTF16LE },
- { "UTF32", ENCODING_UTF32 },
- { "UTF-32", ENCODING_UTF32 },
- { "UTF32BE", ENCODING_UTF32BE },
- { "UTF-32BE", ENCODING_UTF32BE },
- { "UTF32LE", ENCODING_UTF32LE },
- { "UTF-32LE", ENCODING_UTF32LE },
- { "UCS2", ENCODING_UCS2 },
- { "UCS-2", ENCODING_UCS2 },
- { "UCS4", ENCODING_UCS4 },
- { "UCS-4", ENCODING_UCS4 },
-};
-
-SDL_iconv_t SDL_iconv_open(const char *tocode, const char *fromcode)
+ {
+ "ASCII", ENCODING_ASCII}, {
+ "US-ASCII", ENCODING_ASCII}, {
+ "LATIN1", ENCODING_LATIN1}, {
+ "ISO-8859-1", ENCODING_LATIN1}, {
+ "UTF8", ENCODING_UTF8}, {
+ "UTF-8", ENCODING_UTF8}, {
+ "UTF16", ENCODING_UTF16}, {
+ "UTF-16", ENCODING_UTF16}, {
+ "UTF16BE", ENCODING_UTF16BE}, {
+ "UTF-16BE", ENCODING_UTF16BE}, {
+ "UTF16LE", ENCODING_UTF16LE}, {
+ "UTF-16LE", ENCODING_UTF16LE}, {
+ "UTF32", ENCODING_UTF32}, {
+ "UTF-32", ENCODING_UTF32}, {
+ "UTF32BE", ENCODING_UTF32BE}, {
+ "UTF-32BE", ENCODING_UTF32BE}, {
+ "UTF32LE", ENCODING_UTF32LE}, {
+ "UTF-32LE", ENCODING_UTF32LE}, {
+ "UCS2", ENCODING_UCS2}, {
+ "UCS-2", ENCODING_UCS2}, {
+ "UCS4", ENCODING_UCS4}, {
+"UCS-4", ENCODING_UCS4},};
+
+SDL_iconv_t
+SDL_iconv_open(const char *tocode, const char *fromcode)
{
- int src_fmt = ENCODING_UNKNOWN;
- int dst_fmt = ENCODING_UNKNOWN;
- int i;
-
- for ( i = 0; i < SDL_arraysize(encodings); ++i ) {
- if ( SDL_strcasecmp(fromcode, encodings[i].name) == 0 ) {
- src_fmt = encodings[i].format;
- if ( dst_fmt != ENCODING_UNKNOWN ) {
- break;
- }
- }
- if ( SDL_strcasecmp(tocode, encodings[i].name) == 0 ) {
- dst_fmt = encodings[i].format;
- if ( src_fmt != ENCODING_UNKNOWN ) {
- break;
- }
- }
- }
- if ( src_fmt != ENCODING_UNKNOWN && dst_fmt != ENCODING_UNKNOWN ) {
- SDL_iconv_t cd = (SDL_iconv_t)SDL_malloc(sizeof(*cd));
- if ( cd ) {
- cd->src_fmt = src_fmt;
- cd->dst_fmt = dst_fmt;
- return cd;
- }
- }
- return (SDL_iconv_t)-1;
+ int src_fmt = ENCODING_UNKNOWN;
+ int dst_fmt = ENCODING_UNKNOWN;
+ int i;
+
+ for (i = 0; i < SDL_arraysize(encodings); ++i) {
+ if (SDL_strcasecmp(fromcode, encodings[i].name) == 0) {
+ src_fmt = encodings[i].format;
+ if (dst_fmt != ENCODING_UNKNOWN) {
+ break;
+ }
+ }
+ if (SDL_strcasecmp(tocode, encodings[i].name) == 0) {
+ dst_fmt = encodings[i].format;
+ if (src_fmt != ENCODING_UNKNOWN) {
+ break;
+ }
+ }
+ }
+ if (src_fmt != ENCODING_UNKNOWN && dst_fmt != ENCODING_UNKNOWN) {
+ SDL_iconv_t cd = (SDL_iconv_t) SDL_malloc(sizeof(*cd));
+ if (cd) {
+ cd->src_fmt = src_fmt;
+ cd->dst_fmt = dst_fmt;
+ return cd;
+ }
+ }
+ return (SDL_iconv_t) - 1;
}
-size_t SDL_iconv(SDL_iconv_t cd,
- char **inbuf, size_t *inbytesleft,
- char **outbuf, size_t *outbytesleft)
+size_t
+SDL_iconv(SDL_iconv_t cd,
+ char **inbuf, size_t * inbytesleft,
+ char **outbuf, size_t * outbytesleft)
{
- /* For simplicity, we'll convert everything to and from UCS-4 */
- char *src, *dst;
- size_t srclen, dstlen;
- Uint32 ch = 0;
- size_t total;
-
- if ( !inbuf || !*inbuf ) {
- /* Reset the context */
- return 0;
- }
- if ( !outbuf || !*outbuf || !outbytesleft || !*outbytesleft ) {
- return SDL_ICONV_E2BIG;
- }
- src = *inbuf;
- srclen = (inbytesleft ? *inbytesleft : 0);
- dst = *outbuf;
- dstlen = *outbytesleft;
-
- switch ( cd->src_fmt ) {
- case ENCODING_UTF16:
- /* Scan for a byte order marker */
- {
- Uint8 *p = (Uint8 *)src;
- size_t n = srclen / 2;
- while ( n ) {
- if ( p[0] == 0xFF && p[1] == 0xFE ) {
- cd->src_fmt = ENCODING_UTF16BE;
- break;
- } else if ( p[0] == 0xFE && p[1] == 0xFF ) {
- cd->src_fmt = ENCODING_UTF16LE;
- break;
- }
- p += 2;
- --n;
- }
- if ( n == 0 ) {
- /* We can't tell, default to host order */
- cd->src_fmt = ENCODING_UTF16NATIVE;
- }
- }
- break;
- case ENCODING_UTF32:
- /* Scan for a byte order marker */
- {
- Uint8 *p = (Uint8 *)src;
- size_t n = srclen / 4;
- while ( n ) {
- if ( p[0] == 0xFF && p[1] == 0xFE &&
- p[2] == 0x00 && p[3] == 0x00 ) {
- cd->src_fmt = ENCODING_UTF32BE;
- break;
- } else if ( p[0] == 0x00 && p[1] == 0x00 &&
- p[2] == 0xFE && p[3] == 0xFF ) {
- cd->src_fmt = ENCODING_UTF32LE;
- break;
- }
- p += 4;
- --n;
- }
- if ( n == 0 ) {
- /* We can't tell, default to host order */
- cd->src_fmt = ENCODING_UTF32NATIVE;
- }
- }
- break;
- }
-
- switch ( cd->dst_fmt ) {
- case ENCODING_UTF16:
- /* Default to host order, need to add byte order marker */
- if ( dstlen < 2 ) {
- return SDL_ICONV_E2BIG;
- }
- *(Uint16 *)dst = UNICODE_BOM;
- dst += 2;
- dstlen -= 2;
- cd->dst_fmt = ENCODING_UTF16NATIVE;
- break;
- case ENCODING_UTF32:
- /* Default to host order, need to add byte order marker */
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- *(Uint32 *)dst = UNICODE_BOM;
- dst += 4;
- dstlen -= 4;
- cd->dst_fmt = ENCODING_UTF32NATIVE;
- break;
- }
-
- total = 0;
- while ( srclen > 0 ) {
- /* Decode a character */
- switch ( cd->src_fmt ) {
- case ENCODING_ASCII:
- {
- Uint8 *p = (Uint8 *)src;
- ch = (Uint32)(p[0] & 0x7F);
- ++src;
- --srclen;
- }
- break;
- case ENCODING_LATIN1:
- {
- Uint8 *p = (Uint8 *)src;
- ch = (Uint32)p[0];
- ++src;
- --srclen;
- }
- break;
- case ENCODING_UTF8: /* RFC 3629 */
- {
- Uint8 *p = (Uint8 *)src;
- size_t left = 0;
- SDL_bool overlong = SDL_FALSE;
- if ( p[0] >= 0xFC ) {
- if ( (p[0] & 0xFE) != 0xFC ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- if ( p[0] == 0xFC ) {
- overlong = SDL_TRUE;
- }
- ch = (Uint32)(p[0] & 0x01);
- left = 5;
- }
- } else if ( p[0] >= 0xF8 ) {
- if ( (p[0] & 0xFC) != 0xF8 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- if ( p[0] == 0xF8 ) {
- overlong = SDL_TRUE;
- }
- ch = (Uint32)(p[0] & 0x03);
- left = 4;
- }
- } else if ( p[0] >= 0xF0 ) {
- if ( (p[0] & 0xF8) != 0xF0 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- if ( p[0] == 0xF0 ) {
- overlong = SDL_TRUE;
- }
- ch = (Uint32)(p[0] & 0x07);
- left = 3;
- }
- } else if ( p[0] >= 0xE0 ) {
- if ( (p[0] & 0xF0) != 0xE0 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- if ( p[0] == 0xE0 ) {
- overlong = SDL_TRUE;
- }
- ch = (Uint32)(p[0] & 0x0F);
- left = 2;
- }
- } else if ( p[0] >= 0xC0 ) {
- if ( (p[0] & 0xE0) != 0xC0 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- if ( (p[0] & 0xCE) == 0xC0 ) {
- overlong = SDL_TRUE;
- }
- ch = (Uint32)(p[0] & 0x1F);
- left = 1;
- }
- } else {
- if ( (p[0] & 0x80) != 0x00 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- } else {
- ch = (Uint32)p[0];
- }
- }
- ++src;
- --srclen;
- if ( srclen < left ) {
- return SDL_ICONV_EINVAL;
- }
- while ( left-- ) {
- ++p;
- if ( (p[0] & 0xC0) != 0x80 ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- break;
- }
- ch <<= 6;
- ch |= (p[0] & 0x3F);
- ++src;
- --srclen;
- }
- if ( overlong ) {
- /* Potential security risk
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- }
- if ( (ch >= 0xD800 && ch <= 0xDFFF) ||
- (ch == 0xFFFE || ch == 0xFFFF) ||
- ch > 0x10FFFF ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- }
- }
- break;
- case ENCODING_UTF16BE: /* RFC 2781 */
- {
- Uint8 *p = (Uint8 *)src;
- Uint16 W1, W2;
- if ( srclen < 2 ) {
- return SDL_ICONV_EINVAL;
- }
- W1 = ((Uint16)p[0] << 8) |
- (Uint16)p[1];
- src += 2;
- srclen -= 2;
- if ( W1 < 0xD800 || W1 > 0xDFFF ) {
- ch = (Uint32)W1;
- break;
- }
- if ( W1 > 0xDBFF ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- break;
- }
- if ( srclen < 2 ) {
- return SDL_ICONV_EINVAL;
- }
- p = (Uint8 *)src;
- W2 = ((Uint16)p[0] << 8) |
- (Uint16)p[1];
- src += 2;
- srclen -= 2;
- if ( W2 < 0xDC00 || W2 > 0xDFFF ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- break;
- }
- ch = (((Uint32)(W1 & 0x3FF) << 10) |
- (Uint32)(W2 & 0x3FF)) + 0x10000;
- }
- break;
- case ENCODING_UTF16LE: /* RFC 2781 */
- {
- Uint8 *p = (Uint8 *)src;
- Uint16 W1, W2;
- if ( srclen < 2 ) {
- return SDL_ICONV_EINVAL;
- }
- W1 = ((Uint16)p[1] << 8) |
- (Uint16)p[0];
- src += 2;
- srclen -= 2;
- if ( W1 < 0xD800 || W1 > 0xDFFF ) {
- ch = (Uint32)W1;
- break;
- }
- if ( W1 > 0xDBFF ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- break;
- }
- if ( srclen < 2 ) {
- return SDL_ICONV_EINVAL;
- }
- p = (Uint8 *)src;
- W2 = ((Uint16)p[1] << 8) |
- (Uint16)p[0];
- src += 2;
- srclen -= 2;
- if ( W2 < 0xDC00 || W2 > 0xDFFF ) {
- /* Skip illegal sequences
- return SDL_ICONV_EILSEQ;
- */
- ch = UNKNOWN_UNICODE;
- break;
- }
- ch = (((Uint32)(W1 & 0x3FF) << 10) |
- (Uint32)(W2 & 0x3FF)) + 0x10000;
- }
- break;
- case ENCODING_UTF32BE:
- {
- Uint8 *p = (Uint8 *)src;
- if ( srclen < 4 ) {
- return SDL_ICONV_EINVAL;
- }
- ch = ((Uint32)p[0] << 24) |
- ((Uint32)p[1] << 16) |
- ((Uint32)p[2] << 8) |
- (Uint32)p[3];
- src += 4;
- srclen -= 4;
- }
- break;
- case ENCODING_UTF32LE:
- {
- Uint8 *p = (Uint8 *)src;
- if ( srclen < 4 ) {
- return SDL_ICONV_EINVAL;
- }
- ch = ((Uint32)p[3] << 24) |
- ((Uint32)p[2] << 16) |
- ((Uint32)p[1] << 8) |
- (Uint32)p[0];
- src += 4;
- srclen -= 4;
- }
- break;
- case ENCODING_UCS2:
- {
- Uint16 *p = (Uint16 *)src;
- if ( srclen < 2 ) {
- return SDL_ICONV_EINVAL;
- }
- ch = *p;
- src += 2;
- srclen -= 2;
- }
- break;
- case ENCODING_UCS4:
- {
- Uint32 *p = (Uint32 *)src;
- if ( srclen < 4 ) {
- return SDL_ICONV_EINVAL;
- }
- ch = *p;
- src += 4;
- srclen -= 4;
- }
- break;
- }
-
- /* Encode a character */
- switch ( cd->dst_fmt ) {
- case ENCODING_ASCII:
- {
- Uint8 *p = (Uint8 *)dst;
- if ( dstlen < 1 ) {
- return SDL_ICONV_E2BIG;
- }
- if ( ch > 0x7F ) {
- *p = UNKNOWN_ASCII;
- } else {
- *p = (Uint8)ch;
- }
- ++dst;
- --dstlen;
- }
- break;
- case ENCODING_LATIN1:
- {
- Uint8 *p = (Uint8 *)dst;
- if ( dstlen < 1 ) {
- return SDL_ICONV_E2BIG;
- }
- if ( ch > 0xFF ) {
- *p = UNKNOWN_ASCII;
- } else {
- *p = (Uint8)ch;
- }
- ++dst;
- --dstlen;
- }
- break;
- case ENCODING_UTF8: /* RFC 3629 */
- {
- Uint8 *p = (Uint8 *)dst;
- if ( ch > 0x10FFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( ch <= 0x7F ) {
- if ( dstlen < 1 ) {
- return SDL_ICONV_E2BIG;
- }
- *p = (Uint8)ch;
- ++dst;
- --dstlen;
- } else if ( ch <= 0x7FF ) {
- if ( dstlen < 2 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = 0xC0 | (Uint8)((ch >> 6) & 0x1F);
- p[1] = 0x80 | (Uint8)(ch & 0x3F);
- dst += 2;
- dstlen -= 2;
- } else if ( ch <= 0xFFFF ) {
- if ( dstlen < 3 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = 0xE0 | (Uint8)((ch >> 12) & 0x0F);
- p[1] = 0x80 | (Uint8)((ch >> 6) & 0x3F);
- p[2] = 0x80 | (Uint8)(ch & 0x3F);
- dst += 3;
- dstlen -= 3;
- } else if ( ch <= 0x1FFFFF ) {
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = 0xF0 | (Uint8)((ch >> 18) & 0x07);
- p[1] = 0x80 | (Uint8)((ch >> 12) & 0x3F);
- p[2] = 0x80 | (Uint8)((ch >> 6) & 0x3F);
- p[3] = 0x80 | (Uint8)(ch & 0x3F);
- dst += 4;
- dstlen -= 4;
- } else if ( ch <= 0x3FFFFFF ) {
- if ( dstlen < 5 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = 0xF8 | (Uint8)((ch >> 24) & 0x03);
- p[1] = 0x80 | (Uint8)((ch >> 18) & 0x3F);
- p[2] = 0x80 | (Uint8)((ch >> 12) & 0x3F);
- p[3] = 0x80 | (Uint8)((ch >> 6) & 0x3F);
- p[4] = 0x80 | (Uint8)(ch & 0x3F);
- dst += 5;
- dstlen -= 5;
- } else {
- if ( dstlen < 6 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = 0xFC | (Uint8)((ch >> 30) & 0x01);
- p[1] = 0x80 | (Uint8)((ch >> 24) & 0x3F);
- p[2] = 0x80 | (Uint8)((ch >> 18) & 0x3F);
- p[3] = 0x80 | (Uint8)((ch >> 12) & 0x3F);
- p[4] = 0x80 | (Uint8)((ch >> 6) & 0x3F);
- p[5] = 0x80 | (Uint8)(ch & 0x3F);
- dst += 6;
- dstlen -= 6;
- }
- }
- break;
- case ENCODING_UTF16BE: /* RFC 2781 */
- {
- Uint8 *p = (Uint8 *)dst;
- if ( ch > 0x10FFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( ch < 0x10000 ) {
- if ( dstlen < 2 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = (Uint8)(ch >> 8);
- p[1] = (Uint8)ch;
- dst += 2;
- dstlen -= 2;
- } else {
- Uint16 W1, W2;
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- ch = ch - 0x10000;
- W1 = 0xD800 | (Uint16)((ch >> 10) & 0x3FF);
- W2 = 0xDC00 | (Uint16)(ch & 0x3FF);
- p[0] = (Uint8)(W1 >> 8);
- p[1] = (Uint8)W1;
- p[2] = (Uint8)(W2 >> 8);
- p[3] = (Uint8)W2;
- dst += 4;
- dstlen -= 4;
- }
- }
- break;
- case ENCODING_UTF16LE: /* RFC 2781 */
- {
- Uint8 *p = (Uint8 *)dst;
- if ( ch > 0x10FFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( ch < 0x10000 ) {
- if ( dstlen < 2 ) {
- return SDL_ICONV_E2BIG;
- }
- p[1] = (Uint8)(ch >> 8);
- p[0] = (Uint8)ch;
- dst += 2;
- dstlen -= 2;
- } else {
- Uint16 W1, W2;
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- ch = ch - 0x10000;
- W1 = 0xD800 | (Uint16)((ch >> 10) & 0x3FF);
- W2 = 0xDC00 | (Uint16)(ch & 0x3FF);
- p[1] = (Uint8)(W1 >> 8);
- p[0] = (Uint8)W1;
- p[3] = (Uint8)(W2 >> 8);
- p[2] = (Uint8)W2;
- dst += 4;
- dstlen -= 4;
- }
- }
- break;
- case ENCODING_UTF32BE:
- {
- Uint8 *p = (Uint8 *)dst;
- if ( ch > 0x10FFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- p[0] = (Uint8)(ch >> 24);
- p[1] = (Uint8)(ch >> 16);
- p[2] = (Uint8)(ch >> 8);
- p[3] = (Uint8)ch;
- dst += 4;
- dstlen -= 4;
- }
- break;
- case ENCODING_UTF32LE:
- {
- Uint8 *p = (Uint8 *)dst;
- if ( ch > 0x10FFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- p[3] = (Uint8)(ch >> 24);
- p[2] = (Uint8)(ch >> 16);
- p[1] = (Uint8)(ch >> 8);
- p[0] = (Uint8)ch;
- dst += 4;
- dstlen -= 4;
- }
- break;
- case ENCODING_UCS2:
- {
- Uint16 *p = (Uint16 *)dst;
- if ( ch > 0xFFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( dstlen < 2 ) {
- return SDL_ICONV_E2BIG;
- }
- *p = (Uint16)ch;
- dst += 2;
- dstlen -= 2;
- }
- break;
- case ENCODING_UCS4:
- {
- Uint32 *p = (Uint32 *)dst;
- if ( ch > 0x7FFFFFFF ) {
- ch = UNKNOWN_UNICODE;
- }
- if ( dstlen < 4 ) {
- return SDL_ICONV_E2BIG;
- }
- *p = ch;
- dst += 4;
- dstlen -= 4;
- }
- break;
- }
-
- /* Update state */
- *inbuf = src;
- *inbytesleft = srclen;
- *outbuf = dst;
- *outbytesleft = dstlen;
- ++total;
- }
- return total;
+ /* For simplicity, we'll convert everything to and from UCS-4 */
+ char *src, *dst;
+ size_t srclen, dstlen;
+ Uint32 ch;
+ size_t total;
+
+ if (!inbuf || !*inbuf) {
+ /* Reset the context */
+ return 0;
+ }
+ if (!outbuf || !*outbuf || !outbytesleft || !*outbytesleft) {
+ return SDL_ICONV_E2BIG;
+ }
+ src = *inbuf;
+ srclen = (inbytesleft ? *inbytesleft : 0);
+ dst = *outbuf;
+ dstlen = *outbytesleft;
+
+ switch (cd->src_fmt) {
+ case ENCODING_UTF16:
+ /* Scan for a byte order marker */
+ {
+ Uint8 *p = (Uint8 *) src;
+ size_t n = srclen / 2;
+ while (n) {
+ if (p[0] == 0xFF && p[1] == 0xFE) {
+ cd->src_fmt = ENCODING_UTF16BE;
+ break;
+ } else if (p[0] == 0xFE && p[1] == 0xFF) {
+ cd->src_fmt = ENCODING_UTF16LE;
+ break;
+ }
+ p += 2;
+ --n;
+ }
+ if (n == 0) {
+ /* We can't tell, default to host order */
+ cd->src_fmt = ENCODING_UTF16NATIVE;
+ }
+ }
+ break;
+ case ENCODING_UTF32:
+ /* Scan for a byte order marker */
+ {
+ Uint8 *p = (Uint8 *) src;
+ size_t n = srclen / 4;
+ while (n) {
+ if (p[0] == 0xFF && p[1] == 0xFE &&
+ p[2] == 0x00 && p[3] == 0x00) {
+ cd->src_fmt = ENCODING_UTF32BE;
+ break;
+ } else if (p[0] == 0x00 && p[1] == 0x00 &&
+ p[2] == 0xFE && p[3] == 0xFF) {
+ cd->src_fmt = ENCODING_UTF32LE;
+ break;
+ }
+ p += 4;
+ --n;
+ }
+ if (n == 0) {
+ /* We can't tell, default to host order */
+ cd->src_fmt = ENCODING_UTF32NATIVE;
+ }
+ }
+ break;
+ }
+
+ switch (cd->dst_fmt) {
+ case ENCODING_UTF16:
+ /* Default to host order, need to add byte order marker */
+ if (dstlen < 2) {
+ return SDL_ICONV_E2BIG;
+ }
+ *(Uint16 *) dst = UNICODE_BOM;
+ dst += 2;
+ dstlen -= 2;
+ cd->dst_fmt = ENCODING_UTF16NATIVE;
+ break;
+ case ENCODING_UTF32:
+ /* Default to host order, need to add byte order marker */
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ *(Uint32 *) dst = UNICODE_BOM;
+ dst += 4;
+ dstlen -= 4;
+ cd->dst_fmt = ENCODING_UTF32NATIVE;
+ break;
+ }
+
+ total = 0;
+ while (srclen > 0) {
+ /* Decode a character */
+ switch (cd->src_fmt) {
+ case ENCODING_ASCII:
+ {
+ Uint8 *p = (Uint8 *) src;
+ ch = (Uint32) (p[0] & 0x7F);
+ ++src;
+ --srclen;
+ }
+ break;
+ case ENCODING_LATIN1:
+ {
+ Uint8 *p = (Uint8 *) src;
+ ch = (Uint32) p[0];
+ ++src;
+ --srclen;
+ }
+ break;
+ case ENCODING_UTF8: /* RFC 3629 */
+ {
+ Uint8 *p = (Uint8 *) src;
+ size_t left = 0;
+ SDL_bool overlong = SDL_FALSE;
+ if (p[0] >= 0xFC) {
+ if ((p[0] & 0xFE) != 0xFC) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ if (p[0] == 0xFC) {
+ overlong = SDL_TRUE;
+ }
+ ch = (Uint32) (p[0] & 0x01);
+ left = 5;
+ }
+ } else if (p[0] >= 0xF8) {
+ if ((p[0] & 0xFC) != 0xF8) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ if (p[0] == 0xF8) {
+ overlong = SDL_TRUE;
+ }
+ ch = (Uint32) (p[0] & 0x03);
+ left = 4;
+ }
+ } else if (p[0] >= 0xF0) {
+ if ((p[0] & 0xF8) != 0xF0) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ if (p[0] == 0xF0) {
+ overlong = SDL_TRUE;
+ }
+ ch = (Uint32) (p[0] & 0x07);
+ left = 3;
+ }
+ } else if (p[0] >= 0xE0) {
+ if ((p[0] & 0xF0) != 0xE0) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ if (p[0] == 0xE0) {
+ overlong = SDL_TRUE;
+ }
+ ch = (Uint32) (p[0] & 0x0F);
+ left = 2;
+ }
+ } else if (p[0] >= 0xC0) {
+ if ((p[0] & 0xE0) != 0xC0) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ if ((p[0] & 0xCE) == 0xC0) {
+ overlong = SDL_TRUE;
+ }
+ ch = (Uint32) (p[0] & 0x1F);
+ left = 1;
+ }
+ } else {
+ if ((p[0] & 0x80) != 0x00) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ } else {
+ ch = (Uint32) p[0];
+ }
+ }
+ ++src;
+ --srclen;
+ if (srclen < left) {
+ return SDL_ICONV_EINVAL;
+ }
+ while (left--) {
+ ++p;
+ if ((p[0] & 0xC0) != 0x80) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ break;
+ }
+ ch <<= 6;
+ ch |= (p[0] & 0x3F);
+ ++src;
+ --srclen;
+ }
+ if (overlong) {
+ /* Potential security risk
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ }
+ if ((ch >= 0xD800 && ch <= 0xDFFF) ||
+ (ch == 0xFFFE || ch == 0xFFFF) || ch > 0x10FFFF) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ }
+ }
+ break;
+ case ENCODING_UTF16BE: /* RFC 2781 */
+ {
+ Uint8 *p = (Uint8 *) src;
+ Uint16 W1, W2;
+ if (srclen < 2) {
+ return SDL_ICONV_EINVAL;
+ }
+ W1 = ((Uint16) p[0] << 8) | (Uint16) p[1];
+ src += 2;
+ srclen -= 2;
+ if (W1 < 0xD800 || W1 > 0xDFFF) {
+ ch = (Uint32) W1;
+ break;
+ }
+ if (W1 > 0xDBFF) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ break;
+ }
+ if (srclen < 2) {
+ return SDL_ICONV_EINVAL;
+ }
+ p = (Uint8 *) src;
+ W2 = ((Uint16) p[0] << 8) | (Uint16) p[1];
+ src += 2;
+ srclen -= 2;
+ if (W2 < 0xDC00 || W2 > 0xDFFF) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ break;
+ }
+ ch = (((Uint32) (W1 & 0x3FF) << 10) |
+ (Uint32) (W2 & 0x3FF)) + 0x10000;
+ }
+ break;
+ case ENCODING_UTF16LE: /* RFC 2781 */
+ {
+ Uint8 *p = (Uint8 *) src;
+ Uint16 W1, W2;
+ if (srclen < 2) {
+ return SDL_ICONV_EINVAL;
+ }
+ W1 = ((Uint16) p[1] << 8) | (Uint16) p[0];
+ src += 2;
+ srclen -= 2;
+ if (W1 < 0xD800 || W1 > 0xDFFF) {
+ ch = (Uint32) W1;
+ break;
+ }
+ if (W1 > 0xDBFF) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ break;
+ }
+ if (srclen < 2) {
+ return SDL_ICONV_EINVAL;
+ }
+ p = (Uint8 *) src;
+ W2 = ((Uint16) p[1] << 8) | (Uint16) p[0];
+ src += 2;
+ srclen -= 2;
+ if (W2 < 0xDC00 || W2 > 0xDFFF) {
+ /* Skip illegal sequences
+ return SDL_ICONV_EILSEQ;
+ */
+ ch = UNKNOWN_UNICODE;
+ break;
+ }
+ ch = (((Uint32) (W1 & 0x3FF) << 10) |
+ (Uint32) (W2 & 0x3FF)) + 0x10000;
+ }
+ break;
+ case ENCODING_UTF32BE:
+ {
+ Uint8 *p = (Uint8 *) src;
+ if (srclen < 4) {
+ return SDL_ICONV_EINVAL;
+ }
+ ch = ((Uint32) p[0] << 24) |
+ ((Uint32) p[1] << 16) |
+ ((Uint32) p[2] << 8) | (Uint32) p[3];
+ src += 4;
+ srclen -= 4;
+ }
+ break;
+ case ENCODING_UTF32LE:
+ {
+ Uint8 *p = (Uint8 *) src;
+ if (srclen < 4) {
+ return SDL_ICONV_EINVAL;
+ }
+ ch = ((Uint32) p[3] << 24) |
+ ((Uint32) p[2] << 16) |
+ ((Uint32) p[1] << 8) | (Uint32) p[0];
+ src += 4;
+ srclen -= 4;
+ }
+ break;
+ case ENCODING_UCS2:
+ {
+ Uint16 *p = (Uint16 *) src;
+ if (srclen < 2) {
+ return SDL_ICONV_EINVAL;
+ }
+ ch = *p;
+ src += 2;
+ srclen -= 2;
+ }
+ break;
+ case ENCODING_UCS4:
+ {
+ Uint32 *p = (Uint32 *) src;
+ if (srclen < 4) {
+ return SDL_ICONV_EINVAL;
+ }
+ ch = *p;
+ src += 4;
+ srclen -= 4;
+ }
+ break;
+ }
+
+ /* Encode a character */
+ switch (cd->dst_fmt) {
+ case ENCODING_ASCII:
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (dstlen < 1) {
+ return SDL_ICONV_E2BIG;
+ }
+ if (ch > 0x7F) {
+ *p = UNKNOWN_ASCII;
+ } else {
+ *p = (Uint8) ch;
+ }
+ ++dst;
+ --dstlen;
+ }
+ break;
+ case ENCODING_LATIN1:
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (dstlen < 1) {
+ return SDL_ICONV_E2BIG;
+ }
+ if (ch > 0xFF) {
+ *p = UNKNOWN_ASCII;
+ } else {
+ *p = (Uint8) ch;
+ }
+ ++dst;
+ --dstlen;
+ }
+ break;
+ case ENCODING_UTF8: /* RFC 3629 */
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (ch > 0x10FFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (ch <= 0x7F) {
+ if (dstlen < 1) {
+ return SDL_ICONV_E2BIG;
+ }
+ *p = (Uint8) ch;
+ ++dst;
+ --dstlen;
+ } else if (ch <= 0x7FF) {
+ if (dstlen < 2) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = 0xC0 | (Uint8) ((ch >> 6) & 0x1F);
+ p[1] = 0x80 | (Uint8) (ch & 0x3F);
+ dst += 2;
+ dstlen -= 2;
+ } else if (ch <= 0xFFFF) {
+ if (dstlen < 3) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = 0xE0 | (Uint8) ((ch >> 12) & 0x0F);
+ p[1] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
+ p[2] = 0x80 | (Uint8) (ch & 0x3F);
+ dst += 3;
+ dstlen -= 3;
+ } else if (ch <= 0x1FFFFF) {
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = 0xF0 | (Uint8) ((ch >> 18) & 0x07);
+ p[1] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
+ p[2] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
+ p[3] = 0x80 | (Uint8) (ch & 0x3F);
+ dst += 4;
+ dstlen -= 4;
+ } else if (ch <= 0x3FFFFFF) {
+ if (dstlen < 5) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = 0xF8 | (Uint8) ((ch >> 24) & 0x03);
+ p[1] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
+ p[2] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
+ p[3] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
+ p[4] = 0x80 | (Uint8) (ch & 0x3F);
+ dst += 5;
+ dstlen -= 5;
+ } else {
+ if (dstlen < 6) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = 0xFC | (Uint8) ((ch >> 30) & 0x01);
+ p[1] = 0x80 | (Uint8) ((ch >> 24) & 0x3F);
+ p[2] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
+ p[3] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
+ p[4] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
+ p[5] = 0x80 | (Uint8) (ch & 0x3F);
+ dst += 6;
+ dstlen -= 6;
+ }
+ }
+ break;
+ case ENCODING_UTF16BE: /* RFC 2781 */
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (ch > 0x10FFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (ch < 0x10000) {
+ if (dstlen < 2) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = (Uint8) (ch >> 8);
+ p[1] = (Uint8) ch;
+ dst += 2;
+ dstlen -= 2;
+ } else {
+ Uint16 W1, W2;
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ ch = ch - 0x10000;
+ W1 = 0xD800 | (Uint16) ((ch >> 10) & 0x3FF);
+ W2 = 0xDC00 | (Uint16) (ch & 0x3FF);
+ p[0] = (Uint8) (W1 >> 8);
+ p[1] = (Uint8) W1;
+ p[2] = (Uint8) (W2 >> 8);
+ p[3] = (Uint8) W2;
+ dst += 4;
+ dstlen -= 4;
+ }
+ }
+ break;
+ case ENCODING_UTF16LE: /* RFC 2781 */
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (ch > 0x10FFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (ch < 0x10000) {
+ if (dstlen < 2) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[1] = (Uint8) (ch >> 8);
+ p[0] = (Uint8) ch;
+ dst += 2;
+ dstlen -= 2;
+ } else {
+ Uint16 W1, W2;
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ ch = ch - 0x10000;
+ W1 = 0xD800 | (Uint16) ((ch >> 10) & 0x3FF);
+ W2 = 0xDC00 | (Uint16) (ch & 0x3FF);
+ p[1] = (Uint8) (W1 >> 8);
+ p[0] = (Uint8) W1;
+ p[3] = (Uint8) (W2 >> 8);
+ p[2] = (Uint8) W2;
+ dst += 4;
+ dstlen -= 4;
+ }
+ }
+ break;
+ case ENCODING_UTF32BE:
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (ch > 0x10FFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[0] = (Uint8) (ch >> 24);
+ p[1] = (Uint8) (ch >> 16);
+ p[2] = (Uint8) (ch >> 8);
+ p[3] = (Uint8) ch;
+ dst += 4;
+ dstlen -= 4;
+ }
+ break;
+ case ENCODING_UTF32LE:
+ {
+ Uint8 *p = (Uint8 *) dst;
+ if (ch > 0x10FFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ p[3] = (Uint8) (ch >> 24);
+ p[2] = (Uint8) (ch >> 16);
+ p[1] = (Uint8) (ch >> 8);
+ p[0] = (Uint8) ch;
+ dst += 4;
+ dstlen -= 4;
+ }
+ break;
+ case ENCODING_UCS2:
+ {
+ Uint16 *p = (Uint16 *) dst;
+ if (ch > 0xFFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (dstlen < 2) {
+ return SDL_ICONV_E2BIG;
+ }
+ *p = (Uint16) ch;
+ dst += 2;
+ dstlen -= 2;
+ }
+ break;
+ case ENCODING_UCS4:
+ {
+ Uint32 *p = (Uint32 *) dst;
+ if (ch > 0x7FFFFFFF) {
+ ch = UNKNOWN_UNICODE;
+ }
+ if (dstlen < 4) {
+ return SDL_ICONV_E2BIG;
+ }
+ *p = ch;
+ dst += 4;
+ dstlen -= 4;
+ }
+ break;
+ }
+
+ /* Update state */
+ *inbuf = src;
+ *inbytesleft = srclen;
+ *outbuf = dst;
+ *outbytesleft = dstlen;
+ ++total;
+ }
+ return total;
}
-int SDL_iconv_close(SDL_iconv_t cd)
+int
+SDL_iconv_close(SDL_iconv_t cd)
{
- if ( cd && cd != (SDL_iconv_t)-1 ) {
- SDL_free(cd);
- }
- return 0;
+ if (cd && cd != (SDL_iconv_t) - 1) {
+ SDL_free(cd);
+ }
+ return 0;
}
#endif /* !HAVE_ICONV */
-char *SDL_iconv_string(const char *tocode, const char *fromcode, char *inbuf, size_t inbytesleft)
+char *
+SDL_iconv_string(const char *tocode, const char *fromcode, char *inbuf,
+ size_t inbytesleft)
{
- SDL_iconv_t cd;
- char *string;
- size_t stringsize;
- char *outbuf;
- size_t outbytesleft;
- size_t retCode = 0;
-
- cd = SDL_iconv_open(tocode, fromcode);
- if ( cd == (SDL_iconv_t)-1 ) {
- return NULL;
- }
-
- stringsize = inbytesleft > 4 ? inbytesleft : 4;
- string = SDL_malloc(stringsize);
- if ( !string ) {
- SDL_iconv_close(cd);
- return NULL;
- }
- outbuf = string;
- outbytesleft = stringsize;
- SDL_memset(outbuf, 0, 4);
-
- while ( inbytesleft > 0 ) {
- retCode = SDL_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
- switch (retCode) {
- case SDL_ICONV_E2BIG:
- {
- char *oldstring = string;
- stringsize *= 2;
- string = SDL_realloc(string, stringsize);
- if ( !string ) {
- SDL_iconv_close(cd);
- return NULL;
- }
- outbuf = string + (outbuf - oldstring);
- outbytesleft = stringsize - (outbuf - string);
- SDL_memset(outbuf, 0, 4);
- }
- break;
- case SDL_ICONV_EILSEQ:
- /* Try skipping some input data - not perfect, but... */
- ++inbuf;
- --inbytesleft;
- break;
- case SDL_ICONV_EINVAL:
- case SDL_ICONV_ERROR:
- /* We can't continue... */
- inbytesleft = 0;
- break;
- }
- }
- SDL_iconv_close(cd);
-
- return string;
+ SDL_iconv_t cd;
+ char *string;
+ size_t stringsize;
+ char *outbuf;
+ size_t outbytesleft;
+ size_t retCode = 0;
+
+ cd = SDL_iconv_open(tocode, fromcode);
+ if (cd == (SDL_iconv_t) - 1) {
+ return NULL;
+ }
+
+ stringsize = inbytesleft > 4 ? inbytesleft : 4;
+ string = SDL_malloc(stringsize);
+ if (!string) {
+ SDL_iconv_close(cd);
+ return NULL;
+ }
+ outbuf = string;
+ outbytesleft = stringsize;
+ SDL_memset(outbuf, 0, 4);
+
+ while (inbytesleft > 0) {
+ retCode = SDL_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+ switch (retCode) {
+ case SDL_ICONV_E2BIG:
+ {
+ char *oldstring = string;
+ stringsize *= 2;
+ string = SDL_realloc(string, stringsize);
+ if (!string) {
+ SDL_iconv_close(cd);
+ return NULL;
+ }
+ outbuf = string + (outbuf - oldstring);
+ outbytesleft = stringsize - (outbuf - string);
+ SDL_memset(outbuf, 0, 4);
+ }
+ break;
+ case SDL_ICONV_EILSEQ:
+ /* Try skipping some input data - not perfect, but... */
+ ++inbuf;
+ --inbytesleft;
+ break;
+ case SDL_ICONV_EINVAL:
+ case SDL_ICONV_ERROR:
+ /* We can't continue... */
+ inbytesleft = 0;
+ break;
+ }
+ }
+ SDL_iconv_close(cd);
+
+ return string;
}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/stdlib/SDL_malloc.c b/src/stdlib/SDL_malloc.c
index 3d973f62..63f85140 100644
--- a/src/stdlib/SDL_malloc.c
+++ b/src/stdlib/SDL_malloc.c
@@ -477,8 +477,8 @@ DEFAULT_MMAP_THRESHOLD default: 256K
#ifndef WIN32
#ifdef _WIN32
#define WIN32 1
-#endif /* _WIN32 */
-#endif /* WIN32 */
+#endif /* _WIN32 */
+#endif /* WIN32 */
#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
@@ -491,123 +491,123 @@ DEFAULT_MMAP_THRESHOLD default: 256K
#define LACKS_STRINGS_H
#define LACKS_SYS_TYPES_H
#define LACKS_ERRNO_H
-#define LACKS_FCNTL_H
+#define LACKS_FCNTL_H
#define MALLOC_FAILURE_ACTION
-#define MMAP_CLEARS 0 /* WINCE and some others apparently don't clear */
-#endif /* WIN32 */
+#define MMAP_CLEARS 0 /* WINCE and some others apparently don't clear */
+#endif /* WIN32 */
#if defined(DARWIN) || defined(_DARWIN)
/* Mac OSX docs advise not to use sbrk; it seems better to use mmap */
#ifndef HAVE_MORECORE
#define HAVE_MORECORE 0
#define HAVE_MMAP 1
-#endif /* HAVE_MORECORE */
-#endif /* DARWIN */
+#endif /* HAVE_MORECORE */
+#endif /* DARWIN */
#ifndef LACKS_SYS_TYPES_H
-#include <sys/types.h> /* For size_t */
-#endif /* LACKS_SYS_TYPES_H */
+#include <sys/types.h> /* For size_t */
+#endif /* LACKS_SYS_TYPES_H */
/* The maximum possible size_t value has all bits set */
#define MAX_SIZE_T (~(size_t)0)
#ifndef ONLY_MSPACES
#define ONLY_MSPACES 0
-#endif /* ONLY_MSPACES */
+#endif /* ONLY_MSPACES */
#ifndef MSPACES
#if ONLY_MSPACES
#define MSPACES 1
-#else /* ONLY_MSPACES */
+#else /* ONLY_MSPACES */
#define MSPACES 0
-#endif /* ONLY_MSPACES */
-#endif /* MSPACES */
+#endif /* ONLY_MSPACES */
+#endif /* MSPACES */
#ifndef MALLOC_ALIGNMENT
#define MALLOC_ALIGNMENT ((size_t)8U)
-#endif /* MALLOC_ALIGNMENT */
+#endif /* MALLOC_ALIGNMENT */
#ifndef FOOTERS
#define FOOTERS 0
-#endif /* FOOTERS */
+#endif /* FOOTERS */
#ifndef ABORT
#define ABORT abort()
-#endif /* ABORT */
+#endif /* ABORT */
#ifndef ABORT_ON_ASSERT_FAILURE
#define ABORT_ON_ASSERT_FAILURE 1
-#endif /* ABORT_ON_ASSERT_FAILURE */
+#endif /* ABORT_ON_ASSERT_FAILURE */
#ifndef PROCEED_ON_ERROR
#define PROCEED_ON_ERROR 0
-#endif /* PROCEED_ON_ERROR */
+#endif /* PROCEED_ON_ERROR */
#ifndef USE_LOCKS
#define USE_LOCKS 0
-#endif /* USE_LOCKS */
+#endif /* USE_LOCKS */
#ifndef INSECURE
#define INSECURE 0
-#endif /* INSECURE */
+#endif /* INSECURE */
#ifndef HAVE_MMAP
#define HAVE_MMAP 1
-#endif /* HAVE_MMAP */
+#endif /* HAVE_MMAP */
#ifndef MMAP_CLEARS
#define MMAP_CLEARS 1
-#endif /* MMAP_CLEARS */
+#endif /* MMAP_CLEARS */
#ifndef HAVE_MREMAP
#ifdef linux
#define HAVE_MREMAP 1
-#else /* linux */
+#else /* linux */
#define HAVE_MREMAP 0
-#endif /* linux */
-#endif /* HAVE_MREMAP */
+#endif /* linux */
+#endif /* HAVE_MREMAP */
#ifndef MALLOC_FAILURE_ACTION
#define MALLOC_FAILURE_ACTION errno = ENOMEM;
-#endif /* MALLOC_FAILURE_ACTION */
+#endif /* MALLOC_FAILURE_ACTION */
#ifndef HAVE_MORECORE
#if ONLY_MSPACES
#define HAVE_MORECORE 0
-#else /* ONLY_MSPACES */
+#else /* ONLY_MSPACES */
#define HAVE_MORECORE 1
-#endif /* ONLY_MSPACES */
-#endif /* HAVE_MORECORE */
+#endif /* ONLY_MSPACES */
+#endif /* HAVE_MORECORE */
#if !HAVE_MORECORE
#define MORECORE_CONTIGUOUS 0
-#else /* !HAVE_MORECORE */
+#else /* !HAVE_MORECORE */
#ifndef MORECORE
#define MORECORE sbrk
-#endif /* MORECORE */
+#endif /* MORECORE */
#ifndef MORECORE_CONTIGUOUS
#define MORECORE_CONTIGUOUS 1
-#endif /* MORECORE_CONTIGUOUS */
-#endif /* HAVE_MORECORE */
+#endif /* MORECORE_CONTIGUOUS */
+#endif /* HAVE_MORECORE */
#ifndef DEFAULT_GRANULARITY
#if MORECORE_CONTIGUOUS
-#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */
-#else /* MORECORE_CONTIGUOUS */
+#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */
+#else /* MORECORE_CONTIGUOUS */
#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
-#endif /* MORECORE_CONTIGUOUS */
-#endif /* DEFAULT_GRANULARITY */
+#endif /* MORECORE_CONTIGUOUS */
+#endif /* DEFAULT_GRANULARITY */
#ifndef DEFAULT_TRIM_THRESHOLD
#ifndef MORECORE_CANNOT_TRIM
#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
-#else /* MORECORE_CANNOT_TRIM */
+#else /* MORECORE_CANNOT_TRIM */
#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T
-#endif /* MORECORE_CANNOT_TRIM */
-#endif /* DEFAULT_TRIM_THRESHOLD */
+#endif /* MORECORE_CANNOT_TRIM */
+#endif /* DEFAULT_TRIM_THRESHOLD */
#ifndef DEFAULT_MMAP_THRESHOLD
#if HAVE_MMAP
#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
-#else /* HAVE_MMAP */
+#else /* HAVE_MMAP */
#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
-#endif /* HAVE_MMAP */
-#endif /* DEFAULT_MMAP_THRESHOLD */
+#endif /* HAVE_MMAP */
+#endif /* DEFAULT_MMAP_THRESHOLD */
#ifndef USE_BUILTIN_FFS
#define USE_BUILTIN_FFS 0
-#endif /* USE_BUILTIN_FFS */
+#endif /* USE_BUILTIN_FFS */
#ifndef USE_DEV_RANDOM
#define USE_DEV_RANDOM 0
-#endif /* USE_DEV_RANDOM */
+#endif /* USE_DEV_RANDOM */
#ifndef NO_MALLINFO
#define NO_MALLINFO 0
-#endif /* NO_MALLINFO */
+#endif /* NO_MALLINFO */
#ifndef MALLINFO_FIELD_TYPE
#define MALLINFO_FIELD_TYPE size_t
-#endif /* MALLINFO_FIELD_TYPE */
+#endif /* MALLINFO_FIELD_TYPE */
#define memset SDL_memset
#define memcpy SDL_memcpy
@@ -658,25 +658,27 @@ DEFAULT_MMAP_THRESHOLD default: 256K
#include "/usr/include/malloc.h"
#else /* HAVE_USR_INCLUDE_MALLOC_H */
-struct mallinfo {
- MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */
- MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */
- MALLINFO_FIELD_TYPE smblks; /* always 0 */
- MALLINFO_FIELD_TYPE hblks; /* always 0 */
- MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */
- MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */
- MALLINFO_FIELD_TYPE fsmblks; /* always 0 */
- MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
- MALLINFO_FIELD_TYPE fordblks; /* total free space */
- MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
+struct mallinfo
+{
+ MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */
+ MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */
+ MALLINFO_FIELD_TYPE smblks; /* always 0 */
+ MALLINFO_FIELD_TYPE hblks; /* always 0 */
+ MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */
+ MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */
+ MALLINFO_FIELD_TYPE fsmblks; /* always 0 */
+ MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
+ MALLINFO_FIELD_TYPE fordblks; /* total free space */
+ MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
};
#endif /* HAVE_USR_INCLUDE_MALLOC_H */
#endif /* NO_MALLINFO */
#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+extern "C"
+{
+#endif /* __cplusplus */
#if !ONLY_MSPACES
@@ -699,7 +701,7 @@ extern "C" {
#define dlmalloc_max_footprint malloc_max_footprint
#define dlindependent_calloc independent_calloc
#define dlindependent_comalloc independent_comalloc
-#endif /* USE_DL_PREFIX */
+#endif /* USE_DL_PREFIX */
/*
@@ -716,7 +718,7 @@ extern "C" {
maximum supported value of n differs across systems, but is in all
cases less than the maximum representable value of a size_t.
*/
-void* dlmalloc(size_t);
+ void *dlmalloc(size_t);
/*
free(void* p)
@@ -725,14 +727,14 @@ void* dlmalloc(size_t);
It has no effect if p is null. If p was not malloced or already
freed, free(p) will by default cause the current program to abort.
*/
-void dlfree(void*);
+ void dlfree(void *);
/*
calloc(size_t n_elements, size_t element_size);
Returns a pointer to n_elements * element_size bytes, with all locations
set to zero.
*/
-void* dlcalloc(size_t, size_t);
+ void *dlcalloc(size_t, size_t);
/*
realloc(void* p, size_t n)
@@ -757,7 +759,7 @@ void* dlcalloc(size_t, size_t);
to be used as an argument to realloc is not supported.
*/
-void* dlrealloc(void*, size_t);
+ void *dlrealloc(void *, size_t);
/*
memalign(size_t alignment, size_t n);
@@ -771,14 +773,14 @@ void* dlrealloc(void*, size_t);
Overreliance on memalign is a sure way to fragment space.
*/
-void* dlmemalign(size_t, size_t);
+ void *dlmemalign(size_t, size_t);
/*
valloc(size_t n);
Equivalent to memalign(pagesize, n), where pagesize is the page
size of the system. If the pagesize is unknown, 4096 is used.
*/
-void* dlvalloc(size_t);
+ void *dlvalloc(size_t);
/*
mallopt(int parameter_number, int parameter_value)
@@ -798,7 +800,7 @@ void* dlvalloc(size_t);
M_GRANULARITY -2 page size any power of 2 >= page size
M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support)
*/
-int dlmallopt(int, int);
+ int dlmallopt(int, int);
/*
malloc_footprint();
@@ -809,7 +811,7 @@ int dlmallopt(int, int);
Even if locks are otherwise defined, this function does not use them,
so results might not be up to date.
*/
-size_t dlmalloc_footprint(void);
+ size_t dlmalloc_footprint(void);
/*
malloc_max_footprint();
@@ -822,7 +824,7 @@ size_t dlmalloc_footprint(void);
otherwise defined, this function does not use them, so results might
not be up to date.
*/
-size_t dlmalloc_max_footprint(void);
+ size_t dlmalloc_max_footprint(void);
#if !NO_MALLINFO
/*
@@ -847,8 +849,8 @@ size_t dlmalloc_max_footprint(void);
be kept as longs, the reported values may wrap around zero and
thus be inaccurate.
*/
-struct mallinfo dlmallinfo(void);
-#endif /* NO_MALLINFO */
+ struct mallinfo dlmallinfo(void);
+#endif /* NO_MALLINFO */
/*
independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
@@ -902,7 +904,7 @@ struct mallinfo dlmallinfo(void);
return first;
}
*/
-void** dlindependent_calloc(size_t, size_t, void**);
+ void **dlindependent_calloc(size_t, size_t, void **);
/*
independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
@@ -963,7 +965,7 @@ void** dlindependent_calloc(size_t, size_t, void**);
since it cannot reuse existing noncontiguous small chunks that
might be available for some of the elements.
*/
-void** dlindependent_comalloc(size_t, size_t*, void**);
+ void **dlindependent_comalloc(size_t, size_t *, void **);
/*
@@ -971,7 +973,7 @@ void** dlindependent_comalloc(size_t, size_t*, void**);
Equivalent to valloc(minimum-page-that-holds(n)), that is,
round up n to nearest pagesize.
*/
-void* dlpvalloc(size_t);
+ void *dlpvalloc(size_t);
/*
malloc_trim(size_t pad);
@@ -994,7 +996,7 @@ void* dlpvalloc(size_t);
Malloc_trim returns 1 if it actually released any memory, else 0.
*/
-int dlmalloc_trim(size_t);
+ int dlmalloc_trim(size_t);
/*
malloc_usable_size(void* p);
@@ -1010,7 +1012,7 @@ int dlmalloc_trim(size_t);
p = malloc(n);
assert(malloc_usable_size(p) >= 256);
*/
-size_t dlmalloc_usable_size(void*);
+ size_t dlmalloc_usable_size(void *);
/*
malloc_stats();
@@ -1031,9 +1033,9 @@ size_t dlmalloc_usable_size(void*);
malloc_stats prints only the most commonly interesting statistics.
More information can be obtained by calling mallinfo.
*/
-void dlmalloc_stats(void);
+ void dlmalloc_stats(void);
-#endif /* ONLY_MSPACES */
+#endif /* ONLY_MSPACES */
#if MSPACES
@@ -1041,7 +1043,7 @@ void dlmalloc_stats(void);
mspace is an opaque type representing an independent
region of space that supports mspace_malloc, etc.
*/
-typedef void* mspace;
+ typedef void *mspace;
/*
create_mspace creates and returns a new independent space with the
@@ -1054,7 +1056,7 @@ typedef void* mspace;
compiling with a different DEFAULT_GRANULARITY or dynamically
setting with mallopt(M_GRANULARITY, value).
*/
-mspace create_mspace(size_t capacity, int locked);
+ mspace create_mspace(size_t capacity, int locked);
/*
destroy_mspace destroys the given space, and attempts to return all
@@ -1062,7 +1064,7 @@ mspace create_mspace(size_t capacity, int locked);
bytes freed. After destruction, the results of access to all memory
used by the space become undefined.
*/
-size_t destroy_mspace(mspace msp);
+ size_t destroy_mspace(mspace msp);
/*
create_mspace_with_base uses the memory supplied as the initial base
@@ -1073,13 +1075,13 @@ size_t destroy_mspace(mspace msp);
Destroying this space will deallocate all additionally allocated
space (if possible) but not the initial base.
*/
-mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+ mspace create_mspace_with_base(void *base, size_t capacity, int locked);
/*
mspace_malloc behaves as malloc, but operates within
the given space.
*/
-void* mspace_malloc(mspace msp, size_t bytes);
+ void *mspace_malloc(mspace msp, size_t bytes);
/*
mspace_free behaves as free, but operates within
@@ -1089,7 +1091,7 @@ void* mspace_malloc(mspace msp, size_t bytes);
free may be called instead of mspace_free because freed chunks from
any space are handled by their originating spaces.
*/
-void mspace_free(mspace msp, void* mem);
+ void mspace_free(mspace msp, void *mem);
/*
mspace_realloc behaves as realloc, but operates within
@@ -1100,45 +1102,45 @@ void mspace_free(mspace msp, void* mem);
realloced chunks from any space are handled by their originating
spaces.
*/
-void* mspace_realloc(mspace msp, void* mem, size_t newsize);
+ void *mspace_realloc(mspace msp, void *mem, size_t newsize);
/*
mspace_calloc behaves as calloc, but operates within
the given space.
*/
-void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+ void *mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
/*
mspace_memalign behaves as memalign, but operates within
the given space.
*/
-void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
+ void *mspace_memalign(mspace msp, size_t alignment, size_t bytes);
/*
mspace_independent_calloc behaves as independent_calloc, but
operates within the given space.
*/
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
- size_t elem_size, void* chunks[]);
+ void **mspace_independent_calloc(mspace msp, size_t n_elements,
+ size_t elem_size, void *chunks[]);
/*
mspace_independent_comalloc behaves as independent_comalloc, but
operates within the given space.
*/
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
- size_t sizes[], void* chunks[]);
+ void **mspace_independent_comalloc(mspace msp, size_t n_elements,
+ size_t sizes[], void *chunks[]);
/*
mspace_footprint() returns the number of bytes obtained from the
system for this space.
*/
-size_t mspace_footprint(mspace msp);
+ size_t mspace_footprint(mspace msp);
/*
mspace_max_footprint() returns the peak number of bytes obtained from the
system for this space.
*/
-size_t mspace_max_footprint(mspace msp);
+ size_t mspace_max_footprint(mspace msp);
#if !NO_MALLINFO
@@ -1146,30 +1148,30 @@ size_t mspace_max_footprint(mspace msp);
mspace_mallinfo behaves as mallinfo, but reports properties of
the given space.
*/
-struct mallinfo mspace_mallinfo(mspace msp);
-#endif /* NO_MALLINFO */
+ struct mallinfo mspace_mallinfo(mspace msp);
+#endif /* NO_MALLINFO */
/*
mspace_malloc_stats behaves as malloc_stats, but reports
properties of the given space.
*/
-void mspace_malloc_stats(mspace msp);
+ void mspace_malloc_stats(mspace msp);
/*
mspace_trim behaves as malloc_trim, but
operates within the given space.
*/
-int mspace_trim(mspace msp, size_t pad);
+ int mspace_trim(mspace msp, size_t pad);
/*
An alias for mallopt.
*/
-int mspace_mallopt(int, int);
+ int mspace_mallopt(int, int);
-#endif /* MSPACES */
+#endif /* MSPACES */
#ifdef __cplusplus
-}; /* end of extern "C" */
+}; /* end of extern "C" */
#endif /* __cplusplus */
/*
@@ -1185,21 +1187,21 @@ int mspace_mallopt(int, int);
/*------------------------------ internal #includes ---------------------- */
#ifdef _MSC_VER
-#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
+#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
#endif /* _MSC_VER */
#ifndef LACKS_STDIO_H
-#include <stdio.h> /* for printing in malloc_stats */
+#include <stdio.h> /* for printing in malloc_stats */
#endif
#ifndef LACKS_ERRNO_H
-#include <errno.h> /* for MALLOC_FAILURE_ACTION */
+#include <errno.h> /* for MALLOC_FAILURE_ACTION */
#endif /* LACKS_ERRNO_H */
#if FOOTERS
-#include <time.h> /* for magic initialization */
+#include <time.h> /* for magic initialization */
#endif /* FOOTERS */
#ifndef LACKS_STDLIB_H
-#include <stdlib.h> /* for abort() */
+#include <stdlib.h> /* for abort() */
#endif /* LACKS_STDLIB_H */
#ifdef DEBUG
#if ABORT_ON_ASSERT_FAILURE
@@ -1207,20 +1209,20 @@ int mspace_mallopt(int, int);
#else /* ABORT_ON_ASSERT_FAILURE */
#include <assert.h>
#endif /* ABORT_ON_ASSERT_FAILURE */
-#else /* DEBUG */
+#else /* DEBUG */
#define assert(x)
#endif /* DEBUG */
#ifndef LACKS_STRING_H
-#include <string.h> /* for memset etc */
-#endif /* LACKS_STRING_H */
+#include <string.h> /* for memset etc */
+#endif /* LACKS_STRING_H */
#if USE_BUILTIN_FFS
#ifndef LACKS_STRINGS_H
-#include <strings.h> /* for ffs */
+#include <strings.h> /* for ffs */
#endif /* LACKS_STRINGS_H */
#endif /* USE_BUILTIN_FFS */
#if HAVE_MMAP
#ifndef LACKS_SYS_MMAN_H
-#include <sys/mman.h> /* for mmap */
+#include <sys/mman.h> /* for mmap */
#endif /* LACKS_SYS_MMAN_H */
#ifndef LACKS_FCNTL_H
#include <fcntl.h>
@@ -1228,17 +1230,17 @@ int mspace_mallopt(int, int);
#endif /* HAVE_MMAP */
#if HAVE_MORECORE
#ifndef LACKS_UNISTD_H
-#include <unistd.h> /* for sbrk */
+#include <unistd.h> /* for sbrk */
#else /* LACKS_UNISTD_H */
#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-extern void* sbrk(ptrdiff_t);
+extern void *sbrk(ptrdiff_t);
#endif /* FreeBSD etc */
#endif /* LACKS_UNISTD_H */
#endif /* HAVE_MMAP */
#ifndef WIN32
#ifndef malloc_getpagesize
-# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */
+# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */
# ifndef _SC_PAGE_SIZE
# define _SC_PAGE_SIZE _SC_PAGESIZE
# endif
@@ -1247,10 +1249,10 @@ extern void* sbrk(ptrdiff_t);
# define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
# else
# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
- extern size_t getpagesize();
+extern size_t getpagesize();
# define malloc_getpagesize getpagesize()
# else
-# ifdef WIN32 /* use supplied emulation of getpagesize */
+# ifdef WIN32 /* use supplied emulation of getpagesize */
# define malloc_getpagesize getpagesize()
# else
# ifndef LACKS_SYS_PARAM_H
@@ -1321,7 +1323,7 @@ extern void* sbrk(ptrdiff_t);
/* MORECORE and MMAP must return MFAIL on failure */
#define MFAIL ((void*)(MAX_SIZE_T))
-#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */
+#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */
#if !HAVE_MMAP
#define IS_MMAPPED_BIT (SIZE_T_ZERO)
@@ -1349,7 +1351,7 @@ extern void* sbrk(ptrdiff_t);
is unlikely to be needed, but is supplied just in case.
*/
#define MMAP_FLAGS (MAP_PRIVATE)
-static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
+static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
#define CALL_MMAP(s) ((dev_zero_fd < 0) ? \
(dev_zero_fd = open("/dev/zero", O_RDWR), \
mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
@@ -1360,34 +1362,41 @@ static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
#else /* WIN32 */
/* Win32 MMAP via VirtualAlloc */
-static void* win32mmap(size_t size) {
- void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
- return (ptr != 0)? ptr: MFAIL;
+static void *
+win32mmap(size_t size)
+{
+ void *ptr =
+ VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+ return (ptr != 0) ? ptr : MFAIL;
}
/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
-static void* win32direct_mmap(size_t size) {
- void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
- PAGE_READWRITE);
- return (ptr != 0)? ptr: MFAIL;
+static void *
+win32direct_mmap(size_t size)
+{
+ void *ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
+ PAGE_READWRITE);
+ return (ptr != 0) ? ptr : MFAIL;
}
/* This function supports releasing coalesed segments */
-static int win32munmap(void* ptr, size_t size) {
- MEMORY_BASIC_INFORMATION minfo;
- char* cptr = ptr;
- while (size) {
- if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
- return -1;
- if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
- minfo.State != MEM_COMMIT || minfo.RegionSize > size)
- return -1;
- if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
- return -1;
- cptr += minfo.RegionSize;
- size -= minfo.RegionSize;
- }
- return 0;
+static int
+win32munmap(void *ptr, size_t size)
+{
+ MEMORY_BASIC_INFORMATION minfo;
+ char *cptr = ptr;
+ while (size) {
+ if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
+ return -1;
+ if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
+ minfo.State != MEM_COMMIT || minfo.RegionSize > size)
+ return -1;
+ if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
+ return -1;
+ cptr += minfo.RegionSize;
+ size -= minfo.RegionSize;
+ }
+ return 0;
}
#define CALL_MMAP(s) win32mmap(s)
@@ -1398,13 +1407,13 @@ static int win32munmap(void* ptr, size_t size) {
#if HAVE_MMAP && HAVE_MREMAP
#define CALL_MREMAP(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))
-#else /* HAVE_MMAP && HAVE_MREMAP */
+#else /* HAVE_MMAP && HAVE_MREMAP */
#define CALL_MREMAP(addr, osz, nsz, mv) MFAIL
#endif /* HAVE_MMAP && HAVE_MREMAP */
#if HAVE_MORECORE
#define CALL_MORECORE(S) MORECORE(S)
-#else /* HAVE_MORECORE */
+#else /* HAVE_MORECORE */
#define CALL_MORECORE(S) MFAIL
#endif /* HAVE_MORECORE */
@@ -1454,21 +1463,25 @@ static MLOCK_T magic_init_mutex = PTHREAD_MUTEX_INITIALIZER;
*/
#define MLOCK_T long
-static int win32_acquire_lock (MLOCK_T *sl) {
- for (;;) {
+static int
+win32_acquire_lock(MLOCK_T * sl)
+{
+ for (;;) {
#ifdef InterlockedCompareExchangePointer
- if (!InterlockedCompareExchange(sl, 1, 0))
- return 0;
-#else /* Use older void* version */
- if (!InterlockedCompareExchange((void**)sl, (void*)1, (void*)0))
- return 0;
+ if (!InterlockedCompareExchange(sl, 1, 0))
+ return 0;
+#else /* Use older void* version */
+ if (!InterlockedCompareExchange((void **) sl, (void *) 1, (void *) 0))
+ return 0;
#endif /* InterlockedCompareExchangePointer */
- Sleep (0);
- }
+ Sleep(0);
+ }
}
-static void win32_release_lock (MLOCK_T *sl) {
- InterlockedExchange (sl, 0);
+static void
+win32_release_lock(MLOCK_T * sl)
+{
+ InterlockedExchange(sl, 0);
}
#define INITIAL_LOCK(l) *(l)=0
@@ -1481,7 +1494,7 @@ static MLOCK_T magic_init_mutex;
#endif /* WIN32 */
#define USE_LOCK_BIT (2U)
-#else /* USE_LOCKS */
+#else /* USE_LOCKS */
#define USE_LOCK_BIT (0U)
#define INITIAL_LOCK(l)
#endif /* USE_LOCKS */
@@ -1497,7 +1510,7 @@ static MLOCK_T magic_init_mutex;
#if USE_LOCKS
#define ACQUIRE_MAGIC_INIT_LOCK() ACQUIRE_LOCK(&magic_init_mutex);
#define RELEASE_MAGIC_INIT_LOCK() RELEASE_LOCK(&magic_init_mutex);
-#else /* USE_LOCKS */
+#else /* USE_LOCKS */
#define ACQUIRE_MAGIC_INIT_LOCK()
#define RELEASE_MAGIC_INIT_LOCK()
#endif /* USE_LOCKS */
@@ -1640,19 +1653,20 @@ static MLOCK_T magic_init_mutex;
*/
-struct malloc_chunk {
- size_t prev_foot; /* Size of previous chunk (if free). */
- size_t head; /* Size and inuse bits. */
- struct malloc_chunk* fd; /* double links -- used only if free. */
- struct malloc_chunk* bk;
+struct malloc_chunk
+{
+ size_t prev_foot; /* Size of previous chunk (if free). */
+ size_t head; /* Size and inuse bits. */
+ struct malloc_chunk *fd; /* double links -- used only if free. */
+ struct malloc_chunk *bk;
};
-typedef struct malloc_chunk mchunk;
-typedef struct malloc_chunk* mchunkptr;
-typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */
-typedef size_t bindex_t; /* Described below */
-typedef unsigned int binmap_t; /* Described below */
-typedef unsigned int flag_t; /* The type of various bit flag sets */
+typedef struct malloc_chunk mchunk;
+typedef struct malloc_chunk *mchunkptr;
+typedef struct malloc_chunk *sbinptr; /* The type of bins of chunks */
+typedef size_t bindex_t; /* Described below */
+typedef unsigned int binmap_t; /* Described below */
+typedef unsigned int flag_t; /* The type of various bit flag sets */
/* ------------------- Chunks sizes and alignments ----------------------- */
@@ -1845,21 +1859,22 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
is of course much better.
*/
-struct malloc_tree_chunk {
- /* The first four fields must be compatible with malloc_chunk */
- size_t prev_foot;
- size_t head;
- struct malloc_tree_chunk* fd;
- struct malloc_tree_chunk* bk;
-
- struct malloc_tree_chunk* child[2];
- struct malloc_tree_chunk* parent;
- bindex_t index;
+struct malloc_tree_chunk
+{
+ /* The first four fields must be compatible with malloc_chunk */
+ size_t prev_foot;
+ size_t head;
+ struct malloc_tree_chunk *fd;
+ struct malloc_tree_chunk *bk;
+
+ struct malloc_tree_chunk *child[2];
+ struct malloc_tree_chunk *parent;
+ bindex_t index;
};
-typedef struct malloc_tree_chunk tchunk;
-typedef struct malloc_tree_chunk* tchunkptr;
-typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */
+typedef struct malloc_tree_chunk tchunk;
+typedef struct malloc_tree_chunk *tchunkptr;
+typedef struct malloc_tree_chunk *tbinptr; /* The type of bins of trees */
/* A little helper macro for trees */
#define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])
@@ -1921,18 +1936,19 @@ typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */
and deallocated/trimmed using MORECORE with negative arguments.
*/
-struct malloc_segment {
- char* base; /* base address */
- size_t size; /* allocated size */
- struct malloc_segment* next; /* ptr to next segment */
- flag_t sflags; /* mmap and extern flag */
+struct malloc_segment
+{
+ char *base; /* base address */
+ size_t size; /* allocated size */
+ struct malloc_segment *next; /* ptr to next segment */
+ flag_t sflags; /* mmap and extern flag */
};
#define is_mmapped_segment(S) ((S)->sflags & IS_MMAPPED_BIT)
#define is_extern_segment(S) ((S)->sflags & EXTERN_BIT)
-typedef struct malloc_segment msegment;
-typedef struct malloc_segment* msegmentptr;
+typedef struct malloc_segment msegment;
+typedef struct malloc_segment *msegmentptr;
/* ---------------------------- malloc_state ----------------------------- */
@@ -2019,28 +2035,29 @@ typedef struct malloc_segment* msegmentptr;
#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)
#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)
-struct malloc_state {
- binmap_t smallmap;
- binmap_t treemap;
- size_t dvsize;
- size_t topsize;
- char* least_addr;
- mchunkptr dv;
- mchunkptr top;
- size_t trim_check;
- size_t magic;
- mchunkptr smallbins[(NSMALLBINS+1)*2];
- tbinptr treebins[NTREEBINS];
- size_t footprint;
- size_t max_footprint;
- flag_t mflags;
+struct malloc_state
+{
+ binmap_t smallmap;
+ binmap_t treemap;
+ size_t dvsize;
+ size_t topsize;
+ char *least_addr;
+ mchunkptr dv;
+ mchunkptr top;
+ size_t trim_check;
+ size_t magic;
+ mchunkptr smallbins[(NSMALLBINS + 1) * 2];
+ tbinptr treebins[NTREEBINS];
+ size_t footprint;
+ size_t max_footprint;
+ flag_t mflags;
#if USE_LOCKS
- MLOCK_T mutex; /* locate lock among fields that rarely change */
-#endif /* USE_LOCKS */
- msegment seg;
+ MLOCK_T mutex; /* locate lock among fields that rarely change */
+#endif /* USE_LOCKS */
+ msegment seg;
};
-typedef struct malloc_state* mstate;
+typedef struct malloc_state *mstate;
/* ------------- Global malloc_state and malloc_params ------------------- */
@@ -2050,13 +2067,14 @@ typedef struct malloc_state* mstate;
initialized in init_mparams.
*/
-struct malloc_params {
- size_t magic;
- size_t page_size;
- size_t granularity;
- size_t mmap_threshold;
- size_t trim_threshold;
- flag_t default_mflags;
+struct malloc_params
+{
+ size_t magic;
+ size_t page_size;
+ size_t granularity;
+ size_t mmap_threshold;
+ size_t trim_threshold;
+ flag_t default_mflags;
};
static struct malloc_params mparams;
@@ -2105,30 +2123,34 @@ static struct malloc_state _gm_;
((char*)(A) >= S->base && (char*)(A) < S->base + S->size)
/* Return segment holding given address */
-static msegmentptr segment_holding(mstate m, char* addr) {
- msegmentptr sp = &m->seg;
- for (;;) {
- if (addr >= sp->base && addr < sp->base + sp->size)
- return sp;
- if ((sp = sp->next) == 0)
- return 0;
- }
+static msegmentptr
+segment_holding(mstate m, char *addr)
+{
+ msegmentptr sp = &m->seg;
+ for (;;) {
+ if (addr >= sp->base && addr < sp->base + sp->size)
+ return sp;
+ if ((sp = sp->next) == 0)
+ return 0;
+ }
}
/* Return true if segment contains a segment link */
-static int has_segment_link(mstate m, msegmentptr ss) {
- msegmentptr sp = &m->seg;
- for (;;) {
- if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size)
- return 1;
- if ((sp = sp->next) == 0)
- return 0;
- }
+static int
+has_segment_link(mstate m, msegmentptr ss)
+{
+ msegmentptr sp = &m->seg;
+ for (;;) {
+ if ((char *) sp >= ss->base && (char *) sp < ss->base + ss->size)
+ return 1;
+ if ((sp = sp->next) == 0)
+ return 0;
+ }
}
#ifndef MORECORE_CANNOT_TRIM
#define should_trim(M,s) ((s) > (M)->trim_check)
-#else /* MORECORE_CANNOT_TRIM */
+#else /* MORECORE_CANNOT_TRIM */
#define should_trim(M,s) (0)
#endif /* MORECORE_CANNOT_TRIM */
@@ -2160,11 +2182,11 @@ static int has_segment_link(mstate m, msegmentptr ss) {
#ifndef PREACTION
#define PREACTION(M) (0)
-#endif /* PREACTION */
+#endif /* PREACTION */
#ifndef POSTACTION
#define POSTACTION(M)
-#endif /* POSTACTION */
+#endif /* POSTACTION */
#endif /* USE_LOCKS */
@@ -2218,17 +2240,17 @@ static void reset_on_error(mstate m);
#define check_mmapped_chunk(M,P) do_check_mmapped_chunk(M,P)
#define check_malloc_state(M) do_check_malloc_state(M)
-static void do_check_any_chunk(mstate m, mchunkptr p);
-static void do_check_top_chunk(mstate m, mchunkptr p);
-static void do_check_mmapped_chunk(mstate m, mchunkptr p);
-static void do_check_inuse_chunk(mstate m, mchunkptr p);
-static void do_check_free_chunk(mstate m, mchunkptr p);
-static void do_check_malloced_chunk(mstate m, void* mem, size_t s);
-static void do_check_tree(mstate m, tchunkptr t);
-static void do_check_treebin(mstate m, bindex_t i);
-static void do_check_smallbin(mstate m, bindex_t i);
-static void do_check_malloc_state(mstate m);
-static int bin_find(mstate m, mchunkptr x);
+static void do_check_any_chunk(mstate m, mchunkptr p);
+static void do_check_top_chunk(mstate m, mchunkptr p);
+static void do_check_mmapped_chunk(mstate m, mchunkptr p);
+static void do_check_inuse_chunk(mstate m, mchunkptr p);
+static void do_check_free_chunk(mstate m, mchunkptr p);
+static void do_check_malloced_chunk(mstate m, void *mem, size_t s);
+static void do_check_tree(mstate m, tchunkptr t);
+static void do_check_treebin(mstate m, bindex_t i);
+static void do_check_smallbin(mstate m, bindex_t i);
+static void do_check_malloc_state(mstate m);
+static int bin_find(mstate m, mchunkptr x);
static size_t traverse_and_check(mstate m);
#endif /* DEBUG */
@@ -2394,7 +2416,7 @@ static size_t traverse_and_check(mstate m);
#if (FOOTERS && !INSECURE)
/* Check if (alleged) mstate m has expected magic field */
#define ok_magic(M) ((M)->magic == mparams.magic)
-#else /* (FOOTERS && !INSECURE) */
+#else /* (FOOTERS && !INSECURE) */
#define ok_magic(M) (1)
#endif /* (FOOTERS && !INSECURE) */
@@ -2459,446 +2481,477 @@ static size_t traverse_and_check(mstate m);
/* ---------------------------- setting mparams -------------------------- */
/* Initialize mparams */
-static int init_mparams(void) {
- if (mparams.page_size == 0) {
- size_t s;
-
- mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
- mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
+static int
+init_mparams(void)
+{
+ if (mparams.page_size == 0) {
+ size_t s;
+
+ mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
+ mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
#if MORECORE_CONTIGUOUS
- mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT;
-#else /* MORECORE_CONTIGUOUS */
- mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT;
+ mparams.default_mflags = USE_LOCK_BIT | USE_MMAP_BIT;
+#else /* MORECORE_CONTIGUOUS */
+ mparams.default_mflags =
+ USE_LOCK_BIT | USE_MMAP_BIT | USE_NONCONTIGUOUS_BIT;
#endif /* MORECORE_CONTIGUOUS */
#if (FOOTERS && !INSECURE)
- {
+ {
#if USE_DEV_RANDOM
- int fd;
- unsigned char buf[sizeof(size_t)];
- /* Try to use /dev/urandom, else fall back on using time */
- if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
- read(fd, buf, sizeof(buf)) == sizeof(buf)) {
- s = *((size_t *) buf);
- close(fd);
- }
- else
+ int fd;
+ unsigned char buf[sizeof(size_t)];
+ /* Try to use /dev/urandom, else fall back on using time */
+ if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
+ read(fd, buf, sizeof(buf)) == sizeof(buf)) {
+ s = *((size_t *) buf);
+ close(fd);
+ } else
#endif /* USE_DEV_RANDOM */
- s = (size_t)(time(0) ^ (size_t)0x55555555U);
+ s = (size_t) (time(0) ^ (size_t) 0x55555555U);
- s |= (size_t)8U; /* ensure nonzero */
- s &= ~(size_t)7U; /* improve chances of fault for bad values */
+ s |= (size_t) 8U; /* ensure nonzero */
+ s &= ~(size_t) 7U; /* improve chances of fault for bad values */
- }
+ }
#else /* (FOOTERS && !INSECURE) */
- s = (size_t)0x58585858U;
+ s = (size_t) 0x58585858U;
#endif /* (FOOTERS && !INSECURE) */
- ACQUIRE_MAGIC_INIT_LOCK();
- if (mparams.magic == 0) {
- mparams.magic = s;
- /* Set up lock for main malloc area */
- INITIAL_LOCK(&gm->mutex);
- gm->mflags = mparams.default_mflags;
- }
- RELEASE_MAGIC_INIT_LOCK();
+ ACQUIRE_MAGIC_INIT_LOCK();
+ if (mparams.magic == 0) {
+ mparams.magic = s;
+ /* Set up lock for main malloc area */
+ INITIAL_LOCK(&gm->mutex);
+ gm->mflags = mparams.default_mflags;
+ }
+ RELEASE_MAGIC_INIT_LOCK();
#ifndef WIN32
- mparams.page_size = malloc_getpagesize;
- mparams.granularity = ((DEFAULT_GRANULARITY != 0)?
- DEFAULT_GRANULARITY : mparams.page_size);
+ mparams.page_size = malloc_getpagesize;
+ mparams.granularity = ((DEFAULT_GRANULARITY != 0) ?
+ DEFAULT_GRANULARITY : mparams.page_size);
#else /* WIN32 */
- {
- SYSTEM_INFO system_info;
- GetSystemInfo(&system_info);
- mparams.page_size = system_info.dwPageSize;
- mparams.granularity = system_info.dwAllocationGranularity;
- }
+ {
+ SYSTEM_INFO system_info;
+ GetSystemInfo(&system_info);
+ mparams.page_size = system_info.dwPageSize;
+ mparams.granularity = system_info.dwAllocationGranularity;
+ }
#endif /* WIN32 */
- /* Sanity-check configuration:
- size_t must be unsigned and as wide as pointer type.
- ints must be at least 4 bytes.
- alignment must be at least 8.
- Alignment, min chunk size, and page size must all be powers of 2.
- */
- if ((sizeof(size_t) != sizeof(char*)) ||
- (MAX_SIZE_T < MIN_CHUNK_SIZE) ||
- (sizeof(int) < 4) ||
- (MALLOC_ALIGNMENT < (size_t)8U) ||
- ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) ||
- ((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) ||
- ((mparams.granularity & (mparams.granularity-SIZE_T_ONE)) != 0) ||
- ((mparams.page_size & (mparams.page_size-SIZE_T_ONE)) != 0))
- ABORT;
- }
- return 0;
+ /* Sanity-check configuration:
+ size_t must be unsigned and as wide as pointer type.
+ ints must be at least 4 bytes.
+ alignment must be at least 8.
+ Alignment, min chunk size, and page size must all be powers of 2.
+ */
+ if ((sizeof(size_t) != sizeof(char *)) ||
+ (MAX_SIZE_T < MIN_CHUNK_SIZE) ||
+ (sizeof(int) < 4) ||
+ (MALLOC_ALIGNMENT < (size_t) 8U) ||
+ ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT - SIZE_T_ONE)) != 0) ||
+ ((MCHUNK_SIZE & (MCHUNK_SIZE - SIZE_T_ONE)) != 0) ||
+ ((mparams.granularity & (mparams.granularity - SIZE_T_ONE)) != 0)
+ || ((mparams.page_size & (mparams.page_size - SIZE_T_ONE)) != 0))
+ ABORT;
+ }
+ return 0;
}
/* support for mallopt */
-static int change_mparam(int param_number, int value) {
- size_t val = (size_t)value;
- init_mparams();
- switch(param_number) {
- case M_TRIM_THRESHOLD:
- mparams.trim_threshold = val;
- return 1;
- case M_GRANULARITY:
- if (val >= mparams.page_size && ((val & (val-1)) == 0)) {
- mparams.granularity = val;
- return 1;
+static int
+change_mparam(int param_number, int value)
+{
+ size_t val = (size_t) value;
+ init_mparams();
+ switch (param_number) {
+ case M_TRIM_THRESHOLD:
+ mparams.trim_threshold = val;
+ return 1;
+ case M_GRANULARITY:
+ if (val >= mparams.page_size && ((val & (val - 1)) == 0)) {
+ mparams.granularity = val;
+ return 1;
+ } else
+ return 0;
+ case M_MMAP_THRESHOLD:
+ mparams.mmap_threshold = val;
+ return 1;
+ default:
+ return 0;
}
- else
- return 0;
- case M_MMAP_THRESHOLD:
- mparams.mmap_threshold = val;
- return 1;
- default:
- return 0;
- }
}
#if DEBUG
/* ------------------------- Debugging Support --------------------------- */
/* Check properties of any chunk, whether free, inuse, mmapped etc */
-static void do_check_any_chunk(mstate m, mchunkptr p) {
- assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
- assert(ok_address(m, p));
+static void
+do_check_any_chunk(mstate m, mchunkptr p)
+{
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
}
/* Check properties of top chunk */
-static void do_check_top_chunk(mstate m, mchunkptr p) {
- msegmentptr sp = segment_holding(m, (char*)p);
- size_t sz = chunksize(p);
- assert(sp != 0);
- assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
- assert(ok_address(m, p));
- assert(sz == m->topsize);
- assert(sz > 0);
- assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE);
- assert(pinuse(p));
- assert(!next_pinuse(p));
+static void
+do_check_top_chunk(mstate m, mchunkptr p)
+{
+ msegmentptr sp = segment_holding(m, (char *) p);
+ size_t sz = chunksize(p);
+ assert(sp != 0);
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
+ assert(sz == m->topsize);
+ assert(sz > 0);
+ assert(sz == ((sp->base + sp->size) - (char *) p) - TOP_FOOT_SIZE);
+ assert(pinuse(p));
+ assert(!next_pinuse(p));
}
/* Check properties of (inuse) mmapped chunks */
-static void do_check_mmapped_chunk(mstate m, mchunkptr p) {
- size_t sz = chunksize(p);
- size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD);
- assert(is_mmapped(p));
- assert(use_mmap(m));
- assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
- assert(ok_address(m, p));
- assert(!is_small(sz));
- assert((len & (mparams.page_size-SIZE_T_ONE)) == 0);
- assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD);
- assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0);
+static void
+do_check_mmapped_chunk(mstate m, mchunkptr p)
+{
+ size_t sz = chunksize(p);
+ size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD);
+ assert(is_mmapped(p));
+ assert(use_mmap(m));
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
+ assert(!is_small(sz));
+ assert((len & (mparams.page_size - SIZE_T_ONE)) == 0);
+ assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD);
+ assert(chunk_plus_offset(p, sz + SIZE_T_SIZE)->head == 0);
}
/* Check properties of inuse chunks */
-static void do_check_inuse_chunk(mstate m, mchunkptr p) {
- do_check_any_chunk(m, p);
- assert(cinuse(p));
- assert(next_pinuse(p));
- /* If not pinuse and not mmapped, previous chunk has OK offset */
- assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p);
- if (is_mmapped(p))
- do_check_mmapped_chunk(m, p);
+static void
+do_check_inuse_chunk(mstate m, mchunkptr p)
+{
+ do_check_any_chunk(m, p);
+ assert(cinuse(p));
+ assert(next_pinuse(p));
+ /* If not pinuse and not mmapped, previous chunk has OK offset */
+ assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p);
+ if (is_mmapped(p))
+ do_check_mmapped_chunk(m, p);
}
/* Check properties of free chunks */
-static void do_check_free_chunk(mstate m, mchunkptr p) {
- size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT);
- mchunkptr next = chunk_plus_offset(p, sz);
- do_check_any_chunk(m, p);
- assert(!cinuse(p));
- assert(!next_pinuse(p));
- assert (!is_mmapped(p));
- if (p != m->dv && p != m->top) {
- if (sz >= MIN_CHUNK_SIZE) {
- assert((sz & CHUNK_ALIGN_MASK) == 0);
- assert(is_aligned(chunk2mem(p)));
- assert(next->prev_foot == sz);
- assert(pinuse(p));
- assert (next == m->top || cinuse(next));
- assert(p->fd->bk == p);
- assert(p->bk->fd == p);
+static void
+do_check_free_chunk(mstate m, mchunkptr p)
+{
+ size_t sz = p->head & ~(PINUSE_BIT | CINUSE_BIT);
+ mchunkptr next = chunk_plus_offset(p, sz);
+ do_check_any_chunk(m, p);
+ assert(!cinuse(p));
+ assert(!next_pinuse(p));
+ assert(!is_mmapped(p));
+ if (p != m->dv && p != m->top) {
+ if (sz >= MIN_CHUNK_SIZE) {
+ assert((sz & CHUNK_ALIGN_MASK) == 0);
+ assert(is_aligned(chunk2mem(p)));
+ assert(next->prev_foot == sz);
+ assert(pinuse(p));
+ assert(next == m->top || cinuse(next));
+ assert(p->fd->bk == p);
+ assert(p->bk->fd == p);
+ } else /* markers are always of size SIZE_T_SIZE */
+ assert(sz == SIZE_T_SIZE);
}
- else /* markers are always of size SIZE_T_SIZE */
- assert(sz == SIZE_T_SIZE);
- }
}
/* Check properties of malloced chunks at the point they are malloced */
-static void do_check_malloced_chunk(mstate m, void* mem, size_t s) {
- if (mem != 0) {
- mchunkptr p = mem2chunk(mem);
- size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT);
- do_check_inuse_chunk(m, p);
- assert((sz & CHUNK_ALIGN_MASK) == 0);
- assert(sz >= MIN_CHUNK_SIZE);
- assert(sz >= s);
- /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */
- assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE));
- }
+static void
+do_check_malloced_chunk(mstate m, void *mem, size_t s)
+{
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ size_t sz = p->head & ~(PINUSE_BIT | CINUSE_BIT);
+ do_check_inuse_chunk(m, p);
+ assert((sz & CHUNK_ALIGN_MASK) == 0);
+ assert(sz >= MIN_CHUNK_SIZE);
+ assert(sz >= s);
+ /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */
+ assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE));
+ }
}
/* Check a tree and its subtrees. */
-static void do_check_tree(mstate m, tchunkptr t) {
- tchunkptr head = 0;
- tchunkptr u = t;
- bindex_t tindex = t->index;
- size_t tsize = chunksize(t);
- bindex_t idx;
- compute_tree_index(tsize, idx);
- assert(tindex == idx);
- assert(tsize >= MIN_LARGE_SIZE);
- assert(tsize >= minsize_for_tree_index(idx));
- assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1))));
-
- do { /* traverse through chain of same-sized nodes */
- do_check_any_chunk(m, ((mchunkptr)u));
- assert(u->index == tindex);
- assert(chunksize(u) == tsize);
- assert(!cinuse(u));
- assert(!next_pinuse(u));
- assert(u->fd->bk == u);
- assert(u->bk->fd == u);
- if (u->parent == 0) {
- assert(u->child[0] == 0);
- assert(u->child[1] == 0);
- }
- else {
- assert(head == 0); /* only one node on chain has parent */
- head = u;
- assert(u->parent != u);
- assert (u->parent->child[0] == u ||
- u->parent->child[1] == u ||
- *((tbinptr*)(u->parent)) == u);
- if (u->child[0] != 0) {
- assert(u->child[0]->parent == u);
- assert(u->child[0] != u);
- do_check_tree(m, u->child[0]);
- }
- if (u->child[1] != 0) {
- assert(u->child[1]->parent == u);
- assert(u->child[1] != u);
- do_check_tree(m, u->child[1]);
- }
- if (u->child[0] != 0 && u->child[1] != 0) {
- assert(chunksize(u->child[0]) < chunksize(u->child[1]));
- }
+static void
+do_check_tree(mstate m, tchunkptr t)
+{
+ tchunkptr head = 0;
+ tchunkptr u = t;
+ bindex_t tindex = t->index;
+ size_t tsize = chunksize(t);
+ bindex_t idx;
+ compute_tree_index(tsize, idx);
+ assert(tindex == idx);
+ assert(tsize >= MIN_LARGE_SIZE);
+ assert(tsize >= minsize_for_tree_index(idx));
+ assert((idx == NTREEBINS - 1)
+ || (tsize < minsize_for_tree_index((idx + 1))));
+
+ do { /* traverse through chain of same-sized nodes */
+ do_check_any_chunk(m, ((mchunkptr) u));
+ assert(u->index == tindex);
+ assert(chunksize(u) == tsize);
+ assert(!cinuse(u));
+ assert(!next_pinuse(u));
+ assert(u->fd->bk == u);
+ assert(u->bk->fd == u);
+ if (u->parent == 0) {
+ assert(u->child[0] == 0);
+ assert(u->child[1] == 0);
+ } else {
+ assert(head == 0); /* only one node on chain has parent */
+ head = u;
+ assert(u->parent != u);
+ assert(u->parent->child[0] == u ||
+ u->parent->child[1] == u ||
+ *((tbinptr *) (u->parent)) == u);
+ if (u->child[0] != 0) {
+ assert(u->child[0]->parent == u);
+ assert(u->child[0] != u);
+ do_check_tree(m, u->child[0]);
+ }
+ if (u->child[1] != 0) {
+ assert(u->child[1]->parent == u);
+ assert(u->child[1] != u);
+ do_check_tree(m, u->child[1]);
+ }
+ if (u->child[0] != 0 && u->child[1] != 0) {
+ assert(chunksize(u->child[0]) < chunksize(u->child[1]));
+ }
+ }
+ u = u->fd;
}
- u = u->fd;
- } while (u != t);
- assert(head != 0);
+ while (u != t);
+ assert(head != 0);
}
/* Check all the chunks in a treebin. */
-static void do_check_treebin(mstate m, bindex_t i) {
- tbinptr* tb = treebin_at(m, i);
- tchunkptr t = *tb;
- int empty = (m->treemap & (1U << i)) == 0;
- if (t == 0)
- assert(empty);
- if (!empty)
- do_check_tree(m, t);
+static void
+do_check_treebin(mstate m, bindex_t i)
+{
+ tbinptr *tb = treebin_at(m, i);
+ tchunkptr t = *tb;
+ int empty = (m->treemap & (1U << i)) == 0;
+ if (t == 0)
+ assert(empty);
+ if (!empty)
+ do_check_tree(m, t);
}
/* Check all the chunks in a smallbin. */
-static void do_check_smallbin(mstate m, bindex_t i) {
- sbinptr b = smallbin_at(m, i);
- mchunkptr p = b->bk;
- unsigned int empty = (m->smallmap & (1U << i)) == 0;
- if (p == b)
- assert(empty);
- if (!empty) {
- for (; p != b; p = p->bk) {
- size_t size = chunksize(p);
- mchunkptr q;
- /* each chunk claims to be free */
- do_check_free_chunk(m, p);
- /* chunk belongs in bin */
- assert(small_index(size) == i);
- assert(p->bk == b || chunksize(p->bk) == chunksize(p));
- /* chunk is followed by an inuse chunk */
- q = next_chunk(p);
- if (q->head != FENCEPOST_HEAD)
- do_check_inuse_chunk(m, q);
+static void
+do_check_smallbin(mstate m, bindex_t i)
+{
+ sbinptr b = smallbin_at(m, i);
+ mchunkptr p = b->bk;
+ unsigned int empty = (m->smallmap & (1U << i)) == 0;
+ if (p == b)
+ assert(empty);
+ if (!empty) {
+ for (; p != b; p = p->bk) {
+ size_t size = chunksize(p);
+ mchunkptr q;
+ /* each chunk claims to be free */
+ do_check_free_chunk(m, p);
+ /* chunk belongs in bin */
+ assert(small_index(size) == i);
+ assert(p->bk == b || chunksize(p->bk) == chunksize(p));
+ /* chunk is followed by an inuse chunk */
+ q = next_chunk(p);
+ if (q->head != FENCEPOST_HEAD)
+ do_check_inuse_chunk(m, q);
+ }
}
- }
}
/* Find x in a bin. Used in other check functions. */
-static int bin_find(mstate m, mchunkptr x) {
- size_t size = chunksize(x);
- if (is_small(size)) {
- bindex_t sidx = small_index(size);
- sbinptr b = smallbin_at(m, sidx);
- if (smallmap_is_marked(m, sidx)) {
- mchunkptr p = b;
- do {
- if (p == x)
- return 1;
- } while ((p = p->fd) != b);
- }
- }
- else {
- bindex_t tidx;
- compute_tree_index(size, tidx);
- if (treemap_is_marked(m, tidx)) {
- tchunkptr t = *treebin_at(m, tidx);
- size_t sizebits = size << leftshift_for_tree_index(tidx);
- while (t != 0 && chunksize(t) != size) {
- t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
- sizebits <<= 1;
- }
- if (t != 0) {
- tchunkptr u = t;
- do {
- if (u == (tchunkptr)x)
- return 1;
- } while ((u = u->fd) != t);
- }
+static int
+bin_find(mstate m, mchunkptr x)
+{
+ size_t size = chunksize(x);
+ if (is_small(size)) {
+ bindex_t sidx = small_index(size);
+ sbinptr b = smallbin_at(m, sidx);
+ if (smallmap_is_marked(m, sidx)) {
+ mchunkptr p = b;
+ do {
+ if (p == x)
+ return 1;
+ }
+ while ((p = p->fd) != b);
+ }
+ } else {
+ bindex_t tidx;
+ compute_tree_index(size, tidx);
+ if (treemap_is_marked(m, tidx)) {
+ tchunkptr t = *treebin_at(m, tidx);
+ size_t sizebits = size << leftshift_for_tree_index(tidx);
+ while (t != 0 && chunksize(t) != size) {
+ t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
+ sizebits <<= 1;
+ }
+ if (t != 0) {
+ tchunkptr u = t;
+ do {
+ if (u == (tchunkptr) x)
+ return 1;
+ }
+ while ((u = u->fd) != t);
+ }
+ }
}
- }
- return 0;
+ return 0;
}
/* Traverse each chunk and check it; return total */
-static size_t traverse_and_check(mstate m) {
- size_t sum = 0;
- if (is_initialized(m)) {
- msegmentptr s = &m->seg;
- sum += m->topsize + TOP_FOOT_SIZE;
- while (s != 0) {
- mchunkptr q = align_as_chunk(s->base);
- mchunkptr lastq = 0;
- assert(pinuse(q));
- while (segment_holds(s, q) &&
- q != m->top && q->head != FENCEPOST_HEAD) {
- sum += chunksize(q);
- if (cinuse(q)) {
- assert(!bin_find(m, q));
- do_check_inuse_chunk(m, q);
- }
- else {
- assert(q == m->dv || bin_find(m, q));
- assert(lastq == 0 || cinuse(lastq)); /* Not 2 consecutive free */
- do_check_free_chunk(m, q);
+static size_t
+traverse_and_check(mstate m)
+{
+ size_t sum = 0;
+ if (is_initialized(m)) {
+ msegmentptr s = &m->seg;
+ sum += m->topsize + TOP_FOOT_SIZE;
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ mchunkptr lastq = 0;
+ assert(pinuse(q));
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ sum += chunksize(q);
+ if (cinuse(q)) {
+ assert(!bin_find(m, q));
+ do_check_inuse_chunk(m, q);
+ } else {
+ assert(q == m->dv || bin_find(m, q));
+ assert(lastq == 0 || cinuse(lastq)); /* Not 2 consecutive free */
+ do_check_free_chunk(m, q);
+ }
+ lastq = q;
+ q = next_chunk(q);
+ }
+ s = s->next;
}
- lastq = q;
- q = next_chunk(q);
- }
- s = s->next;
}
- }
- return sum;
+ return sum;
}
/* Check all properties of malloc_state. */
-static void do_check_malloc_state(mstate m) {
- bindex_t i;
- size_t total;
- /* check bins */
- for (i = 0; i < NSMALLBINS; ++i)
- do_check_smallbin(m, i);
- for (i = 0; i < NTREEBINS; ++i)
- do_check_treebin(m, i);
-
- if (m->dvsize != 0) { /* check dv chunk */
- do_check_any_chunk(m, m->dv);
- assert(m->dvsize == chunksize(m->dv));
- assert(m->dvsize >= MIN_CHUNK_SIZE);
- assert(bin_find(m, m->dv) == 0);
- }
+static void
+do_check_malloc_state(mstate m)
+{
+ bindex_t i;
+ size_t total;
+ /* check bins */
+ for (i = 0; i < NSMALLBINS; ++i)
+ do_check_smallbin(m, i);
+ for (i = 0; i < NTREEBINS; ++i)
+ do_check_treebin(m, i);
+
+ if (m->dvsize != 0) { /* check dv chunk */
+ do_check_any_chunk(m, m->dv);
+ assert(m->dvsize == chunksize(m->dv));
+ assert(m->dvsize >= MIN_CHUNK_SIZE);
+ assert(bin_find(m, m->dv) == 0);
+ }
- if (m->top != 0) { /* check top chunk */
- do_check_top_chunk(m, m->top);
- assert(m->topsize == chunksize(m->top));
- assert(m->topsize > 0);
- assert(bin_find(m, m->top) == 0);
- }
+ if (m->top != 0) { /* check top chunk */
+ do_check_top_chunk(m, m->top);
+ assert(m->topsize == chunksize(m->top));
+ assert(m->topsize > 0);
+ assert(bin_find(m, m->top) == 0);
+ }
- total = traverse_and_check(m);
- assert(total <= m->footprint);
- assert(m->footprint <= m->max_footprint);
+ total = traverse_and_check(m);
+ assert(total <= m->footprint);
+ assert(m->footprint <= m->max_footprint);
}
#endif /* DEBUG */
/* ----------------------------- statistics ------------------------------ */
#if !NO_MALLINFO
-static struct mallinfo internal_mallinfo(mstate m) {
- struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
- if (!PREACTION(m)) {
- check_malloc_state(m);
- if (is_initialized(m)) {
- size_t nfree = SIZE_T_ONE; /* top always free */
- size_t mfree = m->topsize + TOP_FOOT_SIZE;
- size_t sum = mfree;
- msegmentptr s = &m->seg;
- while (s != 0) {
- mchunkptr q = align_as_chunk(s->base);
- while (segment_holds(s, q) &&
- q != m->top && q->head != FENCEPOST_HEAD) {
- size_t sz = chunksize(q);
- sum += sz;
- if (!cinuse(q)) {
- mfree += sz;
- ++nfree;
- }
- q = next_chunk(q);
+static struct mallinfo
+internal_mallinfo(mstate m)
+{
+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ if (!PREACTION(m)) {
+ check_malloc_state(m);
+ if (is_initialized(m)) {
+ size_t nfree = SIZE_T_ONE; /* top always free */
+ size_t mfree = m->topsize + TOP_FOOT_SIZE;
+ size_t sum = mfree;
+ msegmentptr s = &m->seg;
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ size_t sz = chunksize(q);
+ sum += sz;
+ if (!cinuse(q)) {
+ mfree += sz;
+ ++nfree;
+ }
+ q = next_chunk(q);
+ }
+ s = s->next;
+ }
+
+ nm.arena = sum;
+ nm.ordblks = nfree;
+ nm.hblkhd = m->footprint - sum;
+ nm.usmblks = m->max_footprint;
+ nm.uordblks = m->footprint - mfree;
+ nm.fordblks = mfree;
+ nm.keepcost = m->topsize;
}
- s = s->next;
- }
- nm.arena = sum;
- nm.ordblks = nfree;
- nm.hblkhd = m->footprint - sum;
- nm.usmblks = m->max_footprint;
- nm.uordblks = m->footprint - mfree;
- nm.fordblks = mfree;
- nm.keepcost = m->topsize;
+ POSTACTION(m);
}
-
- POSTACTION(m);
- }
- return nm;
+ return nm;
}
#endif /* !NO_MALLINFO */
-static void internal_malloc_stats(mstate m) {
- if (!PREACTION(m)) {
- size_t maxfp = 0;
- size_t fp = 0;
- size_t used = 0;
- check_malloc_state(m);
- if (is_initialized(m)) {
- msegmentptr s = &m->seg;
- maxfp = m->max_footprint;
- fp = m->footprint;
- used = fp - (m->topsize + TOP_FOOT_SIZE);
-
- while (s != 0) {
- mchunkptr q = align_as_chunk(s->base);
- while (segment_holds(s, q) &&
- q != m->top && q->head != FENCEPOST_HEAD) {
- if (!cinuse(q))
- used -= chunksize(q);
- q = next_chunk(q);
+static void
+internal_malloc_stats(mstate m)
+{
+ if (!PREACTION(m)) {
+ size_t maxfp = 0;
+ size_t fp = 0;
+ size_t used = 0;
+ check_malloc_state(m);
+ if (is_initialized(m)) {
+ msegmentptr s = &m->seg;
+ maxfp = m->max_footprint;
+ fp = m->footprint;
+ used = fp - (m->topsize + TOP_FOOT_SIZE);
+
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ if (!cinuse(q))
+ used -= chunksize(q);
+ q = next_chunk(q);
+ }
+ s = s->next;
+ }
}
- s = s->next;
- }
- }
-
#ifndef LACKS_STDIO_H
- fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp));
- fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp));
- fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used));
+ fprintf(stderr, "max system bytes = %10lu\n",
+ (unsigned long) (maxfp));
+ fprintf(stderr, "system bytes = %10lu\n", (unsigned long) (fp));
+ fprintf(stderr, "in use bytes = %10lu\n", (unsigned long) (used));
#endif
- POSTACTION(m);
- }
+ POSTACTION(m);
+ }
}
/* ----------------------- Operations on smallbins ----------------------- */
@@ -3162,905 +3215,925 @@ static void internal_malloc_stats(mstate m) {
*/
/* Malloc using mmap */
-static void* mmap_alloc(mstate m, size_t nb) {
- size_t mmsize = granularity_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
- if (mmsize > nb) { /* Check for wrap around 0 */
- char* mm = (char*)(DIRECT_MMAP(mmsize));
- if (mm != CMFAIL) {
- size_t offset = align_offset(chunk2mem(mm));
- size_t psize = mmsize - offset - MMAP_FOOT_PAD;
- mchunkptr p = (mchunkptr)(mm + offset);
- p->prev_foot = offset | IS_MMAPPED_BIT;
- (p)->head = (psize|CINUSE_BIT);
- mark_inuse_foot(m, p, psize);
- chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
- chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0;
-
- if (mm < m->least_addr)
- m->least_addr = mm;
- if ((m->footprint += mmsize) > m->max_footprint)
- m->max_footprint = m->footprint;
- assert(is_aligned(chunk2mem(p)));
- check_mmapped_chunk(m, p);
- return chunk2mem(p);
+static void *
+mmap_alloc(mstate m, size_t nb)
+{
+ size_t mmsize =
+ granularity_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ if (mmsize > nb) { /* Check for wrap around 0 */
+ char *mm = (char *) (DIRECT_MMAP(mmsize));
+ if (mm != CMFAIL) {
+ size_t offset = align_offset(chunk2mem(mm));
+ size_t psize = mmsize - offset - MMAP_FOOT_PAD;
+ mchunkptr p = (mchunkptr) (mm + offset);
+ p->prev_foot = offset | IS_MMAPPED_BIT;
+ (p)->head = (psize | CINUSE_BIT);
+ mark_inuse_foot(m, p, psize);
+ chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
+ chunk_plus_offset(p, psize + SIZE_T_SIZE)->head = 0;
+
+ if (mm < m->least_addr)
+ m->least_addr = mm;
+ if ((m->footprint += mmsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+ assert(is_aligned(chunk2mem(p)));
+ check_mmapped_chunk(m, p);
+ return chunk2mem(p);
+ }
}
- }
- return 0;
+ return 0;
}
/* Realloc using mmap */
-static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb) {
- size_t oldsize = chunksize(oldp);
- if (is_small(nb)) /* Can't shrink mmap regions below small size */
- return 0;
- /* Keep old chunk if big enough but not too big */
- if (oldsize >= nb + SIZE_T_SIZE &&
- (oldsize - nb) <= (mparams.granularity << 1))
- return oldp;
- else {
- size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
- size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
- size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
- CHUNK_ALIGN_MASK);
- char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
- oldmmsize, newmmsize, 1);
- if (cp != CMFAIL) {
- mchunkptr newp = (mchunkptr)(cp + offset);
- size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
- newp->head = (psize|CINUSE_BIT);
- mark_inuse_foot(m, newp, psize);
- chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
- chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0;
-
- if (cp < m->least_addr)
- m->least_addr = cp;
- if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
- m->max_footprint = m->footprint;
- check_mmapped_chunk(m, newp);
- return newp;
+static mchunkptr
+mmap_resize(mstate m, mchunkptr oldp, size_t nb)
+{
+ size_t oldsize = chunksize(oldp);
+ if (is_small(nb)) /* Can't shrink mmap regions below small size */
+ return 0;
+ /* Keep old chunk if big enough but not too big */
+ if (oldsize >= nb + SIZE_T_SIZE &&
+ (oldsize - nb) <= (mparams.granularity << 1))
+ return oldp;
+ else {
+ size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
+ size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
+ size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
+ CHUNK_ALIGN_MASK);
+ char *cp = (char *) CALL_MREMAP((char *) oldp - offset,
+ oldmmsize, newmmsize, 1);
+ if (cp != CMFAIL) {
+ mchunkptr newp = (mchunkptr) (cp + offset);
+ size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
+ newp->head = (psize | CINUSE_BIT);
+ mark_inuse_foot(m, newp, psize);
+ chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
+ chunk_plus_offset(newp, psize + SIZE_T_SIZE)->head = 0;
+
+ if (cp < m->least_addr)
+ m->least_addr = cp;
+ if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+ check_mmapped_chunk(m, newp);
+ return newp;
+ }
}
- }
- return 0;
+ return 0;
}
/* -------------------------- mspace management -------------------------- */
/* Initialize top chunk and its size */
-static void init_top(mstate m, mchunkptr p, size_t psize) {
- /* Ensure alignment */
- size_t offset = align_offset(chunk2mem(p));
- p = (mchunkptr)((char*)p + offset);
- psize -= offset;
-
- m->top = p;
- m->topsize = psize;
- p->head = psize | PINUSE_BIT;
- /* set size of fake trailing chunk holding overhead space only once */
- chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
- m->trim_check = mparams.trim_threshold; /* reset on each update */
+static void
+init_top(mstate m, mchunkptr p, size_t psize)
+{
+ /* Ensure alignment */
+ size_t offset = align_offset(chunk2mem(p));
+ p = (mchunkptr) ((char *) p + offset);
+ psize -= offset;
+
+ m->top = p;
+ m->topsize = psize;
+ p->head = psize | PINUSE_BIT;
+ /* set size of fake trailing chunk holding overhead space only once */
+ chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
+ m->trim_check = mparams.trim_threshold; /* reset on each update */
}
/* Initialize bins for a new mstate that is otherwise zeroed out */
-static void init_bins(mstate m) {
- /* Establish circular links for smallbins */
- bindex_t i;
- for (i = 0; i < NSMALLBINS; ++i) {
- sbinptr bin = smallbin_at(m,i);
- bin->fd = bin->bk = bin;
- }
+static void
+init_bins(mstate m)
+{
+ /* Establish circular links for smallbins */
+ bindex_t i;
+ for (i = 0; i < NSMALLBINS; ++i) {
+ sbinptr bin = smallbin_at(m, i);
+ bin->fd = bin->bk = bin;
+ }
}
#if PROCEED_ON_ERROR
/* default corruption action */
-static void reset_on_error(mstate m) {
- int i;
- ++malloc_corruption_error_count;
- /* Reinitialize fields to forget about all memory */
- m->smallbins = m->treebins = 0;
- m->dvsize = m->topsize = 0;
- m->seg.base = 0;
- m->seg.size = 0;
- m->seg.next = 0;
- m->top = m->dv = 0;
- for (i = 0; i < NTREEBINS; ++i)
- *treebin_at(m, i) = 0;
- init_bins(m);
+static void
+reset_on_error(mstate m)
+{
+ int i;
+ ++malloc_corruption_error_count;
+ /* Reinitialize fields to forget about all memory */
+ m->smallbins = m->treebins = 0;
+ m->dvsize = m->topsize = 0;
+ m->seg.base = 0;
+ m->seg.size = 0;
+ m->seg.next = 0;
+ m->top = m->dv = 0;
+ for (i = 0; i < NTREEBINS; ++i)
+ *treebin_at(m, i) = 0;
+ init_bins(m);
}
#endif /* PROCEED_ON_ERROR */
/* Allocate chunk and prepend remainder with chunk in successor base. */
-static void* prepend_alloc(mstate m, char* newbase, char* oldbase,
- size_t nb) {
- mchunkptr p = align_as_chunk(newbase);
- mchunkptr oldfirst = align_as_chunk(oldbase);
- size_t psize = (char*)oldfirst - (char*)p;
- mchunkptr q = chunk_plus_offset(p, nb);
- size_t qsize = psize - nb;
- set_size_and_pinuse_of_inuse_chunk(m, p, nb);
-
- assert((char*)oldfirst > (char*)q);
- assert(pinuse(oldfirst));
- assert(qsize >= MIN_CHUNK_SIZE);
-
- /* consolidate remainder with first chunk of old base */
- if (oldfirst == m->top) {
- size_t tsize = m->topsize += qsize;
- m->top = q;
- q->head = tsize | PINUSE_BIT;
- check_top_chunk(m, q);
- }
- else if (oldfirst == m->dv) {
- size_t dsize = m->dvsize += qsize;
- m->dv = q;
- set_size_and_pinuse_of_free_chunk(q, dsize);
- }
- else {
- if (!cinuse(oldfirst)) {
- size_t nsize = chunksize(oldfirst);
- unlink_chunk(m, oldfirst, nsize);
- oldfirst = chunk_plus_offset(oldfirst, nsize);
- qsize += nsize;
+static void *
+prepend_alloc(mstate m, char *newbase, char *oldbase, size_t nb)
+{
+ mchunkptr p = align_as_chunk(newbase);
+ mchunkptr oldfirst = align_as_chunk(oldbase);
+ size_t psize = (char *) oldfirst - (char *) p;
+ mchunkptr q = chunk_plus_offset(p, nb);
+ size_t qsize = psize - nb;
+ set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+
+ assert((char *) oldfirst > (char *) q);
+ assert(pinuse(oldfirst));
+ assert(qsize >= MIN_CHUNK_SIZE);
+
+ /* consolidate remainder with first chunk of old base */
+ if (oldfirst == m->top) {
+ size_t tsize = m->topsize += qsize;
+ m->top = q;
+ q->head = tsize | PINUSE_BIT;
+ check_top_chunk(m, q);
+ } else if (oldfirst == m->dv) {
+ size_t dsize = m->dvsize += qsize;
+ m->dv = q;
+ set_size_and_pinuse_of_free_chunk(q, dsize);
+ } else {
+ if (!cinuse(oldfirst)) {
+ size_t nsize = chunksize(oldfirst);
+ unlink_chunk(m, oldfirst, nsize);
+ oldfirst = chunk_plus_offset(oldfirst, nsize);
+ qsize += nsize;
+ }
+ set_free_with_pinuse(q, qsize, oldfirst);
+ insert_chunk(m, q, qsize);
+ check_free_chunk(m, q);
}
- set_free_with_pinuse(q, qsize, oldfirst);
- insert_chunk(m, q, qsize);
- check_free_chunk(m, q);
- }
- check_malloced_chunk(m, chunk2mem(p), nb);
- return chunk2mem(p);
+ check_malloced_chunk(m, chunk2mem(p), nb);
+ return chunk2mem(p);
}
/* Add a segment to hold a new noncontiguous region */
-static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
- /* Determine locations and sizes of segment, fenceposts, old top */
- char* old_top = (char*)m->top;
- msegmentptr oldsp = segment_holding(m, old_top);
- char* old_end = oldsp->base + oldsp->size;
- size_t ssize = pad_request(sizeof(struct malloc_segment));
- char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
- size_t offset = align_offset(chunk2mem(rawsp));
- char* asp = rawsp + offset;
- char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp;
- mchunkptr sp = (mchunkptr)csp;
- msegmentptr ss = (msegmentptr)(chunk2mem(sp));
- mchunkptr tnext = chunk_plus_offset(sp, ssize);
- mchunkptr p = tnext;
- int nfences = 0;
-
- /* reset top to new space */
- init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
-
- /* Set up segment record */
- assert(is_aligned(ss));
- set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
- *ss = m->seg; /* Push current record */
- m->seg.base = tbase;
- m->seg.size = tsize;
- m->seg.sflags = mmapped;
- m->seg.next = ss;
-
- /* Insert trailing fenceposts */
- for (;;) {
- mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
- p->head = FENCEPOST_HEAD;
- ++nfences;
- if ((char*)(&(nextp->head)) < old_end)
- p = nextp;
- else
- break;
- }
- assert(nfences >= 2);
-
- /* Insert the rest of old top into a bin as an ordinary free chunk */
- if (csp != old_top) {
- mchunkptr q = (mchunkptr)old_top;
- size_t psize = csp - old_top;
- mchunkptr tn = chunk_plus_offset(q, psize);
- set_free_with_pinuse(q, psize, tn);
- insert_chunk(m, q, psize);
- }
+static void
+add_segment(mstate m, char *tbase, size_t tsize, flag_t mmapped)
+{
+ /* Determine locations and sizes of segment, fenceposts, old top */
+ char *old_top = (char *) m->top;
+ msegmentptr oldsp = segment_holding(m, old_top);
+ char *old_end = oldsp->base + oldsp->size;
+ size_t ssize = pad_request(sizeof(struct malloc_segment));
+ char *rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ size_t offset = align_offset(chunk2mem(rawsp));
+ char *asp = rawsp + offset;
+ char *csp = (asp < (old_top + MIN_CHUNK_SIZE)) ? old_top : asp;
+ mchunkptr sp = (mchunkptr) csp;
+ msegmentptr ss = (msegmentptr) (chunk2mem(sp));
+ mchunkptr tnext = chunk_plus_offset(sp, ssize);
+ mchunkptr p = tnext;
+ int nfences = 0;
+
+ /* reset top to new space */
+ init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
+
+ /* Set up segment record */
+ assert(is_aligned(ss));
+ set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
+ *ss = m->seg; /* Push current record */
+ m->seg.base = tbase;
+ m->seg.size = tsize;
+ m->seg.sflags = mmapped;
+ m->seg.next = ss;
+
+ /* Insert trailing fenceposts */
+ for (;;) {
+ mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
+ p->head = FENCEPOST_HEAD;
+ ++nfences;
+ if ((char *) (&(nextp->head)) < old_end)
+ p = nextp;
+ else
+ break;
+ }
+ assert(nfences >= 2);
+
+ /* Insert the rest of old top into a bin as an ordinary free chunk */
+ if (csp != old_top) {
+ mchunkptr q = (mchunkptr) old_top;
+ size_t psize = csp - old_top;
+ mchunkptr tn = chunk_plus_offset(q, psize);
+ set_free_with_pinuse(q, psize, tn);
+ insert_chunk(m, q, psize);
+ }
- check_top_chunk(m, m->top);
+ check_top_chunk(m, m->top);
}
/* -------------------------- System allocation -------------------------- */
/* Get memory from system using MORECORE or MMAP */
-static void* sys_alloc(mstate m, size_t nb) {
- char* tbase = CMFAIL;
- size_t tsize = 0;
- flag_t mmap_flag = 0;
-
- init_mparams();
-
- /* Directly map large chunks */
- if (use_mmap(m) && nb >= mparams.mmap_threshold) {
- void* mem = mmap_alloc(m, nb);
- if (mem != 0)
- return mem;
- }
+static void *
+sys_alloc(mstate m, size_t nb)
+{
+ char *tbase = CMFAIL;
+ size_t tsize = 0;
+ flag_t mmap_flag = 0;
+
+ init_mparams();
+
+ /* Directly map large chunks */
+ if (use_mmap(m) && nb >= mparams.mmap_threshold) {
+ void *mem = mmap_alloc(m, nb);
+ if (mem != 0)
+ return mem;
+ }
- /*
- Try getting memory in any of three ways (in most-preferred to
- least-preferred order):
- 1. A call to MORECORE that can normally contiguously extend memory.
+ /*
+ Try getting memory in any of three ways (in most-preferred to
+ least-preferred order):
+ 1. A call to MORECORE that can normally contiguously extend memory.
(disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
or main space is mmapped or a previous contiguous call failed)
- 2. A call to MMAP new space (disabled if not HAVE_MMAP).
+ 2. A call to MMAP new space (disabled if not HAVE_MMAP).
Note that under the default settings, if MORECORE is unable to
fulfill a request, and HAVE_MMAP is true, then mmap is
used as a noncontiguous system allocator. This is a useful backup
strategy for systems with holes in address spaces -- in this case
sbrk cannot contiguously expand the heap, but mmap may be able to
find space.
- 3. A call to MORECORE that cannot usually contiguously extend memory.
+ 3. A call to MORECORE that cannot usually contiguously extend memory.
(disabled if not HAVE_MORECORE)
- */
-
- if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
- char* br = CMFAIL;
- msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top);
- size_t asize = 0;
- ACQUIRE_MORECORE_LOCK();
-
- if (ss == 0) { /* First time through or recovery */
- char* base = (char*)CALL_MORECORE(0);
- if (base != CMFAIL) {
- asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
- /* Adjust to end on a page boundary */
- if (!is_page_aligned(base))
- asize += (page_align((size_t)base) - (size_t)base);
- /* Can't call MORECORE if size is negative when treated as signed */
- if (asize < HALF_MAX_SIZE_T &&
- (br = (char*)(CALL_MORECORE(asize))) == base) {
- tbase = base;
- tsize = asize;
+ */
+
+ if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
+ char *br = CMFAIL;
+ msegmentptr ss =
+ (m->top == 0) ? 0 : segment_holding(m, (char *) m->top);
+ size_t asize = 0;
+ ACQUIRE_MORECORE_LOCK();
+
+ if (ss == 0) { /* First time through or recovery */
+ char *base = (char *) CALL_MORECORE(0);
+ if (base != CMFAIL) {
+ asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
+ /* Adjust to end on a page boundary */
+ if (!is_page_aligned(base))
+ asize += (page_align((size_t) base) - (size_t) base);
+ /* Can't call MORECORE if size is negative when treated as signed */
+ if (asize < HALF_MAX_SIZE_T &&
+ (br = (char *) (CALL_MORECORE(asize))) == base) {
+ tbase = base;
+ tsize = asize;
+ }
+ }
+ } else {
+ /* Subtract out existing available top space from MORECORE request. */
+ asize =
+ granularity_align(nb - m->topsize + TOP_FOOT_SIZE +
+ SIZE_T_ONE);
+ /* Use mem here only if it did continuously extend old space */
+ if (asize < HALF_MAX_SIZE_T &&
+ (br =
+ (char *) (CALL_MORECORE(asize))) == ss->base + ss->size) {
+ tbase = br;
+ tsize = asize;
+ }
}
- }
- }
- else {
- /* Subtract out existing available top space from MORECORE request. */
- asize = granularity_align(nb - m->topsize + TOP_FOOT_SIZE + SIZE_T_ONE);
- /* Use mem here only if it did continuously extend old space */
- if (asize < HALF_MAX_SIZE_T &&
- (br = (char*)(CALL_MORECORE(asize))) == ss->base+ss->size) {
- tbase = br;
- tsize = asize;
- }
- }
- if (tbase == CMFAIL) { /* Cope with partial failure */
- if (br != CMFAIL) { /* Try to use/extend the space we did get */
- if (asize < HALF_MAX_SIZE_T &&
- asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
- size_t esize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE - asize);
- if (esize < HALF_MAX_SIZE_T) {
- char* end = (char*)CALL_MORECORE(esize);
- if (end != CMFAIL)
- asize += esize;
- else { /* Can't use; try to release */
- end = (char*)CALL_MORECORE(-asize);
- br = CMFAIL;
+ if (tbase == CMFAIL) { /* Cope with partial failure */
+ if (br != CMFAIL) { /* Try to use/extend the space we did get */
+ if (asize < HALF_MAX_SIZE_T &&
+ asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
+ size_t esize =
+ granularity_align(nb + TOP_FOOT_SIZE +
+ SIZE_T_ONE - asize);
+ if (esize < HALF_MAX_SIZE_T) {
+ char *end = (char *) CALL_MORECORE(esize);
+ if (end != CMFAIL)
+ asize += esize;
+ else { /* Can't use; try to release */
+ end = (char *) CALL_MORECORE(-asize);
+ br = CMFAIL;
+ }
+ }
+ }
}
- }
+ if (br != CMFAIL) { /* Use the space we did get */
+ tbase = br;
+ tsize = asize;
+ } else
+ disable_contiguous(m); /* Don't try contiguous path in the future */
}
- }
- if (br != CMFAIL) { /* Use the space we did get */
- tbase = br;
- tsize = asize;
- }
- else
- disable_contiguous(m); /* Don't try contiguous path in the future */
- }
- RELEASE_MORECORE_LOCK();
- }
-
- if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
- size_t req = nb + TOP_FOOT_SIZE + SIZE_T_ONE;
- size_t rsize = granularity_align(req);
- if (rsize > nb) { /* Fail if wraps around zero */
- char* mp = (char*)(CALL_MMAP(rsize));
- if (mp != CMFAIL) {
- tbase = mp;
- tsize = rsize;
- mmap_flag = IS_MMAPPED_BIT;
- }
+ RELEASE_MORECORE_LOCK();
}
- }
- if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
- size_t asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
- if (asize < HALF_MAX_SIZE_T) {
- char* br = CMFAIL;
- char* end = CMFAIL;
- ACQUIRE_MORECORE_LOCK();
- br = (char*)(CALL_MORECORE(asize));
- end = (char*)(CALL_MORECORE(0));
- RELEASE_MORECORE_LOCK();
- if (br != CMFAIL && end != CMFAIL && br < end) {
- size_t ssize = end - br;
- if (ssize > nb + TOP_FOOT_SIZE) {
- tbase = br;
- tsize = ssize;
+ if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
+ size_t req = nb + TOP_FOOT_SIZE + SIZE_T_ONE;
+ size_t rsize = granularity_align(req);
+ if (rsize > nb) { /* Fail if wraps around zero */
+ char *mp = (char *) (CALL_MMAP(rsize));
+ if (mp != CMFAIL) {
+ tbase = mp;
+ tsize = rsize;
+ mmap_flag = IS_MMAPPED_BIT;
+ }
}
- }
}
- }
- if (tbase != CMFAIL) {
-
- if ((m->footprint += tsize) > m->max_footprint)
- m->max_footprint = m->footprint;
-
- if (!is_initialized(m)) { /* first-time initialization */
- m->seg.base = m->least_addr = tbase;
- m->seg.size = tsize;
- m->seg.sflags = mmap_flag;
- m->magic = mparams.magic;
- init_bins(m);
- if (is_global(m))
- init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
- else {
- /* Offset top by embedded malloc_state */
- mchunkptr mn = next_chunk(mem2chunk(m));
- init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE);
- }
+ if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
+ size_t asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
+ if (asize < HALF_MAX_SIZE_T) {
+ char *br = CMFAIL;
+ char *end = CMFAIL;
+ ACQUIRE_MORECORE_LOCK();
+ br = (char *) (CALL_MORECORE(asize));
+ end = (char *) (CALL_MORECORE(0));
+ RELEASE_MORECORE_LOCK();
+ if (br != CMFAIL && end != CMFAIL && br < end) {
+ size_t ssize = end - br;
+ if (ssize > nb + TOP_FOOT_SIZE) {
+ tbase = br;
+ tsize = ssize;
+ }
+ }
+ }
}
- else {
- /* Try to merge with an existing segment */
- msegmentptr sp = &m->seg;
- while (sp != 0 && tbase != sp->base + sp->size)
- sp = sp->next;
- if (sp != 0 &&
- !is_extern_segment(sp) &&
- (sp->sflags & IS_MMAPPED_BIT) == mmap_flag &&
- segment_holds(sp, m->top)) { /* append */
- sp->size += tsize;
- init_top(m, m->top, m->topsize + tsize);
- }
- else {
- if (tbase < m->least_addr)
- m->least_addr = tbase;
- sp = &m->seg;
- while (sp != 0 && sp->base != tbase + tsize)
- sp = sp->next;
- if (sp != 0 &&
- !is_extern_segment(sp) &&
- (sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
- char* oldbase = sp->base;
- sp->base = tbase;
- sp->size += tsize;
- return prepend_alloc(m, tbase, oldbase, nb);
+ if (tbase != CMFAIL) {
+
+ if ((m->footprint += tsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+
+ if (!is_initialized(m)) { /* first-time initialization */
+ m->seg.base = m->least_addr = tbase;
+ m->seg.size = tsize;
+ m->seg.sflags = mmap_flag;
+ m->magic = mparams.magic;
+ init_bins(m);
+ if (is_global(m))
+ init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
+ else {
+ /* Offset top by embedded malloc_state */
+ mchunkptr mn = next_chunk(mem2chunk(m));
+ init_top(m, mn,
+ (size_t) ((tbase + tsize) - (char *) mn) -
+ TOP_FOOT_SIZE);
+ }
+ }
+
+ else {
+ /* Try to merge with an existing segment */
+ msegmentptr sp = &m->seg;
+ while (sp != 0 && tbase != sp->base + sp->size)
+ sp = sp->next;
+ if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */
+ sp->size += tsize;
+ init_top(m, m->top, m->topsize + tsize);
+ } else {
+ if (tbase < m->least_addr)
+ m->least_addr = tbase;
+ sp = &m->seg;
+ while (sp != 0 && sp->base != tbase + tsize)
+ sp = sp->next;
+ if (sp != 0 &&
+ !is_extern_segment(sp) &&
+ (sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
+ char *oldbase = sp->base;
+ sp->base = tbase;
+ sp->size += tsize;
+ return prepend_alloc(m, tbase, oldbase, nb);
+ } else
+ add_segment(m, tbase, tsize, mmap_flag);
+ }
}
- else
- add_segment(m, tbase, tsize, mmap_flag);
- }
- }
- if (nb < m->topsize) { /* Allocate from new or extended top space */
- size_t rsize = m->topsize -= nb;
- mchunkptr p = m->top;
- mchunkptr r = m->top = chunk_plus_offset(p, nb);
- r->head = rsize | PINUSE_BIT;
- set_size_and_pinuse_of_inuse_chunk(m, p, nb);
- check_top_chunk(m, m->top);
- check_malloced_chunk(m, chunk2mem(p), nb);
- return chunk2mem(p);
+ if (nb < m->topsize) { /* Allocate from new or extended top space */
+ size_t rsize = m->topsize -= nb;
+ mchunkptr p = m->top;
+ mchunkptr r = m->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+ check_top_chunk(m, m->top);
+ check_malloced_chunk(m, chunk2mem(p), nb);
+ return chunk2mem(p);
+ }
}
- }
- MALLOC_FAILURE_ACTION;
- return 0;
+ MALLOC_FAILURE_ACTION;
+ return 0;
}
/* ----------------------- system deallocation -------------------------- */
/* Unmap and unlink any mmapped segments that don't contain used chunks */
-static size_t release_unused_segments(mstate m) {
- size_t released = 0;
- msegmentptr pred = &m->seg;
- msegmentptr sp = pred->next;
- while (sp != 0) {
- char* base = sp->base;
- size_t size = sp->size;
- msegmentptr next = sp->next;
- if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
- mchunkptr p = align_as_chunk(base);
- size_t psize = chunksize(p);
- /* Can unmap if first chunk holds entire segment and not pinned */
- if (!cinuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) {
- tchunkptr tp = (tchunkptr)p;
- assert(segment_holds(sp, (char*)sp));
- if (p == m->dv) {
- m->dv = 0;
- m->dvsize = 0;
- }
- else {
- unlink_large_chunk(m, tp);
- }
- if (CALL_MUNMAP(base, size) == 0) {
- released += size;
- m->footprint -= size;
- /* unlink obsoleted record */
- sp = pred;
- sp->next = next;
- }
- else { /* back out if cannot unmap */
- insert_large_chunk(m, tp, psize);
+static size_t
+release_unused_segments(mstate m)
+{
+ size_t released = 0;
+ msegmentptr pred = &m->seg;
+ msegmentptr sp = pred->next;
+ while (sp != 0) {
+ char *base = sp->base;
+ size_t size = sp->size;
+ msegmentptr next = sp->next;
+ if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
+ mchunkptr p = align_as_chunk(base);
+ size_t psize = chunksize(p);
+ /* Can unmap if first chunk holds entire segment and not pinned */
+ if (!cinuse(p)
+ && (char *) p + psize >= base + size - TOP_FOOT_SIZE) {
+ tchunkptr tp = (tchunkptr) p;
+ assert(segment_holds(sp, (char *) sp));
+ if (p == m->dv) {
+ m->dv = 0;
+ m->dvsize = 0;
+ } else {
+ unlink_large_chunk(m, tp);
+ }
+ if (CALL_MUNMAP(base, size) == 0) {
+ released += size;
+ m->footprint -= size;
+ /* unlink obsoleted record */
+ sp = pred;
+ sp->next = next;
+ } else { /* back out if cannot unmap */
+ insert_large_chunk(m, tp, psize);
+ }
+ }
}
- }
+ pred = sp;
+ sp = next;
}
- pred = sp;
- sp = next;
- }
- return released;
+ return released;
}
-static int sys_trim(mstate m, size_t pad) {
- size_t released = 0;
- if (pad < MAX_REQUEST && is_initialized(m)) {
- pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
-
- if (m->topsize > pad) {
- /* Shrink top space in granularity-size units, keeping at least one */
- size_t unit = mparams.granularity;
- size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
- SIZE_T_ONE) * unit;
- msegmentptr sp = segment_holding(m, (char*)m->top);
-
- if (!is_extern_segment(sp)) {
- if (is_mmapped_segment(sp)) {
- if (HAVE_MMAP &&
- sp->size >= extra &&
- !has_segment_link(m, sp)) { /* can't shrink if pinned */
- size_t newsize = sp->size - extra;
- /* Prefer mremap, fall back to munmap */
- if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) ||
- (CALL_MUNMAP(sp->base + newsize, extra) == 0)) {
- released = extra;
+static int
+sys_trim(mstate m, size_t pad)
+{
+ size_t released = 0;
+ if (pad < MAX_REQUEST && is_initialized(m)) {
+ pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
+
+ if (m->topsize > pad) {
+ /* Shrink top space in granularity-size units, keeping at least one */
+ size_t unit = mparams.granularity;
+ size_t extra =
+ ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
+ SIZE_T_ONE) * unit;
+ msegmentptr sp = segment_holding(m, (char *) m->top);
+
+ if (!is_extern_segment(sp)) {
+ if (is_mmapped_segment(sp)) {
+ if (HAVE_MMAP && sp->size >= extra && !has_segment_link(m, sp)) { /* can't shrink if pinned */
+ size_t newsize = sp->size - extra;
+ /* Prefer mremap, fall back to munmap */
+ if ((CALL_MREMAP
+ (sp->base, sp->size, newsize, 0) != MFAIL)
+ || (CALL_MUNMAP(sp->base + newsize, extra)
+ == 0)) {
+ released = extra;
+ }
+ }
+ } else if (HAVE_MORECORE) {
+ if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
+ extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
+ ACQUIRE_MORECORE_LOCK();
+ {
+ /* Make sure end of memory is where we last set it. */
+ char *old_br = (char *) (CALL_MORECORE(0));
+ if (old_br == sp->base + sp->size) {
+ char *rel_br = (char *) (CALL_MORECORE(-extra));
+ char *new_br = (char *) (CALL_MORECORE(0));
+ if (rel_br != CMFAIL && new_br < old_br)
+ released = old_br - new_br;
+ }
+ }
+ RELEASE_MORECORE_LOCK();
+ }
}
- }
- }
- else if (HAVE_MORECORE) {
- if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
- extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
- ACQUIRE_MORECORE_LOCK();
- {
- /* Make sure end of memory is where we last set it. */
- char* old_br = (char*)(CALL_MORECORE(0));
- if (old_br == sp->base + sp->size) {
- char* rel_br = (char*)(CALL_MORECORE(-extra));
- char* new_br = (char*)(CALL_MORECORE(0));
- if (rel_br != CMFAIL && new_br < old_br)
- released = old_br - new_br;
+
+ if (released != 0) {
+ sp->size -= released;
+ m->footprint -= released;
+ init_top(m, m->top, m->topsize - released);
+ check_top_chunk(m, m->top);
}
- }
- RELEASE_MORECORE_LOCK();
}
- }
-
- if (released != 0) {
- sp->size -= released;
- m->footprint -= released;
- init_top(m, m->top, m->topsize - released);
- check_top_chunk(m, m->top);
- }
- }
- /* Unmap any unused mmapped segments */
- if (HAVE_MMAP)
- released += release_unused_segments(m);
+ /* Unmap any unused mmapped segments */
+ if (HAVE_MMAP)
+ released += release_unused_segments(m);
- /* On failure, disable autotrim to avoid repeated failed future calls */
- if (released == 0)
- m->trim_check = MAX_SIZE_T;
- }
+ /* On failure, disable autotrim to avoid repeated failed future calls */
+ if (released == 0)
+ m->trim_check = MAX_SIZE_T;
+ }
- return (released != 0)? 1 : 0;
+ return (released != 0) ? 1 : 0;
}
/* ---------------------------- malloc support --------------------------- */
/* allocate a large request from the best fitting chunk in a treebin */
-static void* tmalloc_large(mstate m, size_t nb) {
- tchunkptr v = 0;
- size_t rsize = -nb; /* Unsigned negation */
- tchunkptr t;
- bindex_t idx;
- compute_tree_index(nb, idx);
-
- if ((t = *treebin_at(m, idx)) != 0) {
- /* Traverse tree for this bin looking for node with size == nb */
- size_t sizebits = nb << leftshift_for_tree_index(idx);
- tchunkptr rst = 0; /* The deepest untaken right subtree */
- for (;;) {
- tchunkptr rt;
- size_t trem = chunksize(t) - nb;
- if (trem < rsize) {
- v = t;
- if ((rsize = trem) == 0)
- break;
- }
- rt = t->child[1];
- t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
- if (rt != 0 && rt != t)
- rst = rt;
- if (t == 0) {
- t = rst; /* set t to least subtree holding sizes > nb */
- break;
- }
- sizebits <<= 1;
+static void *
+tmalloc_large(mstate m, size_t nb)
+{
+ tchunkptr v = 0;
+ size_t rsize = -nb; /* Unsigned negation */
+ tchunkptr t;
+ bindex_t idx;
+ compute_tree_index(nb, idx);
+
+ if ((t = *treebin_at(m, idx)) != 0) {
+ /* Traverse tree for this bin looking for node with size == nb */
+ size_t sizebits = nb << leftshift_for_tree_index(idx);
+ tchunkptr rst = 0; /* The deepest untaken right subtree */
+ for (;;) {
+ tchunkptr rt;
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ v = t;
+ if ((rsize = trem) == 0)
+ break;
+ }
+ rt = t->child[1];
+ t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
+ if (rt != 0 && rt != t)
+ rst = rt;
+ if (t == 0) {
+ t = rst; /* set t to least subtree holding sizes > nb */
+ break;
+ }
+ sizebits <<= 1;
+ }
}
- }
- if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
- binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
- if (leftbits != 0) {
- bindex_t i;
- binmap_t leastbit = least_bit(leftbits);
- compute_bit2idx(leastbit, i);
- t = *treebin_at(m, i);
+ if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
+ binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
+ if (leftbits != 0) {
+ bindex_t i;
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ t = *treebin_at(m, i);
+ }
}
- }
- while (t != 0) { /* find smallest of tree or subtree */
- size_t trem = chunksize(t) - nb;
- if (trem < rsize) {
- rsize = trem;
- v = t;
+ while (t != 0) { /* find smallest of tree or subtree */
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ rsize = trem;
+ v = t;
+ }
+ t = leftmost_child(t);
}
- t = leftmost_child(t);
- }
- /* If dv is a better fit, return 0 so malloc will use it */
- if (v != 0 && rsize < (size_t)(m->dvsize - nb)) {
- if (RTCHECK(ok_address(m, v))) { /* split */
- mchunkptr r = chunk_plus_offset(v, nb);
- assert(chunksize(v) == rsize + nb);
- if (RTCHECK(ok_next(v, r))) {
- unlink_large_chunk(m, v);
- if (rsize < MIN_CHUNK_SIZE)
- set_inuse_and_pinuse(m, v, (rsize + nb));
- else {
- set_size_and_pinuse_of_inuse_chunk(m, v, nb);
- set_size_and_pinuse_of_free_chunk(r, rsize);
- insert_chunk(m, r, rsize);
+ /* If dv is a better fit, return 0 so malloc will use it */
+ if (v != 0 && rsize < (size_t) (m->dvsize - nb)) {
+ if (RTCHECK(ok_address(m, v))) { /* split */
+ mchunkptr r = chunk_plus_offset(v, nb);
+ assert(chunksize(v) == rsize + nb);
+ if (RTCHECK(ok_next(v, r))) {
+ unlink_large_chunk(m, v);
+ if (rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(m, v, (rsize + nb));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ insert_chunk(m, r, rsize);
+ }
+ return chunk2mem(v);
+ }
}
- return chunk2mem(v);
- }
+ CORRUPTION_ERROR_ACTION(m);
}
- CORRUPTION_ERROR_ACTION(m);
- }
- return 0;
+ return 0;
}
/* allocate a small request from the best fitting chunk in a treebin */
-static void* tmalloc_small(mstate m, size_t nb) {
- tchunkptr t, v;
- size_t rsize;
- bindex_t i;
- binmap_t leastbit = least_bit(m->treemap);
- compute_bit2idx(leastbit, i);
-
- v = t = *treebin_at(m, i);
- rsize = chunksize(t) - nb;
-
- while ((t = leftmost_child(t)) != 0) {
- size_t trem = chunksize(t) - nb;
- if (trem < rsize) {
- rsize = trem;
- v = t;
+static void *
+tmalloc_small(mstate m, size_t nb)
+{
+ tchunkptr t, v;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leastbit = least_bit(m->treemap);
+ compute_bit2idx(leastbit, i);
+
+ v = t = *treebin_at(m, i);
+ rsize = chunksize(t) - nb;
+
+ while ((t = leftmost_child(t)) != 0) {
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ rsize = trem;
+ v = t;
+ }
}
- }
- if (RTCHECK(ok_address(m, v))) {
- mchunkptr r = chunk_plus_offset(v, nb);
- assert(chunksize(v) == rsize + nb);
- if (RTCHECK(ok_next(v, r))) {
- unlink_large_chunk(m, v);
- if (rsize < MIN_CHUNK_SIZE)
- set_inuse_and_pinuse(m, v, (rsize + nb));
- else {
- set_size_and_pinuse_of_inuse_chunk(m, v, nb);
- set_size_and_pinuse_of_free_chunk(r, rsize);
- replace_dv(m, r, rsize);
- }
- return chunk2mem(v);
+ if (RTCHECK(ok_address(m, v))) {
+ mchunkptr r = chunk_plus_offset(v, nb);
+ assert(chunksize(v) == rsize + nb);
+ if (RTCHECK(ok_next(v, r))) {
+ unlink_large_chunk(m, v);
+ if (rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(m, v, (rsize + nb));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(m, r, rsize);
+ }
+ return chunk2mem(v);
+ }
}
- }
- CORRUPTION_ERROR_ACTION(m);
- return 0;
+ CORRUPTION_ERROR_ACTION(m);
+ return 0;
}
/* --------------------------- realloc support --------------------------- */
-static void* internal_realloc(mstate m, void* oldmem, size_t bytes) {
- if (bytes >= MAX_REQUEST) {
- MALLOC_FAILURE_ACTION;
- return 0;
- }
- if (!PREACTION(m)) {
- mchunkptr oldp = mem2chunk(oldmem);
- size_t oldsize = chunksize(oldp);
- mchunkptr next = chunk_plus_offset(oldp, oldsize);
- mchunkptr newp = 0;
- void* extra = 0;
-
- /* Try to either shrink or extend into top. Else malloc-copy-free */
-
- if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
- ok_next(oldp, next) && ok_pinuse(next))) {
- size_t nb = request2size(bytes);
- if (is_mmapped(oldp))
- newp = mmap_resize(m, oldp, nb);
- else if (oldsize >= nb) { /* already big enough */
- size_t rsize = oldsize - nb;
- newp = oldp;
- if (rsize >= MIN_CHUNK_SIZE) {
- mchunkptr remainder = chunk_plus_offset(newp, nb);
- set_inuse(m, newp, nb);
- set_inuse(m, remainder, rsize);
- extra = chunk2mem(remainder);
- }
- }
- else if (next == m->top && oldsize + m->topsize > nb) {
- /* Expand into top */
- size_t newsize = oldsize + m->topsize;
- size_t newtopsize = newsize - nb;
- mchunkptr newtop = chunk_plus_offset(oldp, nb);
- set_inuse(m, oldp, nb);
- newtop->head = newtopsize |PINUSE_BIT;
- m->top = newtop;
- m->topsize = newtopsize;
- newp = oldp;
- }
- }
- else {
- USAGE_ERROR_ACTION(m, oldmem);
- POSTACTION(m);
- return 0;
+static void *
+internal_realloc(mstate m, void *oldmem, size_t bytes)
+{
+ if (bytes >= MAX_REQUEST) {
+ MALLOC_FAILURE_ACTION;
+ return 0;
}
+ if (!PREACTION(m)) {
+ mchunkptr oldp = mem2chunk(oldmem);
+ size_t oldsize = chunksize(oldp);
+ mchunkptr next = chunk_plus_offset(oldp, oldsize);
+ mchunkptr newp = 0;
+ void *extra = 0;
+
+ /* Try to either shrink or extend into top. Else malloc-copy-free */
+
+ if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
+ ok_next(oldp, next) && ok_pinuse(next))) {
+ size_t nb = request2size(bytes);
+ if (is_mmapped(oldp))
+ newp = mmap_resize(m, oldp, nb);
+ else if (oldsize >= nb) { /* already big enough */
+ size_t rsize = oldsize - nb;
+ newp = oldp;
+ if (rsize >= MIN_CHUNK_SIZE) {
+ mchunkptr remainder = chunk_plus_offset(newp, nb);
+ set_inuse(m, newp, nb);
+ set_inuse(m, remainder, rsize);
+ extra = chunk2mem(remainder);
+ }
+ } else if (next == m->top && oldsize + m->topsize > nb) {
+ /* Expand into top */
+ size_t newsize = oldsize + m->topsize;
+ size_t newtopsize = newsize - nb;
+ mchunkptr newtop = chunk_plus_offset(oldp, nb);
+ set_inuse(m, oldp, nb);
+ newtop->head = newtopsize | PINUSE_BIT;
+ m->top = newtop;
+ m->topsize = newtopsize;
+ newp = oldp;
+ }
+ } else {
+ USAGE_ERROR_ACTION(m, oldmem);
+ POSTACTION(m);
+ return 0;
+ }
- POSTACTION(m);
+ POSTACTION(m);
- if (newp != 0) {
- if (extra != 0) {
- internal_free(m, extra);
- }
- check_inuse_chunk(m, newp);
- return chunk2mem(newp);
- }
- else {
- void* newmem = internal_malloc(m, bytes);
- if (newmem != 0) {
- size_t oc = oldsize - overhead_for(oldp);
- memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
- internal_free(m, oldmem);
- }
- return newmem;
+ if (newp != 0) {
+ if (extra != 0) {
+ internal_free(m, extra);
+ }
+ check_inuse_chunk(m, newp);
+ return chunk2mem(newp);
+ } else {
+ void *newmem = internal_malloc(m, bytes);
+ if (newmem != 0) {
+ size_t oc = oldsize - overhead_for(oldp);
+ memcpy(newmem, oldmem, (oc < bytes) ? oc : bytes);
+ internal_free(m, oldmem);
+ }
+ return newmem;
+ }
}
- }
- return 0;
+ return 0;
}
/* --------------------------- memalign support -------------------------- */
-static void* internal_memalign(mstate m, size_t alignment, size_t bytes) {
- if (alignment <= MALLOC_ALIGNMENT) /* Can just use malloc */
- return internal_malloc(m, bytes);
- if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
- alignment = MIN_CHUNK_SIZE;
- if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */
- size_t a = MALLOC_ALIGNMENT << 1;
- while (a < alignment) a <<= 1;
- alignment = a;
- }
-
- if (bytes >= MAX_REQUEST - alignment) {
- if (m != 0) { /* Test isn't needed but avoids compiler warning */
- MALLOC_FAILURE_ACTION;
+static void *
+internal_memalign(mstate m, size_t alignment, size_t bytes)
+{
+ if (alignment <= MALLOC_ALIGNMENT) /* Can just use malloc */
+ return internal_malloc(m, bytes);
+ if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
+ alignment = MIN_CHUNK_SIZE;
+ if ((alignment & (alignment - SIZE_T_ONE)) != 0) { /* Ensure a power of 2 */
+ size_t a = MALLOC_ALIGNMENT << 1;
+ while (a < alignment)
+ a <<= 1;
+ alignment = a;
}
- }
- else {
- size_t nb = request2size(bytes);
- size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
- char* mem = (char*)internal_malloc(m, req);
- if (mem != 0) {
- void* leader = 0;
- void* trailer = 0;
- mchunkptr p = mem2chunk(mem);
-
- if (PREACTION(m)) return 0;
- if ((((size_t)(mem)) % alignment) != 0) { /* misaligned */
- /*
- Find an aligned spot inside chunk. Since we need to give
- back leading space in a chunk of at least MIN_CHUNK_SIZE, if
- the first calculation places us at a spot with less than
- MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
- We've allocated enough total room so that this is always
- possible.
- */
- char* br = (char*)mem2chunk((size_t)(((size_t)(mem +
- alignment -
- SIZE_T_ONE)) &
- -alignment));
- char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)?
- br : br+alignment;
- mchunkptr newp = (mchunkptr)pos;
- size_t leadsize = pos - (char*)(p);
- size_t newsize = chunksize(p) - leadsize;
-
- if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
- newp->prev_foot = p->prev_foot + leadsize;
- newp->head = (newsize|CINUSE_BIT);
- }
- else { /* Otherwise, give back leader, use the rest */
- set_inuse(m, newp, newsize);
- set_inuse(m, p, leadsize);
- leader = chunk2mem(p);
- }
- p = newp;
- }
- /* Give back spare room at the end */
- if (!is_mmapped(p)) {
- size_t size = chunksize(p);
- if (size > nb + MIN_CHUNK_SIZE) {
- size_t remainder_size = size - nb;
- mchunkptr remainder = chunk_plus_offset(p, nb);
- set_inuse(m, p, nb);
- set_inuse(m, remainder, remainder_size);
- trailer = chunk2mem(remainder);
+ if (bytes >= MAX_REQUEST - alignment) {
+ if (m != 0) { /* Test isn't needed but avoids compiler warning */
+ MALLOC_FAILURE_ACTION;
}
- }
+ } else {
+ size_t nb = request2size(bytes);
+ size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
+ char *mem = (char *) internal_malloc(m, req);
+ if (mem != 0) {
+ void *leader = 0;
+ void *trailer = 0;
+ mchunkptr p = mem2chunk(mem);
+
+ if (PREACTION(m))
+ return 0;
+ if ((((size_t) (mem)) % alignment) != 0) { /* misaligned */
+ /*
+ Find an aligned spot inside chunk. Since we need to give
+ back leading space in a chunk of at least MIN_CHUNK_SIZE, if
+ the first calculation places us at a spot with less than
+ MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
+ We've allocated enough total room so that this is always
+ possible.
+ */
+ char *br = (char *)
+ mem2chunk((size_t)
+ (((size_t)
+ (mem + alignment -
+ SIZE_T_ONE)) & -alignment));
+ char *pos =
+ ((size_t) (br - (char *) (p)) >=
+ MIN_CHUNK_SIZE) ? br : br + alignment;
+ mchunkptr newp = (mchunkptr) pos;
+ size_t leadsize = pos - (char *) (p);
+ size_t newsize = chunksize(p) - leadsize;
+
+ if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
+ newp->prev_foot = p->prev_foot + leadsize;
+ newp->head = (newsize | CINUSE_BIT);
+ } else { /* Otherwise, give back leader, use the rest */
+ set_inuse(m, newp, newsize);
+ set_inuse(m, p, leadsize);
+ leader = chunk2mem(p);
+ }
+ p = newp;
+ }
- assert (chunksize(p) >= nb);
- assert((((size_t)(chunk2mem(p))) % alignment) == 0);
- check_inuse_chunk(m, p);
- POSTACTION(m);
- if (leader != 0) {
- internal_free(m, leader);
- }
- if (trailer != 0) {
- internal_free(m, trailer);
- }
- return chunk2mem(p);
+ /* Give back spare room at the end */
+ if (!is_mmapped(p)) {
+ size_t size = chunksize(p);
+ if (size > nb + MIN_CHUNK_SIZE) {
+ size_t remainder_size = size - nb;
+ mchunkptr remainder = chunk_plus_offset(p, nb);
+ set_inuse(m, p, nb);
+ set_inuse(m, remainder, remainder_size);
+ trailer = chunk2mem(remainder);
+ }
+ }
+
+ assert(chunksize(p) >= nb);
+ assert((((size_t) (chunk2mem(p))) % alignment) == 0);
+ check_inuse_chunk(m, p);
+ POSTACTION(m);
+ if (leader != 0) {
+ internal_free(m, leader);
+ }
+ if (trailer != 0) {
+ internal_free(m, trailer);
+ }
+ return chunk2mem(p);
+ }
}
- }
- return 0;
+ return 0;
}
/* ------------------------ comalloc/coalloc support --------------------- */
-static void** ialloc(mstate m,
- size_t n_elements,
- size_t* sizes,
- int opts,
- void* chunks[]) {
- /*
- This provides common support for independent_X routines, handling
- all of the combinations that can result.
-
- The opts arg has:
- bit 0 set if all elements are same size (using sizes[0])
- bit 1 set if elements should be zeroed
- */
-
- size_t element_size; /* chunksize of each element, if all same */
- size_t contents_size; /* total size of elements */
- size_t array_size; /* request size of pointer array */
- void* mem; /* malloced aggregate space */
- mchunkptr p; /* corresponding chunk */
- size_t remainder_size; /* remaining bytes while splitting */
- void** marray; /* either "chunks" or malloced ptr array */
- mchunkptr array_chunk; /* chunk for malloced ptr array */
- flag_t was_enabled; /* to disable mmap */
- size_t size;
- size_t i;
-
- /* compute array length, if needed */
- if (chunks != 0) {
- if (n_elements == 0)
- return chunks; /* nothing to do */
- marray = chunks;
- array_size = 0;
- }
- else {
- /* if empty req, must still return chunk representing empty array */
- if (n_elements == 0)
- return (void**)internal_malloc(m, 0);
- marray = 0;
- array_size = request2size(n_elements * (sizeof(void*)));
- }
-
- /* compute total element size */
- if (opts & 0x1) { /* all-same-size */
- element_size = request2size(*sizes);
- contents_size = n_elements * element_size;
- }
- else { /* add up all the sizes */
- element_size = 0;
- contents_size = 0;
- for (i = 0; i != n_elements; ++i)
- contents_size += request2size(sizes[i]);
- }
-
- size = contents_size + array_size;
-
- /*
- Allocate the aggregate chunk. First disable direct-mmapping so
- malloc won't use it, since we would not be able to later
- free/realloc space internal to a segregated mmap region.
- */
- was_enabled = use_mmap(m);
- disable_mmap(m);
- mem = internal_malloc(m, size - CHUNK_OVERHEAD);
- if (was_enabled)
- enable_mmap(m);
- if (mem == 0)
- return 0;
-
- if (PREACTION(m)) return 0;
- p = mem2chunk(mem);
- remainder_size = chunksize(p);
-
- assert(!is_mmapped(p));
+static void **
+ialloc(mstate m, size_t n_elements, size_t * sizes, int opts, void *chunks[])
+{
+ /*
+ This provides common support for independent_X routines, handling
+ all of the combinations that can result.
+
+ The opts arg has:
+ bit 0 set if all elements are same size (using sizes[0])
+ bit 1 set if elements should be zeroed
+ */
+
+ size_t element_size; /* chunksize of each element, if all same */
+ size_t contents_size; /* total size of elements */
+ size_t array_size; /* request size of pointer array */
+ void *mem; /* malloced aggregate space */
+ mchunkptr p; /* corresponding chunk */
+ size_t remainder_size; /* remaining bytes while splitting */
+ void **marray; /* either "chunks" or malloced ptr array */
+ mchunkptr array_chunk; /* chunk for malloced ptr array */
+ flag_t was_enabled; /* to disable mmap */
+ size_t size;
+ size_t i;
+
+ /* compute array length, if needed */
+ if (chunks != 0) {
+ if (n_elements == 0)
+ return chunks; /* nothing to do */
+ marray = chunks;
+ array_size = 0;
+ } else {
+ /* if empty req, must still return chunk representing empty array */
+ if (n_elements == 0)
+ return (void **) internal_malloc(m, 0);
+ marray = 0;
+ array_size = request2size(n_elements * (sizeof(void *)));
+ }
- if (opts & 0x2) { /* optionally clear the elements */
- memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
- }
+ /* compute total element size */
+ if (opts & 0x1) { /* all-same-size */
+ element_size = request2size(*sizes);
+ contents_size = n_elements * element_size;
+ } else { /* add up all the sizes */
+ element_size = 0;
+ contents_size = 0;
+ for (i = 0; i != n_elements; ++i)
+ contents_size += request2size(sizes[i]);
+ }
- /* If not provided, allocate the pointer array as final part of chunk */
- if (marray == 0) {
- size_t array_chunk_size;
- array_chunk = chunk_plus_offset(p, contents_size);
- array_chunk_size = remainder_size - contents_size;
- marray = (void**) (chunk2mem(array_chunk));
- set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
- remainder_size = contents_size;
- }
+ size = contents_size + array_size;
+
+ /*
+ Allocate the aggregate chunk. First disable direct-mmapping so
+ malloc won't use it, since we would not be able to later
+ free/realloc space internal to a segregated mmap region.
+ */
+ was_enabled = use_mmap(m);
+ disable_mmap(m);
+ mem = internal_malloc(m, size - CHUNK_OVERHEAD);
+ if (was_enabled)
+ enable_mmap(m);
+ if (mem == 0)
+ return 0;
+
+ if (PREACTION(m))
+ return 0;
+ p = mem2chunk(mem);
+ remainder_size = chunksize(p);
+
+ assert(!is_mmapped(p));
+
+ if (opts & 0x2) { /* optionally clear the elements */
+ memset((size_t *) mem, 0, remainder_size - SIZE_T_SIZE - array_size);
+ }
- /* split out elements */
- for (i = 0; ; ++i) {
- marray[i] = chunk2mem(p);
- if (i != n_elements-1) {
- if (element_size != 0)
- size = element_size;
- else
- size = request2size(sizes[i]);
- remainder_size -= size;
- set_size_and_pinuse_of_inuse_chunk(m, p, size);
- p = chunk_plus_offset(p, size);
+ /* If not provided, allocate the pointer array as final part of chunk */
+ if (marray == 0) {
+ size_t array_chunk_size;
+ array_chunk = chunk_plus_offset(p, contents_size);
+ array_chunk_size = remainder_size - contents_size;
+ marray = (void **) (chunk2mem(array_chunk));
+ set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
+ remainder_size = contents_size;
}
- else { /* the final element absorbs any overallocation slop */
- set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
- break;
+
+ /* split out elements */
+ for (i = 0;; ++i) {
+ marray[i] = chunk2mem(p);
+ if (i != n_elements - 1) {
+ if (element_size != 0)
+ size = element_size;
+ else
+ size = request2size(sizes[i]);
+ remainder_size -= size;
+ set_size_and_pinuse_of_inuse_chunk(m, p, size);
+ p = chunk_plus_offset(p, size);
+ } else { /* the final element absorbs any overallocation slop */
+ set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
+ break;
+ }
}
- }
#if DEBUG
- if (marray != chunks) {
- /* final element must have exactly exhausted chunk */
- if (element_size != 0) {
- assert(remainder_size == element_size);
- }
- else {
- assert(remainder_size == request2size(sizes[i]));
+ if (marray != chunks) {
+ /* final element must have exactly exhausted chunk */
+ if (element_size != 0) {
+ assert(remainder_size == element_size);
+ } else {
+ assert(remainder_size == request2size(sizes[i]));
+ }
+ check_inuse_chunk(m, mem2chunk(marray));
}
- check_inuse_chunk(m, mem2chunk(marray));
- }
- for (i = 0; i != n_elements; ++i)
- check_inuse_chunk(m, mem2chunk(marray[i]));
+ for (i = 0; i != n_elements; ++i)
+ check_inuse_chunk(m, mem2chunk(marray[i]));
#endif /* DEBUG */
- POSTACTION(m);
- return marray;
+ POSTACTION(m);
+ return marray;
}
@@ -4068,343 +4141,369 @@ static void** ialloc(mstate m,
#if !ONLY_MSPACES
-void* dlmalloc(size_t bytes) {
- /*
- Basic algorithm:
- If a small request (< 256 bytes minus per-chunk overhead):
+void *
+dlmalloc(size_t bytes)
+{
+ /*
+ Basic algorithm:
+ If a small request (< 256 bytes minus per-chunk overhead):
1. If one exists, use a remainderless chunk in associated smallbin.
- (Remainderless means that there are too few excess bytes to
- represent as a chunk.)
+ (Remainderless means that there are too few excess bytes to
+ represent as a chunk.)
2. If it is big enough, use the dv chunk, which is normally the
- chunk adjacent to the one used for the most recent small request.
+ chunk adjacent to the one used for the most recent small request.
3. If one exists, split the smallest available chunk in a bin,
- saving remainder in dv.
+ saving remainder in dv.
4. If it is big enough, use the top chunk.
5. If available, get memory from system and use it
- Otherwise, for a large request:
+ Otherwise, for a large request:
1. Find the smallest available binned chunk that fits, and use it
- if it is better fitting than dv chunk, splitting if necessary.
+ if it is better fitting than dv chunk, splitting if necessary.
2. If better fitting than any binned chunk, use the dv chunk.
3. If it is big enough, use the top chunk.
4. If request size >= mmap threshold, try to directly mmap this chunk.
5. If available, get memory from system and use it
- The ugly goto's here ensure that postaction occurs along all paths.
- */
-
- if (!PREACTION(gm)) {
- void* mem;
- size_t nb;
- if (bytes <= MAX_SMALL_REQUEST) {
- bindex_t idx;
- binmap_t smallbits;
- nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
- idx = small_index(nb);
- smallbits = gm->smallmap >> idx;
-
- if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
- mchunkptr b, p;
- idx += ~smallbits & 1; /* Uses next bin if idx empty */
- b = smallbin_at(gm, idx);
- p = b->fd;
- assert(chunksize(p) == small_index2size(idx));
- unlink_first_small_chunk(gm, b, p, idx);
- set_inuse_and_pinuse(gm, p, small_index2size(idx));
- mem = chunk2mem(p);
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
- }
+ The ugly goto's here ensure that postaction occurs along all paths.
+ */
+
+ if (!PREACTION(gm)) {
+ void *mem;
+ size_t nb;
+ if (bytes <= MAX_SMALL_REQUEST) {
+ bindex_t idx;
+ binmap_t smallbits;
+ nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
+ idx = small_index(nb);
+ smallbits = gm->smallmap >> idx;
+
+ if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+ mchunkptr b, p;
+ idx += ~smallbits & 1; /* Uses next bin if idx empty */
+ b = smallbin_at(gm, idx);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(idx));
+ unlink_first_small_chunk(gm, b, p, idx);
+ set_inuse_and_pinuse(gm, p, small_index2size(idx));
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
- else if (nb > gm->dvsize) {
- if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
- mchunkptr b, p, r;
- size_t rsize;
- bindex_t i;
- binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
- binmap_t leastbit = least_bit(leftbits);
- compute_bit2idx(leastbit, i);
- b = smallbin_at(gm, i);
- p = b->fd;
- assert(chunksize(p) == small_index2size(i));
- unlink_first_small_chunk(gm, b, p, i);
- rsize = small_index2size(i) - nb;
- /* Fit here cannot be remainderless if 4byte sizes */
- if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
- set_inuse_and_pinuse(gm, p, small_index2size(i));
- else {
- set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
- r = chunk_plus_offset(p, nb);
- set_size_and_pinuse_of_free_chunk(r, rsize);
- replace_dv(gm, r, rsize);
- }
- mem = chunk2mem(p);
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
+ else if (nb > gm->dvsize) {
+ if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
+ mchunkptr b, p, r;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leftbits =
+ (smallbits << idx) & left_bits(idx2bit(idx));
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ b = smallbin_at(gm, i);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(i));
+ unlink_first_small_chunk(gm, b, p, i);
+ rsize = small_index2size(i) - nb;
+ /* Fit here cannot be remainderless if 4byte sizes */
+ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(gm, p, small_index2size(i));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ r = chunk_plus_offset(p, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(gm, r, rsize);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+
+ else if (gm->treemap != 0
+ && (mem = tmalloc_small(gm, nb)) != 0) {
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+ }
+ } else if (bytes >= MAX_REQUEST)
+ nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
+ else {
+ nb = pad_request(bytes);
+ if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
}
- else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) {
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
+ if (nb <= gm->dvsize) {
+ size_t rsize = gm->dvsize - nb;
+ mchunkptr p = gm->dv;
+ if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
+ mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
+ gm->dvsize = rsize;
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ } else { /* exhaust dv */
+ size_t dvs = gm->dvsize;
+ gm->dvsize = 0;
+ gm->dv = 0;
+ set_inuse_and_pinuse(gm, p, dvs);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
}
- }
- }
- else if (bytes >= MAX_REQUEST)
- nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
- else {
- nb = pad_request(bytes);
- if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
- }
- }
-
- if (nb <= gm->dvsize) {
- size_t rsize = gm->dvsize - nb;
- mchunkptr p = gm->dv;
- if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
- mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
- gm->dvsize = rsize;
- set_size_and_pinuse_of_free_chunk(r, rsize);
- set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
- }
- else { /* exhaust dv */
- size_t dvs = gm->dvsize;
- gm->dvsize = 0;
- gm->dv = 0;
- set_inuse_and_pinuse(gm, p, dvs);
- }
- mem = chunk2mem(p);
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
- }
- else if (nb < gm->topsize) { /* Split top */
- size_t rsize = gm->topsize -= nb;
- mchunkptr p = gm->top;
- mchunkptr r = gm->top = chunk_plus_offset(p, nb);
- r->head = rsize | PINUSE_BIT;
- set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
- mem = chunk2mem(p);
- check_top_chunk(gm, gm->top);
- check_malloced_chunk(gm, mem, nb);
- goto postaction;
- }
+ else if (nb < gm->topsize) { /* Split top */
+ size_t rsize = gm->topsize -= nb;
+ mchunkptr p = gm->top;
+ mchunkptr r = gm->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ mem = chunk2mem(p);
+ check_top_chunk(gm, gm->top);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
- mem = sys_alloc(gm, nb);
+ mem = sys_alloc(gm, nb);
- postaction:
- POSTACTION(gm);
- return mem;
- }
+ postaction:
+ POSTACTION(gm);
+ return mem;
+ }
- return 0;
+ return 0;
}
-void dlfree(void* mem) {
- /*
- Consolidate freed chunks with preceeding or succeeding bordering
- free chunks, if they exist, and then place in a bin. Intermixed
- with special cases for top, dv, mmapped chunks, and usage errors.
- */
+void
+dlfree(void *mem)
+{
+ /*
+ Consolidate freed chunks with preceeding or succeeding bordering
+ free chunks, if they exist, and then place in a bin. Intermixed
+ with special cases for top, dv, mmapped chunks, and usage errors.
+ */
- if (mem != 0) {
- mchunkptr p = mem2chunk(mem);
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
#if FOOTERS
- mstate fm = get_mstate_for(p);
- if (!ok_magic(fm)) {
- USAGE_ERROR_ACTION(fm, p);
- return;
- }
+ mstate fm = get_mstate_for(p);
+ if (!ok_magic(fm)) {
+ USAGE_ERROR_ACTION(fm, p);
+ return;
+ }
#else /* FOOTERS */
#define fm gm
#endif /* FOOTERS */
- if (!PREACTION(fm)) {
- check_inuse_chunk(fm, p);
- if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
- size_t psize = chunksize(p);
- mchunkptr next = chunk_plus_offset(p, psize);
- if (!pinuse(p)) {
- size_t prevsize = p->prev_foot;
- if ((prevsize & IS_MMAPPED_BIT) != 0) {
- prevsize &= ~IS_MMAPPED_BIT;
- psize += prevsize + MMAP_FOOT_PAD;
- if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
- fm->footprint -= psize;
- goto postaction;
- }
- else {
- mchunkptr prev = chunk_minus_offset(p, prevsize);
- psize += prevsize;
- p = prev;
- if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
- if (p != fm->dv) {
- unlink_chunk(fm, p, prevsize);
- }
- else if ((next->head & INUSE_BITS) == INUSE_BITS) {
- fm->dvsize = psize;
- set_free_with_pinuse(p, psize, next);
- goto postaction;
- }
+ if (!PREACTION(fm)) {
+ check_inuse_chunk(fm, p);
+ if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
+ size_t psize = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, psize);
+ if (!pinuse(p)) {
+ size_t prevsize = p->prev_foot;
+ if ((prevsize & IS_MMAPPED_BIT) != 0) {
+ prevsize &= ~IS_MMAPPED_BIT;
+ psize += prevsize + MMAP_FOOT_PAD;
+ if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
+ fm->footprint -= psize;
+ goto postaction;
+ } else {
+ mchunkptr prev = chunk_minus_offset(p, prevsize);
+ psize += prevsize;
+ p = prev;
+ if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
+ if (p != fm->dv) {
+ unlink_chunk(fm, p, prevsize);
+ } else if ((next->head & INUSE_BITS) ==
+ INUSE_BITS) {
+ fm->dvsize = psize;
+ set_free_with_pinuse(p, psize, next);
+ goto postaction;
+ }
+ } else
+ goto erroraction;
+ }
+ }
+
+ if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+ if (!cinuse(next)) { /* consolidate forward */
+ if (next == fm->top) {
+ size_t tsize = fm->topsize += psize;
+ fm->top = p;
+ p->head = tsize | PINUSE_BIT;
+ if (p == fm->dv) {
+ fm->dv = 0;
+ fm->dvsize = 0;
+ }
+ if (should_trim(fm, tsize))
+ sys_trim(fm, 0);
+ goto postaction;
+ } else if (next == fm->dv) {
+ size_t dsize = fm->dvsize += psize;
+ fm->dv = p;
+ set_size_and_pinuse_of_free_chunk(p, dsize);
+ goto postaction;
+ } else {
+ size_t nsize = chunksize(next);
+ psize += nsize;
+ unlink_chunk(fm, next, nsize);
+ set_size_and_pinuse_of_free_chunk(p, psize);
+ if (p == fm->dv) {
+ fm->dvsize = psize;
+ goto postaction;
+ }
+ }
+ } else
+ set_free_with_pinuse(p, psize, next);
+ insert_chunk(fm, p, psize);
+ check_free_chunk(fm, p);
+ goto postaction;
+ }
}
- else
- goto erroraction;
- }
+ erroraction:
+ USAGE_ERROR_ACTION(fm, p);
+ postaction:
+ POSTACTION(fm);
}
-
- if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
- if (!cinuse(next)) { /* consolidate forward */
- if (next == fm->top) {
- size_t tsize = fm->topsize += psize;
- fm->top = p;
- p->head = tsize | PINUSE_BIT;
- if (p == fm->dv) {
- fm->dv = 0;
- fm->dvsize = 0;
- }
- if (should_trim(fm, tsize))
- sys_trim(fm, 0);
- goto postaction;
- }
- else if (next == fm->dv) {
- size_t dsize = fm->dvsize += psize;
- fm->dv = p;
- set_size_and_pinuse_of_free_chunk(p, dsize);
- goto postaction;
- }
- else {
- size_t nsize = chunksize(next);
- psize += nsize;
- unlink_chunk(fm, next, nsize);
- set_size_and_pinuse_of_free_chunk(p, psize);
- if (p == fm->dv) {
- fm->dvsize = psize;
- goto postaction;
- }
- }
- }
- else
- set_free_with_pinuse(p, psize, next);
- insert_chunk(fm, p, psize);
- check_free_chunk(fm, p);
- goto postaction;
- }
- }
- erroraction:
- USAGE_ERROR_ACTION(fm, p);
- postaction:
- POSTACTION(fm);
}
- }
#if !FOOTERS
#undef fm
#endif /* FOOTERS */
}
-void* dlcalloc(size_t n_elements, size_t elem_size) {
- void* mem;
- size_t req = 0;
- if (n_elements != 0) {
- req = n_elements * elem_size;
- if (((n_elements | elem_size) & ~(size_t)0xffff) &&
- (req / n_elements != elem_size))
- req = MAX_SIZE_T; /* force downstream failure on overflow */
- }
- mem = dlmalloc(req);
- if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
- memset(mem, 0, req);
- return mem;
+void *
+dlcalloc(size_t n_elements, size_t elem_size)
+{
+ void *mem;
+ size_t req = 0;
+ if (n_elements != 0) {
+ req = n_elements * elem_size;
+ if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
+ (req / n_elements != elem_size))
+ req = MAX_SIZE_T; /* force downstream failure on overflow */
+ }
+ mem = dlmalloc(req);
+ if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+ memset(mem, 0, req);
+ return mem;
}
-void* dlrealloc(void* oldmem, size_t bytes) {
- if (oldmem == 0)
- return dlmalloc(bytes);
+void *
+dlrealloc(void *oldmem, size_t bytes)
+{
+ if (oldmem == 0)
+ return dlmalloc(bytes);
#ifdef REALLOC_ZERO_BYTES_FREES
- if (bytes == 0) {
- dlfree(oldmem);
- return 0;
- }
+ if (bytes == 0) {
+ dlfree(oldmem);
+ return 0;
+ }
#endif /* REALLOC_ZERO_BYTES_FREES */
- else {
+ else {
#if ! FOOTERS
- mstate m = gm;
+ mstate m = gm;
#else /* FOOTERS */
- mstate m = get_mstate_for(mem2chunk(oldmem));
- if (!ok_magic(m)) {
- USAGE_ERROR_ACTION(m, oldmem);
- return 0;
- }
+ mstate m = get_mstate_for(mem2chunk(oldmem));
+ if (!ok_magic(m)) {
+ USAGE_ERROR_ACTION(m, oldmem);
+ return 0;
+ }
#endif /* FOOTERS */
- return internal_realloc(m, oldmem, bytes);
- }
+ return internal_realloc(m, oldmem, bytes);
+ }
}
-void* dlmemalign(size_t alignment, size_t bytes) {
- return internal_memalign(gm, alignment, bytes);
+void *
+dlmemalign(size_t alignment, size_t bytes)
+{
+ return internal_memalign(gm, alignment, bytes);
}
-void** dlindependent_calloc(size_t n_elements, size_t elem_size,
- void* chunks[]) {
- size_t sz = elem_size; /* serves as 1-element array */
- return ialloc(gm, n_elements, &sz, 3, chunks);
+void **
+dlindependent_calloc(size_t n_elements, size_t elem_size, void *chunks[])
+{
+ size_t sz = elem_size; /* serves as 1-element array */
+ return ialloc(gm, n_elements, &sz, 3, chunks);
}
-void** dlindependent_comalloc(size_t n_elements, size_t sizes[],
- void* chunks[]) {
- return ialloc(gm, n_elements, sizes, 0, chunks);
+void **
+dlindependent_comalloc(size_t n_elements, size_t sizes[], void *chunks[])
+{
+ return ialloc(gm, n_elements, sizes, 0, chunks);
}
-void* dlvalloc(size_t bytes) {
- size_t pagesz;
- init_mparams();
- pagesz = mparams.page_size;
- return dlmemalign(pagesz, bytes);
+void *
+dlvalloc(size_t bytes)
+{
+ size_t pagesz;
+ init_mparams();
+ pagesz = mparams.page_size;
+ return dlmemalign(pagesz, bytes);
}
-void* dlpvalloc(size_t bytes) {
- size_t pagesz;
- init_mparams();
- pagesz = mparams.page_size;
- return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
+void *
+dlpvalloc(size_t bytes)
+{
+ size_t pagesz;
+ init_mparams();
+ pagesz = mparams.page_size;
+ return dlmemalign(pagesz,
+ (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
}
-int dlmalloc_trim(size_t pad) {
- int result = 0;
- if (!PREACTION(gm)) {
- result = sys_trim(gm, pad);
- POSTACTION(gm);
- }
- return result;
+int
+dlmalloc_trim(size_t pad)
+{
+ int result = 0;
+ if (!PREACTION(gm)) {
+ result = sys_trim(gm, pad);
+ POSTACTION(gm);
+ }
+ return result;
}
-size_t dlmalloc_footprint(void) {
- return gm->footprint;
+size_t
+dlmalloc_footprint(void)
+{
+ return gm->footprint;
}
-size_t dlmalloc_max_footprint(void) {
- return gm->max_footprint;
+size_t
+dlmalloc_max_footprint(void)
+{
+ return gm->max_footprint;
}
#if !NO_MALLINFO
-struct mallinfo dlmallinfo(void) {
- return internal_mallinfo(gm);
+struct mallinfo
+dlmallinfo(void)
+{
+ return internal_mallinfo(gm);
}
#endif /* NO_MALLINFO */
-void dlmalloc_stats() {
- internal_malloc_stats(gm);
+void
+dlmalloc_stats()
+{
+ internal_malloc_stats(gm);
}
-size_t dlmalloc_usable_size(void* mem) {
- if (mem != 0) {
- mchunkptr p = mem2chunk(mem);
- if (cinuse(p))
- return chunksize(p) - overhead_for(p);
- }
- return 0;
+size_t
+dlmalloc_usable_size(void *mem)
+{
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ if (cinuse(p))
+ return chunksize(p) - overhead_for(p);
+ }
+ return 0;
}
-int dlmallopt(int param_number, int value) {
- return change_mparam(param_number, value);
+int
+dlmallopt(int param_number, int value)
+{
+ return change_mparam(param_number, value);
}
#endif /* !ONLY_MSPACES */
@@ -4413,78 +4512,85 @@ int dlmallopt(int param_number, int value) {
#if MSPACES
-static mstate init_user_mstate(char* tbase, size_t tsize) {
- size_t msize = pad_request(sizeof(struct malloc_state));
- mchunkptr mn;
- mchunkptr msp = align_as_chunk(tbase);
- mstate m = (mstate)(chunk2mem(msp));
- memset(m, 0, msize);
- INITIAL_LOCK(&m->mutex);
- msp->head = (msize|PINUSE_BIT|CINUSE_BIT);
- m->seg.base = m->least_addr = tbase;
- m->seg.size = m->footprint = m->max_footprint = tsize;
- m->magic = mparams.magic;
- m->mflags = mparams.default_mflags;
- disable_contiguous(m);
- init_bins(m);
- mn = next_chunk(mem2chunk(m));
- init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);
- check_top_chunk(m, m->top);
- return m;
+static mstate
+init_user_mstate(char *tbase, size_t tsize)
+{
+ size_t msize = pad_request(sizeof(struct malloc_state));
+ mchunkptr mn;
+ mchunkptr msp = align_as_chunk(tbase);
+ mstate m = (mstate) (chunk2mem(msp));
+ memset(m, 0, msize);
+ INITIAL_LOCK(&m->mutex);
+ msp->head = (msize | PINUSE_BIT | CINUSE_BIT);
+ m->seg.base = m->least_addr = tbase;
+ m->seg.size = m->footprint = m->max_footprint = tsize;
+ m->magic = mparams.magic;
+ m->mflags = mparams.default_mflags;
+ disable_contiguous(m);
+ init_bins(m);
+ mn = next_chunk(mem2chunk(m));
+ init_top(m, mn, (size_t) ((tbase + tsize) - (char *) mn) - TOP_FOOT_SIZE);
+ check_top_chunk(m, m->top);
+ return m;
}
-mspace create_mspace(size_t capacity, int locked) {
- mstate m = 0;
- size_t msize = pad_request(sizeof(struct malloc_state));
- init_mparams(); /* Ensure pagesize etc initialized */
-
- if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
- size_t rs = ((capacity == 0)? mparams.granularity :
- (capacity + TOP_FOOT_SIZE + msize));
- size_t tsize = granularity_align(rs);
- char* tbase = (char*)(CALL_MMAP(tsize));
- if (tbase != CMFAIL) {
- m = init_user_mstate(tbase, tsize);
- m->seg.sflags = IS_MMAPPED_BIT;
- set_lock(m, locked);
+mspace
+create_mspace(size_t capacity, int locked)
+{
+ mstate m = 0;
+ size_t msize = pad_request(sizeof(struct malloc_state));
+ init_mparams(); /* Ensure pagesize etc initialized */
+
+ if (capacity < (size_t) - (msize + TOP_FOOT_SIZE + mparams.page_size)) {
+ size_t rs = ((capacity == 0) ? mparams.granularity :
+ (capacity + TOP_FOOT_SIZE + msize));
+ size_t tsize = granularity_align(rs);
+ char *tbase = (char *) (CALL_MMAP(tsize));
+ if (tbase != CMFAIL) {
+ m = init_user_mstate(tbase, tsize);
+ m->seg.sflags = IS_MMAPPED_BIT;
+ set_lock(m, locked);
+ }
}
- }
- return (mspace)m;
+ return (mspace) m;
}
-mspace create_mspace_with_base(void* base, size_t capacity, int locked) {
- mstate m = 0;
- size_t msize = pad_request(sizeof(struct malloc_state));
- init_mparams(); /* Ensure pagesize etc initialized */
-
- if (capacity > msize + TOP_FOOT_SIZE &&
- capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
- m = init_user_mstate((char*)base, capacity);
- m->seg.sflags = EXTERN_BIT;
- set_lock(m, locked);
- }
- return (mspace)m;
+mspace
+create_mspace_with_base(void *base, size_t capacity, int locked)
+{
+ mstate m = 0;
+ size_t msize = pad_request(sizeof(struct malloc_state));
+ init_mparams(); /* Ensure pagesize etc initialized */
+
+ if (capacity > msize + TOP_FOOT_SIZE &&
+ capacity < (size_t) - (msize + TOP_FOOT_SIZE + mparams.page_size)) {
+ m = init_user_mstate((char *) base, capacity);
+ m->seg.sflags = EXTERN_BIT;
+ set_lock(m, locked);
+ }
+ return (mspace) m;
}
-size_t destroy_mspace(mspace msp) {
- size_t freed = 0;
- mstate ms = (mstate)msp;
- if (ok_magic(ms)) {
- msegmentptr sp = &ms->seg;
- while (sp != 0) {
- char* base = sp->base;
- size_t size = sp->size;
- flag_t flag = sp->sflags;
- sp = sp->next;
- if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) &&
- CALL_MUNMAP(base, size) == 0)
- freed += size;
+size_t
+destroy_mspace(mspace msp)
+{
+ size_t freed = 0;
+ mstate ms = (mstate) msp;
+ if (ok_magic(ms)) {
+ msegmentptr sp = &ms->seg;
+ while (sp != 0) {
+ char *base = sp->base;
+ size_t size = sp->size;
+ flag_t flag = sp->sflags;
+ sp = sp->next;
+ if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) &&
+ CALL_MUNMAP(base, size) == 0)
+ freed += size;
+ }
+ } else {
+ USAGE_ERROR_ACTION(ms, ms);
}
- }
- else {
- USAGE_ERROR_ACTION(ms,ms);
- }
- return freed;
+ return freed;
}
/*
@@ -4493,344 +4599,363 @@ size_t destroy_mspace(mspace msp) {
*/
-void* mspace_malloc(mspace msp, size_t bytes) {
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
- }
- if (!PREACTION(ms)) {
- void* mem;
- size_t nb;
- if (bytes <= MAX_SMALL_REQUEST) {
- bindex_t idx;
- binmap_t smallbits;
- nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
- idx = small_index(nb);
- smallbits = ms->smallmap >> idx;
-
- if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
- mchunkptr b, p;
- idx += ~smallbits & 1; /* Uses next bin if idx empty */
- b = smallbin_at(ms, idx);
- p = b->fd;
- assert(chunksize(p) == small_index2size(idx));
- unlink_first_small_chunk(ms, b, p, idx);
- set_inuse_and_pinuse(ms, p, small_index2size(idx));
- mem = chunk2mem(p);
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
- }
+void *
+mspace_malloc(mspace msp, size_t bytes)
+{
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ if (!PREACTION(ms)) {
+ void *mem;
+ size_t nb;
+ if (bytes <= MAX_SMALL_REQUEST) {
+ bindex_t idx;
+ binmap_t smallbits;
+ nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
+ idx = small_index(nb);
+ smallbits = ms->smallmap >> idx;
+
+ if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+ mchunkptr b, p;
+ idx += ~smallbits & 1; /* Uses next bin if idx empty */
+ b = smallbin_at(ms, idx);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(idx));
+ unlink_first_small_chunk(ms, b, p, idx);
+ set_inuse_and_pinuse(ms, p, small_index2size(idx));
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
- else if (nb > ms->dvsize) {
- if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
- mchunkptr b, p, r;
- size_t rsize;
- bindex_t i;
- binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
- binmap_t leastbit = least_bit(leftbits);
- compute_bit2idx(leastbit, i);
- b = smallbin_at(ms, i);
- p = b->fd;
- assert(chunksize(p) == small_index2size(i));
- unlink_first_small_chunk(ms, b, p, i);
- rsize = small_index2size(i) - nb;
- /* Fit here cannot be remainderless if 4byte sizes */
- if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
- set_inuse_and_pinuse(ms, p, small_index2size(i));
- else {
- set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
- r = chunk_plus_offset(p, nb);
- set_size_and_pinuse_of_free_chunk(r, rsize);
- replace_dv(ms, r, rsize);
- }
- mem = chunk2mem(p);
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
+ else if (nb > ms->dvsize) {
+ if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
+ mchunkptr b, p, r;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leftbits =
+ (smallbits << idx) & left_bits(idx2bit(idx));
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ b = smallbin_at(ms, i);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(i));
+ unlink_first_small_chunk(ms, b, p, i);
+ rsize = small_index2size(i) - nb;
+ /* Fit here cannot be remainderless if 4byte sizes */
+ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(ms, p, small_index2size(i));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ r = chunk_plus_offset(p, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(ms, r, rsize);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+
+ else if (ms->treemap != 0
+ && (mem = tmalloc_small(ms, nb)) != 0) {
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+ }
+ } else if (bytes >= MAX_REQUEST)
+ nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
+ else {
+ nb = pad_request(bytes);
+ if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
}
- else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) {
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
+ if (nb <= ms->dvsize) {
+ size_t rsize = ms->dvsize - nb;
+ mchunkptr p = ms->dv;
+ if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
+ mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
+ ms->dvsize = rsize;
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ } else { /* exhaust dv */
+ size_t dvs = ms->dvsize;
+ ms->dvsize = 0;
+ ms->dv = 0;
+ set_inuse_and_pinuse(ms, p, dvs);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
}
- }
- }
- else if (bytes >= MAX_REQUEST)
- nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
- else {
- nb = pad_request(bytes);
- if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
- }
- }
- if (nb <= ms->dvsize) {
- size_t rsize = ms->dvsize - nb;
- mchunkptr p = ms->dv;
- if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
- mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
- ms->dvsize = rsize;
- set_size_and_pinuse_of_free_chunk(r, rsize);
- set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
- }
- else { /* exhaust dv */
- size_t dvs = ms->dvsize;
- ms->dvsize = 0;
- ms->dv = 0;
- set_inuse_and_pinuse(ms, p, dvs);
- }
- mem = chunk2mem(p);
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
- }
-
- else if (nb < ms->topsize) { /* Split top */
- size_t rsize = ms->topsize -= nb;
- mchunkptr p = ms->top;
- mchunkptr r = ms->top = chunk_plus_offset(p, nb);
- r->head = rsize | PINUSE_BIT;
- set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
- mem = chunk2mem(p);
- check_top_chunk(ms, ms->top);
- check_malloced_chunk(ms, mem, nb);
- goto postaction;
- }
+ else if (nb < ms->topsize) { /* Split top */
+ size_t rsize = ms->topsize -= nb;
+ mchunkptr p = ms->top;
+ mchunkptr r = ms->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ mem = chunk2mem(p);
+ check_top_chunk(ms, ms->top);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
- mem = sys_alloc(ms, nb);
+ mem = sys_alloc(ms, nb);
- postaction:
- POSTACTION(ms);
- return mem;
- }
+ postaction:
+ POSTACTION(ms);
+ return mem;
+ }
- return 0;
+ return 0;
}
-void mspace_free(mspace msp, void* mem) {
- if (mem != 0) {
- mchunkptr p = mem2chunk(mem);
+void
+mspace_free(mspace msp, void *mem)
+{
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
#if FOOTERS
- mstate fm = get_mstate_for(p);
+ mstate fm = get_mstate_for(p);
#else /* FOOTERS */
- mstate fm = (mstate)msp;
+ mstate fm = (mstate) msp;
#endif /* FOOTERS */
- if (!ok_magic(fm)) {
- USAGE_ERROR_ACTION(fm, p);
- return;
- }
- if (!PREACTION(fm)) {
- check_inuse_chunk(fm, p);
- if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
- size_t psize = chunksize(p);
- mchunkptr next = chunk_plus_offset(p, psize);
- if (!pinuse(p)) {
- size_t prevsize = p->prev_foot;
- if ((prevsize & IS_MMAPPED_BIT) != 0) {
- prevsize &= ~IS_MMAPPED_BIT;
- psize += prevsize + MMAP_FOOT_PAD;
- if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
- fm->footprint -= psize;
- goto postaction;
- }
- else {
- mchunkptr prev = chunk_minus_offset(p, prevsize);
- psize += prevsize;
- p = prev;
- if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
- if (p != fm->dv) {
- unlink_chunk(fm, p, prevsize);
- }
- else if ((next->head & INUSE_BITS) == INUSE_BITS) {
- fm->dvsize = psize;
- set_free_with_pinuse(p, psize, next);
- goto postaction;
- }
- }
- else
- goto erroraction;
- }
+ if (!ok_magic(fm)) {
+ USAGE_ERROR_ACTION(fm, p);
+ return;
}
-
- if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
- if (!cinuse(next)) { /* consolidate forward */
- if (next == fm->top) {
- size_t tsize = fm->topsize += psize;
- fm->top = p;
- p->head = tsize | PINUSE_BIT;
- if (p == fm->dv) {
- fm->dv = 0;
- fm->dvsize = 0;
- }
- if (should_trim(fm, tsize))
- sys_trim(fm, 0);
- goto postaction;
- }
- else if (next == fm->dv) {
- size_t dsize = fm->dvsize += psize;
- fm->dv = p;
- set_size_and_pinuse_of_free_chunk(p, dsize);
- goto postaction;
+ if (!PREACTION(fm)) {
+ check_inuse_chunk(fm, p);
+ if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
+ size_t psize = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, psize);
+ if (!pinuse(p)) {
+ size_t prevsize = p->prev_foot;
+ if ((prevsize & IS_MMAPPED_BIT) != 0) {
+ prevsize &= ~IS_MMAPPED_BIT;
+ psize += prevsize + MMAP_FOOT_PAD;
+ if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
+ fm->footprint -= psize;
+ goto postaction;
+ } else {
+ mchunkptr prev = chunk_minus_offset(p, prevsize);
+ psize += prevsize;
+ p = prev;
+ if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
+ if (p != fm->dv) {
+ unlink_chunk(fm, p, prevsize);
+ } else if ((next->head & INUSE_BITS) ==
+ INUSE_BITS) {
+ fm->dvsize = psize;
+ set_free_with_pinuse(p, psize, next);
+ goto postaction;
+ }
+ } else
+ goto erroraction;
+ }
+ }
+
+ if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+ if (!cinuse(next)) { /* consolidate forward */
+ if (next == fm->top) {
+ size_t tsize = fm->topsize += psize;
+ fm->top = p;
+ p->head = tsize | PINUSE_BIT;
+ if (p == fm->dv) {
+ fm->dv = 0;
+ fm->dvsize = 0;
+ }
+ if (should_trim(fm, tsize))
+ sys_trim(fm, 0);
+ goto postaction;
+ } else if (next == fm->dv) {
+ size_t dsize = fm->dvsize += psize;
+ fm->dv = p;
+ set_size_and_pinuse_of_free_chunk(p, dsize);
+ goto postaction;
+ } else {
+ size_t nsize = chunksize(next);
+ psize += nsize;
+ unlink_chunk(fm, next, nsize);
+ set_size_and_pinuse_of_free_chunk(p, psize);
+ if (p == fm->dv) {
+ fm->dvsize = psize;
+ goto postaction;
+ }
+ }
+ } else
+ set_free_with_pinuse(p, psize, next);
+ insert_chunk(fm, p, psize);
+ check_free_chunk(fm, p);
+ goto postaction;
+ }
}
- else {
- size_t nsize = chunksize(next);
- psize += nsize;
- unlink_chunk(fm, next, nsize);
- set_size_and_pinuse_of_free_chunk(p, psize);
- if (p == fm->dv) {
- fm->dvsize = psize;
- goto postaction;
- }
- }
- }
- else
- set_free_with_pinuse(p, psize, next);
- insert_chunk(fm, p, psize);
- check_free_chunk(fm, p);
- goto postaction;
+ erroraction:
+ USAGE_ERROR_ACTION(fm, p);
+ postaction:
+ POSTACTION(fm);
}
- }
- erroraction:
- USAGE_ERROR_ACTION(fm, p);
- postaction:
- POSTACTION(fm);
}
- }
}
-void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) {
- void* mem;
- size_t req = 0;
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
- }
- if (n_elements != 0) {
- req = n_elements * elem_size;
- if (((n_elements | elem_size) & ~(size_t)0xffff) &&
- (req / n_elements != elem_size))
- req = MAX_SIZE_T; /* force downstream failure on overflow */
- }
- mem = internal_malloc(ms, req);
- if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
- memset(mem, 0, req);
- return mem;
+void *
+mspace_calloc(mspace msp, size_t n_elements, size_t elem_size)
+{
+ void *mem;
+ size_t req = 0;
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ if (n_elements != 0) {
+ req = n_elements * elem_size;
+ if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
+ (req / n_elements != elem_size))
+ req = MAX_SIZE_T; /* force downstream failure on overflow */
+ }
+ mem = internal_malloc(ms, req);
+ if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+ memset(mem, 0, req);
+ return mem;
}
-void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
- if (oldmem == 0)
- return mspace_malloc(msp, bytes);
+void *
+mspace_realloc(mspace msp, void *oldmem, size_t bytes)
+{
+ if (oldmem == 0)
+ return mspace_malloc(msp, bytes);
#ifdef REALLOC_ZERO_BYTES_FREES
- if (bytes == 0) {
- mspace_free(msp, oldmem);
- return 0;
- }
+ if (bytes == 0) {
+ mspace_free(msp, oldmem);
+ return 0;
+ }
#endif /* REALLOC_ZERO_BYTES_FREES */
- else {
+ else {
#if FOOTERS
- mchunkptr p = mem2chunk(oldmem);
- mstate ms = get_mstate_for(p);
+ mchunkptr p = mem2chunk(oldmem);
+ mstate ms = get_mstate_for(p);
#else /* FOOTERS */
- mstate ms = (mstate)msp;
+ mstate ms = (mstate) msp;
#endif /* FOOTERS */
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ return internal_realloc(ms, oldmem, bytes);
}
- return internal_realloc(ms, oldmem, bytes);
- }
}
-void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
- }
- return internal_memalign(ms, alignment, bytes);
+void *
+mspace_memalign(mspace msp, size_t alignment, size_t bytes)
+{
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ return internal_memalign(ms, alignment, bytes);
}
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
- size_t elem_size, void* chunks[]) {
- size_t sz = elem_size; /* serves as 1-element array */
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
- }
- return ialloc(ms, n_elements, &sz, 3, chunks);
+void **
+mspace_independent_calloc(mspace msp, size_t n_elements,
+ size_t elem_size, void *chunks[])
+{
+ size_t sz = elem_size; /* serves as 1-element array */
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ return ialloc(ms, n_elements, &sz, 3, chunks);
}
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
- size_t sizes[], void* chunks[]) {
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- return 0;
- }
- return ialloc(ms, n_elements, sizes, 0, chunks);
+void **
+mspace_independent_comalloc(mspace msp, size_t n_elements,
+ size_t sizes[], void *chunks[])
+{
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ return 0;
+ }
+ return ialloc(ms, n_elements, sizes, 0, chunks);
}
-int mspace_trim(mspace msp, size_t pad) {
- int result = 0;
- mstate ms = (mstate)msp;
- if (ok_magic(ms)) {
- if (!PREACTION(ms)) {
- result = sys_trim(ms, pad);
- POSTACTION(ms);
+int
+mspace_trim(mspace msp, size_t pad)
+{
+ int result = 0;
+ mstate ms = (mstate) msp;
+ if (ok_magic(ms)) {
+ if (!PREACTION(ms)) {
+ result = sys_trim(ms, pad);
+ POSTACTION(ms);
+ }
+ } else {
+ USAGE_ERROR_ACTION(ms, ms);
}
- }
- else {
- USAGE_ERROR_ACTION(ms,ms);
- }
- return result;
+ return result;
}
-void mspace_malloc_stats(mspace msp) {
- mstate ms = (mstate)msp;
- if (ok_magic(ms)) {
- internal_malloc_stats(ms);
- }
- else {
- USAGE_ERROR_ACTION(ms,ms);
- }
+void
+mspace_malloc_stats(mspace msp)
+{
+ mstate ms = (mstate) msp;
+ if (ok_magic(ms)) {
+ internal_malloc_stats(ms);
+ } else {
+ USAGE_ERROR_ACTION(ms, ms);
+ }
}
-size_t mspace_footprint(mspace msp) {
- size_t result;
- mstate ms = (mstate)msp;
- if (ok_magic(ms)) {
- result = ms->footprint;
- }
- USAGE_ERROR_ACTION(ms,ms);
- return result;
+size_t
+mspace_footprint(mspace msp)
+{
+ size_t result;
+ mstate ms = (mstate) msp;
+ if (ok_magic(ms)) {
+ result = ms->footprint;
+ }
+ USAGE_ERROR_ACTION(ms, ms);
+ return result;
}
-size_t mspace_max_footprint(mspace msp) {
- size_t result;
- mstate ms = (mstate)msp;
- if (ok_magic(ms)) {
- result = ms->max_footprint;
- }
- USAGE_ERROR_ACTION(ms,ms);
- return result;
+size_t
+mspace_max_footprint(mspace msp)
+{
+ size_t result;
+ mstate ms = (mstate) msp;
+ if (ok_magic(ms)) {
+ result = ms->max_footprint;
+ }
+ USAGE_ERROR_ACTION(ms, ms);
+ return result;
}
#if !NO_MALLINFO
-struct mallinfo mspace_mallinfo(mspace msp) {
- mstate ms = (mstate)msp;
- if (!ok_magic(ms)) {
- USAGE_ERROR_ACTION(ms,ms);
- }
- return internal_mallinfo(ms);
+struct mallinfo
+mspace_mallinfo(mspace msp)
+{
+ mstate ms = (mstate) msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms, ms);
+ }
+ return internal_mallinfo(ms);
}
#endif /* NO_MALLINFO */
-int mspace_mallopt(int param_number, int value) {
- return change_mparam(param_number, value);
+int
+mspace_mallopt(int param_number, int value)
+{
+ return change_mparam(param_number, value);
}
#endif /* MSPACES */
@@ -5109,3 +5234,4 @@ History:
*/
#endif /* !HAVE_MALLOC */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/stdlib/SDL_qsort.c b/src/stdlib/SDL_qsort.c
index 9278d257..11be41f3 100644
--- a/src/stdlib/SDL_qsort.c
+++ b/src/stdlib/SDL_qsort.c
@@ -60,7 +60,7 @@
#ifndef HAVE_QSORT
-static char _ID[]="<qsort.c gjm 1.12 1998-03-19>";
+static char _ID[] = "<qsort.c gjm 1.12 1998-03-19>";
/* How many bytes are there per word? (Must be a power of 2,
* and must in fact equal sizeof(int).)
@@ -81,7 +81,7 @@ static char _ID[]="<qsort.c gjm 1.12 1998-03-19>";
*/
#define TRUNC_nonaligned 12
#define TRUNC_aligned 12
-#define TRUNC_words 12*WORD_BYTES /* nb different meaning */
+#define TRUNC_words 12*WORD_BYTES /* nb different meaning */
/* We use a simple pivoting algorithm for shortish sub-arrays
* and a more complicated one for larger ones. The threshold
@@ -89,7 +89,11 @@ static char _ID[]="<qsort.c gjm 1.12 1998-03-19>";
*/
#define PIVOT_THRESHOLD 40
-typedef struct { char * first; char * last; } stack_entry;
+typedef struct
+{
+ char *first;
+ char *last;
+} stack_entry;
#define pushLeft {stack[stacktop].first=ffirst;stack[stacktop++].last=last;}
#define pushRight {stack[stacktop].first=first;stack[stacktop++].last=llast;}
#define doLeft {first=ffirst;llast=last;continue;}
@@ -261,165 +265,187 @@ typedef struct { char * first; char * last; } stack_entry;
/* ---------------------------------------------------------------------- */
-static char * pivot_big(char *first, char *mid, char *last, size_t size,
- int compare(const void *, const void *)) {
- size_t d=(((last-first)/size)>>3)*size;
- char *m1,*m2,*m3;
- { char *a=first, *b=first+d, *c=first+2*d;
+static char *
+pivot_big(char *first, char *mid, char *last, size_t size,
+ int compare(const void *, const void *))
+{
+ size_t d = (((last - first) / size) >> 3) * size;
+ char *m1, *m2, *m3;
+ {
+ char *a = first, *b = first + d, *c = first + 2 * d;
#ifdef DEBUG_QSORT
-fprintf(stderr,"< %d %d %d\n",*(int*)a,*(int*)b,*(int*)c);
+ fprintf(stderr, "< %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
#endif
- m1 = compare(a,b)<0 ?
- (compare(b,c)<0 ? b : (compare(a,c)<0 ? c : a))
- : (compare(a,c)<0 ? a : (compare(b,c)<0 ? c : b));
- }
- { char *a=mid-d, *b=mid, *c=mid+d;
+ m1 = compare(a, b) < 0 ?
+ (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+ : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
+ }
+ {
+ char *a = mid - d, *b = mid, *c = mid + d;
#ifdef DEBUG_QSORT
-fprintf(stderr,". %d %d %d\n",*(int*)a,*(int*)b,*(int*)c);
+ fprintf(stderr, ". %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
#endif
- m2 = compare(a,b)<0 ?
- (compare(b,c)<0 ? b : (compare(a,c)<0 ? c : a))
- : (compare(a,c)<0 ? a : (compare(b,c)<0 ? c : b));
- }
- { char *a=last-2*d, *b=last-d, *c=last;
+ m2 = compare(a, b) < 0 ?
+ (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+ : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
+ }
+ {
+ char *a = last - 2 * d, *b = last - d, *c = last;
#ifdef DEBUG_QSORT
-fprintf(stderr,"> %d %d %d\n",*(int*)a,*(int*)b,*(int*)c);
+ fprintf(stderr, "> %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
#endif
- m3 = compare(a,b)<0 ?
- (compare(b,c)<0 ? b : (compare(a,c)<0 ? c : a))
- : (compare(a,c)<0 ? a : (compare(b,c)<0 ? c : b));
- }
+ m3 = compare(a, b) < 0 ?
+ (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+ : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
+ }
#ifdef DEBUG_QSORT
-fprintf(stderr,"-> %d %d %d\n",*(int*)m1,*(int*)m2,*(int*)m3);
+ fprintf(stderr, "-> %d %d %d\n", *(int *) m1, *(int *) m2, *(int *) m3);
#endif
- return compare(m1,m2)<0 ?
- (compare(m2,m3)<0 ? m2 : (compare(m1,m3)<0 ? m3 : m1))
- : (compare(m1,m3)<0 ? m1 : (compare(m2,m3)<0 ? m3 : m2));
+ return compare(m1, m2) < 0 ?
+ (compare(m2, m3) < 0 ? m2 : (compare(m1, m3) < 0 ? m3 : m1))
+ : (compare(m1, m3) < 0 ? m1 : (compare(m2, m3) < 0 ? m3 : m2));
}
/* ---------------------------------------------------------------------- */
-static void qsort_nonaligned(void *base, size_t nmemb, size_t size,
- int (*compare)(const void *, const void *)) {
-
- stack_entry stack[STACK_SIZE];
- int stacktop=0;
- char *first,*last;
- char *pivot=malloc(size);
- size_t trunc=TRUNC_nonaligned*size;
- assert(pivot!=0);
-
- first=(char*)base; last=first+(nmemb-1)*size;
-
- if ((size_t)(last-first)>trunc) {
- char *ffirst=first, *llast=last;
- while (1) {
- /* Select pivot */
- { char * mid=first+size*((last-first)/size >> 1);
- Pivot(SWAP_nonaligned,size);
- memcpy(pivot,mid,size);
- }
- /* Partition. */
- Partition(SWAP_nonaligned,size);
- /* Prepare to recurse/iterate. */
- Recurse(trunc)
+static void
+qsort_nonaligned(void *base, size_t nmemb, size_t size,
+ int (*compare) (const void *, const void *))
+{
+
+ stack_entry stack[STACK_SIZE];
+ int stacktop = 0;
+ char *first, *last;
+ char *pivot = malloc(size);
+ size_t trunc = TRUNC_nonaligned * size;
+ assert(pivot != 0);
+
+ first = (char *) base;
+ last = first + (nmemb - 1) * size;
+
+ if ((size_t) (last - first) > trunc) {
+ char *ffirst = first, *llast = last;
+ while (1) {
+ /* Select pivot */
+ {
+ char *mid = first + size * ((last - first) / size >> 1);
+ Pivot(SWAP_nonaligned, size);
+ memcpy(pivot, mid, size);
+ }
+ /* Partition. */
+ Partition(SWAP_nonaligned, size);
+ /* Prepare to recurse/iterate. */
+ Recurse(trunc)}
}
- }
- PreInsertion(SWAP_nonaligned,TRUNC_nonaligned,size);
- Insertion(SWAP_nonaligned);
- free(pivot);
+ PreInsertion(SWAP_nonaligned, TRUNC_nonaligned, size);
+ Insertion(SWAP_nonaligned);
+ free(pivot);
}
-static void qsort_aligned(void *base, size_t nmemb, size_t size,
- int (*compare)(const void *, const void *)) {
-
- stack_entry stack[STACK_SIZE];
- int stacktop=0;
- char *first,*last;
- char *pivot=malloc(size);
- size_t trunc=TRUNC_aligned*size;
- assert(pivot!=0);
-
- first=(char*)base; last=first+(nmemb-1)*size;
-
- if ((size_t)(last-first)>trunc) {
- char *ffirst=first,*llast=last;
- while (1) {
- /* Select pivot */
- { char * mid=first+size*((last-first)/size >> 1);
- Pivot(SWAP_aligned,size);
- memcpy(pivot,mid,size);
- }
- /* Partition. */
- Partition(SWAP_aligned,size);
- /* Prepare to recurse/iterate. */
- Recurse(trunc)
+static void
+qsort_aligned(void *base, size_t nmemb, size_t size,
+ int (*compare) (const void *, const void *))
+{
+
+ stack_entry stack[STACK_SIZE];
+ int stacktop = 0;
+ char *first, *last;
+ char *pivot = malloc(size);
+ size_t trunc = TRUNC_aligned * size;
+ assert(pivot != 0);
+
+ first = (char *) base;
+ last = first + (nmemb - 1) * size;
+
+ if ((size_t) (last - first) > trunc) {
+ char *ffirst = first, *llast = last;
+ while (1) {
+ /* Select pivot */
+ {
+ char *mid = first + size * ((last - first) / size >> 1);
+ Pivot(SWAP_aligned, size);
+ memcpy(pivot, mid, size);
+ }
+ /* Partition. */
+ Partition(SWAP_aligned, size);
+ /* Prepare to recurse/iterate. */
+ Recurse(trunc)}
}
- }
- PreInsertion(SWAP_aligned,TRUNC_aligned,size);
- Insertion(SWAP_aligned);
- free(pivot);
+ PreInsertion(SWAP_aligned, TRUNC_aligned, size);
+ Insertion(SWAP_aligned);
+ free(pivot);
}
-static void qsort_words(void *base, size_t nmemb,
- int (*compare)(const void *, const void *)) {
+static void
+qsort_words(void *base, size_t nmemb,
+ int (*compare) (const void *, const void *))
+{
- stack_entry stack[STACK_SIZE];
- int stacktop=0;
- char *first,*last;
- char *pivot=malloc(WORD_BYTES);
- assert(pivot!=0);
+ stack_entry stack[STACK_SIZE];
+ int stacktop = 0;
+ char *first, *last;
+ char *pivot = malloc(WORD_BYTES);
+ assert(pivot != 0);
- first=(char*)base; last=first+(nmemb-1)*WORD_BYTES;
+ first = (char *) base;
+ last = first + (nmemb - 1) * WORD_BYTES;
- if (last-first>TRUNC_words) {
- char *ffirst=first, *llast=last;
- while (1) {
+ if (last - first > TRUNC_words) {
+ char *ffirst = first, *llast = last;
+ while (1) {
#ifdef DEBUG_QSORT
-fprintf(stderr,"Doing %d:%d: ",
- (first-(char*)base)/WORD_BYTES,
- (last-(char*)base)/WORD_BYTES);
+ fprintf(stderr, "Doing %d:%d: ",
+ (first - (char *) base) / WORD_BYTES,
+ (last - (char *) base) / WORD_BYTES);
#endif
- /* Select pivot */
- { char * mid=first+WORD_BYTES*((last-first) / (2*WORD_BYTES));
- Pivot(SWAP_words,WORD_BYTES);
- *(int*)pivot=*(int*)mid;
- }
+ /* Select pivot */
+ {
+ char *mid =
+ first + WORD_BYTES * ((last - first) / (2 * WORD_BYTES));
+ Pivot(SWAP_words, WORD_BYTES);
+ *(int *) pivot = *(int *) mid;
+ }
#ifdef DEBUG_QSORT
-fprintf(stderr,"pivot=%d\n",*(int*)pivot);
+ fprintf(stderr, "pivot=%d\n", *(int *) pivot);
#endif
- /* Partition. */
- Partition(SWAP_words,WORD_BYTES);
- /* Prepare to recurse/iterate. */
- Recurse(TRUNC_words)
+ /* Partition. */
+ Partition(SWAP_words, WORD_BYTES);
+ /* Prepare to recurse/iterate. */
+ Recurse(TRUNC_words)}
}
- }
- PreInsertion(SWAP_words,(TRUNC_words/WORD_BYTES),WORD_BYTES);
- /* Now do insertion sort. */
- last=((char*)base)+nmemb*WORD_BYTES;
- for (first=((char*)base)+WORD_BYTES;first!=last;first+=WORD_BYTES) {
- /* Find the right place for |first|. My apologies for var reuse */
- int *pl=(int*)(first-WORD_BYTES),*pr=(int*)first;
- *(int*)pivot=*(int*)first;
- for (;compare(pl,pivot)>0;pr=pl,--pl) {
- *pr=*pl; }
- if (pr!=(int*)first) *pr=*(int*)pivot;
- }
- free(pivot);
+ PreInsertion(SWAP_words, (TRUNC_words / WORD_BYTES), WORD_BYTES);
+ /* Now do insertion sort. */
+ last = ((char *) base) + nmemb * WORD_BYTES;
+ for (first = ((char *) base) + WORD_BYTES; first != last;
+ first += WORD_BYTES) {
+ /* Find the right place for |first|. My apologies for var reuse */
+ int *pl = (int *) (first - WORD_BYTES), *pr = (int *) first;
+ *(int *) pivot = *(int *) first;
+ for (; compare(pl, pivot) > 0; pr = pl, --pl) {
+ *pr = *pl;
+ }
+ if (pr != (int *) first)
+ *pr = *(int *) pivot;
+ }
+ free(pivot);
}
/* ---------------------------------------------------------------------- */
-void qsort(void *base, size_t nmemb, size_t size,
- int (*compare)(const void *, const void *)) {
-
- if (nmemb<=1) return;
- if (((uintptr_t)base|size)&(WORD_BYTES-1))
- qsort_nonaligned(base,nmemb,size,compare);
- else if (size!=WORD_BYTES)
- qsort_aligned(base,nmemb,size,compare);
- else
- qsort_words(base,nmemb,compare);
+void
+qsort(void *base, size_t nmemb, size_t size,
+ int (*compare) (const void *, const void *))
+{
+
+ if (nmemb <= 1)
+ return;
+ if (((uintptr_t) base | size) & (WORD_BYTES - 1))
+ qsort_nonaligned(base, nmemb, size, compare);
+ else if (size != WORD_BYTES)
+ qsort_aligned(base, nmemb, size, compare);
+ else
+ qsort_words(base, nmemb, compare);
}
#endif /* !HAVE_QSORT */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/stdlib/SDL_stdlib.c b/src/stdlib/SDL_stdlib.c
index b9c3bacc..de17663a 100644
--- a/src/stdlib/SDL_stdlib.c
+++ b/src/stdlib/SDL_stdlib.c
@@ -33,588 +33,632 @@
#ifndef __FLTUSED__
#define __FLTUSED__
#ifdef __cplusplus
- extern "C"
+extern "C"
#endif
- __declspec(selectany) int _fltused=1;
+__declspec(selectany)
+ int _fltused = 1;
#endif
/* Float to long */
-void __declspec(naked) _ftol()
+ void __declspec(naked) _ftol()
{
- __asm {
- push ebp
- mov ebp,esp
- sub esp,20h
- and esp,0FFFFFFF0h
- fld st(0)
- fst dword ptr [esp+18h]
- fistp qword ptr [esp+10h]
- fild qword ptr [esp+10h]
- mov edx,dword ptr [esp+18h]
- mov eax,dword ptr [esp+10h]
- test eax,eax
- je integer_QnaN_or_zero
+ /* *INDENT-OFF* */
+ __asm {
+ push ebp
+ mov ebp,esp
+ sub esp,20h
+ and esp,0FFFFFFF0h
+ fld st(0)
+ fst dword ptr [esp+18h]
+ fistp qword ptr [esp+10h]
+ fild qword ptr [esp+10h]
+ mov edx,dword ptr [esp+18h]
+ mov eax,dword ptr [esp+10h]
+ test eax,eax
+ je integer_QnaN_or_zero
arg_is_not_integer_QnaN:
- fsubp st(1),st
- test edx,edx
- jns positive
- fstp dword ptr [esp]
- mov ecx,dword ptr [esp]
- xor ecx,80000000h
- add ecx,7FFFFFFFh
- adc eax,0
- mov edx,dword ptr [esp+14h]
- adc edx,0
- jmp localexit
+ fsubp st(1),st
+ test edx,edx
+ jns positive
+ fstp dword ptr [esp]
+ mov ecx,dword ptr [esp]
+ xor ecx,80000000h
+ add ecx,7FFFFFFFh
+ adc eax,0
+ mov edx,dword ptr [esp+14h]
+ adc edx,0
+ jmp localexit
positive:
- fstp dword ptr [esp]
- mov ecx,dword ptr [esp]
- add ecx,7FFFFFFFh
- sbb eax,0
- mov edx,dword ptr [esp+14h]
- sbb edx,0
- jmp localexit
+ fstp dword ptr [esp]
+ mov ecx,dword ptr [esp]
+ add ecx,7FFFFFFFh
+ sbb eax,0
+ mov edx,dword ptr [esp+14h]
+ sbb edx,0
+ jmp localexit
integer_QnaN_or_zero:
- mov edx,dword ptr [esp+14h]
- test edx,7FFFFFFFh
- jne arg_is_not_integer_QnaN
- fstp dword ptr [esp+18h]
- fstp dword ptr [esp+18h]
+ mov edx,dword ptr [esp+14h]
+ test edx,7FFFFFFFh
+ jne arg_is_not_integer_QnaN
+ fstp dword ptr [esp+18h]
+ fstp dword ptr [esp+18h]
localexit:
- leave
- ret
- }
+ leave
+ ret
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _ftol2_sse()
+
+void
+__declspec(naked)
+_ftol2_sse()
{
- _ftol();
+ _ftol();
}
/* 64-bit math operators for 32-bit systems */
-void __declspec(naked) _allmul()
+void
+__declspec(naked)
+_allmul()
{
- __asm {
- push ebp
- mov ebp,esp
- push edi
- push esi
- push ebx
- sub esp,0Ch
- mov eax,dword ptr [ebp+10h]
- mov edi,dword ptr [ebp+8]
- mov ebx,eax
- mov esi,eax
- sar esi,1Fh
- mov eax,dword ptr [ebp+8]
- mul ebx
- imul edi,esi
- mov ecx,edx
- mov dword ptr [ebp-18h],eax
- mov edx,dword ptr [ebp+0Ch]
- add ecx,edi
- imul ebx,edx
- mov eax,dword ptr [ebp-18h]
- lea ebx,[ebx+ecx]
- mov dword ptr [ebp-14h],ebx
- mov edx,dword ptr [ebp-14h]
- add esp,0Ch
- pop ebx
- pop esi
- pop edi
- pop ebp
- ret
- }
+ /* *INDENT-OFF* */
+ __asm {
+ push ebp
+ mov ebp,esp
+ push edi
+ push esi
+ push ebx
+ sub esp,0Ch
+ mov eax,dword ptr [ebp+10h]
+ mov edi,dword ptr [ebp+8]
+ mov ebx,eax
+ mov esi,eax
+ sar esi,1Fh
+ mov eax,dword ptr [ebp+8]
+ mul ebx
+ imul edi,esi
+ mov ecx,edx
+ mov dword ptr [ebp-18h],eax
+ mov edx,dword ptr [ebp+0Ch]
+ add ecx,edi
+ imul ebx,edx
+ mov eax,dword ptr [ebp-18h]
+ lea ebx,[ebx+ecx]
+ mov dword ptr [ebp-14h],ebx
+ mov edx,dword ptr [ebp-14h]
+ add esp,0Ch
+ pop ebx
+ pop esi
+ pop edi
+ pop ebp
+ ret
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _alldiv()
+void
+__declspec(naked)
+_alldiv()
{
- __asm {
- push edi
- push esi
- push ebx
- xor edi,edi
- mov eax,dword ptr [esp+14h]
- or eax,eax
- jge L1
- inc edi
- mov edx,dword ptr [esp+10h]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+14h],eax
- mov dword ptr [esp+10h],edx
+ /* *INDENT-OFF* */
+ __asm {
+ push edi
+ push esi
+ push ebx
+ xor edi,edi
+ mov eax,dword ptr [esp+14h]
+ or eax,eax
+ jge L1
+ inc edi
+ mov edx,dword ptr [esp+10h]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+14h],eax
+ mov dword ptr [esp+10h],edx
L1:
- mov eax,dword ptr [esp+1Ch]
- or eax,eax
- jge L2
- inc edi
- mov edx,dword ptr [esp+18h]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+1Ch],eax
- mov dword ptr [esp+18h],edx
+ mov eax,dword ptr [esp+1Ch]
+ or eax,eax
+ jge L2
+ inc edi
+ mov edx,dword ptr [esp+18h]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+1Ch],eax
+ mov dword ptr [esp+18h],edx
L2:
- or eax,eax
- jne L3
- mov ecx,dword ptr [esp+18h]
- mov eax,dword ptr [esp+14h]
- xor edx,edx
- div ecx
- mov ebx,eax
- mov eax,dword ptr [esp+10h]
- div ecx
- mov edx,ebx
- jmp L4
+ or eax,eax
+ jne L3
+ mov ecx,dword ptr [esp+18h]
+ mov eax,dword ptr [esp+14h]
+ xor edx,edx
+ div ecx
+ mov ebx,eax
+ mov eax,dword ptr [esp+10h]
+ div ecx
+ mov edx,ebx
+ jmp L4
L3:
- mov ebx,eax
- mov ecx,dword ptr [esp+18h]
- mov edx,dword ptr [esp+14h]
- mov eax,dword ptr [esp+10h]
+ mov ebx,eax
+ mov ecx,dword ptr [esp+18h]
+ mov edx,dword ptr [esp+14h]
+ mov eax,dword ptr [esp+10h]
L5:
- shr ebx,1
- rcr ecx,1
- shr edx,1
- rcr eax,1
- or ebx,ebx
- jne L5
- div ecx
- mov esi,eax
- mul dword ptr [esp+1Ch]
- mov ecx,eax
- mov eax,dword ptr [esp+18h]
- mul esi
- add edx,ecx
- jb L6
- cmp edx,dword ptr [esp+14h]
- ja L6
- jb L7
- cmp eax,dword ptr [esp+10h]
- jbe L7
+ shr ebx,1
+ rcr ecx,1
+ shr edx,1
+ rcr eax,1
+ or ebx,ebx
+ jne L5
+ div ecx
+ mov esi,eax
+ mul dword ptr [esp+1Ch]
+ mov ecx,eax
+ mov eax,dword ptr [esp+18h]
+ mul esi
+ add edx,ecx
+ jb L6
+ cmp edx,dword ptr [esp+14h]
+ ja L6
+ jb L7
+ cmp eax,dword ptr [esp+10h]
+ jbe L7
L6:
- dec esi
+ dec esi
L7:
- xor edx,edx
- mov eax,esi
+ xor edx,edx
+ mov eax,esi
L4:
- dec edi
- jne L8
- neg edx
- neg eax
- sbb edx,0
+ dec edi
+ jne L8
+ neg edx
+ neg eax
+ sbb edx,0
L8:
- pop ebx
- pop esi
- pop edi
- ret 10h
- }
+ pop ebx
+ pop esi
+ pop edi
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _aulldiv()
+void
+__declspec(naked)
+_aulldiv()
{
- __asm {
- push ebx
- push esi
- mov eax,dword ptr [esp+18h]
- or eax,eax
- jne L1
- mov ecx,dword ptr [esp+14h]
- mov eax,dword ptr [esp+10h]
- xor edx,edx
- div ecx
- mov ebx,eax
- mov eax,dword ptr [esp+0Ch]
- div ecx
- mov edx,ebx
- jmp L2
+ /* *INDENT-OFF* */
+ __asm {
+ push ebx
+ push esi
+ mov eax,dword ptr [esp+18h]
+ or eax,eax
+ jne L1
+ mov ecx,dword ptr [esp+14h]
+ mov eax,dword ptr [esp+10h]
+ xor edx,edx
+ div ecx
+ mov ebx,eax
+ mov eax,dword ptr [esp+0Ch]
+ div ecx
+ mov edx,ebx
+ jmp L2
L1:
- mov ecx,eax
- mov ebx,dword ptr [esp+14h]
- mov edx,dword ptr [esp+10h]
- mov eax,dword ptr [esp+0Ch]
+ mov ecx,eax
+ mov ebx,dword ptr [esp+14h]
+ mov edx,dword ptr [esp+10h]
+ mov eax,dword ptr [esp+0Ch]
L3:
- shr ecx,1
- rcr ebx,1
- shr edx,1
- rcr eax,1
- or ecx,ecx
- jne L3
- div ebx
- mov esi,eax
- mul dword ptr [esp+18h]
- mov ecx,eax
- mov eax,dword ptr [esp+14h]
- mul esi
- add edx,ecx
- jb L4
- cmp edx,dword ptr [esp+10h]
- ja L4
- jb L5
- cmp eax,dword ptr [esp+0Ch]
- jbe L5
+ shr ecx,1
+ rcr ebx,1
+ shr edx,1
+ rcr eax,1
+ or ecx,ecx
+ jne L3
+ div ebx
+ mov esi,eax
+ mul dword ptr [esp+18h]
+ mov ecx,eax
+ mov eax,dword ptr [esp+14h]
+ mul esi
+ add edx,ecx
+ jb L4
+ cmp edx,dword ptr [esp+10h]
+ ja L4
+ jb L5
+ cmp eax,dword ptr [esp+0Ch]
+ jbe L5
L4:
- dec esi
+ dec esi
L5:
- xor edx,edx
- mov eax,esi
+ xor edx,edx
+ mov eax,esi
L2:
- pop esi
- pop ebx
- ret 10h
- }
+ pop esi
+ pop ebx
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _allrem()
+void
+__declspec(naked)
+_allrem()
{
- __asm {
- push ebx
- push edi
- xor edi,edi
- mov eax,dword ptr [esp+10h]
- or eax,eax
- jge L1
- inc edi
- mov edx,dword ptr [esp+0Ch]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+10h],eax
- mov dword ptr [esp+0Ch],edx
+ /* *INDENT-OFF* */
+ __asm {
+ push ebx
+ push edi
+ xor edi,edi
+ mov eax,dword ptr [esp+10h]
+ or eax,eax
+ jge L1
+ inc edi
+ mov edx,dword ptr [esp+0Ch]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+10h],eax
+ mov dword ptr [esp+0Ch],edx
L1:
- mov eax,dword ptr [esp+18h]
- or eax,eax
- jge L2
- mov edx,dword ptr [esp+14h]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+18h],eax
- mov dword ptr [esp+14h],edx
+ mov eax,dword ptr [esp+18h]
+ or eax,eax
+ jge L2
+ mov edx,dword ptr [esp+14h]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+18h],eax
+ mov dword ptr [esp+14h],edx
L2:
- or eax,eax
- jne L3
- mov ecx,dword ptr [esp+14h]
- mov eax,dword ptr [esp+10h]
- xor edx,edx
- div ecx
- mov eax,dword ptr [esp+0Ch]
- div ecx
- mov eax,edx
- xor edx,edx
- dec edi
- jns L4
- jmp L8
+ or eax,eax
+ jne L3
+ mov ecx,dword ptr [esp+14h]
+ mov eax,dword ptr [esp+10h]
+ xor edx,edx
+ div ecx
+ mov eax,dword ptr [esp+0Ch]
+ div ecx
+ mov eax,edx
+ xor edx,edx
+ dec edi
+ jns L4
+ jmp L8
L3:
- mov ebx,eax
- mov ecx,dword ptr [esp+14h]
- mov edx,dword ptr [esp+10h]
- mov eax,dword ptr [esp+0Ch]
+ mov ebx,eax
+ mov ecx,dword ptr [esp+14h]
+ mov edx,dword ptr [esp+10h]
+ mov eax,dword ptr [esp+0Ch]
L5:
- shr ebx,1
- rcr ecx,1
- shr edx,1
- rcr eax,1
- or ebx,ebx
- jne L5
- div ecx
- mov ecx,eax
- mul dword ptr [esp+18h]
- xchg eax,ecx
- mul dword ptr [esp+14h]
- add edx,ecx
- jb L6
- cmp edx,dword ptr [esp+10h]
- ja L6
- jb L7
- cmp eax,dword ptr [esp+0Ch]
- jbe L7
+ shr ebx,1
+ rcr ecx,1
+ shr edx,1
+ rcr eax,1
+ or ebx,ebx
+ jne L5
+ div ecx
+ mov ecx,eax
+ mul dword ptr [esp+18h]
+ xchg eax,ecx
+ mul dword ptr [esp+14h]
+ add edx,ecx
+ jb L6
+ cmp edx,dword ptr [esp+10h]
+ ja L6
+ jb L7
+ cmp eax,dword ptr [esp+0Ch]
+ jbe L7
L6:
- sub eax,dword ptr [esp+14h]
- sbb edx,dword ptr [esp+18h]
+ sub eax,dword ptr [esp+14h]
+ sbb edx,dword ptr [esp+18h]
L7:
- sub eax,dword ptr [esp+0Ch]
- sbb edx,dword ptr [esp+10h]
- dec edi
- jns L8
+ sub eax,dword ptr [esp+0Ch]
+ sbb edx,dword ptr [esp+10h]
+ dec edi
+ jns L8
L4:
- neg edx
- neg eax
- sbb edx,0
+ neg edx
+ neg eax
+ sbb edx,0
L8:
- pop edi
- pop ebx
- ret 10h
- }
+ pop edi
+ pop ebx
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _aullrem()
+void
+__declspec(naked)
+_aullrem()
{
- __asm {
- push ebx
- mov eax,dword ptr [esp+14h]
- or eax,eax
- jne L1
- mov ecx,dword ptr [esp+10h]
- mov eax,dword ptr [esp+0Ch]
- xor edx,edx
- div ecx
- mov eax,dword ptr [esp+8]
- div ecx
- mov eax,edx
- xor edx,edx
- jmp L2
+ /* *INDENT-OFF* */
+ __asm {
+ push ebx
+ mov eax,dword ptr [esp+14h]
+ or eax,eax
+ jne L1
+ mov ecx,dword ptr [esp+10h]
+ mov eax,dword ptr [esp+0Ch]
+ xor edx,edx
+ div ecx
+ mov eax,dword ptr [esp+8]
+ div ecx
+ mov eax,edx
+ xor edx,edx
+ jmp L2
L1:
- mov ecx,eax
- mov ebx,dword ptr [esp+10h]
- mov edx,dword ptr [esp+0Ch]
- mov eax,dword ptr [esp+8]
+ mov ecx,eax
+ mov ebx,dword ptr [esp+10h]
+ mov edx,dword ptr [esp+0Ch]
+ mov eax,dword ptr [esp+8]
L3:
- shr ecx,1
- rcr ebx,1
- shr edx,1
- rcr eax,1
- or ecx,ecx
- jne L3
- div ebx
- mov ecx,eax
- mul dword ptr [esp+14h]
- xchg eax,ecx
- mul dword ptr [esp+10h]
- add edx,ecx
- jb L4
- cmp edx,dword ptr [esp+0Ch]
- ja L4
- jb L5
- cmp eax,dword ptr [esp+8]
- jbe L5
+ shr ecx,1
+ rcr ebx,1
+ shr edx,1
+ rcr eax,1
+ or ecx,ecx
+ jne L3
+ div ebx
+ mov ecx,eax
+ mul dword ptr [esp+14h]
+ xchg eax,ecx
+ mul dword ptr [esp+10h]
+ add edx,ecx
+ jb L4
+ cmp edx,dword ptr [esp+0Ch]
+ ja L4
+ jb L5
+ cmp eax,dword ptr [esp+8]
+ jbe L5
L4:
- sub eax,dword ptr [esp+10h]
- sbb edx,dword ptr [esp+14h]
+ sub eax,dword ptr [esp+10h]
+ sbb edx,dword ptr [esp+14h]
L5:
- sub eax,dword ptr [esp+8]
- sbb edx,dword ptr [esp+0Ch]
- neg edx
- neg eax
- sbb edx,0
+ sub eax,dword ptr [esp+8]
+ sbb edx,dword ptr [esp+0Ch]
+ neg edx
+ neg eax
+ sbb edx,0
L2:
- pop ebx
- ret 10h
- }
+ pop ebx
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _alldvrm()
+void
+__declspec(naked)
+_alldvrm()
{
- __asm {
- push edi
- push esi
- push ebp
- xor edi,edi
- xor ebp,ebp
- mov eax,dword ptr [esp+14h]
- or eax,eax
- jge L1
- inc edi
- inc ebp
- mov edx,dword ptr [esp+10h]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+14h],eax
- mov dword ptr [esp+10h],edx
+ /* *INDENT-OFF* */
+ __asm {
+ push edi
+ push esi
+ push ebp
+ xor edi,edi
+ xor ebp,ebp
+ mov eax,dword ptr [esp+14h]
+ or eax,eax
+ jge L1
+ inc edi
+ inc ebp
+ mov edx,dword ptr [esp+10h]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+14h],eax
+ mov dword ptr [esp+10h],edx
L1:
- mov eax,dword ptr [esp+1Ch]
- or eax,eax
- jge L2
- inc edi
- mov edx,dword ptr [esp+18h]
- neg eax
- neg edx
- sbb eax,0
- mov dword ptr [esp+1Ch],eax
- mov dword ptr [esp+18h],edx
+ mov eax,dword ptr [esp+1Ch]
+ or eax,eax
+ jge L2
+ inc edi
+ mov edx,dword ptr [esp+18h]
+ neg eax
+ neg edx
+ sbb eax,0
+ mov dword ptr [esp+1Ch],eax
+ mov dword ptr [esp+18h],edx
L2:
- or eax,eax
- jne L3
- mov ecx,dword ptr [esp+18h]
- mov eax,dword ptr [esp+14h]
- xor edx,edx
- div ecx
- mov ebx,eax
- mov eax,dword ptr [esp+10h]
- div ecx
- mov esi,eax
- mov eax,ebx
- mul dword ptr [esp+18h]
- mov ecx,eax
- mov eax,esi
- mul dword ptr [esp+18h]
- add edx,ecx
- jmp L4
+ or eax,eax
+ jne L3
+ mov ecx,dword ptr [esp+18h]
+ mov eax,dword ptr [esp+14h]
+ xor edx,edx
+ div ecx
+ mov ebx,eax
+ mov eax,dword ptr [esp+10h]
+ div ecx
+ mov esi,eax
+ mov eax,ebx
+ mul dword ptr [esp+18h]
+ mov ecx,eax
+ mov eax,esi
+ mul dword ptr [esp+18h]
+ add edx,ecx
+ jmp L4
L3:
- mov ebx,eax
- mov ecx,dword ptr [esp+18h]
- mov edx,dword ptr [esp+14h]
- mov eax,dword ptr [esp+10h]
+ mov ebx,eax
+ mov ecx,dword ptr [esp+18h]
+ mov edx,dword ptr [esp+14h]
+ mov eax,dword ptr [esp+10h]
L5:
- shr ebx,1
- rcr ecx,1
- shr edx,1
- rcr eax,1
- or ebx,ebx
- jne L5
- div ecx
- mov esi,eax
- mul dword ptr [esp+1Ch]
- mov ecx,eax
- mov eax,dword ptr [esp+18h]
- mul esi
- add edx,ecx
- jb L6
- cmp edx,dword ptr [esp+14h]
- ja L6
- jb L7
- cmp eax,dword ptr [esp+10h]
- jbe L7
+ shr ebx,1
+ rcr ecx,1
+ shr edx,1
+ rcr eax,1
+ or ebx,ebx
+ jne L5
+ div ecx
+ mov esi,eax
+ mul dword ptr [esp+1Ch]
+ mov ecx,eax
+ mov eax,dword ptr [esp+18h]
+ mul esi
+ add edx,ecx
+ jb L6
+ cmp edx,dword ptr [esp+14h]
+ ja L6
+ jb L7
+ cmp eax,dword ptr [esp+10h]
+ jbe L7
L6:
- dec esi
- sub eax,dword ptr [esp+18h]
- sbb edx,dword ptr [esp+1Ch]
+ dec esi
+ sub eax,dword ptr [esp+18h]
+ sbb edx,dword ptr [esp+1Ch]
L7:
- xor ebx,ebx
+ xor ebx,ebx
L4:
- sub eax,dword ptr [esp+10h]
- sbb edx,dword ptr [esp+14h]
- dec ebp
- jns L9
- neg edx
- neg eax
- sbb edx,0
+ sub eax,dword ptr [esp+10h]
+ sbb edx,dword ptr [esp+14h]
+ dec ebp
+ jns L9
+ neg edx
+ neg eax
+ sbb edx,0
L9:
- mov ecx,edx
- mov edx,ebx
- mov ebx,ecx
- mov ecx,eax
- mov eax,esi
- dec edi
- jne L8
- neg edx
- neg eax
- sbb edx,0
+ mov ecx,edx
+ mov edx,ebx
+ mov ebx,ecx
+ mov ecx,eax
+ mov eax,esi
+ dec edi
+ jne L8
+ neg edx
+ neg eax
+ sbb edx,0
L8:
- pop ebp
- pop esi
- pop edi
- ret 10h
- }
+ pop ebp
+ pop esi
+ pop edi
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _aulldvrm()
+void
+__declspec(naked)
+_aulldvrm()
{
- __asm {
- push esi
- mov eax,dword ptr [esp+14h]
- or eax,eax
- jne L1
- mov ecx,dword ptr [esp+10h]
- mov eax,dword ptr [esp+0Ch]
- xor edx,edx
- div ecx
- mov ebx,eax
- mov eax,dword ptr [esp+8]
- div ecx
- mov esi,eax
- mov eax,ebx
- mul dword ptr [esp+10h]
- mov ecx,eax
- mov eax,esi
- mul dword ptr [esp+10h]
- add edx,ecx
- jmp L2
+ /* *INDENT-OFF* */
+ __asm {
+ push esi
+ mov eax,dword ptr [esp+14h]
+ or eax,eax
+ jne L1
+ mov ecx,dword ptr [esp+10h]
+ mov eax,dword ptr [esp+0Ch]
+ xor edx,edx
+ div ecx
+ mov ebx,eax
+ mov eax,dword ptr [esp+8]
+ div ecx
+ mov esi,eax
+ mov eax,ebx
+ mul dword ptr [esp+10h]
+ mov ecx,eax
+ mov eax,esi
+ mul dword ptr [esp+10h]
+ add edx,ecx
+ jmp L2
L1:
- mov ecx,eax
- mov ebx,dword ptr [esp+10h]
- mov edx,dword ptr [esp+0Ch]
- mov eax,dword ptr [esp+8]
+ mov ecx,eax
+ mov ebx,dword ptr [esp+10h]
+ mov edx,dword ptr [esp+0Ch]
+ mov eax,dword ptr [esp+8]
L3:
- shr ecx,1
- rcr ebx,1
- shr edx,1
- rcr eax,1
- or ecx,ecx
- jne L3
- div ebx
- mov esi,eax
- mul dword ptr [esp+14h]
- mov ecx,eax
- mov eax,dword ptr [esp+10h]
- mul esi
- add edx,ecx
- jb L4
- cmp edx,dword ptr [esp+0Ch]
- ja L4
- jb L5
- cmp eax,dword ptr [esp+8]
- jbe L5
+ shr ecx,1
+ rcr ebx,1
+ shr edx,1
+ rcr eax,1
+ or ecx,ecx
+ jne L3
+ div ebx
+ mov esi,eax
+ mul dword ptr [esp+14h]
+ mov ecx,eax
+ mov eax,dword ptr [esp+10h]
+ mul esi
+ add edx,ecx
+ jb L4
+ cmp edx,dword ptr [esp+0Ch]
+ ja L4
+ jb L5
+ cmp eax,dword ptr [esp+8]
+ jbe L5
L4:
- dec esi
- sub eax,dword ptr [esp+10h]
- sbb edx,dword ptr [esp+14h]
+ dec esi
+ sub eax,dword ptr [esp+10h]
+ sbb edx,dword ptr [esp+14h]
L5:
- xor ebx,ebx
+ xor ebx,ebx
L2:
- sub eax,dword ptr [esp+8]
- sbb edx,dword ptr [esp+0Ch]
- neg edx
- neg eax
- sbb edx,0
- mov ecx,edx
- mov edx,ebx
- mov ebx,ecx
- mov ecx,eax
- mov eax,esi
- pop esi
- ret 10h
- }
+ sub eax,dword ptr [esp+8]
+ sbb edx,dword ptr [esp+0Ch]
+ neg edx
+ neg eax
+ sbb edx,0
+ mov ecx,edx
+ mov edx,ebx
+ mov ebx,ecx
+ mov ecx,eax
+ mov eax,esi
+ pop esi
+ ret 10h
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _allshl()
+void
+__declspec(naked)
+_allshl()
{
- __asm {
- cmp cl,40h
- jae RETZERO
- cmp cl,20h
- jae MORE32
- shld edx,eax,cl
- shl eax,cl
- ret
+ /* *INDENT-OFF* */
+ __asm {
+ cmp cl,40h
+ jae RETZERO
+ cmp cl,20h
+ jae MORE32
+ shld edx,eax,cl
+ shl eax,cl
+ ret
MORE32:
- mov edx,eax
- xor eax,eax
- and cl,1Fh
- shl edx,cl
- ret
+ mov edx,eax
+ xor eax,eax
+ and cl,1Fh
+ shl edx,cl
+ ret
RETZERO:
- xor eax,eax
- xor edx,edx
- ret
- }
+ xor eax,eax
+ xor edx,edx
+ ret
+ }
+ /* *INDENT-ON* */
}
-void __declspec(naked) _aullshr()
+void
+__declspec(naked)
+_aullshr()
{
- __asm {
- cmp cl,40h
- jae RETZERO
- cmp cl,20h
- jae MORE32
- shrd eax,edx,cl
- shr edx,cl
- ret
+ /* *INDENT-OFF* */
+ __asm {
+ cmp cl,40h
+ jae RETZERO
+ cmp cl,20h
+ jae MORE32
+ shrd eax,edx,cl
+ shr edx,cl
+ ret
MORE32:
- mov eax,edx
- xor edx,edx
- and cl,1Fh
- shr eax,cl
- ret
+ mov eax,edx
+ xor edx,edx
+ and cl,1Fh
+ shr eax,cl
+ ret
RETZERO:
- xor eax,eax
- xor edx,edx
- ret
- }
+ xor eax,eax
+ xor edx,edx
+ ret
+ }
+ /* *INDENT-ON* */
}
#endif /* MSC_VER */
#endif /* !HAVE_LIBC */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/stdlib/SDL_string.c b/src/stdlib/SDL_string.c
index 02a93a5d..fa9672a3 100644
--- a/src/stdlib/SDL_string.c
+++ b/src/stdlib/SDL_string.c
@@ -30,26 +30,27 @@
#define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f'))
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL)
-static size_t SDL_ScanLong(const char *text, int radix, long *valuep)
+static size_t
+SDL_ScanLong(const char *text, int radix, long *valuep)
{
const char *textstart = text;
long value = 0;
SDL_bool negative = SDL_FALSE;
- if ( *text == '-' ) {
+ if (*text == '-') {
negative = SDL_TRUE;
++text;
}
- if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {
+ if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
text += 2;
}
- for ( ; ; ) {
+ for (;;) {
int v;
- if ( SDL_isdigit(*text) ) {
+ if (SDL_isdigit(*text)) {
v = *text - '0';
- } else if ( radix == 16 && SDL_isupperhex(*text) ) {
+ } else if (radix == 16 && SDL_isupperhex(*text)) {
v = 10 + (*text - 'A');
- } else if ( radix == 16 && SDL_islowerhex(*text) ) {
+ } else if (radix == 16 && SDL_islowerhex(*text)) {
v = 10 + (*text - 'a');
} else {
break;
@@ -58,8 +59,8 @@ static size_t SDL_ScanLong(const char *text, int radix, long *valuep)
value += v;
++text;
}
- if ( valuep ) {
- if ( negative && value ) {
+ if (valuep) {
+ if (negative && value) {
*valuep = -value;
} else {
*valuep = value;
@@ -70,21 +71,22 @@ static size_t SDL_ScanLong(const char *text, int radix, long *valuep)
#endif
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD)
-static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)
+static size_t
+SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)
{
const char *textstart = text;
unsigned long value = 0;
- if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {
+ if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
text += 2;
}
- for ( ; ; ) {
+ for (;;) {
int v;
- if ( SDL_isdigit(*text) ) {
+ if (SDL_isdigit(*text)) {
v = *text - '0';
- } else if ( radix == 16 && SDL_isupperhex(*text) ) {
+ } else if (radix == 16 && SDL_isupperhex(*text)) {
v = 10 + (*text - 'A');
- } else if ( radix == 16 && SDL_islowerhex(*text) ) {
+ } else if (radix == 16 && SDL_islowerhex(*text)) {
v = 10 + (*text - 'a');
} else {
break;
@@ -93,7 +95,7 @@ static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *v
value += v;
++text;
}
- if ( valuep ) {
+ if (valuep) {
*valuep = value;
}
return (text - textstart);
@@ -101,21 +103,22 @@ static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *v
#endif
#ifndef HAVE_SSCANF
-static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep)
+static size_t
+SDL_ScanUintPtrT(const char *text, int radix, uintptr_t * valuep)
{
const char *textstart = text;
uintptr_t value = 0;
- if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {
+ if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
text += 2;
}
- for ( ; ; ) {
+ for (;;) {
int v;
- if ( SDL_isdigit(*text) ) {
+ if (SDL_isdigit(*text)) {
v = *text - '0';
- } else if ( radix == 16 && SDL_isupperhex(*text) ) {
+ } else if (radix == 16 && SDL_isupperhex(*text)) {
v = 10 + (*text - 'A');
- } else if ( radix == 16 && SDL_islowerhex(*text) ) {
+ } else if (radix == 16 && SDL_islowerhex(*text)) {
v = 10 + (*text - 'a');
} else {
break;
@@ -124,7 +127,7 @@ static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep)
value += v;
++text;
}
- if ( valuep ) {
+ if (valuep) {
*valuep = value;
}
return (text - textstart);
@@ -133,26 +136,27 @@ static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep)
#ifdef SDL_HAS_64BIT_TYPE
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL)
-static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep)
+static size_t
+SDL_ScanLongLong(const char *text, int radix, Sint64 * valuep)
{
const char *textstart = text;
Sint64 value = 0;
SDL_bool negative = SDL_FALSE;
- if ( *text == '-' ) {
+ if (*text == '-') {
negative = SDL_TRUE;
++text;
}
- if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {
+ if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
text += 2;
}
- for ( ; ; ) {
+ for (;;) {
int v;
- if ( SDL_isdigit(*text) ) {
+ if (SDL_isdigit(*text)) {
v = *text - '0';
- } else if ( radix == 16 && SDL_isupperhex(*text) ) {
+ } else if (radix == 16 && SDL_isupperhex(*text)) {
v = 10 + (*text - 'A');
- } else if ( radix == 16 && SDL_islowerhex(*text) ) {
+ } else if (radix == 16 && SDL_islowerhex(*text)) {
v = 10 + (*text - 'a');
} else {
break;
@@ -161,8 +165,8 @@ static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep)
value += v;
++text;
}
- if ( valuep ) {
- if ( negative && value ) {
+ if (valuep) {
+ if (negative && value) {
*valuep = -value;
} else {
*valuep = value;
@@ -173,21 +177,22 @@ static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep)
#endif
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL)
-static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valuep)
+static size_t
+SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 * valuep)
{
const char *textstart = text;
Uint64 value = 0;
- if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {
+ if (radix == 16 && SDL_strncmp(text, "0x", 2) == 0) {
text += 2;
}
- for ( ; ; ) {
+ for (;;) {
int v;
- if ( SDL_isdigit(*text) ) {
+ if (SDL_isdigit(*text)) {
v = *text - '0';
- } else if ( radix == 16 && SDL_isupperhex(*text) ) {
+ } else if (radix == 16 && SDL_isupperhex(*text)) {
v = 10 + (*text - 'A');
- } else if ( radix == 16 && SDL_islowerhex(*text) ) {
+ } else if (radix == 16 && SDL_islowerhex(*text)) {
v = 10 + (*text - 'a');
} else {
break;
@@ -196,7 +201,7 @@ static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valu
value += v;
++text;
}
- if ( valuep ) {
+ if (valuep) {
*valuep = value;
}
return (text - textstart);
@@ -205,31 +210,32 @@ static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valu
#endif /* SDL_HAS_64BIT_TYPE */
#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD)
-static size_t SDL_ScanFloat(const char *text, double *valuep)
+static size_t
+SDL_ScanFloat(const char *text, double *valuep)
{
const char *textstart = text;
unsigned long lvalue = 0;
double value = 0.0;
SDL_bool negative = SDL_FALSE;
- if ( *text == '-' ) {
+ if (*text == '-') {
negative = SDL_TRUE;
++text;
}
text += SDL_ScanUnsignedLong(text, 10, &lvalue);
value += lvalue;
- if ( *text == '.' ) {
+ if (*text == '.') {
int mult = 10;
++text;
- while ( SDL_isdigit(*text) ) {
+ while (SDL_isdigit(*text)) {
lvalue = *text - '0';
- value += (double)lvalue / mult;
+ value += (double) lvalue / mult;
mult *= 10;
++text;
}
}
- if ( valuep ) {
- if ( negative && value ) {
+ if (valuep) {
+ if (negative && value) {
*valuep = -value;
} else {
*valuep = value;
@@ -240,31 +246,32 @@ static size_t SDL_ScanFloat(const char *text, double *valuep)
#endif
#ifndef SDL_memset
-void *SDL_memset(void *dst, int c, size_t len)
+void *
+SDL_memset(void *dst, int c, size_t len)
{
size_t left = (len % 4);
- if ( len >= 4 ) {
+ if (len >= 4) {
Uint32 value = 0;
- Uint32 *dstp = (Uint32 *)dst;
+ Uint32 *dstp = (Uint32 *) dst;
int i;
for (i = 0; i < 4; ++i) {
value <<= 8;
value |= c;
}
len /= 4;
- while ( len-- ) {
+ while (len--) {
*dstp++ = value;
}
}
- if ( left > 0 ) {
- Uint8 value = (Uint8)c;
- Uint8 *dstp = (Uint8 *)dst;
- switch(left) {
- case 3:
+ if (left > 0) {
+ Uint8 value = (Uint8) c;
+ Uint8 *dstp = (Uint8 *) dst;
+ switch (left) {
+ case 3:
*dstp++ = value;
- case 2:
+ case 2:
*dstp++ = value;
- case 1:
+ case 1:
*dstp++ = value;
}
}
@@ -273,11 +280,12 @@ void *SDL_memset(void *dst, int c, size_t len)
#endif
#ifndef SDL_memcpy
-void *SDL_memcpy(void *dst, const void *src, size_t len)
+void *
+SDL_memcpy(void *dst, const void *src, size_t len)
{
- char *srcp = (char *)src;
- char *dstp = (char *)dst;
- while ( len-- ) {
+ char *srcp = (char *) src;
+ char *dstp = (char *) dst;
+ while (len--) {
*dstp++ = *srcp++;
}
return dst;
@@ -285,13 +293,14 @@ void *SDL_memcpy(void *dst, const void *src, size_t len)
#endif
#ifndef SDL_revcpy
-void *SDL_revcpy(void *dst, const void *src, size_t len)
+void *
+SDL_revcpy(void *dst, const void *src, size_t len)
{
- char *srcp = (char *)src;
- char *dstp = (char *)dst;
+ char *srcp = (char *) src;
+ char *dstp = (char *) dst;
srcp += len;
dstp += len;
- while ( len-- ) {
+ while (len--) {
*dstp-- = *srcp--;
}
return dst;
@@ -299,26 +308,28 @@ void *SDL_revcpy(void *dst, const void *src, size_t len)
#endif
#ifndef SDL_memcmp
-int SDL_memcmp(const void *s1, const void *s2, size_t len)
+int
+SDL_memcmp(const void *s1, const void *s2, size_t len)
{
- char *s1p = (char *)s1;
- char *s2p = (char *)s2;
- while ( len-- ) {
- if ( *s1p != *s2p ) {
+ char *s1p = (char *) s1;
+ char *s2p = (char *) s2;
+ while (len--) {
+ if (*s1p != *s2p) {
return (*s1p - *s2p);
- }
- ++s1p;
- ++s2p;
+ }
+ ++s1p;
+ ++s2p;
}
return 0;
}
#endif
#ifndef HAVE_STRLEN
-size_t SDL_strlen(const char *string)
+size_t
+SDL_strlen(const char *string)
{
size_t len = 0;
- while ( *string++ ) {
+ while (*string++) {
++len;
}
return len;
@@ -326,11 +337,12 @@ size_t SDL_strlen(const char *string)
#endif
#ifndef HAVE_STRLCPY
-size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen)
+size_t
+SDL_strlcpy(char *dst, const char *src, size_t maxlen)
{
size_t srclen = SDL_strlen(src);
- if ( maxlen > 0 ) {
- size_t len = SDL_min(srclen, maxlen-1);
+ if (maxlen > 0) {
+ size_t len = SDL_min(srclen, maxlen - 1);
SDL_memcpy(dst, src, len);
dst[len] = '\0';
}
@@ -339,23 +351,25 @@ size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen)
#endif
#ifndef HAVE_STRLCAT
-size_t SDL_strlcat(char *dst, const char *src, size_t maxlen)
+size_t
+SDL_strlcat(char *dst, const char *src, size_t maxlen)
{
size_t dstlen = SDL_strlen(dst);
size_t srclen = SDL_strlen(src);
- if ( dstlen < maxlen ) {
- SDL_strlcpy(dst+dstlen, src, maxlen-dstlen);
+ if (dstlen < maxlen) {
+ SDL_strlcpy(dst + dstlen, src, maxlen - dstlen);
}
- return dstlen+srclen;
+ return dstlen + srclen;
}
#endif
#ifndef HAVE_STRDUP
-char *SDL_strdup(const char *string)
+char *
+SDL_strdup(const char *string)
{
- size_t len = SDL_strlen(string)+1;
+ size_t len = SDL_strlen(string) + 1;
char *newstr = SDL_malloc(len);
- if ( newstr ) {
+ if (newstr) {
SDL_strlcpy(newstr, string, len);
}
return newstr;
@@ -363,13 +377,14 @@ char *SDL_strdup(const char *string)
#endif
#ifndef HAVE__STRREV
-char *SDL_strrev(char *string)
+char *
+SDL_strrev(char *string)
{
size_t len = SDL_strlen(string);
char *a = &string[0];
- char *b = &string[len-1];
+ char *b = &string[len - 1];
len /= 2;
- while ( len-- ) {
+ while (len--) {
char c = *a;
*a++ = *b;
*b-- = c;
@@ -379,65 +394,70 @@ char *SDL_strrev(char *string)
#endif
#ifndef HAVE__STRUPR
-char *SDL_strupr(char *string)
+char *
+SDL_strupr(char *string)
{
char *bufp = string;
- while ( *bufp ) {
+ while (*bufp) {
*bufp = SDL_toupper(*bufp);
- ++bufp;
+ ++bufp;
}
return string;
}
#endif
#ifndef HAVE__STRLWR
-char *SDL_strlwr(char *string)
+char *
+SDL_strlwr(char *string)
{
char *bufp = string;
- while ( *bufp ) {
+ while (*bufp) {
*bufp = SDL_tolower(*bufp);
- ++bufp;
+ ++bufp;
}
return string;
}
#endif
#ifndef HAVE_STRCHR
-char *SDL_strchr(const char *string, int c)
+char *
+SDL_strchr(const char *string, int c)
{
- while ( *string ) {
- if ( *string == c ) {
- return (char *)string;
+ while (*string) {
+ if (*string == c) {
+ return (char *) string;
}
- ++string;
+ ++string;
}
return NULL;
}
#endif
#ifndef HAVE_STRRCHR
-char *SDL_strrchr(const char *string, int c)
+char *
+SDL_strrchr(const char *string, int c)
{
const char *bufp = string + SDL_strlen(string) - 1;
- while ( bufp >= string ) {
- if ( *bufp == c ) {
- return (char *)bufp;
+ while (bufp >= string) {
+ if (*bufp == c) {
+ return (char *) bufp;
}
- --bufp;
+ --bufp;
}
return NULL;
}
#endif
#ifndef HAVE_STRSTR
-char *SDL_strstr(const char *haystack, const char *needle)
+char *
+SDL_strstr(const char *haystack, const char *needle)
{
size_t length = SDL_strlen(needle);
- while ( *haystack ) {
- if ( SDL_strncmp(haystack, needle, length) == 0 ) {
- return (char *)haystack;
+ while (*haystack) {
+ if (SDL_strncmp(haystack, needle, length) == 0) {
+ return (char *) haystack;
}
- ++haystack;
+ ++haystack;
}
return NULL;
}
@@ -454,16 +474,17 @@ static const char ntoa_table[] = {
#endif /* ntoa() conversion table */
#ifndef HAVE__LTOA
-char *SDL_ltoa(long value, char *string, int radix)
+char *
+SDL_ltoa(long value, char *string, int radix)
{
char *bufp = string;
- if ( value < 0 ) {
+ if (value < 0) {
*bufp++ = '-';
value = -value;
}
- if ( value ) {
- while ( value > 0 ) {
+ if (value) {
+ while (value > 0) {
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
@@ -473,8 +494,8 @@ char *SDL_ltoa(long value, char *string, int radix)
*bufp = '\0';
/* The numbers went into the string backwards. :) */
- if ( *string == '-' ) {
- SDL_strrev(string+1);
+ if (*string == '-') {
+ SDL_strrev(string + 1);
} else {
SDL_strrev(string);
}
@@ -484,12 +505,13 @@ char *SDL_ltoa(long value, char *string, int radix)
#endif
#ifndef HAVE__ULTOA
-char *SDL_ultoa(unsigned long value, char *string, int radix)
+char *
+SDL_ultoa(unsigned long value, char *string, int radix)
{
char *bufp = string;
- if ( value ) {
- while ( value > 0 ) {
+ if (value) {
+ while (value > 0) {
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
@@ -506,13 +528,14 @@ char *SDL_ultoa(unsigned long value, char *string, int radix)
#endif
#ifndef HAVE_STRTOL
-long SDL_strtol(const char *string, char **endp, int base)
+long
+SDL_strtol(const char *string, char **endp, int base)
{
size_t len;
long value;
- if ( !base ) {
- if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) {
+ if (!base) {
+ if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
base = 16;
} else {
base = 10;
@@ -520,21 +543,22 @@ long SDL_strtol(const char *string, char **endp, int base)
}
len = SDL_ScanLong(string, base, &value);
- if ( endp ) {
- *endp = (char *)string + len;
+ if (endp) {
+ *endp = (char *) string + len;
}
return value;
}
#endif
#ifndef HAVE_STRTOUL
-unsigned long SDL_strtoul(const char *string, char **endp, int base)
+unsigned long
+SDL_strtoul(const char *string, char **endp, int base)
{
size_t len;
unsigned long value;
- if ( !base ) {
- if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) {
+ if (!base) {
+ if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
base = 16;
} else {
base = 10;
@@ -542,8 +566,8 @@ unsigned long SDL_strtoul(const char *string, char **endp, int base)
}
len = SDL_ScanUnsignedLong(string, base, &value);
- if ( endp ) {
- *endp = (char *)string + len;
+ if (endp) {
+ *endp = (char *) string + len;
}
return value;
}
@@ -552,16 +576,17 @@ unsigned long SDL_strtoul(const char *string, char **endp, int base)
#ifdef SDL_HAS_64BIT_TYPE
#ifndef HAVE__I64TOA
-char *SDL_lltoa(Sint64 value, char *string, int radix)
+char *
+SDL_lltoa(Sint64 value, char *string, int radix)
{
char *bufp = string;
- if ( value < 0 ) {
+ if (value < 0) {
*bufp++ = '-';
value = -value;
}
- if ( value ) {
- while ( value > 0 ) {
+ if (value) {
+ while (value > 0) {
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
@@ -571,8 +596,8 @@ char *SDL_lltoa(Sint64 value, char *string, int radix)
*bufp = '\0';
/* The numbers went into the string backwards. :) */
- if ( *string == '-' ) {
- SDL_strrev(string+1);
+ if (*string == '-') {
+ SDL_strrev(string + 1);
} else {
SDL_strrev(string);
}
@@ -582,12 +607,13 @@ char *SDL_lltoa(Sint64 value, char *string, int radix)
#endif
#ifndef HAVE__UI64TOA
-char *SDL_ulltoa(Uint64 value, char *string, int radix)
+char *
+SDL_ulltoa(Uint64 value, char *string, int radix)
{
char *bufp = string;
- if ( value ) {
- while ( value > 0 ) {
+ if (value) {
+ while (value > 0) {
*bufp++ = ntoa_table[value % radix];
value /= radix;
}
@@ -604,13 +630,14 @@ char *SDL_ulltoa(Uint64 value, char *string, int radix)
#endif
#ifndef HAVE_STRTOLL
-Sint64 SDL_strtoll(const char *string, char **endp, int base)
+Sint64
+SDL_strtoll(const char *string, char **endp, int base)
{
size_t len;
Sint64 value;
- if ( !base ) {
- if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) {
+ if (!base) {
+ if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
base = 16;
} else {
base = 10;
@@ -618,21 +645,22 @@ Sint64 SDL_strtoll(const char *string, char **endp, int base)
}
len = SDL_ScanLongLong(string, base, &value);
- if ( endp ) {
- *endp = (char *)string + len;
+ if (endp) {
+ *endp = (char *) string + len;
}
return value;
}
#endif
#ifndef HAVE_STRTOULL
-Uint64 SDL_strtoull(const char *string, char **endp, int base)
+Uint64
+SDL_strtoull(const char *string, char **endp, int base)
{
size_t len;
Uint64 value;
- if ( !base ) {
- if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) {
+ if (!base) {
+ if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
base = 16;
} else {
base = 10;
@@ -640,8 +668,8 @@ Uint64 SDL_strtoull(const char *string, char **endp, int base)
}
len = SDL_ScanUnsignedLongLong(string, base, &value);
- if ( endp ) {
- *endp = (char *)string + len;
+ if (endp) {
+ *endp = (char *) string + len;
}
return value;
}
@@ -650,104 +678,111 @@ Uint64 SDL_strtoull(const char *string, char **endp, int base)
#endif /* SDL_HAS_64BIT_TYPE */
#ifndef HAVE_STRTOD
-double SDL_strtod(const char *string, char **endp)
+double
+SDL_strtod(const char *string, char **endp)
{
size_t len;
double value;
len = SDL_ScanFloat(string, &value);
- if ( endp ) {
- *endp = (char *)string + len;
+ if (endp) {
+ *endp = (char *) string + len;
}
return value;
}
#endif
#ifndef HAVE_STRCMP
-int SDL_strcmp(const char *str1, const char *str2)
+int
+SDL_strcmp(const char *str1, const char *str2)
{
while (*str1 && *str2) {
- if ( *str1 != *str2 )
+ if (*str1 != *str2)
break;
++str1;
++str2;
}
- return (int)((unsigned char)*str1 - (unsigned char)*str2);
+ return (int) ((unsigned char) *str1 - (unsigned char) *str2);
}
#endif
#ifndef HAVE_STRNCMP
-int SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
+int
+SDL_strncmp(const char *str1, const char *str2, size_t maxlen)
{
- while ( *str1 && *str2 && maxlen ) {
- if ( *str1 != *str2 )
+ while (*str1 && *str2 && maxlen) {
+ if (*str1 != *str2)
break;
++str1;
++str2;
--maxlen;
}
- if ( ! maxlen ) {
+ if (!maxlen) {
return 0;
}
- return (int)((unsigned char)*str1 - (unsigned char)*str2);
+ return (int) ((unsigned char) *str1 - (unsigned char) *str2);
}
#endif
#if !defined(HAVE_STRCASECMP) && !defined(HAVE__STRICMP)
-int SDL_strcasecmp(const char *str1, const char *str2)
+int
+SDL_strcasecmp(const char *str1, const char *str2)
{
char a = 0;
char b = 0;
- while ( *str1 && *str2 ) {
+ while (*str1 && *str2) {
a = SDL_tolower(*str1);
b = SDL_tolower(*str2);
- if ( a != b )
+ if (a != b)
break;
++str1;
++str2;
}
- return (int)((unsigned char)a - (unsigned char)b);
+ return (int) ((unsigned char) a - (unsigned char) b);
}
#endif
#if !defined(HAVE_STRNCASECMP) && !defined(HAVE__STRNICMP)
-int SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
+int
+SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen)
{
char a = 0;
char b = 0;
- while ( *str1 && *str2 && maxlen ) {
+ while (*str1 && *str2 && maxlen) {
a = SDL_tolower(*str1);
b = SDL_tolower(*str2);
- if ( a != b )
+ if (a != b)
break;
++str1;
++str2;
--maxlen;
}
- return (int)((unsigned char)a - (unsigned char)b);
+ return (int) ((unsigned char) a - (unsigned char) b);
}
#endif
#ifndef HAVE_SSCANF
-int SDL_sscanf(const char *text, const char *fmt, ...)
+int
+SDL_sscanf(const char *text, const char *fmt, ...)
{
va_list ap;
int retval = 0;
va_start(ap, fmt);
- while ( *fmt ) {
- if ( *fmt == ' ' ) {
- while ( SDL_isspace(*text) ) {
+ while (*fmt) {
+ if (*fmt == ' ') {
+ while (SDL_isspace(*text)) {
++text;
}
++fmt;
continue;
}
- if ( *fmt == '%' ) {
+ if (*fmt == '%') {
SDL_bool done = SDL_FALSE;
long count = 0;
int radix = 10;
- enum {
+ enum
+ {
DO_SHORT,
DO_INT,
DO_LONG,
@@ -756,31 +791,31 @@ int SDL_sscanf(const char *text, const char *fmt, ...)
SDL_bool suppress = SDL_FALSE;
++fmt;
- if ( *fmt == '%' ) {
- if ( *text == '%' ) {
+ if (*fmt == '%') {
+ if (*text == '%') {
++text;
++fmt;
continue;
}
break;
}
- if ( *fmt == '*' ) {
+ if (*fmt == '*') {
suppress = SDL_TRUE;
++fmt;
}
fmt += SDL_ScanLong(fmt, 10, &count);
- if ( *fmt == 'c' ) {
- if ( ! count ) {
+ if (*fmt == 'c') {
+ if (!count) {
count = 1;
}
- if ( suppress ) {
- while ( count-- ) {
+ if (suppress) {
+ while (count--) {
++text;
}
} else {
- char *valuep = va_arg(ap, char*);
- while ( count-- ) {
+ char *valuep = va_arg(ap, char *);
+ while (count--) {
*valuep++ = *text++;
}
++retval;
@@ -788,200 +823,204 @@ int SDL_sscanf(const char *text, const char *fmt, ...)
continue;
}
- while ( SDL_isspace(*text) ) {
+ while (SDL_isspace(*text)) {
++text;
}
/* FIXME: implement more of the format specifiers */
while (!done) {
- switch(*fmt) {
- case '*':
- suppress = SDL_TRUE;
- break;
- case 'h':
- if ( inttype > DO_SHORT ) {
- ++inttype;
- }
- break;
- case 'l':
- if ( inttype < DO_LONGLONG ) {
- ++inttype;
- }
- break;
- case 'I':
- if ( SDL_strncmp(fmt, "I64", 3) == 0 ) {
- fmt += 2;
- inttype = DO_LONGLONG;
+ switch (*fmt) {
+ case '*':
+ suppress = SDL_TRUE;
+ break;
+ case 'h':
+ if (inttype > DO_SHORT) {
+ ++inttype;
+ }
+ break;
+ case 'l':
+ if (inttype < DO_LONGLONG) {
+ ++inttype;
+ }
+ break;
+ case 'I':
+ if (SDL_strncmp(fmt, "I64", 3) == 0) {
+ fmt += 2;
+ inttype = DO_LONGLONG;
+ }
+ break;
+ case 'i':
+ {
+ int index = 0;
+ if (text[index] == '-') {
+ ++index;
}
- break;
- case 'i':
- {
- int index = 0;
- if ( text[index] == '-' ) {
- ++index;
- }
- if ( text[index] == '0' ) {
- if ( SDL_tolower(text[index+1]) == 'x' ) {
- radix = 16;
- } else {
- radix = 8;
- }
+ if (text[index] == '0') {
+ if (SDL_tolower(text[index + 1]) == 'x') {
+ radix = 16;
+ } else {
+ radix = 8;
}
}
- /* Fall through to %d handling */
- case 'd':
+ }
+ /* Fall through to %d handling */
+ case 'd':
#ifdef SDL_HAS_64BIT_TYPE
- if ( inttype == DO_LONGLONG ) {
- Sint64 value;
- text += SDL_ScanLongLong(text, radix, &value);
- if ( ! suppress ) {
- Sint64 *valuep = va_arg(ap, Sint64*);
- *valuep = value;
- ++retval;
- }
+ if (inttype == DO_LONGLONG) {
+ Sint64 value;
+ text += SDL_ScanLongLong(text, radix, &value);
+ if (!suppress) {
+ Sint64 *valuep = va_arg(ap, Sint64 *);
+ *valuep = value;
+ ++retval;
}
- else
+ } else
#endif /* SDL_HAS_64BIT_TYPE */
- {
- long value;
- text += SDL_ScanLong(text, radix, &value);
- if ( ! suppress ) {
- switch (inttype) {
- case DO_SHORT:
- { short* valuep = va_arg(ap, short*);
- *valuep = (short)value;
- }
- break;
- case DO_INT:
- { int* valuep = va_arg(ap, int*);
- *valuep = (int)value;
- }
- break;
- case DO_LONG:
- { long* valuep = va_arg(ap, long*);
- *valuep = value;
- }
- break;
- case DO_LONGLONG:
- /* Handled above */
- break;
+ {
+ long value;
+ text += SDL_ScanLong(text, radix, &value);
+ if (!suppress) {
+ switch (inttype) {
+ case DO_SHORT:
+ {
+ short *valuep = va_arg(ap, short *);
+ *valuep = (short) value;
+ }
+ break;
+ case DO_INT:
+ {
+ int *valuep = va_arg(ap, int *);
+ *valuep = (int) value;
}
- ++retval;
+ break;
+ case DO_LONG:
+ {
+ long *valuep = va_arg(ap, long *);
+ *valuep = value;
+ }
+ break;
+ case DO_LONGLONG:
+ /* Handled above */
+ break;
}
+ ++retval;
}
- done = SDL_TRUE;
- break;
- case 'o':
- if ( radix == 10 ) {
- radix = 8;
- }
- /* Fall through to unsigned handling */
- case 'x':
- case 'X':
- if ( radix == 10 ) {
- radix = 16;
- }
- /* Fall through to unsigned handling */
- case 'u':
+ }
+ done = SDL_TRUE;
+ break;
+ case 'o':
+ if (radix == 10) {
+ radix = 8;
+ }
+ /* Fall through to unsigned handling */
+ case 'x':
+ case 'X':
+ if (radix == 10) {
+ radix = 16;
+ }
+ /* Fall through to unsigned handling */
+ case 'u':
#ifdef SDL_HAS_64BIT_TYPE
- if ( inttype == DO_LONGLONG ) {
- Uint64 value;
- text += SDL_ScanUnsignedLongLong(text, radix, &value);
- if ( ! suppress ) {
- Uint64 *valuep = va_arg(ap, Uint64*);
- *valuep = value;
- ++retval;
- }
+ if (inttype == DO_LONGLONG) {
+ Uint64 value;
+ text += SDL_ScanUnsignedLongLong(text, radix, &value);
+ if (!suppress) {
+ Uint64 *valuep = va_arg(ap, Uint64 *);
+ *valuep = value;
+ ++retval;
}
- else
+ } else
#endif /* SDL_HAS_64BIT_TYPE */
- {
- unsigned long value;
- text += SDL_ScanUnsignedLong(text, radix, &value);
- if ( ! suppress ) {
- switch (inttype) {
- case DO_SHORT:
- { short* valuep = va_arg(ap, short*);
- *valuep = (short)value;
- }
- break;
- case DO_INT:
- { int* valuep = va_arg(ap, int*);
- *valuep = (int)value;
- }
- break;
- case DO_LONG:
- { long* valuep = va_arg(ap, long*);
- *valuep = value;
- }
- break;
- case DO_LONGLONG:
- /* Handled above */
- break;
+ {
+ unsigned long value;
+ text += SDL_ScanUnsignedLong(text, radix, &value);
+ if (!suppress) {
+ switch (inttype) {
+ case DO_SHORT:
+ {
+ short *valuep = va_arg(ap, short *);
+ *valuep = (short) value;
+ }
+ break;
+ case DO_INT:
+ {
+ int *valuep = va_arg(ap, int *);
+ *valuep = (int) value;
}
- ++retval;
+ break;
+ case DO_LONG:
+ {
+ long *valuep = va_arg(ap, long *);
+ *valuep = value;
+ }
+ break;
+ case DO_LONGLONG:
+ /* Handled above */
+ break;
}
+ ++retval;
}
- done = SDL_TRUE;
- break;
- case 'p':
- {
- uintptr_t value;
- text += SDL_ScanUintPtrT(text, 16, &value);
- if ( ! suppress ) {
- void** valuep = va_arg(ap, void**);
- *valuep = (void*)value;
- ++retval;
- }
+ }
+ done = SDL_TRUE;
+ break;
+ case 'p':
+ {
+ uintptr_t value;
+ text += SDL_ScanUintPtrT(text, 16, &value);
+ if (!suppress) {
+ void **valuep = va_arg(ap, void **);
+ *valuep = (void *) value;
+ ++retval;
}
- done = SDL_TRUE;
- break;
- case 'f':
- {
- double value;
- text += SDL_ScanFloat(text, &value);
- if ( ! suppress ) {
- float* valuep = va_arg(ap, float*);
- *valuep = (float)value;
- ++retval;
- }
+ }
+ done = SDL_TRUE;
+ break;
+ case 'f':
+ {
+ double value;
+ text += SDL_ScanFloat(text, &value);
+ if (!suppress) {
+ float *valuep = va_arg(ap, float *);
+ *valuep = (float) value;
+ ++retval;
}
- done = SDL_TRUE;
- break;
- case 's':
- if ( suppress ) {
- while ( !SDL_isspace(*text) ) {
- ++text;
- if ( count ) {
- if ( --count == 0 ) {
- break;
- }
+ }
+ done = SDL_TRUE;
+ break;
+ case 's':
+ if (suppress) {
+ while (!SDL_isspace(*text)) {
+ ++text;
+ if (count) {
+ if (--count == 0) {
+ break;
}
}
- } else {
- char *valuep = va_arg(ap, char*);
- while ( !SDL_isspace(*text) ) {
- *valuep++ = *text++;
- if ( count ) {
- if ( --count == 0 ) {
- break;
- }
+ }
+ } else {
+ char *valuep = va_arg(ap, char *);
+ while (!SDL_isspace(*text)) {
+ *valuep++ = *text++;
+ if (count) {
+ if (--count == 0) {
+ break;
}
}
- *valuep = '\0';
- ++retval;
}
- done = SDL_TRUE;
- break;
- default:
- done = SDL_TRUE;
- break;
+ *valuep = '\0';
+ ++retval;
+ }
+ done = SDL_TRUE;
+ break;
+ default:
+ done = SDL_TRUE;
+ break;
}
++fmt;
}
continue;
}
- if ( *text == *fmt ) {
+ if (*text == *fmt) {
++text;
++fmt;
continue;
@@ -996,7 +1035,8 @@ int SDL_sscanf(const char *text, const char *fmt, ...)
#endif
#ifndef HAVE_SNPRINTF
-int SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...)
+int
+SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...)
{
va_list ap;
int retval;
@@ -1010,92 +1050,101 @@ int SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...)
#endif
#ifndef HAVE_VSNPRINTF
-static size_t SDL_PrintLong(char *text, long value, int radix, size_t maxlen)
+static size_t
+SDL_PrintLong(char *text, long value, int radix, size_t maxlen)
{
char num[130];
size_t size;
SDL_ltoa(value, num, radix);
size = SDL_strlen(num);
- if ( size >= maxlen ) {
- size = maxlen-1;
+ if (size >= maxlen) {
+ size = maxlen - 1;
}
- SDL_strlcpy(text, num, size+1);
+ SDL_strlcpy(text, num, size + 1);
return size;
}
-static size_t SDL_PrintUnsignedLong(char *text, unsigned long value, int radix, size_t maxlen)
+
+static size_t
+SDL_PrintUnsignedLong(char *text, unsigned long value, int radix,
+ size_t maxlen)
{
char num[130];
size_t size;
SDL_ultoa(value, num, radix);
size = SDL_strlen(num);
- if ( size >= maxlen ) {
- size = maxlen-1;
+ if (size >= maxlen) {
+ size = maxlen - 1;
}
- SDL_strlcpy(text, num, size+1);
+ SDL_strlcpy(text, num, size + 1);
return size;
}
+
#ifdef SDL_HAS_64BIT_TYPE
-static size_t SDL_PrintLongLong(char *text, Sint64 value, int radix, size_t maxlen)
+static size_t
+SDL_PrintLongLong(char *text, Sint64 value, int radix, size_t maxlen)
{
char num[130];
size_t size;
SDL_lltoa(value, num, radix);
size = SDL_strlen(num);
- if ( size >= maxlen ) {
- size = maxlen-1;
+ if (size >= maxlen) {
+ size = maxlen - 1;
}
- SDL_strlcpy(text, num, size+1);
+ SDL_strlcpy(text, num, size + 1);
return size;
}
-static size_t SDL_PrintUnsignedLongLong(char *text, Uint64 value, int radix, size_t maxlen)
+
+static size_t
+SDL_PrintUnsignedLongLong(char *text, Uint64 value, int radix, size_t maxlen)
{
char num[130];
size_t size;
SDL_ulltoa(value, num, radix);
size = SDL_strlen(num);
- if ( size >= maxlen ) {
- size = maxlen-1;
+ if (size >= maxlen) {
+ size = maxlen - 1;
}
- SDL_strlcpy(text, num, size+1);
+ SDL_strlcpy(text, num, size + 1);
return size;
}
#endif /* SDL_HAS_64BIT_TYPE */
-static size_t SDL_PrintFloat(char *text, double arg, size_t maxlen)
+static size_t
+SDL_PrintFloat(char *text, double arg, size_t maxlen)
{
char *textstart = text;
- if ( arg ) {
+ if (arg) {
/* This isn't especially accurate, but hey, it's easy. :) */
const double precision = 0.00000001;
size_t len;
unsigned long value;
- if ( arg < 0 ) {
+ if (arg < 0) {
*text++ = '-';
--maxlen;
arg = -arg;
}
- value = (unsigned long)arg;
+ value = (unsigned long) arg;
len = SDL_PrintUnsignedLong(text, value, 10, maxlen);
text += len;
maxlen -= len;
arg -= value;
- if ( arg > precision && maxlen ) {
+ if (arg > precision && maxlen) {
int mult = 10;
*text++ = '.';
- while ( (arg > precision) && maxlen ) {
- value = (unsigned long)(arg * mult);
+ while ((arg > precision) && maxlen) {
+ value = (unsigned long) (arg * mult);
len = SDL_PrintUnsignedLong(text, value, 10, maxlen);
text += len;
maxlen -= len;
- arg -= (double)value / mult;
+ arg -= (double) value / mult;
mult *= 10;
}
}
@@ -1104,28 +1153,33 @@ static size_t SDL_PrintFloat(char *text, double arg, size_t maxlen)
}
return (text - textstart);
}
-static size_t SDL_PrintString(char *text, const char *string, size_t maxlen)
+
+static size_t
+SDL_PrintString(char *text, const char *string, size_t maxlen)
{
char *textstart = text;
- while ( *string && maxlen-- ) {
+ while (*string && maxlen--) {
*text++ = *string++;
}
return (text - textstart);
}
-int SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap)
+
+int
+SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap)
{
char *textstart = text;
- if ( maxlen <= 0 ) {
+ if (maxlen <= 0) {
return 0;
}
- --maxlen; /* For the trailing '\0' */
- while ( *fmt && maxlen ) {
- if ( *fmt == '%' ) {
+ --maxlen; /* For the trailing '\0' */
+ while (*fmt && maxlen) {
+ if (*fmt == '%') {
SDL_bool done = SDL_FALSE;
size_t len = 0;
SDL_bool do_lowercase = SDL_FALSE;
int radix = 10;
- enum {
+ enum
+ {
DO_INT,
DO_LONG,
DO_LONGLONG
@@ -1133,104 +1187,132 @@ int SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap)
++fmt;
/* FIXME: implement more of the format specifiers */
- while ( *fmt == '.' || (*fmt >= '0' && *fmt <= '9') ) {
+ while (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) {
++fmt;
}
while (!done) {
- switch(*fmt) {
- case '%':
- *text = '%';
- len = 1;
- done = SDL_TRUE;
- break;
- case 'c':
- /* char is promoted to int when passed through (...) */
- *text = (char)va_arg(ap, int);
- len = 1;
- done = SDL_TRUE;
- break;
- case 'h':
- /* short is promoted to int when passed through (...) */
- break;
- case 'l':
- if ( inttype < DO_LONGLONG ) {
- ++inttype;
- }
+ switch (*fmt) {
+ case '%':
+ *text = '%';
+ len = 1;
+ done = SDL_TRUE;
+ break;
+ case 'c':
+ /* char is promoted to int when passed through (...) */
+ *text = (char) va_arg(ap, int);
+ len = 1;
+ done = SDL_TRUE;
+ break;
+ case 'h':
+ /* short is promoted to int when passed through (...) */
+ break;
+ case 'l':
+ if (inttype < DO_LONGLONG) {
+ ++inttype;
+ }
+ break;
+ case 'I':
+ if (SDL_strncmp(fmt, "I64", 3) == 0) {
+ fmt += 2;
+ inttype = DO_LONGLONG;
+ }
+ break;
+ case 'i':
+ case 'd':
+ switch (inttype) {
+ case DO_INT:
+ len =
+ SDL_PrintLong(text,
+ (long) va_arg(ap, int),
+ radix, maxlen);
break;
- case 'I':
- if ( SDL_strncmp(fmt, "I64", 3) == 0 ) {
- fmt += 2;
- inttype = DO_LONGLONG;
- }
+ case DO_LONG:
+ len =
+ SDL_PrintLong(text, va_arg(ap, long),
+ radix, maxlen);
break;
- case 'i':
- case 'd':
- switch (inttype) {
- case DO_INT:
- len = SDL_PrintLong(text, (long)va_arg(ap, int), radix, maxlen);
- break;
- case DO_LONG:
- len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen);
- break;
- case DO_LONGLONG:
+ case DO_LONGLONG:
#ifdef SDL_HAS_64BIT_TYPE
- len = SDL_PrintLongLong(text, va_arg(ap, Sint64), radix, maxlen);
+ len =
+ SDL_PrintLongLong(text,
+ va_arg(ap, Sint64),
+ radix, maxlen);
#else
- len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen);
+ len =
+ SDL_PrintLong(text, va_arg(ap, long),
+ radix, maxlen);
#endif
- break;
- }
- done = SDL_TRUE;
break;
- case 'p':
- case 'x':
- do_lowercase = SDL_TRUE;
- /* Fall through to 'X' handling */
- case 'X':
- if ( radix == 10 ) {
- radix = 16;
- }
- if ( *fmt == 'p' ) {
- inttype = DO_LONG;
- }
- /* Fall through to unsigned handling */
- case 'o':
- if ( radix == 10 ) {
- radix = 8;
- }
- /* Fall through to unsigned handling */
- case 'u':
- switch (inttype) {
- case DO_INT:
- len = SDL_PrintUnsignedLong(text, (unsigned long)va_arg(ap, unsigned int), radix, maxlen);
- break;
- case DO_LONG:
- len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen);
- break;
- case DO_LONGLONG:
+ }
+ done = SDL_TRUE;
+ break;
+ case 'p':
+ case 'x':
+ do_lowercase = SDL_TRUE;
+ /* Fall through to 'X' handling */
+ case 'X':
+ if (radix == 10) {
+ radix = 16;
+ }
+ if (*fmt == 'p') {
+ inttype = DO_LONG;
+ }
+ /* Fall through to unsigned handling */
+ case 'o':
+ if (radix == 10) {
+ radix = 8;
+ }
+ /* Fall through to unsigned handling */
+ case 'u':
+ switch (inttype) {
+ case DO_INT:
+ len = SDL_PrintUnsignedLong(text, (unsigned long)
+ va_arg(ap,
+ unsigned
+ int),
+ radix, maxlen);
+ break;
+ case DO_LONG:
+ len =
+ SDL_PrintUnsignedLong(text,
+ va_arg(ap,
+ unsigned
+ long),
+ radix, maxlen);
+ break;
+ case DO_LONGLONG:
#ifdef SDL_HAS_64BIT_TYPE
- len = SDL_PrintUnsignedLongLong(text, va_arg(ap, Uint64), radix, maxlen);
+ len =
+ SDL_PrintUnsignedLongLong(text,
+ va_arg(ap,
+ Uint64),
+ radix, maxlen);
#else
- len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen);
+ len =
+ SDL_PrintUnsignedLong(text,
+ va_arg(ap,
+ unsigned
+ long),
+ radix, maxlen);
#endif
- break;
- }
- if ( do_lowercase ) {
- SDL_strlwr(text);
- }
- done = SDL_TRUE;
- break;
- case 'f':
- len = SDL_PrintFloat(text, va_arg(ap, double), maxlen);
- done = SDL_TRUE;
- break;
- case 's':
- len = SDL_PrintString(text, va_arg(ap, char*), maxlen);
- done = SDL_TRUE;
- break;
- default:
- done = SDL_TRUE;
break;
+ }
+ if (do_lowercase) {
+ SDL_strlwr(text);
+ }
+ done = SDL_TRUE;
+ break;
+ case 'f':
+ len = SDL_PrintFloat(text, va_arg(ap, double), maxlen);
+ done = SDL_TRUE;
+ break;
+ case 's':
+ len = SDL_PrintString(text, va_arg(ap, char *), maxlen);
+ done = SDL_TRUE;
+ break;
+ default:
+ done = SDL_TRUE;
+ break;
}
++fmt;
}
@@ -1246,3 +1328,4 @@ int SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap)
return (text - textstart);
}
#endif
+/* vi: set ts=4 sw=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-27 17:45:50 +0000