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; }