FUNCTION UseOpenBase() 
    LOCAL aStr   := {} 
    LOCAL cDbf   := GetStartUpFolder() + "\TEST" 
    LOCAL cIndx  := cDbf 
    LOCAL lDbfNo 
    LOCAL aAlias := {} 
    LOCAL n      := 0 
  
    IF ( lDbfNo := ! File( cDbf+'.dbf' ) ) 
       AAdd( aStr, { 'F1', 'D',  8, 0 } ) 
       AAdd( aStr, { 'F2', 'C', 60, 0 } ) 
       AAdd( aStr, { 'F3', 'N', 10, 2 } ) 
       AAdd( aStr, { 'F4', 'L',  1, 0 } ) 
  
       dbCreate( cDbf, aStr ) 
    ENDIF 
  
    IF lDbfNo .OR. !FILE(cIndx+'.cdx')  
       // если нет базы или индекса 
       USE ( cDbf ) ALIAS "TEST" EXCLUSIVE NEW 
  
       WHILE TEST->( RecCount() ) < 10 
          TEST->( dbAppend() ) 
          TEST->F1 := Date() + n++ 
          TEST->F2 := Str( n ) 
          TEST->F3 := n 
          TEST->F4 := ( n % 2 ) == 0 
       END 
  
       GO TOP 
       INDEX ON RECNO() TAG NN FOR !Deleted()          
       INDEX ON RECNO() TAG NO FOR  Deleted()          
       USE 
  
    ENDIF 
  
    SET AUTOPEN ON 
  
    USE ( cDbf ) ALIAS "TEST" SHARED NEW 
    OrdSetFocus('NN') 
    GO TOP 
  
 //   ORDLISTADD( cIndx ) 
  
    AADD( aAlias, ALIAS() )  // запомнить базу для закрытия 
  
 RETURN aAlias 
 

 
 #define HB_OS_WIN_USED 
  
 #include "hbapi.h" 
 #include "hbapiitm.h" 
 #include "hbapirdd.h" 
 #include "hbrdddbf.h" 
 #include "hbapicdp.h" 
  
 //#include "hbdate.h" 
  
 #ifdef __XHARBOUR__ 
 #define HB_SUCCESS SUCCESS 
 #endif 
  
 /* 
 HB_FUNC( MILLIS ) 
 { 
    hb_retnl( hb_dateMilliSeconds() ); 
 } 
 */ 
 /* 
 HB_FUNC( DBSETCDP ) 
 { 
    AREAP pArea = hb_rddGetCurrentWorkAreaPointer(); 
  
    if( pArea && ISCHAR(1) ) 
    { 
       char * pCdp = hb_parc(1); 
       if( pCdp ) 
          pArea->cdPage = hb_cdpFind( (char *) pCdp ); 
    } 
 } 
 */ 
  
 // ------------------------------- 
 // Static func bMemoGetBlock(nPos) 
 // Return {|| dbGetMemoBlock(nPos)} 
 // ------------------------------- 
 HB_FUNC( DBGETMEMOBLOCK ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    USHORT uiField = hb_parni( 1 ) - 1; 
 #ifdef __XHARBOUR__ 
    LPFIELD pField = pArea->lpFields + uiField; 
 #else 
    LPFIELD pField = pArea->area.lpFields + uiField; 
 #endif 
    char * ptr = ( char * ) pArea->pRecord + pArea->pFieldOffset[uiField]; 
    ULONG ulBlock = 0; 
  
    if( pField->uiLen == 4 ) 
       ulBlock =  HB_GET_LE_UINT32( ptr ); 
    else 
    { 
       BYTE bByte; 
       USHORT uiCount; 
  
       for( uiCount = 0; uiCount < 10; uiCount++ ) 
       { 
          bByte = ptr[ uiCount ]; 
          if( bByte >= '0' && bByte <= '9' ) 
             ulBlock = ulBlock * 10 + ( bByte - '0' ); 
       } 
    } 
    hb_retnl( ulBlock ); 
 } 
  
 // --------------------------- 
 // Получить значение поля как строка 
 //  if FieldType(nPos) == "C"; xVal := FieldGet(nPos) 
 //  else                     ; xVal := dbGetValue(nPos) 
 //  endif 
 // --------------------------- 
 HB_FUNC( DBGETVALUE ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    USHORT uiField = hb_parni( 1 ) - 1; 
 #ifdef __XHARBOUR__ 
    LPFIELD pField = pArea->lpFields + uiField; 
 #else 
    LPFIELD pField = pArea->area.lpFields + uiField; 
 #endif 
    hb_retclen( ( char * ) pArea->pRecord + pArea->pFieldOffset[uiField], pField->uiLen ); 
 } 
  
 // ----------------------------- 
 //	if FieldType(nPos) == "C"; FieldPut(nPos, xVal) 
 //	else                     ; dbPutValue(nPos, xVal) 
 //	endif 
 // ----------------------------- 
 HB_FUNC( DBPUTVALUE ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    USHORT uiField = hb_parni( 1 ) - 1; 
 #ifdef __XHARBOUR__ 
    LPFIELD pField = pArea->lpFields + uiField; 
 #else 
    LPFIELD pField = pArea->area.lpFields + uiField; 
 #endif 
    if( ISCHAR(2) && ( hb_parclen(2) <= pField->uiLen ) ) 
    { 
       memcpy( ( char * ) pArea->pRecord + pArea->pFieldOffset[uiField], hb_parc(2), hb_parclen(2) ); 
       pArea->fRecordChanged = TRUE; 
       pArea->fDataFlush = TRUE; 
    } 
    hb_ret(); 
 } 
  
 // ------------------------ 
 // Вставить запись 
 //   nKol := 1;    nRec := RecNo() 
 //   dbGoto(nRec); dbInsert(nRec, nKol) 
 // ------------------------ 
 HB_FUNC( DBINSERT ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    BOOL bOk = TRUE; 
  
    if( pArea && ! pArea->fReadonly && ! pArea->fShared ) 
    { 
       ULONG ulRec, ulCount = ISNUM(2) ? hb_parnl(2) : 1; 
 #ifdef __XHARBOUR__ 
       ULONG hFile = pArea->hDataFile; 
 #else 
       HB_FHANDLE hFile = hb_fileHandle( pArea->pDataFile ); 
 #endif 
  
       if( ISNUM(1) ) 
          ulRec = hb_parnl(1); 
       else 
          SELF_RECNO( ( AREAP ) pArea, &ulRec ); 
  
       if( ulRec == 0 || ulRec > pArea->ulRecCount ) 
          bOk = FALSE; 
  
       if( bOk && SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS ) 
          bOk = FALSE; 
       else 
       { 
          ULONG ulIndex; 
  
          for( ulIndex = 0; ulIndex < ulCount; ulIndex ++) 
             SELF_APPEND( ( AREAP ) pArea, TRUE ); 
          SELF_FLUSH( ( AREAP ) pArea ); 
  
 /* 
          pArea->fUpdateHeader = TRUE; 
          pArea->ulRecCount += ulCount; 
  
          if( SELF_WRITEDBHEADER( ( AREAP ) pArea ) != HB_SUCCESS ) 
             bOk = FALSE; 
 */ 
  
          if( bOk ) 
          { 
             ULONG ulLen = (pArea->ulRecCount - ulRec) * pArea->uiRecordLen; 
             ULONG ulLen1 = ulCount*pArea->uiRecordLen; 
 //            ULONG ulRecNo; 
             char * pData = hb_xgrab( ulLen + 1 ); 
             char * pZero = hb_xgrab( ulLen1 + 1 ); 
  
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (ulRec - 1), FS_SET ); 
             hb_fsReadLarge( hFile, pData, ulLen ); 
  
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (pArea->ulRecCount - ulCount), FS_SET ); 
             hb_fsReadLarge( hFile, pZero, ulLen1 ); 
  
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (ulRec - 1), FS_SET ); 
             hb_fsWriteLarge( hFile, pZero, ulLen1 ); 
  
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (ulRec + ulCount - 1), FS_SET ); 
             hb_fsWriteLarge( hFile, pData, ulLen ); 
             hb_xfree( pData ); 
             hb_xfree( pZero ); 
  
 /* 
             for( ulRecNo = ulRec + ulCount - 1; ulRecNo >= ulRec; ulRecNo --) 
             { 
                SELF_GOTO( ( AREAP ) pArea, ulRecNo );  
                SELF_SETBLANKRECORD( ( AREAP ) pArea, 2 ); // HB_BLANK_EOF 
             } 
 */ 
          } 
  
       } 
  
       if( bOk && SELF_GOTO( ( AREAP ) pArea, ulRec ) != HB_SUCCESS ) 
          bOk = FALSE; 
    } 
    hb_retl( bOk ); 
 } 
  
 // ---------------------------- 
 // Физическое удаление записей 
 //    nKol := 1;    nRec := RecNo() 
 //	  dbGoto(nRec); dbDelRecord(nRec, nKol) 
 // ---------------------------- 
 HB_FUNC( DBDELRECORD ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    BOOL bOk = TRUE; 
  
    if( pArea && ! pArea->fReadonly && ! pArea->fShared ) 
    { 
       ULONG ulRec, ulCount = ISNUM(2) ? hb_parnl(2) : 1; 
 #ifdef __XHARBOUR__ 
       ULONG hFile = pArea->hDataFile; 
 #else 
       HB_FHANDLE hFile = hb_fileHandle( pArea->pDataFile ); 
 #endif 
  
       if( ISNUM(1) ) 
          ulRec = hb_parnl(1); 
       else 
          SELF_RECNO( ( AREAP ) pArea, &ulRec ); 
  
       if( ulRec == 0 || (ulRec + ulCount - 1) > pArea->ulRecCount ) 
          bOk = FALSE; 
  
       if( bOk && SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS ) 
          bOk = FALSE; 
       else 
       { 
          char pData; 
  
          if( (ulRec + ulCount - 1) < pArea->ulRecCount ) 
          { 
             ULONG ulLen = (pArea->ulRecCount - (ulRec + ulCount - 1)) * pArea->uiRecordLen; 
             char * pData = hb_xgrab( ulLen + 1 ); 
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (ulRec + ulCount - 1), FS_SET ); 
             hb_fsReadLarge( hFile, pData, ulLen ); 
             hb_fsSeekLarge( hFile, ( HB_FOFFSET ) pArea->uiHeaderLen + 
                             ( HB_FOFFSET ) pArea->uiRecordLen * 
                             ( HB_FOFFSET ) (ulRec - 1), FS_SET ); 
             hb_fsWriteLarge( hFile, pData, ulLen ); 
             hb_xfree( pData ); 
          } 
  
          pArea->fUpdateHeader = TRUE; 
          pArea->ulRecCount -= ulCount; 
       } 
  
       if( bOk && SELF_WRITEDBHEADER( ( AREAP ) pArea ) != HB_SUCCESS ) 
          bOk = FALSE; 
       if( bOk && SELF_GOTO( ( AREAP ) pArea, ulRec ) != HB_SUCCESS ) 
          bOk = FALSE; 
    } 
    hb_retl( bOk ); 
 } 
  
 // -------------------------- 
 // Обрезать файл после записи ... 
 //   nRec := RecNo(); dbGoto(nRec) 
 //   dbTruncate(nRec) 
 // -------------------------- 
 HB_FUNC( DBTRUNCATE ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    BOOL bOk = TRUE; 
  
    if( pArea && ! pArea->fReadonly && ! pArea->fShared ) 
    { 
       ULONG ulRec; 
  
       if( ISNUM(1) ) 
          ulRec = hb_parnl(1); 
       else 
          SELF_RECNO( ( AREAP ) pArea, &ulRec ); 
  
       if( ulRec == 0 || ulRec > pArea->ulRecCount ) 
          bOk = FALSE; 
  
       if( bOk && SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS ) 
          bOk = FALSE; 
       else 
       { 
          pArea->fUpdateHeader = TRUE; 
          pArea->ulRecCount = ulRec; 
       } 
  
       if( bOk && SELF_WRITEDBHEADER( ( AREAP ) pArea ) != HB_SUCCESS ) 
          bOk = FALSE; 
       if( bOk && SELF_GOTO( ( AREAP ) pArea, ulRec ) != HB_SUCCESS ) 
          bOk = FALSE; 
    } 
    hb_retl( bOk ); 
 } 
  
 HB_FUNC( DBRECORDGET ) 
 { 
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    PHB_ITEM pItem = hb_itemPutNI( NULL, 0 ); 
    BYTE *pRec; 
  
    if( pArea && (SELF_INFO( (AREAP) pArea, DBI_GETRECSIZE, pItem ) == HB_SUCCESS) && ( SELF_GETREC( (AREAP) pArea, &pRec ) == HB_SUCCESS ) ) 
    { 
       hb_retclen( pRec, hb_itemGetNI(pItem) ); 
    } 
    hb_itemRelease( pItem ); 
  
 } 
  
 HB_FUNC( DBRECORDPUT ) 
 { 
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    PHB_ITEM pItem = hb_itemPutNI( NULL, 0 ); 
  
    if( pArea && ISCHAR(1) && (SELF_INFO( (AREAP) pArea, DBI_GETRECSIZE, pItem ) == HB_SUCCESS) && hb_parclen(1) >= (ULONG) hb_itemGetNI(pItem) ) 
    { 
       SELF_PUTREC( pArea, hb_parc(1) ); 
    } 
    hb_itemRelease( pItem ); 
 } 
  
 static void SetFieldType( LPFIELD pField, char bType ) 
 { 
    switch( bType ) 
    { 
       case 'C': 
          pField->uiType = HB_FT_STRING; 
          break; 
       case 'L': 
          pField->uiType = HB_FT_LOGICAL; 
          break; 
       case 'D': 
          pField->uiType = HB_FT_DATE; 
          break; 
       case 'I': 
       case '2': 
       case '4': 
          pField->uiType = HB_FT_INTEGER; 
          break; 
       case 'Y': 
          pField->uiType = HB_FT_CURRENCY; 
          break; 
       case 'N': 
          pField->uiType = HB_FT_LONG; 
          break; 
       case 'F': 
          pField->uiType = HB_FT_FLOAT; 
          break; 
       case '8': 
       case 'B': 
          pField->uiType = HB_FT_DOUBLE; 
    } 
 } 
  
 // ------------------------ 
 // Переименовать поле, поменять его тип и дробную часть 
 // в пределах длины поля, заданную при создании dbf 
 // FieldRename( nPos, FieldNameNew[, FieldTypeNew[, FieldDecNew]] ) 
 // ------------------------ 
 HB_FUNC( FIELDRENAME ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    USHORT uiField = hb_parni( 1 ); 
    char szFieldName[12]; 
  
 #ifdef __XHARBOUR__ 
    if( uiField && uiField <= pArea->uiFieldCount && ISCHAR(2) && hb_parclen(2) <= 11 ) 
 #else 
    if( uiField && uiField <= pArea->area.uiFieldCount && ISCHAR(2) && hb_parclen(2) <= 11 ) 
 #endif 
    { 
       char * szType = hb_parc( 3 ); 
 #ifdef __XHARBOUR__ 
       ULONG hFile = pArea->hDataFile; 
       LPFIELD pField = pArea->lpFields + uiField - 1; 
 #else 
       HB_FHANDLE hFile = hb_fileHandle( pArea->pDataFile ); 
       LPFIELD pField = pArea->area.lpFields + uiField - 1; 
 #endif 
       ULONG ulOffset = sizeof( DBFHEADER ) + (uiField-1)*sizeof( DBFFIELD ); 
  
       memset(szFieldName, 0, 12); 
       memcpy(szFieldName, hb_parc(2), hb_parclen(2) ); 
  
       hb_fsSeekLarge( hFile, ( HB_FOFFSET ) ulOffset, FS_SET ); 
       hb_fsWriteLarge( hFile, szFieldName, 11 ); 
       pField->sym = ( void * ) hb_dynsymGetCase( szFieldName ); 
  
       if( szType ) 
       { 
          hb_fsSeekLarge( hFile, ( HB_FOFFSET ) ( ulOffset + 11 ), FS_SET ); 
          hb_fsWriteLarge( hFile, szType, 1 ); 
          SetFieldType( pField, szType[0] ); 
       } 
       if( ISNUM( 4 ) ) 
       { 
          USHORT uiDec = hb_parni( 4 ); 
          hb_fsSeekLarge( hFile, ( HB_FOFFSET ) ( ulOffset + 17 ), FS_SET ); 
          hb_fsWriteLarge( hFile, (char *) &uiDec, 1 ); 
          pField->uiDec = uiDec; 
       } 
  
    } 
 } 
  
 HB_FUNC( DBFRECCOUNT ) 
 { 
    DBFAREAP pArea = ( DBFAREAP ) hb_rddGetCurrentWorkAreaPointer(); 
    if( pArea ) 
    { 
       if( ISNUM( 1 ) ) 
       { 
          HB_PUT_LE_UINT32( pArea->dbfHeader.ulRecCount, hb_parnl( 1 ) ); 
          pArea->fUpdateHeader = TRUE; 
       } 
       hb_retnl( HB_GET_LE_UINT32( pArea->dbfHeader.ulRecCount ) ); 
    } 
    else 
       hb_retnl( 0 ); 
 } 
  
 #include <windows.h> 
  
 HB_FUNC( GETSYSTEMDEFAULTLANGID ) 
 { 
   hb_retnl( GetSystemDefaultLangID() ); 
 }