_TSCHAR ** __cdecl _capture_argv(
#endif
va_list *arglist,
const _TSCHAR *firstarg,
_TSCHAR **static_argv,
size_t max_static_entries
)
{
_TSCHAR ** argv;
_TSCHAR * nextarg;
size_t i;
size_t max_entries;
nextarg = (_TSCHAR *)firstarg;
argv = static_argv;
max_entries = max_static_entries;
i = 0;
for (;;) {
if (i >= max_entries) {
if (argv == static_argv)
argv = _malloc_crt((max_entries * 2) * sizeof(_TSCHAR *));
else
argv = _realloc_crt(argv, (max_entries * 2) * sizeof(_TSCHAR *));
if (argv == NULL) break;
max_entries += max_entries;
}
argv[ i++ ] = nextarg;
if (nextarg == NULL) break;
nextarg = va_arg(*arglist, _TSCHAR *);
}
return argv;
}
static IDpair * __cdecl idtab (
FILE *pstream
)
{
IDpair * pairptr; /* ptr to entry */
IDpair * newptr; /* ptr to newly malloc'd memory */
/* search the table. if table is empty, appropriate action should
* fall out automatically.
*/
for ( pairptr = __idpairs ; pairptr < (__idpairs+__idtabsiz) ; pairptr++ )
if ( pairptr->stream == pstream )
break;
/* if we found an entry, return it.
*/
if ( pairptr < (__idpairs + __idtabsiz) )
return(pairptr);
/* did not find an entry in the table. if pstream was NULL, then try
* creating/expanding the table. otherwise, return NULL. note that
* when the table is created or expanded, exactly one new entry is
* produced. this must not be changed unless code is added to mark
* the extra entries as being free (i.e., set their stream fields to
* to NULL).
*/
if ( (pstream != NULL) || ((newptr = (IDpair *)_realloc_crt((void *)__idpairs,
(__idtabsiz + 1)*sizeof(IDpair))) == NULL) )
/* either pstream was non-NULL or the attempt to create/expand
* the table failed. in either case, return a NULL to indicate
* failure.
*/
return( NULL );
__idpairs = newptr; /* new table ptr */
pairptr = newptr + __idtabsiz; /* first new entry */
__idtabsiz++; /* new table size */
return( pairptr );
}
int __cdecl __crtsetenv (
#endif
const _TSCHAR *option,
const int primary
)
{
int ix;
int remove; /* 1 if variable is to be removed */
_TSCHAR **env;
_TSCHAR *name, *value;
const _TSCHAR *equal;
/*
* check that the option string is valid, find the equal sign
* and verify '=' is not the first character in string.
*/
if ( (option == NULL) || ((equal = _tcschr(option, _T('='))) == NULL)
|| option == equal)
return(-1);
/* if the character following '=' is null, we are removing the
* the environment variable. Otherwise, we are adding or updating
* an environment variable.
*/
remove = (*(equal + 1) == _T('\0'));
/*
* the first time _[w]putenv() is called, copy the environment
* block that was passed to [w]main to avoid making a
* dangling pointer if the block is re-alloced.
*/
#ifdef WPRFLAG
if (_wenviron == __winitenv)
_wenviron = copy_environ(_wenviron);
#else
if (_environ == __initenv)
_environ = copy_environ(_environ);
#endif
/* see if requested environment array exists */
if (_tenviron == NULL) {
/*
* The requested type of environment does not exist.
* See if other type exists, if so convert it to requested type.
* The functions that convert the enviroment (__mbtow_environ and
* __wtomb_environ) will call this function (__crt[w]setenv) once
* for each of the pre-existing environment variables. To avoid
* an infinite loop, test the primary flag.
*/
#ifdef WPRFLAG
if (primary && _environ)
{
if (__mbtow_environ() != 0)
return -1;
}
#else
if (primary && _wenviron)
{
if (__wtomb_environ() != 0)
return -1;
}
#endif
else {
/* nothing to remove, return */
if ( remove )
return 0;
else {
/* create ones that do not exist */
if (_environ == NULL)
{
if ( (_environ = _malloc_crt(sizeof(char *))) == NULL)
return -1;
*_environ = NULL;
}
if (_wenviron == NULL)
{
if ( (_wenviron = _malloc_crt(sizeof(wchar_t *))) == NULL)
return -1;
*_wenviron = NULL;
}
}
}
}
/*
* At this point, the two types of environments are in sync (as much
* as they can be anyway). The only way they can get out of sync
* (besides users directly modifiying the environment) is if there
* are conversion problems: If the user sets two Unicode EVs,
* "foo1" and "foo2" and converting then to multibyte yields "foo?"
* and "foo?", then the environment blocks will differ.
*/
/* init env pointers */
env = _tenviron;
/* See if the string is already in the environment */
#ifdef WPRFLAG
ix = wfindenv(option, equal - option);
#else
ix = findenv(option, equal - option);
#endif
if ((ix >= 0) && (*env != NULL)) {
/* String is already in the environment - overwrite/remove it */
if (remove) {
/* free the string being removed */
_free_crt(env[ix]);
/* removing -- move all the later strings up */
for ( ; env[ix] != NULL; ++ix) {
env[ix] = env[ix+1];
}
/* shrink the environment memory block
(ix now has number of strings, including NULL) --
this realloc probably can't fail, since we're
shrinking a mem block, but we're careful anyway. */
if (env = (_TSCHAR **) _realloc_crt(env, ix * sizeof(_TSCHAR *)))
_tenviron = env;
}
else {
/* replace the option */
env[ix] = (_TSCHAR *) option;
}
}
else {
/*
* String is NOT in the environment
*/
if ( !remove ) {
/*
* Append the string to the environ table. Note that
* table must be grown to do this.
*/
if (ix < 0)
ix = -ix; /* ix = length of environ table */
if ( (env = (_TSCHAR **)_realloc_crt(env, sizeof(_TSCHAR *) *
(ix + 2))) == NULL )
return -1;
env[ix] = (_TSCHAR *)option;
env[ix + 1] = NULL;
_tenviron = env;
}
else
/*
* We are asked to remove an environment var that
* isn't there...just return success
*/
return 0;
}
/*
* Update the OS environment. Don't give an error if this fails
* since the failure will not affect the user unless he/she is making
* direct API calls. Only need to do this for one type, OS converts
* to other type automatically.
*/
if ( primary &&
(name = (_TSCHAR *)_malloc_crt((_tcslen(option) + 2) * sizeof(_TSCHAR))) != NULL )
{
_tcscpy(name, option);
value = name + (equal - option);
*value++ = _T('\0');
SetEnvironmentVariable(name, remove ? NULL : value);
_free_crt(name);
}
return 0;
}
int __cdecl _setmaxstdio (
int maxnum
)
{
void **newpiob;
int i;
int retval;
/*
* Make sure the request is reasonable.
*/
if ( (maxnum < _IOB_ENTRIES) || (maxnum > _NHANDLE_) )
return -1;
_mlock(_IOB_SCAN_LOCK);
/*
* Try to reallocate the __piob array.
*/
if ( maxnum > _nstream ) {
if ( (newpiob = _realloc_crt( __piob, maxnum * sizeof(void *) ))
!= NULL )
{
/*
* Initialize new __piob entries to NULL
*/
for ( i = _nstream ; i < maxnum ; i++ )
newpiob[i] = NULL;
retval = _nstream = maxnum;
__piob = newpiob;
}
else
retval = -1;
}
else if ( maxnum == _nstream )
retval = _nstream;
else { /* maxnum < _nstream */
retval = maxnum;
/*
* Clean up the portion of the __piob[] to be freed.
*/
for ( i = _nstream - 1 ; i >= maxnum ; i-- )
/*
* If __piob[i] is non-NULL, free up the _FILEX struct it
* points to.
*/
if ( __piob[i] != NULL )
if ( !inuse( (FILE *)__piob[i] ) ) {
_free_crt( __piob[i] );
}
else {
/*
* _FILEX is still inuse! Don't free any anything and
* return failure to the caller.
*/
retval = -1;
break;
}
if ( retval != -1 )
if ( (newpiob = _realloc_crt( __piob, maxnum * sizeof(void *) ))
!= NULL )
{
_nstream = maxnum; /* retval already set to maxnum */
__piob = newpiob;
}
else
retval = -1;
}
_munlock(_IOB_SCAN_LOCK);
return retval;
}
void * __fastcall _realloc_crt_fastcall(void *ptr, size_t size)
{
return _realloc_crt(ptr, size);
}
