PHB_ITEM hb_socketItemPut( PHB_ITEM pItem, HB_SOCKET sd )
{
HB_SOCKET * pSocket = ( HB_SOCKET * ) hb_gcAllocate( sizeof( HB_SOCKET ), &s_gcSocketFuncs );
*pSocket = sd;
return hb_itemPutPtrGC( pItem, pSocket );
}
static void s_listenRet( HB_SOCKET sd, const char * szRootPath, HB_BOOL rpc )
{
if( sd != HB_NO_SOCKET )
{
PHB_LISTENSD lsd, * lsd_ptr;
int iLen;
lsd = ( PHB_LISTENSD ) memset( hb_xgrab( sizeof( HB_LISTENSD ) ),
0, sizeof( HB_LISTENSD ) );
lsd->sd = sd;
lsd->rpc = rpc;
if( szRootPath )
hb_strncpy( lsd->rootPath, szRootPath, sizeof( lsd->rootPath ) - 1 );
else
hb_fsBaseDirBuff( lsd->rootPath );
iLen = ( int ) strlen( lsd->rootPath );
if( iLen > 0 )
{
if( ! s_isDirSep( lsd->rootPath[ iLen - 1 ] ) )
{
if( iLen == sizeof( lsd->rootPath ) - 1 )
--iLen;
lsd->rootPath[ iLen ] = HB_OS_PATH_DELIM_CHR;
}
}
lsd_ptr = ( PHB_LISTENSD * ) hb_gcAllocate( sizeof( PHB_LISTENSD ),
&s_gcListensdFuncs );
*lsd_ptr = lsd;
hb_retptrGC( lsd_ptr );
}
else
hb_ret();
}
PHB_ITEM hb_fileItemPut( PHB_ITEM pItem, PHB_FILE pFile )
{
PHB_FILE * fileHolder = ( PHB_FILE * ) hb_gcAllocate( sizeof( PHB_FILE ),
&s_gcFileFuncs );
* fileHolder = pFile;
return hb_itemPutPtrGC( pItem, fileHolder );
}
static void hb_SQLHSTMT_stor( PHB_ITEM pHDbcItm, SQLHSTMT hStmt, int iParam )
{
PHB_SQLHSTMT pHStmt = ( PHB_SQLHSTMT ) hb_gcAllocate( sizeof( HB_SQLHSTMT ), &s_gcSQLHSTMTFuncs );
pHStmt->hStmt = hStmt;
pHStmt->conn_counter = 0;
/* initialize pointer scanned by mark function before allocating new
* new GC block - such allocation may activate GC and uninitalized
* pointer will be accessed from our mark function
*/
pHStmt->pHDbcItm = NULL;
if( pHDbcItm )
{
PHB_SQLHDBC pHDbc = hb_SQLHDBC_get( pHDbcItm );
if( pHDbc )
{
pHStmt->conn_counter = pHDbc->conn_counter;
pHStmt->pHDbcItm = hb_itemNew( pHDbcItm );
hb_gcUnlock( pHStmt->pHDbcItm );
}
}
hb_storptrGC( ( void * ) pHStmt, iParam );
}
PHB_ITEM hb_cairoPatternItemPut( PHB_ITEM pItem, cairo_pattern_t * pPattern )
{
cairo_pattern_t ** ppPattern = ( cairo_pattern_t ** ) hb_gcAllocate( sizeof( cairo_pattern_t * ), &s_gcPatternFuncs );
*ppPattern = pPattern;
return hb_itemPutPtrGC( pItem, ppPattern );
}
PHB_ITEM hb_sockexItemPut( PHB_ITEM pItem, PHB_SOCKEX pSock )
{
PHB_SOCKEX * pSockPtr = ( PHB_SOCKEX * ) hb_gcAllocate( sizeof( PHB_SOCKEX ), &s_gcSocketFuncs );
*pSockPtr = pSock;
return hb_itemPutPtrGC( pItem, pSockPtr );
}
PHB_ITEM hb_socketItemPut( PHB_ITEM pItem, HB_SOCKET sd )
{
PHB_SOCKEX * pSockPtr = ( PHB_SOCKEX * ) hb_gcAllocate( sizeof( PHB_SOCKEX ), &s_gcSocketFuncs );
*pSockPtr = hb_sockexNew( sd, NULL, NULL );
return hb_itemPutPtrGC( pItem, pSockPtr );
}
static void hb_hrbReturn( PHRB_BODY pHrbBody )
{
PHRB_BODY * pHrbPtr = ( PHRB_BODY * ) hb_gcAllocate( sizeof( PHRB_BODY ),
&s_gcHrbFuncs );
*pHrbPtr = pHrbBody;
hb_retptrGC( pHrbPtr );
}
static void hb_SQLHENV_stor( SQLHENV hEnv, int iParam )
{
PHB_SQLHENV pHEnv = ( PHB_SQLHENV ) hb_gcAllocate( sizeof( HB_SQLHENV ), &s_gcSQLHENVFuncs );
pHEnv->hEnv = hEnv;
hb_storptrGC( ( void * ) pHEnv, iParam );
}
static void hb_BIO_ret( BIO * bio, char * pszBuffer )
{
HB_BIO ** ptr = ( HB_BIO ** ) hb_gcAllocate( sizeof( HB_BIO * ), &s_gcBIOFuncs );
*ptr = PHB_BIO_create( bio, pszBuffer );
hb_retptrGC( ( void * ) ptr );
}
PHB_ITEM hb_dbTransInfoPut( PHB_ITEM pItem, LPDBTRANSINFO lpdbTransInfo )
{
LPDBTRANSINFO * pHolder;
pHolder = ( LPDBTRANSINFO * ) hb_gcAllocate( sizeof( LPDBTRANSINFO ), &s_gcTransInfo );
*pHolder = lpdbTransInfo;
return hb_itemPutPtrGC( pItem, pHolder );
}
void hb_X509_ret( X509 * x509, HB_BOOL fRelease )
{
PHB_X509 ph = ( PHB_X509 ) hb_gcAllocate( sizeof( HB_X509 ), &s_gcX509_funcs );
ph->pX509 = x509;
ph->fRelease = fRelease;
hb_retptrGC( ( void * ) ph );
}
static HBMXML_NODE * mxml_node_new( mxml_node_t * node, int iNew )
{
HBMXML_NODE * pHbnode = ( HBMXML_NODE * ) hb_gcAllocate( sizeof( HBMXML_NODE ),
&s_gc_mxml_nodeFuncs );
pHbnode->node = node;
if( iNew == 0 )
mxmlRetain( node );
return pHbnode;
}
static void s_consrvRet( PHB_CONSRV conn )
{
if( conn )
{
PHB_CONSRV * conn_ptr = ( PHB_CONSRV * ) hb_gcAllocate( sizeof( PHB_CONSRV ),
&s_gcConSrvFuncs );
*conn_ptr = conn;
hb_retptrGC( conn_ptr );
}
else
hb_ret();
}
static void hb_fileReturn( PHB_FILE pFile )
{
if( pFile )
{
PHB_FILE * fileHolder = ( PHB_FILE * ) hb_gcAllocate( sizeof( PHB_FILE ),
&s_gcFileFuncs );
* fileHolder = pFile;
hb_retptrGC( fileHolder );
}
else
hb_ret();
}
static void hb_MYSQL_ret( MYSQL * p )
{
if( p )
{
void ** ph = ( void ** ) hb_gcAllocate( sizeof( MYSQL * ), &s_gcMYSQLFuncs );
*ph = p;
hb_retptrGC( ph );
}
else
hb_retptr( NULL );
}
static PHB_ITEM hb_i18n_newitem( PHB_I18N_TRANS pI18N )
{
PHB_I18N_TRANS * pI18NHolder;
PHB_ITEM pItem = hb_itemNew( NULL );
if( ! pI18N )
pI18N = hb_i18n_new();
pI18NHolder = ( PHB_I18N_TRANS * )
hb_gcAllocate( sizeof( PHB_I18N_TRANS ), &s_gcI18NFuncs );
*pI18NHolder = pI18N;
return hb_itemPutPtrGC( pItem, pI18NHolder );
}
void hb_PGconn_ret( PGconn * p )
{
if( p )
{
void ** ph = ( void ** ) hb_gcAllocate( sizeof( PGconn * ), &s_gcPGconnFuncs );
*ph = p;
hb_retptrGC( ph );
}
else
hb_retptr( NULL );
}
static void hb_FILE_ret( FILE * p )
{
if( p )
{
void ** ph = ( void ** ) hb_gcAllocate( sizeof( FILE * ), &s_gcFILEFuncs );
*ph = p;
hb_retptrGC( ph );
}
else
hb_retptr( NULL );
}
static void hb_PGcancel_ret( PGcancel * p )
{
if( p )
{
void ** ph = ( void ** ) hb_gcAllocate( sizeof( PGcancel * ), &s_gcPGcancelFuncs );
*ph = p;
hb_retptrGC( ph );
}
else
hb_retptr( NULL );
}
void hb_PGresult_ret( PGresult * p )
{
if( p )
{
void ** ph = ( void ** ) hb_gcAllocate( sizeof( PGresult * ), &s_gcPGresultFuncs );
*ph = p;
hb_retptrGC( ph );
}
else
hb_retptr( NULL );
}
static void hb_SQLHDBC_stor( PHB_ITEM pHEnvItm, SQLHDBC hDbc, int iParam )
{
PHB_SQLHDBC pHDbc = ( PHB_SQLHDBC ) hb_gcAllocate( sizeof( HB_SQLHDBC ), &s_gcSQLHDBCFuncs );
pHDbc->hDbc = hDbc;
pHDbc->conn_counter = 1;
/* initialize pointer scanned by mark function before allocating new
new GC block - such allocation may activate GC and uninitalized
pointer will be accessed from our mark function */
pHDbc->pHEnvItm = NULL;
if( pHEnvItm )
{
pHDbc->pHEnvItm = hb_itemNew( pHEnvItm );
hb_gcUnlock( pHDbc->pHEnvItm );
}
hb_storptrGC( ( void * ) pHDbc, iParam );
}
PHB_REGEX hb_regexCompile( const char * szRegEx, HB_SIZE nLen, int iFlags )
{
PHB_REGEX pRegEx;
HB_SYMBOL_UNUSED( nLen );
pRegEx = ( PHB_REGEX ) hb_gcAllocate( sizeof( *pRegEx ), &s_gcRegexFuncs );
memset( pRegEx, 0, sizeof( *pRegEx ) );
pRegEx->fFree = HB_TRUE;
pRegEx->iFlags = iFlags;
if( ( s_reg_comp )( pRegEx, szRegEx ) != 0 )
{
hb_gcFree( pRegEx );
pRegEx = NULL;
}
return pRegEx;
}
PHB_ITEM hb_libLoad( PHB_ITEM pLibName, PHB_ITEM pArgs )
{
void * hDynLib = NULL;
if( hb_itemGetCLen( pLibName ) > 0 )
{
int argc = pArgs ? ( int ) hb_arrayLen( pArgs ) : 0, i;
const char ** argv = NULL;
if( argc > 0 )
{
argv = ( const char ** ) hb_xgrab( sizeof( char * ) * argc );
for( i = 0; i < argc; ++i )
argv[ i ] = hb_arrayGetCPtr( pArgs, i + 1 );
}
if( hb_vmLockModuleSymbols() )
{
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) hb_stackId(), HB_TRUE );
#if defined( HB_OS_WIN )
{
void * hFileName;
hDynLib = ( void * ) LoadLibraryEx( HB_ITEMGETSTR( pLibName, &hFileName, NULL ), NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
hb_strfree( hFileName );
}
#elif defined( HB_OS_OS2 )
{
HB_UCHAR LoadError[ 256 ] = ""; /* Area for load failure information */
HMODULE hDynModule;
if( DosLoadModule( ( PSZ ) LoadError, sizeof( LoadError ),
( PCSZ ) hb_itemGetCPtr( pLibName ), &hDynModule ) == NO_ERROR )
hDynLib = ( void * ) hDynModule;
}
#elif defined( HB_HAS_DLFCN )
hDynLib = ( void * ) dlopen( hb_itemGetCPtr( pLibName ), RTLD_LAZY | RTLD_GLOBAL );
if( ! hDynLib )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_libLoad(): dlopen(): %s", dlerror() ) );
}
#elif defined( HB_CAUSEWAY_DLL )
hDynLib = LoadLibrary( hb_itemGetCPtr( pLibName ) );
#else
{
int iTODO;
}
#endif
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
hb_vmUnlockModuleSymbols();
}
if( argv )
hb_xfree( ( void * ) argv );
}
if( hDynLib )
{
void ** pLibPtr = ( void ** ) hb_gcAllocate( sizeof( void * ), &s_gcDynlibFuncs );
*pLibPtr = hDynLib;
return hb_itemPutPtrGC( NULL, pLibPtr );
}
return NULL;
}
