/* * Altera o valor de uma variavel de memoria em nivel xBase. Retorna 1 se for * bem sucedido ou 0 em caso de erro. * 01/07/2008 - 17:12:17 */ int wxMemvarPut( char * szVarName, PHB_ITEM pValue ) { HB_DYNS_PTR pDyn; int result = 0; #ifdef HB_THREAD_SUPPORT HB_THREAD_STUB pDyn = s_memvarThFindName( szVarName, (HB_STACK *) &HB_VM_STACK ); #else pDyn = hb_dynsymFindName( szVarName ); #endif /* * Se a variavel não existir ... criamos ela aqui como pública! */ if( !pDyn ) { PHB_ITEM pMemvar = hb_itemNew( NULL ); hb_itemPutC( pMemvar, szVarName ); hb_memvarCreateFromItem( pMemvar, VS_PUBLIC, NULL ); hb_itemRelease( pMemvar ); #ifdef HB_THREAD_SUPPORT pDyn = s_memvarThFindName( szVarName, &HB_VM_STACK ); #else pDyn = hb_dynsymFindName( szVarName ); #endif } if( pDyn ) { /* there is dynamic symbol with the requested name - check if it is * a memvar variable */ if( pDyn->hMemvar ) { /* value is already created */ HB_ITEM_PTR pSetItem = hb_memvarGetValueByHandle( pDyn->hMemvar ); // JC1: the variable we have now can't be destroyed in the meanwhile. // It could be changed, but this is a race condition that must be // prevented at prg level. if( HB_IS_BYREF( pSetItem ) ) { pSetItem = hb_itemUnRef( pSetItem ); } hb_itemCopy( pSetItem, pValue ); result = 1; // Count this new value. /* s_globalTable[ pDyn->hMemvar ].counter = 1; */ } } return result; }
PHB_DYNS hb_dynsymFindNameWithNamespaces( const char * szName, const char *pNamespaces ) { if( pNamespaces ) { char *szNamespace = (char *) pNamespaces; PHB_DYNS pDynSym; char szUprName[ HB_SYMBOL_NAME_LEN + 1 ]; { int iLen = HB_SYMBOL_NAME_LEN; char * pDest = szUprName; do { char cChar = *szName++; if( cChar == 0 || cChar == ' ' || cChar == '\t' ) break; else if( cChar >= 'a' && cChar <= 'z' ) *pDest++ = cChar - ( 'a' - 'A' ); else *pDest++ = cChar; } while( --iLen ); *pDest = '\0'; } while ( *szNamespace ) { char *szQualified = hb_xstrcpy( NULL, szNamespace, ".", szUprName, NULL ); pDynSym = hb_dynsymFindName( szQualified ); hb_xfree( szQualified ); if( pDynSym ) { return pDynSym; } szNamespace += strlen( szNamespace ) + 1; } return NULL; } else { return hb_dynsymFindName( szName ); } }
PHB_ITEM hb_itemDoC( const char * szFunc, HB_ULONG ulPCount, ... ) { PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoC(%s, %lu, ...)", szFunc, ulPCount ) ); if( szFunc ) { PHB_DYNS pDynSym = hb_dynsymFindName( szFunc ); if( pDynSym ) { if( hb_vmRequestReenter() ) { hb_vmPushSymbol( pDynSym->pSymbol ); hb_vmPushNil(); if( ulPCount ) { HB_ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) hb_vmPush( va_arg( va, PHB_ITEM ) ); va_end( va ); } hb_vmProc( ( HB_USHORT ) ulPCount ); pResult = hb_itemNew( hb_stackReturnItem() ); hb_vmRequestRestore(); } } } return pResult; }
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo ) { PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) ); if( pEvalInfo ) { PHB_ITEM pItem = pEvalInfo->pItems[ 0 ]; PHB_SYMB pSymbol = NULL; if( HB_IS_STRING( pItem ) ) { PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value ); if( pDynSym ) { pSymbol = pDynSym->pSymbol; pItem = NULL; } } else if( HB_IS_SYMBOL( pItem ) ) { pSymbol = pItem->item.asSymbol.value; pItem = NULL; } else if( HB_IS_BLOCK( pItem ) ) { pSymbol = &hb_symEval; } if( pSymbol ) { HB_USHORT uiParam = 0; hb_vmPushSymbol( pSymbol ); if( pItem ) hb_vmPush( pItem ); else hb_vmPushNil(); while( uiParam < pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ ++uiParam ] ); if( pItem ) hb_vmSend( uiParam ); else hb_vmProc( uiParam ); pResult = hb_itemNew( hb_stackReturnItem() ); } } return pResult; }
static char * sz_callhrb_i( char * szName, int iParam1 ) { PHB_DYNS pSym_onEvent = hb_dynsymFindName( szName ); if( pSym_onEvent ) { hb_vmPushSymbol( hb_dynsymSymbol( pSym_onEvent ) ); hb_vmPushNil(); hb_vmPushInteger( iParam1 ); hb_vmDo( 1 ); return (char *) hb_parc(-1); } else return ""; }
static char * sz_callhrb_sz( char * szName, char * szParam1 ) { PHB_DYNS pSym_onEvent = hb_dynsymFindName( szName ); if( pSym_onEvent ) { hb_vmPushSymbol( hb_dynsymSymbol( pSym_onEvent ) ); hb_vmPushNil(); hb_vmPushString( szParam1, strlen( szParam1 ) ); hb_vmDo( 1 ); return (char *) hb_parc(-1); } else return ""; }
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo ) { HB_THREAD_STUB PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) ); if( pEvalInfo ) { register USHORT uiParam = 1; if( HB_IS_STRING( pEvalInfo->pItems[ 0 ] ) ) { const char * ptr = pEvalInfo->pItems[ 0 ]->item.asString.value; hb_vmPushSymbol( hb_dynsymFindName( ptr )->pSymbol ); hb_vmPushNil(); while( uiParam <= pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ uiParam++ ] ); hb_vmDo( pEvalInfo->paramCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); } else if( HB_IS_BLOCK( pEvalInfo->pItems[ 0 ] ) ) { hb_vmPushSymbol( &hb_symEval ); hb_vmPush( pEvalInfo->pItems[ 0 ] ); while( uiParam <= pEvalInfo->paramCount ) hb_vmPush( pEvalInfo->pItems[ uiParam++ ] ); hb_vmSend( pEvalInfo->paramCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); } } return pResult; }
/* NOTE: Same as hb_itemDo(), but even simpler, since the function name can be directly passed as a zero terminated string. [vszakats] */ PHB_ITEM hb_itemDoC( const char * szFunc, HB_SIZE ulPCount, ... ) { HB_THREAD_STUB PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoC(%s, %hu, ...)", szFunc, ulPCount ) ); if( szFunc ) { PHB_DYNS pDynSym; pDynSym = hb_dynsymFindName( szFunc ); if( pDynSym ) { hb_vmPushState(); hb_vmPushSymbol( pDynSym->pSymbol ); hb_vmPushNil(); if( ulPCount ) { register ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) hb_vmPush( va_arg( va, PHB_ITEM ) ); va_end( va ); } hb_vmDo( ( USHORT ) ulPCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); hb_vmPopState(); } } return pResult; }
PHB_DYNS hb_dynsymFindName_r( const char * szName, PHB_DYNS pDest ) { PHB_DYNS pRet; hb_dynsymLock(); pRet = hb_dynsymFindName( szName ); if( pRet ) { HB_MEMCPY( pDest, pRet, sizeof( HB_DYNS ) ); hb_dynsymUnlock(); return pDest; } hb_dynsymUnlock(); return NULL; }
/* * Find a WorkArea by the alias, return HB_FAILURE if not found */ HB_ERRCODE hb_rddGetAliasNumber( const char * szAlias, int * iArea ) { HB_BOOL fOneLetter; char c; HB_TRACE( HB_TR_DEBUG, ( "hb_rddGetAliasNumber(%s, %p)", szAlias, iArea ) ); while( *szAlias == ' ' ) szAlias++; c = szAlias[ 0 ]; if( c >= 'a' && c <= 'z' ) c -= 'a' - 'A'; fOneLetter = c && ( szAlias[ 1 ] == 0 || szAlias[ 1 ] == ' ' ); if( c >= '0' && c <= '9' ) { *iArea = atoi( szAlias ); } else if( fOneLetter && c >= 'A' && c <= 'K' ) { *iArea = c - 'A' + 1; } else if( fOneLetter && c == 'M' ) { *iArea = HB_RDD_MAX_AREA_NUM; } else { PHB_DYNS pSymAlias = hb_dynsymFindName( szAlias ); *iArea = pSymAlias ? ( int ) hb_dynsymAreaHandle( pSymAlias ) : 0; if( *iArea == 0 ) return HB_FAILURE; } return HB_SUCCESS; }
/* * Retorna uma STRING de uma variavel caracter do xHarbour, criada via .PRG! Ela * retorna em pulLen o tamanho da string encontrada. * 01/07/2008 - 08:40:47 */ char *wxMemvarGetCPtr( char * szVarName, ULONG *pulLen ) { HB_THREAD_STUB HB_DYNS_PTR pDynVar; char *szValue = NULL; HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen)); #ifdef HB_THREAD_SUPPORT pDynVar = s_memvarThFindName( szVarName, &HB_VM_STACK ); #else pDynVar = hb_dynsymFindName( szVarName ); #endif if( pDynVar ) { /* there is dynamic symbol with the requested name - check if it is * a memvar variable */ if( pDynVar->hMemvar ) { /* variable contains some data */ HB_ITEM_PTR pItem = hb_memvarGetValueByHandle( pDynVar->hMemvar ); if( HB_IS_BYREF( pItem ) ) { pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */ } if( HB_IS_STRING( pItem ) ) { szValue = pItem->item.asString.value; *pulLen = pItem->item.asString.length; } } } return szValue; }
/* * Retorna o valor LONG de uma variavel numérica do xHarbour, criada via .PRG * 01/07/2008 - 08:40:47 */ LONG wxMemvarGetNL( char * szVarName ) { HB_THREAD_STUB HB_DYNS_PTR pDynVar; LONG result = 0; HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen)); #ifdef HB_THREAD_SUPPORT pDynVar = s_memvarThFindName( szVarName, &HB_VM_STACK ); #else pDynVar = hb_dynsymFindName( szVarName ); #endif if( pDynVar ) { /* there is dynamic symbol with the requested name - check if it is * a memvar variable */ if( pDynVar->hMemvar ) { /* variable contains some data */ HB_ITEM_PTR pItem = hb_memvarGetValueByHandle( pDynVar->hMemvar ); if( HB_IS_BYREF( pItem ) ) { pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */ } if( HB_IS_NUMERIC( pItem ) ) { result = hb_itemGetNL( pItem ); } } } return result; }
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 HRESULT STDMETHODCALLTYPE GetIDsOfNames( IDispatch * lpThis, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId ) { HRESULT hr = S_OK; HB_SYMBOL_UNUSED( lcid ); if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) ) hr = DISP_E_UNKNOWNINTERFACE; else if( ( ( IHbOleServer * ) lpThis )->fGuids ) return E_NOTIMPL; else if( cNames > 0 ) { char szName[ HB_SYMBOL_NAME_LEN + 1 ]; DISPID dispid = 0; UINT ui; if( s_WideToAnsiBuffer( rgszNames[ 0 ], szName, ( int ) sizeof( szName ) ) != 0 ) { PHB_ITEM pAction; pAction = ( ( IHbOleServer * ) lpThis )->pAction; if( ! pAction ) pAction = s_pAction; if( pAction ) { if( s_pMsgHash ) { HB_SIZE nPos = hb_hashGetCItemPos( s_pMsgHash, szName ); if( nPos == 0 ) { PHB_ITEM pKey = hb_itemPutC( hb_stackAllocItem(), szName ); if( hb_hashAdd( s_pMsgHash, pKey, NULL ) ) hb_hashScan( s_pMsgHash, pKey, &nPos ); hb_stackPop(); } dispid = ( DISPID ) nPos; } else if( HB_IS_HASH( pAction ) ) { HB_SIZE nPos = hb_hashGetCItemPos( pAction, szName ); if( nPos ) dispid = ( DISPID ) nPos; } else if( HB_IS_OBJECT( pAction ) ) { PHB_DYNS pDynSym = hb_dynsymFindName( szName ); if( pDynSym && hb_objHasMessage( pAction, pDynSym ) ) dispid = hb_dynsymToDispId( pDynSym ); } } else { PHB_DYNS pDynSym = hb_dynsymFindName( szName ); if( pDynSym && ( hb_dynsymIsFunction( pDynSym ) || hb_dynsymIsMemvar( pDynSym ) ) ) dispid = hb_dynsymToDispId( pDynSym ); } } for( ui = 0; ui < cNames; ++ui ) rgDispId[ ui ] = DISPID_UNKNOWN; hr = DISP_E_UNKNOWNNAME; if( dispid ) { rgDispId[ 0 ] = dispid; if( cNames == 1 ) hr = S_OK; } } return hr; }
//------------------------------------------------------------------------------ // IEventHandler's Invoke() // self is where the action happens // self function receives events (by their ID number) and distributes the processing // or them or ignores them static ULONG STDMETHODCALLTYPE Invoke( IEventHandler *self, DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *pexcepinfo, UINT *puArgErr ) { PHB_ITEM pItem; int iArg, i; PHB_ITEM pItemArray[32]; // max 32 parameters? PHB_ITEM *pItems; ULONG ulRefMask = 0; ULONG ulPos; PHB_ITEM Key; Key = hb_itemNew( NULL ); // We implement only a "default" interface if ( !IsEqualIID( riid, &IID_NULL ) ) return( DISP_E_UNKNOWNINTERFACE ); HB_SYMBOL_UNUSED(lcid); HB_SYMBOL_UNUSED(wFlags); HB_SYMBOL_UNUSED(result); HB_SYMBOL_UNUSED(pexcepinfo); HB_SYMBOL_UNUSED(puArgErr); // delegate work to somewhere else in PRG //*************************************** #ifdef __USEHASHEVENTS if ( hb_hashScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ), &ulPos ) ) { PHB_ITEM pArray = hb_hashGetValueAt( ((MyRealIEventHandler* ) self)->pEvents, ulPos ); #else ulPos = hb_arrayScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ), NULL, NULL, 0 #ifdef __XHARBOUR__ , 0 #endif ); if ( ulPos ) { PHB_ITEM pArray = hb_arrayGetItemPtr( ((MyRealIEventHandler* ) self)->pEventsExec, ulPos ); #endif PHB_ITEM pExec = hb_arrayGetItemPtr( pArray, 01 ); if ( pExec ) { hb_vmRequestReenter(); switch ( hb_itemType( pExec ) ) { case HB_IT_BLOCK: { hb_vmPushSymbol( &hb_symEval ); hb_vmPush( pExec ); break; } case HB_IT_STRING: { PHB_ITEM pObject = hb_arrayGetItemPtr( pArray, 2 ); hb_vmPushSymbol( hb_dynsymSymbol( hb_dynsymFindName( hb_itemGetCPtr( pExec ) ) ) ); if ( HB_IS_OBJECT( pObject ) ) hb_vmPush( pObject ); else hb_vmPushNil(); break; } case HB_IT_POINTER: { hb_vmPushSymbol( hb_dynsymSymbol( ( (PHB_SYMB) pExec ) -> pDynSym ) ); hb_vmPushNil(); break; } } iArg = params->cArgs; for( i = 1; i<= iArg; i++ ) { pItem = hb_itemNew(NULL); hb_oleVariantToItem( pItem, &(params->rgvarg[iArg-i]) ); pItemArray[i-1] = pItem; // set bit i ulRefMask |= ( 1L << (i-1) ); } if( iArg ) { pItems = pItemArray; hb_itemPushList( ulRefMask, iArg, &pItems ); } // execute hb_vmDo( (USHORT) iArg ); // En caso de que los parametros sean pasados por referencia for( i=iArg; i > 0; i-- ) { if( ( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF ) == VT_BYREF ) { switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt ) { //case VT_UI1|VT_BYREF: // *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbVal) = va_arg(argList,unsigned char*); //pItemArray[i-1] // break; case VT_I2|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.piVal) = (short) hb_itemGetNI(pItemArray[i-1]); break; case VT_I4|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.plVal) = (long) hb_itemGetNL(pItemArray[i-1]); break; case VT_R4|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pfltVal) = (float) hb_itemGetND(pItemArray[i-1]); break; case VT_R8|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdblVal) = (double) hb_itemGetND(pItemArray[i-1]); break; case VT_BOOL|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pboolVal) = (VARIANT_BOOL) ( hb_itemGetL( pItemArray[i-1] ) ? 0xFFFF : 0 ); break; //case VT_ERROR|VT_BYREF: // *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pscode) = va_arg(argList, SCODE*); // break; case VT_DATE|VT_BYREF: *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdate) = (DATE) (double) (hb_itemGetDL(pItemArray[i-1])-2415019 ); break; //case VT_CY|VT_BYREF: // *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pcyVal) = va_arg(argList, CY*); // break; //case VT_BSTR|VT_BYREF: // *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbstrVal = va_arg(argList, BSTR*); // break; //case VT_UNKNOWN|VT_BYREF: // pArg->ppunkVal = va_arg(argList, LPUNKNOWN*); // break; //case VT_DISPATCH|VT_BYREF: // pArg->ppdispVal = va_arg(argList, LPDISPATCH*); // break; } // EOF switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt ) } // EOF if( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF == VT_BYREF ) } // EOF for( i=iArg; i > 0; i-- ) hb_vmRequestRestore(); } // EOF if ( pExec ) } // EOF If Scan hb_itemRelease( Key ); return S_OK; } // EOF invoke //------------------------------------------------------------------------------ // Here's IEventHandler's VTable. It never changes so we can declare it static static const IEventHandlerVtbl IEventHandler_Vtbl = { QueryInterface, AddRef, Release, GetTypeInfoCount, GetTypeInfo, GetIDsOfNames, Invoke }; //------------------------------------------------------------------------------ // constructor // params: // device_interface - refers to the interface type of the COM object (whose event we are trying to receive). // device_event_interface - indicates the interface type of the outgoing interface supported by the COM object. // This will be the interface that must be implemented by the Sink object. // is essentially derived from IDispatch, our Sink object (self IEventHandler) // is also derived from IDispatch. typedef IEventHandler device_interface; // Hash // SetupConnectionPoint( oOle:hObj, @hSink, hEvents ) -> nError // Array // SetupConnectionPoint( oOle:hObj, @hSink, aEvents, aExecEvent ) -> nError HB_FUNC( SETUPCONNECTIONPOINT ) { IConnectionPointContainer* pIConnectionPointContainerTemp = NULL; IUnknown* pIUnknown = NULL; IConnectionPoint* m_pIConnectionPoint; IEnumConnectionPoints* m_pIEnumConnectionPoints; HRESULT hr; //,r; IID rriid; register IEventHandler * selfobj; DWORD dwCookie = 0; device_interface* pdevice_interface = (device_interface*) HB_PARNL( 1 ); MyRealIEventHandler* pThis; // Allocate our IEventHandler object (actually a MyRealIEventHandler) // intentional misrepresentation of size selfobj = ( IEventHandler *) GlobalAlloc( GMEM_FIXED, sizeof( MyRealIEventHandler ) ); if ( ! selfobj ) { hr = E_OUTOFMEMORY; } else { // Store IEventHandler's VTable in the object selfobj->lpVtbl = (IEventHandlerVtbl *) &IEventHandler_Vtbl; // Increment the reference count so we can call Release() below and // it will deallocate only if there is an error with QueryInterface() ((MyRealIEventHandler *) selfobj)->count = 0; //((MyRealIEventHandler *) selfobj)->device_event_interface_iid = &riid; ((MyRealIEventHandler *) selfobj)->device_event_interface_iid = IID_IDispatch; // Query self object itself for its IUnknown pointer which will be used // later to connect to the Connection Point of the device_interface object. hr = selfobj->lpVtbl->QueryInterface( selfobj, &IID_IUnknown, (void**) (void *) &pIUnknown ); if ( hr == S_OK && pIUnknown ) { // Query the pdevice_interface for its connection point. hr = pdevice_interface->lpVtbl->QueryInterface( pdevice_interface, &IID_IConnectionPointContainer, (void**) (void *) &pIConnectionPointContainerTemp ); if ( hr == S_OK && pIConnectionPointContainerTemp ) { // start uncomment hr = pIConnectionPointContainerTemp->lpVtbl->EnumConnectionPoints( pIConnectionPointContainerTemp, &m_pIEnumConnectionPoints ); if ( hr == S_OK && m_pIEnumConnectionPoints ) { do { hr = m_pIEnumConnectionPoints->lpVtbl->Next( m_pIEnumConnectionPoints, 1, &m_pIConnectionPoint , NULL); if( hr == S_OK ) { if ( m_pIConnectionPoint->lpVtbl->GetConnectionInterface( m_pIConnectionPoint, &rriid ) == S_OK ) { break; } } } while( hr == S_OK ); m_pIEnumConnectionPoints->lpVtbl->Release(m_pIEnumConnectionPoints); } // end uncomment //hr = pIConnectionPointContainerTemp ->lpVtbl->FindConnectionPoint(pIConnectionPointContainerTemp , &IID_IDispatch, &m_pIConnectionPoint); pIConnectionPointContainerTemp->lpVtbl->Release( pIConnectionPointContainerTemp ); pIConnectionPointContainerTemp = NULL; } if ( hr == S_OK && m_pIConnectionPoint ) { //OutputDebugString("getting iid"); //Returns the IID of the outgoing interface managed by self connection point. //hr = m_pIConnectionPoint->lpVtbl->GetConnectionInterface(m_pIConnectionPoint, &rriid ); //OutputDebugString("called"); if( hr == S_OK ) { ((MyRealIEventHandler *) selfobj)->device_event_interface_iid = rriid; } else OutputDebugString("error getting iid"); //OutputDebugString("calling advise"); hr = m_pIConnectionPoint->lpVtbl->Advise( m_pIConnectionPoint, pIUnknown, &dwCookie ); ((MyRealIEventHandler *) selfobj)->pIConnectionPoint = m_pIConnectionPoint; ((MyRealIEventHandler *) selfobj)->dwEventCookie = dwCookie; } pIUnknown->lpVtbl->Release(pIUnknown); pIUnknown = NULL; } } if( selfobj ) { pThis = (MyRealIEventHandler *) selfobj; #ifndef __USEHASHEVENTS pThis->pEventsExec = hb_itemNew( hb_param( 4, HB_IT_ANY ) ); #endif pThis->pEvents = hb_itemNew( hb_param( 3, HB_IT_ANY ) ); HB_STORNL2( (LONG_PTR) pThis, 2 ); } HWNDret( hr ); } //------------------------------------------------------------------------------ HB_FUNC( SHUTDOWNCONNECTIONPOINT ) { MyRealIEventHandler *self = ( MyRealIEventHandler * ) HB_PARNL( 1 ); if( self->pIConnectionPoint ) { self->pIConnectionPoint->lpVtbl->Unadvise( self->pIConnectionPoint, self->dwEventCookie ); self->dwEventCookie = 0; self->pIConnectionPoint->lpVtbl->Release( self->pIConnectionPoint ); self->pIConnectionPoint = NULL; } } //------------------------------------------------------------------------------ HB_FUNC( RELEASEDISPATCH ) { IDispatch * pObj; pObj = ( IDispatch * ) HWNDparam( 1 ); pObj->lpVtbl->Release( pObj ); }
/* NOTE: Same as hb_itemDoC(), but has additional second parameter which set the reference mask for 1-st 32/64 parametes [druzus] */ PHB_ITEM hb_itemDoCRef( char * szFunc, HB_SIZE ulRefMask, HB_SIZE ulPCount, ... ) { HB_THREAD_STUB PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoCRef(%s, %hu, %hu, ...)", szFunc, ulRefMask, ulPCount ) ); if( szFunc ) { PHB_DYNS pDynSym; pDynSym = hb_dynsymFindName( szFunc ); if( pDynSym ) { hb_vmPushState(); hb_vmPushSymbol( pDynSym->pSymbol ); hb_vmPushNil(); if( ulPCount ) { PHB_ITEM pItemRefBuf[ sizeof( HB_SIZE ) * 8 ]; HB_ITEM itmRef; register HB_SIZE ulParam; HB_SIZE ulRef = 0; va_list va; PHB_ITEM * pRefBase; PHB_ITEM pParam; pRefBase = pItemRefBuf; /* initialize the reference item */ itmRef.type = HB_IT_BYREF; itmRef.item.asRefer.offset = -1; itmRef.item.asRefer.BasePtr.itemsbasePtr = &pRefBase; va_start( va, ulPCount ); for( ulParam = 0; ulParam < ulPCount; ulParam++ ) { pParam = va_arg( va, PHB_ITEM ); if( ulRefMask & ( 1L << ulParam ) ) { /* when item is passed by reference then we have to put * the reference on the stack instead of the item itself */ pItemRefBuf[ ulRef++ ] = pParam; itmRef.item.asRefer.value = ( LONG ) ulRef; /* hb_vmPush( &itmRef ); */ pParam = &itmRef; } hb_vmPush( pParam ); } va_end( va ); } hb_vmDo( ( USHORT ) ulPCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); hb_vmPopState(); } } return pResult; }
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_ULONG ulPCount, ... ) { PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %lu, ...)", pItem, ulPCount ) ); if( pItem ) { PHB_SYMB pSymbol = NULL; if( HB_IS_STRING( pItem ) ) { PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value ); if( pDynSym ) { pSymbol = pDynSym->pSymbol; pItem = NULL; } } else if( HB_IS_SYMBOL( pItem ) ) { pSymbol = pItem->item.asSymbol.value; pItem = NULL; } else if( HB_IS_BLOCK( pItem ) ) { pSymbol = &hb_symEval; } if( pSymbol ) { if( hb_vmRequestReenter() ) { hb_vmPushSymbol( pSymbol ); if( pItem ) hb_vmPush( pItem ); else hb_vmPushNil(); if( ulPCount ) { HB_ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) hb_vmPush( va_arg( va, PHB_ITEM ) ); va_end( va ); } if( pItem ) hb_vmSend( ( HB_USHORT ) ulPCount ); else hb_vmProc( ( HB_USHORT ) ulPCount ); pResult = hb_itemNew( hb_stackReturnItem() ); hb_vmRequestRestore(); } } } return pResult; }
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_SIZE ulPCount, ... ) { HB_THREAD_STUB PHB_ITEM pResult = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %hu, ...)", pItem, ulPCount ) ); if( pItem ) { PHB_SYMB pSymbol = NULL; if( HB_IS_STRING( pItem ) ) { PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value ); if( pDynSym ) pSymbol = pDynSym->pSymbol; } else if( HB_IS_POINTER( pItem ) ) pSymbol = ( PHB_SYMB ) pItem->item.asPointer.value; else if( HB_IS_SYMBOL( pItem ) ) pSymbol = pItem->item.asSymbol.value; if( pSymbol ) { hb_vmPushState(); hb_vmPushSymbol( pSymbol ); hb_vmPushNil(); if( ulPCount ) { register ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) hb_vmPush( va_arg( va, PHB_ITEM ) ); va_end( va ); } hb_vmDo( ( USHORT ) ulPCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); hb_vmPopState(); } else if( HB_IS_BLOCK( pItem ) ) { hb_vmPushState(); hb_vmPushSymbol( &hb_symEval ); hb_vmPush( pItem ); if( ulPCount ) { register ULONG ulParam; va_list va; va_start( va, ulPCount ); for( ulParam = 1; ulParam <= ulPCount; ulParam++ ) hb_vmPush( va_arg( va, PHB_ITEM ) ); va_end( va ); } hb_vmSend( ( USHORT ) ulPCount ); pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); hb_vmPopState(); } else if( HB_IS_ARRAY( pItem ) ) { hb_vmPushState(); if( hb_execFromArray( pItem ) ) { pResult = hb_itemNew( NULL ); hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) ); } hb_vmPopState(); } } return pResult; }
BOOL hb_execFromArray( PHB_ITEM pFirst ) { register ULONG i; HB_SIZE ulLen; ULONG ulStart = 1; PHB_ITEM pArgs; PHB_ITEM pString; PHB_ITEM pSelf = NULL; PHB_DYNS pExecSym = NULL; PHB_SYMB pSymbol = NULL; if( pFirst == NULL || pFirst->type != HB_IT_ARRAY ) return FALSE; pString = hb_arrayGetItemPtr( pFirst, 1 ); pArgs = pFirst; if( HB_IS_OBJECT( pString ) && hb_arrayLen( pFirst ) >= 2 ) { pSelf = pString; pString = hb_arrayGetItemPtr( pFirst, 2 ); if( pString->type == HB_IT_STRING ) pExecSym = hb_dynsymFindName( pString->item.asString.value ); else if( pString->type == HB_IT_POINTER ) pSymbol = ( PHB_SYMB ) hb_itemGetPtr( pString ); ulStart = 3; } else if( pString->type == HB_IT_STRING ) { pExecSym = hb_dynsymFindName( pString->item.asString.value ); ulStart = 2; } else if( pString->type == HB_IT_POINTER ) { pSymbol = ( PHB_SYMB ) hb_itemGetPtr( pString ); ulStart = 2; } else if( HB_IS_BLOCK( pString ) ) { pSymbol = &hb_symEval; ulStart = 2; } if( pExecSym ) pSymbol = pExecSym->pSymbol; if( pSymbol == NULL ) return FALSE; hb_vmPushSymbol( pSymbol ); if( pSelf ) hb_vmPush( pSelf ); else hb_vmPushNil(); ulLen = hb_arrayLen( pArgs ); /* pushing the contents of the array */ for( i = ulStart; i <= ulLen; i++ ) hb_vmPush( hb_arrayGetItemPtr( pArgs, i ) ); if( pSelf ) hb_vmSend( ( USHORT ) ( ulLen - ulStart + 1 ) ); else hb_vmDo( ( USHORT ) ( ulLen - ulStart + 1 ) ); return TRUE; }