QBasic & Borland Pascal & C/Delphi5.iso/C/BC_502/32SNIPIT.PAK/LANGDRV.C

C/C++ Source or Header | 1997-05-06 | 29.1 KB | 760 lines

// BDE32 3.x - (C) Copyright 1996 by Borland International

// Langdrv.C
#include "snipit.h"

#define MAXLEN 50

static DBIResult IntlFillTable(hDBIDb hDb, pCHAR szTblName, pCHAR szTblType,
                               DFLOAT NumRecs);
static DBIResult IntlPutFieldSample(hDBICur hCur, pBYTE pRecBuf,
                                    UINT16 FldNum, pFLDDesc pfldDesc);
static DBIResult IntlDisplayTable(hDBICur hCur, UINT32 uDisplayNRecs);

static const char szTblType[] = szPARADOX;


//=====================================================================
//  Function:
//          LangDriver();
//
//  Description:
//          This sample code will create a Paradox table with the default
//          Paradox language driver (as defined in the IDAPI configuration
//          file), append 10 records to the table, and then delete the
//          table.  Field names, table names, and field data need to be
//          converted when using non-ASCII characters.  This code
//          demonstrates how to do international support in IDAPI
//          functions DbiGetLdName, DbiGetLdObj, DbiAnsiToNative and
//          DbiNativeToAnsi.
//=====================================================================
void
LangDriver (void)
{
    hDBIDb      hDb;                            // Handle to the database
    hDBICur     hCur;                           // Handle to the table
    CRTblDesc   TblDesc;                        // Create table descriptor
    UINT16      uDispNumRecs = 10 ;             // Number of records to add and
                                                //   display.
    pVOID       pLdObj = NULL;                  // Language driver object.
    CHAR        szDspTblName[DBIMAXNAMELEN];    // Buffer to hold table name
                                                // for display (in ANSI
                                                // character set)
    UINT16      i;                              // Loop counter
    BOOL        bDataLoss;                      // Contains if data loss occured
                                                //   durring conversion
    DBIResult   rslt;                           // Return value from IDAPI
                                                //   functions
    // Variables are declared local because they are changed within this
    //   this example.
    char szTblName[] = "╟R8PXT▀L";

    // Field descriptor used in creating a table
    FLDDesc fldDesc[] = {
                     { // Field 1 - ALPHA
                1,            // Field number
                "─LPH┼",      // Field name
                fldZSTRING,   // Field type
                fldUNKNOWN,   // Field subtype
                10,           // Field size
                0,            // Decimal places ( 0 )
                              //     computed
                0,            // Offset in record ( 0 )
                11,           // Length in bytes  ( 0 )
                0,            // For Null bits    ( 0 )
                fldvNOCHECKS, // Validity checks   ( 0 )
                fldrREADWRITE // Rights
              },
              { // Field 2 - NUMERIC
                2, "╤▄MERIC", fldFLOAT, fldUNKNOWN,
                0, 0, 0, 0, 0, fldvNOCHECKS, fldrREADWRITE
              },
              { // Field 3 - MONEY
                3, "M╓NEY", fldFLOAT, fldstMONEY,
                0, 0, 0, 0, 0, fldvNOCHECKS, fldrREADWRITE
              },
              { // Field 4 - DATE
                4, "DAT╔", fldDATE, fldUNKNOWN,
                0, 0, 0, 0, 0, fldvNOCHECKS, fldrREADWRITE
              },
              { // Field 5 - MEMO
                5, "M╔MO", fldBLOB, fldstMEMO,
                20, 0, 0, 0, 0, fldvNOCHECKS, fldrREADWRITE
              }
             }; // Array of field descriptors

    // The number of fields in the table.
    const UINT16 uNumFields = sizeof(fldDesc) / sizeof (fldDesc[0]);

    Screen("*** Create/Open/Fill Paradox Table Example ***\r\n");

    BREAK_IN_DEBUGGER();

    Screen("    Initializing IDAPI...");
    if (InitAndConnect(&hDb) != DBIERR_NONE)
    {
        Screen("\r\n*** End of Example ***");
        return;
    }

    Screen("    Setting the default database directory...");
    rslt = DbiSetDirectory(hDb, (pCHAR)szTblDirectory);
    ChkRslt(rslt, "SetDirectory");

    // Table name is received from users in ANSI character set but IDAPI
    // expects it in OEM.
    AnsiToOem((pCHAR)szTblName, (pCHAR)szTblName);

    Screen("    Initializing the table descriptor...");
    memset((void *) &TblDesc , 0, sizeof(CRTblDesc));
    lstrcpy(TblDesc.szTblName, szTblName);
    lstrcpy(TblDesc.szTblType, szTblType);
    TblDesc.iFldCount = uNumFields;

    // Translate field names in field descriptor from ANSI (as received
    // from users) to the table's character set using table's language
    // driver.
    // Get default language driver name for specified table type. This
    // will also be the language driver of the new table.
    rslt = DbiGetLdObj(NULL, &pLdObj);
    if (ChkRslt(rslt, "GetLdName") == DBIERR_NONE)
    {
        for (i=0; i<uNumFields; i++)
        {
            rslt = DbiAnsiToNative(pLdObj, fldDesc[i].szName,
                                   fldDesc[i].szName, 0, &bDataLoss);
            ChkRslt(rslt, "AnsiToNative");
        }
    }
    else
    {
        CloseDbAndExit(&hDb);
        Screen("\r\n*** End of Example ***");
        return;
    }

    TblDesc.pfldDesc = fldDesc;

    // Create and overwrite the table using default language driver
    // defined in IDAPI configuration file.
    Screen("    Creating the Paradox table...");
    rslt = DbiCreateTable(hDb, TRUE, &TblDesc);
    if (ChkRslt(rslt, "CreateTable") != DBIERR_NONE)
    {
        CloseDbAndExit(&hDb);
        Screen("\r\n*** End of Example ***");
        return;
    }

    Screen("    Fill the table with random data...");
    IntlFillTable(hDb, (pCHAR)szTblName, (pCHAR)szTblType, uDispNumRecs);

    // Open the table which we just created.  The table name should be
    // translated from the DOS character set to ANSI for display.
    OemToAnsi(szTblName, szDspTblName);
    Screen("    Open the \"%s\" table...", szDspTblName);
    rslt = DbiOpenTable(hDb, (pCHAR)szTblName, (pCHAR)szTblType,
                        NULL, NULL, 0, dbiREADWRITE, dbiOPENSHARED,
                        xltFIELD, FALSE, NULL, &hCur);
    if (ChkRslt(rslt, "OpenTable") != DBIERR_NONE)
    {
        rslt = DbiDeleteTable(hDb, (pCHAR)szTblName, (pCHAR)szTblType);
        ChkRslt(rslt, "DeleteTable");
        CloseDbAndExit(&hDb);
        Screen("\r\n*** End of Example ***");
        return;
    }

    Screen("    Display the \"%s\" table which we just created...",
           szDspTblName);
    IntlDisplayTable(hCur, uDispNumRecs);

    Screen("\r\n    Close the Table...");
    rslt = DbiCloseCursor(&hCur);
    ChkRslt(rslt, "CloseCursor");

    Screen("    Deleting the table...");
    rslt = DbiDeleteTable(hDb, (pCHAR)szTblName, (pCHAR)szTblType);
    ChkRslt(rslt, "DeleteTable");

    Screen("    Close the database and exit IDAPI...");
    CloseDbAndExit(&hDb);

    Screen("\r\n*** End of Example ***");
}


