PHB_DYNS hb_dynsymFindWithNamespaces( const char * szName, const char * pNamespaces ) { if( pNamespaces ) { char * szNamespace = ( char * ) pNamespaces; PHB_DYNS pDynSym; while( *szNamespace ) { char * szQualified = hb_xstrcpy( NULL, szNamespace, ".", szName, NULL ); pDynSym = hb_dynsymFind( szQualified ); hb_xfree( szQualified ); if( pDynSym ) return pDynSym; szNamespace += strlen( szNamespace ) + 1; } return NULL; } else return hb_dynsymFind( szName ); }
PHB_DYNS hb_dynsymFindName( const char * szName ) /* finds a symbol */ { char szUprName[ HB_SYMBOL_NAME_LEN + 1 ]; HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymFindName(%s)", szName ) ); /* make a copy as we may get a const string, then turn it to uppercase */ /* NOTE: This block is optimized for speed [vszakats] */ { 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'; } return hb_dynsymFind( szUprName ); }
PHB_DYNS hb_dynsymGetCase( const char * szName ) /* finds and creates a symbol if not found CASE SENSITIVE! */ { 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_dynsymFind( szName ); 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; }
PHB_DYNS hb_dynsymFindName( const char * szName ) /* finds a symbol */ { char szUprName[ HB_SYMBOL_NAME_LEN + 1 ]; HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymFindName(%s)", szName ) ); { 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'; } return hb_dynsymFind( ( char * ) szUprName ); }
static void hb_hrbUnLoad( PHRB_BODY pHrbBody ) { hb_hrbExit( pHrbBody ); if( pHrbBody->pModuleSymbols ) hb_vmFreeSymbols( pHrbBody->pModuleSymbols ); if( pHrbBody->pDynFunc ) { HB_ULONG ul; for( ul = 0; ul < pHrbBody->ulFuncs; ul++ ) { if( pHrbBody->pDynFunc[ ul ].szName && pHrbBody->pDynFunc[ ul ].pcodeFunc.pCode ) { PHB_DYNS pDyn = hb_dynsymFind( pHrbBody->pDynFunc[ ul ].szName ); if( pDyn && pDyn->pSymbol->value.pCodeFunc == &pHrbBody->pDynFunc[ ul ].pcodeFunc ) { pDyn->pSymbol->value.pCodeFunc = NULL; } } if( pHrbBody->pDynFunc[ ul ].pCode ) hb_xfree( pHrbBody->pDynFunc[ ul ].pCode ); if( pHrbBody->pDynFunc[ ul ].szName ) hb_xfree( pHrbBody->pDynFunc[ ul ].szName ); } hb_xfree( pHrbBody->pDynFunc ); } hb_xfree( pHrbBody ); }
PHB_SYMB hb_dynsymFindSymbol( const char * szName ) { PHB_DYNS pDynSym; HB_TRACE( HB_TR_DEBUG, ( "hb_dynsymFindSymbol(%s)", szName ) ); pDynSym = hb_dynsymFind( szName ); return pDynSym ? pDynSym->pSymbol : NULL; }
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; }
/* * Call specific driver function to load any configuration needed... * 14/12/2008 - 20:05:26 */ static void SQLSYS_LOADINFO( const char *DriverName, SQLSYS_INFO *pStruct ) { PHB_DYNS pDynSym = hb_dynsymFind( DriverName ); if ( pDynSym && hb_dynsymIsFunction( pDynSym ) ) { HB_TRACE(HB_TR_DEBUG,(" SQLSYS_LOADINFO( '%s', %p ) ... (LOADing)", DriverName, pStruct )); hb_vmPushDynSym( pDynSym ); hb_vmPushNil(); hb_vmPushPointer( ( void * ) pStruct ); hb_vmDo( 1 ); } else { HB_TRACE(HB_TR_DEBUG,(" SQLSYS_LOADINFO( '%s', %p ) ... ERROR: DRIVER NOT FOUND!!! ###", DriverName, pStruct )); memset( pStruct, '\0', sizeof( SQLSYS_INFO ) ); } }
static void hb_pp_StdRules( PHB_ITEM ppItem ) { static HB_BOOL s_fInit = HB_TRUE; static PHB_DYNS s_pDynSym; if( s_fInit ) { s_pDynSym = hb_dynsymFind( "__PP_STDRULES" ); s_fInit = HB_FALSE; } if( s_pDynSym ) { hb_vmPushDynSym( s_pDynSym ); hb_vmPushNil(); hb_vmPush( ppItem ); hb_vmProc( 1 ); } }
PHB_DYNS hb_dynsymFind_r( const char * szName, PHB_DYNS pDest ) { PHB_DYNS pRet; hb_dynsymLock(); pRet = hb_dynsymFind( szName ); if( pRet ) { HB_MEMCPY( pDest, pRet, sizeof( HB_DYNS ) ); hb_dynsymUnlock(); return pDest; } hb_dynsymUnlock(); return NULL; }
void hb_traceInit( void ) { FILE * fpTrace; PHB_DYNS pTraceLog = hb_dynsymFind( "TRACELOG" ); if( s_bDoInit && pTraceLog && pTraceLog->pSymbol->value.pFunPtr && hb_fsFile( "trace.log" ) ) { s_bDoInit = FALSE; // Might have been initialized if TraceLog() was called before traceInit! hb_threadLockInit( S_TRACEMTX ); /* Empty the file if it exists. */ fpTrace = hb_fopen( "trace.log", "w" ); if( fpTrace ) fclose( fpTrace ); } }
/* * Find a field index by name */ HB_USHORT hb_rddFieldIndex( AREAP pArea, const char * szName ) { HB_TRACE( HB_TR_DEBUG, ( "hb_rddFieldIndex(%p, %s)", pArea, szName ) ); while( HB_ISSPACE( *szName ) ) ++szName; if( *szName ) { HB_SIZE nLen = strlen( szName ); while( HB_ISSPACE( szName[ nLen - 1 ] ) ) --nLen; if( nLen <= HB_SYMBOL_NAME_LEN ) { char szFieldName[ HB_SYMBOL_NAME_LEN + 1 ]; PHB_DYNS pDynSym; szFieldName[ nLen ] = '\0'; while( nLen-- ) szFieldName[ nLen ] = HB_TOUPPER( szName[ nLen ] ); pDynSym = hb_dynsymFind( szFieldName ); if( pDynSym ) { LPFIELD pField = pArea->lpFields; HB_USHORT uiCount = 0; while( pField ) { ++uiCount; if( pDynSym == ( PHB_DYNS ) pField->sym ) return uiCount; pField = pField->lpfNext; } } } } return 0; }
/* Clear all memvar variables optionally without GetList PUBLIC variable */ void hb_memvarsClear( HB_BOOL fAll ) { HB_STACK_TLS_PRELOAD PHB_DYNS pGetList; HB_TRACE( HB_TR_DEBUG, ( "hb_memvarsClear(%d)", ( int ) fAll ) ); pGetList = fAll ? NULL : hb_dynsymFind( "GETLIST" ); hb_stackClearMemvarsBase(); hb_stackGetPrivateStack()->base = 0; hb_memvarSetPrivatesBase( 0 ); #if ! defined( HB_MT_VM ) hb_dynsymEval( hb_memvarClear, ( void * ) pGetList ); #else /* this is a little bit hacked but many times faster version * of memvars clearing because it scans only given thread stack * not global dynamic symbol table. It noticeable reduce the cost * of HVM thread releasing. */ hb_stackClearMemvars( pGetList ? ( int ) pGetList->uiSymNum : -1 ); #endif }
static PHB_DYNS hb_memvarFindSymbol( const char * szArg, HB_SIZE nLen ) { PHB_DYNS pDynSym = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_memvarFindSymbol(%p,%" HB_PFS "u)", szArg, nLen ) ); if( nLen && szArg && *szArg ) { char szUprName[ HB_SYMBOL_NAME_LEN + 1 ]; int iSize = 0; do { char cChar = *szArg++; if( cChar >= 'a' && cChar <= 'z' ) szUprName[ iSize++ ] = cChar - ( 'a' - 'A' ); else if( cChar == ' ' || cChar == '\t' || cChar == '\n' ) { if( iSize ) break; } else if( ! cChar ) break; else szUprName[ iSize++ ] = cChar; } while( --nLen && iSize < HB_SYMBOL_NAME_LEN ); if( iSize ) { szUprName[ iSize ] = '\0'; pDynSym = hb_dynsymFind( szUprName ); } } return pDynSym; }
BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, PVOID pvReserved ) #endif { static HB_BOOL s_fInit = HB_FALSE; BOOL fResult = TRUE; HB_SYMBOL_UNUSED( pvReserved ); switch( dwReason ) { case DLL_PROCESS_ATTACH: s_hInstDll = ( HINSTANCE ) hInstance; s_lLockCount = s_lObjectCount = 0; s_IClassFactoryObj.lpVtbl = ( IClassFactoryVtbl * ) &IClassFactory_Vtbl; DisableThreadLibraryCalls( ( HMODULE ) hInstance ); s_fInit = ! hb_vmIsActive(); if( s_fInit ) hb_vmInit( HB_FALSE ); hb_oleInit(); if( ! s_fServerReady ) { PHB_DYNS pDynSym = hb_dynsymFind( "DLLMAIN" ); if( pDynSym && hb_dynsymIsFunction( pDynSym ) && hb_vmRequestReenter() ) { hb_vmPushDynSym( pDynSym ); hb_vmPushNil(); hb_vmProc( 0 ); hb_vmRequestRestore(); } } fResult = s_fServerReady ? TRUE : FALSE; break; case DLL_PROCESS_DETACH: s_fServerReady = HB_FALSE; if( s_pAction ) { hb_itemRelease( s_pAction ); s_pAction = NULL; } if( s_pMsgHash ) { hb_itemRelease( s_pMsgHash ); s_pMsgHash = NULL; } if( s_fInit ) { hb_vmQuit(); s_fInit = HB_FALSE; } break; } return fResult; }
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; }
static PHRB_BODY hb_hrbLoad( const char * szHrbBody, HB_SIZE nBodySize, HB_USHORT usMode, const char * szFileName ) { PHRB_BODY pHrbBody = NULL; if( szHrbBody ) { HB_SIZE nBodyOffset = 0; HB_SIZE nSize; /* Size of function */ HB_SIZE nPos; HB_ULONG ul; char * buffer, ch; HB_USHORT usBind = ( usMode & HB_HRB_BIND_MODEMASK ); PHB_SYMB pSymRead; /* Symbols read */ PHB_DYNF pDynFunc; /* Functions read */ PHB_DYNS pDynSym; int iVersion = hb_hrbReadHead( szHrbBody, nBodySize, &nBodyOffset ); if( iVersion == 0 ) { hb_errRT_BASE( EG_CORRUPTION, 9995, NULL, HB_ERR_FUNCNAME, 0 ); return NULL; } pHrbBody = ( PHRB_BODY ) hb_xgrab( sizeof( HRB_BODY ) ); pHrbBody->fInit = HB_FALSE; pHrbBody->fExit = HB_FALSE; pHrbBody->lSymStart = -1; pHrbBody->ulFuncs = 0; pHrbBody->pSymRead = NULL; pHrbBody->pDynFunc = NULL; pHrbBody->pModuleSymbols = NULL; if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulSymbols ) || pHrbBody->ulSymbols == 0 ) { hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_CORRUPTION, 9996, NULL, HB_ERR_FUNCNAME, 0 ); return NULL; } /* calculate the size of dynamic symbol table */ nPos = nBodyOffset; nSize = 0; for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */ { while( nBodyOffset < nBodySize ) { ++nSize; if( szHrbBody[ nBodyOffset++ ] == 0 ) break; } nBodyOffset += 2; if( nBodyOffset >= nBodySize ) { hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 ); return NULL; } } nBodyOffset = nPos; ul = pHrbBody->ulSymbols * sizeof( HB_SYMB ); pSymRead = ( PHB_SYMB ) hb_xgrab( nSize + ul ); buffer = ( ( char * ) pSymRead ) + ul; for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) /* Read symbols in .hrb */ { pSymRead[ ul ].szName = buffer; do { ch = *buffer++ = szHrbBody[ nBodyOffset++ ]; } while( ch ); pSymRead[ ul ].scope.value = ( HB_BYTE ) szHrbBody[ nBodyOffset++ ]; pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) ( HB_PTRDIFF ) szHrbBody[ nBodyOffset++ ]; pSymRead[ ul ].pDynSym = NULL; if( pHrbBody->lSymStart == -1 && ( pSymRead[ ul ].scope.value & HB_FS_FIRST ) != 0 && ( pSymRead[ ul ].scope.value & HB_FS_INITEXIT ) == 0 ) { pHrbBody->lSymStart = ul; } } /* Read number of functions */ if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &pHrbBody->ulFuncs ) ) { hb_xfree( pSymRead ); hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_CORRUPTION, 9997, NULL, HB_ERR_FUNCNAME, 0 ); return NULL; } pHrbBody->pSymRead = pSymRead; if( pHrbBody->ulFuncs ) { pDynFunc = ( PHB_DYNF ) hb_xgrab( pHrbBody->ulFuncs * sizeof( HB_DYNF ) ); memset( pDynFunc, 0, pHrbBody->ulFuncs * sizeof( HB_DYNF ) ); pHrbBody->pDynFunc = pDynFunc; for( ul = 0; ul < pHrbBody->ulFuncs; ul++ ) { HB_ULONG ulValue; /* Read name of function */ pDynFunc[ ul ].szName = hb_hrbReadId( szHrbBody, nBodySize, &nBodyOffset ); if( pDynFunc[ ul ].szName == NULL ) break; /* Read size of function */ if( ! hb_hrbReadValue( szHrbBody, nBodySize, &nBodyOffset, &ulValue ) ) break; nSize = ( HB_SIZE ) ulValue; if( nBodyOffset + nSize > nBodySize ) break; /* Copy function body */ pDynFunc[ ul ].pCode = ( HB_BYTE * ) hb_xgrab( nSize ); memcpy( ( char * ) pDynFunc[ ul ].pCode, szHrbBody + nBodyOffset, nSize ); nBodyOffset += nSize; pDynFunc[ ul ].pCodeFunc = ( PHB_PCODEFUNC ) hb_xgrab( sizeof( HB_PCODEFUNC ) ); pDynFunc[ ul ].pCodeFunc->pCode = pDynFunc[ ul ].pCode; pDynFunc[ ul ].pCodeFunc->pSymbols = pSymRead; } if( ul < pHrbBody->ulFuncs ) { hb_xfree( pSymRead ); hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_CORRUPTION, 9998, NULL, HB_ERR_FUNCNAME, 0 ); return NULL; } } /* End of PCODE loading, now linking */ for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) { if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_FUNC ) { nPos = hb_hrbFindSymbol( pSymRead[ ul ].szName, pHrbBody->pDynFunc, pHrbBody->ulFuncs ); if( nPos == SYM_NOT_FOUND ) { pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN; } else { pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) pHrbBody->pDynFunc[ nPos ].pCodeFunc; pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC | HB_FS_LOCAL | ( usBind == HB_HRB_BIND_FORCELOCAL ? HB_FS_STATIC : 0 ); } } else if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_DEFERRED ) { pSymRead[ ul ].value.pCodeFunc = ( PHB_PCODEFUNC ) SYM_EXTERN; pSymRead[ ul ].scope.value |= HB_FS_DEFERRED; } /* External function */ if( pSymRead[ ul ].value.pCodeFunc == ( PHB_PCODEFUNC ) SYM_EXTERN ) { pSymRead[ ul ].value.pCodeFunc = NULL; pDynSym = hb_dynsymFind( pSymRead[ ul ].szName ); if( pDynSym ) { pSymRead[ ul ].value.pFunPtr = pDynSym->pSymbol->value.pFunPtr; if( pDynSym->pSymbol->scope.value & HB_FS_PCODEFUNC ) { pSymRead[ ul ].scope.value |= HB_FS_PCODEFUNC; } } else if( ( pSymRead[ ul ].scope.value & HB_FS_DEFERRED ) == 0 ) { if( ( usMode & HB_HRB_BIND_LAZY ) != 0 ) pSymRead[ ul ].scope.value |= HB_FS_DEFERRED; else { char szName[ HB_SYMBOL_NAME_LEN + 1 ]; hb_strncpy( szName, pSymRead[ ul ].szName, sizeof( szName ) - 1 ); hb_xfree( pSymRead ); hb_hrbUnLoad( pHrbBody ); hb_errRT_BASE( EG_ARG, 6101, "Unknown or unregistered symbol", szName, 0 ); return NULL; } } } } if( hb_vmLockModuleSymbols() ) { if( usBind == HB_HRB_BIND_LOCAL ) { for( ul = 0; ul < pHrbBody->ulSymbols; ul++ ) { if( ( pSymRead[ ul ].scope.value & ( HB_FS_LOCAL | HB_FS_STATIC ) ) == HB_FS_LOCAL ) { pDynSym = hb_dynsymFind( pSymRead[ ul ].szName ); if( pDynSym ) { /* convert public function to static one */ pSymRead[ ul ].scope.value |= HB_FS_STATIC; } } } } pHrbBody->pModuleSymbols = hb_vmRegisterSymbols( pHrbBody->pSymRead, ( HB_USHORT ) pHrbBody->ulSymbols, szFileName ? szFileName : "pcode.hrb", 0, HB_TRUE, HB_FALSE, usBind == HB_HRB_BIND_OVERLOAD ); if( pHrbBody->pModuleSymbols->pModuleSymbols != pSymRead ) { /* * Old unused symbol table has been recycled - free the one * we allocated and disactivate static initialization [druzus] */ pHrbBody->pSymRead = pHrbBody->pModuleSymbols->pModuleSymbols; hb_xfree( pSymRead ); pHrbBody->fInit = HB_TRUE; } else { /* mark symbol table as dynamically allocated so HVM will free it on exit */ pHrbBody->pModuleSymbols->fAllocated = HB_TRUE; /* initialize static variables */ hb_hrbInitStatic( pHrbBody ); } hb_vmUnlockModuleSymbols(); } else { hb_xfree( pSymRead ); hb_hrbUnLoad( pHrbBody ); pHrbBody = NULL; } } return pHrbBody; }