static void
hbgihb_init(void *dummy)
{
HB_SYMBOL_UNUSED(dummy);
if (!s_pDyns__CLSNEW) {
PHB_SYMB pExecSym = hb_symbolNew("__CLSADDMSG");
pExecSym->value.pFunPtr = HB_FUNCNAME(__CLSADDMSG);
s_pDyns__CLSADDMSG = hb_dynsymNew(pExecSym);
pExecSym = hb_symbolNew("__CLSNEW");
pExecSym->value.pFunPtr = HB_FUNCNAME(__CLSNEW);
s_pDyns__CLSNEW = hb_dynsymNew(pExecSym);
}
}
PHB_DYNS hb_dynsymGetWithNamespaces( const char * szName, const char * pNamespaces ) /* finds and creates a symbol if not found CASE INSENSITIVE! */
{
HB_THREAD_STUB_STACK
PHB_DYNS pDynSym;
HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymGetCase(%s)", szName ) );
/* TraceLog( NULL, "Searching: %s\n", szName );
*/
/* JC1: read the notice for hb_dynsymGet() */
hb_dynsymLock();
pDynSym = hb_dynsymFindNameWithNamespaces( szName, pNamespaces );
if( ! pDynSym ) /* Does it exists ? */
{
/* TraceLog( NULL, "Creating: %s\n", szName );
*/
pDynSym = hb_dynsymNew( hb_symbolNew( szName ), HB_GETMODULESYM() ); /* Make new symbol */
pDynSym->pSymbol->scope.value = HB_FS_PUBLIC;
}
hb_dynsymUnlock();
/* TraceLog( NULL, "Returning: %p\n", pDynSym );
*/
return pDynSym;
}
void hb_errInit( void )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_errInit()" ) );
/* error function */
hb_dynsymNew( &s_symErrorNew );
/* Create error class and base object */
s_pError = hb_itemNew( NULL );
hb_clsAssociate( hb_errClassCreate() );
hb_itemMove( s_pError, hb_stackReturnItem() );
}
PHB_DYNS hb_dynsymGet( const char * szName ) /* finds and creates a symbol if not found */
{
HB_THREAD_STUB_STACK
/* make a copy as we may get a const string, then turn it to uppercase */
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
PHB_DYNS pDynSym;
HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymGet(%s)", szName ) );
{
register int iLen = HB_SYMBOL_NAME_LEN;
char * pDest = szUprName;
do
{
register 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';
}
/* JC1: Notice, locking this function MAY seem useless but it is not.
Suppose two threads calling this functon with the same szUprName: both
of them may find ! pDynSym, and both of them may proceed to hb_dynsymNew().
Although this operation would suceed, one of the threas would get an
invalid reference, and we would have a memory leak, as one of the
two dynsymNew() would be overriden
*/
hb_dynsymLock();
pDynSym = hb_dynsymFind( ( char * ) szUprName );
if( ! pDynSym ) /* Does it exists ? */
{
/* TraceLog( NULL, "*** Did NOT find >%s< - CREATED New!\n", szUprName );
*/
pDynSym = hb_dynsymNew( hb_symbolNew( ( char * ) szUprName ), HB_GETMODULESYM() ); /* Make new symbol */
pDynSym->pSymbol->scope.value = HB_FS_PUBLIC;
}
hb_dynsymUnlock();
return pDynSym;
}
PHB_DYNS hb_dynsymNew_r( PHB_SYMB pSymbol, PSYMBOLS pModuleSymbols, PHB_DYNS pDest )
{
PHB_DYNS pRet;
hb_dynsymLock();
pRet = hb_dynsymNew( pSymbol, pModuleSymbols );
if( pRet )
{
HB_MEMCPY( pDest, pRet, sizeof( HB_DYNS ) );
hb_dynsymUnlock();
return pDest;
}
hb_dynsymUnlock();
return NULL;
}