//=====================================================================
//  Function:
//          IntlFillTable(hDb, szTblName, szTblType, NumRecs);
//
//  Input:  hDb         - The database handle
//          szTblName   - Name of the table to fill
//          szTblTyps   - Type of the table to fill
//          NumRecs     - The number of records to insert
//
//  Return: DBIResult - success?
//
//  Description:
//          This function adds the specified number of records to
//          the table containing random data.
//=====================================================================
DBIResult
IntlFillTable (hDBIDb hDb, pCHAR szTblName, pCHAR szTblType, DFLOAT NumRecs)
{
    DBIResult   rslt;           // Return value from IDAPI functions
    DFLOAT      fRecCount;      // Loop variable = count of records
    UINT16      FldCntr;        // Field counter
    pBYTE       pRecBuf;        // Pointer to the record buffer
    FLDDesc     fldDesc;        // Field descriptor
    CURProps    TblProps;       // Table descriptor
    hDBICur     hCur;           // Handle to the table
    hDBICur     hFldList;       // Handle to the field list table

    rslt = DbiOpenTable(hDb, szTblName, szTblType, NULL, NULL, 0, dbiREADWRITE,
                        dbiOPENSHARED, xltFIELD, FALSE, NULL, &hCur);
    if (ChkRslt(rslt,"OpenTable") != DBIERR_NONE)
    {
        return rslt;
    }

    //  Create an in-memory table that contains a list of fields. Note
    //  that logical (i.e. IDAPI types), are being requested instead of
    //  driver types.
    rslt = DbiOpenFieldList(hDb, szTblName, szTblType, FALSE, &hFldList);
    if (ChkRslt(rslt,"OpenFieldList")!= DBIERR_NONE)
    {
        rslt = DbiCloseCursor(&hCur);
        ChkRslt(rslt, "CloseCursor");
        return rslt;
    }

    //  Append the records if the list and table are available
    if (hCur && hFldList)
    {
        ChkRslt(DbiGetCursorProps(hCur, &TblProps),
                "GetCursorProps");

        pRecBuf = (pBYTE) malloc(TblProps.iRecBufSize);
        if (!pRecBuf)
        {
            Screen("Out of Memory");
            rslt = DbiCloseCursor(&hCur);
            ChkRslt(rslt, "CloseCursor");
            rslt = DbiCloseCursor(&hFldList);
            ChkRslt(rslt, "CloseCursor");
            return DBIERR_NOMEMORY;
        }

        // Loop until the specified number of records have been written
        // to the table.
        for (fRecCount = 0; fRecCount < NumRecs; fRecCount++)
        {
            //  Make sure we're starting with a clean record buffer
            rslt = DbiInitRecord(hCur, pRecBuf);
            ChkRslt(rslt, "InitRecord");

            FldCntr = 1;
            rslt = DbiSetToBegin(hFldList);
            ChkRslt(rslt,  "SetToBegin");

            // This loop will use the previously opened field list to
            // determine what type of data is inserted into the table.
            while (DbiGetNextRecord(hFldList, dbiNOLOCK, (pBYTE) &fldDesc,
                                    NULL) == DBIERR_NONE)
            {
                // Put field data into the record buffer
                IntlPutFieldSample(hCur, pRecBuf, FldCntr, &fldDesc);
                FldCntr++;
            }

            // All fields have been inserted into the record buffer. Now
            // we need to append the record to the table.
            rslt = DbiAppendRecord(hCur, pRecBuf);
            ChkRslt(rslt, "AppendRecord") ;

            // Make sure to close all blobs (opened when data was put into
            // the record buffer).
            FldCntr = 1;
            rslt = DbiSetToBegin(hFldList);
            ChkRslt(rslt, "SetToBegin");
            while (DbiGetNextRecord(hFldList, dbiNOLOCK, (pBYTE) &fldDesc,
                                    NULL) == DBIERR_NONE)
            {
                if (fldDesc.iFldType == fldBLOB)
                {
                    rslt = DbiFreeBlob(hCur, pRecBuf, FldCntr);
                    ChkRslt(rslt, "FreeBlob");
                }
                FldCntr++;
            }
        }

        // Free allocated record buffer
        free((pCHAR) pRecBuf);
    }

    // Clean up and return
    rslt = DbiCloseCursor(&hFldList);
    ChkRslt(rslt, "CloseCursor");

    rslt = DbiCloseCursor(&hCur);
    ChkRslt(rslt, "CloseCursor");

    return DBIERR_NONE;
}

