自学教程：C++ HB_SYMBOL_UNUSED函数代码示例

static void * hb_pcre2_grab( PCRE2_SIZE size, void * data ){   HB_SYMBOL_UNUSED( data );   return size > 0 ? hb_xgrab( size ) : NULL;}

static void hb_mlGetEOLs( PHB_MLC_INFO pMLC, int iParam ){   int iEOLs = 0;   HB_SIZE nLen;   pMLC->pEOLs = pMLC->EOL_buffer;/* NOTE: This is a parameter extension (HB_EXTENSION) which breaks         our effort to keep strict parameter compatibility with         Clipper 5.x. In this case we've resorted to a compromise         because there was no other idea which seemed natural enough.         Clipper will ignore these parameters and use CRLF EOL hard         coded. [vszakats] */#ifndef HB_CLP_STRICT /* HB_EXTENSION */   nLen = hb_parclen( iParam );   if( nLen )   {      pMLC->pEOLs[ 0 ].szEOL = hb_parc( iParam );      pMLC->pEOLs[ 0 ].nLen = nLen;      iEOLs = 1;   }   else if( HB_ISARRAY( iParam ) )   {      PHB_ITEM pArray = hb_param( iParam, HB_IT_ARRAY );      HB_SIZE nSize = hb_arrayLen( pArray ), n;      for( n = 1; n <= nSize; ++n )      {         if( hb_arrayGetCLen( pArray, n ) > 0 )            ++iEOLs;      }      if( iEOLs )      {         if( iEOLs > HB_EOL_BUFFER_SIZE )            pMLC->pEOLs = ( PHB_EOL_INFO ) hb_xgrab( sizeof( HB_EOL_INFO ) * iEOLs );         iEOLs = 0;         for( n = 1; n <= nSize; ++n )         {            nLen = hb_arrayGetCLen( pArray, n );            if( nLen > 0 )            {               pMLC->pEOLs[ iEOLs ].szEOL = hb_arrayGetCPtr( pArray, n );               pMLC->pEOLs[ iEOLs ].nLen = nLen;               ++iEOLs;            }         }      }   }#else   HB_SYMBOL_UNUSED( iParam );   HB_SYMBOL_UNUSED( nLen );#endif   if( iEOLs == 0 )   {      pMLC->pEOLs[ 0 ].szEOL = hb_setGetEOL();      if( ! pMLC->pEOLs[ 0 ].szEOL || ! pMLC->pEOLs[ 0 ].szEOL[ 0 ] )         pMLC->pEOLs[ 0 ].szEOL = hb_conNewLine();      pMLC->pEOLs[ 0 ].nLen = strlen( pMLC->pEOLs[ 0 ].szEOL );      iEOLs = pMLC->pEOLs[ 0 ].nLen ? 1 : 0;   }   pMLC->iEOLs = iEOLs;}

static void hbqt_lib_exit( void * cargo ){   HB_SYMBOL_UNUSED( cargo );}

HB_FATTR hb_fsAttrToRaw( HB_FATTR nAttr ){   HB_FATTR raw_attr;   HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrToRaw(%u)", nAttr ) );#if defined( HB_OS_DOS )   raw_attr = 0;   if( nAttr & HB_FA_ARCHIVE )   raw_attr |= FA_ARCH;   if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FA_DIREC;   if( nAttr & HB_FA_HIDDEN )    raw_attr |= FA_HIDDEN;   if( nAttr & HB_FA_READONLY )  raw_attr |= FA_RDONLY;   if( nAttr & HB_FA_LABEL )     raw_attr |= FA_LABEL;   if( nAttr & HB_FA_SYSTEM )    raw_attr |= FA_SYSTEM;#elif defined( HB_OS_OS2 )   raw_attr = 0;   if( nAttr & HB_FA_ARCHIVE )   raw_attr |= FILE_ARCHIVED;   if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_DIRECTORY;   if( nAttr & HB_FA_HIDDEN )    raw_attr |= FILE_HIDDEN;   if( nAttr & HB_FA_READONLY )  raw_attr |= FILE_READONLY;   if( nAttr & HB_FA_SYSTEM )    raw_attr |= FILE_SYSTEM;#elif defined( HB_OS_WIN )   raw_attr = 0;   if( nAttr & HB_FA_ARCHIVE )   raw_attr |= FILE_ATTRIBUTE_ARCHIVE;   if( nAttr & HB_FA_DIRECTORY ) raw_attr |= FILE_ATTRIBUTE_DIRECTORY;   if( nAttr & HB_FA_HIDDEN )    raw_attr |= FILE_ATTRIBUTE_HIDDEN;   if( nAttr & HB_FA_READONLY )  raw_attr |= FILE_ATTRIBUTE_READONLY;   if( nAttr & HB_FA_SYSTEM )    raw_attr |= FILE_ATTRIBUTE_SYSTEM;   if( nAttr & HB_FA_NORMAL )    raw_attr |= FILE_ATTRIBUTE_NORMAL;   /* Note that FILE_ATTRIBUTE_NORMAL is not needed      HB_FA_DEVICE not supported      HB_FA_VOLCOMP needs to be checked */   if( nAttr & HB_FA_ENCRYPTED )  raw_attr |= FILE_ATTRIBUTE_ENCRYPTED;   if( nAttr & HB_FA_TEMPORARY )  raw_attr |= FILE_ATTRIBUTE_TEMPORARY;   if( nAttr & HB_FA_SPARSE )     raw_attr |= FILE_ATTRIBUTE_SPARSE_FILE;   if( nAttr & HB_FA_REPARSE )    raw_attr |= FILE_ATTRIBUTE_REPARSE_POINT;   if( nAttr & HB_FA_COMPRESSED ) raw_attr |= FILE_ATTRIBUTE_COMPRESSED;   if( nAttr & HB_FA_OFFLINE )    raw_attr |= FILE_ATTRIBUTE_OFFLINE;   if( nAttr & HB_FA_NOTINDEXED ) raw_attr |= 0x00002000; /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED not defined in some older winnt.h */   if( nAttr & HB_FA_VOLCOMP )    raw_attr |= 0x00008000;#elif defined( HB_OS_UNIX )   raw_attr = HB_FA_POSIX_ATTR( nAttr );   if( nAttr & HB_FA_FILE )       raw_attr |= S_IFREG;   if( nAttr & HB_FA_DIRECTORY )  raw_attr |= S_IFDIR;   if( nAttr & HB_FA_LINK )       raw_attr |= S_IFLNK;   if( nAttr & HB_FA_CHRDEVICE )  raw_attr |= S_IFCHR;   if( nAttr & HB_FA_BLKDEVICE )  raw_attr |= S_IFBLK;   if( nAttr & HB_FA_FIFO )       raw_attr |= S_IFIFO;   if( nAttr & HB_FA_SOCKET )     raw_attr |= S_IFSOCK;#else   HB_SYMBOL_UNUSED( nAttr );   raw_attr = 0;#endif   return raw_attr;}

static void hb_regfree( PHB_REGEX pRegEx ){   HB_SYMBOL_UNUSED( pRegEx );}

static HB_BOOL s_fileAccept( const char * pszFileName ){   HB_SYMBOL_UNUSED( pszFileName );   return HB_FALSE;}

static PHB_FILE s_fileOpen( PHB_FILE_FUNCS pFuncs, const char * pszName,                            const char * pszDefExt, HB_USHORT uiExFlags,                            const char * pPaths, PHB_ITEM pError ){   const char * pszHost = pszName + FILE_PREFIX_LEN, * ptr;   PHB_FILE pFile = NULL;   HB_ERRCODE errcode = 0;   HB_SIZE nLen = 0;   int iPort = 0;   int timeout = -1;   HB_SYMBOL_UNUSED( pFuncs );   HB_SYMBOL_UNUSED( pszDefExt );   HB_SYMBOL_UNUSED( pPaths );   if( ( ptr = strchr( pszHost, ':' ) ) != NULL && ptr != pszHost )   {      nLen = ptr - pszHost;      ++ptr;      while( HB_ISDIGIT( * ptr ) )         iPort = iPort * 10 + ( * ptr++ - '0' );      if( * ptr == ':' )      {         ++ptr;         while( HB_ISDIGIT( * ptr ) )            timeout = HB_MAX( timeout, 0 ) * 10 + ( * ptr++ - '0' );      }      if( * ptr != 0 && * ptr != ':' )         iPort = 0;   }   if( iPort > 0 )   {      char * pszAddr, * pszIpAddr;      pszAddr = hb_strndup( pszHost, nLen );      pszIpAddr = hb_socketResolveAddr( pszAddr, HB_SOCKET_AF_INET );      hb_xfree( pszAddr );      if( pszIpAddr )      {         HB_SOCKET sd = hb_socketOpen( HB_SOCKET_PF_INET, HB_SOCKET_PT_STREAM, 0 );         if( sd != HB_NO_SOCKET )         {            void * pSockAddr;            unsigned uiLen;            if( hb_socketInetAddr( &pSockAddr, &uiLen, pszIpAddr, iPort ) )            {               hb_socketSetKeepAlive( sd, HB_TRUE );               if( hb_socketConnect( sd, pSockAddr, uiLen, timeout ) == 0 )               {                  switch( uiExFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) )                  {                     case FO_READ:                        hb_socketShutdown( sd, HB_SOCKET_SHUT_WR );                        break;                     case FO_WRITE:                        hb_socketShutdown( sd, HB_SOCKET_SHUT_RD );                        break;                  }                  pFile = s_fileNew( sd, timeout );                  sd = HB_NO_SOCKET;               }               hb_xfree( pSockAddr );            }            if( sd != HB_NO_SOCKET )            {               errcode = hb_socketGetError();               hb_socketClose( sd );            }         }         hb_xfree( pszIpAddr );      }      if( errcode == 0 && pFile == NULL )         errcode = hb_socketGetError();   }   else      errcode = HB_SOCKET_ERR_WRONGADDR;   hb_fsSetError( errcode );   if( pError )   {      hb_errPutFileName( pError, pszName );      if( pFile == NULL )      {         hb_errPutOsCode( pError, errcode );         hb_errPutGenCode( pError, ( HB_ERRCODE ) EG_OPEN );      }   }   return pFile;}

BOOL WINAPI SetCurrentDirectoryW( LPCWSTR dirname ){   HB_SYMBOL_UNUSED( dirname );   return FALSE;}

UINT WINAPI SetErrorMode( UINT mode ){   HB_SYMBOL_UNUSED( mode );   return 0;}

HB_ERRCODE hb_rddSelectWorkAreaNumber( int iArea ){   HB_SYMBOL_UNUSED( iArea );   return HB_FAILURE;}

HB_ERRCODE hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias ){   HB_SYMBOL_UNUSED( pSymAlias );   return HB_FAILURE;}

