/* Observe that philosopher n is eating */
void
eats(
i4 n)
{
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
Psem( &SIsem );
SIfprintf( stderr,"Error: unexpected exception in eats()...");
Vsem( &SIsem );
EXdelete();
return;
}
#endif
if( Noisy )
{
Psem( &SIsem );
SIfprintf(stderr, "%d (%s) eats...\n", n, Names[ n ] );
Vsem( &SIsem );
}
CSswitch();
#ifdef EX_DEBUG
EXdelete();
#endif
}
/*
** Function:
**
** rfapi_writeRFHeader
**
** Description:
**
** Write response file header to open file descriptor
**
** Inputs:
**
** II_RFAPI_HANDLE *handle - Pointer to intialized respone file handle
** FILE *fd - Pointer to an open response file
**
** Outputs:
**
** None
**
** Returns:
**
** II_RFAPI_STATUS:
** II_RF_ST_OK on success
**
** on failure:
** II_RF_ST_NULL_ARG
** II_RF_ST_FAIL
**
** History:
** 02-Jul-2009 (hanje04)
** Bug 122227
** SD 137277
** Increase size of datebuf to prevent buffer overrun in
** when calling rfapi_GetDateTime() :-(
** 12-Jul-2010 (hanje04)
** BUG 124081
** Add APPEND_HEADER if we're appending
*/
II_RFAPI_STATUS
rfapi_writeRFHeader( II_RFAPI_HANDLE *handle,
FILE *fd )
{
char date_buf[50]; /* buffer date and time string string */
/* check handle is valid */
if ( (*handle) == NULL )
return( II_RF_ST_NULL_ARG );
else if ( ! (*handle)->flags & II_RF_OP_INITIALIZED )
return( II_RF_ST_FAIL );
if ( SIisopen( fd ) != TRUE )
return( II_RF_ST_FAIL );
/* get time info */
rfapi_getDateTime( date_buf );
/* write out header */
if ( (*handle)->flags & II_RF_OP_APPEND )
SIfprintf( fd, RFAPI_RESPONSE_FILE_APPEND_HEADER, date_buf );
else
SIfprintf( fd, RFAPI_RESPONSE_FILE_HEADER, date_buf );
return( II_RF_ST_OK );
}
/*
** Name: apiprompt_func For prompt Messages
**
** Description:
** Prompt callback function
**
** History:
** 03-Feb-99 (rajus01)
** Created.
*/
static II_VOID
apiprompt_func( IIAPI_PROMPTPARM *promptParm )
{
SIfprintf( outputf, "\t===== Prompt Message =====\n" );
STcopy(password, promptParm->pd_reply);
promptParm->pd_rep_len = STlength( promptParm->pd_reply );
promptParm->pd_rep_flags = 0;
if ( verboseLevel > 1 )
{
SIfprintf( outputf, "\tpd_envHandle\t= 0x%lx\n",
promptParm->pd_envHandle );
SIfprintf( outputf, "\tpd_connHandle\t= 0x%lx\n",
promptParm->pd_connHandle );
}
if( promptParm->pd_flags & IIAPI_PR_NOECHO )
SIfprintf( outputf, "\tpd_flags\t= IIAPI_PR_NOECHO \n" );
if( promptParm->pd_flags & IIAPI_PR_TIMEOUT )
{
SIfprintf( outputf, "\tpd_flags\t= IIAPI_PR_TIMEOUT \n" );
SIfprintf( outputf, "\tpd_timeout\t= %d\n", promptParm->pd_timeout );
}
SIfprintf( outputf, "\tpd_msg_len\t= %d\n", promptParm->pd_msg_len );
SIfprintf( outputf, "\tpd_message\t= %s\n", promptParm->pd_message );
SIfprintf( outputf, "\tpd_max_reply\t= %d\n", promptParm->pd_max_reply );
SIfprintf( outputf, "\t=========================\n" );
return;
}
void
logger(
i4 errnum, i4 arg1, i4 arg2)
{
char buf[ ER_MAX_LEN ];
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
Psem( &SIsem );
SIfprintf( stderr,"Error: unexpected exception in logger()...");
Vsem( &SIsem );
EXdelete();
return;
}
#endif
Psem( &SIsem );
if( ERreport( errnum, buf ) == OK )
SIfprintf(stderr, "%s\n", buf);
else
SIfprintf(stderr, "ERROR %d (%x), %s %d\n",
errnum, errnum, arg1, arg2 );
Vsem( &SIsem );
#ifdef EX_DEBUG
EXdelete();
#endif
if(errnum != E_CS0018_NORMAL_SHUTDOWN)
PCexit(FAIL);
PCexit(OK);
}
static VOID
usage()
{
if(ingres_menu) {
SIfprintf(stderr, ERget(E_ST0177_usage_1), SystemExecName);
SIfprintf(stderr, ERget(E_ST017E_usage_2), SystemExecName);
}
else {
SIfprintf(stderr, ERget(E_ST0534_usage_3),SystemExecName, SystemExecName);
}
}
static void
yyadd_path( char *idirectory )
{
STATUS sts;
IPATH *ipath_cur;
IPATH *ipath_new;
char *buf;
/* Locate the last directory in the list of include paths */
for (ipath_cur = &ihead;
ipath_cur->next != NULL;
ipath_cur = ipath_cur->next)
continue;
/* Allocate memory for the new path structure */
ipath_new = (IPATH *)MEreqmem(0, sizeof(IPATH), FALSE, &sts);
if (ipath_new == NULL || sts != OK)
{
SIfprintf( stderr, E_YAPP002 );
yydump();
}
/*
** Anchor the new structure and fill it in
*/
ipath_cur->next = ipath_new;
ipath_new->pathloc =
(LOCATION *)MEreqmem(0, sizeof(LOCATION), FALSE, &sts);
ipath_new->next = NULL;
if (ipath_new->pathloc == NULL || sts != OK )
{
SIfprintf( stderr, E_YAPP003 );
yydump( );
}
buf = (char *)MEreqmem(0, MAX_LOC + 1, FALSE, &sts);
if (buf == NULL || sts != OK )
{
SIfprintf( stderr, E_YAPP004 );
yydump();
}
STcopy(idirectory, buf);
if (LOfroms(PATH, buf, ipath_new->pathloc) != OK)
{
SIfprintf( stderr, E_YAPP005 );
yydump();
}
}
/* decode semaphore error */
void
semerr(
i4 rv,
CS_SEMAPHORE *sp,
char *msg)
{
MY_SCB *scb;
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
SIfprintf( stderr,"Error: unexpected exception in semerr()...");
EXdelete();
return;
}
#endif
CSget_scb( (CS_SCB **)&scb );
SIfprintf(stderr, "%s %p returned %d (%s)\n", msg, sp, rv, maperr(rv) );
SIfprintf(stderr, "\tPhilosopher %d, scb %p\n", scb->phil, scb );
SIfprintf(stderr, "\t%p->cs_value %d\n", sp, sp->cs_value );
SIfprintf(stderr, "\t%p->cs_count %d\n", sp, sp->cs_count );
SIfprintf(stderr, "\t%p->cs_owner %x\n", sp, sp->cs_owner );
SIfprintf(stderr, "\t%p->cs_list %p\n", sp, sp->cs_list );
SIfprintf(stderr, "\t%p->cs_next %p\n", sp, sp->cs_next );
#ifdef EX_DEBUG
EXdelete();
#endif
}
/*
** Name: error
**
** Description:
** Prints an error message to stderr. If two error strings are passed
** to the function, the function will make a win32 api call to obtain
** a detailed error code.
**
** Re-entrancy:
** yes.
**
** Inputs:
** s1 - mandatory error message
** s2 - optional error message(should only be used if a win32 api call
** failed.
**
** Outputs:
** An error message.
**
** Returns:
** To operating system a FAIL return code.
**
** Side effects:
** Causes process to terminate.
**
** History:
** 14-jun-95 (reijo01)
** Created.
*/
void
error(char *s1, char *s2)
{
DWORD error_code;
if (s2)
{
error_code = GetLastError();
SIfprintf( stderr, "%s: %s %s %d\n", iirundbms, s1, s2, error_code );
}
else
{
SIfprintf( stderr, "%s: %s %s\n", iirundbms, s1, s2 );
}
PCexit(FAIL);
}
void
yyerror()
{
SIfprintf( stderr, ERget( S_ST0410_crs_syntax_error ), yylineno,
file_name );
PCexit( FAIL );
}
i4
CM_UTF32toUTF8 (int inval, char *resstr)
{
i4 i, n;
ConversionResult result;
UTF32 utf32_buf[2];
UTF8 utf8_buf[15];
UTF32 *utf32SourceStart;
UTF8 *utf8TargetStart;
i2 rescnt = 0;
utf32_buf[0] = inval; utf32_buf[1] = 0;
for (n = 0; n < 8; n++) utf8_buf[n] = 0;
utf32SourceStart = utf32_buf;
utf8TargetStart = utf8_buf;
result = CM_ConvertUTF32toUTF8((const UTF32 **) &utf32SourceStart,
&(utf32_buf[1]), &utf8TargetStart,
&(utf8_buf[14]),
0, &rescnt);
if (result != conversionOK) {
SIfprintf(stderr,
"CM_ConvertUTF32toUTF8 : fatal error: result %d for input %08x\n", result, utf32_buf[0]); exit(1);
}
for (i=0; i < rescnt; i++)
{
resstr[i] = utf8_buf[i];
}
return rescnt;
}
static i4
pp_input( FILE *input, STACK_FRAME *stack, bool ifdef )
{
i4 token;
u_i4 directive = NONE;
while( directive != ENDIF && (token = yylex( input )) != tEOF )
{
switch( token )
{
case tSOURCE:
if( active( stack ) )
yyputline( infile->yytext );
break;
case tHISTORY:
/* don't display */
break;
case tDIRECTIVE:
directive = pp_directive( input, stack,
ifdef );
break;
}
}
if( token == tEOF && ifdef )
{
SIfprintf( stderr, E_YAPP009 );
yydump();
}
return( token );
}
static void
define(char *symbol, char *value, bool hist)
{
SYMBOL **symptr_anchor;
SYMBOL *symptr_new;
STATUS sts;
char *buf;
/* Locate the last defined symbol in the list */
for (symptr_anchor = &symtab.head;
*symptr_anchor != NULL;
symptr_anchor = &((*symptr_anchor)->next) )
continue;
/* Allocate memory for the new symbol structure */
symptr_new = (SYMBOL *)MEreqmem(0, sizeof(SYMBOL), FALSE, &sts);
if (symptr_new == NULL || sts != OK)
{
SIfprintf( stderr, E_YAPP008 );
yydump();
}
/*
** Anchor the new symbol structure and fill it in
*/
*symptr_anchor = symptr_new;
symptr_new->name = STalloc( symbol );
symptr_new->value = STalloc( value );
symptr_new->hist_flag = hist;
symptr_new->next = NULL;
symtab.nsym++;
}
static void
yydump( )
{
i4 filenum;
for (filenum = 0; filenum <= filex; filenum++)
{
if (filenum < MAX_INCLUDE && file[filenum].yyopen == TRUE)
SIfprintf(stderr, E_YAPP00D,
file[filenum].name,
file[filenum].yylineno,
file[filenum].yytext);
}
SIfprintf(stderr, ERx("\n") );
PCexit( FAIL );
}
/*
** Function:
**
** rfapi_writeSecHeader
**
** Description:
**
** Write given section header to open response file.
**
** Inputs:
**
** II_RFAPI_HANDLE *handle - Pointer to intialized respone file handle
** II_RFAPI_STRING header - Section header to be written
** FILE *fd - Pointer to an open response file
**
** Outputs:
**
** None
**
** Returns:
**
** II_RFAPI_STATUS:
** II_RF_ST_OK on success
**
** on failure:
** II_RF_ST_NULL_ARG
** II_RF_ST_FAIL
*/
II_RFAPI_STATUS
rfapi_writeSecHeader( II_RFAPI_HANDLE *handle,
II_RFAPI_STRING header,
FILE *fd )
{
/* check handle is valid */
if ( (*handle) == NULL )
return( II_RF_ST_NULL_ARG );
else if ( ! (*handle)->flags & II_RF_OP_INITIALIZED )
return( II_RF_ST_FAIL );
/* check for valid header */
if ( header == NULL || *header == '\0' )
return( II_RF_ST_NULL_ARG );
/* check response file is open */
if ( SIisopen( fd ) != TRUE )
return( II_RF_ST_FAIL );
/* write the header */
SIfprintf( fd, RFAPI_SECTION_HEADER, header );
return( II_RF_ST_OK ) ;
}
char
*FIND_SEPstring(char *token,char *string)
{
i4 token_len ;
i4 string_len ;
char *cp = NULL ;
char *pp = NULL ;
char *tp = NULL ;
if (token == NULL || *token == EOS)
{
if (tracing&TRACE_PARM)
SIfprintf(traceptr,ERx("FIND_SEPstring> token is null\n"));
return (NULL);
}
if (string == NULL || *string == EOS)
{
if (tracing&TRACE_PARM)
SIfprintf(traceptr,ERx("FIND_SEPstring> string is null\n"));
return (NULL);
}
string_len = STlength(string);
if ((token_len = STlength(token)) < string_len)
{
if (tracing&TRACE_PARM)
SIfprintf(traceptr
,ERx("FIND_SEPstring> token <%s> is too small (%d chars)\n")
,token,token_len);
return (NULL);
}
for (tp = token, cp = NULL, pp = NULL
; (*tp != EOS)&&(cp == NULL)&&(token_len-- >= string_len)
; CMnext(tp))
{
if ((STbcompare(tp, string_len, string, string_len, TRUE) == 0)
&&((pp == NULL)||CMoper(pp)||CMwhite(pp)))
{
cp = tp;
}
pp = tp;
}
return (cp);
}
/* CM_UTF32toUTF16 - This routine accepts a UTF32 value as an i4
** It converts the UTF32 code to the output buffer
** It writes the number of UTF16 code units written
** to ocount;
** Input
** invalue The UTF32 code point value between 0 to 0x10FFFF.
** outstr An array of outstr pointer at least
**
**
** returns converstionOK if successful >0 otherwise.
**
** History
** 3-nov-2008 (gupsh01)
** Added.
*/
i4
CM_UTF32toUTF16 (i4 inval, u_i2 *outbuf, u_i2 *outend, i4 *outlen)
{
i4 i, rescnt;
ConversionResult result = conversionOK;
UTF32 utf32_buf[2];
UTF16 utf16_buf[3];
UTF32 *utf32SourceStart, *utf32TargetStart;
UTF16 *utf16SourceStart, *utf16TargetStart;
utf32_buf[0] = inval; utf32_buf[1] = 0;
utf16_buf[0] = utf16_buf[1] = utf16_buf[2] = 0;
utf32SourceStart = utf32_buf;
utf16TargetStart = utf16_buf;
if (result = CM_ConvertUTF32toUTF16((const UTF32 **) &utf32SourceStart,
&(utf32_buf[1]), &utf16TargetStart,
&(utf16_buf[2]),
0, &rescnt) != conversionOK )
{
#ifdef xDebug
SIfprintf(stderr,
"CM_ConvertUTF32toUTF16 : fatal error: result %d for input %08x\n",
result, utf32_buf[0]);
#endif
return result;
}
else if ((outbuf + rescnt) > outend)
{
#ifdef xDebug
SIfprintf(stderr,
"CM_ConvertUTF32toUTF16 : fatal error: result %d for input %08x\n",
result, utf32_buf[0]);
#endif
return targetExhausted;
}
else
{
*outlen = rescnt;
*outbuf = utf16_buf[0];
if (rescnt == 2)
*(outbuf + 1) = utf16_buf[1];
return conversionOK;
}
}
/*
** Setup global variables and add threads for each philosopher.
** Called by CSinitialize before threads are started
*/
STATUS
hello(
CS_INFO_CB *csib)
{
i4 i;
STATUS stat;
CL_ERR_DESC err;
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
SIfprintf( stderr,"Error: unexpected exception in hello()...");
EXdelete();
return FAIL;
}
#endif
SIsem.cs_value = 0;
SIsem.cs_count = 0;
SIsem.cs_owner = NULL;
SIsem.cs_list = NULL;
SIsem.cs_next = NULL;
Freesem.cs_value = 0;
Freesem.cs_count = 0;
Freesem.cs_owner = NULL;
Freesem.cs_list = NULL;
Freesem.cs_next = NULL;
for( i = 0, stat = OK; i < n_phils && stat == OK; i++ )
{
Freesticks[ i ] = 2;
stat = CSadd_thread( 0, (PTR)NULL, i + 1, (CS_SID*)NULL, &err );
}
/* no semaphore needed, called before CSdispatch */
if( Noisy )
SIfprintf(stderr, "World begins, philosophers wonder why.\n" );
#ifdef EX_DEBUG
EXdelete();
#endif
return( stat );
}
static bool
writeMgrFile( char *altPath )
{
char *dirPath;
char fullPath[OCFG_MAX_STRLEN];
FILE *pfile;
LOCATION loc;
STATUS status;
# ifdef VMS
NMgtAt(SYSTEM_LOCATION_VARIABLE,&dirPath); /* usually II_SYSTEM */
if (dirPath != NULL && *dirPath)
STlcopy(dirPath,fullPath,sizeof(fullPath)-20-1);
else
return (FALSE);
STcat(fullPath,"[");
STcat(fullPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(fullPath,".files]");
STcat(fullPath,MGR_STR_FILE_NAME);
# else
NMgtAt(SYSTEM_LOCATION_VARIABLE,&dirPath); /* usually II_SYSTEM */
if (dirPath != NULL && *dirPath)
STlcopy(dirPath,fullPath,sizeof(fullPath)-20-1);
else
return (FALSE);
STcat(fullPath,"/");
STcat(fullPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(fullPath,"/files/");
STcat(fullPath,MGR_STR_FILE_NAME);
# endif /* ifdef VMS */
if ( LOfroms(PATH & FILENAME, fullPath, &loc) != OK )
return FALSE;
if (SIfopen(&loc, "w", (i4)SI_TXT, OCFG_MAX_STRLEN, &pfile) != OK)
return FALSE;
if (altPath && *altPath)
SIfprintf(pfile,"%s=%s\n",MGR_STR_PATH,altPath);
SIfprintf(pfile,"%s=%s\n",MGR_STR_MANAGER,
driverManager == MGR_VALUE_UNIX_ODBC ?
MGR_STR_UNIX_ODBC : MGR_STR_CAI_PT);
return TRUE;
}
static ConversionResult
CM_ConvertUTF16toUTF32 (
const UTF16** sourceStart, const UTF16* sourceEnd,
UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags)
{
ConversionResult result = conversionOK;
const UTF16* source = *sourceStart;
UTF32* target = *targetStart;
UTF32 ch, ch2;
while (source < sourceEnd) {
const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
ch = *source++;
/* If we have a surrogate pair, convert to UTF32 first. */
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
/* If the 16 bits following the high surrogate are in the source buffer... */
if (source < sourceEnd) {
ch2 = *source;
/* If it's a low surrogate, convert to UTF32. */
if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+ (ch2 - UNI_SUR_LOW_START) + halfBase;
++source;
} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
--source; /* return to the illegal value itself */
result = sourceIllegal;
break;
}
} else { /* We don't have the 16 bits following the high surrogate. */
--source; /* return to the high surrogate */
result = sourceExhausted;
break;
}
} else if (flags == strictConversion) {
/* UTF-16 surrogate values are illegal in UTF-32 */
if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
--source; /* return to the illegal value itself */
result = sourceIllegal;
break;
}
}
if (target >= targetEnd) {
source = oldSource; /* Back up source pointer! */
result = targetExhausted; break;
}
*target++ = ch;
}
*sourceStart = source;
*targetStart = target;
#ifdef CVTUTF_DEBUG
if (result == sourceIllegal) {
SIfprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
SIflush(stderr);
}
#endif
return result;
}
static STATUS
MEerror(
STATUS error_status)
{
char ME_err_buf[ER_MAX_LEN];
ERreport(error_status, ME_err_buf);
SIfprintf(stderr, "%s\n", ME_err_buf);
return( OK );
}
static bool
proc_version(char *featname, bool only)
{
PKGBLK *pkg;
SCAN_LIST(instPkgList,pkg)
{
if (!STbcompare(featname, 0, pkg->feature, 0, TRUE))
{
if (!only) /* Don't identify the package if there's only one. */
SIfprintf(batchOutf, ERx("%s "), pkg->feature);
SIfprintf(batchOutf, ERx("%s\n"), pkg->version);
return TRUE;
}
}
IIUGerr(E_ST017B_not_present, 0, 1, featname);
return FALSE;
}
static void
yyputline( char *outtext)
{
char token_buf[MAX_LINE+1];
char token_val[MAX_LINE+1];
char *p = token_buf;
static char *symc = ERx(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$");
i4 symc_l = STlength(symc);
i4 defidx;
static i4 iterate_level = 0;
/* Check to make sure we don't have runaway recursion */
if (iterate_level++ > MAX_ITERATION)
{
SIfprintf( stderr, E_YAPP006 );
yydump();
}
/* Break up the string into tokens and try to resolve symbols */
while (*outtext != EOS)
{
p = token_buf;
while (STindex(symc, outtext, symc_l) != NULL) {
STlcopy(outtext, p, 1);
CMnext(outtext);
CMnext(p);
}
/* Found a token that may be defined as a symbol */
if (p != token_buf)
{
/* If the token is defined then translate the */
/* value of the substituted text, otherwise just */
/* output the untranslated text. */
STcopy(ERx(""), p);
if (OK == is_defined(token_buf, token_val))
yyputline( token_val );
else
SIprintf("%s", token_buf);
}
/* The text being processed at this point is whitespace, */
/* operators, or some other characters that are not */
/* valid for tokens. */
else
{
SIputc(*outtext, stdout);
CMnext(outtext);
}
}
iterate_level--;
}
void
main(int argc, char *argv[])
{
char buf[ MAXBUF+1 ];
i4 c;
if (argc == 1)
PCexit(FAIL);
for(;argc > 1 ; --argc)
SIfprintf(stdout,"%s ",*++argv);
}
/*
** Function:
**
** rfapi_doWrite
**
** Description:
**
** Write given parameter list to open response file
**
** Inputs:
**
** II_RFAPI_HANDLE *handle - Pointer to intialized respone file handle
** RFAPI_VAR **var_list - List of response file variable to write
** FILE *fd - Pointer to an open response file
**
** Outputs:
**
** None
**
** Returns:
**
** II_RFAPI_STATUS:
** II_RF_ST_OK on success
**
** on failure:
** II_RF_ST_IO_ERROR
** ...
** II_RF_ST_FAIL
*/
II_RFAPI_STATUS
rfapi_doWrite( II_RFAPI_HANDLE *handle,
RFAPI_VAR **var_list,
FILE *fd )
{
RFAPI_PARAMS *params_ptr;
i4 i=0;
if ( SIisopen( fd ) != TRUE )
return( II_RF_ST_IO_ERROR );
/*
** scroll through the list of parameters in order and write out
** the names and values
*/
while ( var_list[i] != NULL )
{
/* only print parameters valid for specified output format */
if ( (*handle)->output_format & var_list[i]->valid_on )
{
if ( params_ptr = rfapi_findParam( handle, var_list[i]->pname ) )
SIfprintf( fd, "%s=%s\n",
var_list[i]->vname,
(params_ptr)->param.value );
else if ( (*handle)->flags & II_RF_OP_WRITE_DEFAULTS &&
(*handle)->output_format & var_list[i]->default_on )
SIfprintf( fd, "%s=%s\n",
var_list[i]->vname,
(*handle)->output_format & II_RF_DP_LINUX ?
var_list[i]->default_lnx :
var_list[i]->default_win );
}
i++;
}
return( II_RF_ST_OK );
}
/* Called when all thread functions return from the TERMINATE state */
STATUS
bye()
{
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
SIfprintf( stderr,"Error: unexpected exception in bye()...");
EXdelete();
return FAIL;
}
#endif
/* no semaphore needed, called when all threads are dead */
if( Noisy )
SIfprintf(stderr, "All philosophers are dead. World ends.\n");
#ifdef EX_DEBUG
EXdelete();
#endif
return( OK );
}
bool
IS_FileNotation(char *filenm)
{
char *tmp_ptr = NULL ;
if (tracing&TRACE_PARM)
{
SIfprintf(traceptr,ERx("IS_FileNotation> filenm = %s\n"),filenm);
}
if ((tmp_ptr = FIND_SEPstring(filenm,ERx("@FILE("))) == NULL)
{
if (tracing&TRACE_PARM)
SIfprintf(traceptr,ERx("IS_FileNotation> return FALSE\n"));
return (FALSE);
}
if (tracing&TRACE_PARM)
{
SIfprintf(traceptr,ERx("IS_FileNotation> return TRUE\n"));
}
return (TRUE);
}
/*
** RESIGNAL a few specific errors.
*/
STATUS
ex_handler2(
EX_ARGS *ex_args)
{
STATUS stat = EX_DECLARE;
if (ex_args->exarg_num == free_exc) {
Psem( &SIsem );
SIfprintf( stderr,"RESIG:freesticks(%d)\n", ex_args->exarg_array[0]);
Vsem( &SIsem );
stat = EX_RESIGNAL;
}
if (ex_args->exarg_num == get_exc) {
Psem( &SIsem );
SIfprintf( stderr,"RESIG:getsticks(%d)\n", ex_args->exarg_array[0]);
Vsem( &SIsem );
stat = EX_RESIGNAL;
}
return stat;
}
/* Observe that philosopher n is thinking */
void
thinks(
i4 n)
{
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
Psem( &SIsem );
SIfprintf( stderr,"exception raised while thinking, OK...\n");
Vsem( &SIsem );
EXdelete();
return;
}
#endif
if( Noisy )
{
Psem( &SIsem );
SIfprintf(stderr, "%d (%s) thinks...\n", n, Names[ n ] );
Vsem( &SIsem );
}
CSswitch();
#ifdef EX_DEBUG
EXsignal(not_handled, 0);
Psem( &SIsem );
SIfprintf( stderr,"Error: should not be reached in thinks()...");
Vsem( &SIsem );
EXdelete();
#endif
}
/*
** Name: apievent_func For Dbevent Messages
**
** Description:
** Dbevent callback function
**
** History:
** 03-Feb-99 (rajus01)
** Created.
** 12-Jul-02 (gordy)
** ait_printData() now prints directly to output.
*/
static II_VOID
apievent_func( IIAPI_EVENTPARM *eventParm )
{
SIfprintf( outputf, "\t===== Dbevent Message =====\n" );
if ( verboseLevel > 1 )
{
SIfprintf( outputf, "\tev_envHandle = 0x%lx\n",
eventParm->ev_envHandle );
SIfprintf( outputf, "\tev_connHandle = 0x%lx\n",
eventParm->ev_connHandle );
}
SIfprintf( outputf, "\tev_eventName\t= %s\n", eventParm->ev_eventName );
SIfprintf( outputf, "\tev_eventOwner\t= %s\n", eventParm->ev_eventOwner );
SIfprintf( outputf, "\tev_eventDB\t= %s\n", eventParm->ev_eventDB );
if ( verboseLevel >= 1 )
{
if ( eventParm->ev_eventTime.dv_null == TRUE )
SIfprintf( outputf, "\tev_eventTime = NULL\n" );
else
{
IIAPI_DESCRIPTOR descr;
descr.ds_dataType = IIAPI_DTE_TYPE;
descr.ds_nullable = FALSE;
descr.ds_length = eventParm->ev_eventTime.dv_length;
descr.ds_precision = 0;
descr.ds_scale = 0;
descr.ds_columnType = IIAPI_COL_TUPLE;
descr.ds_columnName = NULL;
SIfprintf( outputf, "\tev_eventTime\t= " );
ait_printData( &descr, &eventParm->ev_eventTime );
}
}
SIfprintf( outputf, "\t=========================\n" );
return;
}
char *
maperr(
STATUS rv)
{
char *ret_val;
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
SIfprintf( stderr,"Error: unexpected exception in maperr()...");
EXdelete();
return "";
}
#endif
switch( rv )
{
case E_CS0017_SMPR_DEADLOCK:
ret_val = "E_CS0017_SMPR_DEADLOCK";
break;
case E_CS000F_REQUEST_ABORTED:
ret_val = "E_CS000F_REQUEST_ABORTED";
break;
case E_CS000A_NO_SEMAPHORE:
ret_val = "E_CS000A_NO_SEMAPHORE";
break;
case OK:
ret_val = "";
break;
default:
ret_val = "Unknown exception";
break;
}
#ifdef EX_DEBUG
EXdelete();
#endif
return ret_val;
}