//=====================================================================
//  Function:
//          IntlPutFieldSample(hCur, pRecBuf, FldNum, pfldDesc);
//
//  Input:  hCur     - The handle for the table to fill
//          pRecBuf  - The record buffer to insert data into
//          FldNum   - The field we are generating
//          pfldDesc - A descriptor that describes the field to generate
//
//  Return: Result returned from DbiPutField().
//
//  Description:
//          This routine is used to put field data into a record
//          buffer. Note that all LOGICAL field types are covered. You
//          will need to refer to documentation, or run the DRVCAPS.C
//          example for PHYSICAL to LOGICAL field mappings.
//=====================================================================
DBIResult
IntlPutFieldSample (hDBICur hCur, pBYTE pRecBuf, UINT16 FldNum,
                    pFLDDesc pfldDesc)
{
    pBYTE      pBuf;           // Buffer which contains the record data
    DBIResult  rslt;           // Return value from IDAPI functions
    INT16      i;              // Loop counter
    INT16      BlobSize;       // Size of the BLOB
    BOOL       bDataLoss;      // If any data is lost in translation

    BOOL       Bool;           // Used for fldBOOL
    INT16      Int16;          // Used for fldINT16
    UINT16     uInt16;         // Used for fldUINT16
    INT32      Int32;          // Used for fldINT32
    UINT32     uInt32;         // Used for fldUINT32
    DFLOAT     Float;          // Used for fldFLOAT
    FMTBcd     fmtBcd;         // Used for fldBCD
    DBIDATE    Date;           // Used for fldDATE
    TIME       Time;           // Used for fldTIME
    TIMESTAMP  tStamp;         // Used for fldTIMESTAMP
    UINT16     month;          // Used in generating the date
    UINT16     day;            // Used in generating the date
    UINT16     year;           // Used in generating the date
    UINT16     hour;           // Used in generating the time
    UINT16     min;            // Used in generating the time
    UINT16     sec;            // Used in generating the time
    pVOID      pLdObj = NULL;  // Table's language driver object

    // Allocate a generic buffer (used for string & blob fields)
    pBuf = (pBYTE) malloc(4096 * sizeof(CHAR));

    // This section contains sample code demonstrating how to
    // insert a field of any type into a record buffer.  Random data
    // is used by this example.  Field data is assumed to be in the ANSI
    // character set, and needs to be translated into the table's
    // character set before being inserted in the table.

    // Get tables language driver
    rslt = DbiGetLdObj(hCur, &pLdObj);
    ChkRslt(rslt, "GetLdObj");

    switch (pfldDesc->iFldType)
    {
        case fldBYTES:
        case fldZSTRING:
            sprintf((pCHAR)pBuf, "F∩Θld #%d", FldNum);
            // Translate the character string.  If table's language
            // driver is based on the ANSI character set, no translation
            // is performed.
            rslt = DbiAnsiToNative(pLdObj, (pCHAR)pBuf, (pCHAR)pBuf, NULL,
                                   &bDataLoss);
            ChkRslt(rslt, "AnsiToNative");

            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, pBuf);
            break;
        case fldDATE:
            // Randomly generate and encode a date
            month = (UINT16)((rand() % 12) + 1);
            day = (UINT16)((rand() % 20) + 1);
            year = (UINT16)((rand() % 99) + 1900);
            rslt = DbiDateEncode(month, day, year, &Date);
            ChkRslt(rslt, "DateEncode");

            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE) &Date);
            break;
        case fldBLOB:
            // Generate a blob with length from 10-4010 bytes
            BlobSize = (UINT16)((rand() % 4000) + 11);

            strcpy((pCHAR)pBuf, "BL╓B Θxßmple ");

            // Write data to the BLOB field
            for (i = 0; i < (BlobSize % 11); i++)
            {
                strcat((pCHAR)pBuf, "BL╓B tΦst ");
            }

            // Translate character data.  If table's language
            // driver is based on ANSI character set, no translation
            // is performed.
            rslt = DbiAnsiToNative(pLdObj, (pCHAR)pBuf, (pCHAR)pBuf, NULL,
                                   &bDataLoss);
            ChkRslt(rslt, "AnsiToNative");

            // Init the blob header (contents defined by IDAPI client)
            if ((pfldDesc->iSubType == fldstFMTMEMO) ||
                 (pfldDesc->iSubType == fldstOLEOBJ) ||
                 (pfldDesc->iSubType == fldstGRAPHIC))
            {
                 memset(pBuf, 8, '\0');
            }

            // Open the blob prior to putting
            ChkRslt(DbiOpenBlob(hCur, pRecBuf, FldNum, dbiREADWRITE), "OpenBlob");

            // Put the blob. Note that DbiFreeBlob() will be
            // called after the record is inserted!
            rslt = DbiPutBlob(hCur, pRecBuf, FldNum, 0, BlobSize,
                              pBuf);
            break;
        case fldBOOL:
            // Boolean fields are either TRUE or FALSE
            if ((rand() % 100) < 50)
                Bool = 1;
            else
                Bool = 0;
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&Bool);
            break;
        case fldINT16:
            Int16 = (UINT16)(rand() % 255);
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&Int16);
            break;
        case fldBCD:
            Float = (rand() / 1.21324);
            rslt = DbiBcdFromFloat(&Float, pfldDesc->iUnits1,
                                    pfldDesc->iUnits2, &fmtBcd);
            ChkRslt(rslt, "BcdFromFloat");

            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&fmtBcd);
            break;
        case fldLOCKINFO:
            rslt = 0;
            break;
        case fldUINT16:
            uInt16 = (UINT16)(rand() % 255);
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&uInt16);
            break;
        case fldINT32:
            // Put the data into the record buffer if it is not an
            // auto-increment field.
            if (pfldDesc->iSubType != fldstAUTOINC)
            {
                Int32 = (rand() % 10000);
                rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&Int32);
            }
            else
            {
                // Don't have to put a value into an auto-increment field,
                // but make certain not to return an error.
                rslt = 0;
            }
            break;
        case fldUINT32:
            uInt32 = (rand() % 10000);
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&uInt32);
            break;
        case fldFLOAT:
            Float = (rand() % 128000L);
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&Float);
            break;
        case fldTIME:
            // Randomize and encode a time value
            hour = (UINT16)((rand() % 23) + 1);
            min = (UINT16)((rand() % 59) + 1);
            sec = (UINT16)(((rand() * 2) % 59999U) + 1);
            rslt = DbiTimeEncode( hour, min, sec, &Time);
            ChkRslt(rslt, "TimeEncode");

            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&Time);
            break;
        case fldTIMESTAMP:
            // Encode a date and a time
            month = (UINT16)((rand() % 12) + 1);
            day = (UINT16)((rand() % 20) + 1);
            year = (UINT16)((rand() % 99) + 1900);
            rslt = DbiDateEncode(month, day, year, &Date);
            ChkRslt(rslt, "DateEncode");
            hour = (UINT16)((rand() % 23) + 1);
            min = (UINT16)((rand() % 59) + 1);
            sec = (UINT16)(((rand() * 2) % 59999U) + 1);
            rslt = DbiTimeEncode(hour, min, sec, &Time);
            ChkRslt(rslt, "TimeEncode");

            // Now encode and put the time stamp
            rslt = DbiTimeStampEncode(Date, Time, &tStamp);
            ChkRslt(rslt, "TimeStampEncode");
            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)&tStamp);
            break;
        case fldVARBYTES:
            // Init the size (1st two bytes) and contents
            *((int *) pBuf) = (pfldDesc->iUnits1 - 2);
            for (i = 2; i < pfldDesc->iUnits1; i++)
            {
                pBuf[i] = (UINT16)((rand() % 90) + 32);
            }
            pBuf[i] = '\0';

            // Put the data into the record buffer
            rslt = DbiPutField(hCur, FldNum, pRecBuf, (pBYTE)pBuf);
            break;
        default:
            rslt = DBIERR_INVALIDFLDTYPE;
            break;
    }
    // Determine if any of the previous DbiPutField functions failed.
    ChkRslt(rslt, "PutField");

    // Clean up and return
    free((pCHAR) pBuf);
    return rslt;
}