HB_ERRCODE hb_rddSelectWorkAreaAlias( const char * szName ){   HB_SYMBOL_UNUSED( szName );   return HB_FAILURE;}

void hb_rddWaShutDown( PHB_STACKRDD pRddInfo ){   HB_SYMBOL_UNUSED( pRddInfo );}

static void hb_pcre2_free( void * ptr, void * data ){   HB_SYMBOL_UNUSED( data );   if( ptr )      hb_xfree( ptr );}

static void s_fileFlush( PHB_FILE pFile, HB_BOOL fDirty ){   HB_SYMBOL_UNUSED( pFile );   HB_SYMBOL_UNUSED( fDirty );}

HANDLE WINAPI GetStdHandle( DWORD nStdHandle ){   HB_SYMBOL_UNUSED( nStdHandle );   return NULL;}

static void s_fileCommit( PHB_FILE pFile ){   HB_SYMBOL_UNUSED( pFile );   hb_fsSetError( HB_FILE_ERR_UNSUPPORTED );}

DWORD WINAPI GetFileType( HANDLE handle ){   HB_SYMBOL_UNUSED( handle );   return 0;}

static HB_BOOL s_fileAccept( PHB_FILE_FUNCS pFuncs, const char * pszFileName ){   HB_SYMBOL_UNUSED( pFuncs );   return hb_strnicmp( pszFileName, FILE_PREFIX, FILE_PREFIX_LEN ) == 0;}

