/* 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; }