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