BOOL WINAPI SetKeyboardState( PBYTE p ){   HB_SYMBOL_UNUSED( p );   return FALSE;}

HB_FATTR hb_fsAttrFromRaw( HB_FATTR raw_attr ){   HB_FATTR nAttr;   HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrFromRaw(%u)", raw_attr ) );#if defined( HB_OS_DOS )   nAttr = 0;   if( raw_attr & FA_ARCH )   nAttr |= HB_FA_ARCHIVE;   if( raw_attr & FA_DIREC )  nAttr |= HB_FA_DIRECTORY;   if( raw_attr & FA_HIDDEN ) nAttr |= HB_FA_HIDDEN;   if( raw_attr & FA_RDONLY ) nAttr |= HB_FA_READONLY;   if( raw_attr & FA_LABEL )  nAttr |= HB_FA_LABEL;   if( raw_attr & FA_SYSTEM ) nAttr |= HB_FA_SYSTEM;#elif defined( HB_OS_OS2 )   nAttr = 0;   if( raw_attr & FILE_ARCHIVED )  nAttr |= HB_FA_ARCHIVE;   if( raw_attr & FILE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY;   if( raw_attr & FILE_HIDDEN )    nAttr |= HB_FA_HIDDEN;   if( raw_attr & FILE_READONLY )  nAttr |= HB_FA_READONLY;   if( raw_attr & FILE_SYSTEM )    nAttr |= HB_FA_SYSTEM;#elif defined( HB_OS_WIN )   nAttr = 0;   if( raw_attr & FILE_ATTRIBUTE_ARCHIVE )   nAttr |= HB_FA_ARCHIVE;   if( raw_attr & FILE_ATTRIBUTE_DIRECTORY ) nAttr |= HB_FA_DIRECTORY;   if( raw_attr & FILE_ATTRIBUTE_HIDDEN )    nAttr |= HB_FA_HIDDEN;   if( raw_attr & FILE_ATTRIBUTE_READONLY )  nAttr |= HB_FA_READONLY;   if( raw_attr & FILE_ATTRIBUTE_SYSTEM )    nAttr |= HB_FA_SYSTEM;   if( raw_attr & FILE_ATTRIBUTE_NORMAL )    nAttr |= HB_FA_NORMAL;   /* Note that FILE_ATTRIBUTE_NORMAL is not needed      HB_FA_DEVICE not supported      HB_FA_VOLCOMP needs to be checked */   if( raw_attr & FILE_ATTRIBUTE_ENCRYPTED )     nAttr |= HB_FA_ENCRYPTED;   if( raw_attr & FILE_ATTRIBUTE_TEMPORARY )     nAttr |= HB_FA_TEMPORARY;   if( raw_attr & FILE_ATTRIBUTE_SPARSE_FILE )   nAttr |= HB_FA_SPARSE;   if( raw_attr & FILE_ATTRIBUTE_REPARSE_POINT ) nAttr |= HB_FA_REPARSE;   if( raw_attr & FILE_ATTRIBUTE_COMPRESSED )    nAttr |= HB_FA_COMPRESSED;   if( raw_attr & FILE_ATTRIBUTE_OFFLINE )       nAttr |= HB_FA_OFFLINE;   /* FILE_ATTRIBUTE_NOT_CONTENT_INDEXED */   /* not defined in some older winnt.h  */   if( raw_attr & 0x00002000 )                   nAttr |= HB_FA_NOTINDEXED;   if( raw_attr & 0x00008000 )                   nAttr |= HB_FA_VOLCOMP;#elif defined( HB_OS_UNIX )   nAttr = ( ( raw_attr & S_IXOTH ) ? HB_FA_XOTH : 0 ) |           ( ( raw_attr & S_IWOTH ) ? HB_FA_WOTH : 0 ) |           ( ( raw_attr & S_IROTH ) ? HB_FA_ROTH : 0 ) |           ( ( raw_attr & S_IXGRP ) ? HB_FA_XGRP : 0 ) |           ( ( raw_attr & S_IWGRP ) ? HB_FA_WGRP : 0 ) |           ( ( raw_attr & S_IRGRP ) ? HB_FA_RGRP : 0 ) |           ( ( raw_attr & S_IXUSR ) ? HB_FA_XUSR : 0 ) |           ( ( raw_attr & S_IWUSR ) ? HB_FA_WUSR : 0 ) |           ( ( raw_attr & S_IRUSR ) ? HB_FA_RUSR : 0 ) |           ( ( raw_attr & S_ISVTX ) ? HB_FA_SVTX : 0 ) |           ( ( raw_attr & S_ISGID ) ? HB_FA_SGID : 0 ) |           ( ( raw_attr & S_ISUID ) ? HB_FA_SUID : 0 );   if( S_ISREG( raw_attr ) )  nAttr |= HB_FA_FILE;   if( S_ISDIR( raw_attr ) )  nAttr |= HB_FA_DIRECTORY;   if( S_ISLNK( raw_attr ) )  nAttr |= HB_FA_LINK;   if( S_ISCHR( raw_attr ) )  nAttr |= HB_FA_CHRDEVICE;   if( S_ISBLK( raw_attr ) )  nAttr |= HB_FA_BLKDEVICE;   if( S_ISFIFO( raw_attr ) ) nAttr |= HB_FA_FIFO;#if ! defined( HB_OS_VXWORKS )   if( S_ISSOCK( raw_attr ) ) nAttr |= HB_FA_SOCKET;#endif#else   nAttr = 0;   HB_SYMBOL_UNUSED( raw_attr );#endif   return nAttr;}

static HB_ERRCODE sddDisconnect( SQLDDCONNECTION * pConnection ){   HB_SYMBOL_UNUSED( pConnection );   hb_errRT_SQLBASE( EG_UNSUPPORTED, ESQLDD_NULLSDD, NULL, NULL );   return HB_FAILURE;}

//.........这里部分代码省略.........               iDay   = lt.tm_mday;               iHour = lt.tm_hour;               iMin  = lt.tm_min;               iSec  = lt.tm_sec;#  if defined( HB_OS_LINUX ) && /      defined( __GLIBC__ ) && defined( __GLIBC_MINOR__ ) && /      ( __GLIBC__ > 2 || ( __GLIBC__ == 2 && __GLIBC_MINOR__ >= 6 ) )#     if defined( _BSD_SOURCE ) || defined( _SVID_SOURCE ) || /         ( __GLIBC_MINOR__ >= 12 && /           ( ( defined( _POSIX_C_SOURCE ) || _POSIX_C_SOURCE >= 200809L ) || /             ( defined( _XOPEN_SOURCE ) || _XOPEN_SOURCE >= 700 ) ) )               iMSec = sStat.st_mtim.tv_nsec / 1000000;#     else               iMSec = sStat.st_mtimensec / 1000000;#     endif#  endif            }            else               bFound = HB_FALSE;         }      }      hb_fsSetIOError( bFound, 0 );   }#else   {      int iTODO; /* TODO: for given platform */      /* HB_SYMBOL_UNUSED( ffind ); */      HB_SYMBOL_UNUSED( iYear );      HB_SYMBOL_UNUSED( iMonth );      HB_SYMBOL_UNUSED( iDay );      HB_SYMBOL_UNUSED( iHour );      HB_SYMBOL_UNUSED( iMin );      HB_SYMBOL_UNUSED( iSec );      HB_SYMBOL_UNUSED( iMSec );      HB_SYMBOL_UNUSED( raw_attr );      bFound = HB_FALSE;      hb_fsSetIOError( bFound, 0 );   }#endif   /* Fill common Harbour found file info */   if( bFound )   {      /* Do the conversions common for all platforms */      ffind->szName[ sizeof( ffind->szName ) - 1 ] = '/0';#if ! defined( HB_OS_WIN )      /* Convert from OS codepage */      {         char * pszFree = NULL;         HB_SIZE nSize = sizeof( ffind->szName );         const char * pszResult = hb_osDecodeCP( ffind->szName, &pszFree, &nSize );         if( pszFree )         {            hb_strncpy( ffind->szName, pszResult, sizeof( ffind->szName ) - 1 );

static HB_ERRCODE sddOpen( SQLBASEAREAP pArea ){   HB_SYMBOL_UNUSED( pArea );   hb_errRT_SQLBASE( EG_UNSUPPORTED, ESQLDD_NULLSDD, NULL, NULL );   return HB_FAILURE;}

static int hb_regcomp( PHB_REGEX pRegEx, const char * szRegEx ){   HB_SYMBOL_UNUSED( pRegEx );   HB_SYMBOL_UNUSED( szRegEx );   return -1;}

static HB_ERRCODE sddClose( SQLBASEAREAP pArea ){   HB_SYMBOL_UNUSED( pArea );   return HB_SUCCESS;}

static void hbqt_lib_init( void * cargo ){   HB_SYMBOL_UNUSED( cargo );   hbqt_registerCallbacks();}

static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ){   HB_ULONG ulConn;   SQLDDCONNECTION * pConn;   HB_SYMBOL_UNUSED( pRDD );   ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent;   if( ulConn > 0 && ulConn <= s_ulConnectionCount )      pConn = s_pConnection[ ulConn - 1 ];   else      pConn = NULL;   switch( uiIndex )   {      case RDDI_REMOTE:         hb_itemPutL( pItem, HB_TRUE );         break;      case RDDI_CONNECTION:      {         HB_ULONG ulNewConnection = 0;         if( hb_itemType( pItem ) & HB_IT_NUMERIC )            ulNewConnection = hb_itemGetNL( pItem );         hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent );         if( ulNewConnection )            s_ulConnectionCurrent = ulNewConnection;         break;      }      case RDDI_ISDBF:         hb_itemPutL( pItem, HB_FALSE );         break;      case RDDI_CANPUTREC:         hb_itemPutL( pItem, HB_TRUE );         break;      case RDDI_CONNECT:      {         PSDDNODE     pNode = NULL;         HB_ULONG     ul;         const char * pStr;         pStr = hb_arrayGetCPtr( pItem, 1 );         if( pStr )         {            pNode = s_pSdd;            while( pNode )            {               if( ! hb_stricmp( pNode->Name, pStr ) )                  break;               pNode = pNode->pNext;            }         }         hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );         pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) );         memset( pConn, 0, sizeof( SQLDDCONNECTION ) );         if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS )         {            pConn->pSDD = pNode;            /* Find free connection handle */            for( ul = 0; ul < s_ulConnectionCount; ul++ )            {               if( ! s_pConnection[ ul ] )                  break;            }            if( ul >= s_ulConnectionCount )            {               /* Realloc connection table */               if( s_pConnection )                  s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) );               else                  s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );               memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );               ul = s_ulConnectionCount;               s_ulConnectionCount += CONNECTION_LIST_EXPAND;            }            s_pConnection[ ul ] = pConn;            ul++;            s_ulConnectionCurrent = ul;         }         else         {            hb_xfree( pConn );            ul = 0;         }         hb_itemPutNI( pItem, ul );         break;      }      case RDDI_DISCONNECT:         hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );//.........这里部分代码省略.........

