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; }
HB_BOOL hbgi_hb_clsAddMsg(HB_USHORT uiClass, const char *szMessage, HB_USHORT uiType, HB_USHORT uiScope, PHB_FUNC pFuncPtr, PHB_ITEM pInit) { PHB_SYMB pExecSym = hb_symbolNew(""); PHB_ITEM pFuncItem; pExecSym->value.pFunPtr = pFuncPtr; pFuncItem = hb_itemPutSymbol(NULL, pExecSym); hbgi_hb_clsAddMsgNative(uiClass, szMessage, uiType, uiScope, pFuncItem, pInit); hb_itemRelease(pFuncItem); return HB_TRUE; }
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( PHB_SYMB pSymbol, PSYMBOLS pModuleSymbols ) /* creates a new dynamic symbol */ { HB_THREAD_STUB PHB_DYNS pDynSym; HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymNew(%p, %p)", pSymbol, pModuleSymbols ) ); hb_dynsymLock(); pDynSym = hb_dynsymFind( pSymbol->szName ); /* Find position */ if( pDynSym ) /* If name exists */ { assert( 0 ); if( ( pSymbol->scope.value & HB_FS_LOCAL ) == HB_FS_LOCAL ) { #if 0 assert( pModuleSymbols ); if( pDynSym->pModuleSymbols ) TraceLog( NULL, "Symbol: '%s' was previously defined at Module: '%s'\n", pSymbol->szName, pDynSym->pModuleSymbols->szModuleName ); #endif /* if( pSymbol->value.pFunPtr && pDynSym->pSymbol->value.pFunPtr == NULL ) */ { #if 0 /* reenabled - it's still wrong, Druzus */ /* see note below */ /* register only non static functions */ if( ( pSymbol->scope.value & ( HB_FS_STATIC | HB_FS_INITEXIT ) ) == HB_FS_STATIC ) { assert( 0 ); TraceLog( NULL, "Rejecting: %s in %s\n", pSymbol->szName, pModuleSymbols ? pModuleSymbols->szModuleName : "" ); } else #endif { /* This is the symbol of the function definition module. */ assert( pSymbol->value.pFunPtr ); pDynSym->pSymbol = pSymbol; } } pDynSym->pModuleSymbols = pModuleSymbols; /* TraceLog( NULL, "Symbol: '%s' DEFINED in Module: '%s'\n", pSymbol->szName, pModuleSymbols ? pModuleSymbols->szModuleName : "" ); */ } pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */ hb_dynsymUnlock(); return pDynSym; /* Return pointer to DynSym */ } if( s_uiDynSymbols == 0 ) /* Do we have any symbols ? */ { pDynSym = s_pDynItems[ 0 ].pDynSym; /* Point to first symbol */ /* *<1>* Remember we already got this one */ } else /* We want more symbols ! */ { s_pDynItems = ( PDYNHB_ITEM ) hb_xrealloc( s_pDynItems, ( s_uiDynSymbols + 1 ) * sizeof( DYNHB_ITEM ) ); if( s_uiClosestDynSym <= s_uiDynSymbols ) /* Closest < current !! */ { /* Here it goes :-) */ register UINT uiPos; for( uiPos = 0; uiPos < ( UINT ) ( s_uiDynSymbols - s_uiClosestDynSym ); uiPos++ ) { /* Insert element in array */ HB_MEMCPY( &s_pDynItems[ s_uiDynSymbols - uiPos ], &s_pDynItems[ s_uiDynSymbols - uiPos - 1 ], sizeof( DYNHB_ITEM ) ); } } pDynSym = ( PHB_DYNS ) hb_xgrab( sizeof( HB_DYNS ) ); s_pDynItems[ s_uiClosestDynSym ].pDynSym = pDynSym; /* Enter DynSym */ } s_uiDynSymbols++; /* Got one more symbol */ pDynSym->hMemvar = 0; pDynSym->hArea = 0; #ifndef HB_NO_PROFILER pDynSym->ulCalls = 0; /* profiler support */ pDynSym->ulTime = 0; /* profiler support */ pDynSym->ulRecurse = 0; #endif #if 0 /* now the compiler creates separate symbols for functions and * fields/memvars/aliases so we should not have any problem here * and this code is not necessary but I decide to left it here * disabled at least for debugging. */ if( pSymbol->value.pFunPtr && ( pSymbol->scope.value & ( HB_FS_STATIC | HB_FS_INITEXIT ) ) == HB_FS_STATIC ) { /* * This symbol points to static function - we cannot register * such symbols in global dynsyms because we may have more * static functions with the same name and non static one * registered later - the static function should be directly * accessible _ONLY_ from their modules. * So we will clone this symbol. */ assert( 0 ); TraceLog( NULL, "Cloned: %s in %s\n", pSymbol->szName, pModuleSymbols ? pModuleSymbols->szModuleName : "" ); pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym in original symbol */ pSymbol = hb_symbolNew( pSymbol->szName ); /* clone the symbol */ } #endif /* TraceLog( NULL, "Symbol: '%s' IMPORTED in Module: '%s'\n", pSymbol->szName, pModuleSymbols ? pModuleSymbols->szModuleName : "" ); */ if( ( pSymbol->scope.value & HB_FS_LOCAL ) == HB_FS_LOCAL ) { /* This is the true local symbol */ assert( pSymbol->value.pFunPtr ); assert( pModuleSymbols ); pDynSym->pModuleSymbols = pModuleSymbols; /* TraceLog( NULL, "Symbol: '%s' DEFINED in Module: '%s'\n", pSymbol->szName, pModuleSymbols ? pModuleSymbols->szModuleName : "" ); */ } else { pDynSym->pModuleSymbols = NULL; } pDynSym->pSymbol = pSymbol; pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */ hb_dynsymUnlock(); return pDynSym; }