PHB_ITEM hb_errPutArgs( PHB_ITEM pError, HB_ULONG ulArgCount, ... )
{
PHB_ITEM pArray;
HB_ULONG ulArgPos;
va_list va;
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutArgs(%p, %lu, ...)", pError, ulArgCount ) );
pArray = hb_itemArrayNew( ulArgCount );
/* Build the array from the passed arguments. */
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
hb_itemArrayPut( pArray, ulArgPos, va_arg( va, PHB_ITEM ) );
va_end( va );
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
return pError;
}
HB_USHORT hb_errRT_BASE( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... )
{
HB_USHORT uiAction;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
HB_ULONG ulArgPos;
/* I replaced EF_CANRETRY with EF_NONE for Clipper compatibility
* If it's wrong and I missed something please fix me, Druzus.
*/
pError = hb_errRT_New( ES_ERROR, HB_ERR_SS_BASE, errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE /* EF_CANRETRY */ );
/* Build the array from the passed arguments. */
switch( ulArgCount )
{
case 0:
pArray = NULL;
break;
case HB_ERR_ARGS_BASEPARAMS:
pArray = hb_pcount() ? hb_arrayBaseParams() : NULL;
break;
case HB_ERR_ARGS_SELFPARAMS:
pArray = hb_arraySelfParams();
break;
default:
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
uiAction = hb_errLaunch( pError );
/* Release. */
hb_errRelease( pError );
return uiAction;
}
PHB_ITEM hb_errRT_BASE_Subst( HB_ERRCODE errGenCode, HB_ERRCODE errSubCode, const char * szDescription, const char * szOperation, HB_ULONG ulArgCount, ... )
{
PHB_ITEM pRetVal;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
HB_ULONG ulArgPos;
pError = hb_errRT_New_Subst( ES_ERROR, HB_ERR_SS_BASE, errGenCode, errSubCode, szDescription, szOperation, 0, EF_NONE );
/* Build the array from the passed arguments. */
switch( ulArgCount )
{
case 0:
pArray = NULL;
break;
case HB_ERR_ARGS_BASEPARAMS:
pArray = hb_pcount() ? hb_arrayBaseParams() : NULL;
break;
case HB_ERR_ARGS_SELFPARAMS:
pArray = hb_arraySelfParams();
break;
default:
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
PHB_ITEM pArg = va_arg( va, PHB_ITEM );
if( pArg )
hb_itemArrayPut( pArray, ulArgPos, pArg );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_errPutArgsArray( pError, pArray );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* Ok, launch... */
pRetVal = hb_errLaunchSubst( pError );
hb_errRelease( pError );
return pRetVal;
}
/*
* Add <pItem> to array <pReturn> at pos <uiPos>
* AddToArray( <pItem>, <pReturn>, <uiPos> )
*/
static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, HB_SIZE nPos )
{
HB_TRACE( HB_TR_DEBUG, ( "AddToArray(%p, %p, %" HB_PFS "u)", pItem, pReturn, nPos ) );
if( HB_IS_SYMBOL( pItem ) ) /* Symbol is pushed as text */
{
PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, nPos );
if( pArrayItem )
{
HB_SIZE nLen = strlen( pItem->item.asSymbol.value->szName ) + 2;
char * szBuff = ( char * ) hb_xgrab( nLen + 1 );
hb_snprintf( szBuff, nLen + 1, "[%s]", pItem->item.asSymbol.value->szName );
hb_itemPutCLPtr( pArrayItem, szBuff, nLen );
}
}
else /* Normal types */
hb_itemArrayPut( pReturn, nPos, pItem );
}
static int hb_matherrblock( HB_MATH_EXCEPTION * pexc )
{
PHB_MATHERRDATA pMathErr = hb_mathErrData();
int retval;
/* call codeblock for both case: handled and unhandled exceptions */
if( pMathErr->block )
{
PHB_ITEM pArray, pRet;
PHB_ITEM pType, pFuncname, pError, pArg1, pArg2, pRetval, pHandled;
const char * funcname = pexc->funcname;
if( funcname == HB_ERR_FUNCNAME )
{
PHB_SYMB pSym = hb_itemGetSymbol( hb_stackBaseItem() );
if( pSym )
funcname = pSym->szName;
}
pType = hb_itemPutNI( NULL, pexc->type );
pFuncname = hb_itemPutC( NULL, funcname );
pError = hb_itemPutC( NULL, pexc->error );
pArg1 = hb_itemPutND( NULL, pexc->arg1 );
pArg2 = hb_itemPutND( NULL, pexc->arg2 );
pRetval = hb_itemPutNDLen( NULL, pexc->retval, pexc->retvalwidth, pexc->retvaldec );
pHandled = hb_itemPutL( NULL, pexc->handled );
pArray = hb_itemArrayNew( 2 );
hb_itemArrayPut( pArray, 1, pRetval );
hb_itemArrayPut( pArray, 2, pHandled );
/* launch error codeblock that can
a) change the members of the array = {dRetval, lHandled} to set the
return value of the math C RTL routine and the <exception handled
flag> and it
b) can return an integer value to set the return value of matherr().
NOTE that these values are only used if lHandled was .F. and is set
to .T. within the codeblock */
pRet = hb_itemDo( pMathErr->block, 6, pType, pFuncname, pError, pArg1, pArg2, pArray );
hb_itemRelease( pType );
hb_itemRelease( pFuncname );
hb_itemRelease( pError );
hb_itemRelease( pArg1 );
hb_itemRelease( pArg2 );
hb_itemRelease( pRetval );
hb_itemRelease( pHandled );
if( pexc->handled )
{
/* math exception has already been handled, so codeblock call above
was only informative */
retval = 1;
}
else
{
/* exception handled by codeblock ? */
pHandled = hb_itemArrayGet( pArray, 2 );
if( pHandled )
{
pexc->handled = hb_itemGetL( pHandled );
hb_itemRelease( pHandled );
}
if( pexc->handled )
{
/* YES ! */
/* extract retval for math routine and matherr() */
pRetval = hb_itemArrayGet( pArray, 1 );
if( pRetval )
{
pexc->retval = hb_itemGetND( pRetval );
hb_itemGetNLen( pRetval, &pexc->retvalwidth, &pexc->retvaldec );
hb_itemRelease( pRetval );
}
if( pRet && HB_IS_NUMERIC( pRet ) )
{
retval = hb_itemGetNI( pRet ); /* block may also return 0 to force C math lib warnings */
hb_itemRelease( pRet );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
}
else
{
/* NO ! */
retval = 1;
}
}
hb_itemRelease( pArray );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
if( pMathErr->prevHandler )
{
if( pexc->handled )
{
/* the error is handled, so simply inform the previous handler */
( *pMathErr->prevHandler )( pexc );
}
else
{
/* else go on error handling within previous handler */
retval = ( *pMathErr->prevHandler )( pexc );
}
}
return retval;
}
/* throwing a CT-subsystem error without value substitution
- function adapted from errorapi.c */
HB_USHORT ct_error( HB_USHORT uiSeverity, HB_ERRCODE errGenCode, HB_ERRCODE errSubCode,
const char * szDescription, const char * szOperation,
HB_ERRCODE errOsCode, HB_USHORT uiFlags, HB_ULONG ulArgCount, ... )
{
HB_USHORT uiAction;
PHB_ITEM pError;
PHB_ITEM pArray;
va_list va;
HB_ULONG ulArgPos;
HB_TRACE( HB_TR_DEBUG, ( "ct_error(%hu, %d, %d, %s, %s, %d, %hu, %lu)",
uiSeverity, errGenCode, errSubCode, szDescription, szOperation, errOsCode, uiFlags, ulArgCount ) );
pError = hb_errRT_New( uiSeverity, CT_SUBSYSTEM, errGenCode, errSubCode, szDescription, szOperation, errOsCode, uiFlags );
/* Build the array from the passed arguments. */
if( ulArgCount == 0 )
{
pArray = NULL;
}
else if( ulArgCount == HB_ERR_ARGS_BASEPARAMS )
{
if( hb_pcount() == 0 )
pArray = NULL;
else
pArray = hb_arrayBaseParams();
}
else if( ulArgCount == HB_ERR_ARGS_SELFPARAMS )
{
pArray = hb_arraySelfParams();
}
else
{
pArray = hb_itemArrayNew( ulArgCount );
va_start( va, ulArgCount );
for( ulArgPos = 1; ulArgPos <= ulArgCount; ulArgPos++ )
{
hb_itemArrayPut( pArray, ulArgPos, va_arg( va, PHB_ITEM ) );
}
va_end( va );
}
if( pArray )
{
/* Assign the new array to the object data item. */
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmSend( 1 );
/* Release the Array. */
hb_itemRelease( pArray );
}
/* launch error codeblock */
uiAction = hb_errLaunch( pError );
/* release error codeblock */
hb_errRelease( pError );
return uiAction;
}
