fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2010-10-13 13:21 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* 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
This commit is contained in:
Przemyslaw Czerpak
2010-10-13 11:22:21 +00:00
parent 3b7b686f85
commit aabe2c9dab
10 changed files with 543 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
harbour/ChangeLog
View File

@@ -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

1
harbour/contrib/hbxbp/hbxbp.hbx
View File

@@ -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

2
harbour/contrib/rddads/ads1.c
View File

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

30
harbour/doc/xhb-diff.txt
View File

@@ -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.

210
harbour/src/rdd/dbf1.c
View File

@@ -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 )

487
harbour/src/rdd/dbffpt/dbffpt1.c
View File

@@ -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 := { <nStart>, <nCount> } */
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 )

3
harbour/src/rtl/cdpapi.c
View File

@@ -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

2
harbour/src/rtl/gtapi.c
View File

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

11
harbour/src/rtl/gttrm/gttrm.c
View File

@@ -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:

9
harbour/src/rtl/hbgtcore.c
View File

@@ -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 );