static HB_ERRCODE sqlite3GoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { sqlite3_stmt * st = ( ( SDDDATA * ) pArea->pSDDData )->pStmt; while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) { PHB_ITEM pArray; HB_USHORT ui; pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); for( ui = 0; ui < pArea->area.uiFieldCount; ++ui ) { PHB_ITEM pItem = NULL; LPFIELD pField = pArea->area.lpFields + ui; switch( pField->uiType ) { case HB_FT_STRING: pItem = S_HB_ITEMPUTSTR( NULL, ( const char * ) sqlite3_column_text( st, ui ) ); break; case HB_FT_LONG: case HB_FT_INTEGER: if( pField->uiDec == 0 ) #if HB_VMLONG_MAX == INT32_MAX || defined( HB_LONG_LONG_OFF ) pItem = hb_itemPutNIntLen( NULL, sqlite3_column_int( st, ui ), pField->uiLen ); #else pItem = hb_itemPutNIntLen( NULL, sqlite3_column_int64( st, ui ), pField->uiLen ); #endif else pItem = hb_itemPutNDLen( NULL, sqlite3_column_double( st, ui ), pField->uiLen, pField->uiDec ); break; case HB_FT_BLOB: pItem = hb_itemPutCL( NULL, ( const char * ) sqlite3_column_blob( st, ui ), sqlite3_column_bytes( st, ui ) ); break; } if( pItem ) { hb_arraySetForward( pArray, ui + 1, pItem ); hb_itemRelease( pItem ); } } if( pArea->ulRecCount + 1 <= pArea->ulRecMax ) { pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } pArea->ulRecCount++; pArea->pRow[ pArea->ulRecCount ] = pArray; pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; if( sqlite3_step( st ) != SQLITE_ROW ) { pArea->fFetched = HB_TRUE; break; } }
static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea ) { PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn; SDDDATA * pSDDData; PGresult * pResult; ExecStatusType status; PHB_ITEM pItemEof, pItem; HB_USHORT uiFields, uiCount; HB_BOOL bError; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; pResult = PQexec( pConn, pArea->szQuery ); if( ! pResult ) { hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_LOWMEMORY, "Query failed", NULL, 0 ); /* Low memory, etc */ return HB_FAILURE; } status = PQresultStatus( pResult ); if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK ) { hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, PQresultErrorMessage( pResult ), pArea->szQuery, ( HB_ERRCODE ) status ); PQclear( pResult ); return HB_FAILURE; } pSDDData->pResult = pResult; uiFields = ( HB_USHORT ) PQnfields( pResult ); SELF_SETFIELDEXTENT( &pArea->area, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); pItem = hb_itemNew( NULL ); bError = HB_FALSE; for( uiCount = 0; uiCount < uiFields; uiCount++ ) { DBFIELDINFO dbFieldInfo; memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) ); dbFieldInfo.atomName = PQfname( pResult, ( int ) uiCount ); switch( PQftype( pResult, ( int ) uiCount ) ) { case BPCHAROID: case VARCHAROID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4; break; case TEXTOID: dbFieldInfo.uiType = HB_FT_MEMO; dbFieldInfo.uiLen = 10; break; case NUMERICOID: dbFieldInfo.uiType = HB_FT_DOUBLE; dbFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16; dbFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF; break; case INT2OID: dbFieldInfo.uiType = HB_FT_INTEGER; dbFieldInfo.uiLen = 6; break; case INT4OID: dbFieldInfo.uiType = HB_FT_INTEGER; dbFieldInfo.uiLen = 11; break; case INT8OID: case OIDOID: dbFieldInfo.uiType = HB_FT_LONG; dbFieldInfo.uiLen = 20; break; case FLOAT4OID: case FLOAT8OID: case CASHOID: /* TODO: ??? */ dbFieldInfo.uiType = HB_FT_DOUBLE; dbFieldInfo.uiLen = 16; dbFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */ break; case BOOLOID: dbFieldInfo.uiType = HB_FT_LOGICAL; dbFieldInfo.uiLen = 1; break; case DATEOID: dbFieldInfo.uiType = HB_FT_DATE; dbFieldInfo.uiLen = 8; break; case INETOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 29; break; case CIDROID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 32; break; case MACADDROID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 17; break; case BITOID: case VARBITOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount ); break; case TIMEOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 12; break; case TIMESTAMPOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 23; break; case TIMETZOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 15; break; case TIMESTAMPTZOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 26; break; case NAMEOID: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiLen = 63; break; case BYTEAOID: dbFieldInfo.uiType = HB_FT_STRING; break; default: bError = HB_TRUE; break; } /* printf( "field:%s \ttype:%d \tsize:%d \tformat:%d \tmod:%d err=%d\n", dbFieldInfo.atomName, PQftype( pResult, ( int ) uiCount ), PQfsize( pResult, uiCount ), PQfformat( pResult, uiCount ) , PQfmod( pResult, uiCount ), bError ); */ if( ! bError ) { switch( dbFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr; pStr = ( char * ) hb_xgrab( dbFieldInfo.uiLen + 1 ); memset( pStr, ' ', dbFieldInfo.uiLen ); pStr[ dbFieldInfo.uiLen ] = '\0'; hb_itemPutCL( pItem, pStr, dbFieldInfo.uiLen ); hb_xfree( pStr ); break; } case HB_FT_MEMO: hb_itemPutC( pItem, NULL ); hb_itemSetCMemo( pItem ); break; case HB_FT_INTEGER: hb_itemPutNI( pItem, 0 ); break; case HB_FT_LONG: hb_itemPutNL( pItem, 0 ); break; case HB_FT_DOUBLE: hb_itemPutND( pItem, 0.0 ); break; case HB_FT_LOGICAL: hb_itemPutL( pItem, HB_FALSE ); break; case HB_FT_DATE: hb_itemPutDS( pItem, NULL ); break; default: hb_itemClear( pItem ); bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiCount + 1, pItem ); /* if( dbFieldInfo.uiType == HB_IT_DOUBLE || dbFieldInfo.uiType == HB_IT_INTEGER ) dbFieldInfo.uiType = HB_IT_LONG; */ if( ! bError ) bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE ); } if( bError ) break; } hb_itemRelease( pItem ); if( bError ) { hb_itemClear( pItemEof ); hb_itemRelease( pItemEof ); hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 ); return HB_FAILURE; } pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult ); pArea->ulRecMax = pArea->ulRecCount + 1; pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pArea->fFetched = HB_TRUE; return HB_SUCCESS; }
static void sk_add( PHB_SETKEY * sk_list_ptr, HB_BOOL bReturn, int iKeyCode, PHB_ITEM pAction, PHB_ITEM pIsActive ) { if( iKeyCode ) { PHB_SETKEY sk_list_tmp, sk_list_end; if( pIsActive && ! HB_IS_BLOCK( pIsActive ) ) pIsActive = NULL; if( pAction && ! HB_IS_BLOCK( pAction ) ) pAction = NULL; sk_list_tmp = sk_findkey( iKeyCode, *sk_list_ptr, &sk_list_end ); if( sk_list_tmp == NULL ) { if( pAction ) { sk_list_tmp = ( PHB_SETKEY ) hb_xgrab( sizeof( HB_SETKEY ) ); sk_list_tmp->next = NULL; sk_list_tmp->iKeyCode = iKeyCode; sk_list_tmp->pAction = hb_itemNew( pAction ); sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL; if( sk_list_end == NULL ) *sk_list_ptr = sk_list_tmp; else sk_list_end->next = sk_list_tmp; } } else { /* Return the previous value */ if( bReturn ) hb_itemReturn( sk_list_tmp->pAction ); /* Free the previous values */ hb_itemRelease( sk_list_tmp->pAction ); if( sk_list_tmp->pIsActive ) { hb_itemRelease( sk_list_tmp->pIsActive ); } /* Set the new values or free the entry */ if( pAction ) { sk_list_tmp->pAction = hb_itemNew( pAction ); sk_list_tmp->pIsActive = pIsActive ? hb_itemNew( pIsActive ) : NULL; } else { /* if this is true, then the key found is the first key in the list */ if( sk_list_end == NULL ) { sk_list_tmp = *sk_list_ptr; *sk_list_ptr = sk_list_tmp->next; hb_xfree( sk_list_tmp ); } else { sk_list_end->next = sk_list_tmp->next; hb_xfree( sk_list_tmp ); } } } } }
/* * Obtain the current value of a field. */ static HB_ERRCODE hb_sdfGetValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { LPFIELD pField; HB_TRACE( HB_TR_DEBUG, ( "hb_sdfGetValue(%p, %hu, %p)", pArea, uiIndex, pItem ) ); if( --uiIndex >= pArea->area.uiFieldCount ) return HB_FAILURE; pField = pArea->area.lpFields + uiIndex; switch( pField->uiType ) { case HB_FT_STRING: if( ( pField->uiFlags & HB_FF_BINARY ) == 0 ) { HB_SIZE nLen = pField->uiLen; char * pszVal = hb_cdpnDup( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], &nLen, pArea->area.cdPage, hb_vmCDP() ); hb_itemPutCLPtr( pItem, pszVal, nLen ); } else { hb_itemPutCL( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen ); } break; case HB_FT_LOGICAL: switch( pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] ) { case 'T': case 't': case 'Y': case 'y': hb_itemPutL( pItem, HB_TRUE ); break; default: hb_itemPutL( pItem, HB_FALSE ); break; } break; case HB_FT_DATE: hb_itemPutDS( pItem, ( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ] ); break; case HB_FT_TIMESTAMP: { long lJulian, lMilliSec; HB_BYTE * pFieldPtr = pArea->pRecord + pArea->pFieldOffset[ uiIndex ], bChar; bChar = pFieldPtr[ pField->uiLen ]; pFieldPtr[ pField->uiLen ] = 0; hb_timeStampStrGetDT( ( const char * ) pFieldPtr, &lJulian, &lMilliSec ); pFieldPtr[ pField->uiLen ] = bChar; hb_itemPutTDT( pItem, lJulian, lMilliSec ); break; } case HB_FT_LONG: { HB_MAXINT lVal; double dVal; HB_BOOL fDbl; fDbl = hb_strnToNum( ( const char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], pField->uiLen, &lVal, &dVal ); if( pField->uiDec ) { hb_itemPutNDLen( pItem, fDbl ? dVal : ( double ) lVal, ( int ) ( pField->uiLen - pField->uiDec - 1 ), ( int ) pField->uiDec ); } else if( fDbl ) { hb_itemPutNDLen( pItem, dVal, ( int ) pField->uiLen, 0 ); } else { hb_itemPutNIntLen( pItem, lVal, ( int ) pField->uiLen ); } } break; case HB_FT_MEMO: hb_itemPutC( pItem, NULL ); break; case HB_FT_NONE: hb_itemClear( pItem ); break; default: { PHB_ITEM pError; pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) ); hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) ); hb_errPutSubCode( pError, EDBF_DATATYPE ); SELF_ERROR( &pArea->area, pError ); hb_itemRelease( pError ); return HB_FAILURE; } } return HB_SUCCESS; }
void hb_ssl_socketClose( PHB_SSLSTREAM pStream ) { SSL_shutdown( pStream->ssl ); hb_itemRelease( pStream->pSSL ); hb_xfree( pStream ); }
static const char * _hb_jsonDecode( const char * szSource, PHB_ITEM pValue ) { if( *szSource == '\"' ) { char * szDest, * szHead; HB_SIZE nAlloc = 16; szHead = szDest = ( char * ) hb_xgrab( nAlloc ); szSource++; while( *szSource != '\"' ) { if( szHead + 6 >= szDest + nAlloc ) { HB_SIZE nLen = szHead - szDest; nAlloc += nAlloc << 1; szDest = ( char * ) hb_xrealloc( szDest, nAlloc ); szHead = szDest + nLen; } if( *szSource == '\\' ) { szSource++; switch( *szSource ) { case '\"': *szHead++ = '\"'; break; case '\\': *szHead++ = '\\'; break; case '/': *szHead++ = '/'; break; case 'b': *szHead++ = '\b'; break; case 'f': *szHead++ = '\f'; break; case 'n': *szHead++ = '\n'; break; case 'r': *szHead++ = '\r'; break; case 't': *szHead++ = '\t'; break; case 'u': { HB_WCHAR wc = 0; int i; for( i = 0; i < 4; i++ ) { char c = *++szSource; wc <<= 4; if( c >= '0' && c <= '9' ) wc += c - '0'; else if( c >= 'A' && c <= 'F' ) wc += c - 'A' + 10; else if( c >= 'a' && c <= 'f' ) wc += c - 'a' + 10; else { hb_xfree( szDest ); return NULL; } } szHead += hb_cdpU16ToStr( hb_vmCDP(), HB_CDP_ENDIAN_NATIVE, &wc, 1, szHead, szDest + nAlloc - szHead ); break; } default: hb_xfree( szDest ); return NULL; } szSource++; } else if( *( const unsigned char * ) szSource >= ' ' ) *szHead++ = *szSource++; else { hb_xfree( szDest ); return NULL; } } hb_itemPutCL( pValue, szDest, szHead - szDest ); hb_xfree( szDest ); return szSource + 1; } else if( *szSource == '-' || ( *szSource >= '0' && *szSource <= '9' ) ) { /* NOTE: this function is much less strict to number format than JSON syntax definition. This is allowed behaviour [Mindaugas] */ HB_MAXINT nValue = 0; double dblValue = 0; HB_BOOL fNeg, fDbl = HB_FALSE; int iDec = 0; fNeg = *szSource == '-'; if( fNeg ) szSource++; while( *szSource >= '0' && *szSource <= '9' ) { nValue = nValue * 10 + *szSource - '0'; szSource++; } if( *szSource == '.' ) { double mult = 1; dblValue = ( double ) nValue; fDbl = HB_TRUE; szSource++; while( *szSource >= '0' && *szSource <= '9' ) { mult /= 10; dblValue += ( ( double ) ( *szSource - '0' ) ) * mult; szSource++; iDec++; } } if( *szSource == 'e' || *szSource == 'E' ) { HB_BOOL fNegExp; int iExp = 0; szSource++; fNegExp = *szSource == '-'; if( fNegExp ) szSource++; while( *szSource >= '0' && *szSource <= '9' ) { iExp = iExp * 10 + *szSource - '0'; szSource++; } if( ! fDbl ) { dblValue = ( double ) nValue; fDbl = HB_TRUE; } if( fNegExp ) iDec += iExp; dblValue = hb_numExpConv( dblValue, fNegExp ? iExp : -iExp ); } if( fDbl ) hb_itemPutNDDec( pValue, hb_numRound( fNeg ? -dblValue : dblValue, iDec ), iDec ); else hb_itemPutNInt( pValue, fNeg ? -nValue : nValue ); return szSource; } else if( ! strncmp( szSource, "null", 4 ) ) { hb_itemClear( pValue ); return szSource + 4; } else if( ! strncmp( szSource, "true", 4 ) ) { hb_itemPutL( pValue, HB_TRUE ); return szSource + 4; } else if( ! strncmp( szSource, "false", 5 ) ) { hb_itemPutL( pValue, HB_FALSE ); return szSource + 5; } else if( *szSource == '[' ) { hb_arrayNew( pValue, 0 ); szSource = _skipws( szSource + 1 ); if( *szSource != ']' ) { PHB_ITEM pItem = hb_itemNew( NULL ); for( ;; ) { szSource = _hb_jsonDecode( szSource, pItem ); if( ! szSource ) { hb_itemRelease( pItem ); return NULL; } hb_arrayAddForward( pValue, pItem ); szSource = _skipws( szSource ); if( *szSource == ',' ) { szSource = _skipws( szSource + 1 ); continue; } else if( *szSource == ']' ) break; else { hb_itemRelease( pItem ); return NULL; } } hb_itemRelease( pItem ); } return szSource + 1; } else if( *szSource == '{' ) { hb_hashNew( pValue ); szSource = _skipws( szSource + 1 ); if( *szSource != '}' ) { PHB_ITEM pItemKey = hb_itemNew( NULL ); PHB_ITEM pItemValue = hb_itemNew( NULL ); for( ;; ) { /* Do we need to check if key does not exist yet? */ if( ( szSource = _hb_jsonDecode( szSource, pItemKey ) ) == NULL || ! HB_IS_STRING( pItemKey ) || * ( szSource = _skipws( szSource ) ) != ':' || ( szSource = _hb_jsonDecode( _skipws( szSource + 1 ), pItemValue ) ) == NULL) { hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); return NULL; } hb_hashAdd( pValue, pItemKey, pItemValue ); szSource = _skipws( szSource ); if( *szSource == ',' ) { szSource = _skipws( szSource + 1 ); continue; } else if( *szSource == '}' ) break; else { hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); return NULL; } } hb_itemRelease( pItemKey ); hb_itemRelease( pItemValue ); } return szSource + 1; } return NULL; }
/* * Create a data store in the specified WorkArea. */ static HB_ERRCODE hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo ) { HB_ERRCODE errCode; PHB_FNAME pFileName; PHB_ITEM pError = NULL; HB_BOOL fRetry; char szFileName[ HB_PATH_MAX ]; HB_TRACE( HB_TR_DEBUG, ( "hb_sdfCreate(%p,%p)", pArea, pCreateInfo ) ); pArea->fShared = HB_FALSE; /* pCreateInfo->fShared; */ pArea->fReadonly = HB_FALSE; /* pCreateInfo->fReadonly */ if( pCreateInfo->cdpId ) { pArea->area.cdPage = hb_cdpFindExt( pCreateInfo->cdpId ); if( ! pArea->area.cdPage ) pArea->area.cdPage = hb_vmCDP(); } else pArea->area.cdPage = hb_vmCDP(); pFileName = hb_fsFNameSplit( pCreateInfo->abName ); if( hb_setGetDefExtension() && ! pFileName->szExtension ) { PHB_ITEM pItem = hb_itemPutC( NULL, NULL ); SELF_INFO( &pArea->area, DBI_TABLEEXT, pItem ); pFileName->szExtension = hb_itemGetCPtr( pItem ); hb_fsFNameMerge( szFileName, pFileName ); hb_itemRelease( pItem ); } else { hb_strncpy( szFileName, pCreateInfo->abName, sizeof( szFileName ) - 1 ); } hb_xfree( pFileName ); /* Try create */ do { pArea->pFile = hb_fileExtOpen( szFileName, NULL, FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE | FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME | FXO_NOSEEKPOS, NULL, pError ); if( ! pArea->pFile ) { if( ! pError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_CREATE ); hb_errPutSubCode( pError, EDBF_CREATE_DBF ); hb_errPutOsCode( pError, hb_fsError() ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) ); hb_errPutFileName( pError, szFileName ); hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT ); } fRetry = ( SELF_ERROR( &pArea->area, pError ) == E_RETRY ); } else fRetry = HB_FALSE; } while( fRetry ); if( pError ) hb_itemRelease( pError ); if( ! pArea->pFile ) return HB_FAILURE; errCode = SUPER_CREATE( &pArea->area, pCreateInfo ); if( errCode != HB_SUCCESS ) { SELF_CLOSE( &pArea->area ); return errCode; } hb_sdfInitArea( pArea, szFileName ); /* Position cursor at the first record */ return SELF_GOTOP( &pArea->area ); }
static HB_ERRCODE ocilibOpen( SQLBASEAREAP pArea ) { OCI_Statement * st = OCI_StatementCreate( ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn ); OCI_Resultset * rs; SDDDATA * pSDDData; void * hQuery; HB_USHORT uiFields, uiIndex; PHB_ITEM pItemEof, pItem; HB_ERRCODE errCode; char * szError; HB_BOOL bError; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; if( ! st ) { szError = ocilibGetError( &errCode ); hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode ); hb_xfree( szError ); return HB_FAILURE; } pItem = hb_itemPutC( NULL, pArea->szQuery ); if( ! OCI_ExecuteStmt( st, M_HB_ITEMGETSTR( pItem, &hQuery, NULL ) ) ) { hb_strfree( hQuery ); hb_itemRelease( pItem ); szError = ocilibGetError( &errCode ); OCI_StatementFree( st ); hb_errRT_OCIDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); hb_xfree( szError ); return HB_FAILURE; } else { hb_strfree( hQuery ); hb_itemRelease( pItem ); } rs = OCI_GetResultset( st ); uiFields = ( HB_USHORT ) OCI_GetColumnCount( rs ); SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); pItem = hb_itemNew( NULL ); #if 0 HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) ); #endif errCode = 0; bError = HB_FALSE; for( uiIndex = 0; uiIndex < uiFields; ++uiIndex ) { DBFIELDINFO pFieldInfo; PHB_ITEM pName; OCI_Column * col = OCI_GetColumn( rs, uiIndex + 1 ); unsigned int uiDataType; unsigned int uiSize; int iDec; HB_BOOL bNullable; if( ! col ) { hb_itemRelease( pItemEof ); hb_itemRelease( pItem ); szError = ocilibGetError( NULL ); OCI_StatementFree( st ); hb_errRT_OCIDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 ); hb_xfree( szError ); return HB_FAILURE; } pName = D_HB_ITEMPUTSTR( NULL, OCI_ColumnGetName( col ) ); pFieldInfo.atomName = hb_itemGetCPtr( pName ); uiDataType = OCI_ColumnGetType( col ); uiSize = OCI_ColumnGetSize( col ); iDec = OCI_ColumnGetPrecision( col ); bNullable = ( HB_BOOL ) OCI_ColumnGetNullable( col ); if( bNullable ) pFieldInfo.uiFlags |= HB_FF_NULLABLE; pFieldInfo.uiLen = ( HB_USHORT ) uiSize; pFieldInfo.uiDec = ( HB_USHORT ) iDec; #if 0 HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d nullable=%d %d %d %d %d", pFieldInfo.atomName, uiDataType, uiSize, iDec, bNullable, OCI_ColumnGetScale( col ), OCI_ColumnGetPrecision( col ), OCI_ColumnGetFractionalPrecision( col ), OCI_ColumnGetLeadingPrecision( col ) ) ); #endif switch( uiDataType ) { case OCI_CDT_TEXT: pFieldInfo.uiType = HB_FT_STRING; break; case OCI_CDT_NUMERIC: pFieldInfo.uiType = HB_FT_LONG; /* For plain 'NUMERIC', precision is zero and scale is -127 */ if( OCI_ColumnGetPrecision( col ) > 0 ) pFieldInfo.uiLen = ( HB_USHORT ) OCI_ColumnGetPrecision( col ); if( OCI_ColumnGetScale( col ) >= 0 ) pFieldInfo.uiDec = ( HB_USHORT ) OCI_ColumnGetScale( col ); else pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals(); break; case OCI_CDT_LONG: pFieldInfo.uiType = HB_FT_VARLENGTH; break; case OCI_CDT_RAW: pFieldInfo.uiType = HB_FT_BLOB; break; case OCI_CDT_DATETIME: case OCI_CDT_TIMESTAMP: case OCI_CDT_INTERVAL: pFieldInfo.uiType = HB_FT_TIME; break; default: #if 0 HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", uiDataType ) ); #endif bError = HB_TRUE; errCode = ( HB_ERRCODE ) uiDataType; pFieldInfo.uiType = 0; pFieldInfo.uiType = HB_FT_STRING; break; } if( ! bError ) { switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); pStr[ pFieldInfo.uiLen ] = '\0'; hb_itemPutCLPtr( pItem, pStr, pFieldInfo.uiLen ); break; } case HB_FT_MEMO: case HB_FT_VARLENGTH: case HB_FT_BLOB: hb_itemPutC( pItem, NULL ); break; case HB_FT_INTEGER: hb_itemPutNI( pItem, 0 ); break; case HB_FT_LONG: if( pFieldInfo.uiDec == 0 ) hb_itemPutNLLen( pItem, 0, pFieldInfo.uiLen ); else hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec ); break; case HB_FT_DOUBLE: hb_itemPutNDLen( pItem, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec ); break; case HB_FT_LOGICAL: hb_itemPutL( pItem, HB_FALSE ); break; case HB_FT_DATE: hb_itemPutDL( pItem, 0 ); break; case HB_FT_TIME: case HB_FT_TIMESTAMP: hb_itemPutTDT( pItem, 0, 0 ); break; default: hb_itemClear( pItem ); bError = HB_TRUE; } hb_arraySetForward( pItemEof, uiIndex + 1, pItem ); if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } hb_itemRelease( pName ); if( bError ) break; } hb_itemRelease( pItem ); if( bError ) { hb_itemRelease( pItemEof ); OCI_StatementFree( st ); hb_errRT_OCIDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); return HB_FAILURE; } pArea->ulRecCount = 0; pArea->ulRecMax = SQLDD_ROWSET_INIT; pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pSDDData->pStmt = st; return HB_SUCCESS; }
static HB_ERRCODE ocilibGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { OCI_Statement * st = ( ( SDDDATA * ) pArea->pSDDData )->pStmt; OCI_Resultset * rs = OCI_GetResultset( st ); while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) { PHB_ITEM pArray; HB_USHORT ui; if( ! OCI_FetchNext( rs ) ) { pArea->fFetched = HB_TRUE; break; } pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); for( ui = 1; ui <= pArea->area.uiFieldCount; ++ui ) { PHB_ITEM pItem = NULL; LPFIELD pField = pArea->area.lpFields + ui - 1; switch( pField->uiType ) { case HB_FT_STRING: if( OCI_IsNull( rs, ui ) ) { char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pField->uiLen + 1 ); memset( pStr, ' ', pField->uiLen ); pStr[ pField->uiLen ] = '\0'; pItem = hb_itemPutCLPtr( NULL, pStr, pField->uiLen ); } else { const dtext * val; if( ( val = OCI_GetString( rs, ui ) ) != NULL ) pItem = D_HB_ITEMPUTSTRLEN( NULL, val, ( HB_SIZE ) dtslen( val ) ); /* TODO: Pad it to pField->uiLen size with spaces? */ } break; case HB_FT_LONG: case HB_FT_INTEGER: if( pField->uiDec == 0 ) #if HB_VMLONG_MAX == INT32_MAX || defined( HB_LONG_LONG_OFF ) pItem = hb_itemPutNIntLen( NULL, OCI_GetInt( rs, ui ), pField->uiLen ); #else pItem = hb_itemPutNIntLen( NULL, OCI_GetBigInt( rs, ui ), pField->uiLen ); #endif else pItem = hb_itemPutNDLen( NULL, OCI_GetDouble( rs, ui ), pField->uiLen, pField->uiDec ); break; case HB_FT_VARLENGTH: case HB_FT_MEMO: { OCI_Long * val = OCI_GetLong( rs, ui ); if( val ) { unsigned int uiSize = OCI_LongGetSize( val ); if( OCI_LongGetType( val ) == OCI_CLONG ) pItem = D_HB_ITEMPUTSTRLEN( NULL, ( D_HB_CHAR * ) OCI_LongGetBuffer( val ), uiSize ); else pItem = hb_itemPutCL( NULL, ( char * ) OCI_LongGetBuffer( val ), uiSize ); } break; } case HB_FT_IMAGE: case HB_FT_BLOB: case HB_FT_OLE: { OCI_Long * val = OCI_GetLong( rs, ui ); if( val ) pItem = hb_itemPutCL( NULL, ( char * ) OCI_LongGetBuffer( val ), OCI_LongGetSize( val ) ); break; } case HB_FT_CURRENCY: case HB_FT_CURDOUBLE: case HB_FT_FLOAT: case HB_FT_DOUBLE: pItem = hb_itemPutNDLen( NULL, OCI_GetDouble( rs, ui ), pField->uiLen, pField->uiDec ); break; case HB_FT_DATE: { OCI_Date * date = OCI_GetDate( rs, ui ); int iYear, iMonth, iDay; if( date && OCI_DateGetDate( date, &iYear, &iMonth, &iDay ) ) pItem = hb_itemPutD( NULL, iYear, iMonth, iDay ); break; } case HB_FT_TIME: { OCI_Date * date = OCI_GetDate( rs, ui ); int iYear, iMonth, iDay, iHour, iMin, iSec; if( date && OCI_DateGetDateTime( date, &iYear, &iMonth, &iDay, &iHour, &iMin, &iSec ) ) pItem = hb_itemPutTDT( NULL, hb_dateEncode( iYear, iMonth, iDay ), hb_timeEncode( iHour, iMin, iSec, 0 ) ); break; } case HB_FT_TIMESTAMP: { OCI_Timestamp * ts = OCI_GetTimestamp( rs, ui ); int iYear, iMonth, iDay, iHour, iMin, iSec, iFSec; if( ts && OCI_TimestampGetDateTime( ts, &iYear, &iMonth, &iDay, &iHour, &iMin, &iSec, &iFSec ) ) pItem = hb_itemPutTDT( NULL, hb_dateEncode( iYear, iMonth, iDay ), hb_timeEncode( iHour, iMin, iSec, iFSec / 1000000 ) ); break; } } if( pItem ) { hb_arraySetForward( pArray, ui, pItem ); hb_itemRelease( pItem ); } } if( pArea->ulRecCount + 1 <= pArea->ulRecMax ) { pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } pArea->ulRecCount++; pArea->pRow[ pArea->ulRecCount ] = pArray; pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; }
int hb_CmpTdSpan( const char * szFile, PHB_ITEM pArray, int iCompLevel, PHB_ITEM pBlock, BOOL bOverWrite, const char * szPassWord, int iSpanSize, BOOL bPath, BOOL bDrive, PHB_ITEM pProgress ) { ULONG ulCount = 0; const char * szDummy; DWORD dwSize; BOOL bAdded = FALSE; BOOL bReturn = TRUE; BOOL bFileExist = hb_fsFile( szFile ); CZipArchive szZip; SpanCallbackc span; SpanActionCallbackc spanac; szZip.SetSpanCallback( &span ); if( iSpanSize == 0 ) { iSpanSize = 1457664; } try { if( ( bFileExist && bOverWrite ) || ! bFileExist ) { szZip.Open( szFile, CZipArchive::zipCreateSpan, iSpanSize ); } else { bReturn = FALSE; return ( int ) bReturn; } } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } //if (! bReturn ) //{ if( szPassWord != NULL ) { szZip.SetPassword( szPassWord ); } if( pZipI.szComment != NULL ) { szZip.SetGlobalComment( pZipI.szComment ); hb_xfree( pZipI.szComment ); } if( HB_IS_BLOCK( pProgress ) ) { pProgressInfo = pProgress; szZip.SetCallback( &spanac ); } for( ulCount = 1; ( ulCount <= hb_arrayLen( pArray ) ); ulCount++ ) { szDummy = ( char * ) hb_arrayGetCPtr( pArray, ulCount ); dwSize = GetCurrentFileSize( szDummy ); bAdded = FALSE; if( dwSize != ( DWORD ) -1 ) { if( pBlock != NULL ) { PHB_ITEM FileName = hb_itemPutC( NULL, hb_arrayGetCPtr( pArray, ulCount ) ), FilePos = hb_itemPutNI( NULL, ulCount ); hb_vmEvalBlockV( pBlock, 2, FileName, FilePos ); hb_itemRelease( FileName ); hb_itemRelease( FilePos ); } try { if( bPath && ! bAdded ) { szZip.AddNewFile( szDummy, iCompLevel, true, CZipArchive::zipsmSafeSmart, 65536 ); bAdded = TRUE; } else if( ! bDrive && ! bPath && ! bAdded ) { szZip.AddNewFile( szDummy, iCompLevel, false, CZipArchive::zipsmSafeSmart, 65536 ); } } catch( ... ) { } } } //} try { szZip.Close(); } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } return ( int ) bReturn; }
int hb_CmpTdSpanStd( char * szFile, char * szFiletoCompress, int iCompLevel, PHB_ITEM pBlock, BOOL bOverWrite, char * szPassWord, int iSpanSize, BOOL bPath, BOOL bDrive, PHB_ITEM pProgress ) { DWORD dwSize; BOOL bAdded = FALSE; BOOL bReturn = TRUE; BOOL bFileExist = hb_fsFile( szFile ); CZipArchive szZip; SpanCallbackc span; SpanActionCallbackc spanac; szZip.SetSpanCallback( &span ); if( iSpanSize == 0 ) { iSpanSize = 1457664; } try { if( ( bFileExist && bOverWrite ) || ! bFileExist ) { szZip.Open( szFile, CZipArchive::zipCreateSpan, iSpanSize ); } else { return ( int ) false; } } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } if( szPassWord != NULL ) { szZip.SetPassword( szPassWord ); } if( pZipI.szComment != NULL ) { szZip.SetGlobalComment( pZipI.szComment ); hb_xfree( pZipI.szComment ); } if( HB_IS_BLOCK( pProgress ) ) { pProgressInfo = pProgress; szZip.SetCallback( &spanac ); } if( bReturn ) { try { if( szPassWord != NULL ) { szZip.SetPassword( szPassWord ); } dwSize = GetCurrentFileSize( szFiletoCompress ); if( pBlock != NULL ) { PHB_ITEM FileName = hb_itemPutC( NULL, szFiletoCompress ); hb_vmEvalBlockV( pBlock, 1, FileName ); hb_itemRelease( FileName ); } #if defined( __WIN32__ ) || defined( __MINGW32__ ) if( bDrive && ! bAdded ) { if( ! szZip.AddNewFileDrv( szFiletoCompress, iCompLevel, true, CZipArchive::zipsmSafeSmart, 65536 ) ) { bReturn = FALSE; } else { bAdded = TRUE; } } #endif if( bPath && ! bAdded ) { if( ! szZip.AddNewFile( szFiletoCompress, iCompLevel, true, CZipArchive::zipsmSafeSmart, 65536 ) ) { bReturn = FALSE; } else { bAdded = TRUE; } } else if( ! bDrive && ! bPath && ! bAdded ) { if( ! szZip.AddNewFile( szFiletoCompress, iCompLevel, false, CZipArchive::zipsmSafeSmart, 65536 ) ) { bReturn = FALSE; } } } catch( ... ) { } } try { szZip.Close(); } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } if( pProgressInfo ) { hb_itemRelease( pProgressInfo ); } return ( int ) bReturn; }
int hb_CompressFile( const char * szFile, PHB_ITEM pArray, int iCompLevel, PHB_ITEM pBlock, BOOL bOverWrite, const char * szPassWord, BOOL bPath, BOOL bDrive, PHB_ITEM pProgress ) { ULONG ulCount = 0; const char * szDummy; char * szDummyLower = NULL; char * szFileLower = hb_strdup( ( char * ) szFile ); BOOL bFileExist = hb_fsFile( szFile ); BOOL bAdded = FALSE; BOOL bReturn = TRUE; DWORD dwSize; CZipArchive szZip; SpanCallbackc span; SpanActionCallbackc spanac; szZip.SetSpanCallback( &span ); #ifdef HB_OS_WIN_32 hb_strLower( szFileLower, strlen( szFileLower ) ); #endif try { if( ( bFileExist && bOverWrite ) || ! bFileExist ) { szZip.Open( szFile, CZipArchive::zipCreate, 0 ); } else { szZip.Open( szFile, CZipArchive::zipOpen, 0 ); } } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } if( bReturn ) { if( szPassWord != NULL ) { szZip.SetPassword( szPassWord ); } if( pZipI.szComment != NULL ) { szZip.SetGlobalComment( pZipI.szComment ); hb_xfree( pZipI.szComment ); } if( HB_IS_BLOCK( pProgress ) ) { pProgressInfo = pProgress; szZip.SetCallback( &spanac ); } for( ulCount = 1; ( ulCount <= hb_arrayLen( pArray ) ); ulCount++ ) { szDummy = ( char * ) hb_arrayGetCPtr( pArray, ulCount ); dwSize = GetCurrentFileSize( szDummy ); bAdded = FALSE; szDummyLower = hb_strdup( ( char * ) szDummy ); #ifdef HB_OS_WIN_32 hb_strLower( szDummyLower, strlen( szDummyLower ) ); #endif // Prevent adding current archive file ! if( strstr( szFileLower, szDummyLower ) == NULL && strstr( szDummyLower, szFileLower ) == NULL ) { if( dwSize != ( DWORD ) -1 ) { if( pBlock != NULL ) { PHB_ITEM FileName = hb_itemPutC( NULL, hb_arrayGetCPtr( pArray, ulCount ) ), FilePos = hb_itemPutNI( NULL, ulCount ); hb_vmEvalBlockV( pBlock, 2, FileName, FilePos ); hb_itemRelease( FileName ); hb_itemRelease( FilePos ); } try { if( bPath && ! bAdded ) { szZip.AddNewFile( szDummy, iCompLevel, true, CZipArchive::zipsmSafeSmart, 65536 ); bAdded = TRUE; } else if( ! bDrive && ! bPath && ! bAdded ) { szZip.AddNewFile( szDummy, iCompLevel, false, CZipArchive::zipsmSafeSmart, 65536 ); } } catch( ... ) { } } } hb_xfree( szDummyLower ); } } hb_xfree( szFileLower ); try { szZip.Close(); } catch( CZipException ) { bReturn = FALSE; } catch( ... ) { } return ( int ) bReturn; }
static amqp_response_type_enum s_process_response( int iParam, amqp_rpc_reply_t x ) { if( HB_ISBYREF( iParam ) ) { PHB_ITEM hResponse = hb_hashNew( NULL ); PHB_ITEM pKey = hb_itemNew( NULL ); PHB_ITEM pVal = hb_itemNew( NULL ); char szName[ HB_SYMBOL_NAME_LEN + HB_SYMBOL_NAME_LEN + 5 ]; hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "cAPI" ), hb_itemPutC( pVal, hb_procname( 0, szName, HB_FALSE ) ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReplyType" ), hb_itemPutNI( pVal, ( int ) x.reply_type ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nLibraryError" ), hb_itemPutNI( pVal, x.library_error ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "cLibraryError" ), hb_itemPutC( pVal, amqp_error_string2( x.library_error ) ) ); switch( x.reply_type ) { case AMQP_RESPONSE_NORMAL: /* fallthrough */ case AMQP_RESPONSE_LIBRARY_EXCEPTION: /* fallthrough */ case AMQP_RESPONSE_NONE: break; case AMQP_RESPONSE_SERVER_EXCEPTION: hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReplyID" ), hb_itemPutNI( pVal, ( int ) x.reply.id ) ); switch( x.reply.id ) { case AMQP_CONNECTION_CLOSE_METHOD: { amqp_connection_close_t * m = ( amqp_connection_close_t * ) x.reply.decoded; hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Code" ), hb_itemPutNL( pVal, ( long ) m->reply_code ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Text" ), hb_itemPutCL( pVal, m->reply_text.bytes, m->reply_text.len ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_ClassID" ), hb_itemPutNL( pVal, ( long ) m->class_id ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_MethodID" ), hb_itemPutNL( pVal, ( long ) m->method_id ) ); break; } case AMQP_CHANNEL_CLOSE_METHOD: { amqp_channel_close_t * m = ( amqp_channel_close_t * ) x.reply.decoded; hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Code" ), hb_itemPutNL( pVal, ( long ) m->reply_code ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_Text" ), hb_itemPutCL( pVal, m->reply_text.bytes, m->reply_text.len ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_ClassID" ), hb_itemPutNL( pVal, ( long ) m->class_id ) ); hb_hashAdd( hResponse, hb_itemPutCConst( pKey, "nReply_MethodID" ), hb_itemPutNL( pVal, ( long ) m->method_id ) ); break; } } break; } if( ! hb_itemParamStoreRelease( iParam, hResponse ) ) hb_itemRelease( hResponse ); hb_itemRelease( pVal ); hb_itemRelease( pKey ); } return x.reply_type; }
static void insertdata( struct hb_BTree * pBTree ) { PHB_ITEM data = hb_itemNew( NULL ); hb_BTreeInsert( pBTree, "fuweqgsz", hb_itemPutNL( data, 1 ) ); hb_BTreeInsert( pBTree, "sjruexrd", hb_itemPutNL( data, 2 ) ); hb_BTreeInsert( pBTree, "fvveitnz", hb_itemPutNL( data, 3 ) ); hb_BTreeInsert( pBTree, "aqgksjxe", hb_itemPutNL( data, 4 ) ); hb_BTreeInsert( pBTree, "oonrehvj", hb_itemPutNL( data, 5 ) ); hb_BTreeInsert( pBTree, "gvowjwtr", hb_itemPutNL( data, 6 ) ); hb_BTreeInsert( pBTree, "xxidwtvn", hb_itemPutNL( data, 7 ) ); hb_BTreeInsert( pBTree, "rwjbxesd", hb_itemPutNL( data, 8 ) ); hb_BTreeInsert( pBTree, "yaznsaek", hb_itemPutNL( data, 9 ) ); hb_BTreeInsert( pBTree, "wbdhfkfy", hb_itemPutNL( data, 10 ) ); hb_BTreeInsert( pBTree, "lryaezia", hb_itemPutNL( data, 11 ) ); hb_BTreeInsert( pBTree, "tspmnrvk", hb_itemPutNL( data, 12 ) ); hb_BTreeInsert( pBTree, "hpxryhdj", hb_itemPutNL( data, 13 ) ); hb_BTreeInsert( pBTree, "sztcqaby", hb_itemPutNL( data, 14 ) ); hb_BTreeInsert( pBTree, "fcyzsqja", hb_itemPutNL( data, 15 ) ); hb_BTreeInsert( pBTree, "uccxumvg", hb_itemPutNL( data, 16 ) ); hb_BTreeInsert( pBTree, "amwuoout", hb_itemPutNL( data, 17 ) ); hb_BTreeInsert( pBTree, "yaytseln", hb_itemPutNL( data, 18 ) ); hb_BTreeInsert( pBTree, "sfiiozej", hb_itemPutNL( data, 19 ) ); hb_BTreeInsert( pBTree, "xuvsoljy", hb_itemPutNL( data, 20 ) ); hb_BTreeInsert( pBTree, "qmqjbedm", hb_itemPutNL( data, 21 ) ); hb_BTreeInsert( pBTree, "cctzzrkz", hb_itemPutNL( data, 22 ) ); hb_BTreeInsert( pBTree, "ikytgdon", hb_itemPutNL( data, 23 ) ); hb_BTreeInsert( pBTree, "pksobcwu", hb_itemPutNL( data, 24 ) ); hb_BTreeInsert( pBTree, "vmurindj", hb_itemPutNL( data, 25 ) ); hb_BTreeInsert( pBTree, "elvybqwg", hb_itemPutNL( data, 26 ) ); hb_BTreeInsert( pBTree, "ixchaztx", hb_itemPutNL( data, 27 ) ); hb_BTreeInsert( pBTree, "nzpztlhd", hb_itemPutNL( data, 28 ) ); hb_BTreeInsert( pBTree, "aucrchiw", hb_itemPutNL( data, 29 ) ); hb_BTreeInsert( pBTree, "munrytse", hb_itemPutNL( data, 30 ) ); hb_BTreeInsert( pBTree, "kqkhcmls", hb_itemPutNL( data, 31 ) ); hb_BTreeInsert( pBTree, "abqhurbi", hb_itemPutNL( data, 32 ) ); hb_BTreeInsert( pBTree, "ymrldckr", hb_itemPutNL( data, 33 ) ); hb_BTreeInsert( pBTree, "rhsmfflc", hb_itemPutNL( data, 34 ) ); hb_BTreeInsert( pBTree, "apyfkvee", hb_itemPutNL( data, 35 ) ); hb_BTreeInsert( pBTree, "cdntyzrf", hb_itemPutNL( data, 36 ) ); hb_BTreeInsert( pBTree, "iacblqrh", hb_itemPutNL( data, 37 ) ); hb_BTreeInsert( pBTree, "xvewqana", hb_itemPutNL( data, 38 ) ); hb_BTreeInsert( pBTree, "xmybqytj", hb_itemPutNL( data, 39 ) ); hb_BTreeInsert( pBTree, "dnowympf", hb_itemPutNL( data, 40 ) ); hb_BTreeInsert( pBTree, "smloihft", hb_itemPutNL( data, 41 ) ); hb_BTreeInsert( pBTree, "zumppmis", hb_itemPutNL( data, 42 ) ); hb_BTreeInsert( pBTree, "jirucnxu", hb_itemPutNL( data, 43 ) ); hb_BTreeInsert( pBTree, "ecdzikcv", hb_itemPutNL( data, 44 ) ); hb_BTreeInsert( pBTree, "slbwvnpg", hb_itemPutNL( data, 45 ) ); hb_BTreeInsert( pBTree, "yaftlkmz", hb_itemPutNL( data, 46 ) ); hb_BTreeInsert( pBTree, "blcepksd", hb_itemPutNL( data, 47 ) ); hb_BTreeInsert( pBTree, "xufowlpl", hb_itemPutNL( data, 48 ) ); hb_BTreeInsert( pBTree, "xegtjtqc", hb_itemPutNL( data, 49 ) ); hb_BTreeInsert( pBTree, "yplcqumq", hb_itemPutNL( data, 50 ) ); hb_BTreeInsert( pBTree, "vdoycauz", hb_itemPutNL( data, 51 ) ); hb_BTreeInsert( pBTree, "uhqkjuph", hb_itemPutNL( data, 52 ) ); hb_BTreeInsert( pBTree, "prllaeyi", hb_itemPutNL( data, 53 ) ); hb_BTreeInsert( pBTree, "ybzgmwzm", hb_itemPutNL( data, 54 ) ); hb_BTreeInsert( pBTree, "kkvyllnp", hb_itemPutNL( data, 55 ) ); hb_BTreeInsert( pBTree, "nberwsrb", hb_itemPutNL( data, 56 ) ); hb_BTreeInsert( pBTree, "wgetahua", hb_itemPutNL( data, 57 ) ); hb_BTreeInsert( pBTree, "yxcyehcv", hb_itemPutNL( data, 58 ) ); hb_BTreeInsert( pBTree, "oacormks", hb_itemPutNL( data, 59 ) ); hb_BTreeInsert( pBTree, "mcadkdxo", hb_itemPutNL( data, 60 ) ); hb_BTreeInsert( pBTree, "ycsalwqw", hb_itemPutNL( data, 61 ) ); hb_BTreeInsert( pBTree, "qmpysvjl", hb_itemPutNL( data, 62 ) ); hb_BTreeInsert( pBTree, "iqikamew", hb_itemPutNL( data, 63 ) ); hb_BTreeInsert( pBTree, "iaparrva", hb_itemPutNL( data, 64 ) ); hb_BTreeInsert( pBTree, "casbvtay", hb_itemPutNL( data, 65 ) ); hb_BTreeInsert( pBTree, "blaksexr", hb_itemPutNL( data, 66 ) ); hb_BTreeInsert( pBTree, "tbosrbql", hb_itemPutNL( data, 67 ) ); hb_BTreeInsert( pBTree, "ifkywsyt", hb_itemPutNL( data, 68 ) ); hb_BTreeInsert( pBTree, "gvklwevy", hb_itemPutNL( data, 69 ) ); hb_BTreeInsert( pBTree, "krpmpbud", hb_itemPutNL( data, 70 ) ); hb_BTreeInsert( pBTree, "rdvlwbwm", hb_itemPutNL( data, 71 ) ); hb_BTreeInsert( pBTree, "apnvdkww", hb_itemPutNL( data, 72 ) ); hb_BTreeInsert( pBTree, "euqdocvm", hb_itemPutNL( data, 73 ) ); hb_BTreeInsert( pBTree, "ksmkjcwp", hb_itemPutNL( data, 74 ) ); hb_BTreeInsert( pBTree, "bztgclzc", hb_itemPutNL( data, 75 ) ); hb_BTreeInsert( pBTree, "awkdnuxa", hb_itemPutNL( data, 76 ) ); hb_BTreeInsert( pBTree, "abavnpod", hb_itemPutNL( data, 77 ) ); hb_BTreeInsert( pBTree, "dvwvhjmh", hb_itemPutNL( data, 78 ) ); hb_BTreeInsert( pBTree, "dmfmivqb", hb_itemPutNL( data, 79 ) ); hb_BTreeInsert( pBTree, "ewsxanon", hb_itemPutNL( data, 80 ) ); hb_itemRelease( data ); }
static HB_ERRCODE odbcOpen( SQLBASEAREAP pArea ) { SDDCONN * pSDDConn = ( SDDCONN * ) pArea->pConnection->pSDDConn; SDDDATA * pSDDData; O_HB_CHAR * pchQuery; SQLHSTMT hStmt; SQLSMALLINT iNameLen; PHB_ITEM pItemEof, pItem; HB_BOOL bError; HB_USHORT uiFields, uiIndex; HB_ERRCODE errCode; char * szError; SQLRETURN result; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; #if ODBCVER >= 0x0300 if( ! SQL_SUCCEEDED( SQLAllocHandle( SQL_HANDLE_STMT, pSDDConn->hConn, &hStmt ) ) ) #else if( ! SQL_SUCCEEDED( SQLAllocStmt( pSDDConn->hConn, &hStmt ) ) ) #endif { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, SQL_NULL_HSTMT, &errCode ); hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTALLOC, szError, pArea->szQuery, errCode ); hb_xfree( szError ); return HB_FAILURE; } pchQuery = O_HB_CHARDUP( pArea->szQuery ); result = SQLExecDirect( hStmt, ( SQLTCHAR * ) HB_UNCONST( pchQuery ), ( SQLINTEGER ) O_HB_STRLEN( pchQuery ) ); hb_xfree( pchQuery ); if( ! SQL_SUCCEEDED( result ) ) { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode ); #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); #else SQLFreeStmt( hStmt, SQL_DROP ); #endif hb_errRT_ODBCDD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); hb_xfree( szError ); return HB_FAILURE; } if( ! SQL_SUCCEEDED( SQLNumResultCols( hStmt, &iNameLen ) ) ) { szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, &errCode ); #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); #else SQLFreeStmt( hStmt, SQL_DROP ); #endif hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1000, szError, pArea->szQuery, errCode ); hb_xfree( szError ); return HB_FAILURE; } uiFields = ( HB_USHORT ) iNameLen; SELF_SETFIELDEXTENT( &pArea->area, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); pItem = hb_itemNew( NULL ); #if 0 HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) ); #endif errCode = 0; bError = HB_FALSE; for( uiIndex = 0; uiIndex < uiFields; uiIndex++ ) { DBFIELDINFO dbFieldInfo; char * pszName; SQLTCHAR cName[ 256 ]; SQLULEN uiSize; SQLSMALLINT iDataType, iDec, iNull; if( ! SQL_SUCCEEDED( SQLDescribeCol( hStmt, ( SQLSMALLINT ) uiIndex + 1, cName, HB_SIZEOFARRAY( cName ), &iNameLen, &iDataType, &uiSize, &iDec, &iNull ) ) ) { hb_itemRelease( pItemEof ); hb_itemRelease( pItem ); szError = odbcGetError( pSDDConn->hEnv, pSDDConn->hConn, hStmt, NULL ); #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); #else SQLFreeStmt( hStmt, SQL_DROP ); #endif hb_errRT_ODBCDD( EG_OPEN, ESQLDD_STMTDESCR + 1001, szError, pArea->szQuery, 0 ); hb_xfree( szError ); return HB_FAILURE; } memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) ); dbFieldInfo.atomName = pszName = O_HB_OSSTRDUP( ( O_HB_CHAR * ) cName ); /* We do mapping of many SQL types to one Harbour field type here, so, we need store real SQL type in uiTypeExtended. SQL types are signed, so, HB_USHORT type casting is a little hackish. We need to remember use this casting also in expressions like this: if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT ) or introduce our own unsigned SQL types. [Mindaugas] */ dbFieldInfo.uiTypeExtended = ( HB_USHORT ) iDataType; dbFieldInfo.uiLen = ( HB_USHORT ) uiSize; dbFieldInfo.uiDec = iDec; if( iNull == SQL_NULLABLE ) dbFieldInfo.uiFlags |= HB_FF_NULLABLE; #if 0 HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d null=%d", dbFieldInfo.atomName, iDataType, uiSize, iDec, iNull ) ); #endif switch( iDataType ) { case SQL_CHAR: case SQL_VARCHAR: case SQL_LONGVARCHAR: dbFieldInfo.uiType = HB_FT_STRING; break; case SQL_WCHAR: case SQL_WVARCHAR: case SQL_WLONGVARCHAR: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiFlags |= HB_FF_UNICODE; break; case SQL_BINARY: case SQL_VARBINARY: case SQL_LONGVARBINARY: dbFieldInfo.uiType = HB_FT_STRING; dbFieldInfo.uiFlags |= HB_FF_BINARY; break; case SQL_TINYINT: case SQL_SMALLINT: case SQL_INTEGER: case SQL_BIGINT: dbFieldInfo.uiType = HB_FT_INTEGER; break; case SQL_DECIMAL: case SQL_NUMERIC: dbFieldInfo.uiType = HB_FT_LONG; break; case SQL_REAL: case SQL_FLOAT: case SQL_DOUBLE: dbFieldInfo.uiType = HB_FT_DOUBLE; break; case SQL_BIT: dbFieldInfo.uiType = HB_FT_LOGICAL; break; case SQL_DATE: #if ODBCVER >= 0x0300 case SQL_TYPE_DATE: #endif dbFieldInfo.uiType = HB_FT_DATE; break; case SQL_TIME: #if ODBCVER >= 0x0300 case SQL_TYPE_TIME: #endif dbFieldInfo.uiType = HB_FT_TIME; break; /* SQL_DATETIME = SQL_DATE = 9 */ case SQL_TIMESTAMP: #if ODBCVER >= 0x0300 case SQL_TYPE_TIMESTAMP: #endif dbFieldInfo.uiType = HB_FT_TIMESTAMP; break; default: #if 0 HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) ); #endif bError = HB_TRUE; errCode = ( HB_ERRCODE ) iDataType; break; } if( ! bError ) { switch( dbFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr; pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 ); memset( pStr, ' ', dbFieldInfo.uiLen ); pStr[ dbFieldInfo.uiLen ] = '\0'; hb_itemPutCL( pItem, pStr, dbFieldInfo.uiLen ); hb_xfree( pStr ); break; } case HB_FT_MEMO: hb_itemPutC( pItem, NULL ); break; case HB_FT_INTEGER: hb_itemPutNI( pItem, 0 ); break; case HB_FT_LONG: if( dbFieldInfo.uiDec == 0 ) hb_itemPutNLLen( pItem, 0, dbFieldInfo.uiLen ); else hb_itemPutNDLen( pItem, 0.0, dbFieldInfo.uiLen, dbFieldInfo.uiDec ); break; case HB_FT_DOUBLE: hb_itemPutNDLen( pItem, 0.0, dbFieldInfo.uiLen, dbFieldInfo.uiDec ); break; case HB_FT_LOGICAL: hb_itemPutL( pItem, HB_FALSE ); break; case HB_FT_DATE: hb_itemPutDL( pItem, 0 ); break; case HB_FT_TIME: hb_itemPutTDT( pItem, 0, 0 ); break; case HB_FT_TIMESTAMP: hb_itemPutTDT( pItem, 0, 0 ); break; default: hb_itemClear( pItem ); bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiIndex + 1, pItem ); if( ! bError ) bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE ); hb_xfree( pszName ); } if( bError ) break; } hb_itemRelease( pItem ); if( bError ) { hb_itemRelease( pItemEof ); #if ODBCVER >= 0x0300 SQLFreeHandle( SQL_HANDLE_STMT, hStmt ); #else SQLFreeStmt( hStmt, SQL_DROP ); #endif hb_errRT_ODBCDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); return HB_FAILURE; } pArea->ulRecCount = 0; pArea->ulRecMax = SQLDD_ROWSET_INIT; pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pSDDData->hStmt = hStmt; return HB_SUCCESS; }
static void s_signalHandler( int sig, siginfo_t * info, void * v ) #endif { HB_UINT uiSig; HB_SIZE nPos; #if ! ( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) ) HB_SYMBOL_UNUSED( v ); #endif /* let's find the right signal handler. */ hb_threadEnterCriticalSectionGC( &s_ServiceMutex ); /* avoid working if PRG signal handling has been disabled */ if( ! s_bSignalEnabled ) { hb_threadLeaveCriticalSection( &s_ServiceMutex ); return; } s_bSignalEnabled = HB_FALSE; nPos = hb_arrayLen( s_pHooks ); /* subsig not necessary */ uiSig = ( HB_UINT ) s_translateSignal( ( HB_UINT ) sig, 0 ); while( nPos > 0 ) { PHB_ITEM pFunction; HB_UINT uiMask; pFunction = hb_arrayGetItemPtr( s_pHooks, nPos ); uiMask = ( HB_UINT ) hb_arrayGetNI( pFunction, 1 ); if( uiMask & uiSig ) { PHB_ITEM pExecArray, pRet; int iRet; /* we don't unlock the mutex now, even if it is a little dangerous. But we are in a signal hander... for now just 2 parameters */ pExecArray = hb_itemArrayNew( 3 ); hb_arraySet( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) ); hb_arraySetNI( pExecArray, 2, uiSig ); /* the third parameter is an array: */ pRet = hb_arrayGetItemPtr( pExecArray, 3 ); #if defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) hb_arrayNew( pRet, 1 ); #elif defined( HB_OS_BSD ) hb_arrayNew( pRet, info ? 6 : 1 ); #else hb_arrayNew( pRet, 6 ); #endif hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, sig ); #if ! ( defined( HB_OS_OS2_GCC ) || defined( __WATCOMC__ ) ) #if defined( HB_OS_BSD ) if( info ) #endif { hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, info->si_code ); #if ! defined( HB_OS_VXWORKS ) hb_arraySetNI( pRet, HB_SERVICE_OSERROR, info->si_errno ); hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, ( void * ) info->si_addr ); hb_arraySetNI( pRet, HB_SERVICE_PROCESS, info->si_pid ); hb_arraySetNI( pRet, HB_SERVICE_UID, info->si_uid ); #endif } #endif pRet = hb_itemDo( pExecArray, 0 ); iRet = hb_itemGetNI( pRet ); hb_itemRelease( pRet ); hb_itemRelease( pExecArray ); switch( iRet ) { case HB_SERVICE_HANDLED: s_bSignalEnabled = HB_TRUE; hb_threadLeaveCriticalSection( &s_ServiceMutex ); return; case HB_SERVICE_QUIT: s_bSignalEnabled = HB_FALSE; hb_threadLeaveCriticalSection( &s_ServiceMutex ); /* TODO: A service cleanup routine */ hb_vmRequestQuit(); /* Allow signals to go through pthreads */ s_serviceSetDflSig(); /* NOTICE: should be pthread_exit(0), but a bug in Linux threading prevents it: calling pthread exit from a signal handler will cause infinite wait for restart signal. This solution is rude, while the other would allow clean VM termination... but it works. */ exit( 0 ); } } nPos--; } s_bSignalEnabled = HB_TRUE; #if 0 s_serviceSetHBSig(); #endif #if 0 if( uiSig != HB_SIGNAL_UNKNOWN ) { if( s_aOldAction[ sig ].sa_flags & SA_SIGINFO ) s_aOldAction[ sig ].sa_sigaction( sig, info, v ); else s_aOldAction[ sig ].sa_handler( sig ); } #endif }
static HB_ERRCODE odbcGoTo( SQLBASEAREAP pArea, HB_ULONG ulRecNo ) { SQLHSTMT hStmt; SQLRETURN res; SQLLEN iLen; PHB_ITEM pArray, pItem; LPFIELD pField; HB_USHORT ui; /* No pArea->pSDDData for DBCreate() area... * though pArea->fFetched == HB_TRUE for them */ hStmt = pArea->pSDDData ? ( ( SDDDATA * ) pArea->pSDDData )->hStmt : NULL; while( ulRecNo > pArea->ulRecCount && ! pArea->fFetched ) { if( ! SQL_SUCCEEDED( SQLFetch( hStmt ) ) ) { pArea->fFetched = HB_TRUE; break; } pArray = hb_itemArrayNew( pArea->area.uiFieldCount ); pItem = NULL; for( ui = 1; ui <= pArea->area.uiFieldCount; ui++ ) { iLen = SQL_NULL_DATA; res = 0; pField = pArea->area.lpFields + ui - 1; switch( pField->uiType ) { case HB_FT_STRING: if( pField->uiType & HB_FF_BINARY ) { char buffer[ 1 ]; iLen = 0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, buffer, 0, &iLen ) ) ) { if( iLen >= 0 ) { char * val = ( char * ) hb_xgrab( iLen + 1 ); if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BINARY, val, iLen + 1, &iLen ) ) ) pItem = hb_itemPutCLPtr( pItem, val, ( HB_SIZE ) iLen ); else hb_xfree( val ); } } } else { O_HB_CHAR buffer[ 1 ]; #if defined( UNICODE ) SQLSMALLINT iTargetType = SQL_C_WCHAR; #else SQLSMALLINT iTargetType = SQL_C_CHAR; #endif iLen = 0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, buffer, 0, &iLen ) ) ) { if( iLen >= 0 ) { O_HB_CHAR * val = ( O_HB_CHAR * ) hb_xgrab( iLen + sizeof( O_HB_CHAR ) ); if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, iTargetType, val, iLen + sizeof( O_HB_CHAR ), &iLen ) ) ) { #if defined( UNICODE ) iLen >>= 1; #endif pItem = O_HB_ITEMPUTSTRLEN( pItem, val, ( HB_SIZE ) iLen ); } hb_xfree( val ); } } } break; case HB_FT_INTEGER: #if ODBCVER >= 0x0300 if( pField->uiTypeExtended == ( HB_USHORT ) SQL_BIGINT ) { HB_I64 val = 0; /* NOTE: SQL_C_SBIGINT not available before ODBC 3.0 */ if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_SBIGINT, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutNIntLen( pItem, val, pField->uiLen ); } else #endif { SQLINTEGER val = 0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutNLLen( pItem, val, pField->uiLen ); } break; case HB_FT_LONG: if( pField->uiDec == 0 && pField->uiLen < 10 ) { SQLINTEGER val = 0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_LONG, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutNLLen( pItem, val, pField->uiLen ); } else { double val = 0.0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec ); } break; case HB_FT_DOUBLE: { double val = 0.0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DOUBLE, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutNDLen( pItem, val, pField->uiLen, pField->uiDec ); break; } case HB_FT_LOGICAL: { unsigned char val = 0; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_BIT, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutL( pItem, val != 0 ); break; } case HB_FT_DATE: { DATE_STRUCT val = { 0, 0, 0 }; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_DATE, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutD( pItem, val.year, val.month, val.day ); break; } case HB_FT_TIME: { TIME_STRUCT val = { 0, 0, 0 }; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIME, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutTDT( pItem, 0, hb_timeEncode( val.hour, val.minute, val.second, 0 ) ); break; } case HB_FT_TIMESTAMP: { TIMESTAMP_STRUCT val = { 0, 0, 0, 0, 0, 0, 0 }; if( SQL_SUCCEEDED( res = SQLGetData( hStmt, ui, SQL_C_TIMESTAMP, &val, sizeof( val ), &iLen ) ) ) pItem = hb_itemPutTDT( pItem, hb_dateEncode( val.year, val.month, val.day ), hb_timeEncode( val.hour, val.minute, val.second, val.fraction / 1000000 ) ); break; } } /* TODO: check SQL_SUCCEEDED( res ) */ /* TODO: check for SQL_NO_TOTAL. What does this mean? */ HB_SYMBOL_UNUSED( res ); if( pItem ) { /* NULL -> NIL */ if( iLen == SQL_NULL_DATA ) hb_itemClear( pItem ); else hb_arraySetForward( pArray, ui, pItem ); } } if( pItem ) hb_itemRelease( pItem ); if( pArea->ulRecCount + 1 >= pArea->ulRecMax ) { pArea->pRow = ( void ** ) hb_xrealloc( pArea->pRow, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xrealloc( pArea->pRowFlags, ( pArea->ulRecMax + SQLDD_ROWSET_RESIZE ) * sizeof( HB_BYTE ) ); pArea->ulRecMax += SQLDD_ROWSET_RESIZE; } pArea->ulRecCount++; pArea->pRow[ pArea->ulRecCount ] = pArray; pArea->pRowFlags[ pArea->ulRecCount ] = SQLDD_FLAG_CACHED; }
/* Manager of signals for windows */ static LONG s_signalHandler( int type, int sig, PEXCEPTION_RECORD exc ) { HB_SIZE nPos; HB_UINT uiSig; /* let's find the right signal handler. */ hb_threadEnterCriticalSectionGC( &s_ServiceMutex ); /* avoid working if PRG signal handling has been disabled */ if( ! s_bSignalEnabled ) { hb_threadLeaveCriticalSection( &s_ServiceMutex ); return EXCEPTION_EXECUTE_HANDLER; } s_bSignalEnabled = HB_FALSE; nPos = hb_arrayLen( s_pHooks ); /* subsig not necessary */ uiSig = ( HB_UINT ) s_translateSignal( ( HB_UINT ) type, ( HB_UINT ) sig ); while( nPos > 0 ) { PHB_ITEM pFunction; HB_UINT uiMask; pFunction = hb_arrayGetItemPtr( s_pHooks, nPos ); uiMask = ( HB_UINT ) hb_arrayGetNI( pFunction, 1 ); if( ( uiMask & uiSig ) == uiSig ) { PHB_ITEM pExecArray, pRet; int iRet; /* we don't unlock the mutex now, even if it is a little dangerous. But we are in a signal hander... for now just 2 parameters */ pExecArray = hb_itemArrayNew( 3 ); hb_arraySetForward( pExecArray, 1, hb_arrayGetItemPtr( pFunction, 2 ) ); hb_arraySetNI( pExecArray, 2, uiSig ); /* the third parameter is an array: * 1: low-level signal * 2: low-level subsignal * 3: low-level system error * 4: address that rose the signal * 5: process id of the signal riser * 6: UID of the riser */ pRet = hb_arrayGetItemPtr( pExecArray, 3 ); hb_arrayNew( pRet, 6 ); hb_arraySetNI( pRet, HB_SERVICE_OSSIGNAL, type ); hb_arraySetNI( pRet, HB_SERVICE_OSSUBSIG, sig ); /* could be meaningless, but does not matter here */ hb_arraySetNI( pRet, HB_SERVICE_OSERROR, GetLastError() ); if( type == 0 ) /* exception */ hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, ( void * ) exc->ExceptionAddress ); else hb_arraySetPtr( pRet, HB_SERVICE_ADDRESS, NULL ); /* TODO: */ hb_arraySetNI( pRet, HB_SERVICE_PROCESS, GetCurrentThreadId() ); /* TODO: */ hb_arraySetNI( pRet, HB_SERVICE_UID, 0 ); pRet = hb_itemDo( pExecArray, 0 ); iRet = hb_itemGetNI( pRet ); hb_itemRelease( pRet ); hb_itemRelease( pExecArray ); switch( iRet ) { case HB_SERVICE_HANDLED: s_bSignalEnabled = HB_TRUE; hb_threadLeaveCriticalSection( &s_ServiceMutex ); return EXCEPTION_CONTINUE_EXECUTION; case HB_SERVICE_QUIT: s_bSignalEnabled = HB_FALSE; hb_threadLeaveCriticalSection( &s_ServiceMutex ); hb_vmRequestQuit(); #ifndef HB_THREAD_SUPPORT hb_vmQuit(); exit( 0 ); #else hb_threadCancelInternal(); #endif } } nPos--; } s_bSignalEnabled = HB_TRUE; return EXCEPTION_EXECUTE_HANDLER; }
static HB_BOOL hb_copyfile( const char * szSource, const char * szDest, PHB_ITEM pBlock ) { HB_BOOL bRetVal = HB_FALSE; HB_FHANDLE fhndSource; HB_TRACE( HB_TR_DEBUG, ( "hb_copyfile(%s, %s)", szSource, szDest ) ); while( ( fhndSource = hb_spOpen( szSource, FO_READ | FO_SHARED | FO_PRIVATE ) ) == FS_ERROR ) { HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_OPEN, 2012, NULL, szSource, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 ); if( uiAction != E_RETRY ) break; } if( fhndSource != FS_ERROR ) { HB_FHANDLE fhndDest; while( ( fhndDest = hb_spCreate( szDest, FC_NORMAL ) ) == FS_ERROR ) { HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_CREATE, 2012, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 ); if( uiAction != E_RETRY ) break; } if( fhndDest != FS_ERROR ) { #if defined( HB_OS_UNIX ) struct stat struFileInfo; int iSuccess = fstat( fhndSource, &struFileInfo ); #endif HB_BYTE * buffer = ( HB_BYTE * ) hb_xgrab( BUFFER_SIZE ); HB_SIZE nRead; bRetVal = HB_TRUE; if( hb_itemType( pBlock ) != HB_IT_BLOCK ) pBlock = NULL; while( ( nRead = hb_fsReadLarge( fhndSource, buffer, BUFFER_SIZE ) ) != 0 ) { while( hb_fsWriteLarge( fhndDest, buffer, nRead ) != nRead ) { HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_WRITE, 2016, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 ); if( uiAction != E_RETRY ) { bRetVal = HB_FALSE; break; } } if( pBlock ) { PHB_ITEM pCnt = hb_itemPutNS( NULL, nRead ); hb_vmEvalBlockV( pBlock, 1, pCnt ); hb_itemRelease( pCnt ); } } hb_xfree( buffer ); #if defined( HB_OS_UNIX ) if( iSuccess == 0 ) fchmod( fhndDest, struFileInfo.st_mode ); #endif hb_fsClose( fhndDest ); } hb_fsClose( fhndSource ); } return bRetVal; }
static HB_BOOL hb_regex( int iRequest ) { #if defined( HB_HAS_PCRE2 ) HB_REGMATCH * aMatches; #else HB_REGMATCH aMatches[ HB_REGMATCH_SIZE( REGEX_MAX_GROUPS ) ]; #endif PHB_ITEM pRetArray, pString; int iMatches, iMaxMatch; HB_BOOL fResult = HB_FALSE; PHB_REGEX pRegEx; const char * pszString; HB_SIZE nLen; pString = hb_param( 2, HB_IT_STRING ); if( ! pString ) { hb_errRT_BASE_SubstR( EG_ARG, 3014, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); return HB_FALSE; } pRegEx = hb_regexGet( hb_param( 1, HB_IT_ANY ), ( ! hb_parldef( 3, HB_TRUE ) ? HBREG_ICASE : 0 ) | ( hb_parl( 4 ) ? HBREG_NEWLINE : 0 ) ); if( ! pRegEx ) return HB_FALSE; #if defined( HB_HAS_PCRE2 ) aMatches = pRegEx->re_match_data = pcre2_match_data_create( REGEX_MAX_GROUPS, NULL ); #endif pszString = hb_itemGetCPtr( pString ); nLen = hb_itemGetCLen( pString ); iMaxMatch = iRequest == 0 || iRequest == 4 || iRequest == 5 ? REGEX_MAX_GROUPS : 1; iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches ); if( iMatches > 0 ) { PHB_ITEM pMatch; int i; switch( iRequest ) { case 0: pRetArray = hb_itemArrayNew( iMatches ); for( i = 0; i < iMatches; i++ ) { if( HB_REGMATCH_EO( aMatches, i ) != HB_REGMATCH_UNSET ) hb_arraySetCL( pRetArray, i + 1, pszString + HB_REGMATCH_SO( aMatches, i ), HB_REGMATCH_EO( aMatches, i ) - HB_REGMATCH_SO( aMatches, i ) ); else hb_arraySetCL( pRetArray, i + 1, NULL, 0 ); } hb_itemReturnRelease( pRetArray ); fResult = HB_TRUE; break; case 1: /* LIKE */ fResult = HB_REGMATCH_SO( aMatches, 0 ) == 0 && ( HB_SIZE ) HB_REGMATCH_EO( aMatches, 0 ) == nLen; break; case 2: /* HAS */ fResult = HB_TRUE; break; case 3: /* SPLIT */ iMaxMatch = hb_parni( 5 ); pRetArray = hb_itemArrayNew( 0 ); pMatch = hb_itemNew( NULL ); iMatches = 0; do { hb_itemPutCL( pMatch, pszString, HB_REGMATCH_SO( aMatches, 0 ) ); hb_arrayAddForward( pRetArray, pMatch ); nLen -= HB_REGMATCH_EO( aMatches, 0 ); pszString += HB_REGMATCH_EO( aMatches, 0 ); iMatches++; } while( HB_REGMATCH_EO( aMatches, 0 ) > 0 && nLen && ( iMaxMatch == 0 || iMatches < iMaxMatch ) && hb_regexec( pRegEx, pszString, nLen, 1, aMatches ) > 0 ); /* last match must be done also in case that pszString is empty; this would mean an empty split field at the end of the string */ /* if( nLen ) */ { hb_itemPutCL( pMatch, pszString, nLen ); hb_arrayAddForward( pRetArray, pMatch ); } hb_itemRelease( pMatch ); hb_itemReturnRelease( pRetArray ); fResult = HB_TRUE; break; case 4: /* results AND positions */ pRetArray = hb_itemArrayNew( iMatches ); for( i = 0; i < iMatches; i++ ) { int iSO = HB_REGMATCH_SO( aMatches, i ), iEO = HB_REGMATCH_EO( aMatches, i ); pMatch = hb_arrayGetItemPtr( pRetArray, i + 1 ); hb_arrayNew( pMatch, 3 ); if( iEO != ( int ) HB_REGMATCH_UNSET ) { /* matched string */ hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO ); /* begin of match */ hb_arraySetNS( pMatch, 2, iSO + 1 ); /* End of match */ hb_arraySetNS( pMatch, 3, iEO ); } else { hb_arraySetCL( pMatch, 1, NULL, 0 ); hb_arraySetNS( pMatch, 2, 0 ); hb_arraySetNS( pMatch, 3, 0 ); } } hb_itemReturnRelease( pRetArray ); fResult = HB_TRUE; break; case 5: /* _ALL_ results AND positions */ { PHB_ITEM pAtxArray; int iMax = hb_parni( 5 ); /* max nuber of matches I want, 0 = unlimited */ int iGetMatch = hb_parni( 6 ); /* Gets if want only one single match or a sub-match */ HB_BOOL fOnlyMatch = hb_parldef( 7, HB_TRUE ); /* if HB_TRUE returns only matches and sub-matches, not positions */ HB_SIZE nOffset = 0; int iCount = 0; int iSO, iEO; /* Set new array */ pRetArray = hb_itemArrayNew( 0 ); do { /* If I want all matches */ if( iGetMatch == 0 || /* Check boundaries */ ( iGetMatch < 0 || iGetMatch > iMatches ) ) { pAtxArray = hb_itemArrayNew( iMatches ); for( i = 0; i < iMatches; i++ ) { iSO = HB_REGMATCH_SO( aMatches, i ); iEO = HB_REGMATCH_EO( aMatches, i ); pMatch = hb_arrayGetItemPtr( pAtxArray, i + 1 ); if( ! fOnlyMatch ) { hb_arrayNew( pMatch, 3 ); if( iEO != ( int ) HB_REGMATCH_UNSET ) { /* matched string */ hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO ); /* begin of match */ hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 ); /* End of match */ hb_arraySetNS( pMatch, 3, nOffset + iEO ); } else { hb_arraySetCL( pMatch, 1, NULL, 0 ); hb_arraySetNS( pMatch, 2, 0 ); hb_arraySetNS( pMatch, 3, 0 ); } } else { if( iEO != ( int ) HB_REGMATCH_UNSET ) /* matched string */ hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO ); else hb_itemPutC( pMatch, NULL ); } } hb_arrayAddForward( pRetArray, pAtxArray ); hb_itemRelease( pAtxArray ); } else /* Here I get only single matches */ { i = iGetMatch - 1; iSO = HB_REGMATCH_SO( aMatches, i ); iEO = HB_REGMATCH_EO( aMatches, i ); pMatch = hb_itemNew( NULL ); if( ! fOnlyMatch ) { hb_arrayNew( pMatch, 3 ); if( iEO != ( int ) HB_REGMATCH_UNSET ) { /* matched string */ hb_arraySetCL( pMatch, 1, pszString + iSO, iEO - iSO ); /* begin of match */ hb_arraySetNS( pMatch, 2, nOffset + iSO + 1 ); /* End of match */ hb_arraySetNS( pMatch, 3, nOffset + iEO ); } else { hb_arraySetCL( pMatch, 1, NULL, 0 ); hb_arraySetNS( pMatch, 2, 0 ); hb_arraySetNS( pMatch, 3, 0 ); } } else { if( iEO != ( int ) HB_REGMATCH_UNSET ) /* matched string */ hb_itemPutCL( pMatch, pszString + iSO, iEO - iSO ); else hb_itemPutC( pMatch, NULL ); } hb_arrayAddForward( pRetArray, pMatch ); hb_itemRelease( pMatch ); } iEO = HB_REGMATCH_EO( aMatches, 0 ); if( iEO == ( int ) HB_REGMATCH_UNSET ) break; nLen -= iEO; pszString += iEO; nOffset += iEO; iCount++; } while( iEO && nLen && ( iMax == 0 || iCount < iMax ) && ( iMatches = hb_regexec( pRegEx, pszString, nLen, iMaxMatch, aMatches ) ) > 0 ); hb_itemReturnRelease( pRetArray ); fResult = HB_TRUE; break; } } } else if( iRequest == 3 ) { pRetArray = hb_itemArrayNew( 1 ); hb_arraySet( pRetArray, 1, pString ); hb_itemReturnRelease( pRetArray ); fResult = HB_TRUE; } hb_regexFree( pRegEx ); return fResult; }
/* * Open a data store in the WorkArea. */ static HB_ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo ) { PHB_ITEM pError = NULL; PHB_FNAME pFileName; HB_ERRCODE errCode; HB_USHORT uiFlags; HB_BOOL fRetry; char szFileName[ HB_PATH_MAX ]; char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ]; HB_TRACE( HB_TR_DEBUG, ( "hb_sdfOpen(%p,%p)", pArea, pOpenInfo ) ); pArea->fShared = HB_TRUE; /* pOpenInfo->fShared; */ pArea->fReadonly = HB_TRUE; /* pOpenInfo->fReadonly; */ if( pOpenInfo->cdpId ) { pArea->area.cdPage = hb_cdpFindExt( pOpenInfo->cdpId ); if( ! pArea->area.cdPage ) pArea->area.cdPage = hb_vmCDP(); } else pArea->area.cdPage = hb_vmCDP(); uiFlags = ( pArea->fReadonly ? FO_READ : FO_READWRITE ) | ( pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE ); pFileName = hb_fsFNameSplit( pOpenInfo->abName ); /* Add default file name extension if necessary */ if( hb_setGetDefExtension() && ! pFileName->szExtension ) { PHB_ITEM pFileExt = hb_itemPutC( NULL, NULL ); SELF_INFO( &pArea->area, DBI_TABLEEXT, pFileExt ); pFileName->szExtension = hb_itemGetCPtr( pFileExt ); hb_fsFNameMerge( szFileName, pFileName ); hb_itemRelease( pFileExt ); } else { hb_strncpy( szFileName, pOpenInfo->abName, sizeof( szFileName ) - 1 ); } /* Create default alias if necessary */ if( ! pOpenInfo->atomAlias && pFileName->szName ) { const char * szName = strrchr( pFileName->szName, ':' ); if( szName == NULL ) szName = pFileName->szName; else ++szName; hb_strncpyUpperTrim( szAlias, szName, sizeof( szAlias ) - 1 ); pOpenInfo->atomAlias = szAlias; } hb_xfree( pFileName ); /* Try open */ do { pArea->pFile = hb_fileExtOpen( szFileName, NULL, uiFlags | FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME | FXO_NOSEEKPOS, NULL, pError ); if( ! pArea->pFile ) { if( ! pError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_OPEN ); hb_errPutSubCode( pError, EDBF_OPEN_DBF ); hb_errPutOsCode( pError, hb_fsError() ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) ); hb_errPutFileName( pError, szFileName ); hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT ); } fRetry = ( SELF_ERROR( &pArea->area, pError ) == E_RETRY ); } else fRetry = HB_FALSE; } while( fRetry ); if( pError ) hb_itemRelease( pError ); if( ! pArea->pFile ) return HB_FAILURE; errCode = SUPER_OPEN( &pArea->area, pOpenInfo ); if( errCode != HB_SUCCESS ) { SELF_CLOSE( &pArea->area ); return HB_FAILURE; } hb_sdfInitArea( pArea, szFileName ); /* Position cursor at the first record */ return SELF_GOTOP( &pArea->area ); }
static HB_ERRCODE sqlbaseCreate( SQLBASEAREAP pArea, LPDBOPENINFO pOpenInfo ) { PHB_ITEM pItemEof, pItem; HB_USHORT uiCount; HB_BOOL bError; pArea->ulConnection = pOpenInfo->ulConnection ? pOpenInfo->ulConnection : s_ulConnectionCurrent; if( pArea->ulConnection > s_ulConnectionCount || ( pArea->ulConnection && ! s_pConnection[ pArea->ulConnection - 1 ] ) ) { hb_errRT_SQLBASE( EG_OPEN, ESQLDD_NOTCONNECTED, "Not connected", NULL ); return HB_FAILURE; } if( pArea->ulConnection ) { pArea->pConnection = s_pConnection[ pArea->ulConnection - 1 ]; pArea->pConnection->uiAreaCount++; pArea->pSDD = pArea->pConnection->pSDD; } else pArea->pSDD = &sddNull; pItemEof = hb_itemArrayNew( pArea->area.uiFieldCount ); bError = HB_FALSE; for( uiCount = 0; uiCount < pArea->area.uiFieldCount; uiCount++ ) { LPFIELD pField = pArea->area.lpFields + uiCount; switch( pField->uiType ) { case HB_FT_STRING: { char * pStr; pStr = ( char * ) hb_xgrab( pField->uiLen + 1 ); memset( pStr, ' ', pField->uiLen ); pStr[ pField->uiLen ] = '\0'; pItem = hb_itemPutCL( NULL, pStr, pField->uiLen ); hb_xfree( pStr ); break; } case HB_FT_MEMO: pItem = hb_itemPutC( NULL, NULL ); break; case HB_FT_INTEGER: if( pField->uiDec ) pItem = hb_itemPutND( NULL, 0.0 ); else pItem = hb_itemPutNI( NULL, 0 ); break; case HB_FT_LONG: if( pField->uiDec ) pItem = hb_itemPutND( NULL, 0.0 ); else pItem = hb_itemPutNL( NULL, 0 ); break; case HB_FT_FLOAT: pItem = hb_itemPutND( NULL, 0.0 ); break; case HB_FT_DOUBLE: pItem = hb_itemPutND( NULL, 0.0 ); break; case HB_FT_DATE: pItem = hb_itemPutDS( NULL, NULL ); break; case HB_FT_LOGICAL: pItem = hb_itemPutL( NULL, HB_FALSE ); break; default: pItem = hb_itemNew( NULL ); bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiCount + 1, pItem ); hb_itemRelease( pItem ); if( bError ) break; } if( bError ) { hb_itemClear( pItemEof ); hb_itemRelease( pItemEof ); hb_errRT_SQLBASE( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", NULL ); SELF_CLOSE( ( AREAP ) pArea ); return HB_FAILURE; } pArea->ulRecCount = 0; pArea->pRow = ( void ** ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xalloc( SQLDD_ROWSET_RESIZE * sizeof( HB_BYTE ) ); pArea->ulRecMax = SQLDD_ROWSET_RESIZE; *( pArea->pRow ) = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pArea->fFetched = HB_TRUE; if( SUPER_CREATE( ( AREAP ) pArea, pOpenInfo ) != HB_SUCCESS ) { SELF_CLOSE( ( AREAP ) pArea ); return HB_FAILURE; } return SELF_GOTOP( ( AREAP ) pArea ); }
/* * 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; }
static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea ) { MYSQL * pMySql = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pMySql; SDDDATA * pSDDData; PHB_ITEM pItemEof, pItem; HB_ULONG ulIndex; HB_USHORT uiFields, uiCount; HB_ERRCODE errCode = 0; HB_BOOL bError; DBFIELDINFO pFieldInfo; MYSQL_FIELD * pMyField; void ** pRow; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; if( mysql_real_query( pMySql, pArea->szQuery, ( unsigned long ) strlen( pArea->szQuery ) ) ) { hb_errRT_MySQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery, mysql_errno( pMySql ) ); return HB_FAILURE; } if( ( pSDDData->pResult = mysql_store_result( pMySql ) ) == NULL ) { hb_errRT_MySQLDD( EG_MEM, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery, mysql_errno( pMySql ) ); return HB_FAILURE; } uiFields = ( HB_USHORT ) mysql_num_fields( pSDDData->pResult ); SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); bError = HB_FALSE; for( uiCount = 0; uiCount < uiFields; uiCount++ ) { pMyField = mysql_fetch_field_direct( pSDDData->pResult, uiCount ); pFieldInfo.atomName = pMyField->name; pFieldInfo.uiLen = ( HB_USHORT ) pMyField->length; pFieldInfo.uiDec = 0; switch( pMyField->type ) { case MYSQL_TYPE_TINY: case MYSQL_TYPE_SHORT: pFieldInfo.uiType = HB_FT_INTEGER; break; case MYSQL_TYPE_LONG: case MYSQL_TYPE_LONGLONG: case MYSQL_TYPE_INT24: pFieldInfo.uiType = HB_FT_LONG; break; case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_DOUBLE: pFieldInfo.uiType = HB_FT_DOUBLE; pFieldInfo.uiDec = ( HB_USHORT ) pMyField->decimals; break; case MYSQL_TYPE_STRING: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_ENUM: pFieldInfo.uiType = HB_FT_STRING; break; case MYSQL_TYPE_DATE: pFieldInfo.uiType = HB_FT_DATE; break; case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: pFieldInfo.uiType = HB_FT_MEMO; break; case MYSQL_TYPE_TIMESTAMP: case MYSQL_TYPE_DATETIME: pFieldInfo.uiType = HB_FT_TIMESTAMP; pFieldInfo.uiLen = 8; break; case MYSQL_TYPE_TIME: pFieldInfo.uiType = HB_FT_TIME; pFieldInfo.uiLen = 4; break; case MYSQL_TYPE_NULL: case MYSQL_TYPE_YEAR: case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_SET: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_BIT: case MYSQL_TYPE_GEOMETRY: bError = HB_TRUE; errCode = ( HB_ERRCODE ) pMyField->type; pFieldInfo.uiType = 0; break; } if( ! bError ) { switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr; pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); pStr[ pFieldInfo.uiLen ] = '\0'; pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen ); hb_xfree( pStr ); break; } case HB_FT_MEMO: pItem = hb_itemPutC( NULL, NULL ); break; case HB_FT_INTEGER: pItem = hb_itemPutNI( NULL, 0 ); break; case HB_FT_LONG: pItem = hb_itemPutNL( NULL, 0 ); break; case HB_FT_DOUBLE: pItem = hb_itemPutND( NULL, 0.0 ); break; case HB_FT_DATE: pItem = hb_itemPutDS( NULL, NULL ); break; case HB_FT_TIMESTAMP: case HB_FT_TIME: pItem = hb_itemPutTDT( NULL, 0, 0 ); break; default: pItem = hb_itemNew( NULL ); bError = HB_TRUE; break; } hb_arraySetForward( pItemEof, uiCount + 1, pItem ); hb_itemRelease( pItem ); #if 0 if( pFieldInfo.uiType == HB_IT_DOUBLE || pFieldInfo.uiType == HB_IT_INTEGER ) pFieldInfo.uiType = HB_IT_LONG; #endif if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } if( bError ) break; } if( bError ) { hb_itemRelease( pItemEof ); hb_errRT_MySQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); return HB_FAILURE; } pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( pSDDData->pResult ); pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) ); pArea->ulRecMax = pArea->ulRecCount + 1; pRow = pArea->pRow; *pRow = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pRow++; for( ulIndex = 1; ulIndex <= pArea->ulRecCount; ulIndex++ ) { *pRow++ = ( void * ) mysql_row_tell( pSDDData->pResult ); mysql_fetch_row( pSDDData->pResult ); } pArea->fFetched = HB_TRUE; return HB_SUCCESS; }
static HB_BOOL hb_copyfile( const char * szSource, const char * szDest ) { HB_BOOL bRetVal = HB_FALSE; HB_FHANDLE fhndSource; PHB_ITEM pError = NULL; HB_TRACE( HB_TR_DEBUG, ( "hb_copyfile(%s, %s)", szSource, szDest ) ); do { fhndSource = hb_fsExtOpen( szSource, NULL, FO_READ | FXO_DEFAULTS | FXO_SHARELOCK, NULL, pError ); if( fhndSource == FS_ERROR ) { pError = hb_errRT_FileError( pError, NULL, EG_OPEN, 2012, szSource ); if( hb_errLaunch( pError ) != E_RETRY ) break; } } while( fhndSource == FS_ERROR ); if( fhndSource != FS_ERROR ) { HB_FHANDLE fhndDest; do { fhndDest = hb_fsExtOpen( szDest, NULL, FXO_TRUNCATE | FO_READWRITE | FO_EXCLUSIVE | FXO_DEFAULTS | FXO_SHARELOCK, NULL, pError ); if( fhndDest == FS_ERROR ) { pError = hb_errRT_FileError( pError, NULL, EG_CREATE, 2012, szDest ); if( hb_errLaunch( pError ) != E_RETRY ) break; } } while( fhndDest == FS_ERROR ); if( fhndDest != FS_ERROR ) { #if defined( HB_OS_UNIX ) struct stat struFileInfo; int iSuccess = fstat( fhndSource, &struFileInfo ); #endif void * buffer; HB_USHORT usRead; buffer = hb_xgrab( BUFFER_SIZE ); bRetVal = HB_TRUE; while( ( usRead = hb_fsRead( fhndSource, buffer, BUFFER_SIZE ) ) != 0 ) { while( hb_fsWrite( fhndDest, buffer, usRead ) != usRead ) { pError = hb_errRT_FileError( pError, NULL, EG_WRITE, 2016, szDest ); if( hb_errLaunch( pError ) != E_RETRY ) { bRetVal = HB_FALSE; break; } } } hb_xfree( buffer ); #if defined( HB_OS_UNIX ) if( iSuccess == 0 ) fchmod( fhndDest, struFileInfo.st_mode ); #endif hb_fsClose( fhndDest ); } hb_fsClose( fhndSource ); } if( pError ) hb_itemRelease( pError ); return bRetVal; }
static HB_ERRCODE mysqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; LPFIELD pField; char * pValue; char szBuffer[ 64 ]; HB_BOOL bError; PHB_ITEM pError; HB_SIZE ulLen; bError = HB_FALSE; uiIndex--; pField = pArea->area.lpFields + uiIndex; pValue = pSDDData->pNatRecord[ uiIndex ]; ulLen = pSDDData->pNatLength[ uiIndex ]; /* NULL => NIL (?) */ if( ! pValue ) { hb_itemClear( pItem ); return HB_SUCCESS; } switch( pField->uiType ) { case HB_FT_STRING: { #if 0 char * pStr; /* Expand strings to field length */ pStr = ( char * ) hb_xgrab( pField->uiLen + 1 ); if( pValue ) memcpy( pStr, pValue, ulLen ); if( ( HB_SIZE ) pField->uiLen > ulLen ) memset( pStr + ulLen, ' ', pField->uiLen - ulLen ); pStr[ pField->uiLen ] = '\0'; hb_itemPutCRaw( pItem, pStr, pField->uiLen ); #else /* Do not expand strings */ if( pValue ) hb_itemPutCL( pItem, pValue, ulLen ); else hb_itemPutC( pItem, NULL ); #endif break; } case HB_FT_MEMO: if( pValue ) hb_itemPutCL( pItem, pValue, ulLen ); else hb_itemPutC( pItem, NULL ); hb_itemSetCMemo( pItem ); break; case HB_FT_INTEGER: case HB_FT_LONG: case HB_FT_DOUBLE: if( pValue ) { hb_strncpy( szBuffer, pValue, sizeof( szBuffer ) - 1 ); if( pField->uiDec ) { hb_itemPutNDLen( pItem, atof( szBuffer ), ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); } else hb_itemPutNLLen( pItem, atol( szBuffer ), ( int ) pField->uiLen ); } else { if( pField->uiDec ) hb_itemPutNDLen( pItem, 0.0, ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); else hb_itemPutNLLen( pItem, 0, ( int ) pField->uiLen ); } break; case HB_FT_DATE: { char szDate[ 9 ]; szDate[ 0 ] = pValue[ 0 ]; szDate[ 1 ] = pValue[ 1 ]; szDate[ 2 ] = pValue[ 2 ]; szDate[ 3 ] = pValue[ 3 ]; szDate[ 4 ] = pValue[ 5 ]; szDate[ 5 ] = pValue[ 6 ]; szDate[ 6 ] = pValue[ 8 ]; szDate[ 7 ] = pValue[ 9 ]; szDate[ 8 ] = '\0'; hb_itemPutDS( pItem, szDate ); break; } case HB_FT_TIMESTAMP: { char szTimeStamp[ 15 ]; szTimeStamp[ 0 ] = pValue[ 0 ]; szTimeStamp[ 1 ] = pValue[ 1 ]; szTimeStamp[ 2 ] = pValue[ 2 ]; szTimeStamp[ 3 ] = pValue[ 3 ]; szTimeStamp[ 4 ] = pValue[ 5 ]; szTimeStamp[ 5 ] = pValue[ 6 ]; szTimeStamp[ 6 ] = pValue[ 8 ]; szTimeStamp[ 7 ] = pValue[ 9 ]; szTimeStamp[ 8 ] = pValue[ 11 ]; szTimeStamp[ 9 ] = pValue[ 12 ]; szTimeStamp[ 10 ] = pValue[ 14 ]; szTimeStamp[ 11 ] = pValue[ 15 ]; szTimeStamp[ 12 ] = pValue[ 17 ]; szTimeStamp[ 13 ] = pValue[ 18 ]; szTimeStamp[ 14 ] = '\0'; hb_itemPutTS( pItem, szTimeStamp ); break; } case HB_FT_TIME: { char szTimeStamp[ 15 ]; szTimeStamp[ 0 ] = '0'; szTimeStamp[ 1 ] = '0'; szTimeStamp[ 2 ] = '0'; szTimeStamp[ 3 ] = '0'; szTimeStamp[ 4 ] = '0'; szTimeStamp[ 5 ] = '0'; szTimeStamp[ 6 ] = '0'; szTimeStamp[ 7 ] = '0'; szTimeStamp[ 8 ] = pValue[ 0 ]; szTimeStamp[ 9 ] = pValue[ 1 ]; szTimeStamp[ 10 ] = pValue[ 3 ]; szTimeStamp[ 11 ] = pValue[ 4 ]; szTimeStamp[ 12 ] = pValue[ 6 ]; szTimeStamp[ 13 ] = pValue[ 7 ]; szTimeStamp[ 14 ] = '\0'; hb_itemPutTS( pItem, szTimeStamp ); break; } default: bError = HB_TRUE; break; } if( bError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) ); hb_errPutSubCode( pError, EDBF_DATATYPE ); SELF_ERROR( ( AREAP ) pArea, pError ); hb_itemRelease( pError ); return HB_FAILURE; } return HB_SUCCESS; }
static HB_ERRCODE pgsqlGetValue( SQLBASEAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { SDDDATA * pSDDData = ( SDDDATA * ) pArea->pSDDData; LPFIELD pField; char * pValue; HB_BOOL bError; PHB_ITEM pError; HB_SIZE ulLen; bError = HB_FALSE; uiIndex--; pField = pArea->area.lpFields + uiIndex; if( PQgetisnull( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ) ) /* TOFIX: it breaks defined field type */ return HB_SUCCESS; pValue = PQgetvalue( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); ulLen = ( HB_SIZE ) PQgetlength( pSDDData->pResult, pArea->ulRecNo - 1, uiIndex ); /* printf( "fieldget recno:%d index:%d value:%s len:%d\n", pArea->ulRecNo, uiIndex, pValue, ulLen ); */ switch( pField->uiType ) { case HB_FT_STRING: hb_itemPutCL( pItem, pValue, ulLen ); break; case HB_FT_MEMO: hb_itemPutCL( pItem, pValue, ulLen ); hb_itemSetCMemo( pItem ); break; case HB_FT_INTEGER: case HB_FT_LONG: case HB_FT_DOUBLE: if( pField->uiDec ) hb_itemPutNDLen( pItem, atof( pValue ), ( int ) pField->uiLen - ( ( int ) pField->uiDec + 1 ), ( int ) pField->uiDec ); else if( pField->uiLen > 9 ) hb_itemPutNDLen( pItem, atof( pValue ), ( int ) pField->uiLen, ( int ) pField->uiDec ); else hb_itemPutNLLen( pItem, atol( pValue ), ( int ) pField->uiLen ); break; case HB_FT_LOGICAL: hb_itemPutL( pItem, pValue[ 0 ] == 'T' || pValue[ 0 ] == 'Y' ); break; case HB_FT_DATE: { char szDate[ 9 ]; szDate[ 0 ] = pValue[ 0 ]; szDate[ 1 ] = pValue[ 1 ]; szDate[ 2 ] = pValue[ 2 ]; szDate[ 3 ] = pValue[ 3 ]; szDate[ 4 ] = pValue[ 5 ]; szDate[ 5 ] = pValue[ 6 ]; szDate[ 6 ] = pValue[ 8 ]; szDate[ 7 ] = pValue[ 9 ]; szDate[ 8 ] = '\0'; hb_itemPutDS( pItem, szDate ); break; } default: bError = HB_TRUE; break; } if( bError ) { pError = hb_errNew(); hb_errPutGenCode( pError, EG_DATATYPE ); hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_DATATYPE ) ); hb_errPutSubCode( pError, EDBF_DATATYPE ); SELF_ERROR( &pArea->area, pError ); hb_itemRelease( pError ); return HB_FAILURE; } return HB_SUCCESS; }
//-----------------------------------------------------------------------= // ÚÄ1ra Col.a Pintar // ³ static void near PaintTheLine( HDC hDC, RECT * rct, WORD wIndex, PCLIPVAR pAtext, PCLIPVAR pAsizes, HPEN hWhitePen, HPEN hGrayPen, BOOL bTree, PCLIPVAR pAJustify, WORD wPressed, BOOL bHeader, WORD nStyle, WORD wFocus, BOOL bFocused, PCLIPVAR pTextColor, PCLIPVAR pBkColor, WORD wRowPos, WORD nHeightCtrl, LONG nClrLine, BOOL bFooter, BOOL bSelect, PCLIPVAR pFont, BOOL bDrawFocusRect ) { RECT box, wholebox, rctadj; int iMaxRight = rct->right; WORD wLenJust = 0 ; #ifndef __HARBOUR__ WORD wLen = _VARRAYLEN( pAtext ); CLV_WORD lJustify; #else WORD wLen = hb_arrayLen( pAtext ); PHB_ITEM uElem = hb_itemNew( NULL ); #endif WORD wType, wcLen; LONG lValue; char * cValue; HPEN hOldPen, hPen; BITMAP bmp; WORD wRow, wCol; LONG lColor ; HBRUSH hBrush; LONG lTextColorOld = -1 ; // CeSoTech LONG lBkColorOld = -1 ; // CeSoTech PCLIPVAR pEvalOld ; HFONT hFont ; // CeSoTech WORD wAlign ; // CeSoTech // CeSoTech LONG nClrLineC = ( nStyle == 2 || nStyle == 6 || nStyle == 8 || nStyle == 10 ) ? GetSysColor( COLOR_BTNSHADOW ) : 0 ; // CeSoTech if ( nClrLine >= 0 ) // Desde Clipper manda color especifico linea nClrLineC = nClrLine ; if ( ! bDrawHeaders ) bHeader = FALSE ; if ( bFooter ) bHeader = TRUE ; //-> Para que lo pinte con similar aspecto //CeSoTech // Si es un estilo sin separadores horizontales, pintar uno mas arriba //CeSoTech para que que bien completa el area !!! if ( ! (bHeader) && (nStyle == 0 || nStyle == 5 || nStyle == 6 || nStyle == 9 || nStyle == 10) ) rct->top-- ; wholebox.top = rct->top+1; wholebox.left = rct->left; wholebox.bottom = rct->bottom; wholebox.right = rct->right; rct->right = 0; box.top = rct->top ; box.bottom = rct->bottom - 1; if( !wIndex | wIndex > wLen ) wIndex = 1; if ( pAJustify ) #ifndef __HARBOUR__ wLenJust = _VARRAYLEN( pAJustify ); #else wLenJust = hb_arrayLen( pAJustify ); #endif while( wIndex <= wLen ) { rct->left = rct->right; rct->right = ( wIndex == wLen ? iMaxRight : rct->left + GetInt( pAsizes, wIndex ) ); // CeSoTech // Cuando estoy estoy en la ultima celda, NO pintar hasta // el final si no existe ajuste de ultima columna. if ( ( wIndex == wLen ) && ( ! bAdjLastCol ) ) { rct->right = rct->left + GetInt( pAsizes, wIndex ) +(bHeader ? 1: 0) ; if ( !bAdjBrowse ) wholebox.right = rct->right ; // Tambien ajusto el borde focus } // CeSoTech // wAlign = HA_LEFT | VA_CENTER ; // Alineacion por defecto wcLen = 0; ///////// INICIO Toma de datos celda !!! #ifndef __HARBOUR__ if ( wIndex <= wLenJust ) { _cAt( pAJustify, wIndex, 0xFFFF, ( PCLIPVAR ) &lJustify ); wAlign = lJustify.wWord ; } _cAt( pAtext, wIndex, 0xFFFF, ++_tos ); wType = _tos->wType; if ( wType & NUMERIC ) lValue = (LONG) _tos->pPointer1; if ( wType & CHARACTER ) { cValue = _VSTR( _tos ); wcLen = _tos->w2; } #else if ( wIndex <= wLenJust ) { hb_arrayGet( pAJustify, wIndex, uElem ); if ( ( hb_itemType( uElem ) & LOGICAL ) && hb_itemGetL( uElem ) ) wAlign = HA_RIGHT | VA_CENTER ; else wAlign = hb_itemGetNL( uElem ); hb_itemClear( uElem ); } // uElem.type = HB_IT_NIL; hb_arrayGet( pAtext, wIndex, uElem ); wType = hb_itemType( uElem ); if ( wType & NUMERIC ) lValue = hb_itemGetNL( uElem ); if ( wType & CHARACTER ) { // cValue = hb_itemGetC( uElem ); cValue = hb_itemGetCPtr( uElem ); wcLen = strlen( cValue ); } #endif ///////// FIN Toma de datos celda !!! if( wFocus > 0 && wIndex != wFocus ) { #ifndef __HARBOUR__ _tos--; #endif if( rct->right >= iMaxRight ) { wIndex = wLen + 1; // ya no pintamos m s } else ++wIndex; continue; } if( bTree || (GetInt( pAsizes, wIndex ) > 0) ) //Si NO es columna oculta (x Freeze) { //(Es lo mismo no hacer esto, // pero es para evitar hacer trabajar // al codigo sin sentido !!! ) if( (wType & NUMERIC) && bTree ) { if( lValue ) { FillRect( hDC, rct, hBrush = CreateSolidBrush( GetPixel( hDC, rct->left, rct->top ) ) ); DrawMasked( hDC, (HBITMAP) lValue, rct->top, rct->left ); DeleteObject( hBrush ); } } else // Si es Numerico Bmp no Tree, o , es Character !!!! { if ( pBkColor ) // Bloque de Color Fondo Celda { _PutSym( _SymEval ); _xPushM( pBkColor ); _PutLN( wRowPos ); _PutLN( wIndex ); _PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) ); _xEval( 3 ) ; if ( _parinfo( -1 ) & NUMERIC ) lBkColorOld = SetBkColor( hDC, _parnl( - 1 ) ) ; } if( pTextColor ) // Bloque de Color Texto Celda { _PutSym( _SymEval ); _xPushM( pTextColor ); _PutLN( wRowPos ); _PutLN( wIndex ); _PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) ); _xEval( 3 ) ; if ( _parinfo( -1 ) & NUMERIC ) lTextColorOld = SetTextColor( hDC, _parnl( - 1 ) ) ; } hFont = 0 ; if( pFont ) // Bloque de Font Celda { _PutSym( _SymEval ); _xPushM( pFont ); _PutLN( wRowPos ); _PutLN( wIndex ); _PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) ); _xEval( 3 ) ; if ( _parinfo( -1 ) & NUMERIC ) hFont = (HFONT) _parnl( - 1 ) ; } /////// CeSoTech /////// if (!bHeader) rct->top ++; if( wType & NUMERIC ) // Es un BitMap { FW_DrawBitmapCenter( hDC, (HBITMAP) lValue, rct, nStyle, bSelect ); } else // Es una Cadena { FW_DrawText( hDC, rct, ( wType & CHARACTER ) ? cValue : "", wAlign, wcLen, hFont, bHeader ) ; } /////// CeSoTech restauracion de colores ////// if ( lTextColorOld >= 0 ) { SetTextColor( hDC, lTextColorOld ) ; lTextColorOld = -1 ; } if ( lBkColorOld >= 0 ) { SetBkColor( hDC, lBkColorOld ) ; lBkColorOld = -1 ; } /// CeSoTech /// // Si hay modalidad ajustar el Browse y no hay ajuste de ultima // columna, deber‚ pintar hasta el final hasta cubrir toda // el area, hasta llegar a la derecha del control. (Col.Ficticia) if ( bAdjBrowse && wIndex == wLen && !bAdjLastCol && rct->right <= iMaxRight ) { rctadj.top = rct->top; rctadj.left = rct->right ; rctadj.bottom = rct->bottom; rctadj.right = wholebox.right ; if ( nStyle == 3 ) rctadj.top--; if ( wFocus == 0 ) // Si No es CellStyle (Pinto hasta final) ExtTextOut( hDC, 0, rct->top, ETO_OPAQUE, &rctadj, "", 0, 0 ); if ( bHeader && nStyle==3 ) // Pinto Bordes Header Falso { rctadj.right = wholebox.right - 2 ; rctadj.bottom = rctadj.bottom - 2 ; WndDrawBox( hDC, &rctadj, hWhitePen, hGrayPen ); rctadj.bottom++ ; rctadj.right++ ; WndDrawBox( hDC, &rctadj, hWhitePen, GetStockObject( BLACK_PEN ) ); if ( bFooter ) // Si es Footer (Linea Negra de Arriba Foot) { hPen = GetStockObject( BLACK_PEN ); hOldPen = SelectObject( hDC, hPen ); MoveTo( hDC, rctadj.left-1, rctadj.top-1 ); LineTo( hDC, rctadj.right+1, rctadj.top-1 ); SelectObject( hDC, hOldPen ); } } } /// CeSoTech Fin /// if (!bHeader) rct->top --; } box.left = rct->left; box.right = ( wIndex < wLen && rct->right <= iMaxRight ? rct->right - 1 : iMaxRight - 1 ); // CeSoTech // El Borde derecho de Box de la ultima columna, // no estirarlo cuando no exista ajuste de ultima columna // PERO cuando nLineStyle (nStyle) es 7/8 (Lineas Horiz) // queda anti-estetico cortar los renglones, cuando no hay // ajuste ult.col. y hay ajuste de browse. Por ello // se verificara que para cortar el borde no se de esta // condicion. if ( ( wIndex == wLen ) && ( ! bAdjLastCol ) ) { if (! (!bHeader && (nStyle==7 || nStyle==8) && !bAdjLastCol && bAdjBrowse) ) box.right = rct->left + GetInt( pAsizes, wIndex ) - 1 ; } // CeSoTech // if( ! bTree ) { if( wPressed && ( wIndex == wPressed ) ) { WndDrawBox( hDC, &box, hGrayPen, hWhitePen ); } else ///////////// if(!bHeader) if(!bHeader || (bHeader && nStyle!=3) ) { switch( nStyle ) { case 0: break; case 1: // hOldPen = SelectObject( hDC, GetStockObject( BLACK_PEN ) ); hPen = CreatePen(PS_SOLID, 0, nClrLineC ); hOldPen = SelectObject( hDC, hPen); MoveTo( hDC, box.left, box.bottom+1 ); LineTo( hDC, box.left, box.top ); LineTo( hDC, box.right+1, box.top ); LineTo( hDC, box.right+1, box.bottom+1 ); LineTo( hDC, box.left, box.bottom+1 ); SelectObject( hDC, hOldPen ); DeleteObject( hPen); break; case 2: hPen = CreatePen(PS_SOLID, 0, nClrLineC ); hOldPen = SelectObject( hDC, hPen); MoveTo( hDC, box.left, box.bottom+1 ); LineTo( hDC, box.left, box.top ); LineTo( hDC, box.right+1, box.top ); LineTo( hDC, box.right+1, box.bottom+1 ); LineTo( hDC, box.left, box.bottom+1 ); SelectObject( hDC, hOldPen ); DeleteObject( hPen); break; case 3: WndDrawBox( hDC, &box, hWhitePen, hGrayPen ); break; case 4: box.bottom ++; box.right ++; FrameDot( hDC, &box ); box.bottom --; box.right --; break; case 7: case 8: hPen = CreatePen(PS_SOLID, 0, nClrLineC ); hOldPen = SelectObject( hDC, hPen); MoveTo( hDC, box.left, box.top ); LineTo( hDC, box.right+1, box.top ); MoveTo( hDC, box.right+1, box.bottom+1 ); LineTo( hDC, box.left, box.bottom+1 ); SelectObject( hDC, hOldPen ); DeleteObject( hPen); break; case 5: case 6: case 9: case 10: hPen = CreatePen(PS_SOLID, 0, nClrLineC); hOldPen = SelectObject( hDC, hPen); if (box.left>1) { MoveTo( hDC, box.left, box.bottom+1 ); LineTo( hDC, box.left, box.top ); } MoveTo( hDC, box.right+1, box.top ); if ( bDrawFooters && nStyle >= 9 ) { LineTo( hDC, box.right+1, nHeightCtrl - (wFooterHeight+1) ) ; } else { LineTo( hDC, box.right+1, nStyle < 9 ? box.bottom+1 : nHeightCtrl ); } SelectObject( hDC, hOldPen ); DeleteObject( hPen); break; } } else // Box para Headers !!! { box.left ++; // CeSoTech if ( bFooter ) // Linea negra sobre el Footer { hPen = GetStockObject( BLACK_PEN ); hOldPen = SelectObject( hDC, hPen ); MoveTo( hDC, box.left-1, box.top-1 ); LineTo( hDC, box.right+1, box.top-1 ); SelectObject( hDC, hOldPen ); } box.right-- ; box.bottom-- ; WndDrawBox( hDC, &box, hWhitePen, hGrayPen ); box.bottom++ ; box.right++ ; WndDrawBox( hDC, &box, hWhitePen, GetStockObject( BLACK_PEN ) ); box.left --; } } else { if( ! ( wType & NUMERIC ) ) { box.left -= 16; } } // CeSoTech if( bFocused && wFocus > 0 && wIndex == wFocus ) if( bDrawFocusRect && bFocused && wFocus > 0 && wIndex == wFocus && nStyle != 3) { rct->left++; rct->top++; DrawFocusRect( hDC, rct ); rct->left--; rct->top--; } } #ifndef __HARBOUR__ _tos--; #endif if( rct->right >= iMaxRight ) { wIndex = wLen + 1; // ya no pintamos m s } else ++wIndex; } if (bDrawFocusRect && !bTree && bFocused && wFocus==0 && nStyle!=3) // CeSoTech DrawFocusRect( hDC, &wholebox ); hb_itemRelease( uElem ); }
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea ) { sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb; sqlite3_stmt * st = NULL; SDDDATA * pSDDData; const char * pszQuery; HB_SIZE nQueryLen; void * hQuery; HB_USHORT uiFields, uiIndex; PHB_ITEM pItemEof, pItem; HB_ERRCODE errCode; char * szError; HB_BOOL bError; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; pItem = hb_itemPutC( NULL, pArea->szQuery ); pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen ); if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK ) { hb_strfree( hQuery ); hb_itemRelease( pItem ); szError = sqlite3GetError( pDb, &errCode ); hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); sqlite3_finalize( st ); hb_xfree( szError ); return HB_FAILURE; } else { hb_strfree( hQuery ); hb_itemRelease( pItem ); } if( sqlite3_step( st ) != SQLITE_ROW ) { szError = sqlite3GetError( pDb, &errCode ); hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); sqlite3_finalize( st ); hb_xfree( szError ); return HB_FAILURE; } uiFields = ( HB_USHORT ) sqlite3_column_count( st ); SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); #if 0 HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", uiFields ) ); #endif errCode = 0; bError = HB_FALSE; for( uiIndex = 0; uiIndex < uiFields; ++uiIndex ) { DBFIELDINFO pFieldInfo; int iDataType = sqlite3_column_type( st, uiIndex ); PHB_ITEM pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) ); HB_USHORT uiNameLen = ( HB_USHORT ) hb_itemGetCLen( pName ); if( ( ( AREAP ) pArea )->uiMaxFieldNameLength < uiNameLen ) ( ( AREAP ) pArea )->uiMaxFieldNameLength = uiNameLen; pFieldInfo.atomName = hb_itemGetCPtr( pName ); #if 0 HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d", pFieldInfo.atomName, iDataType, sqlite3_column_bytes( st, uiIndex ) ) ); #endif /* There are no field length limits stored in the SQLite3 database, so we're resorting to setting some arbitrary default values to make apps relying on these (f.e. Browse()/GET) to behave somewhat better. For better results, update apps to untie UI metrics from any database field/value widths. [vszakats] */ pFieldInfo.uiLen = 10; pFieldInfo.uiDec = 0; switch( iDataType ) { case SQLITE3_TEXT: pFieldInfo.uiType = HB_FT_STRING; break; case SQLITE_FLOAT: pFieldInfo.uiType = HB_FT_LONG; pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals(); pFieldInfo.uiLen += pFieldInfo.uiDec + 1; break; case SQLITE_INTEGER: pFieldInfo.uiType = HB_FT_LONG; break; case SQLITE_BLOB: case SQLITE_NULL: pFieldInfo.uiType = HB_FT_BLOB; break; default: #if 0 HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) ); #endif bError = HB_TRUE; errCode = ( HB_ERRCODE ) iDataType; pFieldInfo.uiType = 0; break; } if( ! bError ) { switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); pStr[ pFieldInfo.uiLen ] = '\0'; pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen ); break; } case HB_FT_BLOB: pItem = hb_itemPutC( NULL, NULL ); break; case HB_FT_LONG: if( pFieldInfo.uiDec == 0 ) pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen ); else pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec ); break; default: pItem = hb_itemNew( NULL ); bError = HB_TRUE; } hb_arraySetForward( pItemEof, uiIndex + 1, pItem ); hb_itemRelease( pItem ); if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } hb_itemRelease( pName ); if( bError ) break; } if( bError ) { hb_itemRelease( pItemEof ); sqlite3_finalize( st ); hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); return HB_FAILURE; } pArea->ulRecCount = 0; pArea->ulRecMax = SQLDD_ROWSET_INIT; pArea->pRow = ( void ** ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pSDDData->pStmt = st; return HB_SUCCESS; }
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea ) { sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb; sqlite3_stmt * st = NULL; SDDDATA * pSDDData; const char * pszQuery; HB_SIZE nQueryLen; void * hQuery; HB_USHORT uiFields, uiIndex; PHB_ITEM pItemEof, pItem; HB_ERRCODE errCode; char * szError; HB_BOOL bError; pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) ); pSDDData = ( SDDDATA * ) pArea->pSDDData; pItem = hb_itemPutC( NULL, pArea->szQuery ); pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen ); if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK ) { hb_strfree( hQuery ); hb_itemRelease( pItem ); szError = sqlite3GetError( pDb, &errCode ); hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); sqlite3_finalize( st ); hb_xfree( szError ); return HB_FAILURE; } else { hb_strfree( hQuery ); hb_itemRelease( pItem ); } if( sqlite3_step( st ) != SQLITE_ROW ) { szError = sqlite3GetError( pDb, &errCode ); hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode ); sqlite3_finalize( st ); hb_xfree( szError ); return HB_FAILURE; } uiFields = ( HB_USHORT ) sqlite3_column_count( st ); SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields ); pItemEof = hb_itemArrayNew( uiFields ); #if 0 HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", iNameLen ) ); #endif errCode = 0; bError = HB_FALSE; for( uiIndex = 0; uiIndex < uiFields; ++uiIndex ) { DBFIELDINFO pFieldInfo; PHB_ITEM pName; int iDataType; int iSize; int iDec; pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) ); pFieldInfo.atomName = hb_itemGetCPtr( pName ); iDataType = sqlite3_column_type( st, uiIndex ); iSize = sqlite3_column_bytes( st, uiIndex ); iDec = 0; pFieldInfo.uiLen = ( HB_USHORT ) iSize; pFieldInfo.uiDec = ( HB_USHORT ) iDec; #if 0 HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d dec=%d nullable=%d", pFieldInfo.atomName, iDataType, iSize, iDec ) ); #endif switch( iDataType ) { case SQLITE_TEXT: pFieldInfo.uiType = HB_FT_STRING; break; case SQLITE_FLOAT: case SQLITE_INTEGER: pFieldInfo.uiType = HB_FT_LONG; break; case SQLITE_BLOB: pFieldInfo.uiType = HB_FT_BLOB; break; default: #if 0 HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) ); #endif bError = HB_TRUE; errCode = ( HB_ERRCODE ) iDataType; pFieldInfo.uiType = 0; pFieldInfo.uiType = HB_FT_STRING; break; } if( ! bError ) { switch( pFieldInfo.uiType ) { case HB_FT_STRING: { char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 ); memset( pStr, ' ', pFieldInfo.uiLen ); pStr[ pFieldInfo.uiLen ] = '\0'; pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen ); break; } case HB_FT_BLOB: pItem = hb_itemPutC( NULL, NULL ); break; case HB_FT_LONG: if( pFieldInfo.uiDec == 0 ) pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen ); else pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec ); break; default: pItem = hb_itemNew( NULL ); bError = HB_TRUE; } hb_arraySetForward( pItemEof, uiIndex + 1, pItem ); hb_itemRelease( pItem ); if( ! bError ) bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE ); } hb_itemRelease( pName ); if( bError ) break; } if( bError ) { hb_itemRelease( pItemEof ); sqlite3_finalize( st ); hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode ); return HB_FAILURE; } pArea->ulRecCount = 0; pArea->ulRecMax = SQLDD_ROWSET_INIT; pArea->pRow = ( void ** ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( void * ) ); memset( pArea->pRow, 0, SQLDD_ROWSET_INIT * sizeof( void * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); memset( pArea->pRowFlags, 0, SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pSDDData->pStmt = st; return HB_SUCCESS; }