Getting Started

Chapter Updated 10/29/25

Overview

Welcome to Xbase64 DBMS, a collection of specifications, programs, utilities and a C++ class library for manipulating legacy Xbase (DBF) type data files and indices.

The term Xbase is often used used to describe the format of the original dBASE, Clipper and Foxbase (.DBF) files. The XBase file format is well documented and has stood the test of time. Various popular programs still create and read xbase formatted files.

The purpose of the Xbase64 library is to provide reliable and usable programming tools for reading, writing and updating DBF databases, indices and memo fields. Version 4.2.0 has been tested for compatability with dBASE III, dBASE IV and dBASE V version data files and indices *.DBF (data), *.NDX (single tag index), *.MDX (multi tag index) and *.DBT (memo).

Version 4.x.x is a major rewrite of the library to strengthen error processing and bring consistency across modules. It includes updates to the locking process and also includes a module to support MDX multi tag indices.

Earlier versions of the library have included NTX and CDX index formats and that code will be re-incorporated into the latest version in the future.

Why use the Xbase library? The DBF file format is a ubiquitous industry standard that has stood the test of time and has been around for decades with widespread usage. Using this standard file format removes any vender specific locks that bind you to a particular platform. Additionally, with Xbase64 only the options needed can be compiled into or out of the library to provide a custom configuration specific to project requirements. For a small footprint, locking, memo fields and indices could be excluded from the library build which reduces the library size. This tool is useful for small to medium sized apps that don't need all the overhead, sophistication and cost of a complex client server configuration. The Xbase library is designed to be flexible in which options can be compiled into or out of the library and also which environments it can be run on.

Xbase64 is designed to compile and run on most any platform or architecture with a supporting 32 or 64 bit C++ compiler.

Library Features

  • Support for level 5 dBASE files (versions 3,4,5). Support for level 7 files (version 7 and higher) will be supported in a future release.
  • Supports 32 and 64 bit architectures.
  • Supports big endian and little endian architectures.
  • Compatible code, same API across multiple platforms / architectures.
  • Supports single and multi user configurations with record and file locking.
  • Includes support for logfiles.
  • Xbase64 DBMS has been successfully ported and runs on Linux, Mac and Windows
  • The library is built using Cmake to provide support on a wide variety of platforms.
  • The library build is configurable via cmake. Depending on user needs, the library can be built with various options turned on or off to remove unneeded or unwanted functionality from the library or reduce the size of the library footprint.

    System Requirements

    To build the Xbase64 library, the following items are needed:

  • A computer with a C/C++ compiler
  • Cmake

    Classes and User Interface

    Classes and User Interface Documentation via Doxygen

    Field Type Portability

  • Field types were defined to be consistent across various OS and CPU configurations. Xbase64 defines and uses the following field types:

    Field Types
    TypeDescription
    xbBoolContains xbTrue (1) or xbFalse (0)
    xbInt1616 bit int
    xbUInt1616 bit unsigned int
    xbInt3232 bit int
    xbUInt3232 bit unsigned int
    xbInt6464 bit int
    xbUInt6464 bit unsigned int
    xbDoubledouble
    charchar
    voidvoid
    struct SCHEMAUsed for defining record structures


    Xbase64 was designed for portability utilizing standard ANSI-C/C++ compliant code. If you decide to write updates to the Xbase64 project, please try to keep your work to standard C/C++ generic calls and use the above predefined field types.

    Compilation Overview

    To build the xbase64 library, verify you have:
  • Xbase64 source code
  • cmake 2.6 or LATER
  • Compiler and linker

    If you run into issues, verify you have access rights to the target location of the library.

    For Linux:

  • cd build/linux64 or cd build/linux32
  • cmake .
  • make
  • make test
  • sudo make install
  • Verify the ld.so.conf file has the library target directory. For example update file /etc/ld.so.conf to include /usr/local/lib and run ldconfig.

    For Raspberry Pi:

  • cd build/linux64 or cd build/linux32
  • cmake .
  • make
  • make test
  • sudo make install
  • Verify the ld.so.conf file has the library target directory. For example update file /etc/ld.so.conf to include /usr/local/lib and run ldconfig.

    For Mac:

  • Verify you have xcode installed and operational.
  • cd build/mac64
  • cmake . -DCMAKE_OSX_SYSROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk
  • make
  • make test

    For Windows 64 bit with Visual Studio:

  • Open a Visual Studio 64 bit Shell
  • cd build\win64vs
  • buildwin.bat
  • nmake test
  • From a VS Studio 64 bit shell in admin mode: nmake install

    For Windows 32 bit with Visual Studio:

  • Open a Visual Studio 32 bit Shell
  • cd build\win32vs
  • buildwin.bat
  • nmake test
  • From a VS Studio 32 bit shell in admin mode: nmake install

    For Windows 32 bit with Borland 5.5 free compiler

  • cd build\borland5.5
  • BuildBorland.bat
  • make test
  • make install (if errors, run in administrator mode)
  • xb_cfg_check (if errors, add path c:\Program Files\xbase64\bin)

    For Windows with mingw compiler

  • cd build/mingw (go to the appropriate build directory)
  • BuildMinGw.bat (configure for your environment and compile)
  • mingw32-make test (test library buiild)
  • mingw32-make install (install it)
  • "c:\Program Files (x86)\xbase64\bin\xb_cfg_chk" (test install)

    For other platforms:

    Here is something to start with...
  • cd xbase
  • md MyPlatform
  • cd MyPlatform
  • cp ../Cmake/CmakeLists.txt.
  • Enter the appropriate make command for your environment. Check the cmake web site for help.
    On Linux, it is .cmake, then make your mileage may vary Send your results to the library maintainer so it can be added to this library To use the Xbase classes, include the following header file in the program:

    #include <xbase.h>

    For more information on getting started, check out the sample programs in the src/examples folder.


    System Limitations


    Maximum size of a database file is the size of LONG - 2,147,483,647 bytes
    Total number of fields in a database - 255
    Total number of characters in all fields - 32767
    Maximum number of characters in a field - 254
    Total number of records in a file - 1 billion
    Maximum index key length - 100 bytes
    Maximum .DBT file memo block size - 32256
    Maximum expression result length - 100 bytes
    Maximum NDX index key length - 100 bytes


    Future Roadmap

  • Support for dBASE level 7 files
  • Support for Clipper files
  • Support for Foxpro files
  • More complete SQL support
  • ODBC driver
  • Client/server version