From aabe2c9dabef8055f86a9e16c96c8782e64b16cd Mon Sep 17 00:00:00 2001 From: Przemyslaw Czerpak Date: Wed, 13 Oct 2010 11:22:21 +0000 Subject: [PATCH] 2010-10-13 13:21 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) * harbour/src/rtl/gttrm/gttrm.c ! added protection against GPF when wrong parameters are passed to hb_gtInfo( HB_GTI_ADDKEYMAP, ... ) * harbour/src/rtl/hbgtcore.c ! added protection against GPF when wrong parameters are passed to hb_gtAlert() * harbour/src/rtl/gtapi.c * formatting * harbour/src/rtl/cdpapi.c ! fixed return value in hb_cdpStrAsU16Len() * harbour/src/rdd/dbf1.c * harbour/src/rdd/dbffpt/dbffpt1.c + added support for UNICODE fields compatible with the one used by ADS * harbour/contrib/hbxbp/hbxbp.hbx + automatically updated * harbour/contrib/rddads/ads1.c * casting * harbour/doc/xhb-diff.txt * updated information about PRG level hb_socket*() API + added information about serial port support --- harbour/ChangeLog | 30 ++ harbour/contrib/hbxbp/hbxbp.hbx | 1 + harbour/contrib/rddads/ads1.c | 2 +- harbour/doc/xhb-diff.txt | 30 +- harbour/src/rdd/dbf1.c | 210 +++++++++---- harbour/src/rdd/dbffpt/dbffpt1.c | 487 ++++++++++++++++++++----------- harbour/src/rtl/cdpapi.c | 3 +- harbour/src/rtl/gtapi.c | 2 +- harbour/src/rtl/gttrm/gttrm.c | 11 +- harbour/src/rtl/hbgtcore.c | 9 +- 10 files changed, 543 insertions(+), 242 deletions(-) diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 2ce9e13e6f..aff8e0dfbb 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,36 @@ The license applies to all entries newer than 2009-04-28. */ +2010-10-13 13:21 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) + * harbour/src/rtl/gttrm/gttrm.c + ! added protection against GPF when wrong parameters are + passed to hb_gtInfo( HB_GTI_ADDKEYMAP, ... ) + + * harbour/src/rtl/hbgtcore.c + ! added protection against GPF when wrong parameters are + passed to hb_gtAlert() + + * harbour/src/rtl/gtapi.c + * formatting + + * harbour/src/rtl/cdpapi.c + ! fixed return value in hb_cdpStrAsU16Len() + + * harbour/src/rdd/dbf1.c + * harbour/src/rdd/dbffpt/dbffpt1.c + + added support for UNICODE fields compatible with the one used + by ADS + + * harbour/contrib/hbxbp/hbxbp.hbx + + automatically updated + + * harbour/contrib/rddads/ads1.c + * casting + + * harbour/doc/xhb-diff.txt + * updated information about PRG level hb_socket*() API + + added information about serial port support + 2010-10-12 22:20 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com) * contrib/hbqt/qtcore/hbqt_misc.prg * contrib/hbqt/qtgui/THbQtUI.prg diff --git a/harbour/contrib/hbxbp/hbxbp.hbx b/harbour/contrib/hbxbp/hbxbp.hbx index e3b1007d4a..8881ddf65b 100644 --- a/harbour/contrib/hbxbp/hbxbp.hbx +++ b/harbour/contrib/hbxbp/hbxbp.hbx @@ -71,6 +71,7 @@ DYNAMIC GRATRANSLATE DYNAMIC HBPPROCESS DYNAMIC HBXBP_CLEAREVENTBUFFER DYNAMIC HBXBP_CONVERTAFACTFROMXBP +DYNAMIC HBXBP_GETNEXTID DYNAMIC HBXBP_INITIALIZEEVENTBUFFER DYNAMIC HBXBP_SETEVENTLOOP DYNAMIC LASTAPPEVENT diff --git a/harbour/contrib/rddads/ads1.c b/harbour/contrib/rddads/ads1.c index 509b480527..8ae3470c6d 100644 --- a/harbour/contrib/rddads/ads1.c +++ b/harbour/contrib/rddads/ads1.c @@ -2162,7 +2162,7 @@ static HB_ERRCODE adsGetValue( ADSAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem } else { - hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, ( HB_WCHAR * ) pBuffer, u32Length ); + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, ( const HB_WCHAR * ) pBuffer, u32Length ); break; } } diff --git a/harbour/doc/xhb-diff.txt b/harbour/doc/xhb-diff.txt index 78661b100f..34e671c3d5 100644 --- a/harbour/doc/xhb-diff.txt +++ b/harbour/doc/xhb-diff.txt @@ -2037,7 +2037,7 @@ The NTX format in [x]Harbour has also many other extensions like support for multitag indexes or using record number as hidden part of index key and many others which are unique to [x]Harbour. In practice all of CDX extensions are supported by NTX in [x]Harbour. -The NSX format in [x]Harbour is also limited be default to 4GB but like +The NSX format in [x]Harbour is also limited by default to 4GB but like in NTX enabling 64bit locking extend it to 4TB. It also supports common to NTX and CDX set of features. @@ -2085,9 +2085,7 @@ to IP4 protocols only and is the base low level code used for .prg level rewritten from scratch, it's MT safe and was designed to hide platform differences in BSD socket implementation. It also works in DOS builds using WATT-32 library. - -In the future Harbour will have new .prg level API for sockets based on -Harbour C socket API. +This API is available for users also at PRG level by hb_socket*() functions. @@ -2165,8 +2163,8 @@ runtime gettext support as optional user I18N interface. ================== Harbour RTL gives support at .prg level to ZLIB (HB_Z*()) and GZIP (HB_GZ*()) functions. In xHarbour RTL only ZLIB compression/decompression -is available with by: HB_COMPRESS(), HB_UNCOMPRESS(), HB_COMPRESSBUFLEN(), -HB_COMPRESSERROR() and HB_COMPRESSERRORDESC(). +is available by: HB_COMPRESS(), HB_UNCOMPRESS(), HB_COMPRESSBUFLEN(), +HB_COMPRESSERROR() and HB_COMPRESSERRORDESC() functions. In Harbour these functions are available in XHB library. Original Harbour ZLIB API is different. It does not have any non MT safe extensions, it's protected against possible overflows and it's more closer @@ -2174,6 +2172,26 @@ to original ZLIB one. +### SERIAL PORT SUPPORT ### +================================= +Harbour gives common multiplatform PRG and C level API for serial port +communication by hb_com*() functions in core libraries. It also implements +few other known in Clipper serial port interfaces in contrib libraries +like CT3 COM_*() functions in hbct library or basic support for Telepathy +interface in hbtpathy library. All such implementations use at low level +code the core hb_com*() interface so they can work on all platforms. +xHarbour CVS contains only telepath library with some very basic Telepathy +interface which is not available for all platforms. +xHarbour.com distribute also library compatible with CT3 COM*() interface +but only for MS-Windows builds. +It's also possible to ask on xHarbour.news group for HBCOM library. +AFAIK binaries are available for MS-Windows and Linux. +In Harbour the interface given by HBCOM library is also available +inside HBCOMM contrib library which internally uses hb_com*() core +API so it's portable between different OS-es. + + + ### MACRO COMPILER ### ============================ In Harbour macro compiler supports the same expressions as compiler. diff --git a/harbour/src/rdd/dbf1.c b/harbour/src/rdd/dbf1.c index b641290478..e65bb72836 100644 --- a/harbour/src/rdd/dbf1.c +++ b/harbour/src/rdd/dbf1.c @@ -55,6 +55,7 @@ #include "hbrdddbf.h" #include "hbdbsort.h" #include "hbapiitm.h" +#include "hbapistr.h" #include "hbapierr.h" #include "hbapilng.h" #include "hbset.h" @@ -83,6 +84,7 @@ static RDDFUNCS dbfSuper; #define HB_BLANK_SKIP 100 #define HB_BLANK_AUTOINC 101 +#define HB_BLANK_UNISPACE 102 /* @@ -289,7 +291,14 @@ static void hb_dbfSetBlankRecord( DBFAREAP pArea, int iType ) } else { - memset( pPtr, bFill, nSize ); + if( bFill == HB_BLANK_UNISPACE ) + { + HB_SIZE n; + for( n = 0; n < nSize; n += 2 ) + HB_PUT_LE_UINT16( &pPtr[ n ], ' ' ); + } + else + memset( pPtr, bFill, nSize ); pPtr += nSize; nSize = 0; if( bNext == HB_BLANK_SKIP ) @@ -1563,6 +1572,13 @@ static HB_ERRCODE hb_dbfAddField( DBFAREAP pArea, LPDBFIELDINFO pFieldInfo ) /* Update field offset */ pArea->pFieldOffset[ pArea->area.uiFieldCount ] = pArea->uiRecordLen; pArea->uiRecordLen += pFieldInfo->uiLen; + if( ( pFieldInfo->uiFlags & HB_FF_UNICODE ) != 0 ) + { + if( pFieldInfo->uiType == HB_FT_STRING ) + pArea->uiRecordLen += pFieldInfo->uiLen; + else if( pFieldInfo->uiType == HB_FT_VARLENGTH ) + pArea->uiRecordLen += pFieldInfo->uiLen + 2; + } if( pArea->pFieldOffset[ pArea->area.uiFieldCount ] > pArea->uiRecordLen ) return HB_FAILURE; else @@ -1818,7 +1834,13 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI { case HB_FT_STRING: nLen = pField->uiLen; - if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) + { + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ], + nLen ); + } + else if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], &nLen, pArea->area.cdPage, hb_vmCDP() ); @@ -1833,20 +1855,32 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI case HB_FT_VARLENGTH: nLen = pField->uiLen; - if( hb_dbfGetNullFlag( pArea, pArea->pFieldBits[ uiIndex ].uiLengthBit ) ) + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) { - nLen = ( HB_UCHAR ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + nLen - 1 ]; - /* protection against corrupted files */ - if( nLen > ( HB_SIZE ) pField->uiLen ) - nLen = pField->uiLen; + nLen = HB_GET_LE_UINT16( &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + ( nLen << 1 ) ] ); + if( nLen == 0xFFFF ) + nLen = 0; + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ], + nLen ); } - if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) - pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], - &nLen, pArea->area.cdPage, hb_vmCDP() ); else - pszVal = ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ]; + { + if( hb_dbfGetNullFlag( pArea, pArea->pFieldBits[ uiIndex ].uiLengthBit ) ) + { + nLen = ( HB_UCHAR ) pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + nLen - 1 ]; + /* protection against corrupted files */ + if( nLen > ( HB_SIZE ) pField->uiLen ) + nLen = pField->uiLen; + } + if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], + &nLen, pArea->area.cdPage, hb_vmCDP() ); + else + pszVal = ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ]; - hb_itemPutCLPtr( pItem, pszVal, nLen ); + hb_itemPutCLPtr( pItem, pszVal, nLen ); + } break; case HB_FT_LOGICAL: @@ -2245,52 +2279,77 @@ static HB_ERRCODE hb_dbfPutValue( DBFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pI { if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) ) { - pszPtr = hb_itemGetCPtr( pItem ); - nSize = hb_itemGetCLen( pItem ); nLen = pField->uiLen; - if( pField->uiType == HB_FT_STRING ) { - if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) { - hb_cdpnDup2( pszPtr, nSize, - ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], - &nLen, hb_vmCDP(), pArea->area.cdPage ); + HB_WCHAR * pwBuffer = ( HB_WCHAR * ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ]; + nLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + pwBuffer, nLen ); + while( nLen < ( HB_SIZE ) pField->uiLen ) + { + HB_PUT_LE_UINT16( &pwBuffer[ nLen ], ' ' ); + ++nLen; + } } else { - if( nLen > nSize ) - nLen = nSize; - memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], - hb_itemGetCPtr( pItem ), nLen ); + pszPtr = hb_itemGetCPtr( pItem ); + nSize = hb_itemGetCLen( pItem ); + if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + { + hb_cdpnDup2( pszPtr, nSize, + ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], + &nLen, hb_vmCDP(), pArea->area.cdPage ); + } + else + { + if( nLen > nSize ) + nLen = nSize; + memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], + hb_itemGetCPtr( pItem ), nLen ); + } + if( nLen < ( HB_SIZE ) pField->uiLen ) + memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + nLen, + ' ', pField->uiLen - nLen ); } - if( nLen < ( HB_SIZE ) pField->uiLen ) - memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + nLen, - ' ', pField->uiLen - nLen ); } else if( pField->uiType == HB_FT_VARLENGTH ) { - if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) { - if( nLen > ( HB_SIZE ) sizeof( szBuffer ) ) - nLen = sizeof( szBuffer ); - pszPtr = hb_cdpnDup2( pszPtr, nSize, szBuffer, &nLen, - hb_vmCDP(), pArea->area.cdPage ); + HB_WCHAR * pwBuffer = ( HB_WCHAR * ) &pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ]; + nLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + pwBuffer, nLen ); + HB_PUT_LE_UINT16( &pwBuffer[ pField->uiLen ], nLen ); } else { - if( nLen > nSize ) - nLen = nSize; - } - memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pszPtr, nLen ); + pszPtr = hb_itemGetCPtr( pItem ); + nSize = hb_itemGetCLen( pItem ); + if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + { + if( nLen > ( HB_SIZE ) sizeof( szBuffer ) ) + nLen = sizeof( szBuffer ); + pszPtr = hb_cdpnDup2( pszPtr, nSize, szBuffer, &nLen, + hb_vmCDP(), pArea->area.cdPage ); + } + else + { + if( nLen > nSize ) + nLen = nSize; + } + memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pszPtr, nLen ); - if( nLen < ( HB_SIZE ) pField->uiLen ) - { - pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + pField->uiLen - 1 ] = ( HB_BYTE ) nLen; - hb_dbfSetNullFlag( pArea->pRecord, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); + if( nLen < ( HB_SIZE ) pField->uiLen ) + { + pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] + pField->uiLen - 1 ] = ( HB_BYTE ) nLen; + hb_dbfSetNullFlag( pArea->pRecord, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); + } + else + hb_dbfClearNullFlag( pArea->pRecord, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); } - else - hb_dbfClearNullFlag( pArea->pRecord, pArea->uiNullOffset, pArea->pFieldBits[ uiIndex ].uiLengthBit ); } else errCode = EDBF_DATATYPE; @@ -2731,7 +2790,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) { HB_ERRCODE errCode = HB_SUCCESS; HB_SIZE nSize; - HB_USHORT uiCount; + HB_USHORT uiCount, uiLen; HB_BOOL fError, fRawBlob; DBFFIELD * pThisField; HB_BYTE * pBuffer; @@ -2872,10 +2931,19 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) switch( pField->uiType ) { case HB_FT_STRING: - pThisField->bType = 'C'; - pThisField->bLen = ( HB_BYTE ) pField->uiLen; - pThisField->bDec = ( HB_BYTE ) ( pField->uiLen >> 8 ); - pArea->uiRecordLen += pField->uiLen; + uiLen = pField->uiLen; + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) + { + pThisField->bType = '\x1A'; + uiLen <<= 1; + } + else + { + pThisField->bType = 'C'; + } + pThisField->bLen = ( HB_BYTE ) uiLen; + pThisField->bDec = ( HB_BYTE ) ( uiLen >> 8 ); + pArea->uiRecordLen += uiLen; break; case HB_FT_LOGICAL: @@ -2885,7 +2953,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) break; case HB_FT_MEMO: - pThisField->bType = 'M'; + pThisField->bType = ( pField->uiFlags & HB_FF_UNICODE ) ? '\x1C' : 'M'; if( pField->uiLen != 4 || pArea->bMemoType == DB_MEMO_SMT ) pField->uiLen = 10; pThisField->bLen = ( HB_BYTE ) pField->uiLen; @@ -2993,16 +3061,28 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo ) break; case HB_FT_VARLENGTH: - if( pField->uiLen > 255 ) - pField->uiLen = 255; - else if( pField->uiLen == 0 ) + if( pField->uiLen == 0 ) pField->uiLen = 1; - if( pArea->bTableType == DB_DBF_VFP && ( pField->uiFlags & HB_FF_BINARY ) == 0 ) - pThisField->bType = 'V'; + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) + { + if( pField->uiLen > 32766 ) + pField->uiLen = 32766; + pThisField->bType = '\x1B'; + uiLen = ( pField->uiLen + 1 ) << 1; + } else - pThisField->bType = 'Q'; - pThisField->bLen = ( HB_BYTE ) pField->uiLen; - pArea->uiRecordLen += pField->uiLen; + { + if( pField->uiLen > 255 ) + pField->uiLen = 255; + if( pArea->bTableType == DB_DBF_VFP && ( pField->uiFlags & HB_FF_BINARY ) == 0 ) + pThisField->bType = 'V'; + else + pThisField->bType = 'Q'; + uiLen = pField->uiLen; + } + pThisField->bLen = ( HB_BYTE ) uiLen; + pThisField->bDec = ( HB_BYTE ) ( uiLen >> 8 ); + pArea->uiRecordLen += uiLen; hb_dbfAllocNullFlag( pArea, uiCount, HB_TRUE ); break; @@ -4026,6 +4106,24 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo ) pArea->fHasMemo = HB_TRUE; break; + case '\x1A': + dbFieldInfo.uiType = HB_FT_STRING; + dbFieldInfo.uiFlags |= HB_FF_UNICODE; + dbFieldInfo.uiLen = ( pField->bLen + pField->bDec * 256 ) >> 1; + break; + + case '\x1B': + dbFieldInfo.uiType = HB_FT_VARLENGTH; + dbFieldInfo.uiFlags |= HB_FF_UNICODE; + dbFieldInfo.uiLen = ( ( pField->bLen + pField->bDec * 256 ) >> 1 ) - 1; + break; + + case '\x1C': + dbFieldInfo.uiType = HB_FT_MEMO; + dbFieldInfo.uiFlags |= HB_FF_UNICODE; + pArea->fHasMemo = HB_TRUE; + break; + case '0': if( /* pArea->bTableType == DB_DBF_VFP && */ ( pField->bFieldFlags & HB_FF_HIDDEN ) != 0 ) @@ -4302,7 +4400,7 @@ void hb_dbfTranslateRec( DBFAREAP pArea, HB_BYTE * pBuffer, PHB_CODEPAGE cdp_src for( uiIndex = 0, pField = pArea->area.lpFields; uiIndex < pArea->area.uiFieldCount; uiIndex++, pField++ ) { - if( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + if( ( pField->uiFlags & ( HB_FF_BINARY | HB_FF_UNICODE ) ) == 0 && ( pField->uiType == HB_FT_STRING || pField->uiType == HB_FT_VARLENGTH ) ) { if( pTmpBuf == NULL ) diff --git a/harbour/src/rdd/dbffpt/dbffpt1.c b/harbour/src/rdd/dbffpt/dbffpt1.c index cae640ccfc..931df6c7bc 100644 --- a/harbour/src/rdd/dbffpt/dbffpt1.c +++ b/harbour/src/rdd/dbffpt/dbffpt1.c @@ -67,9 +67,10 @@ #include "hbapi.h" #include "hbapiitm.h" -#include "hbinit.h" +#include "hbapistr.h" #include "hbapierr.h" #include "hbapilng.h" +#include "hbinit.h" #include "hbset.h" #include "hbstack.h" #include "hbvm.h" @@ -80,7 +81,11 @@ #include "hbapicdp.h" -#define FPT_DIRECT_TRANS( p ) ( hb_vmCDP() != ( p )->area.cdPage ) +#define FPT_TRANS_NONE 0 +#define FPT_TRANS_CP 1 +#define FPT_TRANS_UNICODE 2 + +#define FPT_DIRECT_TRANS( p ) ( hb_vmCDP() != ( p )->area.cdPage ? FPT_TRANS_CP : FPT_TRANS_NONE ) #define FPT_BLOCK_OFFSET( b ) ( ( HB_FOFFSET ) ( b ) * \ ( HB_FOFFSET ) pArea->ulMemoBlockSize ) @@ -979,6 +984,7 @@ static HB_ULONG hb_fptGetMemoLen( FPTAREAP pArea, HB_USHORT uiIndex ) pArea->bMemoType == DB_MEMO_FPT ) ) { HB_FOFFSET fOffset = FPT_BLOCK_OFFSET( ulBlock ); + if( pArea->bMemoType == DB_MEMO_DBT ) { HB_BYTE pBlock[ DBT_DEFBLOCKSIZE ]; @@ -1115,7 +1121,7 @@ static const char * hb_fptGetMemoType( FPTAREAP pArea, HB_USHORT uiIndex ) * Calculate the size of SMT memo item */ static HB_ULONG hb_fptCountSMTItemLength( FPTAREAP pArea, PHB_ITEM pItem, - HB_ULONG * pulArrayCount, HB_BOOL fTrans ) + HB_ULONG * pulArrayCount, int iTrans ) { HB_ULONG ulLen, u, ulSize; @@ -1129,21 +1135,28 @@ static HB_ULONG hb_fptCountSMTItemLength( FPTAREAP pArea, PHB_ITEM pItem, ulLen = 0xFFFF; for( u = 1; u <= ulLen; u++ ) { - ulSize += hb_fptCountSMTItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, fTrans ); + ulSize += hb_fptCountSMTItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, iTrans ); } break; case HB_IT_MEMO: case HB_IT_STRING: - ulLen = hb_itemGetCLen( pItem ); - if( fTrans ) + if( iTrans == FPT_TRANS_UNICODE ) { - ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, 0xFFFF, - hb_vmCDP(), pArea->area.cdPage ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, 0xFFFF ) * sizeof( HB_WCHAR ); } else { - if( ulLen > 0xFFFF ) - ulLen = 0xFFFF; + ulLen = hb_itemGetCLen( pItem ); + if( iTrans == FPT_TRANS_CP && ulLen > 0 ) + { + ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, 0xFFFF, + hb_vmCDP(), pArea->area.cdPage ); + } + else + { + if( ulLen > 0xFFFF ) + ulLen = 0xFFFF; + } } ulSize = ulLen + 3; break; @@ -1235,9 +1248,9 @@ static HB_ERRCODE hb_fptCountSMTDataLength( FPTAREAP pArea, HB_FOFFSET * pfOffse /* * Write VM item as SMT memos. */ -static HB_ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) +static void hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, int iTrans ) { - HB_ULONG ulLen, u, ulSize = 0; + HB_ULONG ulLen, u; HB_MAXINT iVal; HB_LONG lVal; double dVal; @@ -1254,34 +1267,44 @@ static HB_ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** b *bBufPtr += 2; for( u = 1; u <= ulLen; u++ ) { - ulSize += hb_fptStoreSMTItem( pArea, hb_arrayGetItemPtr( pItem, u ), - bBufPtr, fTrans ); + hb_fptStoreSMTItem( pArea, hb_arrayGetItemPtr( pItem, u ), + bBufPtr, iTrans ); } break; case HB_IT_STRING: case HB_IT_MEMO: *(*bBufPtr)++ = SMT_IT_CHAR; - ulLen = hb_itemGetCLen( pItem ); - if( ulLen > 0 ) + if( iTrans == FPT_TRANS_UNICODE ) { - u = 0xFFFF; - if( fTrans ) - { - HB_SIZE nSize = u; - hb_cdpnDup2( hb_itemGetCPtr( pItem ), ulLen, - ( char * ) *bBufPtr + 2, &nSize, - hb_vmCDP(), pArea->area.cdPage ); - ulLen = ( HB_ULONG ) nSize; - } - else - { - if( ulLen > u ) - ulLen = u; - memcpy( *bBufPtr + 2, hb_itemGetCPtr( pItem ), ulLen ); - } - HB_PUT_LE_UINT16( *bBufPtr, ulLen ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, 0xFFFF ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( HB_WCHAR * ) *bBufPtr + 2, ulLen ); + ulLen *= sizeof( HB_WCHAR ); } + else + { + ulLen = hb_itemGetCLen( pItem ); + if( ulLen > 0 ) + { + u = 0xFFFF; + if( iTrans == FPT_TRANS_CP ) + { + HB_SIZE nSize = u; + hb_cdpnDup2( hb_itemGetCPtr( pItem ), ulLen, + ( char * ) *bBufPtr + 2, &nSize, + hb_vmCDP(), pArea->area.cdPage ); + ulLen = ( HB_ULONG ) nSize; + } + else + { + if( ulLen > u ) + ulLen = u; + memcpy( *bBufPtr + 2, hb_itemGetCPtr( pItem ), ulLen ); + } + } + } + HB_PUT_LE_UINT16( *bBufPtr, ulLen ); *bBufPtr += ulLen + 2; break; @@ -1325,13 +1348,12 @@ static HB_ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** b *(*bBufPtr)++ = SMT_IT_NIL; break; } - return ulSize; } /* * Read SMT item from file */ -static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFSET *pfOffset, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFSET *pfOffset, int iTrans ) { HB_ULONG ulLen, u; HB_BYTE buffer[ 10 ]; @@ -1354,7 +1376,7 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS for( u = 1; u <= ulLen; u++ ) { HB_ERRCODE errCode = hb_fptReadRawSMTItem( pArea, - hb_arrayGetItemPtr( pItem, u ), pfOffset, fTrans ); + hb_arrayGetItemPtr( pItem, u ), pfOffset, iTrans ); if( errCode != HB_SUCCESS ) return errCode; } @@ -1372,15 +1394,24 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS return EDBF_READ; } *pfOffset += ulLen; - if( fTrans && ulLen > 0 ) + if( iTrans == FPT_TRANS_UNICODE ) { - HB_SIZE ulSize = ulLen + 1; - HB_SIZE nLen = ulLen; - hb_cdpnDup3( pBuffer, ulLen, pBuffer, &nLen, &pBuffer, &ulSize, - pArea->area.cdPage, hb_vmCDP() ); - ulLen = ( HB_ULONG ) nLen; + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pBuffer, ulLen >> 1 ); + hb_xfree( pBuffer ); + } + else + { + if( iTrans == FPT_TRANS_CP && ulLen > 0 ) + { + HB_SIZE ulSize = ulLen + 1; + HB_SIZE nLen = ulLen; + hb_cdpnDup3( pBuffer, ulLen, pBuffer, &nLen, &pBuffer, &ulSize, + pArea->area.cdPage, hb_vmCDP() ); + ulLen = ( HB_ULONG ) nLen; + } + hb_itemPutCLPtr( pItem, pBuffer, ulLen ); } - hb_itemPutCLPtr( pItem, pBuffer, ulLen ); break; case SMT_IT_INT: @@ -1430,7 +1461,7 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS /* * Read SMT item from memory buffer. */ -static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, int iTrans ) { HB_ULONG ulLen, u; HB_ERRCODE errCode = HB_SUCCESS; @@ -1457,7 +1488,7 @@ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY for( u = 1; u <= ulLen; u++ ) { errCode = hb_fptReadSMTItem( pArea, pbMemoBuf, bBufEnd, - hb_arrayGetItemPtr( pItem, u ), fTrans ); + hb_arrayGetItemPtr( pItem, u ), iTrans ); if( errCode != HB_SUCCESS ) break; } @@ -1479,7 +1510,12 @@ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY { char * pszStr = ( char * ) ( *pbMemoBuf ); *pbMemoBuf += ulLen; - if( fTrans && ulLen > 0 ) + if( iTrans == FPT_TRANS_UNICODE ) + { + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pszStr, ulLen >> 1 ); + } + else if( iTrans == FPT_TRANS_CP && ulLen != 0 ) { HB_SIZE nLen = ulLen; pszStr = hb_cdpnDup( pszStr, &nLen, pArea->area.cdPage, hb_vmCDP() ); @@ -1556,7 +1592,7 @@ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY * Calculate the size of SIX memo item */ static HB_ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, - HB_ULONG * pulArrayCount, HB_BOOL fTrans ) + HB_ULONG * pulArrayCount, int iTrans ) { HB_ULONG ulLen, u, ulSize; @@ -1573,24 +1609,31 @@ static HB_ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, } for( u = 1; u <= ulLen; u++ ) { - ulSize += hb_fptCountSixItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, fTrans ); + ulSize += hb_fptCountSixItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, iTrans ); } break; case HB_IT_MEMO: case HB_IT_STRING: ulSize = SIX_ITEM_BUFSIZE; - ulLen = hb_itemGetCLen( pItem ); /* only 2 bytes (HB_SHORT) for SIX compatibility */ u = pArea->uiMemoVersion == DB_MEMOVER_SIX ? 0xFFFF : ULONG_MAX; - if( fTrans && ulLen > 0 ) + if( iTrans == FPT_TRANS_UNICODE ) { - ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, u, - hb_vmCDP(), pArea->area.cdPage ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, u ) * sizeof( HB_WCHAR ); } else { - if( ulLen > u ) - ulLen = u; + ulLen = hb_itemGetCLen( pItem ); + if( iTrans == FPT_TRANS_CP && ulLen > 0 ) + { + ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, u, + hb_vmCDP(), pArea->area.cdPage ); + } + else + { + if( ulLen > u ) + ulLen = u; + } } ulSize += ulLen; break; @@ -1609,7 +1652,7 @@ static HB_ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem, /* * Write fpt vartype as SIX memos. */ -static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) +static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, int iTrans ) { HB_ULONG ulLen, u, ulSize; HB_MAXINT iVal; @@ -1633,7 +1676,7 @@ static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** b *bBufPtr += SIX_ITEM_BUFSIZE; for( u = 1; u <= ulLen; u++ ) { - ulSize += hb_fptStoreSixItem( pArea, hb_arrayGetItemPtr( pItem, u ), bBufPtr, fTrans ); + ulSize += hb_fptStoreSixItem( pArea, hb_arrayGetItemPtr( pItem, u ), bBufPtr, iTrans ); } break; @@ -1686,27 +1729,37 @@ static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** b case HB_IT_STRING: case HB_IT_MEMO: HB_PUT_LE_UINT16( &(*bBufPtr)[0], FPTIT_SIX_CHAR ); - ulLen = hb_itemGetCLen( pItem ); - if( ulLen > 0 ) + /* only 2 bytes (HB_SHORT) for SIX compatibility */ + u = pArea->uiMemoVersion == DB_MEMOVER_SIX ? 0xFFFF : ULONG_MAX; + if( iTrans == FPT_TRANS_UNICODE ) { - /* only 2 bytes (HB_SHORT) for SIX compatibility */ - u = pArea->uiMemoVersion == DB_MEMOVER_SIX ? 0xFFFF : ULONG_MAX; - if( fTrans ) - { - HB_SIZE nSize = u; - hb_cdpnDup2( hb_itemGetCPtr( pItem ), ulLen, - ( char * ) *bBufPtr + SIX_ITEM_BUFSIZE, &nSize, - hb_vmCDP(), pArea->area.cdPage ); - ulLen = ( HB_ULONG ) nSize; - } - else - { - if( ulLen > u ) - ulLen = u; - memcpy( *bBufPtr + SIX_ITEM_BUFSIZE, hb_itemGetCPtr( pItem ), ulLen ); - } - HB_PUT_LE_UINT32( &(*bBufPtr)[2], ulLen ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, u ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( HB_WCHAR * ) *bBufPtr + SIX_ITEM_BUFSIZE, ulLen ); + ulLen *= sizeof( HB_WCHAR ); } + else + { + ulLen = hb_itemGetCLen( pItem ); + if( ulLen > 0 ) + { + if( iTrans == FPT_TRANS_CP ) + { + HB_SIZE nSize = u; + hb_cdpnDup2( hb_itemGetCPtr( pItem ), ulLen, + ( char * ) *bBufPtr + SIX_ITEM_BUFSIZE, &nSize, + hb_vmCDP(), pArea->area.cdPage ); + ulLen = ( HB_ULONG ) nSize; + } + else + { + if( ulLen > u ) + ulLen = u; + memcpy( *bBufPtr + SIX_ITEM_BUFSIZE, hb_itemGetCPtr( pItem ), ulLen ); + } + } + } + HB_PUT_LE_UINT32( &(*bBufPtr)[2], ulLen ); *bBufPtr += ulLen + SIX_ITEM_BUFSIZE; break; default: @@ -1720,7 +1773,7 @@ static HB_ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** b /* * Read SIX item from memo. */ -static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, int iTrans ) { HB_USHORT usType; HB_ULONG ulLen, u; @@ -1754,20 +1807,29 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY ulLen = HB_GET_LE_UINT32( &(*pbMemoBuf)[2] ); if( pArea->uiMemoVersion == DB_MEMOVER_SIX ) { - ulLen &= 0xFFFF; /* only 2 bytes (HB_SHORT) for SIX compatibility */ + ulLen &= 0xFFFF; /* only 2 bytes (HB_SHORT) for SIX compatibility */ } (*pbMemoBuf) += SIX_ITEM_BUFSIZE; if( bBufEnd - (*pbMemoBuf) >= ( HB_LONG ) ulLen ) { char * pszStr = ( char * ) ( *pbMemoBuf ); - if( fTrans && ulLen > 0 ) + + if( iTrans == FPT_TRANS_UNICODE ) { - HB_SIZE ulSize = ulLen; - pszStr = hb_cdpnDup( pszStr, &ulSize, pArea->area.cdPage, hb_vmCDP() ); - hb_itemPutCLPtr( pItem, pszStr, ulSize ); + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pszStr, ulLen >> 1 ); } else - hb_itemPutCL( pItem, pszStr, ulLen ); + { + if( iTrans == FPT_TRANS_CP && ulLen > 0 ) + { + HB_SIZE ulSize = ulLen; + pszStr = hb_cdpnDup( pszStr, &ulSize, pArea->area.cdPage, hb_vmCDP() ); + hb_itemPutCLPtr( pItem, pszStr, ulSize ); + } + else + hb_itemPutCL( pItem, pszStr, ulLen ); + } } else { @@ -1790,7 +1852,7 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY for( u = 1; u <= ulLen; u++ ) { errCode = hb_fptReadSixItem( pArea, pbMemoBuf, bBufEnd, - hb_arrayGetItemPtr( pItem, u ), fTrans ); + hb_arrayGetItemPtr( pItem, u ), iTrans ); if( errCode != HB_SUCCESS ) { break; @@ -1822,7 +1884,7 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BY * Calculate the size of FLEX memo item */ static HB_ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, - HB_ULONG * pulArrayCount, HB_BOOL fTrans ) + HB_ULONG * pulArrayCount, int iTrans ) { HB_ULONG ulLen, u, ulSize = 1; HB_MAXINT iVal; @@ -1835,21 +1897,28 @@ static HB_ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, ulLen = hb_arrayLen( pItem ) & 0xFFFF; for( u = 1; u <= ulLen; u++ ) { - ulSize += hb_fptCountFlexItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, fTrans ); + ulSize += hb_fptCountFlexItemLength( pArea, hb_arrayGetItemPtr( pItem, u ), pulArrayCount, iTrans ); } break; case HB_IT_MEMO: case HB_IT_STRING: - ulLen = hb_itemGetCLen( pItem ); - if( fTrans ) + if( iTrans == FPT_TRANS_UNICODE ) { - ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, 0xFFFF, - hb_vmCDP(), pArea->area.cdPage ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, 0xFFFF ) * sizeof( HB_WCHAR ); } else { - if( ulLen > 0xFFFF ) - ulLen = 0xFFFF; + ulLen = hb_itemGetCLen( pItem ); + if( iTrans == FPT_TRANS_CP && ulLen > 0 ) + { + ulLen = hb_cdpnDup2Len( hb_itemGetCPtr( pItem ), ulLen, 0xFFFF, + hb_vmCDP(), pArea->area.cdPage ); + } + else + { + if( ulLen > 0xFFFF ) + ulLen = 0xFFFF; + } } if( ulLen > 0 ) ulSize += ulLen + 2; @@ -1875,7 +1944,7 @@ static HB_ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem, /* * Store in buffer fpt vartype as FLEX memos. */ -static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, HB_BOOL fTrans ) +static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBufPtr, int iTrans ) { HB_ULONG ulLen, u; HB_MAXINT iVal; @@ -1892,7 +1961,7 @@ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf *bBufPtr += 2; for( u = 1; u <= ulLen; u++ ) { - hb_fptStoreFlexItem( pArea, hb_arrayGetItemPtr( pItem, u ), bBufPtr, fTrans ); + hb_fptStoreFlexItem( pArea, hb_arrayGetItemPtr( pItem, u ), bBufPtr, iTrans ); } break; case HB_IT_MEMO: @@ -1906,7 +1975,14 @@ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf { *(*bBufPtr)++ = FPTIT_FLEXAR_STR; u = 0xFFFF; - if( fTrans ) + if( iTrans == FPT_TRANS_UNICODE ) + { + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, u ); + ulLen = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( HB_WCHAR * ) *bBufPtr + 2, ulLen ); + ulLen *= sizeof( HB_WCHAR ); + } + else if( iTrans == FPT_TRANS_CP ) { HB_SIZE nSize = u; hb_cdpnDup2( hb_itemGetCPtr( pItem ), ulLen, @@ -1988,7 +2064,7 @@ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, HB_BYTE ** bBuf /* * Read FLEX item from memo. */ -static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL bRoot, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL bRoot, int iTrans ) { HB_BYTE usType; HB_ULONG ulLen, i; @@ -2321,7 +2397,14 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_B { char * pszStr = ( char * ) ( *pbMemoBuf ); *pbMemoBuf += ulLen; - if( fTrans && ulLen > 0 ) + + + if( iTrans == FPT_TRANS_UNICODE ) + { + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pszStr, ulLen >> 1 ); + } + else if( iTrans == FPT_TRANS_CP && ulLen != 0 ) { HB_SIZE nLen = ulLen; pszStr = hb_cdpnDup( pszStr, &nLen, pArea->area.cdPage, hb_vmCDP() ); @@ -2352,7 +2435,7 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, HB_BYTE ** pbMemoBuf, HB_B for( i = 1; i <= ulLen; i++ ) { errCode = hb_fptReadFlexItem( pArea, pbMemoBuf, bBufEnd, - hb_arrayGetItemPtr( pItem, i ), HB_FALSE, fTrans ); + hb_arrayGetItemPtr( pItem, i ), HB_FALSE, iTrans ); if( errCode != HB_SUCCESS ) { break; @@ -2514,7 +2597,7 @@ static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem, } static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, - HB_ULONG ulBlock, HB_ULONG ulSize, HB_BOOL fTrans ) + HB_ULONG ulBlock, HB_ULONG ulSize, int iTrans ) { if( ulBlock == 0 ) return EDBF_CORRUPT; @@ -2522,7 +2605,7 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, if( ulSize == 0 ) { HB_FOFFSET fOffset = FPT_BLOCK_OFFSET( ulBlock ); - return hb_fptReadRawSMTItem( pArea, pItem, &fOffset, fTrans ); + return hb_fptReadRawSMTItem( pArea, pItem, &fOffset, iTrans ); } else { @@ -2543,7 +2626,7 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, else { bMemoBuf = bBuffer; - errCode = hb_fptReadSMTItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, fTrans ); + errCode = hb_fptReadSMTItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, iTrans ); } hb_xfree( bBuffer ); return errCode; @@ -2555,7 +2638,7 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem, */ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, HB_FHANDLE hFile, HB_ULONG ulBlock, HB_ULONG ulStart, - HB_ULONG ulCount, HB_BOOL fTrans ) + HB_ULONG ulCount, int iTrans ) { HB_ERRCODE errCode; HB_ULONG ulSize = 0, ulType = 0; @@ -2563,7 +2646,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt HB_BYTE * bMemoBuf; FPTBLOCK fptBlock; - HB_TRACE(HB_TR_DEBUG, ("hb_fptGetMemo(%p, %hu, %p, %p, %lu, %lu, %d)", pArea, uiIndex, pItem, ( void * ) ( HB_PTRDIFF ) hFile, ulStart, ulCount, fTrans)); + HB_TRACE(HB_TR_DEBUG, ("hb_fptGetMemo(%p, %hu, %p, %p, %lu, %lu, %d)", pArea, uiIndex, pItem, ( void * ) ( HB_PTRDIFF ) hFile, ulStart, ulCount, iTrans)); if( uiIndex ) { @@ -2657,24 +2740,15 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt } else if( pArea->bMemoType == DB_MEMO_DBT ) { - if( fTrans && ulSize != 0 ) + if( iTrans == FPT_TRANS_UNICODE ) { - HB_SIZE nSize = ulSize; - HB_SIZE ulBufSize = ulSize + 1; - hb_cdpnDup3( pBuffer, ulSize, pBuffer, &nSize, - &pBuffer, &ulBufSize, - pArea->area.cdPage, hb_vmCDP() ); - ulSize = ( HB_ULONG ) nSize; + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pBuffer, ulSize >> 1 ); + hb_xfree( pBuffer ); } - hb_itemPutCLPtr( pItem, pBuffer, ulSize ); - hb_itemSetCMemo( pItem ); - pBuffer = NULL; - } - else if( pArea->bMemoType == DB_MEMO_SMT ) - { - if( ulType == SMT_IT_CHAR ) + else { - if( fTrans && ulSize != 0 ) + if( iTrans == FPT_TRANS_CP && ulSize != 0 ) { HB_SIZE nSize = ulSize; HB_SIZE ulBufSize = ulSize + 1; @@ -2684,6 +2758,33 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt ulSize = ( HB_ULONG ) nSize; } hb_itemPutCLPtr( pItem, pBuffer, ulSize ); + } + hb_itemSetCMemo( pItem ); + pBuffer = NULL; + } + else if( pArea->bMemoType == DB_MEMO_SMT ) + { + if( ulType == SMT_IT_CHAR ) + { + if( iTrans == FPT_TRANS_UNICODE ) + { + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pBuffer, ulSize >> 1 ); + hb_xfree( pBuffer ); + } + else + { + if( iTrans == FPT_TRANS_CP && ulSize != 0 ) + { + HB_SIZE nSize = ulSize; + HB_SIZE ulBufSize = ulSize + 1; + hb_cdpnDup3( pBuffer, ulSize, pBuffer, &nSize, + &pBuffer, &ulBufSize, + pArea->area.cdPage, hb_vmCDP() ); + ulSize = ( HB_ULONG ) nSize; + } + hb_itemPutCLPtr( pItem, pBuffer, ulSize ); + } hb_itemSetCMemo( pItem ); pBuffer = NULL; } @@ -2695,7 +2796,7 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt else { bMemoBuf = ( HB_BYTE * ) pBuffer; - errCode = hb_fptReadSMTItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, fTrans ); + errCode = hb_fptReadSMTItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, iTrans ); } } else @@ -2714,11 +2815,11 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt case FPTIT_SIX_MREF: */ bMemoBuf = ( HB_BYTE * ) pBuffer; - errCode = hb_fptReadSixItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, fTrans ); + errCode = hb_fptReadSixItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, iTrans ); break; case FPTIT_FLEX_ARRAY: bMemoBuf = ( HB_BYTE * ) pBuffer; - errCode = hb_fptReadFlexItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, HB_TRUE, fTrans ); + errCode = hb_fptReadFlexItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, HB_TRUE, iTrans ); break; case FPTIT_FLEX_NIL: hb_itemClear( pItem ); @@ -2759,18 +2860,27 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt hb_itemPutND( pItem, 0.0 /* HB_GET_LE_DOUBLE( pBuffer ) */ ); break; case FPTIT_TEXT: - if( fTrans && ulSize != 0 ) + if( iTrans == FPT_TRANS_UNICODE ) { - HB_SIZE nSize = ulSize; - HB_SIZE ulBufSize = ulSize + 1; - hb_cdpnDup3( pBuffer, ulSize, pBuffer, &nSize, - &pBuffer, &ulBufSize, - pArea->area.cdPage, hb_vmCDP() ); - ulSize = ( HB_ULONG ) nSize; + hb_itemPutStrLenU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( const HB_WCHAR * ) pBuffer, ulSize >> 1 ); + hb_xfree( pBuffer ); + } + else + { + if( iTrans == FPT_TRANS_CP && ulSize != 0 ) + { + HB_SIZE nSize = ulSize; + HB_SIZE ulBufSize = ulSize + 1; + hb_cdpnDup3( pBuffer, ulSize, pBuffer, &nSize, + &pBuffer, &ulBufSize, + pArea->area.cdPage, hb_vmCDP() ); + ulSize = ( HB_ULONG ) nSize; + } + hb_itemPutCLPtr( pItem, pBuffer, ulSize ); } - hb_itemPutCLPtr( pItem, pBuffer, ulSize ); - hb_itemSetCMemo( pItem ); pBuffer = NULL; + hb_itemSetCMemo( pItem ); break; case FPTIT_PICT: hb_itemPutCLPtr( pItem, pBuffer, ulSize ); @@ -2933,7 +3043,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, HB_ULONG ulBlock, HB_ULONG ul * Assign a value to the specified memo field. */ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem, - HB_ULONG * pulBlock, HB_BOOL fTrans ) + HB_ULONG * pulBlock, int iTrans ) { HB_ULONG ulBlock = 0, ulSize, ulType, ulOldSize = 0, ulOldType = 0, ulArrayCount = 0; HB_BYTE itmBuffer[ FLEX_ITEM_BUFSIZE ]; @@ -2947,15 +3057,28 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt if( HB_IS_STRING( pItem ) ) { ulType = FPTIT_TEXT; - ulSize = hb_itemGetCLen( pItem ); - bBufPtr = ( HB_BYTE * ) hb_itemGetCPtr( pItem ); - if( ulSize > 0 && fTrans ) + if( iTrans == FPT_TRANS_UNICODE ) { - HB_SIZE nSize = ulSize; - bBufPtr = bBufAlloc = ( HB_BYTE * ) + ulSize = hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, NULL, 0 ) * sizeof( HB_WCHAR ); + if( ulSize > 0 ) + { + bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize ); + hb_itemCopyStrU16( pItem, HB_CDP_ENDIAN_LITTLE, + ( HB_WCHAR * ) bBufPtr, ulSize / sizeof( HB_WCHAR ) ); + } + } + else + { + ulSize = hb_itemGetCLen( pItem ); + bBufPtr = ( HB_BYTE * ) hb_itemGetCPtr( pItem ); + if( iTrans == FPT_TRANS_CP && ulSize > 0 ) + { + HB_SIZE nSize = ulSize; + bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_cdpnDup( ( const char * ) bBufPtr, &nSize, hb_vmCDP(), pArea->area.cdPage ); - ulSize = ( HB_ULONG ) nSize; + ulSize = ( HB_ULONG ) nSize; + } } if( pArea->bMemoType == DB_MEMO_SMT ) { @@ -2968,11 +3091,11 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt } else if( pArea->bMemoType == DB_MEMO_SMT ) { - ulSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, fTrans ); + ulSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, iTrans ); if( ulSize == 0 ) return EDBF_DATATYPE; bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize ); - hb_fptStoreSMTItem( pArea, pItem, &bBufPtr, fTrans ); + hb_fptStoreSMTItem( pArea, pItem, &bBufPtr, iTrans ); ulType = ( HB_ULONG ) bBufAlloc[ 0 ]; bBufPtr = bBufAlloc; } @@ -2985,11 +3108,11 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt } else { - ulSize = hb_fptCountSixItemLength( pArea, pItem, &ulArrayCount, fTrans ); + ulSize = hb_fptCountSixItemLength( pArea, pItem, &ulArrayCount, iTrans ); if( ulSize > 0 ) { bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize ); - hb_fptStoreSixItem( pArea, pItem, &bBufPtr, fTrans ); + hb_fptStoreSixItem( pArea, pItem, &bBufPtr, iTrans ); ulType = ( HB_ULONG ) HB_GET_LE_UINT16( bBufAlloc ); bBufPtr = bBufAlloc; } @@ -3005,11 +3128,11 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pIt { case HB_IT_ARRAY: ulType = FPTIT_FLEX_ARRAY; - ulSize = hb_fptCountFlexItemLength( pArea, pItem, &ulArrayCount, fTrans ) - 1; + ulSize = hb_fptCountFlexItemLength( pArea, pItem, &ulArrayCount, iTrans ) - 1; if( ulSize > 0 ) { bBufPtr = bBufAlloc = ( HB_BYTE * ) hb_xgrab( ulSize + 1 ); - hb_fptStoreFlexItem( pArea, pItem, &bBufPtr, fTrans ); + hb_fptStoreFlexItem( pArea, pItem, &bBufPtr, iTrans ); bBufPtr = bBufAlloc + 1; /* FLEX doesn't store the first byte of array ID */ } break; @@ -3272,16 +3395,18 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM if( uiType <= pField->uiLen - 2 ) { - if( ulLen > 0 && ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage ) + pString = ( const char * ) pFieldBuf; + if( ulLen > 0 ) { - HB_SIZE nLen = ulLen; - pString = pAlloc = hb_cdpnDup( ( const char * ) pFieldBuf, &nLen, - pArea->area.cdPage, hb_vmCDP() ); - ulLen = ( HB_ULONG ) nLen; + if( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + hb_vmCDP() != pArea->area.cdPage ) + { + HB_SIZE nLen = ulLen; + pString = pAlloc = hb_cdpnDup( pString, &nLen, + pArea->area.cdPage, hb_vmCDP() ); + ulLen = ( HB_ULONG ) nLen; + } } - else - pString = ( const char * ) pFieldBuf; } else { @@ -3375,7 +3500,8 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM else errCode = hb_fptReadSMTBlock( pArea, pItem, ulBlock, 0, ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage ); + hb_vmCDP() != pArea->area.cdPage ? + FPT_TRANS_CP : FPT_TRANS_NONE ); } else if( uiType == HB_VF_BLOB ) errCode = hb_fptReadBlobBlock( pArea, pItem, hFile, ulBlock, 0 ); @@ -3397,8 +3523,9 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM return errCode; errCode = hb_fptGetMemo( pArea, uiIndex, pItem, hFile, 0, 0, 0, - ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage ); + ( pField->uiFlags & HB_FF_UNICODE ) != 0 ? FPT_TRANS_UNICODE : + ( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + hb_vmCDP() != pArea->area.cdPage ? FPT_TRANS_CP : FPT_TRANS_NONE ) ); } else if( hFile == FS_ERROR ) { @@ -3415,12 +3542,12 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM return errCode; } -static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile, HB_USHORT uiMode, HB_BOOL fTrans ) +static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char * szFile, HB_USHORT uiMode, int iTrans ) { HB_ERRCODE errCode; HB_FHANDLE hFile; - HB_TRACE(HB_TR_DEBUG, ("hb_fptGetVarFile(%p, %lu, %s, %hu, %d)", pArea, ulBlock, szFile, uiMode, fTrans)); + HB_TRACE(HB_TR_DEBUG, ("hb_fptGetVarFile(%p, %lu, %s, %hu, %d)", pArea, ulBlock, szFile, uiMode, iTrans)); hFile = hb_fsExtOpen( szFile, NULL, FO_WRITE | FO_EXCLUSIVE | FXO_DEFAULTS | FXO_SHARELOCK | @@ -3435,7 +3562,7 @@ static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, HB_ULONG ulBlock, const char else { hb_fsSeekLarge( hFile, 0, FS_END ); - errCode = hb_fptGetMemo( pArea, 0, NULL, hFile, ulBlock, 0, 0, fTrans ); + errCode = hb_fptGetMemo( pArea, 0, NULL, hFile, ulBlock, 0, 0, iTrans ); hb_fsClose( hFile ); } @@ -3540,8 +3667,9 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM if( !hb_fptFileLockEx( pArea, HB_TRUE ) ) return EDBF_LOCK; errCode = hb_fptPutMemo( pArea, uiIndex, pItem, NULL, - ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage ); + ( pField->uiFlags & HB_FF_UNICODE ) != 0 ? FPT_TRANS_UNICODE : + ( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + hb_vmCDP() != pArea->area.cdPage ? FPT_TRANS_CP : FPT_TRANS_NONE ) ); #if defined( HB_MEMO_SAFELOCK ) if( errCode == HB_SUCCESS ) { @@ -3688,11 +3816,22 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM else if( HB_IS_ARRAY( pItem ) ) { HB_ULONG ulArrayCount = 0; - HB_BOOL fTrans = ( pField->uiFlags & HB_FF_BINARY ) == 0 && - hb_vmCDP() != pArea->area.cdPage; - ulNewSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, fTrans ); + int iTrans; + + /* + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) + iTrans = FPT_TRANS_UNICODE; + else + */ + if( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + hb_vmCDP() != pArea->area.cdPage ) + iTrans = FPT_TRANS_CP; + else + iTrans = FPT_TRANS_NONE; + + ulNewSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, iTrans ); pBlock = pAlloc = ( HB_BYTE * ) hb_xgrab( ulNewSize ); - hb_fptStoreSMTItem( pArea, pItem, &pBlock, fTrans ); + hb_fptStoreSMTItem( pArea, pItem, &pBlock, iTrans ); pBlock = pAlloc; uiType = HB_VF_ARRAY; } @@ -4932,16 +5071,20 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem */ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT uiType, PHB_ITEM pItem ) { + LPFIELD pField; + HB_TRACE(HB_TR_DEBUG, ("hb_fptFieldInfo(%p, %hu, %hu, %p)", pArea, uiIndex, uiType, pItem)); if( !uiIndex || uiIndex > pArea->area.uiFieldCount ) return HB_FAILURE; + pField = &pArea->area.lpFields[ uiIndex - 1 ]; + if( pArea->fHasMemo && pArea->pMemoFile && - ( pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_MEMO || - pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_IMAGE || - pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_BLOB || - pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_OLE ) ) + ( pField->uiType == HB_FT_MEMO || + pField->uiType == HB_FT_IMAGE || + pField->uiType == HB_FT_BLOB || + pField->uiType == HB_FT_OLE ) ) { HB_ULONG ulBlock, ulSize, ulType; HB_BOOL bDeleted; @@ -4954,7 +5097,15 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT /* pItem := { , } */ HB_ULONG ulStart, ulCount; HB_ERRCODE errCode; - HB_BOOL fTrans = FPT_DIRECT_TRANS( pArea ); + int iTrans; + + if( ( pField->uiFlags & HB_FF_UNICODE ) != 0 ) + iTrans = FPT_TRANS_UNICODE; + else if( ( pField->uiFlags & HB_FF_BINARY ) == 0 && + hb_vmCDP() != pArea->area.cdPage ) + iTrans = FPT_TRANS_CP; + else + iTrans = FPT_TRANS_NONE; if( HB_IS_ARRAY( pItem ) ) { @@ -4968,8 +5119,8 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, HB_USHORT uiIndex, HB_USHORT ulStart = ulCount = 0; } if( ulStart || ulCount ) - fTrans = HB_FALSE; - errCode = hb_fptGetMemo( pArea, uiIndex, pItem, FS_ERROR, 0, ulStart, ulCount, fTrans ); + iTrans = FPT_TRANS_NONE; + errCode = hb_fptGetMemo( pArea, uiIndex, pItem, FS_ERROR, 0, ulStart, ulCount, iTrans ); if( errCode != HB_SUCCESS ) { if( errCode != HB_FAILURE ) diff --git a/harbour/src/rtl/cdpapi.c b/harbour/src/rtl/cdpapi.c index ab9ca7a989..2ac9a7ffbd 100644 --- a/harbour/src/rtl/cdpapi.c +++ b/harbour/src/rtl/cdpapi.c @@ -1172,7 +1172,6 @@ HB_SIZE hb_cdpStrAsU16Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, if( cdp == &s_utf8_codepage ) { nSrc = hb_cdpUTF8StringLength( pSrc, nSrc ); - return ( nMax && nSrc > nMax ) ? nMax : nSrc; } else if( cdp->nMultiUC ) { @@ -1215,7 +1214,7 @@ HB_SIZE hb_cdpStrAsU16Len( PHB_CODEPAGE cdp, HB_BOOL fCtrl, return ulD; } - return nSrc; + return ( nMax && nSrc > nMax ) ? nMax : nSrc; } #undef HB_CDP_ENDIAN_SWAP diff --git a/harbour/src/rtl/gtapi.c b/harbour/src/rtl/gtapi.c index 63808f8b79..7f37a294e7 100644 --- a/harbour/src/rtl/gtapi.c +++ b/harbour/src/rtl/gtapi.c @@ -1051,7 +1051,7 @@ HB_ERRCODE hb_gtInfo( int iType, PHB_GT_INFO pInfo ) } int hb_gtAlert( PHB_ITEM pMessage, PHB_ITEM pOptions, - int iClrNorm, int iClrHigh, double dDelay ) + int iClrNorm, int iClrHigh, double dDelay ) { int iResult = 0; PHB_GT pGT; diff --git a/harbour/src/rtl/gttrm/gttrm.c b/harbour/src/rtl/gttrm/gttrm.c index 83b9fd8b05..bdd767f8c2 100644 --- a/harbour/src/rtl/gttrm/gttrm.c +++ b/harbour/src/rtl/gttrm/gttrm.c @@ -3632,10 +3632,13 @@ static HB_BOOL hb_gt_trm_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) break; case HB_GTI_ADDKEYMAP: - iVal = hb_arrayGetNI( pInfo->pNewVal, 1 ); - szVal = hb_arrayGetCPtr( pInfo->pNewVal, 2 ); - if( iVal && szVal && *szVal ) - addKeyMap( pTerm, SET_CLIPKEY( iVal ), szVal ); + if( hb_itemType( pInfo->pNewVal ) & HB_IT_ARRAY ) + { + iVal = hb_arrayGetNI( pInfo->pNewVal, 1 ); + szVal = hb_arrayGetCPtr( pInfo->pNewVal, 2 ); + if( iVal && szVal && *szVal ) + addKeyMap( pTerm, SET_CLIPKEY( iVal ), szVal ); + } break; case HB_GTI_PALETTE: diff --git a/harbour/src/rtl/hbgtcore.c b/harbour/src/rtl/hbgtcore.c index 2bbed7b743..989d59e4f0 100644 --- a/harbour/src/rtl/hbgtcore.c +++ b/harbour/src/rtl/hbgtcore.c @@ -1572,7 +1572,8 @@ static HB_BOOL hb_gt_def_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) break; } case HB_GTI_SETWIN: /* restore screen buffer, cursor shape and possition */ - if( ( hb_itemType( pInfo->pNewVal ) & HB_IT_ARRAY ) && hb_arrayLen( pInfo->pNewVal ) == 8 ) + if( ( hb_itemType( pInfo->pNewVal ) & HB_IT_ARRAY ) && + hb_arrayLen( pInfo->pNewVal ) == 8 ) { HB_GTSELF_DISPBEGIN( pGT ); if( hb_arrayGetCLen( pInfo->pNewVal, 7 ) > 0 ) @@ -1662,10 +1663,10 @@ static HB_BOOL hb_gt_def_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) static int hb_gt_def_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay ) { - int iOptions = ( int ) hb_arrayLen( pOptions ); - int iRet = 0; + int iRet = 0, iOptions; - if( HB_IS_STRING( pMessage ) && iOptions > 0 ) + if( pMessage && HB_IS_STRING( pMessage ) && + pOptions && ( iOptions = ( int ) hb_arrayLen( pOptions ) ) > 0 ) { const char * szMessage = hb_itemGetCPtr( pMessage ); HB_UINT nLen = ( HB_UINT ) hb_itemGetCLen( pMessage );