PHB_ITEM hb_errPutOperation( PHB_ITEM pError, const char * szOperation )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errPutOperation(%p, %s)", pError, szOperation == HB_ERR_FUNCNAME ? "HB_ERR_FUNCNAME" : szOperation ) );
if( szOperation == HB_ERR_FUNCNAME )
{
PHB_SYMB pSym = hb_itemGetSymbol( hb_stackBaseItem() );
if( pSym )
szOperation = pSym->szName;
}
hb_arraySetC( pError, HB_TERROR_OPERATION, szOperation );
return pError;
}
static HRESULT STDMETHODCALLTYPE Invoke( IDispatch * lpThis, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS * pParams,
VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
UINT * puArgErr )
{
PHB_DYNS pDynSym;
PHB_ITEM pAction;
HB_USHORT uiClass = 0;
HB_SYMBOL_UNUSED( lcid );
HB_SYMBOL_UNUSED( pExcepInfo );
HB_SYMBOL_UNUSED( puArgErr );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
return DISP_E_UNKNOWNINTERFACE;
pAction = ( ( IHbOleServer * ) lpThis )->pAction;
if( ! pAction )
pAction = s_pAction;
if( pAction )
{
HB_BOOL fResult = HB_FALSE;
if( s_pMsgHash )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 ||
( ( wFlags & DISPATCH_PROPERTYGET ) != 0 && pParams->cArgs == 0 ) ||
( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 && pParams->cArgs == 1 ) )
{
fResult = hb_oleDispInvoke( NULL, pAction,
hb_hashGetKeyAt( s_pMsgHash, ( HB_SIZE ) dispid ),
pParams, pVarResult, s_objItemToVariant, uiClass );
}
}
else if( HB_IS_HASH( pAction ) )
{
PHB_ITEM pItem;
if( ( ( IHbOleServer * ) lpThis )->fGuids )
{
PHB_ITEM pKey = hb_itemPutNL( hb_stackAllocItem(), ( long ) dispid );
pItem = hb_hashGetItemPtr( pAction, pKey, 0 );
hb_stackPop();
}
else
pItem = hb_hashGetValueAt( pAction, ( HB_SIZE ) dispid );
if( pItem )
{
if( HB_IS_EVALITEM( pItem ) )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 )
{
PHB_SYMB pSym = hb_itemGetSymbol( pItem );
fResult = hb_oleDispInvoke( pSym, pSym ? pAction : pItem, NULL,
pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) != 0 &&
pParams->cArgs == 0 )
{
if( pVarResult )
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
fResult = HB_TRUE;
}
else if( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 &&
pParams->cArgs == 1 )
{
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
fResult = HB_TRUE;
}
}
}
else if( HB_IS_OBJECT( pAction ) )
{
pDynSym = hb_dispIdToDynsym( dispid );
if( pDynSym && ( wFlags & DISPATCH_PROPERTYPUT ) != 0 )
{
if( pParams->cArgs == 1 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
szName[ 0 ] = '_';
hb_strncpy( szName + 1, hb_dynsymName( pDynSym ), sizeof( szName ) - 2 );
pDynSym = hb_dynsymFindName( szName );
}
else
pDynSym = NULL;
}
if( pDynSym && hb_objHasMessage( pAction, pDynSym ) )
{
fResult = hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
pAction, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
if( ! fResult )
return DISP_E_MEMBERNOTFOUND;
}
else
{
pDynSym = hb_dispIdToDynsym( dispid );
if( ! pDynSym )
return DISP_E_MEMBERNOTFOUND;
if( wFlags & DISPATCH_PROPERTYPUT )
{
if( pParams->cArgs == 1 && hb_dynsymIsMemvar( pDynSym ) )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
hb_memvarSetValue( hb_dynsymSymbol( pDynSym ), pItem );
hb_stackPop();
return S_OK;
}
else
return DISP_E_MEMBERNOTFOUND;
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) &&
pParams->cArgs == 0 && hb_dynsymIsMemvar( pDynSym ) )
{
if( pVarResult )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_memvarGet( pItem, hb_dynsymSymbol( pDynSym ) );
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
hb_stackPop();
}
return S_OK;
}
else if( ( wFlags & DISPATCH_METHOD ) == 0 ||
! hb_dynsymIsFunction( pDynSym ) )
return DISP_E_MEMBERNOTFOUND;
else if( ! hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
NULL, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass ) )
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}
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;
}
HB_BOOL hb_execFromArray( PHB_ITEM pParam )
{
PHB_ITEM pArray = NULL;
PHB_ITEM pSelf = NULL;
HB_ULONG ulParamOffset = 0;
if( pParam && HB_IS_ARRAY( pParam ) && ! HB_IS_OBJECT( pParam ) )
{
pArray = pParam;
pParam = hb_arrayGetItemPtr( pArray, 1 );
if( HB_IS_OBJECT( pParam ) )
{
pSelf = pParam;
pParam = hb_arrayGetItemPtr( pArray, 2 );
ulParamOffset = 2;
}
else
ulParamOffset = 1;
}
if( pParam )
{
PHB_SYMB pExecSym = NULL;
if( HB_IS_SYMBOL( pParam ) )
pExecSym = hb_itemGetSymbol( pParam );
else if( HB_IS_STRING( pParam ) )
pExecSym = hb_dynsymGet( hb_itemGetCPtr( pParam ) )->pSymbol;
else if( HB_IS_BLOCK( pParam ) && ! pSelf )
{
pSelf = pParam;
pExecSym = &hb_symEval;
}
if( pExecSym )
{
int iPCount = 0;
hb_vmPushSymbol( pExecSym );
if( pSelf )
hb_vmPush( pSelf );
else
hb_vmPushNil();
if( pArray )
{
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
while( pParam && iPCount < 255 )
{
hb_vmPush( pParam );
++iPCount;
pParam = hb_arrayGetItemPtr( pArray, ++ulParamOffset );
}
}
if( pSelf )
hb_vmSend( ( HB_USHORT ) iPCount );
else
hb_vmProc( ( HB_USHORT ) iPCount );
return HB_TRUE;
}
}
hb_errRT_BASE_SubstR( EG_ARG, 1099, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
return HB_FALSE;
}