//.........这里部分代码省略.........               if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT )               {                  HB_I64 val = 0;                  /* NOTE: SQL_C_SBIGINT not available before ODBC 3.0 */                  if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_SBIGINT, &val, sizeof( val ), &iLen ) ) )                     pItem = hb_itemPutNIntLen( pItem, val, pField->uiLen );               }               else#endif               {                  SQLINTEGER val = 0;                  if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )                     pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );               }               break;            case HB_FT_LONG:               if( pField->uiDec == 0 && pField->uiLen < 10 )               {                  SQLINTEGER val = 0;                  if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) )                     pItem = hb_itemPutNLLen( pItem, val, pField->uiLen );               }               else               {                  double val = 0.0;                  if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )                     pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );               }               break;            case HB_FT_DOUBLE:            {               double val = 0.0;               if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) )                  pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec );               break;            }            case HB_FT_LOGICAL:            {               unsigned char val = 0;               if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BIT, &val, sizeof( val ), &iLen ) ) )                  pItem = hb_itemPutL( pItem, val != 0 );               break;            }            case HB_FT_DATE:            {               DATE_STRUCT val = { 0, 0, 0 };               if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DATE, &val, sizeof( val ), &iLen ) ) )                  pItem = hb_itemPutD( pItem, val.year, val.month, val.day );               break;            }            case HB_FT_TIME:            {               TIME_STRUCT val = { 0, 0, 0 };               if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIME, &val, sizeof( val ), &iLen ) ) )                  pItem = hb_itemPutTDT( pItem, 0, hb_timeEncode( val.hour, val.minute, val.second, 0 ) );               break;            }            case HB_FT_TIMESTAMP:            {               TIMESTAMP_STRUCT val = { 0, 0, 0, 0, 0, 0, 0 };               if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIMESTAMP, &val, sizeof( val ), &iLen ) ) )                  pItem = hb_itemPutTDT( pItem, hb_dateEncode( val.year, val.month, val.day ),                                         hb_timeEncode( val.hour, val.minute, val.second, val.fraction / 1000000 ) );               break;            }         }         /* TODO: check SQL_SUCCEEDED( res ) */         /* TODO: check for SQL_NO_TOTAL. What does this mean? */         HB_SYMBOL_UNUSED( res );         if( pItem )         {            /* NULL -> NIL */            if( iLen == SQL_NULL_DATA )               hb_itemClear( pItem );            else               hb_arraySetForward( pArray, ui, pItem );         }      }      if( pItem )         hb_itemRelease( pItem );      if( pArea->ulRecCount + 1 >= pArea->ulRecMax )      {         pArea->pRow      = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) );         pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) );         pArea->ulRecMax += SQLDD_ROWSET_RESIZE;      }      pArea->ulRecCount++;      pArea->pRow[ pArea->ulRecCount ]      = pArray;      pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED;   }

