/* * Obtain physical row ID at current WorkArea cursor position. */ static HB_ERRCODE hb_delimRecId( DELIMAREAP pArea, PHB_ITEM pRecNo ) { HB_ERRCODE errCode; ULONG ulRecNo; HB_TRACE(HB_TR_DEBUG, ("hb_delimRecId(%p,%p)", pArea, pRecNo)); errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo ); #ifdef HB_C52_STRICT /* this is for strict Clipper compatibility but IMHO Clipper should not do that and always set fixed size independent to the record number */ if( ulRecNo < 10000000 ) { hb_itemPutNLLen( pRecNo, ulRecNo, 7 ); } else { hb_itemPutNLLen( pRecNo, ulRecNo, 10 ); } #else hb_itemPutNInt( pRecNo, ulRecNo ); #endif return errCode; }
static HB_ERRCODE sqlbaseRecId( SQLBASEAREAP pArea, PHB_ITEM pRecNo ) { HB_ERRCODE errCode; HB_ULONG ulRecNo; errCode = SELF_RECNO( ( AREAP ) pArea, &ulRecNo ); hb_itemPutNInt( pRecNo, ulRecNo ); return errCode; }
/* * Retrieve information about the current table/driver. */ static HB_ERRCODE hb_sdfInfo( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { HB_TRACE( HB_TR_DEBUG, ( "hb_sdfInfo(%p,%hu,%p)", pArea, uiIndex, pItem ) ); switch( uiIndex ) { case DBI_CANPUTREC: hb_itemPutL( pItem, pArea->fTransRec ); break; case DBI_GETRECSIZE: hb_itemPutNL( pItem, pArea->uiRecordLen ); break; case DBI_FULLPATH: hb_itemPutC( pItem, pArea->szFileName ); break; case DBI_FILEHANDLE: hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) ); break; case DBI_SHARED: hb_itemPutL( pItem, pArea->fShared ); break; case DBI_ISREADONLY: hb_itemPutL( pItem, pArea->fReadonly ); break; case DBI_POSITIONED: hb_itemPutL( pItem, pArea->fPositioned ); break; case DBI_DB_VERSION: case DBI_RDD_VERSION: { char szBuf[ 64 ]; int iSub = hb_itemGetNI( pItem ); if( iSub == 1 ) hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "SDF" ); else if( iSub == 2 ) hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "SDF", pArea->area.rddID ); else hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 ); hb_itemPutC( pItem, szBuf ); break; } default: return SUPER_INFO( &pArea->area, uiIndex, pItem ); } return HB_SUCCESS; }
static HB_BOOL s_fileConfigure( PHB_FILE pFile, int iIndex, PHB_ITEM pValue ) { switch( iIndex ) { case HB_VF_TIMEOUT: { HB_MAXINT timeout = pFile->timeout; if( HB_IS_NUMERIC( pValue ) ) pFile->timeout = hb_itemGetNInt( pValue ); hb_itemPutNInt( pValue, timeout ); return HB_TRUE; } case HB_VF_SHUTDOWN: { HB_SOCKET sd = hb_sockexGetHandle( pFile->sock ); if( HB_IS_NUMERIC( pValue ) && sd != HB_NO_SOCKET ) { switch( hb_itemGetNI( pValue ) ) { case FO_READ: hb_socketShutdown( sd, HB_SOCKET_SHUT_RD ); break; case FO_WRITE: hb_socketShutdown( sd, HB_SOCKET_SHUT_WR ); break; case FO_READWRITE: hb_socketShutdown( sd, HB_SOCKET_SHUT_RDWR ); break; } } hb_itemClear( pValue ); return HB_TRUE; } case HB_VF_RDHANDLE: case HB_VF_WRHANDLE: hb_itemPutNInt( pValue, ( HB_NHANDLE ) hb_sockexGetHandle( pFile->sock ) ); return HB_TRUE; } return HB_FALSE; }
static UINT_PTR CALLBACK CCHookProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) { UINT_PTR res; HB_BOOL fInit = HB_FALSE; PHB_ITEM pBlock; if( msg == WM_INITDIALOG ) { CHOOSECOLOR * cc = ( CHOOSECOLOR * ) lParam; SetProp( hWnd, _HB_CHOOSECOLOR_CB_PROP_, hb_itemNew( ( PHB_ITEM ) cc->lCustData ) ); fInit = HB_TRUE; } if( ( pBlock = ( PHB_ITEM ) GetProp( hWnd, _HB_CHOOSECOLOR_CB_PROP_ ) ) != NULL && hb_vmRequestReenter() ) { PHB_ITEM pWnd = hbwapi_itemPut_HANDLE( NULL, hWnd ); PHB_ITEM pMsg = hb_itemPutNInt( NULL, msg ); PHB_ITEM pLPa = hb_itemPutNInt( NULL, wParam ); PHB_ITEM pWPa = hb_itemPutNInt( NULL, lParam ); hb_evalBlock( pBlock, pWnd, pMsg, pLPa, pWPa ); res = ( UINT_PTR ) hbwapi_par_RESULT( -1 ); hb_itemRelease( pWnd ); hb_itemRelease( pMsg ); hb_itemRelease( pLPa ); hb_itemRelease( pWPa ); if( msg == WM_NCDESTROY ) { RemoveProp( hWnd, _HB_CHOOSECOLOR_CB_PROP_ ); hb_itemRelease( pBlock ); } hb_vmRequestRestore(); } else res = 0; return fInit ? 1 : res; }
static HB_ERRCODE mysqlExecute( SQLDDCONNECTION * pConnection, PHB_ITEM pItem ) { MYSQL * pMySql = ( ( SDDCONN * ) pConnection->pSDDConn )->pMySql; MYSQL_RES * pResult; HB_ULONG ulAffectedRows; PHB_ITEM pNewID = NULL; if( mysql_real_query( pMySql, hb_itemGetCPtr( pItem ), ( unsigned long ) hb_itemGetCLen( pItem ) ) ) { hb_rddsqlSetError( mysql_errno( pMySql ), mysql_error( pMySql ), hb_itemGetCPtr( pItem ), NULL, 0 ); return HB_FAILURE; } pResult = mysql_store_result( pMySql ); if( pResult ) { ulAffectedRows = ( HB_ULONG ) mysql_num_rows( pResult ); mysql_free_result( pResult ); hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), NULL, ulAffectedRows ); } else { if( mysql_field_count( pMySql ) == 0 ) { ulAffectedRows = ( HB_ULONG ) mysql_affected_rows( pMySql ); if( mysql_insert_id( pMySql ) != 0 ) { pNewID = hb_itemPutNInt( NULL, mysql_insert_id( pMySql ) ); } hb_rddsqlSetError( 0, NULL, hb_itemGetCPtr( pItem ), pNewID, ulAffectedRows ); if( pNewID ) hb_itemRelease( pNewID ); } else /* error */ { hb_rddsqlSetError( mysql_errno( pMySql ), mysql_error( pMySql ), hb_itemGetCPtr( pItem ), NULL, 0 ); return HB_FAILURE; } } return HB_SUCCESS; }
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem ) { HB_ULONG ulConn; SQLDDCONNECTION * pConn; HB_SYMBOL_UNUSED( pRDD ); ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent; if( ulConn > 0 && ulConn <= s_ulConnectionCount ) pConn = s_pConnection[ ulConn - 1 ]; else pConn = NULL; switch( uiIndex ) { case RDDI_REMOTE: hb_itemPutL( pItem, HB_TRUE ); break; case RDDI_CONNECTION: { HB_ULONG ulNewConnection = 0; if( hb_itemType( pItem ) & HB_IT_NUMERIC ) ulNewConnection = hb_itemGetNL( pItem ); hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent ); if( ulNewConnection ) s_ulConnectionCurrent = ulNewConnection; break; } case RDDI_ISDBF: hb_itemPutL( pItem, HB_FALSE ); break; case RDDI_CANPUTREC: hb_itemPutL( pItem, HB_TRUE ); break; case RDDI_CONNECT: { PSDDNODE pNode = NULL; HB_ULONG ul; const char * pStr; pStr = hb_arrayGetCPtr( pItem, 1 ); if( pStr ) { pNode = s_pSdd; while( pNode ) { if( ! hb_stricmp( pNode->Name, pStr ) ) break; pNode = pNode->pNext; } } hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) ); memset( pConn, 0, sizeof( SQLDDCONNECTION ) ); if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS ) { pConn->pSDD = pNode; /* Find free connection handle */ for( ul = 0; ul < s_ulConnectionCount; ul++ ) { if( ! s_pConnection[ ul ] ) break; } if( ul >= s_ulConnectionCount ) { /* Realloc connection table */ if( s_pConnection ) s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) ); else s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND ); memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND ); ul = s_ulConnectionCount; s_ulConnectionCount += CONNECTION_LIST_EXPAND; } s_pConnection[ ul ] = pConn; ul++; s_ulConnectionCurrent = ul; } else { hb_xfree( pConn ); ul = 0; } hb_itemPutNI( pItem, ul ); break; } case RDDI_DISCONNECT: hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS ) { hb_xfree( pConn ); s_pConnection[ ulConn - 1 ] = NULL; if( s_ulConnectionCurrent == ulConn ) s_ulConnectionCurrent = 0; hb_itemPutL( pItem, HB_TRUE ); return HB_SUCCESS; } hb_itemPutL( pItem, HB_FALSE ); return HB_SUCCESS; case RDDI_EXECUTE: hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 ); if( pConn ) hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS ); else hb_itemPutL( pItem, HB_FALSE ); return HB_SUCCESS; case RDDI_ERROR: hb_itemPutC( pItem, s_szError ); return HB_SUCCESS; case RDDI_ERRORNO: hb_itemPutNI( pItem, s_errCode ); return HB_SUCCESS; case RDDI_QUERY: hb_itemPutC( pItem, s_szQuery ); return HB_SUCCESS; case RDDI_NEWID: hb_itemCopy( pItem, s_pItemNewID ); return HB_SUCCESS; case RDDI_AFFECTEDROWS: hb_itemPutNInt( pItem, s_ulAffectedRows ); return HB_SUCCESS; #if 0 default: return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem ); #endif } return HB_SUCCESS; }
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; HB_USHORT uiType = pField->uiType; if( uiType == HB_FT_ANY ) { switch( sqlite3_column_type( st, ui ) ) { case SQLITE_TEXT: uiType = HB_FT_STRING; break; case SQLITE_FLOAT: case SQLITE_INTEGER: uiType = HB_FT_LONG; break; case SQLITE_BLOB: uiType = HB_FT_BLOB; break; } } switch( uiType ) { case HB_FT_STRING: pItem = S_HB_ITEMPUTSTR( NULL, ( const char * ) sqlite3_column_text( st, ui ) ); break; case HB_FT_INTEGER: #if HB_VMLONG_MAX > INT32_MAX && ! defined( HB_LONG_LONG_OFF ) pItem = hb_itemPutNInt( NULL, sqlite3_column_int64( st, ui ) ); break; #endif case HB_FT_LONG: pItem = hb_itemPutNDDec( NULL, sqlite3_column_double( st, ui ), 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; } } if( ulRecNo == 0 || ulRecNo > pArea->ulRecCount ) { pArea->pRecord = pArea->pRow[ 0 ]; pArea->bRecordFlags = pArea->pRowFlags[ 0 ]; pArea->fPositioned = HB_FALSE; } else { pArea->pRecord = pArea->pRow[ ulRecNo ]; pArea->bRecordFlags = pArea->pRowFlags[ ulRecNo ]; pArea->fPositioned = HB_TRUE; } 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, pName = NULL; 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( &pArea->area, uiFields ); errCode = 0; bError = HB_FALSE; pItemEof = hb_itemArrayNew( uiFields ); for( uiIndex = 0; uiIndex < uiFields; ++uiIndex ) { DBFIELDINFO dbFieldInfo; memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) ); pName = S_HB_ITEMPUTSTR( pName, sqlite3_column_name( st, uiIndex ) ); dbFieldInfo.atomName = hb_itemGetCPtr( pName ); dbFieldInfo.uiType = sqlite3DeclType( st, uiIndex ); pItem = hb_arrayGetItemPtr( pItemEof, uiIndex + 1 ); switch( dbFieldInfo.uiType ) { case HB_FT_STRING: { int iSize = sqlite3_column_bytes( st, uiIndex ); char * pStr; dbFieldInfo.uiLen = ( HB_USHORT ) HB_MAX( iSize, 10 ); pStr = ( char * ) hb_xgrab( ( HB_SIZE ) dbFieldInfo.uiLen + 1 ); memset( pStr, ' ', dbFieldInfo.uiLen ); hb_itemPutCLPtr( pItem, pStr, dbFieldInfo.uiLen ); break; } case HB_FT_BLOB: dbFieldInfo.uiLen = 4; hb_itemPutC( pItem, NULL ); break; case HB_FT_INTEGER: dbFieldInfo.uiLen = 8; hb_itemPutNInt( pItem, 0 ); break; case HB_FT_LONG: dbFieldInfo.uiLen = 20; dbFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals(); hb_itemPutNDDec( pItem, 0.0, dbFieldInfo.uiDec ); break; case HB_FT_ANY: dbFieldInfo.uiLen = 6; break; default: bError = HB_TRUE; } if( ! bError ) bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE ); if( bError ) break; } hb_itemRelease( pName ); 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 * ) ); pArea->pRowFlags = ( HB_BYTE * ) hb_xgrab( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) ); pArea->pRow[ 0 ] = pItemEof; pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED; pSDDData->pStmt = st; return HB_SUCCESS; }
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; }
/* * Retrieve information about the current table/driver. */ static HB_ERRCODE hb_delimInfo( DELIMAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem ) { HB_TRACE( HB_TR_DEBUG, ( "hb_delimInfo(%p,%hu,%p)", pArea, uiIndex, pItem ) ); switch( uiIndex ) { case DBI_CANPUTREC: hb_itemPutL( pItem, pArea->fTransRec ); break; case DBI_GETRECSIZE: hb_itemPutNL( pItem, pArea->uiRecordLen ); break; case DBI_GETDELIMITER: { char szDelim[ 2 ]; szDelim[ 0 ] = pArea->cDelim; szDelim[ 1 ] = '\0'; hb_itemPutC( pItem, szDelim ); break; } case DBI_SETDELIMITER: if( hb_itemType( pItem ) & HB_IT_STRING ) { const char * szDelim = hb_itemGetCPtr( pItem ); if( hb_stricmp( szDelim, "BLANK" ) == 0 ) { pArea->cDelim = '\0'; pArea->cSeparator = ' '; } #ifndef HB_CLP_STRICT else if( hb_stricmp( szDelim, "PIPE" ) == 0 ) { pArea->cDelim = '\0'; pArea->cSeparator = '|'; } else if( hb_stricmp( szDelim, "TAB" ) == 0 ) { pArea->cDelim = '\0'; pArea->cSeparator = '\t'; } else #else else if( *szDelim ) #endif { pArea->cDelim = *szDelim; } } /* * a small trick which allow to set character field delimiter and * field separator in COPY TO ... and APPEND FROM ... commands as * array. F.e.: * COPY TO test DELIMITED WITH ({"","|"}) */ #ifndef HB_CLP_STRICT else if( hb_itemType( pItem ) & HB_IT_ARRAY ) { char cSeparator; if( hb_arrayGetType( pItem, 1 ) & HB_IT_STRING ) pArea->cDelim = *hb_arrayGetCPtr( pItem, 1 ); cSeparator = *hb_arrayGetCPtr( pItem, 2 ); if( cSeparator ) pArea->cSeparator = cSeparator; } #endif break; case DBI_SEPARATOR: { char szSeparator[ 2 ]; const char * szNew = hb_itemGetCPtr( pItem ); szSeparator[ 0 ] = pArea->cSeparator; szSeparator[ 1 ] = '\0'; if( *szNew ) pArea->cSeparator = *szNew; hb_itemPutC( pItem, szSeparator ); break; } case DBI_FULLPATH: hb_itemPutC( pItem, pArea->szFileName); break; case DBI_FILEHANDLE: hb_itemPutNInt( pItem, ( HB_NHANDLE ) hb_fileHandle( pArea->pFile ) ); break; case DBI_SHARED: hb_itemPutL( pItem, pArea->fShared ); break; case DBI_ISREADONLY: hb_itemPutL( pItem, pArea->fReadonly ); break; case DBI_POSITIONED: hb_itemPutL( pItem, pArea->fPositioned ); break; case DBI_DB_VERSION: case DBI_RDD_VERSION: { char szBuf[ 64 ]; int iSub = hb_itemGetNI( pItem ); if( iSub == 1 ) hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s)", 0, 1, "DELIM" ); else if( iSub == 2 ) hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d (%s:%d)", 0, 1, "DELIM", pArea->area.rddID ); else hb_snprintf( szBuf, sizeof( szBuf ), "%d.%d", 0, 1 ); hb_itemPutC( pItem, szBuf ); break; } default: return SUPER_INFO( &pArea->area, uiIndex, pItem ); }