kolibrios-fun/contrib/sdk/sources/newlib/libc/reent/hdlman.c
Sergey Semyonov (Serge) 846fce0120 set default newlib dir's structure
git-svn-id: svn://kolibrios.org@4874 a494cfbc-eb01-0410-851d-a64ba20cac60
2014-04-22 09:02:02 +00:00

382 lines
9.0 KiB
C

/****************************************************************************
*
* Open Watcom Project
*
* Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
* ========================================================================
*
* This file contains Original Code and/or Modifications of Original
* Code as defined in and that are subject to the Sybase Open Watcom
* Public License version 1.0 (the 'License'). You may not use this file
* except in compliance with the License. BY USING THIS FILE YOU AGREE TO
* ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
* provided with the Original Code and Modifications, and is also
* available at www.sybase.com/developer/opensource.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
* ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
* NON-INFRINGEMENT. Please see the License for the specific language
* governing rights and limitations under the License.
*
* ========================================================================
*
* Description: Handle manager routines.
*
****************************************************************************/
#include <reent.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#define _NFILES 20
#define _DYNAMIC 0x4000 /* FILE is dynamically allocated */
#define _READ 0x0001 /* file opened for reading */
#define _WRITE 0x0002 /* file opened for writing */
#define NULL_HANDLE (int)-1
#define DUMMY_HANDLE (int)-2
#define INVALID_HANDLE_VALUE (int) -1
#define _AccessIOB()
#define _ReleaseIOB()
#undef __getOSHandle
void __ChkTTYIOMode( int handle );
void __initPOSIXHandles( void ) __attribute__ ((constructor));
void __grow_iomode( int num );
int debugwrite(const char *path,const void *buff,
size_t offset, size_t count, size_t *writes);
int _fmode;
#define NUM_STD_STREAMS 3
#define _ISTTY 0x2000 /* is console device */
unsigned __init_mode[_NFILES] = { /* file mode information (flags) */
_READ, /* stdin */
_WRITE, /* stdout */
_WRITE /* stderr */
};
unsigned *__io_mode = __init_mode; /* initially points to static array */
unsigned __NFiles = _NFILES; /* maximum # of files we can open */
unsigned __NHandles = 0;
int *__OSHandles = NULL;
static __file_handle
stdin_handle = {
NULL,
0,
NULL
};
static __file_handle
stdout_handle =
{
NULL,
0,
debugwrite
};
static __file_handle
stderr_handle =
{
NULL,
0,
debugwrite
};
unsigned __growPOSIXHandles( unsigned num )
{
int *new2;
unsigned i;
if( num > __NHandles )
{
if( __OSHandles == NULL )
{
new2 = malloc( num * sizeof( int ) );
}
else
{
new2 = realloc( __OSHandles, num * sizeof( int ) );
}
if( new2 == NULL )
{
// __set_errno( ENOMEM );
num = __NHandles;
}
else
{
for( i = __NHandles; i < num; i++ )
{
new2[ i ] = NULL_HANDLE;
}
__OSHandles = new2;
__NHandles = num;
}
}
return( __NHandles );
}
int __allocPOSIXHandle( int hdl )
{
int i;
for( i = 0; i < __NHandles; i++ )
{
if( __OSHandles[i] == NULL_HANDLE ) break;
}
if( i >= __NHandles )
{
// 20 -> (20+10+1) -> 31
// 31 -> (31+15+1) -> 47
// 47 -> (47+23+1) -> 71
__growPOSIXHandles( i + (i >> 1) + 1 );
// keep iomode array in sync
if( __NHandles > __NFiles ) __grow_iomode( __NHandles );
for( ; i < __NHandles; i++ )
{
if( __OSHandles[i] == NULL_HANDLE ) break;
}
}
if( i >= __NHandles )
{
i = -1;
} else {
__OSHandles[i] = hdl;
}
return( i );
}
void __freePOSIXHandle( int hid )
{
__OSHandles[ hid ] = NULL_HANDLE;
}
int __getOSHandle( int hid )
{
return( __OSHandles[ hid ] );
}
int __setOSHandle( unsigned hid, int hdl )
{
// call the Win32 API for a standard file handle
switch( hid ) {
case STDIN_FILENO:
// SetStdHandle( STD_INPUT_HANDLE, hdl );
break;
case STDOUT_FILENO:
// SetStdHandle( STD_OUTPUT_HANDLE, hdl );
break;
case STDERR_FILENO:
// SetStdHandle( STD_ERROR_HANDLE, hdl );
break;
}
if( hid < __NHandles )
{
__OSHandles[ hid ] = hdl;
}
else
{
hid = (unsigned)-1; // this should never happen
}
return( hid );
}
// called from library startup code
void __initPOSIXHandles( void )
{
int h;
_fmode = O_BINARY;
__growPOSIXHandles( __NFiles );
h = (int)&stdin_handle;
__allocPOSIXHandle( h ); // should return 0==STDIN_FILENO
h = (int)&stdout_handle;
__allocPOSIXHandle( h ); // should return 1==STDOUT_FILENO
h = (int)&stderr_handle;
__allocPOSIXHandle( h ); // should return 3==STDERR_FILENO
}
/*
static void __finiPOSIXHandles( void )
{
if( __OSHandles != NULL ) {
free( __OSHandles );
__OSHandles = NULL;
}
if( __FakeHandles != NULL )
{
int i;
for( i = 0 ; i < __topFakeHandle ; i++ )
{
// CloseHandle( __FakeHandles[i] );
}
free( __FakeHandles );
__FakeHandles = 0;
}
}
*/
void __set_handles( int num )
{
__NHandles = num;
}
int _grow_handles( int num )
{
if( num > __NHandles )
{
num = __growPOSIXHandles( num );
if( num > __NFiles ) {
__grow_iomode( num ); // sets new __NFiles if successful
}
__NHandles = num;
}
return( __NHandles );
}
static unsigned _init_NFiles; // original __NFiles value;
void __grow_iomode( int num )
{
unsigned *new;
_AccessIOB();
if( __io_mode == __init_mode )
{
_init_NFiles = __NFiles;
new = (unsigned *) malloc( num * sizeof( unsigned ) );
if( new != NULL ) {
memcpy( new, __init_mode, __NFiles * sizeof(unsigned) );
}
}
else
{
new = (unsigned *) realloc( __io_mode, num * sizeof( unsigned ) );
}
if( new == NULL )
{
// __set_errno( ENOMEM );
}
else
{
memset( &new[__NFiles], 0, (num-__NFiles)*sizeof(unsigned) );
__io_mode = new;
__NFiles = num;
}
_ReleaseIOB();
}
void __shrink_iomode( void )
{
_AccessIOB();
// free any malloc'd iomode array
if( __io_mode != __init_mode )
{
free( __io_mode );
__io_mode = __init_mode;
__NFiles = _init_NFiles;
}
_ReleaseIOB();
}
#define _INITIALIZED _DYNAMIC
signed __SetIOMode( int handle, unsigned value )
{
int i;
if( handle >= __NFiles )
{
i = __NFiles; // 20 -> (20+10+1) -> 31
// 31 -> (31+15+1) -> 47
// 47 -> (47+23+1) -> 71
__grow_iomode( i + (i > 1) + 1 );
}
if( handle >= __NFiles )
{
// return an error indication (errno should be set to ENOMEM)
return( -1 );
}
else
{
if( value != 0 )
{
__ChkTTYIOMode( handle );
__io_mode[handle] = value | _INITIALIZED;
}
else
{
__io_mode[handle] = value; /* we're closing it; smite _INITIALIZED */
}
return( handle );
}
}
int _isatty( int hid )
{
return( 0 );
}
void __ChkTTYIOMode( int handle )
{
if( handle < NUM_STD_STREAMS && !(__io_mode[handle] & _INITIALIZED) )
{
__io_mode[handle] |= _INITIALIZED;
if( _isatty( handle ) )
{
__io_mode[handle] |= _ISTTY;
}
}
}
unsigned __GetIOMode( int handle )
{
if( handle >= __NFiles )
{
return( 0 );
}
return( __io_mode[handle] );
};
void __SetIOMode_nogrow( int handle, unsigned value )
{
if( handle < __NFiles )
{
__io_mode[handle] = value; /* we're closing it; smite _INITIALIZED */
}
}