757 lines
22 KiB
C
757 lines
22 KiB
C
/***
|
|
*winsig.c - C signal support
|
|
*
|
|
* Copyright (c) 1991-2001, Microsoft Corporation. All rights reserved.
|
|
*
|
|
*Purpose:
|
|
* Defines signal(), raise() and supporting functions.
|
|
*
|
|
*Revision History:
|
|
* 10-21-91 GJF Signal for Win32 and Dosx32. Copied from old signal.c
|
|
* (the Cruiser implementation with some revisions for
|
|
* Win32), then extensively rewritten.
|
|
* 11-08-91 GJF Cleaned up header files usage.
|
|
* 12-13-91 GJF Fixed multi-thread build.
|
|
* 09-30-92 SRW Add WINAPI keyword to CtrlC handler
|
|
* 02-17-93 GJF Changed for new _getptd().
|
|
* 04-06-93 SKS Replace _CRTAPI* with __cdecl
|
|
* 07-29-93 GJF Must reset the action for all FPE-s to SIG_DFL when
|
|
* SIGFPE is raised.
|
|
* 09-06-94 CFW Replace MTHREAD with _MT.
|
|
* 01-10-95 CFW Debug CRT allocs.
|
|
* 08-16-96 GJF Fixed overruns of _XctActTab. Also, detab-ed.
|
|
* 08-21-96 GJF Fixed _MT part of overrun fix.
|
|
* 03-05-98 GJF Exception-safe locking.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#ifndef _POSIX_
|
|
|
|
#include <cruntime.h>
|
|
#include <errno.h>
|
|
#include <float.h>
|
|
#include <malloc.h>
|
|
#include <mtdll.h>
|
|
#include <oscalls.h>
|
|
#include <signal.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <dbgint.h>
|
|
|
|
/*
|
|
* look up the first entry in the exception-action table corresponding to
|
|
* the given signal
|
|
*/
|
|
#ifdef _MT
|
|
static struct _XCPT_ACTION * __cdecl siglookup(int, struct _XCPT_ACTION *);
|
|
#else /* not _MT */
|
|
static struct _XCPT_ACTION * __cdecl siglookup(int);
|
|
#endif /* _MT */
|
|
|
|
/*
|
|
* variables holding action codes (and code pointers) for SIGINT, SIGBRK,
|
|
* SIGABRT and SIGTERM.
|
|
*
|
|
* note that the disposition (i.e., action to be taken upon receipt) of
|
|
* these signals is defined on a per-process basis (not per-thread)!!
|
|
*/
|
|
|
|
static _PHNDLR ctrlc_action = SIG_DFL; /* SIGINT */
|
|
static _PHNDLR ctrlbreak_action = SIG_DFL; /* SIGBREAK */
|
|
static _PHNDLR abort_action = SIG_DFL; /* SIGABRT */
|
|
static _PHNDLR term_action = SIG_DFL; /* SIGTERM */
|
|
|
|
/*
|
|
* flag indicated whether or not a handler has been installed to capture
|
|
* ^C and ^Break events.
|
|
*/
|
|
static int ConsoleCtrlHandler_Installed = 0;
|
|
|
|
|
|
/***
|
|
*static BOOL WINAPI ctrlevent_capture(DWORD CtrlType) - capture ^C and ^Break events
|
|
*
|
|
*Purpose:
|
|
* Capture ^C and ^Break events from the console and dispose of them
|
|
* according the values in ctrlc_action and ctrlbreak_action, resp.
|
|
* This is the routine that evokes the user-defined action for SIGINT
|
|
* (^C) or SIGBREAK (^Break) installed by a call to signal().
|
|
*
|
|
*Entry:
|
|
* DWORD CtrlType - indicates type of event, two values:
|
|
* CTRL_C_EVENT
|
|
* CTRL_BREAK_EVENT
|
|
*
|
|
*Exit:
|
|
* Returns TRUE to indicate the event (signal) has been handled.
|
|
* Otherwise, returns FALSE.
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
static BOOL WINAPI ctrlevent_capture (
|
|
DWORD CtrlType
|
|
)
|
|
{
|
|
_PHNDLR ctrl_action;
|
|
_PHNDLR *pctrl_action;
|
|
int sigcode;
|
|
|
|
#ifdef _MT
|
|
_mlock(_SIGNAL_LOCK);
|
|
__try {
|
|
#endif /* _MT */
|
|
|
|
/*
|
|
* Identify the type of event and fetch the corresponding action
|
|
* description.
|
|
*/
|
|
|
|
if ( CtrlType == CTRL_C_EVENT ) {
|
|
ctrl_action = *(pctrl_action = &ctrlc_action);
|
|
sigcode = SIGINT;
|
|
}
|
|
else {
|
|
ctrl_action = *(pctrl_action = &ctrlbreak_action);
|
|
sigcode = SIGBREAK;
|
|
}
|
|
|
|
#ifdef _MT
|
|
if ( !(ctrl_action == SIG_DFL) && !(ctrl_action == SIG_IGN) )
|
|
/*
|
|
* Reset the action to be SIG_DFL
|
|
*/
|
|
*pctrl_action = SIG_DFL;
|
|
|
|
}
|
|
__finally {
|
|
_munlock(_SIGNAL_LOCK);
|
|
}
|
|
#endif /* _MT */
|
|
|
|
if ( ctrl_action == SIG_DFL )
|
|
/*
|
|
* return FALSE, indicating the event has NOT been handled
|
|
*/
|
|
return FALSE;
|
|
|
|
if ( ctrl_action != SIG_IGN ) {
|
|
#ifndef _MT
|
|
/*
|
|
* Reset the action to be SIG_DFL and call the user's handler.
|
|
*/
|
|
*pctrl_action = SIG_DFL;
|
|
#endif /* ndef _MT */
|
|
(*ctrl_action)(sigcode);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE, indicating the event has been handled (which may
|
|
* mean it's being ignored)
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
*_PHNDLR signal(signum, sigact) - Define a signal handler
|
|
*
|
|
*Purpose:
|
|
* The signal routine allows the user to define what action should
|
|
* be taken when various signals occur. The Win32/Dosx32 implementation
|
|
* supports seven signals, divided up into three general groups
|
|
*
|
|
* 1. Signals corresponding to OS exceptions. These are:
|
|
* SIGFPE
|
|
* SIGILL
|
|
* SIGSEGV
|
|
* Signal actions for these signals are installed by altering the
|
|
* XcptAction and SigAction fields for the appropriate entry in the
|
|
* exception-action table (XcptActTab[]).
|
|
*
|
|
* 2. Signals corresponding to ^C and ^Break. These are:
|
|
* SIGINT
|
|
* SIGBREAK
|
|
* Signal actions for these signals are installed by altering the
|
|
* _ctrlc_action and _ctrlbreak_action variables.
|
|
*
|
|
* 3. Signals which are implemented only in the runtime. That is, they
|
|
* occur only as the result of a call to raise().
|
|
* SIGABRT
|
|
* SIGTERM
|
|
*
|
|
*
|
|
*Entry:
|
|
* int signum signal type. recognized signal types are:
|
|
*
|
|
* SIGABRT (ANSI)
|
|
* SIGBREAK
|
|
* SIGFPE (ANSI)
|
|
* SIGILL (ANSI)
|
|
* SIGINT (ANSI)
|
|
* SIGSEGV (ANSI)
|
|
* SIGTERM (ANSI)
|
|
*
|
|
* _PHNDLR sigact signal handling function or action code. the action
|
|
* codes are:
|
|
*
|
|
* SIG_DFL - take the default action, whatever that may
|
|
* be, upon receipt of this type type of signal.
|
|
*
|
|
* SIG_DIE - *** ILLEGAL ***
|
|
* special code used in the XcptAction field of an
|
|
* XcptActTab[] entry to indicate that the runtime is
|
|
* to terminate the process upon receipt of the exception.
|
|
* not accepted as a value for sigact.
|
|
*
|
|
* SIG_IGN - ignore this type of signal
|
|
*
|
|
* [function address] - transfer control to this address
|
|
* when a signal of this type occurs.
|
|
*
|
|
*Exit:
|
|
* Good return:
|
|
* Signal returns the previous value of the signal handling function
|
|
* (e.g., SIG_DFL, SIG_IGN, etc., or [function address]). This value is
|
|
* returned in DX:AX.
|
|
*
|
|
* Error return:
|
|
* Signal returns -1 and errno is set to EINVAL. The error return is
|
|
* generally taken if the user submits bogus input values.
|
|
*
|
|
*Exceptions:
|
|
* None.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
_PHNDLR __cdecl signal(
|
|
int signum,
|
|
_PHNDLR sigact
|
|
)
|
|
{
|
|
struct _XCPT_ACTION *pxcptact;
|
|
_PHNDLR oldsigact;
|
|
#ifdef _MT
|
|
_ptiddata ptd;
|
|
#endif
|
|
|
|
/*
|
|
* Check for values of sigact supported on other platforms but not
|
|
* on this one. Also, make sure sigact is not SIG_DIE
|
|
*/
|
|
if ( (sigact == SIG_ACK) || (sigact == SIG_SGE) )
|
|
goto sigreterror;
|
|
|
|
/*
|
|
* Take care of all signals which do not correspond to exceptions
|
|
* in the host OS. Those are:
|
|
*
|
|
* SIGINT
|
|
* SIGBREAK
|
|
* SIGABRT
|
|
* SIGTERM
|
|
*
|
|
*/
|
|
if ( (signum == SIGINT) || (signum == SIGBREAK) || (signum == SIGABRT)
|
|
|| (signum == SIGTERM) ) {
|
|
|
|
#ifdef _MT
|
|
_mlock( _SIGNAL_LOCK );
|
|
__try {
|
|
#endif
|
|
|
|
/*
|
|
* if SIGINT or SIGBREAK, make sure the handler is installed
|
|
* to capture ^C and ^Break events.
|
|
*/
|
|
if ( ((signum == SIGINT) || (signum == SIGBREAK)) &&
|
|
!ConsoleCtrlHandler_Installed )
|
|
if ( SetConsoleCtrlHandler(ctrlevent_capture, TRUE)
|
|
== TRUE )
|
|
ConsoleCtrlHandler_Installed = TRUE;
|
|
else {
|
|
_doserrno = GetLastError();
|
|
_munlock(_SIGNAL_LOCK);
|
|
goto sigreterror;
|
|
}
|
|
|
|
switch (signum) {
|
|
|
|
case SIGINT:
|
|
oldsigact = ctrlc_action;
|
|
ctrlc_action = sigact;
|
|
break;
|
|
|
|
case SIGBREAK:
|
|
oldsigact = ctrlbreak_action;
|
|
ctrlbreak_action = sigact;
|
|
break;
|
|
|
|
case SIGABRT:
|
|
oldsigact = abort_action;
|
|
abort_action = sigact;
|
|
break;
|
|
|
|
case SIGTERM:
|
|
oldsigact = term_action;
|
|
term_action = sigact;
|
|
break;
|
|
}
|
|
|
|
#ifdef _MT
|
|
}
|
|
__finally {
|
|
_munlock( _SIGNAL_LOCK );
|
|
}
|
|
#endif
|
|
goto sigretok;
|
|
}
|
|
|
|
/*
|
|
* If we reach here, signum is supposed to be one the signals which
|
|
* correspond to exceptions in the host OS. Those are:
|
|
*
|
|
* SIGFPE
|
|
* SIGILL
|
|
* SIGSEGV
|
|
*/
|
|
|
|
/*
|
|
* Make sure signum is one of the remaining supported signals.
|
|
*/
|
|
if ( (signum != SIGFPE) && (signum != SIGILL) && (signum != SIGSEGV) )
|
|
goto sigreterror;
|
|
|
|
|
|
#ifdef _MT
|
|
/*
|
|
* Fetch the tid data table entry for this thread
|
|
*/
|
|
ptd = _getptd();
|
|
|
|
/*
|
|
* Check that there a per-thread instance of the exception-action
|
|
* table for this thread. if there isn't, create one.
|
|
*/
|
|
if ( ptd->_pxcptacttab == _XcptActTab )
|
|
/*
|
|
* allocate space for an exception-action table
|
|
*/
|
|
if ( (ptd->_pxcptacttab = _malloc_crt(_XcptActTabSize)) != NULL )
|
|
/*
|
|
* initialize the table by copying over the contents
|
|
* of _XcptActTab[]
|
|
*/
|
|
(void) memcpy(ptd->_pxcptacttab, _XcptActTab,
|
|
_XcptActTabSize);
|
|
else
|
|
/*
|
|
* cannot create exception-action table, return
|
|
* error to caller
|
|
*/
|
|
goto sigreterror;
|
|
|
|
#endif /* _MT */
|
|
|
|
/*
|
|
* look up the proper entry in the exception-action table. note that
|
|
* if several exceptions are mapped to the same signal, this returns
|
|
* the pointer to first such entry in the exception action table. it
|
|
* is assumed that the other entries immediately follow this one.
|
|
*/
|
|
#ifdef _MT
|
|
if ( (pxcptact = siglookup(signum, ptd->_pxcptacttab)) == NULL )
|
|
#else /* not _MT */
|
|
if ( (pxcptact = siglookup(signum)) == NULL )
|
|
#endif /* _MT */
|
|
goto sigreterror;
|
|
|
|
/*
|
|
* SIGSEGV, SIGILL and SIGFPE all have more than one exception mapped
|
|
* to them. the code below depends on the exceptions corresponding to
|
|
* the same signal being grouped together in the exception-action
|
|
* table.
|
|
*/
|
|
|
|
/*
|
|
* store old signal action code for return value
|
|
*/
|
|
oldsigact = pxcptact->XcptAction;
|
|
|
|
/*
|
|
* loop through all entries corresponding to the
|
|
* given signal and update the SigAction and XcptAction
|
|
* fields as appropriate
|
|
*/
|
|
while ( pxcptact->SigNum == signum ) {
|
|
/*
|
|
* take care of the SIG_IGN and SIG_DFL action
|
|
* codes
|
|
*/
|
|
pxcptact->XcptAction = sigact;
|
|
|
|
/*
|
|
* make sure we don't run off the end of the table
|
|
*/
|
|
#ifdef _MT
|
|
if ( ++pxcptact >= ((struct _XCPT_ACTION *)(ptd->_pxcptacttab)
|
|
+ _XcptActTabCount) )
|
|
#else /* not _MT */
|
|
if ( ++pxcptact >= (_XcptActTab + _XcptActTabCount) )
|
|
#endif /* _MT */
|
|
break;
|
|
}
|
|
|
|
sigretok:
|
|
return(oldsigact);
|
|
|
|
sigreterror:
|
|
errno = EINVAL;
|
|
return(SIG_ERR);
|
|
}
|
|
|
|
/***
|
|
*int raise(signum) - Raise a signal
|
|
*
|
|
*Purpose:
|
|
* This routine raises a signal (i.e., performs the action currently
|
|
* defined for this signal). The action associated with the signal is
|
|
* evoked directly without going through intermediate dispatching or
|
|
* handling.
|
|
*
|
|
*Entry:
|
|
* int signum - signal type (e.g., SIGINT)
|
|
*
|
|
*Exit:
|
|
* returns 0 on good return, -1 on bad return.
|
|
*
|
|
*Exceptions:
|
|
* May not return. Raise has no control over the action
|
|
* routines defined for the various signals. Those routines may
|
|
* abort, terminate, etc. In particular, the default actions for
|
|
* certain signals will terminate the program.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
|
|
int __cdecl raise (
|
|
int signum
|
|
)
|
|
{
|
|
_PHNDLR sigact;
|
|
_PHNDLR *psigact;
|
|
PEXCEPTION_POINTERS oldpxcptinfoptrs;
|
|
int oldfpecode;
|
|
int indx;
|
|
|
|
#ifdef _MT
|
|
int siglock = 0;
|
|
_ptiddata ptd;
|
|
#endif
|
|
|
|
switch (signum) {
|
|
|
|
case SIGINT:
|
|
sigact = *(psigact = &ctrlc_action);
|
|
#ifdef _MT
|
|
siglock++;
|
|
#endif
|
|
break;
|
|
|
|
case SIGBREAK:
|
|
sigact = *(psigact = &ctrlbreak_action);
|
|
#ifdef _MT
|
|
siglock++;
|
|
#endif
|
|
break;
|
|
|
|
case SIGABRT:
|
|
sigact = *(psigact = &abort_action);
|
|
#ifdef _MT
|
|
siglock++;
|
|
#endif
|
|
break;
|
|
|
|
case SIGTERM:
|
|
sigact = *(psigact = &term_action);
|
|
#ifdef _MT
|
|
siglock++;
|
|
#endif
|
|
break;
|
|
|
|
case SIGFPE:
|
|
case SIGILL:
|
|
case SIGSEGV:
|
|
#ifdef _MT
|
|
ptd = _getptd();
|
|
sigact = *(psigact = &(siglookup( signum,
|
|
ptd->_pxcptacttab )->XcptAction));
|
|
#else
|
|
sigact = *(psigact = &(siglookup( signum )->
|
|
XcptAction));
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
/*
|
|
* unsupported signal, return an error
|
|
*/
|
|
return (-1);
|
|
}
|
|
|
|
/*
|
|
* If the current action is SIG_IGN, just return
|
|
*/
|
|
if ( sigact == SIG_IGN )
|
|
return(0);
|
|
|
|
/*
|
|
* If the current action is SIG_DFL, take the default action
|
|
*/
|
|
if ( sigact == SIG_DFL ) {
|
|
/*
|
|
* The current default action for all of the supported
|
|
* signals is to terminate with an exit code of 3.
|
|
*/
|
|
_exit(3);
|
|
}
|
|
|
|
#ifdef _MT
|
|
/*
|
|
* if signum is one of the 'process-wide' signals (i.e., SIGINT,
|
|
* SIGBREAK, SIGABRT or SIGTERM), assert _SIGNAL_LOCK.
|
|
*/
|
|
if ( siglock )
|
|
_mlock(_SIGNAL_LOCK);
|
|
|
|
__try {
|
|
#endif
|
|
|
|
|
|
/*
|
|
* From here on, sigact is assumed to be a pointer to a user-supplied
|
|
* handler.
|
|
*/
|
|
|
|
/*
|
|
* For signals which correspond to exceptions, set the pointer
|
|
* to the EXCEPTION_POINTERS structure to NULL
|
|
*/
|
|
if ( (signum == SIGFPE) || (signum == SIGSEGV) ||
|
|
(signum == SIGILL) ) {
|
|
#ifdef _MT
|
|
oldpxcptinfoptrs = ptd->_tpxcptinfoptrs;
|
|
ptd->_tpxcptinfoptrs = NULL;
|
|
#else
|
|
oldpxcptinfoptrs = _pxcptinfoptrs;
|
|
_pxcptinfoptrs = NULL;
|
|
#endif
|
|
|
|
/*
|
|
* If signum is SIGFPE, also set _fpecode to
|
|
* _FPE_EXPLICITGEN
|
|
*/
|
|
if ( signum == SIGFPE ) {
|
|
#ifdef _MT
|
|
oldfpecode = ptd->_tfpecode;
|
|
ptd->_tfpecode = _FPE_EXPLICITGEN;
|
|
#else
|
|
oldfpecode = _fpecode;
|
|
_fpecode = _FPE_EXPLICITGEN;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Reset the action to SIG_DFL and call the user specified handler
|
|
* routine.
|
|
*/
|
|
if ( signum == SIGFPE )
|
|
/*
|
|
* for SIGFPE, must reset the action for all of the floating
|
|
* point exceptions
|
|
*/
|
|
for ( indx = _First_FPE_Indx ;
|
|
indx < _First_FPE_Indx + _Num_FPE ;
|
|
indx++ )
|
|
{
|
|
#ifdef _MT
|
|
( (struct _XCPT_ACTION *)(ptd->_pxcptacttab) +
|
|
indx )->XcptAction = SIG_DFL;
|
|
#else
|
|
_XcptActTab[indx].XcptAction = SIG_DFL;
|
|
#endif
|
|
}
|
|
else
|
|
*psigact = SIG_DFL;
|
|
|
|
#ifdef _MT
|
|
}
|
|
__finally {
|
|
if ( siglock )
|
|
_munlock(_SIGNAL_LOCK);
|
|
}
|
|
#endif
|
|
|
|
if ( signum == SIGFPE )
|
|
/*
|
|
* Special code to support old SIGFPE handlers which
|
|
* expect the value of _fpecode as the second argument.
|
|
*/
|
|
#ifdef _MT
|
|
(*(void (__cdecl *)(int,int))sigact)(SIGFPE,
|
|
ptd->_tfpecode);
|
|
#else
|
|
(*(void (__cdecl *)(int,int))sigact)(SIGFPE, _fpecode);
|
|
#endif
|
|
else
|
|
(*sigact)(signum);
|
|
|
|
/*
|
|
* For signals which correspond to exceptions, restore the pointer
|
|
* to the EXCEPTION_POINTERS structure.
|
|
*/
|
|
if ( (signum == SIGFPE) || (signum == SIGSEGV) ||
|
|
(signum == SIGILL) ) {
|
|
#ifdef _MT
|
|
ptd->_tpxcptinfoptrs = oldpxcptinfoptrs;
|
|
#else
|
|
_pxcptinfoptrs = oldpxcptinfoptrs;
|
|
#endif
|
|
|
|
/*
|
|
* If signum is SIGFPE, also restore _fpecode
|
|
*/
|
|
if ( signum == SIGFPE )
|
|
#ifdef _MT
|
|
ptd->_tfpecode = oldfpecode;
|
|
#else
|
|
_fpecode = oldfpecode;
|
|
#endif
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/***
|
|
*struct _XCPT_ACTION *siglookup(int signum) - look up exception-action table
|
|
* entry for signal.
|
|
*
|
|
*Purpose:
|
|
* Find the first entry int _XcptActTab[] whose SigNum field is signum.
|
|
*
|
|
*Entry:
|
|
* int signum - C signal type (e.g., SIGINT)
|
|
*
|
|
*Exit:
|
|
* If successful, pointer to the table entry. If no such entry, NULL is
|
|
* returned.
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#ifdef _MT
|
|
|
|
static struct _XCPT_ACTION * __cdecl siglookup (
|
|
int signum,
|
|
struct _XCPT_ACTION *pxcptacttab
|
|
)
|
|
{
|
|
struct _XCPT_ACTION *pxcptact = pxcptacttab;
|
|
|
|
#else /* not _MT */
|
|
|
|
static struct _XCPT_ACTION * __cdecl siglookup(int signum)
|
|
{
|
|
struct _XCPT_ACTION *pxcptact = _XcptActTab;
|
|
|
|
#endif /* _MT */
|
|
/*
|
|
* walk thru the _xcptactab table looking for the proper entry. note
|
|
* that in the case where more than one exception corresponds to the
|
|
* same signal, the first such instance in the table is the one
|
|
* returned.
|
|
*/
|
|
#ifdef _MT
|
|
|
|
while ( (pxcptact->SigNum != signum) &&
|
|
(++pxcptact < pxcptacttab + _XcptActTabCount) ) ;
|
|
|
|
#else /* not _MT */
|
|
|
|
while ( (pxcptact->SigNum != signum) &&
|
|
(++pxcptact < _XcptActTab + _XcptActTabCount) ) ;
|
|
|
|
#endif /* _MT */
|
|
|
|
#ifdef _MT
|
|
if ( (pxcptact < (pxcptacttab + _XcptActTabCount)) &&
|
|
#else /* not _MT */
|
|
if ( (pxcptact < (_XcptActTab + _XcptActTabCount)) &&
|
|
#endif /* _MT */
|
|
(pxcptact->SigNum == signum) )
|
|
/*
|
|
* found a table entry corresponding to the signal
|
|
*/
|
|
return(pxcptact);
|
|
else
|
|
/*
|
|
* found no table entry corresponding to the signal
|
|
*/
|
|
return(NULL);
|
|
}
|
|
|
|
#ifdef _MT
|
|
|
|
/***
|
|
*int *__fpecode(void) - return pointer to _fpecode field of the tidtable entry
|
|
* for the current thread
|
|
*
|
|
*Purpose:
|
|
*
|
|
*Entry:
|
|
*
|
|
*Exit:
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
int * __cdecl __fpecode (
|
|
void
|
|
)
|
|
{
|
|
return( &(_getptd()->_tfpecode) );
|
|
}
|
|
|
|
|
|
/***
|
|
*void **__pxcptinfoptrs(void) - return pointer to _pxcptinfoptrs field of the
|
|
* tidtable entry for the current thread
|
|
*
|
|
*Purpose:
|
|
*
|
|
*Entry:
|
|
*
|
|
*Exit:
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void ** __cdecl __pxcptinfoptrs (
|
|
void
|
|
)
|
|
{
|
|
return( &(_getptd()->_tpxcptinfoptrs) );
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* _POSIX_ */
|