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) ||
((__idtabsiz + 1) < __idtabsiz) ||
((__idtabsiz + 1) >= (SIZE_MAX / sizeof(IDpair))) ||
((newptr = (IDpair *)_recalloc_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 _capture_argv(arglist, static_argv, max_static_entries) - set up argv array
* for exec?? functions
*
*Purpose:
* Set up the argv array for the exec?? functions by captures the
* arguments from the passed va_list into the static_argv array. If the
* size of the static_argv array as specified by the max_static_entries
* parameter is not large enough, then allocates a dynamic array to hold
* the arguments. Return the address of the final argv array. If NULL
* then not enough memory to hold argument array. If different from
* static_argv parameter then call must free the return argv array when
* done with it.
*
* The scan of the arglist is terminated when a NULL argument is
* reached. The terminating NULL parameter is stored in the resulting
* argv array.
*
*Entry:
* va_list *arglist - pointer to variable length argument list.
* _TSCHAR *firstarg - first argument to store in array
* _TSCHAR **static_argv - pointer to static argv to use.
* size_t max_static_entries - maximum number of entries that can be
* placed in static_argv array.
*
*Exit:
* returns NULL if no memory.
* Otherwise returns pointer to argv array.
* (sometimes calls malloc)
*
*Exceptions:
*
*******************************************************************************/
#ifdef WPRFLAG
_TSCHAR ** __cdecl _wcapture_argv(
#else /* WPRFLAG */
_TSCHAR ** __cdecl _capture_argv(
#endif /* WPRFLAG */
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) {
/* The math here looks slightly odd. We really want (max_entries*2)*sizeof(_TSCHAR), but that can overflow
We take advantage of calloc's ability to catch overflow and the fact that sizeof(_TSCHAR)*2 cannot overflow
*/
if (argv == static_argv)
{
argv = _calloc_crt(max_entries, sizeof(_TSCHAR *)*2);
}
else
{
argv = _recalloc_crt(argv, max_entries, sizeof(_TSCHAR *)*2);
}
if (argv == NULL) break;
max_entries += max_entries;
}
argv[ i++ ] = nextarg;
if (nextarg == NULL) break;
nextarg = va_arg(*arglist, _TSCHAR *);
}
return argv;
}
int __cdecl _setmaxstdio (
int maxnum
)
{
void **newpiob;
int i;
int retval = 0;
/*
* Make sure the request is reasonable.
*/
_VALIDATE_RETURN(((maxnum >= _IOB_ENTRIES) && (maxnum <= _NHANDLE_)), EINVAL, -1);
_mlock(_IOB_SCAN_LOCK);
__try {
/*
* Try to reallocate the __piob array.
*/
if ( maxnum > _nstream ) {
if ( (newpiob = _recalloc_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 = _recalloc_crt( __piob, maxnum, sizeof(void *) ))
!= NULL )
{
_nstream = maxnum; /* retval already set to maxnum */
__piob = newpiob;
}
else
retval = -1;
}
}
__finally {
_munlock(_IOB_SCAN_LOCK);
}
return retval;
}
