static char * ocilibGetError( HB_ERRCODE * pErrCode )
{
OCI_Error * err = OCI_GetLastError();
char * szRet;
int iNativeErr;
if( err )
{
PHB_ITEM pRet = M_HB_ITEMPUTSTR( NULL, OCI_ErrorGetString( err ) );
szRet = hb_strdup( hb_itemGetCPtr( pRet ) );
hb_itemRelease( pRet );
iNativeErr = OCI_ErrorGetOCICode( err );
}
else
{
szRet = hb_strdup( "Unable to get error message" );
iNativeErr = 9999;
}
if( pErrCode )
*pErrCode = ( HB_ERRCODE ) iNativeErr;
return szRet;
}
static void hb_delimInitArea( DELIMAREAP pArea, char * szFileName )
{
char * szEol;
/* Allocate only after succesfully open file */
pArea->szFileName = hb_strdup( szFileName );
/* set line separator: EOL */
szEol = hb_setGetEOL();
if( !szEol || !szEol[ 0 ] )
szEol = hb_conNewLine();
pArea->szEol = hb_strdup( szEol );
pArea->uiEolLen = strlen( pArea->szEol );
/* allocate record buffer, one additional byte is for deleted flag */
pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen + 1 );
/* pseudo deleted flag */
*pArea->pRecord++ = ' ';
/* Allocate IO buffer */
pArea->ulBufferSize += pArea->uiEolLen;
pArea->pBuffer = ( BYTE * ) hb_xgrab( pArea->ulBufferSize );
pArea->ulRecCount = 0;
pArea->ulFileSize = 0;
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
}
void hb_rddsqlSetError( HB_ERRCODE errCode, const char * szError, const char * szQuery, PHB_ITEM pItem, unsigned long ulAffectedRows )
{
s_errCode = errCode;
if( s_szError )
{
hb_xfree( s_szError );
s_szError = NULL;
}
if( szError )
s_szError = hb_strdup( szError );
if( s_szQuery )
{
hb_xfree( s_szQuery );
s_szQuery = NULL;
}
if( szQuery )
s_szQuery = hb_strdup( szQuery );
if( pItem )
hb_itemCopy( s_pItemNewID, pItem );
else
hb_itemClear( s_pItemNewID );
s_ulAffectedRows = ulAffectedRows;
}
static void hb_gt_cgi_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRDIFF ) hFilenoStdin, ( void * ) ( HB_PTRDIFF ) hFilenoStdout, ( void * ) ( HB_PTRDIFF ) hFilenoStderr ) );
pGTCGI = ( PHB_GTCGI ) hb_xgrab( sizeof( HB_GTCGI ) );
memset( pGTCGI, 0, sizeof( HB_GTCGI ) );
HB_GTLOCAL( pGT ) = pGTCGI;
pGTCGI->hStdout = hFilenoStdout;
#if defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE )
if( IsValidCodePage( CP_UTF8 ) )
{
pGTCGI->uiOldCP = GetConsoleOutputCP();
SetConsoleOutputCP( CP_UTF8 );
HB_GTSELF_SETDISPCP( pGT, "UTF8", NULL, HB_FALSE );
}
#endif
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->nCrLf = strlen( pGTCGI->szCrLf );
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, HB_TRUE );
}
static PHB_IOUSR s_iousrAddNew( const char * pszPrefix )
{
PHB_IOUSR pIO = NULL;
int iCount;
HB_IOUSR_LOCK();
iCount = s_iCount;
while( --iCount >= 0 )
{
if( hb_stricmp( pszPrefix, s_ioUsrs[ iCount ]->prefix ) == 0 )
break;
}
if( iCount < 0 )
{
if( s_iCount == 0 )
hb_vmAtQuit( s_iousrFreeAll, NULL );
pIO = ( PHB_IOUSR ) hb_xgrabz( sizeof( HB_IOUSR ) );
pIO->prefix = hb_strdup( pszPrefix );
pIO->prefix_len = ( int ) strlen( pszPrefix );
s_ioUsrs[ s_iCount++ ] = pIO;
}
HB_IOUSR_UNLOCK();
return pIO;
}
/* create a new identifier or return the existing one
*/
const char * hb_compIdentifierNew( HB_COMP_DECL, const char * szName, int iType )
{
const char * szIdent;
szIdent = ( const char * ) hb_hashTableFind( HB_COMP_PARAM->pIdentifiers,
( const void * ) szName );
if( ! szIdent )
{
/*
* In the future we may add direct support for static identifiers
* so it will not be necessary to allocate separate buffer for them
*/
if( iType == HB_IDENT_COPY || iType == HB_IDENT_STATIC )
szIdent = hb_strdup( szName );
else
szIdent = szName;
hb_hashTableAdd( HB_COMP_PARAM->pIdentifiers,
( const void * ) szIdent, ( const void * ) szIdent );
}
else if( iType == HB_IDENT_FREE )
hb_xfree( ( void * ) szName );
return szIdent;
}
/*
* Function that adds zero or more paths to a list of pathnames to search
*/
void hb_fsAddSearchPath( const char * szPath, HB_PATHNAMES ** pSearchList )
{
char * pPath;
char * pDelim;
HB_BOOL fFree = HB_TRUE;
while( *pSearchList )
pSearchList = &( *pSearchList )->pNext;
pPath = hb_strdup( szPath );
while( ( pDelim = strchr( pPath, HB_OS_PATH_LIST_SEP_CHR ) ) != NULL )
{
*pDelim = '\0';
*pSearchList = ( HB_PATHNAMES * ) hb_xgrab( sizeof( HB_PATHNAMES ) );
( *pSearchList )->szPath = pPath;
( *pSearchList )->fFree = fFree;
pSearchList = &( *pSearchList )->pNext;
pPath = pDelim + 1;
fFree = HB_FALSE;
}
*pSearchList = ( HB_PATHNAMES * ) hb_xgrab( sizeof( HB_PATHNAMES ) );
( *pSearchList )->szPath = pPath;
( *pSearchList )->pNext = NULL;
( *pSearchList )->fFree = fFree;
}
static void hb_gt_cgi_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", ( void * ) pGT, ( void * ) ( HB_PTRUINT ) hFilenoStdin, ( void * ) ( HB_PTRUINT ) hFilenoStdout, ( void * ) ( HB_PTRUINT ) hFilenoStderr ) );
HB_GTLOCAL( pGT ) = pGTCGI = ( PHB_GTCGI ) hb_xgrabz( sizeof( HB_GTCGI ) );
pGTCGI->pGT = pGT;
pGTCGI->hStdout = hFilenoStdout;
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->nCrLf = strlen( pGTCGI->szCrLf );
#ifdef HB_GT_CGI_WIN
{
DWORD dwMode;
pGTCGI->fIsConsole = GetConsoleMode( DosToWinHandle( pGTCGI->hStdout ), &dwMode );
if( pGTCGI->fIsConsole )
HB_GTSELF_SETDISPCP( pGT, "UTF8", NULL, HB_FALSE );
}
#endif
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, HB_TRUE );
}
static int hb_zipStoreFileHandle( zipFile hZip, HB_FHANDLE hFile, const char * szName, const char * szPassword, const char * szComment )
{
char * szZipName;
HB_SIZE nLen;
zip_fileinfo zfi;
int iResult;
HB_BOOL fText;
HB_U32 ulCRC;
if( hFile == FS_ERROR || szName == NULL )
return -200;
/* change path separators to '/' */
szZipName = hb_strdup( szName );
nLen = strlen( szZipName );
while( nLen-- )
{
if( szZipName[ nLen ] == '\\' )
szZipName[ nLen ] = '/';
}
memset( &zfi, 0, sizeof( zfi ) );
zfi.external_fa = 0x81B60020;
zfi.tmz_date.tm_sec = 0;
zfi.tmz_date.tm_min = 0;
zfi.tmz_date.tm_hour = 0;
zfi.tmz_date.tm_mday = 1;
zfi.tmz_date.tm_mon = 0;
zfi.tmz_date.tm_year = 0;
ulCRC = 0;
fText = HB_FALSE;
if( szPassword && hb_zipGetFileInfoFromHandle( hFile, &ulCRC, &fText ) )
zfi.internal_fa = fText ? 1 : 0;
else
/* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
extension. We should analyse content of file to determine this??? */
zfi.internal_fa = 0;
iResult = zipOpenNewFileInZip3( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC );
if( iResult == 0 )
{
char * pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
hb_fsSeek( hFile, 0, FS_SET );
while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
hb_xfree( pString );
zipCloseFileInZip( hZip );
}
hb_xfree( szZipName );
return iResult;
}
static void hb_compChkDefineSwitch( HB_COMP_DECL, const char * pszSwitch )
{
if( pszSwitch && HB_ISOPTSEP( pszSwitch[ 0 ] ) )
{
if( pszSwitch[ 1 ] == 'd' || pszSwitch[ 1 ] == 'D' )
{
if( pszSwitch[ 2 ] )
{
char * szDefText = hb_strdup( pszSwitch + 2 ), * szAssign;
szAssign = strchr( szDefText, '=' );
if( szAssign )
*szAssign++ = '\0';
hb_pp_addDefine( HB_COMP_PARAM->pLex->pPP, szDefText, szAssign );
hb_xfree( szDefText );
}
}
else if( ( pszSwitch[ 1 ] == 'U' || pszSwitch[ 1 ] == 'u' ) &&
( pszSwitch[ 2 ] == 'N' || pszSwitch[ 2 ] == 'n' ) &&
( pszSwitch[ 3 ] == 'D' || pszSwitch[ 3 ] == 'd' ) &&
( pszSwitch[ 4 ] == 'E' || pszSwitch[ 4 ] == 'e' ) &&
( pszSwitch[ 5 ] == 'F' || pszSwitch[ 5 ] == 'f' ) &&
pszSwitch[ 6 ] == ':' )
{
char *szDefText = hb_strdup( pszSwitch + 7 );
unsigned int i = 0;
while( szDefText[ i ] && ! HB_ISOPTSEP( szDefText[ i ] ) )
{
i++;
}
szDefText[ i ] = '\0';
if( szDefText[ 0 ] )
{
if( hb_stricmp( szDefText, ".ARCH." ) == 0 )
hb_pp_delDefine( HB_COMP_PARAM->pLex->pPP, szDefText );
}
hb_xfree( szDefText );
}
}
}
static char * s_fileLinkRead( PHB_FILE_FUNCS pFuncs, const char * pszFileName )
{
PHB_IOUSR pIO = ( PHB_IOUSR ) pFuncs;
const char * pszLink;
s_pushMethod( pIO, IOUSR_LINKREAD );
hb_vmPushString( pszFileName, strlen( pszFileName ) );
hb_vmDo( 1 );
pszLink = hb_parc( -1 );
return pszLink != NULL ? hb_strdup( pszLink ) : NULL;
}
static void hb_sdfInitArea( SDFAREAP pArea, char * szFileName )
{
const char * szEol;
/* Allocate only after succesfully open file */
pArea->szFileName = hb_strdup( szFileName );
/* set line separator: EOL */
szEol = hb_setGetEOL();
if( ! szEol || ! szEol[ 0 ] )
szEol = hb_conNewLine();
pArea->szEol = hb_strdup( szEol );
pArea->uiEolLen = ( HB_USHORT ) strlen( pArea->szEol );
/* Alloc buffer */
pArea->pRecord = ( HB_BYTE * ) hb_xgrab( pArea->uiRecordLen + pArea->uiEolLen + 3 );
/* pseudo deleted flag */
*pArea->pRecord++ = ' ';
pArea->nFileSize = 0;
pArea->ulRecCount = 0;
}
static char * sqlite3GetError( sqlite3 * pDb, HB_ERRCODE * pErrCode )
{
char * szRet;
int iNativeErr = 9999;
if( pDb )
{
PHB_ITEM pRet = S_HB_ITEMPUTSTR( NULL, sqlite3_errmsg( pDb ) );
szRet = hb_strdup( hb_itemGetCPtr( pRet ) );
hb_itemRelease( pRet );
iNativeErr = sqlite3_errcode( pDb );
}
else
szRet = hb_strdup( "Unable to get error message" );
if( pErrCode )
*pErrCode = ( HB_ERRCODE ) iNativeErr;
return szRet;
}
static char * odbcGetError( SQLHENV hEnv, SQLHDBC hConn, SQLHSTMT hStmt, HB_ERRCODE * pErrCode )
{
SQLTCHAR szError[ 6 + SQL_MAX_MESSAGE_LENGTH ];
SQLINTEGER iNativeErr = 9999;
SQLSMALLINT iLen;
char * szRet;
if( SQL_SUCCEEDED( SQLError( hEnv, hConn, hStmt, szError, &iNativeErr, szError + 6, SQL_MAX_MESSAGE_LENGTH, &iLen ) ) )
{
PHB_ITEM pRet;
szError[ 5 ] = ' ';
pRet = O_HB_ITEMPUTSTR( NULL, ( O_HB_CHAR * ) szError );
szRet = hb_strdup( hb_itemGetCPtr( pRet ) );
hb_itemRelease( pRet );
}
else
szRet = hb_strdup( "HY000 Could not get the error message" );
if( pErrCode )
*pErrCode = ( HB_ERRCODE ) iNativeErr;
return szRet;
}
static void hb_sdfInitArea( SDFAREAP pArea, char * szFileName )
{
const char * szEol;
/* Allocate only after succesfully open file */
pArea->szFileName = hb_strdup( szFileName );
/* set line separator: EOL */
szEol = hb_setGetEOL();
if( ! szEol || ! szEol[ 0 ] )
szEol = hb_conNewLine();
pArea->szEol = hb_strdup( szEol );
pArea->uiEolLen = ( HB_USHORT ) strlen( szEol );
pArea->fAnyEol = ( szEol[ 0 ] == '\n' || szEol[ 0 ] == '\r' ) &&
( pArea->uiEolLen == 1 ||
( pArea->uiEolLen == 2 && szEol[ 0 ] != szEol[ 1 ] &&
( szEol[ 1 ] == '\n' || szEol[ 1 ] == '\r' ) ) );
/* allocate record buffer, one additional byte is for deleted flag */
pArea->pRecord = ( HB_BYTE * ) hb_xgrab( pArea->uiRecordLen + pArea->uiEolLen + 1 );
/* pseudo deleted flag */
*pArea->pRecord++ = ' ';
memcpy( pArea->pRecord + pArea->uiRecordLen,
pArea->szEol, pArea->uiEolLen );
if( pArea->fReadonly )
{
/* allocate IO buffer */
pArea->nBufferSize += pArea->fAnyEol ? 2 : pArea->uiEolLen;
if( pArea->nBufferSize < 8192 )
pArea->nBufferSize = 8192;
pArea->pBuffer = ( HB_BYTE * ) hb_xgrab( pArea->nBufferSize );
}
pArea->ulRecCount = 0;
pArea->nBufferIndex = pArea->nBufferRead = pArea->nBufferSize;
}
static char * s_sockexName( PHB_SOCKEX pSock )
{
char * pszName = hb_sockexIsRaw( HB_BFSOCK_GET( pSock )->sock ) ? NULL :
hb_sockexName( HB_BFSOCK_GET( pSock )->sock );
if( pszName )
{
char * pszFree = pszName;
pszName = hb_xstrcpy( NULL, pSock->pFilter->pszName, "|", pszName, NULL );
hb_xfree( pszFree );
}
else
pszName = hb_strdup( pSock->pFilter->pszName );
return pszName;
}
char * hb_cmdargBaseProgName( void )
{
char * pszProgName, * pszBaseProgName = NULL;
pszProgName = hb_cmdargProgName();
if( pszProgName )
{
PHB_FNAME pFileName = hb_fsFNameSplit( pszProgName );
pszBaseProgName = hb_strdup( pFileName->szName );
hb_xfree( pFileName );
hb_xfree( pszProgName );
}
return pszBaseProgName;
}
/* ReadId
Read the next (zero terminated) identifier */
static char * hb_hrbReadId( const char * szBody, HB_SIZE nBodySize, HB_SIZE * pnBodyOffset )
{
const char * szIdx;
HB_TRACE( HB_TR_DEBUG, ( "hb_hrbReadId(%p,%" HB_PFS "u,%p)", szBody, nBodySize, pnBodyOffset ) );
szIdx = &szBody[ *pnBodyOffset ];
do
{
if( *pnBodyOffset > nBodySize )
return NULL;
}
while( szBody[ ( *pnBodyOffset )++ ] );
return hb_strdup( szIdx );
}
static char * hb_fsFileFind( const char * pszFileMask )
{
PHB_FFIND ffind;
if( ( ffind = hb_fsFindFirst( pszFileMask, HB_FA_ALL ) ) != NULL )
{
char pszFileName[ HB_PATH_MAX ];
PHB_FNAME pFileName = hb_fsFNameSplit( pszFileMask );
pFileName->szName = ffind->szName;
pFileName->szExtension = NULL;
hb_fsFNameMerge( pszFileName, pFileName );
hb_fsFindClose( ffind );
hb_xfree( pFileName );
return hb_strdup( pszFileName );
}
return NULL;
}
static void hb_gt_cgi_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRUINT ) hFilenoStdin, ( void * ) ( HB_PTRUINT ) hFilenoStdout, ( void * ) ( HB_PTRUINT ) hFilenoStderr ) );
HB_GTLOCAL( pGT ) = pGTCGI = ( PHB_GTCGI ) hb_xgrabz( sizeof( HB_GTCGI ) );
pGTCGI->hStdout = hFilenoStdout;
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->nCrLf = strlen( pGTCGI->szCrLf );
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, HB_TRUE );
}
char * hb_langName( const char * pszID )
{
char * pszName;
PHB_LANG lang;
lang = pszID ? hb_langFind( pszID ) : hb_vmLang();
if( lang )
{
pszName = ( char * ) hb_xgrab( 128 );
hb_snprintf( pszName, 128, "Harbour Language: %s %s (%s)",
hb_langGetItem( pszID, HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID ),
hb_langGetItem( pszID, HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_NAME ),
hb_langGetItem( pszID, HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_NAMENAT ) );
}
else
pszName = hb_strdup( "Harbour Language: (not installed)" );
return pszName;
}
static PHB_MEMFS_INODE memfsInodeAlloc( const char * szName )
{
PHB_MEMFS_INODE pInode = ( PHB_MEMFS_INODE ) hb_xgrab( sizeof( HB_MEMFS_INODE ) );
HB_ULONG ulInode = 0;
pInode->llSize = 0;
pInode->llAlloc = HB_MEMFS_INITSIZE;
pInode->pData = ( char * ) hb_xgrabz( ( HB_SIZE ) pInode->llAlloc );
pInode->szName = hb_strdup( szName );
pInode->uiCount = 1;
pInode->uiCountRead = pInode->uiCountWrite = 0;
pInode->uiDeny = 0;
/* Insert into inode array. Inode should not exist!!! */
if( s_fs.ulInodeCount >= s_fs.ulInodeAlloc )
{
s_fs.ulInodeAlloc += s_fs.ulInodeAlloc >> 1;
s_fs.pInodes = ( PHB_MEMFS_INODE * ) hb_xrealloc( s_fs.pInodes, s_fs.ulInodeAlloc * sizeof( PHB_MEMFS_INODE ) );
}
static HB_ERRCODE sqlbaseOpen( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo )
{
HB_ERRCODE errCode;
pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent;
if ( pArea->ulConnection == 0 || pArea->ulConnection > s_ulConnectionCount ||
! s_pConnection[ pArea->ulConnection - 1 ] )
{
hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL );
return HB_FAILURE;
}
if ( pArea->area.uiFieldCount )
/* This should not happen (in __dbTrans()), because RDD is registered with RDT_FULL */
return HB_FAILURE;
pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ];
pArea->pConnection->uiAreaCount++;
pArea->pSDD = pArea->pConnection->pSDD;
/* filename is a query */
pArea->szQuery = hb_strdup( pOpenInfo->abName );
errCode = pArea->pSDD->Open( pArea );
if ( errCode == HB_SUCCESS )
{
errCode = SUPER_OPEN( ( AREAP ) pArea, pOpenInfo );
}
if( errCode != HB_SUCCESS )
{
SELF_CLOSE( ( AREAP ) pArea );
return HB_FAILURE;
}
return SELF_GOTOP( ( AREAP ) pArea );
}
static char * hb_curl_strdup( const char * s )
{
return hb_strdup( s );
}
PHB_ZEBRA hb_zebra_create_qrcode( const char * szCode, HB_SIZE nLen, int iFlags )
{
PHB_ZEBRA pZebra;
PHB_BITBUFFER pData, pFinal;
unsigned char * pECC;
int iVersion, iLevel, iMask;
pZebra = hb_zebra_create();
pZebra->iType = HB_ZEBRA_TYPE_QRCODE;
if( nLen > 7089 )
{
pZebra->iError = HB_ZEBRA_ERROR_TOOLARGE;
return pZebra;
}
switch( iFlags & HB_ZEBRA_FLAG_QR_LEVEL_MASK )
{
case HB_ZEBRA_FLAG_QR_LEVEL_M:
iLevel = 1;
break;
case HB_ZEBRA_FLAG_QR_LEVEL_Q:
iLevel = 2;
break;
case HB_ZEBRA_FLAG_QR_LEVEL_H:
iLevel = 3;
break;
default:
iLevel = 0;
break;
}
#ifdef DEBUG_CODE
HB_TRACE( HB_TR_ALWAYS, ( "qr1 iLevel:%d", iLevel ) );
#endif
pData = hb_bitbuffer_create();
iVersion = _qr_dataencode( szCode, nLen, pData, iLevel );
#ifdef DEBUG_CODE
HB_TRACE( HB_TR_ALWAYS, ( "qr3 iVersion:%d", iVersion ) );
#endif
if( iVersion == 0 )
{
hb_bitbuffer_destroy( pData );
pZebra->iError = HB_ZEBRA_ERROR_TOOLARGE;
return pZebra;
}
pZebra->iCol = _qr_versionlength( iVersion );
pZebra->szCode = hb_strdup( szCode );
pECC = _qr_checksum( pData, iVersion, iLevel );
pFinal = _qr_interlace( pData, pECC, iVersion, iLevel );
hb_bitbuffer_destroy( pData );
hb_xfree( pECC );
pZebra->pBits = hb_bitbuffer_create();
_qr_draw( pZebra->pBits, pFinal, iVersion );
hb_bitbuffer_destroy( pFinal );
iMask = _qr_mask( pZebra->pBits, iVersion );
_qr_draw_version_format( pZebra->pBits, iVersion, iLevel, iMask );
return pZebra;
}
char * hb_osStrDecode( const char * pszName )
{
return hb_strdup( pszName );
}
static int hb_pp_parseChangelog( PHB_PP_STATE pState, const char * pszFileName,
BOOL fQuiet, char * piSVNID, char * piSVNDateID,
char ** pszChangeLogID, char ** pszLastEntry )
{
int iResult = 0;
const char * pszFile;
FILE * file_in;
pszFile = pszFileName ? pszFileName : "../../../../ChangeLog";
do
{
if( hb_fsFileExists( pszFile ) )
break;
pszFile += 3;
}
while( ! pszFileName && ( *pszFile == '.' || *pszFile == 'C' ) );
file_in = hb_fopen( pszFile, "r" );
if( ! file_in )
{
if( ! fQuiet )
{
#if ! defined( __MINGW32CE__ ) && ! defined( HB_OS_WIN_CE )
perror( pszFile );
#else
fprintf( stderr, "Cannot open the %s file.\n", pszFile );
#endif
}
iResult = 1;
}
else
{
char szLine[ 256 ];
char szLine1[ 256 ];
char szId[ 128 ];
char szLog[ 128 ];
char * szFrom, * szTo;
int iLen;
*szId = *szLog = *szLine1 = '\0';
do
{
if( ! fgets( szLine, sizeof( szLine ), file_in ) )
break;
if( ! *szId )
{
szFrom = strstr( szLine, "$Id: " );
if( szFrom )
{
szFrom += 5;
szTo = strstr( szFrom, " $" );
if( szTo )
{
*szTo = 0;
}
hb_strncpy( szId, szFrom, sizeof( szId ) - 1 );
hb_strncpy( szLine1, szLine + 1, sizeof( szLine1 ) - 1 );
}
}
else if( ! *szLog )
{
if( szLine[ 4 ] == '-' && szLine[ 7 ] == '-' &&
szLine[ 10 ] == ' ' && szLine[ 13 ] == ':' )
{
int iLen;
hb_strncpy( szLog, szLine, sizeof( szLog ) - 1 );
iLen = strlen( szLog );
while( iLen-- && HB_ISSPACE( szLog[ iLen ] ) )
szLog[ iLen ] = '\0';
}
}
}
while( ! *szLog );
fclose( file_in );
if( ! *szLog )
{
if( ! fQuiet )
fprintf( stderr, "Cannot find valid $Id end log entry in the %s file.\n", pszFile );
iResult = 1;
}
else
{
char _szId[ 6 ];
int u = 0;
hb_xmemset( _szId, 0, 6 );
*szLine = '"';
hb_strncpy( szLine + 1, szLog, sizeof( szLine ) - 3 );
iLen = strlen( szLine );
szLine[ iLen ] = '"';
szLine[ ++iLen ] = '\0';
hb_pp_addDefine( pState, "HB_VER_LENTRY", szLine );
*pszLastEntry = hb_strdup( szLog );
hb_strncpy( szLine + 1, szId, sizeof( szLine ) - 3 );
iLen = strlen( szLine );
szLine[ iLen ] = '"';
szLine[ ++iLen ] = '\0';
hb_pp_addDefine( pState, "HB_VER_CHLCVS", szLine );
*pszChangeLogID = hb_strdup( szId );
szFrom = strchr( szLine, ' ' );
if( szFrom )
{
while( *szFrom == ' ' )
++szFrom;
iLen = 0;
while( ! HB_ISSPACE( szFrom[ iLen ] ) )
{
_szId[ u++ ] = szFrom[ iLen ];
++iLen;
}
/*
Latest CVS version before migration to SVN:
ChangeLog,v 1.6768 2011/01/25 18:50:35 guerra000
*/
if( iLen )
{
#if 0
int iCurrentVersion = atoi( _szId ) + 6768;
sprintf( _szId, "%i", iCurrentVersion );
hb_strncpy( piSVNID, _szId, strlen( _szId ) );
#else
hb_strncpy( piSVNID, _szId, u );
#endif
}
else
_szId[ 0 ] = 0;
}
if( _szId[ 0 ] )
{
char szSVNDateID[ 10 ];
int iLen = 0, u = 0, wLen = ( int ) strlen( szLine1 );
char *szDate = NULL;
*szSVNDateID ='\0';
do
{
if ( szLine1[ u ] == ' ' )
iLen ++;
if ( iLen == 4 )
{
iLen = u;
szDate = szLine1 + iLen + 1;
break;
}
++u;
} while ( u < wLen );
iLen = 0;
u = 0;
do
{
if (! ( szDate[ iLen ] == '-' ) )
szSVNDateID[ u++ ] = szDate[ iLen ];
if ( szDate[ iLen ] == ' ' )
break;
++iLen;
} while( szDate [ iLen ] );
szSVNDateID[ u ] = 0;
hb_strncpy( piSVNDateID, szSVNDateID, u );
hb_pp_addDefine( pState, "HB_VER_BUILDDATE", szSVNDateID );
hb_pp_addDefine( pState, "HB_VER_CVSID", _szId );
}
else
{
if( ! fQuiet )
fprintf( stderr, "Unrecognized Id entry in the %s file.\n", pszFile );
iResult = 1;
}
}
}
return iResult;
}
static HB_BOOL hb_langTranslate( const char * szNewId, PHB_LANG lang, PHB_CODEPAGE cdpIn, PHB_CODEPAGE cdpOut )
{
PHB_LANG_BASE pBase;
HB_LANG_TRANS trans;
char * buffer, * ptr;
HB_SIZE nSize = 0;
int i;
if( ! szNewId || *szNewId == 0 || ! lang || ! cdpIn || ! cdpOut || cdpIn == cdpOut )
return HB_FALSE;
for( i = 0; i < HB_LANG_ITEM_MAX_; ++i )
{
char * pszTrans;
if( i == HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_ID )
pszTrans = hb_strdup( szNewId );
else if( i == HB_LANG_ITEM_BASE_ID + HB_LANG_ITEM_ID_CODEPAGE )
pszTrans = hb_strdup( cdpOut->id );
else
pszTrans = hb_cdpDup( lang->pItemList[ i ], cdpIn, cdpOut );
if( strcmp( pszTrans, lang->pItemList[ i ] ) == 0 )
{
hb_xfree( pszTrans );
trans.pItemList[ i ] = NULL;
}
else
{
trans.pItemList[ i ] = pszTrans;
nSize += strlen( pszTrans ) + 1;
}
}
nSize += sizeof( HB_LANG_TRANS );
buffer = ( char * ) hb_xgrab( nSize );
ptr = buffer + sizeof( trans );
for( i = 0; i < HB_LANG_ITEM_MAX_; ++i )
{
if( trans.pItemList[ i ] != NULL )
{
HB_SIZE nLen = strlen( trans.pItemList[ i ] ) + 1;
memcpy( ptr, trans.pItemList[ i ], nLen );
hb_xfree( ( void * ) trans.pItemList[ i ] );
trans.pItemList[ i ] = ptr;
ptr += nLen;
}
else
trans.pItemList[ i ] = lang->pItemList[ i ];
}
memcpy( buffer, &trans, sizeof( trans ) );
pBase = hb_langFindBase( szNewId );
if( pBase && pBase->lang == NULL )
{
pBase->lang = ( PHB_LANG ) buffer;
pBase->buffer = ( void * ) buffer;
return HB_TRUE;
}
hb_xfree( buffer );
return HB_FALSE;
}
static void hb_gt_std_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTSTD pGTSTD;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRDIFF ) hFilenoStdin, ( void * ) ( HB_PTRDIFF ) hFilenoStdout, ( void * ) ( HB_PTRDIFF ) hFilenoStderr));
pGTSTD = ( PHB_GTSTD ) hb_xgrab( sizeof( HB_GTSTD ) );
memset( pGTSTD, 0, sizeof( HB_GTSTD ) );
HB_GTLOCAL( pGT ) = pGTSTD;
pGTSTD->hStdin = hFilenoStdin;
pGTSTD->hStdout = hFilenoStdout;
pGTSTD->hStderr = hFilenoStderr;
pGTSTD->fStdinConsole = hb_fsIsDevice( pGTSTD->hStdin );
pGTSTD->fStdoutConsole = hb_fsIsDevice( pGTSTD->hStdout );
pGTSTD->fStderrConsole = hb_fsIsDevice( pGTSTD->hStderr );
hb_gt_std_setKeyTrans( pGTSTD, NULL, NULL );
pGTSTD->szCrLf = hb_strdup( hb_conNewLine() );
pGTSTD->ulCrLf = strlen( pGTSTD->szCrLf );
hb_fsSetDevMode( pGTSTD->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
/* SA_NOCLDSTOP in #if is a hack to detect POSIX compatible environment */
#if ( defined( HB_OS_UNIX_COMPATIBLE ) || defined( __DJGPP__ ) ) && \
defined( SA_NOCLDSTOP )
if( pGTSTD->fStdinConsole )
{
#if defined( SIGTTOU )
struct sigaction act, old;
/* if( pGTSTD->saved_TIO.c_lflag & TOSTOP ) != 0 */
sigaction( SIGTTOU, NULL, &old );
memcpy( &act, &old, sizeof( struct sigaction ) );
act.sa_handler = sig_handler;
/* do not use SA_RESTART - new Linux kernels will repeat the operation */
#if defined( SA_ONESHOT )
act.sa_flags = SA_ONESHOT;
#elif defined( SA_RESETHAND )
act.sa_flags = SA_RESETHAND;
#else
act.sa_flags = 0;
#endif
sigaction( SIGTTOU, &act, 0 );
#endif
s_fRestTTY = TRUE;
tcgetattr( pGTSTD->hStdin, &pGTSTD->saved_TIO );
memcpy( &pGTSTD->curr_TIO, &pGTSTD->saved_TIO, sizeof( struct termios ) );
/* atexit( restore_input_mode ); */
pGTSTD->curr_TIO.c_lflag &= ~( ICANON | ECHO );
pGTSTD->curr_TIO.c_iflag &= ~ICRNL;
pGTSTD->curr_TIO.c_cc[ VMIN ] = 0;
pGTSTD->curr_TIO.c_cc[ VTIME ] = 0;
tcsetattr( pGTSTD->hStdin, TCSAFLUSH, &pGTSTD->curr_TIO );
#if defined( SIGTTOU )
act.sa_handler = SIG_DFL;
sigaction( SIGTTOU, &old, NULL );
#endif
pGTSTD->fRestTTY = s_fRestTTY;
}
#ifdef TIOCGWINSZ
if( pGTSTD->fStdoutConsole )
{
struct winsize win;
if( ioctl( pGTSTD->hStdout, TIOCGWINSZ, ( char * ) &win ) != -1 )
{
HB_GTSELF_RESIZE( pGT, win.ws_row, win.ws_col );
}
}
#endif
#elif defined( HB_WIN32_IO ) && ! defined( HB_WINCE )
if( pGTSTD->fStdinConsole )
{
SetConsoleMode( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), 0x0000 );
}
#endif
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, pGTSTD->fStdoutConsole );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDERRCON, pGTSTD->fStderrConsole );
}
static char * s_sockexName( PHB_SOCKEX pSock )
{
return hb_strdup( pSock->pFilter->pszName );
}
