{

PERF_ENTRY(__iscsym);

ENTRY( "__iscsym( c=%d )\n", c );

if ( isalnum( c ) || c == '_' )

{

LOGEXIT( "__iscsym returning 1\n" );

PERF_EXIT(__iscsym);

return 1;

}

LOGEXIT( "__iscsym returning 0\n" );

PERF_EXIT(__iscsym);

return 0;

{

int ret = -1;

PERF_ENTRY(_putenv);

ENTRY( "_putenv( %p (%s) )\n", envstring ? envstring : "NULL", envstring ? envstring : "NULL") ;

if (!envstring)

{

ERROR( "_putenv() called with NULL envstring!\n");

goto EXIT;

}

ret = MiscPutenv(envstring, TRUE) ? 0 : -1;

EXIT:

LOGEXIT( "_putenv returning %d\n", ret);

PERF_EXIT(_putenv);

return ret;

{

int ret;

PERF_ENTRY(rand);

ENTRY("rand(void)\n");

ret = (rand() % (PAL_RAND_MAX + 1));

LOGEXIT("rand() returning %d\n", ret);

PERF_EXIT(rand);

return ret;

{

qsort_s_comparer real_comparer;

void* real_context;

{

CompareWrapperContext* wrapper = (CompareWrapperContext*) context;

return wrapper->real_comparer(wrapper->real_context, e1, e2);

{

if (a == b) return;

size_t tsize;

if (size >= 8)

{

tsize = 8;

size_t nsize = size / tsize;

swap_big(swap8, (swap8*) a, (swap8*) b, nsize)

}

else if (size >= 4)

{

tsize = 4;

size_t nsize = size / tsize;

swap_big(swap4, (swap4*) a, (swap4*) b, nsize)

}

else

{

tsize = 2;

size_t nsize = size / tsize;

swap_big(swap2, (swap2*) a, (swap2*) b, nsize)

}

swap_big(char, (char*) a, (char*) b, size % tsize);

int (__cdecl *compar )(void*, const void *, const void *), void *thunk)

{

char *base = (char *) base_;

if (nmemb <= 9) // use sorting networks for members <= 2^3

{

switch(nmemb)

{

case 9:

SORT9()

break;

case 8:

SORT8()

break;

case 7:

SORT7()

break;

case 6:

SORT6()

break;

case 5:

SORT5(0, 1, 2, 3, 4)

break;

case 4:

SORT4()

break;

case 3:

SORT3()

break;

case 2:

SORT2(0, 1)

break;

default:

break; // nothing to sort

}

return;

}

// sort find for median. `compare` is expectedly more expensive than `swap`

SORT5(0, (nmemb / 4), (nmemb / 2), ((3 * nmemb) / 4), (nmemb - 1));

// guess the median is in the middle now. (from the list above)

size_t pos = 0;

size_t pivot = (nmemb - 1) * size;

// make last element the median(pivot)

cc_swap(base + pivot, base + ((nmemb / 2) * size), size);

// standard qsort pt. below

for (size_t i = 0; i < pivot; i += size)

{

if (compar(thunk, base + i, base + pivot) <= 0)

{

cc_swap(base + i, base + (pos * size), size);

pos++;

}

}

// issue the last change

cc_swap(base + (pos * size), base + pivot, size);

if (pos >= nmemb - 1) {

return; // looks like it was either all sorted OR nothing to sort

}

cc_qsort_r(base, pos++, size, compar, thunk);

cc_qsort_r(base + (pos * size), nmemb - pos, size, compar, thunk);

int (__cdecl *compar )(void*, const void *, const void *), void* context)

{

CompareWrapperContext qsort_s_context = {0};

qsort_s_context.real_comparer = compar;

qsort_s_context.real_context = context;

cc_qsort_r(

base,

nmemb,

size,

qsort_compare_wrapper,

&qsort_s_context

);

{

#if HAVE__NSGETENVIRON

palEnvironment = *(_NSGetEnviron());

#else // HAVE__NSGETENVIRON

extern char **environ;

palEnvironment = environ;

#endif // HAVE__NSGETENVIRON

{

#if HAVE__NSGETENVIRON

*(_NSGetEnviron()) = palEnvironment;

#else // HAVE__NSGETENVIRON

extern char **environ;

environ = palEnvironment;

#endif // HAVE__NSGETENVIRON

{

InternalInitializeCriticalSection(&gcsEnvironment);

MiscGetEnvArray();

return TRUE;

{

TRACE("Cleaning Misc...\n");

InternalDeleteCriticalSection(&gcsEnvironment);

{

int i;

int result = 0;

for(i = 0; left[i] != 0 && result == 0 && i < INT_MAX; i++)

{

result = (left[i] == right[i]) ? 0 : (left[i] < right[i] ? -1 : 1);

}

*last_index = i;

return result;

{

const char *equals, *existingEquals;

char *copy = NULL;

int length;

int i, j;

bool fOwningCS = false;

BOOL result = FALSE;

CPalThread * pthrCurrent = InternalGetCurrentThread();

equals = strchr(string, '=');

if (equals == string || equals == NULL)

{

// "=foo" and "foo" have no meaning

goto done;

}

if (equals[1] == '\0' && deleteIfEmpty)

{

// "foo=" removes foo from the environment in _putenv() on Windows.

// The same string can result from a call to SetEnvironmentVariable()

// with the empty string as the value, but in that case we want to

// set the variable's value to "". deleteIfEmpty will be FALSE in

// that case.

length = strlen(string);

copy = (char *) InternalMalloc(length);

if (copy == NULL)

{

goto done;

}

memcpy(copy, string, length - 1);

copy[length - 1] = '\0'; // Change '=' to '\0'

MiscUnsetenv(copy);

result = TRUE;

}

else

{

// See if we are replacing an item or adding one.

// Make our copy up front, since we'll use it either way.

copy = InternalStrdup(string);

if (copy == NULL)

{

goto done;

}

length = equals - string;

InternalEnterCriticalSection(pthrCurrent, &gcsEnvironment);

fOwningCS = true;

for(i = 0; palEnvironment[i] != NULL; i++)

{

existingEquals = strchr(palEnvironment[i], '=');

if (existingEquals == NULL)

{

// The PAL screens out malformed strings, but

// environ comes from the system, so it might

// have strings without '='. We treat the entire

// string as a name in that case.

existingEquals = palEnvironment[i] + strlen(palEnvironment[i]);

}

if (existingEquals - palEnvironment[i] == length)

{

if (memcmp(string, palEnvironment[i], length) == 0)

{

// Replace this one. Don't free the original,

// though, because there may be outstanding

// references to it that were acquired via

// getenv. This is an unavoidable memory leak.

palEnvironment[i] = copy;

// Set 'copy' to NULL so it won't be freed

copy = NULL;

result = TRUE;

break;

}

}

}

if (palEnvironment[i] == NULL)

{

static BOOL sAllocatedEnviron = FALSE;

// Add a new environment variable.

// We'd like to realloc palEnvironment, but we can't do that the

// first time through.

char **newEnviron = NULL;

if (sAllocatedEnviron) {

if (NULL == (newEnviron =

(char **)InternalRealloc(palEnvironment, (i + 2) * sizeof(char *))))

{

goto done;

}

}

else

{

// Allocate palEnvironment ourselves so we can realloc it later.

newEnviron = (char **)InternalMalloc((i + 2) * sizeof(char *));

if (newEnviron == NULL)

{

goto done;

}

for(j = 0; palEnvironment[j] != NULL; j++)

{

newEnviron[j] = palEnvironment[j];

}

sAllocatedEnviron = TRUE;

}

palEnvironment = newEnviron;

MiscSetEnvArray();

palEnvironment[i] = copy;

palEnvironment[i + 1] = NULL;

// Set 'copy' to NULL so it won't be freed

copy = NULL;

result = TRUE;

}

}

done:

if (fOwningCS)

{

InternalLeaveCriticalSection(pthrCurrent, &gcsEnvironment);

}

if (NULL != copy)

{

InternalFree(copy);

}

return result;

{

const char *equals;

int length;

int i, j;

CPalThread * pthrCurrent = InternalGetCurrentThread();

length = strlen(name);

InternalEnterCriticalSection(pthrCurrent, &gcsEnvironment);

for(i = 0; palEnvironment[i] != NULL; i++)

{

equals = strchr(palEnvironment[i], '=');

if (equals == NULL)

{

equals = palEnvironment[i] + strlen(palEnvironment[i]);

}

if (equals - palEnvironment[i] == length)

{

if (memcmp(name, palEnvironment[i], length) == 0)

{

// Remove this one. Don't free it, though, since

// there might be oustanding references to it that

// were acquired via getenv. This is an

// unavoidable memory leak.

for(j = i + 1; palEnvironment[j] != NULL; j++) { }

// i is now the one we want to remove. j is the

// last index in palEnvironment, which is NULL.

// Shift palEnvironment down by the difference between i and j.

memmove(palEnvironment + i, palEnvironment + i + 1, (j - i) * sizeof(char *));

}

}

}

InternalLeaveCriticalSection(pthrCurrent, &gcsEnvironment);