void sdbReportError( const CHAR *filename, UINT32 lineno,
const CHAR *msg, BOOLEAN isException )
{
BOOLEAN add = FALSE ;
if ( SDB_OK == sdbGetErrno() || !__hasSetErrNo__ )
{
const CHAR *p = NULL ;
if ( isException && msg &&
NULL != ( p = ossStrstr( msg, ":" ) ) &&
0 != ossAtoi( p + 1 ) )
{
sdbSetErrno( ossAtoi( p + 1 ) ) ;
}
else
{
sdbSetErrno( SDB_SPT_EVAL_FAIL ) ;
}
}
if ( ( sdbIsErrMsgEmpty() || !__hasSetErrMsg__ ) && msg )
{
if ( filename )
{
stringstream ss ;
ss << filename << ":" << lineno << " " << msg ;
sdbSetErrMsg( ss.str().c_str() ) ;
}
else
{
sdbSetErrMsg( msg ) ;
}
add = TRUE ;
}
if ( sdbNeedPrintError() )
{
ossPrintf( "%s:%d %s\n",
filename ? filename : "(nofile)" ,
lineno, msg ) ;
if ( !add && !sdbIsErrMsgEmpty() &&
NULL == ossStrstr( sdbGetErrMsg(), msg ) )
{
ossPrintf( "%s\n", sdbGetErrMsg() ) ;
}
}
__hasSetErrMsg__ = FALSE ;
__hasSetErrNo__ = FALSE ;
}
INT32 _sptClassMetaInfo::_getContents( const CHAR *pFileBuff,
const CHAR *pMark1,
const CHAR*pMark2,
CHAR **ppBuff,
INT32 *pBuffSize )
{
INT32 rc = SDB_OK ;
stringstream ss ;
INT32 buffSize = 0 ;
CHAR *pBuff = NULL ;
CHAR *begin = NULL ;
CHAR *end = NULL ;
begin = ossStrstr( (CHAR *)pFileBuff, (CHAR *)pMark1 ) ;
end = ossStrstr( (CHAR *)pFileBuff, (CHAR *)pMark2 ) ;
if ( NULL == begin || NULL == end )
{
rc = SDB_INVALIDARG ;
ss << "Failed to get [" << pMark1 << "], or ["
<< pMark2 << "], rc = " << rc << ERROR_END ;
goto error ;
}
buffSize = end - begin ;
pBuff = (CHAR *)SDB_OSS_MALLOC( buffSize + 1 ) ;
if ( NULL == pBuff )
{
rc = SDB_OOM ;
ss << "Failed to alloc [" << buffSize << "] bytes, rc = "
<< rc << ERROR_END ;
goto error ;
}
ossMemset( pBuff, 0, buffSize ) ;
ossMemcpy( pBuff, begin, buffSize ) ;
pBuff[buffSize] = '\0' ;
*ppBuff = pBuff ;
*pBuffSize = buffSize + 1 ;
done:
return rc ;
error:
PRINT_ERROR ;
goto done ;
}
void _replaceCharsWithSpace( CHAR *pBuff, const CHAR *c )
{
CHAR *pos = NULL ;
while( TRUE )
{
pos = ossStrstr( pBuff, c ) ;
if ( NULL == pos )
{
break ;
}
ossMemset( pos, ' ', ossStrlen(c) ) ;
}
}
const INT32 _dpsLogFilter::getFileCount( const CHAR *path )
{
INT32 fileCount = 0 ;
const CHAR *pFileName = "sequoiadbLog." ;
fs::path fileDir( path ) ;
fs::directory_iterator endIter ;
for( fs::directory_iterator it( path ); it != endIter; ++it )
{
const CHAR *filepath = it->path().filename().string().c_str() ;
const CHAR *dotPos = ossStrrchr( filepath, '.' ) ;
if( !dotPos )
continue ;
const CHAR *namePos = ossStrstr( filepath, pFileName ) ;
if( !namePos )
continue ;
if( ( dotPos - namePos + 1 ) != (UINT32)ossStrlen( pFileName ) )
continue ;
++fileCount ;
}
return fileCount ;
}
void _filterMarks( CHAR *pBuff, const CHAR **marks, INT32 num )
{
INT32 i = 0 ;
INT32 left = 0 ;
CHAR *pos = NULL ;
CHAR *end = NULL ;
for ( ; i < num; i++ )
{
while( TRUE )
{
pos = ossStrstr( pBuff, marks[i] ) ;
if ( NULL == pos )
{
break ;
}
end = pos + ossStrlen( marks[i] ) ;
left = ossStrlen( end ) ;
ossMemmove( pos, end, left ) ;
pos[left] = '\0' ;
}
}
}
INT32 _ossModuleHandle::patchModuleName( const CHAR* name, CHAR *patchedName, UINT32 size )
{
INT32 rc = SDB_OK ;
SDB_ASSERT( name, "Module name can not be NULL" ) ;
SDB_ASSERT( patchedName, "Patched buffer can not be NULL" ) ;
const CHAR *ptr = NULL ;
INT32 patchedNameLen = 0 ;
#ifdef _WINDOWS
INT32 tailLen = ossStrlen(LIB_END_STR) ;
#else
INT32 tailLen = ossStrlen(LIB_END_STR) ;
#endif
ossMemset( patchedName, 0, size ) ;
#ifdef _LINUX
ptr = ossStrstr( name, LIB_START_STR ) ;
if ( ptr != name )
{
ossMemcpy( patchedName, LIB_START_STR, ossStrlen(LIB_START_STR) ) ;
}
#endif
patchedNameLen = ossStrlen( patchedName ) ;
ptr = ossStrrchr( name, '.' ) ;
if ( ptr != NULL )
{
#ifdef _WINDOWS
if ( 'd' != *(ptr + 1) || 'l' != *(ptr + 2) && 'l' != *(ptr + 3) )
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ossStrlen( name ) ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
#else
if ( 's' != *(ptr + 1) && 'o' != *(ptr + 2) )
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ossStrlen( name ) ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
#endif
else
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, strlen( name ) ) ;
}
}
else
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ptr - name ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
done:
return rc ;
error:
goto done ;
}
static INT32 _ossEnumFiles( const string &dirPath,
map<string, string> &mapFiles,
const CHAR *filter, UINT32 filterLen,
OSS_MATCH_TYPE type, UINT32 deep )
{
INT32 rc = SDB_OK ;
const CHAR *pFind = NULL ;
try
{
fs::path dbDir ( dirPath ) ;
fs::directory_iterator end_iter ;
if ( 0 == deep )
{
goto done ;
}
if ( fs::exists ( dbDir ) && fs::is_directory ( dbDir ) )
{
for ( fs::directory_iterator dir_iter ( dbDir );
dir_iter != end_iter; ++dir_iter )
{
try
{
if ( fs::is_regular_file ( dir_iter->status() ) )
{
const std::string fileName =
dir_iter->path().filename().string() ;
if ( ( OSS_MATCH_NULL == type ) ||
( OSS_MATCH_LEFT == type &&
0 == ossStrncmp( fileName.c_str(), filter,
filterLen ) ) ||
( OSS_MATCH_MID == type &&
ossStrstr( fileName.c_str(), filter ) ) ||
( OSS_MATCH_RIGHT == type &&
( pFind = ossStrstr( fileName.c_str(), filter ) ) &&
pFind[filterLen] == 0 ) ||
( OSS_MATCH_ALL == type &&
0 == ossStrcmp( fileName.c_str(), filter ) )
)
{
mapFiles[ fileName ] = dir_iter->path().string() ;
}
}
else if ( fs::is_directory( dir_iter->path() ) && deep > 1 )
{
_ossEnumFiles( dir_iter->path().string(), mapFiles,
filter, filterLen, type, deep - 1 ) ;
}
}
catch( std::exception &e )
{
PD_LOG( PDWARNING, "File or dir[%s] occur exception: %s",
dir_iter->path().string().c_str(),
e.what() ) ;
}
}
}
else
{
rc = SDB_INVALIDARG ;
goto error ;
}
}
catch( std::exception &e )
{
PD_LOG( PDERROR, "Occur exception: %s", e.what() ) ;
rc = SDB_SYS ;
goto error ;
}
done:
return rc ;
error:
goto done ;
}
INT32 _sptClassMetaInfo::_getFuncDesc( const CHAR *pFileBuff,
INT32 fileSize,
string &desc )
{
INT32 rc = SDB_OK ;
stringstream ss ;
INT32 buffSize = 0 ;
CHAR *pBuff = NULL ;
const CHAR *pos = NULL ;
const CHAR *beg_mark =
SPT_LANG_EN == _lang ? SPT_TROFF_NAME_EN : SPT_TROFF_NAME_CN ;
const CHAR *end_mark =
SPT_LANG_EN == _lang ? SPT_TROFF_SYNOPSIS_EN : SPT_TROFF_SYNOPSIS_CN ;
rc = _getContents( pFileBuff, beg_mark, end_mark,
&pBuff, &buffSize ) ;
if ( SDB_OK != rc )
{
ss << "Failed to contents for extracting synopsis, rc = "
<< rc << endl ;
goto error ;
}
_replaceCharsWithSpace( pBuff, "\n" ) ;
_filterMarks( pBuff, _uselessMarks2,
sizeof( _uselessMarks2 ) / sizeof( const CHAR * ) ) ;
pos = ossStrstr( pBuff, "-" ) ;
if ( NULL == pos )
{
rc = SDB_INVALIDARG ;
ss << "Failed to get the description of function, rc = "
<< rc << ERROR_END ;
goto error ;
}
pos++ ;
while( '\r' != *pos && '\n' != *pos )
{
if ( ' ' == *pos )
{
pos++ ;
}
else
{
break ;
}
}
if ( '\r' != *pos && '\n' != *pos )
{
desc += string( "- " ) + pos ;
boost::trim( desc ) ;
}
done:
if ( pBuff )
{
SAFE_OSS_FREE( pBuff ) ;
}
return rc ;
error:
PRINT_ERROR ;
goto done ;
}
INT32 utilParseVersion( CHAR * pVersionStr,
INT32 &version,
INT32 &subVersion,
INT32 &release,
string &buildInfo )
{
INT32 rc = SDB_OK ;
const CHAR *pDelim = " \r\n" ;
CHAR *pToken = NULL ;
CHAR *pLast = NULL ;
if ( !pVersionStr )
{
rc = SDB_INVALIDARG ;
goto error ;
}
pToken = ossStrtok( pVersionStr, pDelim, &pLast ) ;
if ( !pToken )
{
rc = SDB_INVALIDARG ;
goto error ;
}
else
{
CHAR *pTokenTmp = NULL ;
CHAR *pLastTmp = NULL ;
CHAR *pVerPtr = ossStrstr( pToken, ":" ) ;
if ( !pVerPtr )
{
rc = SDB_INVALIDARG ;
goto error ;
}
pTokenTmp = ossStrtok( pVerPtr, " .", &pLastTmp ) ;
if ( !pTokenTmp )
{
rc = SDB_INVALIDARG ;
goto error ;
}
version = ossAtoi( pTokenTmp ) ;
pTokenTmp = ossStrtok( NULL, " .", &pLastTmp ) ;
if ( !pTokenTmp )
{
rc = SDB_INVALIDARG ;
goto error ;
}
subVersion = ossAtoi( pTokenTmp ) ;
}
pToken = ossStrtok( NULL, pDelim, &pLast ) ;
if ( !pToken )
{
rc = SDB_INVALIDARG ;
goto error ;
}
else
{
string releaseStr ;
CHAR *pReleasePtr = ossStrstr( pToken, ":" ) ;
if ( !pReleasePtr )
{
rc = SDB_INVALIDARG ;
goto error ;
}
releaseStr = pReleasePtr ;
utilStrLtrim( releaseStr ) ;
release = ossAtoi( releaseStr.c_str() ) ;
}
pToken = ossStrtok( NULL, pDelim, &pLast ) ;
if ( !pToken )
{
rc = SDB_INVALIDARG ;
goto error ;
}
buildInfo = pToken ;
done:
return rc ;
error:
goto done ;
}