static int hb_regexec( PHB_REGEX pRegEx, const char * szString, HB_SIZE nLen,                       int iMatches, HB_REGMATCH * aMatches ){#if defined( HB_HAS_PCRE2 )   PCRE2_SIZE iResult = pcre2_match( pRegEx->re_pcre,                                     ( PCRE2_SPTR ) szString,                                     ( PCRE2_SIZE ) nLen,                                     ( PCRE2_SIZE ) 0 /* startoffset */,                                     ( uint32_t ) pRegEx->iEFlags,                                     aMatches, s_re_ctxm );   if( iResult == 0 )   {      PCRE2_SIZE i;      for( i = 0; i < ( PCRE2_SIZE ) iMatches; i++ )      {         if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )            iResult = i + 1;      }   }   return ( int ) iResult;#elif defined( HB_HAS_PCRE )   int iResult = pcre_exec( pRegEx->re_pcre, NULL /* pcre_extra */,                            szString, ( int ) nLen, 0 /* startoffset */,                            pRegEx->iEFlags, aMatches, HB_REGMATCH_SIZE( iMatches ) );   if( iResult == 0 )   {      int i;      for( i = 0; i < iMatches; i++ )      {         if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )            iResult = i + 1;      }   }   return iResult;#elif defined( HB_POSIX_REGEX )   char * szBuffer = NULL;   int iResult, i;   if( szString[ nLen ] != 0 )   {      szBuffer = hb_strndup( szString, nLen );      szString = szBuffer;   }   for( i = 0; i < iMatches; i++ )      HB_REGMATCH_EO( aMatches, i ) = HB_REGMATCH_UNSET;   iResult = regexec( &pRegEx->reg, szString, iMatches, aMatches, pRegEx->iEFlags );   if( iResult == 0 )   {      for( i = 0; i < iMatches; i++ )      {         if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET )            iResult = i + 1;      }   }   else      iResult = -1;   if( szBuffer )      hb_xfree( szBuffer );   return iResult;#else   HB_SYMBOL_UNUSED( pRegEx );   HB_SYMBOL_UNUSED( szString );   HB_SYMBOL_UNUSED( nLen );   HB_SYMBOL_UNUSED( iMatches );   HB_SYMBOL_UNUSED( aMatches );   return -1;#endif}