//=====================================================================
//  Function:
//          DisplayTable();
//
//  Input:  The cursor handle - which table to access
//          DisplayNRecs      - how many records to display
//                              (0 means display all records in the table)
//
//  Return: Result of displaying the records in the table
//
//  Descrption:
//          This function will display all records in the table referenced
//          by the cursor.  Records are read from the table in blocks,
//          making this function faster than the DisplayInMemoryTable()
//          function.
//
//  Note:   This function will only display the columns
//          correctly when using a fixed pitch font.
//=====================================================================
DBIResult
IntlDisplayTable (hDBICur hCur, UINT32 uDisplayNRecs)
{
    DBIResult   rslt;               // Return value from IDAPI functions
    CURProps    TblProps;           // Table properties
    pFLDDesc    pFldDescs;          // List of fields
    pBYTE       pRecBuf;            // Record buffer
    CHAR**      ppszField;          // Array to contain the fields of the
                                    //   table.
    pCHAR       szFormat;           // Contains an entire record (row)
    CHAR        szTemp[MAXLEN] =""; // Temporary variable for reading data
    UINT16      uFldNum;            // Loop variable
    UINT16      uMaxNumRecs = 30;   // Maximum number of record to read
                                    // from the table at a time
    UINT32      uNumRecs;           // Number of records Read in from the
                                    //   table
    UINT16      uCount;             // Loop variable
    UINT32      uCurCountRec = 0;   // Counter to keep track of how many
                                    //   records have been displayed
    const UINT16 uDefLength = 15;   // Default size of a field
    pVOID       pLdObj = NULL;      // Language driver object
    BOOL        bDataLoss;          // Data loss parameter for character
                                      //   translation

    rslt = DbiGetCursorProps(hCur, &TblProps);
    if ((ChkRslt(rslt, "GetCursorProps")) != DBIERR_NONE)
    {
        return rslt;
    }

    // Allocate memory for the format string
    szFormat = (pCHAR)malloc(1400);
    // Allocate space for the record buffer
    pRecBuf = (pBYTE)malloc(TblProps.iRecBufSize * sizeof(BYTE) *
                            uMaxNumRecs);
    // Allocate enough space to contain information (field descriptors)
    // about all the fields in the answer table.
    pFldDescs = (pFLDDesc)malloc(TblProps.iFields * sizeof(FLDDesc));
    if ((!pFldDescs) || (!pRecBuf) || (!szFormat))
    {
        if (szFormat) free(szFormat);
        if (pRecBuf) free(pRecBuf);
        if (pFldDescs) free(pFldDescs);
        return DBIERR_NOMEMORY;
    }

    szFormat[0] = 0;

    // Get information about the fields.
    rslt = DbiGetFieldDescs(hCur, pFldDescs);
    ChkRslt(rslt, "GetFieldDescs");

    // Allocate enough buffers to contain data from the fields in the
    // answer table.  Also set the width of non-fldZSTRING fields
    // (all data will be converted to strings for display ).
    ppszField = (CHAR**)malloc(TblProps.iFields * sizeof(CHAR*));
    if (!ppszField)
    {
        free(szFormat);
        free(pRecBuf);
        free(pFldDescs);
        return DBIERR_NOMEMORY;
    }

    SetupFields(TblProps, pFldDescs, ppszField, uDefLength);
    // Get table language driver to translate field names from table's
    // character set to ANSI for display
    rslt = DbiGetLdObj(hCur, &pLdObj);
    if ((ChkRslt(rslt, "GetLdObj")) != DBIERR_NONE)
    {
        free(szFormat);
        free(pRecBuf);
        free(pFldDescs);
        return rslt;
    }

    // Format the names of the fields, aligned by column
    strcpy(szFormat,"\r\n        ");
    for (uFldNum = 0; uFldNum < TblProps.iFields; uFldNum++)
    {
        sprintf(szTemp, "%-*s\t", pFldDescs[uFldNum].iUnits1 + 1,
                pFldDescs[uFldNum].szName);
        strcat(szFormat, szTemp);
    }

    // Translate field names from table's character set to ANSI for display
    rslt = DbiNativeToAnsi(pLdObj, szFormat, szFormat, NULL,
                                 &bDataLoss);
    if ((ChkRslt(rslt, "NativeToAnsi")) != DBIERR_NONE)
    {
        free(szFormat);
        free(pRecBuf);
        free(pFldDescs);
        return rslt;
    }

    // Display the header information (field names)
    Screen(szFormat);

    // Get records from the table until the end of the table is reached
    //   Note that not all field types are supported. All supported field
    //   types are displayed as strings.
    //   The DbiReadBlock function is used in case field mapping
    //   is taking place - the GetNextRec, GetPriorRec, and GetRelativeRec
    //   functions do not take field mapping into consideration.
    uNumRecs = uMaxNumRecs; // Set the number of records to read from the
                            // table as a block
    // if uCurCoutRec == 0, display all the records in the table
    if (uDisplayNRecs == 0)
    {
        uDisplayNRecs = (UINT16)-1; // uDisplayNRecs is unsigned, so
                                    // -1 maximizes the value
    }
    // Get the records from the table and display
    do
    {
        // Limit the number of records to be read from the table -
        // do not want to display more than uDisplayNRecs records.
        if ((uNumRecs + uCurCountRec) > uDisplayNRecs)
        {
            uNumRecs = uDisplayNRecs - uCurCountRec;
        }
        // Read a block of records - this is more efficient than reading
        // records one at a time from the table.
        rslt = DbiReadBlock(hCur, &uNumRecs, pRecBuf);
        if ((rslt != DBIERR_EOF) && // DBIERR_EOF is an expected return
            (rslt != DBIERR_NONE))  // code - means cannot read more records
        {
            free(szFormat);
            for (uFldNum = 0; uFldNum < TblProps.iFields; uFldNum++)
            {
                free(ppszField[uFldNum]);
            }
            free(ppszField);
            free(pFldDescs);
            free(pRecBuf);
            return rslt;
        }
        for (uCount=0; uCount < uNumRecs; uCount++)
        {
            uCurCountRec++;

            // Fill the record buffer with the field values.
            GetFields(hCur, pFldDescs,
                      &pRecBuf[uCount * TblProps.iRecBufSize],
                      ppszField, uDefLength);

            // Add leading blank space to the record.
            strcpy(szFormat,"        ");
            // Add each field to be displayed, making certain that the
            // columns line up.
            for (uFldNum = 0; uFldNum < TblProps.iFields; uFldNum++)
            {
                     sprintf(szTemp, " %-*s\t", pFldDescs[uFldNum].iUnits1,
                     ppszField[uFldNum]);
                     strcat(szFormat, szTemp);
                }
                // Translate table data from table's character set to ANSI for
            // display.
            rslt = DbiNativeToAnsi(pLdObj, szFormat, szFormat, NULL,
                                            &bDataLoss);
                if ((ChkRslt(rslt, "NativeToAnsi")) != DBIERR_NONE)
                {
                     // Clean up.
                     for (uFldNum = 0; uFldNum < TblProps.iFields; uFldNum++)
                     {
                         free(ppszField[uFldNum]);
                     }
                     free(szFormat);
                     free(ppszField);
                     free(pFldDescs);
                     free(pRecBuf);
                }

                // Display the record
                Screen(szFormat);
          } // for ... uCount
    // While ReadBlock reads as many records as are supposed to be
    // batched (uMaxNumRecs) and the maximum number of records have not
    // been read from the table.  Reading a smaller number of records than
    // that specified in uMaxNumRecs indicates that the end of the table has
    // been reached.
    } while((uNumRecs == uMaxNumRecs) &&
            (uCurCountRec < uDisplayNRecs));

    // Expect the End-Of-File error - just means that there
    // aren't any more records in the table.
    if (rslt == DBIERR_EOF)
    {
        rslt = DBIERR_NONE;
    }

    // Clean up.
    for (uFldNum = 0; uFldNum < TblProps.iFields; uFldNum++)
    {
        free(ppszField[uFldNum]);
    }
    free(szFormat);
    free(ppszField);
    free(pFldDescs);
    free(pRecBuf);

    return rslt;
}