/* Export field value into the buffer in PG accepted CSV format */
static HB_BOOL exportBufSqlVar( pgCopyContext * context, PHB_ITEM pValue, const char * szQuote, const char * szEsc )
{
switch( hb_itemType( pValue ) )
{
case HB_IT_STRING:
case HB_IT_MEMO:
{
HB_SIZE nLen = hb_itemGetCLen( pValue );
HB_SIZE nCnt = 0;
const char * szVal = hb_itemGetCPtr( pValue );
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
if( context->str_trim )
{
while( nLen && HB_ISSPACE( szVal[ nLen - 1 ] ) )
nLen--;
}
while( *szVal && nCnt++ < nLen )
{
/* if( *szVal == *szDelim || *szVal == *szEsc || *szVal == *szQuote )
we don't need to escape delim in CSV mode,
only the quote and the escape itself */
if( *szVal == *szQuote || *szVal == *szEsc )
if( ! addToContext( context, *szEsc ) )
return HB_FALSE;
if( ( HB_UCHAR ) *szVal >= 32 )
if( ! addToContext( context, *szVal ) )
return HB_FALSE;
szVal++;
}
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_DATE:
{
char szDate[ 9 ];
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
hb_itemGetDS( pValue, szDate );
if( szDate[ 0 ] == ' ' )
{
if( ! addStrToContext( context, "0100-01-01" ) )
return HB_FALSE;
}
else
{
if( ! addStrnToContext( context, &szDate[ 0 ], 4 ) ||
! addToContext( context, '-' ) ||
! addStrnToContext( context, &szDate[ 4 ], 2 ) ||
! addToContext( context, '-' ) ||
! addStrnToContext( context, &szDate[ 6 ], 2 ) )
return HB_FALSE;
}
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_TIMESTAMP:
{
long lDate, lTime;
char szDateTime[ 24 ];
hb_itemGetTDT( pValue, &lDate, &lTime );
hb_timeStampStr( szDateTime, lDate, lTime );
if( ! addStrToContext( context, szQuote ) ||
! addStrToContext( context, szDateTime ) ||
! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_LOGICAL:
#if 0
if( ! addStrToContext( context, szQuote ) || ! addToContext( context, hb_itemGetL( pValue ) ? 'Y' : 'N' ) || ! addStrToContext( context, szQuote ) )
#endif
if( ! addToContext( context, hb_itemGetL( pValue ) ? 'Y' : 'N' ) )
return HB_FALSE;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char szResult[ HB_MAX_DOUBLE_LENGTH ];
int iSize, iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( hb_itemStrBuf( szResult, pValue, iSize, iDec ) )
{
int iPos = 0;
while( iSize && HB_ISSPACE( szResult[ iPos ] ) )
{
iPos++;
iSize--;
}
if( ! addStrnToContext( context, &szResult[ iPos ], iSize ) )
return HB_FALSE;
}
else
if( ! addToContext( context, '0' ) )
return HB_FALSE;
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
return HB_FALSE;
}
return HB_TRUE;
}
/*
* Assign a value to a field.
*/
static HB_ERRCODE hb_delimPutValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
HB_ERRCODE uiError;
LPFIELD pField;
USHORT uiSize;
HB_TRACE(HB_TR_DEBUG, ("hb_delimPutValue(%p,%hu,%p)", pArea, uiIndex, pItem));
if( !pArea->fPositioned )
return HB_SUCCESS;
if( !pArea->fRecordChanged )
return HB_FAILURE;
uiError = HB_SUCCESS;
--uiIndex;
pField = pArea->lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
uiSize = ( USHORT ) hb_itemGetCLen( pItem );
if( uiSize > pField->uiLen )
uiSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), uiSize );
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_cdppage(), pArea->cdPage, uiSize );
#endif
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize,
' ', pField->uiLen - uiSize );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_DATE( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
uiError = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
uiError = EDBF_DATATYPE;
}
else
uiError = EDBF_DATATYPE;
}
if( uiError != HB_SUCCESS )
{
PHB_ITEM pError= hb_errNew();
USHORT uiGenCode = uiError == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, uiGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? HB_SUCCESS : HB_FAILURE;
}
return HB_SUCCESS;
}
/* Export field value into the buffer in SQL format */
static HB_BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
const char * szDelim, const char * szEsc )
{
switch( hb_itemType( pValue ) )
{
case HB_IT_STRING:
{
HB_SIZE nLen = hb_itemGetCLen( pValue );
HB_SIZE nCnt = 0;
const char *szVal = hb_itemGetCPtr( pValue );
hb_addStrToFBuffer( pFileBuf, szDelim );
while( nLen && HB_ISSPACE( szVal[ nLen - 1 ] ) )
nLen--;
while( *szVal && nCnt++ < nLen )
{
if( *szVal == *szDelim || *szVal == *szEsc )
hb_addToFBuffer( pFileBuf, *szEsc );
if( ( HB_UCHAR ) *szVal >= 32 )
hb_addToFBuffer( pFileBuf, *szVal );
else
{
/* printf( "%d %c", *szVal, *szVal ); */
}
szVal++;
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_DATE:
{
char szDate[ 9 ];
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_itemGetDS( pValue, szDate );
if( szDate[ 0 ] == ' ' )
{
hb_addStrToFBuffer( pFileBuf, "0100-01-01" );
}
else
{
hb_addStrnToFBuffer( pFileBuf, &szDate[0], 4 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[4], 2 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[6], 2 );
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_TIMESTAMP:
{
long lDate, lTime;
char szDateTime[ 24 ];
hb_itemGetTDT( pValue, &lDate, &lTime );
hb_timeStampStr( szDateTime, lDate, lTime );
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_addStrToFBuffer( pFileBuf, szDateTime );
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_LOGICAL:
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_addToFBuffer( pFileBuf, hb_itemGetL( pValue ) ? 'Y' : 'N' );
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char szResult[ HB_MAX_DOUBLE_LENGTH ];
int iSize, iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( hb_itemStrBuf( szResult, pValue, iSize, iDec ) )
{
int iPos = 0;
while( iSize && HB_ISSPACE( szResult[ iPos ] ) )
{
iPos++;
iSize--;
}
hb_addStrnToFBuffer( pFileBuf, &szResult[ iPos ], iSize );
}
else
hb_addToFBuffer( pFileBuf, '0' );
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
/* We do not want MEMO contents */
return HB_FALSE;
}
return HB_TRUE;
}
/*
* Read record, decode it to buffer and set next record offset
*/
static HB_ERRCODE hb_delimReadRecord( DELIMAREAP pArea )
{
USHORT uiField, uiLen, uiSize;
HB_TYPE uiType;
LPFIELD pField;
BYTE * pFieldBuf, buffer[ 256 ];
char cStop;
int ch = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_delimReadRecord(%p)", pArea));
if( pArea->ulBufferStart <= pArea->ulRecordOffset &&
pArea->ulBufferStart + ( HB_FOFFSET ) pArea->ulBufferRead > pArea->ulRecordOffset )
{
pArea->ulBufferIndex = ( ULONG ) ( pArea->ulRecordOffset - pArea->ulBufferStart );
}
else
{
pArea->ulBufferStart = pArea->ulRecordOffset;
pArea->ulBufferRead = pArea->ulBufferIndex = 0;
}
/* clear the record buffer */
hb_delimClearRecordBuffer( pArea );
for( uiField = 0; uiField < pArea->uiFieldCount; ++uiField )
{
pField = pArea->lpFields + uiField;
uiType = pField->uiType;
if( uiType == HB_FT_STRING || uiType == HB_FT_LOGICAL ||
uiType == HB_FT_DATE || uiType == HB_FT_LONG )
{
uiSize = 0;
uiLen = pField->uiLen;
pFieldBuf = pArea->pRecord + pArea->pFieldOffset[ uiField ];
/* ignore leading spaces */
do
ch = hb_delimNextChar( pArea );
while( ch == ' ' );
/* set the stop character */
if( pArea->cDelim && ch == pArea->cDelim )
{
cStop = pArea->cDelim;
ch = hb_delimNextChar( pArea );
}
else
cStop = pArea->cSeparator;
/*
* Clipper uses differ rules for character fields, they
* can be terminated only with valid stop character, when
* other fields also by length
*/
if( pField->uiType == HB_FT_STRING )
{
while( ch >= 0 && ch != cStop )
{
if( uiSize < uiLen )
pFieldBuf[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
}
else
{
while( ch >= 0 && ch != cStop && uiSize < uiLen )
{
buffer[ uiSize++ ] = ( BYTE ) ch;
ch = hb_delimNextChar( pArea );
}
buffer[ uiSize ] = '\0';
if( pField->uiType == HB_FT_LOGICAL )
{
*pFieldBuf = ( *buffer == 'T' || *buffer == 't' ||
*buffer == 'Y' || *buffer == 'y' ) ? 'T' : 'F';
}
else if( pField->uiType == HB_FT_DATE )
{
if( uiSize == 8 && hb_dateEncStr( ( char * ) buffer ) != 0 )
memcpy( pFieldBuf, buffer, 8 );
}
else
{
HB_LONG lVal;
double dVal;
BOOL fDbl;
fDbl = hb_strnToNum( (const char *) buffer, uiSize, &lVal, &dVal );
if( fDbl )
pArea->valResult = hb_itemPutNDLen( pArea->valResult, dVal,
uiLen - pField->uiDec - 1, pField->uiDec );
else
pArea->valResult = hb_itemPutNIntLen( pArea->valResult,
lVal, uiLen );
hb_itemStrBuf( ( char * ) buffer, pArea->valResult, uiLen, pField->uiDec );
/* TODO: RT error on width range */
memcpy( pFieldBuf, buffer, uiLen );
}
}
/* ignore all character to the next field separator */
while( ch >= 0 && ch != pArea->cSeparator )
ch = hb_delimNextChar( pArea );
/* stop reading on EOL */
if( ch < 0 )
break;
}
}
/* ignore all character to the end of line */
while( ch >= 0 )
ch = hb_delimNextChar( pArea );
if( ch == -2 &&
pArea->ulRecordOffset == ( HB_FOFFSET ) ( pArea->ulBufferStart +
pArea->ulBufferIndex ) )
{
pArea->fEof = TRUE;
pArea->fPositioned = FALSE;
}
else
{
pArea->fEof = FALSE;
pArea->fPositioned = TRUE;
}
return HB_SUCCESS;
}
/*
* Assign a value to a field.
*/
static HB_ERRCODE hb_sdfPutValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
HB_ERRCODE errCode;
LPFIELD pField;
HB_SIZE nSize;
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfPutValue(%p,%hu,%p)", pArea, uiIndex, pItem ) );
if( ! pArea->fPositioned )
return HB_SUCCESS;
if( ! pArea->fRecordChanged )
return HB_FAILURE;
if( --uiIndex >= pArea->area.uiFieldCount )
return HB_FAILURE;
errCode = HB_SUCCESS;
pField = pArea->area.lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
if( ( pField->uiFlags & HB_FF_BINARY ) == 0 )
{
nSize = pField->uiLen;
hb_cdpnDup2( hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ),
( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
&nSize, hb_vmCDP(), pArea->area.cdPage );
}
else
{
nSize = hb_itemGetCLen( pItem );
if( nSize > ( HB_SIZE ) pField->uiLen )
nSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), nSize );
}
if( nSize < ( HB_SIZE ) pField->uiLen )
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + nSize,
' ', pField->uiLen - nSize );
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_DATETIME( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else if( pField->uiType == HB_FT_TIMESTAMP &&
( pField->uiLen == 12 || pField->uiLen == 23 ) )
{
long lDate, lTime;
hb_itemGetTDT( pItem, &lDate, &lTime );
if( pField->uiLen == 12 )
hb_timeStr( szBuffer, lTime );
else
hb_timeStampStr( szBuffer, lDate, lTime );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, pField->uiLen );
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
errCode = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
errCode = EDBF_DATATYPE;
}
else
errCode = EDBF_DATATYPE;
}
if( errCode != HB_SUCCESS )
{
PHB_ITEM pError = hb_errNew();
HB_ERRCODE errGenCode = errCode == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, errGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( errGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, errCode );
hb_errPutFlags( pError, EF_CANDEFAULT );
errCode = SELF_ERROR( &pArea->area, pError );
hb_itemRelease( pError );
return errCode == E_DEFAULT ? HB_SUCCESS : HB_FAILURE;
}
return HB_SUCCESS;
}
