db.c

Go to the documentation of this file.

/*
    The contents of this file are subject to the Mozilla Public License 
    Version 1.1 (the "License"); you may not use this file except in 
    compliance with the License. You may obtain a copy of the License at 
    http://www.mozilla.org/MPL/
                                                        
    Software distributed under the License is distributed on an "AS IS" 
    basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. 
    See the License for the specific language governing rights and 
    limitations under the License.
    
    The Original Code is property of Neuros Audio LLC.
    
    The Initial Developer of the Original Code is DeepB. 
    Portions created by others are public domain. 
    All Rights Reserved.
    
    Contributor(s): DeepB, others.
    
    Alternatively, the contents of this file may be used under the terms 
    of the GPL license (the GPL License), in which case the provisions of 
    GPL License are applicable instead of those above.  
    If you wish to allow use of your version of this file only under the 
    terms of the GPL License and not to allow others to use your version of 
    this file under the MPL, indicate your decision by deleting the 
    provisions above and replace them with the notice and other provisions 
    required by the GPL License. If you do not delete the provisions above, 
    a recipient may use your version of this file under either the MPL or 
    the GPL License."
*/

#include "../SYSTEM/sys_hardware.h"
#include "db.h"
#include "db_assert.h"

static BOOL _removeChildIdx(DB_DATA *,DB_FIELDIDX,DB_MDBOFFSET);
static DB_HDL _query(DB_ID, DB_ENTRY, DB_DATA *, DB_HDL);
#define DB_MAXDBNODES       8           /* Maximum children nodes per DB. */

static st_DBDINODE * _copyTree(st_DBDINODE *, const st_DBIDNODE *);
static const DB_DATA * _formDataTree(st_DBDINODE *, const DB_DATA *);
static BOOL _insert2child(st_DBDINODE *);
#define RETURN_ERROR    {FAT_fclose(file);return FALSE;}
#define RETURN_ERROR_DB {FAT_fclose(file);return DB_INVALID_ID;}
static void _sortSAI (unsigned long *, USHORT);
static BOOL _genFile        ( ULONG, const char *);
static BOOL _createDB       ( ULONG, const char *, BOOL);
static BOOL _replacePAI(DB_ID,DB_MDBOFFSET,DB_MDBOFFSET);
#define DB_MAXPAIBUFLEN     64  
static DB_PAIOFFSET _checkPAI(DB_ID,DB_PAIOFFSET,DB_MDBOFFSET);
static DB_PAIOFFSET _createPAIentry(DB_ID,DB_MDBOFFSET);
#define SPECIAL_CHAR_FIX

#define TABLE_SIZE  130
const unsigned char _char_sorting_table[TABLE_SIZE] =
        {
          /*0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,*/
            0x00, 0x06, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
          /*0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,*/
            0x0E, 0x01, 0x02, 0x24, 0x25, 0x03, 0x0F, 0x10, 
            
          /*0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,*/
            0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
          /*0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,*/
            0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 
            
          /*0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,*/
            0x04, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x22,
          /*0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,*/
            0x2C, 0x2D, 0x2E, 0x40, 0x2F, 0x23, 0x30, 0x31, 
            
          /*0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,*/
            0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
          /*0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,*/
            0x4C, 0x4D, 0x32, 0x33, 0x41, 0x42, 0x33, 0x34, 
        
          /*0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,*/
            0x35, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A,
          /*0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,*/
            0x5C, 0x5E, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6A, 
        
          /*0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,*/
            0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7A,
          /*0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,*/
            0x7C, 0x7E, 0x80, 0x36, 0x37, 0x38, 0x39, 0x3A, 
        
          /*0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,*/
            0x3B, 0x4E, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5A, 
          /*0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,*/
            0x5C, 0x5E, 0x60, 0x61, 0x64, 0x66, 0x68, 0x6A, 
        
          /*0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,*/
            0x6C, 0x6E, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7A, 
          /*0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,*/
            0x7C, 0x7E, 0x80, 0x3C, 0x3D, 0x3E, 0x3F, 0x21,
            
          /*0x80, 0x81*/
            0x05, 0x07
        };

#ifdef SPECIAL_CHAR_FIX
#define _2lower(x) (((_char_sorting_table[((x)>>8)&0xff])<<8) |(_char_sorting_table[(x)&0xff]) )
#else
#define _2lower(x) _char_sorting_table[(x)]
#endif


#ifdef BACKUP_DATABASE
const char    strDBBUPDIR[]   = "BAK_DB";
#endif
const char    strDBDIR[]      = "WOID_DB";
const char    strAUDIODIR[]   = "audio";
const char    strAUDIO[]      = "audio.mdb";
const char    strPCAUDIO[]    = "pcaudio.mdb";
const char    strFAILEDHISI[] = "failedhisi.mdb";
const char    strIDEDHISI[]   = "idedhisi.mdb";
const char    strUNIDEDHISI[] = "unidedhisi.mdb";
st_DBREGIST   DB_registration[DB_MAX_ID];   /* DB ID registration record. */
st_DBIDTREE   DB_idtree;                    /* DB ID registration tree. */
st_DBQUERYCTL DB_qctl[DB_OPENMAX];
st_DBINFO     DB_qinfo[DB_OPENMAX];

st_DBNAV      DBnav;

//DB_CTL        DB_ctl;
extern void AUDIO_MDB_INIT_TABLE    ( void );
extern void PCAUDIO_MDB_INIT_TABLE  ( void );
extern void UNIDHISI_MDB_INIT_TABLE ( void );
extern void IDEDHISI_MDB_INIT_TABLE ( void );
extern void FAILHISI_MDB_INIT_TABLE ( void );

#pragma CODE_SECTION (DB_unmount, ".dbinit_code")
BOOL DB_unmount(DB_ID id)
{   
    return TRUE;    
}


#pragma CODE_SECTION (DB_setSyncMark, ".dbinit_code")
void DB_setSyncMark( const char * drive )
{
    st_DBHEADER         header;
    File *              file;
    
    FAT_cd(drive);  
    if( TRUE == FAT_cd(strDBDIR) )
    {
        if( TRUE == FAT_cd(strAUDIODIR) )
        {
            if(file = FAT_fopen(strAUDIO, r_b))
            {
                FAT_fseek(file, 0, SEEK_HEAD);
                if( FAT_fread(file, (unsigned short *)&header, sizeof(st_DBHEADER)) 
                    == sizeof(st_DBHEADER) ) 
                {
                    header.status |= 0x0002;    
                }
                FAT_fseek(file, 0, SEEK_HEAD);
                FAT_fwrite(file, (unsigned short *)&header, sizeof(st_DBHEADER)); 
                FAT_fclose(file);
            }
        }
    }
}

#pragma CODE_SECTION (DB_checkSyncMark, ".dbinit_code")
BOOL DB_checkSyncMark( const char * drive )
{
    st_DBHEADER         header;
    BOOL                ret = TRUE;
    File *              file;
    
    FAT_cd(drive);
    if( TRUE == FAT_cd(strDBDIR) )
    {
        if( TRUE == FAT_cd(strAUDIODIR) )
        {
            if(file = FAT_fopen(strAUDIO, rb))
            {
                if( FAT_fread(file, (unsigned short *)&header, sizeof(st_DBHEADER)) 
                    == sizeof(st_DBHEADER) ) 
                {
                    if( !(header.status & 0x0002) ) ret = FALSE;
                }
                FAT_fclose(file);
            }
        }
    }
            
    return ret;
}

#pragma CODE_SECTION(DB_removeRecord, ".db_code")
BOOL DB_removeRecord(DB_ID childId, DB_ENTRY childEntry, DB_ENTRY paiEntry)
{
    unsigned short  entryNum;
    DB_MDBOFFSET    root;
    DB_MDBOFFSET    child;
    DB_PAIOFFSET    pai;
    DB_FIELDIDX     fldidx;
    DB_RECLEN       len;
    File *          idxfile;
    File *          dbfile;
    unsigned short  record[DB_MAXRECLEN];   
    
    if(DB__cdDBdir(DB__name(DB__rootID(childId), MDB)) == FALSE)   return FALSE;    
    
    fldidx = DB__fieldIndex(childId);

    /* Fetch child MDB offset. */
    idxfile = FAT_fopen(DB__name(childId, SAI), rb);
    FAT_fseek(idxfile, (long)(childEntry + DB_SAIFIRSTENTRY) << 2, SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&child, 2);
    FAT_fread(idxfile, (unsigned short *)&pai, 2);
    FAT_fclose(idxfile);

    /* Update root record, remove child index. */
    idxfile = FAT_fopen(DB__name(childId, PAI), rb);
    FAT_fseek(idxfile, pai+((paiEntry-1)<<1), SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&root, 2);
    FAT_fclose(idxfile);    

    dbfile = FAT_fopen(DB__name(DB__rootID(childId), MDB), r_b);
    FAT_fseek(dbfile, root, SEEK_HEAD);
    DB__getRecord(dbfile, record);
    
    _removeChildIdx(record, fldidx, child);

    len = DB__recordLen(record);

    FAT_fseek(dbfile, root, SEEK_HEAD);
    FAT_fwrite(dbfile, (unsigned short *)record, len);
    FAT_fclose(dbfile);


    /* Search child PAI to remove specified parent entry. */
    DB__removePAIentry(childId, root, pai, &entryNum);

    if(entryNum == 0)
    {
        /* No PAIs left for this entry, delete it. */
        DB__deleteChildRecord(childId, childEntry);
    }

    return TRUE;
}

#pragma CODE_SECTION(_removeChildIdx, ".db_code")
static BOOL _removeChildIdx(DB_DATA *       pRecord, 
                            DB_FIELDIDX     fldidx, 
                            DB_MDBOFFSET    childMdb)
{
    unsigned long       mdb;
    unsigned short *    pD;
    unsigned short *    pT;
    
    pD = (unsigned short *)DB__locateField(pRecord, fldidx);
    
    while(1)
    {
        if(*pD == DB_ESCCHAR) pD++;
        else if( (*pD==DB_RECDLMT) ||(*pD==DB_FLDDLMT) )  break;
        
        mdb = (unsigned long)(*pD)<<16;     
        pT = pD++;
        
        if(*pD == DB_ESCCHAR) pD++;     
        else if( (*pD==DB_RECDLMT) ||(*pD==DB_FLDDLMT) )  break;
        
        mdb |= (unsigned long)(*pD);

        if( mdb == childMdb)
        {
            *pT  = 0;
            *pD  = 0;
        }
        
        pD++;
    }
        
    return TRUE;    
}

//#pragma CODE_SECTION(DB_queryFirst, ".db_code")
#pragma CODE_SECTION(DB_queryFirst, ".sram0_resident")
DB_HDL DB_queryFirst(   DB_ID           id, 
                        DB_FIELDIDX     fldIdx, 
                        DB_ENTRY        fldEntry, 
                        DB_ENTRY        dbEntry,
                        DB_DATA *       pData)
{
    DB_HDL          hdl;
    DB_ID           tmpid;
    USHORT          entryNum;
    unsigned short  ii;
    st_DBQUERYCTL * pCtl;
    st_DBIDNODE *   node;
    st_DBINFO *     pInfo;
            
    /* Locate first available query control OBJ. */
    for( ii = 0; ii < DB_OPENMAX; ii++ ) 
    {       
        if( DB_qctl[ii].free == TRUE )  break;
    }
    if ( ii == DB_OPENMAX ) return DB_INVALID_HDL;  

    /* Valid handle found. */   
    hdl         = ii;
    pCtl        = &DB_qctl[hdl];
    pCtl->free  = FALSE;
    pInfo       = &DB_qinfo[hdl];
    
    if( DB__info(id, pInfo) == FALSE )
    {
        pCtl->free = TRUE;
        return DB_INVALID_HDL;
    }
    
    // start querying.
    node = &DB_idtree.node[id];
    
    /* Check to see if id points to a virtual DB. */
    //if( DB_registration[id].fname == NULL ) 
    if(pInfo->bVirtual == TRUE)
    {
        /* Virtual DB, access through its parent. */
        node = node->parent;        
        return( _query(node->id, dbEntry, pData, hdl) );        
    }

    /* Check to see if primary key is used to access the database. */
    //if( fldIdx == 0 )
    if( (fldIdx == 0)||(fldIdx == 0xffff) )
    {
        /* Primary key detected, query DB directly. */
        return( _query(id, dbEntry, pData, hdl) );
    }

    /* Following code to access DB using specified key. */
    /* Check to see if this is a valid key. */
    //if( DB__info(id, &info) == FALSE ) return DB_INVALID_HDL;
    //if( fldIdx >= info.numOfKeys ) return DB_INVALID_HDL;
    if( fldIdx >= pInfo->numOfKeys )
    {
        pCtl->free = TRUE;
        return DB_INVALID_HDL;
    }

    /* Fetch the access field DB ID. */
    node = node->child; 
    for(ii = 0; ii < fldIdx; ii++ ) node = node->next;

    tmpid = node->id;

    /* Locate the key. */
    hdl = _query(tmpid, fldEntry, pData, hdl);
    if(hdl == DB_INVALID_HDL) return hdl;


    //pCtl = &DB_qctl[hdl];
    /* Close current MDB file. */
    FAT_fclose(pCtl->dbfile);

    /* Close current SAI file. */
    FAT_fclose(pCtl->idxfile);


    /* Open MDB file. */
    pCtl->dbfile = FAT_fopen(DB__name(id, MDB), rb);

    /* Open PAI file. */
    pCtl->idxfile = FAT_fopen(DB__name(tmpid, PAI), rb);
    
    if( pCtl->pai == 0) 
    {
        /* Empty PAI entry. */
        pCtl->free = TRUE;

        FAT_fclose(pCtl->idxfile);
        FAT_fclose(pCtl->dbfile);
        return DB_INVALID_HDL;
    }

    /* PAI entry always takes 32 bits. */
    pCtl->step = 1;
    
    /* Locate the entry number. */
    FAT_fseek(pCtl->idxfile, pCtl->pai - 4, SEEK_HEAD);
    FAT_fread(pCtl->idxfile, &entryNum, 1);
    
    pInfo->numOfPAIent = entryNum+1;
    if(dbEntry > entryNum)
    {
        /* Empty PAI entry. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        FAT_fclose(pCtl->dbfile);
        return DB_INVALID_HDL;
    }
    
    pCtl->idx = pCtl->pai;

#if 1
    /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    ** I chose the confusing way to ease my UI application. :(
    ** Any query via PAI MUST add ONE entry offset, thus the UI
    ** can use the same code to query no matter it is via SAI or PAI,
    ** since "dbEntry == 0" always points to the default empty entry
    ** if we directly query the DB through SAI ( fldIdx == 0 ).
    ** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    */
    pCtl->idx -= 2; 
#endif

    /* Locate the record index. */
    FAT_fseek(pCtl->idxfile, pCtl->idx + (dbEntry << 1), SEEK_HEAD);
    FAT_fread(pCtl->idxfile, (unsigned short *)&pCtl->pai, 2);
        
    /* Locate the record. */
    FAT_fseek(pCtl->dbfile, pCtl->pai, SEEK_HEAD);

    /* Fetch record. */
    if( DB__getRecord(pCtl->dbfile, pData) == FALSE ) 
    {       
        /* No record available. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        FAT_fclose(pCtl->dbfile);
        return DB_INVALID_HDL;
    }

    return hdl;
}

#pragma CODE_SECTION(DB_queryNext, ".db_code")
BOOL DB_queryNext(DB_HDL hdl, DB_ENTRY entry, DB_DATA * pData)
{
    DB_MDBOFFSET    mdb = 0L;
    USHORT *        pD = pData;
    st_DBQUERYCTL * pCtl = &DB_qctl[hdl];
    
    FAT_fseek(pCtl->idxfile, pCtl->idx + (entry<<pCtl->step),SEEK_HEAD);
    FAT_fread(pCtl->idxfile, (unsigned short *)&mdb, 2);
                    
    /* Reached top / bottom ? */
    if( mdb == 0 ) return FALSE;        
    
    /* Locate the record. */
    FAT_fseek(pCtl->dbfile, mdb, SEEK_HEAD);
    
    if(pD)
    {
        *(USHORT*)pD++ = mdb>>16;
        *(USHORT*)pD++ = mdb&0xffff;
    }
    
    return( DB__getRecord(pCtl->dbfile, pD) );  
}


#pragma CODE_SECTION(DB_queryClose, ".db_code")
BOOL DB_queryClose(DB_HDL hdl)
{
    st_DBQUERYCTL * pCtl;
    
    if(hdl == DB_INVALID_HDL )  return FALSE;
    pCtl = &DB_qctl[hdl];
    if(pCtl->free == TRUE)      return TRUE;
    
    FAT_fclose(pCtl->dbfile);       
    FAT_fclose(pCtl->idxfile);      

    pCtl->free = TRUE;

    return TRUE;    
}


#pragma CODE_SECTION(_query, ".db_code")
// Function queries the specified database by the primary key. It is the
// caller's responsibility to maintain the id integrity.
//
// @param id
//          DB ID.
// @param dbEntry
//          DB data entry.
// @param pData
//          DB record data buffer.
// @param hdl
//          DB query handle.
// @return
//      Valid DB handle if successful, otherwise DB_INVALID_HDL.
//
static DB_HDL _query(DB_ID id, DB_ENTRY dbEntry, DB_DATA * pData, DB_HDL hdl)
{
    DB_MDBOFFSET    mdb;
    USHORT *        pD = (USHORT*)pData;
    unsigned short  entryNum;
    unsigned short  ii;
    unsigned long   signature;
    st_DBQUERYCTL * pCtl;
    st_DBINFO *     pInfo;

    pCtl        = &DB_qctl[hdl];
    pInfo       = &DB_qinfo[hdl];
        
    /* Default to SAI entry which takes 64 bits. */
    pCtl->step = 2;

    
    /* Change to corresponding root DB directory. */
    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE) 
    {   
        pCtl->free = TRUE;      
        return DB_INVALID_HDL;
    }

    
    /* Open SAI file. */
    pCtl->idxfile = FAT_fopen(DB__name(id, SAI), rb);

    /* Check SAI file signature for safe. */
    FAT_fread(pCtl->idxfile, (unsigned short *)&signature, 2);

    if( signature != DB_SAI_SIGNATURE ) 
    {
        /* Invalid field access. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        return DB_INVALID_HDL;
    }
    

    /* Check if dbEntry is valid. */
    FAT_fseek(pCtl->idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
    FAT_fread(pCtl->idxfile, &entryNum, 1);
    pInfo->numOfSAIent = entryNum;
    if((long)entryNum <= (long)dbEntry)
    {
        /* Invalid entry. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        return DB_INVALID_HDL;
    }


    /* Add signature entry offset and remember current position. */
    pCtl->idx = (long)DB_SAIFIRSTENTRY<<2;

    /* Read back the entry pointer. */
    FAT_fseek(pCtl->idxfile, (long)(dbEntry + DB_SAIFIRSTENTRY)<<2, SEEK_HEAD);
    FAT_fread(pCtl->idxfile, (unsigned short *)&mdb, 2);

    /* Read back the pai pointer. */
    FAT_fread(pCtl->idxfile, (unsigned short *)&pCtl->pai, 2);
    
    if( mdb == 0) 
    {       
        /* Empty DB. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        return DB_INVALID_HDL;
    }

    /* Open MDB file. */
    pCtl->dbfile = FAT_fopen(DB__name(id, MDB), rb);
        
    /* Locate the record. */
    FAT_fseek(pCtl->dbfile, mdb, SEEK_HEAD);
    
    if(pD)
    {
        *(USHORT*)pD++ = mdb>>16;
        *(USHORT*)pD++ = mdb&0xffff;
    }
    
    /* Fetch record. */
    if( DB__getRecord(pCtl->dbfile, pD) == FALSE ) 
    {       
        /* No record available. */
        pCtl->free = TRUE;
        FAT_fclose(pCtl->idxfile);
        FAT_fclose(pCtl->dbfile);
        return DB_INVALID_HDL;
    }

    return hdl;
}


#pragma CODE_SECTION (DB_mount, ".dbinit_code")
DB_ID DB_mount(const DB_FNAME name)
{
    // CD to corresponding sub-directory.
    if(DB__cdDBdir(name) == FALSE ) return DB_INVALID_ID;

    return( DB__register(name, NULL, NULL) );
}

#pragma CODE_SECTION(DB_insertRecord, ".db_code")
BOOL DB_insertRecord(DB_ID id, const DB_DATA * pData)
{
    st_DBINFO       info;
    st_DBDINODE *   node;                   /* DB insertion node. */
    st_DBDINODE     ditree[DB_MAXDBNODES];  /* DB insertion tree  */
    DB_ENTRY        entry;
    DB_PAIOFFSET    pai;
    DB_MDBOFFSET    mdb;
    File *          dbfile;

    /* Check DB attributes for safe. */
    if( DB__info(id, &info) == FALSE ) return FALSE;
    if( !(info.attribute & DB_ROOT) ) 
    {
        /* Insertion can only be applied to root DB. */
        return FALSE;       
    }


    /* Initialize root node. */
    ditree[0].parent =
    ditree[0].prev = NULL;
    
    /* Copy DB node tree over. */
    _copyTree(ditree, &DB_idtree.node[id]);


    /* Form DB insertion data tree. */
    _formDataTree(ditree, pData);


    /* First to check if record already exists. */
    if( DB__recordPosition(id, &entry, *(unsigned short **)pData, FALSE) == TRUE ) 
    {       
        /* Record already exists, error. */
        return FALSE;
    }


    /* Always append to the end of MDB file. Let's check MDB file size. */
    dbfile = FAT_fopen(DB__name(id, MDB), rb);
    mdb = dbfile->size;
    FAT_fclose(dbfile);


    /* Insert record to root SAI. */
    pai = 0L;

    /* Add entry to SAI file. */
    DB__addSAIentry(id, entry, mdb, pai);

    
    /* Set up parent MDB offset. */
    ditree[0].mdb = mdb;


    /* Update all related children database. */
    if( info.numOfKeys > 1) 
    {
        /* Children available, let's do it. */  
        node = ditree[0].child;
        
        while(node->next)
        {
            _insert2child(node->next);
            node = node->next;
        }
    }


    /* Finally, write root DB data. */

    dbfile = FAT_fopen(DB__name(id, MDB), ab);
    FAT_fwrite(dbfile, (unsigned short *)ditree[0].data, ditree[0].len);
    FAT_fclose(dbfile);
    
    return TRUE;    
}

#pragma CODE_SECTION(_copyTree, ".db_code") 
static st_DBDINODE * _copyTree(st_DBDINODE * pDstTree, const st_DBIDNODE * pSrcTree)
{
    st_DBDINODE * next = pDstTree + 1;

    pDstTree->id = pSrcTree->id;

    /* Check if children present. */
    if ( pSrcTree->child ) 
    {
        pDstTree->child = next;
        next->parent = pDstTree;
        next->prev = NULL;
        next = _copyTree(next, pSrcTree->child );
    }
    else pDstTree->child = NULL;


//DeepB
//Enable recursive parsing of tree nodes
#ifndef USE_DATABASE_HACKS  /* Following code will eat up memory very quickly. */

    /* Check if next node present. */
    if ( pSrcTree->next ) 
    {
        pDstTree->next = next;
        next->prev = pDstTree;
        next->parent = pDstTree->parent;
        next = _copyTree(next, pSrcTree->next );
    }
    else pDstTree->next = NULL;

#else   /* Alternative to save memory. */

    /* Check if next node present. */
    while ( pSrcTree->next ) 
    {
        pDstTree->next = next;
        next->prev = pDstTree;
        next->parent = pDstTree->parent;

        pDstTree = next;

        next++;
        pSrcTree = pSrcTree->next;

        /* Do NOT process sub-children, KNOWN PROBLEM.
        if ( pSrcTree->child ) 
        {
            pDstTree->id = pSrcTree->id;
            pDstTree->child = next;

            next->parent = pDstTree;
            next->prev = NULL;
            next = _copyTree(next, pSrcTree->child );
        }
        else
        */
        {
            pDstTree->id = pSrcTree->id;
            pDstTree->child = NULL;         
        }
    }

    pDstTree->next = NULL;
#endif

    return(next);
}

#pragma CODE_SECTION(_formDataTree, ".db_code")
static const DB_DATA * _formDataTree(st_DBDINODE * pTree, const DB_DATA * pData)
{
    unsigned short ** p;

    p = (unsigned short **)pData;
    
    pTree->data = *p;   
    pTree->len = DB__recordLen(*p);

    p++;

    /* First check children. */
    if ( pTree->child ) 
    {
        p = (unsigned short **)_formDataTree(pTree->child->next, p);
    }
    
    /* Check siblings. */
    while( pTree->next )
    {
        pTree = pTree->next;
        pTree->data = *p;
        pTree->len = DB__recordLen(*p);

        p++;

        if(pTree->child)
        {
            p = (unsigned short **)_formDataTree(pTree->child->next, p);
        }
    }   

    return ((const DB_DATA *)p);    
}
#pragma CODE_SECTION(DB__compare, ".db_code")
short DB__compare(const DB_DATA * pRecord1, const DB_DATA * pRecord2)
{
    const unsigned short *  p1;
    const unsigned short *  p2;
    unsigned short          value1;
    unsigned short          value2;
#ifdef SPECIAL_CHAR_FIX
    unsigned short byte1H, byte1L, byte2H, byte2L;
#endif

    p1 = (const unsigned short *) pRecord1;
    p2 = (const unsigned short *) pRecord2;

    while( 1 ) 
    {
        if(*p1 == DB_ESCCHAR) p1++;     
        if(*p2 == DB_ESCCHAR) p2++;

        if( (*p1 == DB_RECDLMT) || (*p1 == DB_FLDDLMT) )
        {       
            if( (*p2 == DB_RECDLMT) || (*p2 == DB_FLDDLMT) ) return 0;
            else                                             return -1;
        }

        if( (*p2 == DB_RECDLMT) || (*p2 == DB_FLDDLMT) )
        {       
            if( (*p1 == DB_RECDLMT) || (*p1 == DB_FLDDLMT) ) return 0;
            else                                             return 1;
        }

#ifdef SPECIAL_CHAR_FIX
        byte1L = *p1 & 0xFF;
        if ( byte1L < TABLE_SIZE ) byte1L = _2lower(byte1L);        
        byte1H = (*p1 >> 8) & 0xFF;
        
        if ( byte1H < TABLE_SIZE ) byte1H = _2lower(byte1H);
        value1 = (byte1H<<8) | byte1L;
        
        byte2L = *p2 & 0xFF;
        if ( byte2L < TABLE_SIZE ) byte2L = _2lower(byte2L);
        byte2H = (*p2 >> 8) & 0xFF;

        if ( byte2H < TABLE_SIZE ) byte2H = _2lower(byte2H);
        value2 = (byte2H<<8) | byte2L;
#else
        value1 = _2lower(*p1);          
        value2 = _2lower(*p2);
#endif
        
        if(value1 > value2)      return 1;
        else if(value1 < value2) return -1;
        else 
        {
            /* Points to next data. */
            p1++;
            p2++;
        }
    }
}

#pragma CODE_SECTION(DB__insert2leaf, ".db_code")
DB_MDBOFFSET DB__insert2leaf(   DB_ID               id, 
                                DB_ID               parentId,
                                DB_MDBOFFSET        parentMdb,                           
                                const DB_DATA *     pParentRecord,
                                const DB_DATA *     pRecord,                             
                                DB_RECLEN           len,
                                BOOL                bAlwaysInsert)
{
    DB_MDBOFFSET    leafMdb;
    DB_MDBOFFSET    leafPai;
    DB_PAIOFFSET    newPaiStart;
    DB_PAIOFFSET    newPai;
    DB_ENTRY        entry;
    DB_PAIOFFSET    rdStart;
    unsigned short  moduleLen;
    
    union 
    {       
        unsigned short      field[DB_MAXFIELDLEN];
        
        struct 
        {
            unsigned short  pai[DB_MINPAILEN];
            unsigned short  clear[DB_MINPAILEN];
        } pai;  
    } buf;

    DB_PAIOFFSET    paiOffset;
    st_DBPAICTL     control;
    unsigned short  ii;
    File *          idxfile;
    File *          dbfile;
    
    /* First round, check if record already exists. */
    if( DB__recordPosition(id, &entry, pRecord, FALSE) == FALSE)
    {
        /* Record does not exits, append to MDB file. */
        dbfile = FAT_fopen(DB__name(id, MDB), ab);
        
        leafMdb = dbfile->size;
        FAT_fwrite(dbfile, (unsigned short *)pRecord, len);
        FAT_fclose(dbfile);

        /* Create a new entry to PAI file. */
        leafPai = _createPAIentry(id, parentMdb);

        /* Add entry to SAI file. */
        DB__addSAIentry(id, entry, leafMdb, leafPai);

        return leafMdb;
    }


    /* Record exists, all we need to do here is to update the
    ** PAI entry if it exists, or create new PAI if it does not 
    ** exist.
    */

    /* Fetch PAI entry index. */
    idxfile = FAT_fopen(DB__name(id, SAI), r_b);
    
    FAT_fseek(idxfile, ((unsigned long)entry << 2), SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&leafMdb, 2);
    FAT_fread(idxfile, (unsigned short *)&leafPai, 2);

    if( leafPai == 0L ) 
    {
        /* PAI does not exist, add a new entry to PAI file. */
        leafPai = _createPAIentry(id, parentMdb);
            
        /* Update PAI entry in SAI file. */
        FAT_fseek(idxfile, -2, SEEK_MID);
        FAT_fwrite(idxfile, (unsigned short *)&leafPai, 2);
        FAT_fclose(idxfile);

        return leafMdb;
    }
    FAT_fclose(idxfile);
    
    
    /* Record exists and SAI contains a valid PAI entry. We'll check
    ** to insert into the existed PAI module. 
    */
    if( bAlwaysInsert == FALSE ) 
    {
        /* Check to see if PAI already exists. */
        if( _checkPAI(id, leafPai, parentMdb) )
        {                   
            /* Everything matches, do NOT update. */
            return leafMdb;
        }
    }

    
    /* Now to check PAI entry number to see if a new module needs to 
    ** be created.
    */

    /* Read back control data of the current module. */
    idxfile = FAT_fopen(DB__name(id, PAI), r_b);
    
    /* Points to control data. */
    FAT_fseek(idxfile, leafPai - sizeof(st_DBPAICTL), SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&control, sizeof(st_DBPAICTL));

    paiOffset = 
    newPai = leafPai;           

            
    if(control.entryNum == ( (control.dlen - sizeof(st_DBPAICTL) - 2)>>1 ) )
    {
        /* Entry full, free this entry and move it to the end of file.
        **
        ** NOTE:
        **      There might be a TRAP here, ideally we need to search
        **      throught the PAI to see if there is any available entry
        **      with a size bigger than the current one. Here we just
        **      choose not to search and directly create a new moudle
        **      at the end of the PAI file. 
        */

        /* Set up PAI clear buffer. */
        for(ii = 0; ii < DB_MINPAILEN; ii++) buf.pai.clear[ii] = 0;
        
        newPaiStart = idxfile->size;

        /* Check if current module is at the file end. If it is, we'll expand
        ** current module instead of allocating a new one.
        */  
        if(newPaiStart == leafPai - sizeof(st_DBPAICTL) + control.dlen)
        {
            /* At the end of the file. */           
            control.dlen += DB_MINPAILEN;

            /* Update module length before moving it. */
            FAT_fseek(idxfile, -(long)sizeof(st_DBPAICTL), SEEK_MID);
            FAT_fwrite(idxfile, (unsigned short *)&control.dlen, 1); 

                    
            /* Clear all the newly-added entries. */
            FAT_fseek(idxfile, newPaiStart, SEEK_HEAD);
            FAT_fwrite(idxfile, buf.pai.clear, DB_MINPAILEN);
        }

        else
        {
            /* We'll have to allocate a new module. To prevent PAI
            ** file gets too much fragmented, set up a flag here to
            ** do defragmentation( NOT SUPPORTED. ). 
            */
            paiOffset = 
            newPai    = newPaiStart + sizeof(st_DBPAICTL);;

            FAT_fseek(idxfile, leafPai - sizeof(st_DBPAICTL), SEEK_HEAD);

            /* Read back first block. */
            FAT_fread(idxfile, buf.pai.pai, DB_MINPAILEN);
            FAT_fseek(idxfile, (long)(-DB_MINPAILEN), SEEK_MID);

            /* Mark this module to be free. */
            buf.pai.clear[0] = control.dlen;
            buf.pai.clear[1] = PAI_FREE;


            FAT_fwrite(idxfile, buf.pai.clear, DB_MINPAILEN);


            /* Restore clear buffer. */
            buf.pai.clear[0] = 0;
            buf.pai.clear[1] = 0;


            /* Sets up new entry length. */
            buf.pai.pai[0] = control.dlen + DB_MINPAILEN;

            /* Reserve control.dlen. */
            moduleLen = buf.pai.pai[0];


            /* To use the same code as that of direct insertion. We'll 
            ** NOT update the entry number here. 
            */
            //buf.pai.pai[2] = control.entryNum + 1;

            FAT_fseek(idxfile, newPaiStart, SEEK_HEAD);
            FAT_fwrite(idxfile, buf.pai.pai, DB_MINPAILEN);

            newPaiStart += DB_MINPAILEN;

            rdStart = leafPai - sizeof(st_DBPAICTL) + DB_MINPAILEN;

            control.dlen -= DB_MINPAILEN;               
                    
            while(control.dlen)
            {
                FAT_fseek(idxfile, rdStart, SEEK_HEAD);
                FAT_fread(idxfile, buf.pai.pai, DB_MINPAILEN);

                FAT_fseek(idxfile, (long)(-DB_MINPAILEN), SEEK_MID);
                FAT_fwrite(idxfile, buf.pai.clear, DB_MINPAILEN);

                FAT_fseek(idxfile, newPaiStart, SEEK_HEAD);
                FAT_fwrite(idxfile, buf.pai.pai, DB_MINPAILEN);

                rdStart      += DB_MINPAILEN;
                newPaiStart  += DB_MINPAILEN;

                control.dlen -= DB_MINPAILEN;
            }

            FAT_fseek(idxfile, newPaiStart, SEEK_HEAD);
            FAT_fwrite(idxfile, buf.pai.clear, DB_MINPAILEN);
            FAT_fclose(idxfile);

            /* Update the SAI file. */
            idxfile = FAT_fopen(DB__name(id, SAI), r_b);
            FAT_fseek(idxfile, ((unsigned long)entry<<2) + 2, SEEK_HEAD);
            FAT_fwrite(idxfile, (unsigned short *)&newPai, 2);
            FAT_fclose(idxfile);

            /* Restore control.dlen. */
            control.dlen = (unsigned short)moduleLen;


            /* Reopen the PAI file. */
            idxfile = FAT_fopen(DB__name(id, PAI), r_b);
        }
    }

    /* Let's insert the record PAI here. */

    /* Update entryNum first. */
    FAT_fseek(idxfile, newPai - sizeof(st_DBPAICTL) + 2, SEEK_HEAD);

    control.entryNum++;

    FAT_fwrite(idxfile, (unsigned short *)&control.entryNum, 1); 
    
    // If add2child, always append.
    if( bAlwaysInsert == FALSE ) 
    {
        // This has to be an insertion to root DB.
        dbfile = FAT_fopen(DB__name(parentId, MDB), rb);
        
        /* Check to insert. */
        FAT_fseek(idxfile, newPai, SEEK_HEAD);

        while(1)
        {
            FAT_fread(idxfile, (unsigned short *)&rdStart, 2);
    
            if(rdStart == 0L) break;
    
            FAT_fseek(dbfile, rdStart, SEEK_HEAD);
            FAT_fread(dbfile, buf.field, DB_MAXFIELDLEN);
    
            if(DB__compare(buf.field, pParentRecord) < 0)
            {
                newPai += 2;
            }
            else break;
        }
    
        FAT_fclose(dbfile);
    }
    else  newPai += (control.entryNum-1)*2; // Append.
    
    FAT_finsert(idxfile, newPai, 
                (unsigned short *)&parentMdb, 2, 
                paiOffset + control.dlen - sizeof(st_DBPAICTL) );
                
    FAT_fclose(idxfile);
    
    return(leafMdb);
}

#pragma CODE_SECTION(DB__addChildIdx, ".db_code")
BOOL DB__addChildIdx(DB_DATA *      pRecord, 
                     DB_FIELDIDX    fldidx, 
                     DB_MDBOFFSET   childMdb)
{
    unsigned short      ii;
    DB_RECLEN           len;
    BOOL                bFOUND;
    unsigned short *    pD;
    unsigned short *    pT;
    unsigned short *    pS;
    unsigned long       mdb;
    unsigned short      buf[4];
    
    pD = DB__locateField(pRecord, fldidx);
    len = DB__recordLen(pRecord);
    
    bFOUND = FALSE;
    while(1)
    {
        if(*pD == DB_ESCCHAR) pD++;
        else if( (*pD==DB_RECDLMT) ||(*pD==DB_FLDDLMT) )  break;
        
        mdb = (unsigned long)(*pD++)<<16;       
        
        if(*pD == DB_ESCCHAR) pD++;     
        else if( (*pD==DB_RECDLMT) ||(*pD==DB_FLDDLMT) )  break;
        
        mdb |= (unsigned long)(*pD);

        if( mdb == childMdb) return TRUE;
        
        else if( (mdb == 0L)&&(bFOUND == FALSE) )
        {
            pT = pD-1;
            bFOUND = TRUE;
        }
            
        pD++;
    }
    
    
    pS = buf;
    ii = (unsigned long)childMdb>>16;
    if( (ii == DB_FLDDLMT)||(ii == DB_RECDLMT)||(ii == DB_BAGDLMT)||(ii == DB_ESCCHAR) ) 
    {
        *pS++ = DB_ESCCHAR;
    }
    *pS++ = ii;
    ii = childMdb&0x0ffff;
    if( (ii == DB_FLDDLMT)||(ii == DB_RECDLMT)||(ii == DB_BAGDLMT)||(ii == DB_ESCCHAR) ) 
    {
        *pS++ = DB_ESCCHAR;
    }
    *pS++ = ii;
    ii = pS-buf;
    
    if( (bFOUND == TRUE)&&(ii == 2) )
    {
        *pT++ = (unsigned long)childMdb>>16;
        *pT   = childMdb&0x0ffff;
        return TRUE;
    }
    
    // Insert to end of field anyway.
    memmove( pD+ii, pD, len-(pD -(unsigned short *)pRecord)+1);
    pS = buf;
    while(ii--) *pD++ = *pS++;

    return TRUE;    
}

#pragma CODE_SECTION(_insert2child, ".db_code")
static BOOL _insert2child(st_DBDINODE * node)
{
    DB_MDBOFFSET    childMdb;
    DB_ENTRY        entry;
    DB_FIELDIDX     fldidx;
    st_DBDINODE *   tmpNode;
    File *          file;

    if(node->child)
    {       
        /* Parent MDB offset value shall be set here. */

        /* First to check if record already exists. */
        if( DB__recordPosition(node->id, &entry, node->data, FALSE) == TRUE ) 
        {       
            /* Record already exists. */
            file = FAT_fopen(DB__name(node->id, SAI), rb);
            FAT_fseek(file, (long)entry<<2, SEEK_HEAD);
            FAT_fread(file, (unsigned short *)&node->mdb, 2);
            FAT_fclose(file);
        }
        else
        {
            /* Record does not exist. */
            file = FAT_fopen(DB__name(node->id, MDB), rb);
            
            /* New record always gets appended to the end of file. */
            node->mdb = file->size;
            FAT_fclose(file);
        }

        tmpNode = node->child;
        
        while(tmpNode->next)
        {       
            _insert2child(tmpNode->next);
            tmpNode = tmpNode->next;
        }

        // All its children have been processed, now to process child DB itself. 
        childMdb = DB__insert2leaf( node->id, 
                                    node->parent->id,
                                    node->parent->mdb,
                                    node->parent->data,
                                    node->data,
                                    node->len,
                                    FALSE);

        fldidx = DB__fieldIndex(node->id);

        /* Update parent field value. */
        DB__addChildIdx(node->parent->data, fldidx, childMdb);
    }
    else
    {
        /* DB does not have any children, insert it. */
        childMdb = DB__insert2leaf( node->id, 
                                    node->parent->id,
                                    node->parent->mdb,
                                    node->parent->data,
                                    node->data,
                                    node->len,
                                    FALSE);

        fldidx = DB__fieldIndex(node->id);
        

        /* Update parent field value. */
        DB__addChildIdx(node->parent->data, fldidx, childMdb);

        /* Check to reset parent record data length. */
        node->parent->len = DB__recordLen(node->parent->data);
    }
    
    return TRUE;    
}


#pragma CODE_SECTION(DB_init, ".dbinit_code")
BOOL DB_init(void)
{
    unsigned short      ii;
    
    /* Clear database regisration table. */
    for ( ii = 0; ii < DB_MAX_ID; ii++ ) DB_registration[ii].fname = NULL;
    
    /* Reset database ID tree. */
    DB_idtree.counter = 0;  

    /* Reset all available query controls. */
    for( ii = 0; ii < DB_OPENMAX; ii++ ) DB_qctl[ii].free = TRUE;

    /* Initialize DB tree globale controls. */  
    //DB_ctl.actvHdl = DB_INVALID_HDL;
    
    return TRUE;
}


#pragma CODE_SECTION(DB_info, ".db_code")
#if 1
st_DBINFO * DB_info(DB_HDL hdl)
{
    return(&DB_qinfo[hdl]);
}

#else
BOOL DB_info(DB_ID id, st_DBINFO * pInfo)
{
    File *          file;
    
    pInfo->id = id;
    
    /* Check to see if id points to a virtual DB. */
    if( DB_registration[id].fname == NULL ) 
    {
        pInfo->bVirtual = TRUE;
        
        /* Virtual DB, access through its parent. */
        id = DB_idtree.node[id].parent->id;
    }
    else pInfo->bVirtual = FALSE;
    
    
    if( DB__info(id, pInfo) == TRUE )
    {
        /* Read back SAI entry number. */
        if( (file = FAT_fopen(DB__name(id, SAI), rb) ) == NULL ) return FALSE;

        FAT_fseek(file, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);   
        FAT_fread(file, &pInfo->numOfSAIent, 1);
        FAT_fclose(file);
        return TRUE;
    }
    else return FALSE;
}
#endif


#pragma CODE_SECTION(DB__info, ".db_code")
BOOL DB__info(DB_ID id, st_DBINFO * pInfo)
{
    File *              file;
    st_DBHEADER         header;
    unsigned long       signature;      

    #if 1
    pInfo->id = id;
    
    /* Check to see if id points to a virtual DB. */
    if( DB_registration[id].fname == NULL ) 
    {
        pInfo->bVirtual = TRUE;
        
        /* Virtual DB, access through its parent. */
        id = DB_idtree.node[id].parent->id;
    }
    else pInfo->bVirtual = FALSE;
    #endif
    
    // Change to corresponding root DB directory. all files contained
    // in this directory.
    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE)   return FALSE;
    
    if( (file = FAT_fopen(DB__name(id, MDB), rb) ) == NULL ) return FALSE;
    
    if( FAT_fread(file, (unsigned short *)&header, sizeof(st_DBHEADER)) 
            != sizeof(st_DBHEADER) ) RETURN_ERROR;

    FAT_fseek(file, header.len - 2, SEEK_HEAD);
    FAT_fread(file, (unsigned short *)&signature, 2);

    /* Check signature here for safe. */
    if( signature != DB_HEADER_SIGNATURE ) RETURN_ERROR;

    /* Copy information over. */
    pInfo->attribute = header.attribute;
    pInfo->numOfFields = header.numOfFields;
    pInfo->numOfKeys = header.numOfKeys;
    pInfo->status = header.status;
    pInfo->ptrXIM = ((long)header.ptrXIMhi<<16)|header.ptrXIMlo;
    
    FAT_fclose(file);   

    return TRUE;    
}

#pragma CODE_SECTION(DB_childID, ".db_code")
DB_ID DB_childID(DB_ID rootID, DB_FIELDIDX fldIdx)
{
    st_DBIDNODE * node;

    node = &DB_idtree.node[rootID];
    
    node = node->child;
    while(fldIdx--)
    {
        node = node->next;
    }
    
    return node->id;    
}

#pragma CODE_SECTION(DB_parentID, ".db_code")
DB_ID DB_parentID(DB_ID id)
{
    st_DBIDNODE * node;

    node = &DB_idtree.node[id];
    
    /* Traverse to parent. */
    if(node->parent) node = node->parent;
    
    return node->id;    
}

#pragma CODE_SECTION(DB__rootID, ".db_code")
DB_ID DB__rootID(DB_ID id)
{   
    st_DBIDNODE * node;

    node = &DB_idtree.node[id];
    
    /* Traverse to root. */
    while(node->parent) node = node->parent;
    
    return node->id;    
}

#pragma CODE_SECTION(DB_getSaiByMdb, ".db_code")
DB_ENTRY DB_getSaiByMdb(ULONG mdb, DB_ID id)
{
    File *          idxfile;
    unsigned long   signature;
    DB_ENTRY        entry;
    unsigned short  entryNum;
    ULONG           mdbEnt[2];
    
    /* Change to corresponding root DB directory. */
    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE) 
    {   
        return DB_INVALID_ENTRY;
    }

    
    /* Open SAI file. */
    idxfile = FAT_fopen(DB__name(id, SAI), rb);

    /* Check SAI file signature for safe. */
    FAT_fread(idxfile, (unsigned short *)&signature, 2);

    if( signature != DB_SAI_SIGNATURE ) 
    {
        /* Invalid field access. */
        FAT_fclose(idxfile);
        return DB_INVALID_ENTRY;
    }
    

    /* Check if dbEntry is valid. */
    FAT_fseek(idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
    FAT_fread(idxfile, &entryNum, 1);

    FAT_fseek(idxfile, (unsigned long)(DB_SAIFIRSTENTRY)<<2, SEEK_HEAD);
    entry = 0;
    while(entryNum--)
    {
        FAT_fread(idxfile, (unsigned short *)&mdbEnt, 4);
        if(mdbEnt[0] == mdb) 
        {
            FAT_fclose(idxfile);
            return entry;
        }
        entry++;
    }
    
    FAT_fclose(idxfile);
    return DB_INVALID_ENTRY;    
}

#pragma CODE_SECTION(DB_getMdbByRecord, ".db_code")
DB_MDBOFFSET DB_getMdbByRecord(DB_ID id, const unsigned short * pData)
{
    unsigned short  field[DB_MAXFIELDLEN];
    DB_ENTRY        entry;          /* SAI entry number. */
    DB_MDBOFFSET    offset;         /* File offset in MDB file. */
    File *          idxfile;
    File *          dbfile;

    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE)   return 0;
    
    /* Open MDB and SAI files. */
    idxfile = FAT_fopen(DB__name(id, SAI), rb);
    dbfile  = FAT_fopen(DB__name(id, MDB), rb);
    
    
    /* Points to the first valid entry. */
    entry = DB_SAIFIRSTENTRY;


    /* SAI entry takes 64bits, 4 words per entry. */
    FAT_fseek(idxfile, (long)entry << 2, SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&offset, 2);

    while(offset)
    {
        unsigned short len;
        
        FAT_fseek(dbfile, offset, SEEK_HEAD);
        FAT_fread(dbfile, field, DB_MAXFIELDLEN);

        /* Only compare the primary field. */
        if(len = DB__getField(field, 0, field))
        {
            unsigned short * pS = (unsigned short *)field;
            unsigned short * pD = (unsigned short *)pData;
            do
            {
                if(*pS++ != *pD++) break;
        
            } while(--len);
            
            if( 0 == len )
            {
                /* Record found!. */
                FAT_fclose(idxfile);
                FAT_fclose(dbfile);
    
                return offset;
            }
        }

        entry++;

        /* Skip PAI entry. */
        FAT_fseek(idxfile, 2, SEEK_MID);            
        FAT_fread(idxfile, (unsigned short *)&offset, 2);
    }


    /* Record does not exist. */
    FAT_fclose(idxfile);
    FAT_fclose(dbfile);

    // Not found.
    return 0L;  
}
#pragma CODE_SECTION(DB_getField, ".db_code")

DB_FIELDLEN DB_getField(    const DB_DATA * pRecord, 
                            DB_FIELDIDX     fldIdx, 
                            DB_DATA *       pData,
                            st_DBINFO *     pInfo)
{
    st_DBIDNODE *       node;
    DB_ID               tmpid;
    DB_MDBOFFSET        childMdb;
    File *              file;
    unsigned short      ii;
    unsigned short      record[DB_MAXRECLEN];
    
    if(NULL == pData) return 0;
    
    ii = DB__getField(pRecord, fldIdx, pData);
    
    if( (0==fldIdx)||(0==ii)||(fldIdx >= pInfo->numOfKeys) ) return ii;
    
    // Currently only the first child MDB in field is fetched, this is 
    // definitely a hole in algorithm, since there might be more than
    // one there. I simply don't worry about it now because this
    // feature is not used anyway.
    childMdb = ((unsigned long)(*(unsigned short *)pData)<<16)|(*((unsigned short *)pData+1));
    
    // Virtual DB, no data available.
    //if(pInfo->bVirtual == TRUE) return 0; 
    
    /* Get field DB id. */
    //node = DB_idtree.node[pInfo->id].child; 
    node = DB_idtree.node[DB_rootID(pInfo->id)].child; 
    for(ii = 0; ii < fldIdx; ii++ ) node = node->next;
    
    tmpid = node->id;

    DB__cdDBdir(DB__name(DB__rootID(tmpid), MDB));
    
    /* Open child DB MDB file. */
    file = FAT_fopen(DB__name(tmpid, MDB), rb);

    /* Seek to offset. */
    FAT_fseek(file, childMdb, SEEK_HEAD);
    
    DB__getRecord(file, record);
    FAT_fclose(file);

    return( DB__getField(record, 0, pData) );
}


#pragma CODE_SECTION(DB__getField, ".db_code")
DB_FIELDLEN DB__getField(   const DB_DATA * pRecord, 
                            DB_FIELDIDX     fldIdx, 
                            DB_DATA *       pData)
{
    const unsigned short *  pSrc;
    unsigned short *        pDst;
    
    pSrc = (const unsigned short *)DB__locateField(pRecord, fldIdx); 
    
    if( NULL == pSrc )
    {       
        /* Unable to locate the specified field. */
        return 0;
    }

    
    if( (*pSrc == DB_RECDLMT)||(*pSrc == DB_FLDDLMT) )
    {       
        /* Empty record. */
        return 0;
    }


    pDst = (unsigned short *)pData;
    /* Start to fetch field. */
    while(1) 
    {
        if( *pSrc == DB_ESCCHAR) 
        {
            pSrc++;
            *pDst++ = *pSrc++;
        }
        else{
            *pDst++ = *pSrc++;
        }

        if( (*pSrc == DB_RECDLMT)||(*pSrc == DB_FLDDLMT) ) break;
    }
    
    return (pDst - (unsigned short *)pData);
}

#pragma CODE_SECTION(DB_dspData, ".db_code")
DB_DSPDATALEN DB_dspData(DB_ID id, DB_DSPDATA pData, DB_DSPDATAIDX idx )
{
    File *          file;
    unsigned long   pName;
    unsigned short  len;

    /* Change to corresponding root DB directory. */
    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE) return 0;   

    /* Check to see if id points to a virtual DB. */
    if( DB_registration[id].fname == NULL ) 
    {
        /* Virtual DB, access through its parent. */
        id = DB_idtree.node[id].parent->id;
    }

    if( (file = FAT_fopen(DB__name(id, MDB), rb) ) == NULL ) return 0;


    FAT_fseek(file, DB_PNAME_OFFSET + ((long)idx << 2), SEEK_HEAD);
    FAT_fread(file, (unsigned short *)&pName, 2);
    
    FAT_fseek(file, pName, SEEK_HEAD);
    FAT_fread(file, pData, 1);
    
    len = *pData;
    FAT_fread(file, pData, len);
    
    FAT_fclose(file);
    
    return len; 
}
//#pragma CODE_SECTION(DB_deleteRecord, ".db_code")
#pragma CODE_SECTION(DB_deleteRecord, ".sram0_resident")
BOOL DB_deleteRecord(DB_ID id, DB_ENTRY entry)
{
    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE)   return FALSE;
    return DB__deleteChildRecord(id, entry);
}

#pragma CODE_SECTION(DB_deleteRecordByMdb, ".db_code")
BOOL DB_deleteRecordByMdb(DB_ID id, DB_MDBOFFSET mdb)
{
    DB_MDBOFFSET offset;
    USHORT      entryNum;
    DB_ENTRY    entry = 1;
    File *      idxfile;
    BOOL        ret = FALSE;

    if(DB__cdDBdir(DB__name(DB__rootID(id), MDB)) == FALSE)   return FALSE;
    
    // Fetch entry number from SAI file.
    idxfile = FAT_fopen(DB__name(id, SAI), rb);
    FAT_fseek(idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
    FAT_fread(idxfile, &entryNum, 1);

    FAT_fseek(idxfile, (unsigned long)(1+DB_SAIFIRSTENTRY)<<2, SEEK_HEAD);
    while(entryNum--)
    {
        if(2!=FAT_fread(idxfile, (unsigned short *)&offset, 2)) break;
        if(mdb == offset)
        {
            ret = TRUE;
            break;
        }
        // Skip the PAI entry.
        if(2!=FAT_fread(idxfile, (unsigned short *)&offset, 2)) break;
        
        entry++;
    }
    FAT_fclose(idxfile);
    
    if(TRUE == ret) return DB__deleteChildRecord(id, entry);
    
    return FALSE;
}

#pragma CODE_SECTION(DB__deleteChildRecord, ".db_code")
BOOL DB__deleteChildRecord(DB_ID id, DB_ENTRY entry)
{
    DB_ID           childID;
    st_DBIDNODE *   node;
    DB_MDBOFFSET    offset;
    DB_PAIOFFSET    pai;
    unsigned short  entryNum;
    unsigned short  entryLeft;
    File *          idxfile;
    File *          dbfile;
    DB_SAIOFFSET    sai;
    DB_FIELDIDX     fldidx;
    USHORT          fldlen;
    USHORT          usTmp, usLen;
    USHORT          buf[DB_MAXRECLEN];
    unsigned long   fld[32];// Assuming that one field could hold up to
                            // 32 valid offset values.

    // Get MDB offset from SAI file.
    idxfile = FAT_fopen(DB__name(id, SAI), r_b);
    FAT_fseek(idxfile, (unsigned long)(entry+DB_SAIFIRSTENTRY)<<2, SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&offset, 2);

    // Remove SAI entry.
    FAT_fseek(idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
    FAT_fread(idxfile, &entryNum, 1);

    DB_assert(entryNum, DB__DELETECHILDRECORD);
    
    /* Decrement entry number. */
    FAT_fseek(idxfile, -1, SEEK_MID);
    entryNum--;
    FAT_fwrite(idxfile, &entryNum, 1);  
    
    /* Process the rest of the entries. */
    usTmp = (unsigned long)(entryNum - entry)<<2;
    FAT_fseek(idxfile, (unsigned long)(entry + DB_SAIFIRSTENTRY) << 2, SEEK_HEAD);  
    while(usTmp)
    {       
        /* Skip the current entry which should be deleted. */
        FAT_fseek(idxfile, 4, SEEK_MID);

        if(usTmp > DB_MAXRECLEN )   usLen = DB_MAXRECLEN;
        else                        usLen = (unsigned short)usTmp;

        FAT_fread(idxfile, (unsigned short *)buf, usLen);
        FAT_fseek(idxfile, (long)((long)(-4) - usLen ), SEEK_MID);
        FAT_fwrite(idxfile, (unsigned short *)buf, usLen);
        usTmp -= usLen;     
    }

    buf[0] = buf[1] = buf[2] = buf[3] = 0;

    /* Zero out last entry. */
    FAT_fwrite(idxfile, (unsigned short *)buf, 4);
    FAT_fclose(idxfile);

    /* Mark entry as deleted. */
    dbfile = FAT_fopen(DB__name(id, MDB), r_b);

    // Read back the entire record here.
    FAT_fseek(dbfile, offset, SEEK_HEAD);
    DB__getRecord(dbfile, (DB_DATA *)buf);

    FAT_fseek(dbfile, offset, SEEK_HEAD);
    FAT_fread(dbfile, (unsigned short *)&usTmp, 1);
    usTmp |= RECORD_DELETED;
    FAT_fseek(dbfile, -1, SEEK_MID);
    FAT_fwrite(dbfile, (unsigned short *)&usTmp, 1);
    FAT_fclose(dbfile);


    /* Check all the children database. */
    node = &DB_idtree.node[id];
    fldidx = 0;

    if(node->child)
    {
        node = node->child;
        
        while(node->next)
        {
            node = node->next;
            childID = node->id;

            fldidx++;
            
            fldlen = DB__getField(buf, fldidx, fld)>>1;
            
            // Sort all SAIs in field if any.
            _sortSAI(fld, fldlen);
            
            idxfile = FAT_fopen(DB__name(childID, SAI), rb);            
            FAT_fseek(idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
            FAT_fread(idxfile, &entryNum, 1);

            // Note that entry has to be checked from the end of file to 
            // support recursively deleting. 
            while( (entryNum) && (fldlen) ) 
            {
                entryNum--;
                FAT_fseek(idxfile, ((unsigned long)(entryNum + DB_SAIFIRSTENTRY)<<2), SEEK_HEAD);
                FAT_fread(idxfile, (unsigned short *)&sai, 2);
                FAT_fread(idxfile, (unsigned short *)&pai, 2);
                
                if( sai == fld[fldlen-1])
                {
                    fldlen--;

                    // If pai == 0, there is no PAI entries available, does 
                    // NOT need to check.
                    if(pai) DB__removePAIentry(childID, offset, pai, &entryLeft);
                }
                
                else continue;
                
                // if( (sai != fld[fldlen-1]) || (pai == 0) ) continue;
                // fldlen may have been post decremented already.
                if(pai == 0) continue;

                if(entryLeft == 0)
                {
                    /* Close file before deleting SAI entry. */
                    FAT_fclose(idxfile);

                    // The first entry always(?) points to the default empty record,
                    // do not delete it even when it is empty since it defaults to
                    // have at least one virtual record.                
                    if(entryNum != 0)
                    {                    
                        DB__deleteChildRecord(childID, entryNum);
                    }

                    /* Reopen SAI file after deleting. */
                    idxfile = FAT_fopen(DB__name(childID, SAI), rb);
                }
            }

            /* Close file before return. */
            FAT_fclose(idxfile);
        }
    }

    return TRUE;
}

#pragma CODE_SECTION(_sortSAI, ".db_code")
static void _sortSAI ( unsigned long * pSAI, USHORT numOfSAI )
{
//DeepB
#ifdef USE_DATABASE_HACKS
    BOOL          bSortPending = TRUE;
    USHORT        ii;
    unsigned long sai;
    
    if( numOfSAI < 2 ) return;
    
    while( bSortPending == TRUE )
    {
        ii = numOfSAI;        
        bSortPending = FALSE;
        
        while(ii > 1)
        {
            ii--;
            
            if( (*(pSAI+ii)) <  (*(pSAI+ii-1)) )
            {
                // Switch.
                sai = *(pSAI+ii);
                *(pSAI+ii) = *(pSAI+ii-1);
                *(pSAI+ii-1) = sai;
                bSortPending = TRUE;
            }        
        }    
    }
#endif
}

#pragma CODE_SECTION (DB_creator, ".dbinit_code")

BOOL DB_creator( BOOL force2create )
{
    BOOL    ret = TRUE;
    
    FAT_cd(strDISKD);
    if( FAT_cd(strDBDIR) == FALSE )
    {       
        if( FAT_mkdir(strDBDIR) == FALSE)   return FALSE;
        if( FAT_cd(strDBDIR) == FALSE )     return FALSE;
    }
    
    /* Check to create audio DB. */
    ret = _createDB((ULONG)AUDIO_MDB_INIT_TABLE, strAUDIO, force2create);
    
    /* Check to create PC audio DB. */
    if( ret == TRUE )
    {       
        ret = _createDB((ULONG)PCAUDIO_MDB_INIT_TABLE, strPCAUDIO, force2create);
    }

    /* Check to create identified hisi DB. */
    if( ret == TRUE )
    {       
        ret = _createDB((ULONG)IDEDHISI_MDB_INIT_TABLE, strIDEDHISI, force2create);
    }
    
    /* Check to create unidentified hisi DB. */
    if( ret == TRUE )
    {       
        ret = _createDB((ULONG)UNIDHISI_MDB_INIT_TABLE, strUNIDEDHISI, force2create);
    }

    /* Check to create unsuccessful hisi DB. */
    if( ret == TRUE )
    {       
        ret = _createDB((ULONG)FAILHISI_MDB_INIT_TABLE, strFAILEDHISI, force2create);
    }

    return ret;
}


#pragma CODE_SECTION (_createDB, ".dbinit_code")
static BOOL _createDB(  ULONG           dptr,
                        const char *    name,
                        BOOL            force2create  ) 
{
    ULONG       addr;
    int         ii;
    int         numOfDB;
    char        dir[22]; // hard-coded to save stack.
    char        fname[22];
    char *      pC;
    File *      file;
    
    /* Form DB directory. */
    ii = strlen(name) - 4; // strip out the extension.
    memcpy(dir, name, ii);
    dir[ii] = 0;
    
    if( FAT_cd(dir) == FALSE )
    {
        if( FAT_mkdir(dir) == FALSE) return FALSE;      
        if( FAT_cd(dir) == FALSE ) return FALSE;
    }

    file = FAT_fopen(name, rb);
    if( (file == NULL) || ( force2create == TRUE ) ) 
    {   
        if(file) FAT_fclose(file);
        
        /* Skip reserved data. */
        dptr++; 
        
        GEN_rdSRAM(dptr++, (USHORT*)&numOfDB, 1);
        while(numOfDB--)
        {       
            /* Fetch file name. */
            GEN_readXdata(dptr, (USHORT *)&addr, 2);
            dptr += 2;
            
            /* Packed file name length is hardcoded to 10. !!! */
            GEN_readXdata(addr, (USHORT *)fname, 10);       
            
            /* unpack string. */
            GEN_strUnpack((UINT16 *)fname, 10);
        
            /* Generate mdb file. */
            if(_genFile(dptr, fname) == FALSE) return FALSE;
            
            dptr += 4;          
            
            /* Generate sai file. */
            ii = strlen(fname);
            pC = fname+ii-1;
            *pC-- = 'i';
            *pC-- = 'a';
            *pC   = 's';
            
            if(_genFile(dptr, fname) == FALSE) return FALSE;            
            dptr += 4;          
            
            /* Generate pai file. */
            *pC   = 'p';
            
            if(_genFile(dptr, fname) == FALSE) return FALSE;            
            dptr += 4;          
        }
    }
    
    if(file) FAT_fclose(file);
    
    /* Restore to DB directory. */
    FAT_cd(strDOTDOT);
    
    return TRUE;
}


#pragma CODE_SECTION (_genFile, ".dbinit_code")
static BOOL _genFile( ULONG dptr, const char * name)
{
    BOOL            ret = TRUE;
    File *          file;
    unsigned short  buf[360];
    ULONG           addr;
    int             len;

    /* Get data address. */
    GEN_readXdata(dptr, (USHORT *)&addr, 2);    
    if(addr == 0) return TRUE;
        
    dptr += 3;
        
    /* Get data length. */
    GEN_readXdata(dptr, (USHORT *)&len, 1);
    
    DB_assert(len<360, DB_CREATOR);
            
    file = FAT_fopen(name, wb);
    if(file == NULL) return FALSE;
    
    GEN_readXdata(addr, buf, len);
    if( FAT_fwrite(file, buf, len) != len ) ret = FALSE;
    
    FAT_fclose(file);
    return ret;
}
#pragma CODE_SECTION(DB_add2child, ".db_code")
BOOL DB_add2child(  DB_MDBOFFSET    rootMdb,
                    DB_ID           childID, 
                    const DB_DATA * childRecord)
{
    DB_ID               rootID;
    st_DBIDNODE *       node;
    DB_FIELDIDX         fldidx;
    DB_MDBOFFSET        childMdb;
    DB_MDBOFFSET        newOffset;
    DB_MDBOFFSET        tmpMdb;
    DB_RECLEN           originalLen;
    DB_RECLEN           childLen;
    DB_RECLEN           newLen;
    unsigned short      flag;
    File *              dbfile;
    File *              idxfile;
    unsigned short      record[DB_MAXRECLEN];
    //unsigned short    childRecord[DB_MAXRECLEN];

    /* Fetch root MDB entry. */
    rootID = DB__rootID(childID);

    if(DB__cdDBdir(DB__name(rootID, MDB)) == FALSE)   return FALSE; 
    
    //idxfile = FAT_fopen(DB__name(rootID, SAI), rb);
    //FAT_fseek(idxfile, (unsigned long)(rootEntry+DB_SAIFIRSTENTRY) << 2, SEEK_HEAD);
    //FAT_fread(idxfile, (unsigned short *)&mdb, 2);
    //FAT_fclose(idxfile);

    /* Fetch root record. */
    dbfile = FAT_fopen(DB__name(rootID, MDB), rb);
    FAT_fseek(dbfile, rootMdb, SEEK_HEAD);
    DB__getRecord(dbfile, record);
    FAT_fclose(dbfile);


    /* Fetch child MDB entry. */
    //idxfile = FAT_fopen(DB__name(childID, SAI), rb);
    //FAT_fseek(idxfile, (unsigned long)(childEntry+DB_SAIFIRSTENTRY) << 2, SEEK_HEAD);
    //FAT_fread(idxfile, (unsigned short *)&newOffset, 2);
    //FAT_fclose(idxfile);

    /* Fetch child record. */
    //dbfile = FAT_fopen(DB__name(childID, MDB), rb);
    //FAT_fseek(dbfile, newOffset, SEEK_HEAD);
    //DB__getRecord(dbfile, childRecord);
    //FAT_fclose(dbfile);
    
    /* ID to field index. */
    fldidx = DB__fieldIndex(childID);

    originalLen = DB__recordLen(record);
    childLen = DB__recordLen(childRecord);
    
    /* Insert to child. */
    childMdb = DB__insert2leaf( childID, 
                                rootID, 
                                rootMdb,
                                record, 
                                childRecord, 
                                childLen, 
                                TRUE);
                            
    /* Update root DB field value. */
    DB__addChildIdx(record, fldidx, childMdb);
    
    newLen = DB__recordLen(record);
        
    /* If newLen == originalLen, the original is able to hold the new
    ** index without extending record length, we'll just write back the 
    ** new record.
    */
    if(newLen == originalLen) 
    {       
        dbfile = FAT_fopen(DB__name(rootID, MDB), r_b);
        FAT_fseek(dbfile, rootMdb, SEEK_HEAD);
        FAT_fwrite(dbfile, (unsigned short *)record, newLen);
        FAT_fclose(dbfile);
    
        return TRUE;    
    }
    
    else
    {
        /* Mark the original as deleted. */
        dbfile = FAT_fopen(DB__name(rootID, MDB), r_b);

        newOffset = dbfile->size;

        FAT_fseek(dbfile, rootMdb, SEEK_HEAD);
        FAT_fread(dbfile, (unsigned short *)&flag, 1);
        
        flag |= RECORD_DELETED;

        FAT_fseek(dbfile, -1, SEEK_MID);
        FAT_fwrite(dbfile, (unsigned short *)&flag, 1);

        /* Append new to the end of file. */
        FAT_fseek(dbfile, newOffset, SEEK_HEAD);
        FAT_fwrite(dbfile, (unsigned short *)record, newLen);
        FAT_fclose(dbfile);

        /* Search and replace SAI entry. */
        idxfile = FAT_fopen(DB__name(rootID, SAI), r_b);
        FAT_fseek(idxfile,(unsigned long)(DB_SAIFIRSTENTRY) << 2,SEEK_HEAD);
        while(1)
        {
            FAT_fread(idxfile, (unsigned short*)&tmpMdb, 2);
            DB_assert(tmpMdb != 0, DB_ADD2CHILD);
            
            if(tmpMdb == rootMdb)
            {
                FAT_fseek(idxfile,-2,SEEK_MID);
                FAT_fwrite(idxfile, (unsigned short *)&newOffset, 2);
                break;
            }               
            // Skip PAI entry.
            FAT_fread(idxfile, (unsigned short*)&tmpMdb, 2);
        }       
        FAT_fclose(idxfile);

        /* Search and replace all children PAIs. */
        node = &DB_idtree.node[rootID];
        node = node->child;

        while(node->next)
        {
            _replacePAI(node->next->id, rootMdb, newOffset);
            
            node = node->next;
        }
    }
    return TRUE;
}

#pragma CODE_SECTION(_replacePAI, ".db_code") 
static BOOL _replacePAI(    DB_ID           id, 
                            DB_MDBOFFSET    oldOffset,  
                            DB_MDBOFFSET    newOffset) 
{
    DB_MDBOFFSET        mdb;    
    DB_PAIOFFSET        offset;
    st_DBPAICTL         control;
    File *              idxfile;

    idxfile = FAT_fopen(DB__name(id, PAI), r_b);

    offset = DB_PAIHEADERLEN;

    while(1)
    {
        FAT_fseek(idxfile, offset, SEEK_HEAD);

        if( FAT_fread(idxfile, (unsigned short *)&control, sizeof(st_DBPAICTL)) == 0 ) break;

        
        while(control.entryNum--)
        {
            FAT_fread(idxfile, (unsigned short *)&mdb, 2);

            if(oldOffset == mdb)
            {
                FAT_fseek(idxfile, -2, SEEK_MID);
                FAT_fwrite(idxfile, (unsigned short *)&newOffset, 2);
            }
        }

        offset += control.dlen;
    }

    FAT_fclose(idxfile);

    return TRUE;
}
#pragma CODE_SECTION(DB__removePAIentry, ".db_code")
BOOL DB__removePAIentry(    DB_ID               id, 
                            DB_MDBOFFSET        entry, 
                            DB_PAIOFFSET        pai,
                            unsigned short *    pEntryNum)
{   
    st_DBPAICTL     control;
    DB_PAIOFFSET    rdstart;
    DB_PAIOFFSET    wrstart;
    unsigned short  dataleft;
    unsigned short  counter;
    unsigned short  rdlen;
    unsigned short  wrlen;
    unsigned short  ii; 
    DB_MDBOFFSET    rdbuf[DB_MAXPAIBUFLEN];
    DB_MDBOFFSET    wrbuf[DB_MAXPAIBUFLEN];
    DB_MDBOFFSET *  pWr;
    File *          idxfile;

    idxfile = FAT_fopen(DB__name(id, PAI), r_b);
    FAT_fseek(idxfile, pai - sizeof(st_DBPAICTL), SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&control, sizeof(st_DBPAICTL));

    rdstart = pai;
    wrstart = pai;
    dataleft = control.entryNum;
    *pEntryNum = control.entryNum;

    while(dataleft)
    {
        if(dataleft > DB_MAXPAIBUFLEN)  rdlen = DB_MAXPAIBUFLEN << 1;           
        else                            rdlen = dataleft << 1;

        counter = 0;

        FAT_fread(idxfile, (unsigned short *)rdbuf, rdlen);

        pWr = wrbuf;

        for(ii = 0; ii < (rdlen>>1); ii++)
        {           
            if(rdbuf[ii] != entry)      *pWr++ = rdbuf[ii];
            else                        counter++;
        }

        wrlen = rdlen - (counter<<1);
        *pEntryNum -= counter;

        FAT_fseek(idxfile, wrstart, SEEK_HEAD);
        FAT_fwrite(idxfile, (unsigned short *)wrbuf, wrlen);

        wrstart += wrlen;

        dataleft -= (rdlen>>1);

        rdstart += rdlen;

        FAT_fseek(idxfile, rdstart, SEEK_HEAD);
    }


    /* Zero out all free entries. */
    if( control.entryNum > *pEntryNum)
    {
        wrstart = pai + ( (long)(*pEntryNum) << 1 );

        dataleft = (control.entryNum - *pEntryNum) << 1;

        for(ii = 0; ii < DB_MAXPAIBUFLEN; ii++) wrbuf[ii] = 0L;

        while(dataleft)
        {
            if(dataleft > (DB_MAXPAIBUFLEN<<1)) wrlen = (DB_MAXPAIBUFLEN<<1);
            else                                wrlen = dataleft;
        
            FAT_fseek(idxfile, wrstart, SEEK_HEAD);
            FAT_fwrite(idxfile, (unsigned short *)wrbuf, wrlen);

            wrstart += wrlen;
            dataleft -= wrlen;
        }
    }


    /* Update entryNum. */
    if(*pEntryNum)
    {
        FAT_fseek(idxfile, pai - sizeof(st_DBPAICTL) + 2, SEEK_HEAD);
        FAT_fwrite(idxfile, pEntryNum, 1);  
    }
    else
    {       
        /* Mark this module to be free. */
        FAT_fseek(idxfile, pai - sizeof(st_DBPAICTL) + 1, SEEK_HEAD);
        control.flag |= PAI_FREE;

        FAT_fwrite(idxfile, (unsigned short *)&control.flag, 1);
        FAT_fwrite(idxfile, pEntryNum, 1);
    }

    FAT_fclose(idxfile);
    
    return TRUE;
}

#pragma CODE_SECTION (DB__register, ".dbinit_code")
DB_ID DB__register(const DB_FNAME name, st_DBIDNODE * parent, st_DBIDNODE * prev )
{
    File *              file;   
    st_DBHEADER         header;
    DB_ID               id, tmpid;
    st_DBIDNODE *       prevnode;
    char                tmpname[DB_MAXLFN];
    char *              pC;
    unsigned short      tmp;
    
#ifdef DB_REGIST2SRAM
    unsigned long       pBuf[64]; // support up to 16 children per DB.
    unsigned long *     pp;
    unsigned long       dname;
#else
    DB_FNAME            dname;
    unsigned long *     pp; 
#endif
    unsigned short      ii;
    unsigned long       signature;


    if( (file = FAT_fopen(name, rb)) == NULL ) return DB_INVALID_ID;

    /* Check header file signature. */
    if( FAT_fread(file, (unsigned short *)&header, sizeof(st_DBHEADER)) 
            != sizeof(st_DBHEADER) )    RETURN_ERROR_DB;

    /* Seek to fetch signature. */
    FAT_fseek(file, header.len - 2, SEEK_HEAD);
    FAT_fread(file, (unsigned short *)&signature, 2);
    if( signature != DB_HEADER_SIGNATURE ) RETURN_ERROR_DB;


    /* Register database and all its children if any, build the ID tree. */
#ifdef DB_REGIST2SRAM

    /* Allocate header file name buffer. */
    ii = strlen(name);  
    dname = GEN_malloc( ii + 1 );   
    GEN_wrSRAM(dname, (unsigned short *)name, ii+1);    
    
    /* Register database ID. */
    id = DB_idtree.node[DB_idtree.counter].id = DB_idtree.counter;  
    
    //DB_assert (id < DB_MAX_ID, DB__REGISTER);
    if(id >= DB_MAX_ID)
    {
        SYS_die(DB__REGISTER);
    }
    
    /* Register this id. */
    DB_registration[id].fname = dname;
    DB_registration[id].len = ii;

#else   
    /* Allocate header file name buffer. */
    dname = (DB_FNAME)malloc( strlen(name) + 1 );   
    strcpy((char *)dname, (char *)name);

    /* Register database ID. */
    id = DB_idtree.node[DB_idtree.counter].id = DB_idtree.counter;

    /* Register this id. */
    DB_registration[id].fname = dname;
    DB_registration[id].len = strlen(dname);
#endif

    DB_idtree.counter++;

    /* Always put the newly-registered at last. */
    DB_idtree.node[id].next = NULL;
    
    /* Only register root database here. */
    DB_idtree.node[id].parent = parent;

    /* Set up previous sibling. */
    DB_idtree.node[id].prev = prev;

    if( prev ) prev->next = &DB_idtree.node[id];

    /* Set up child default to NULL. */
    DB_idtree.node[id].child = NULL;
    
    
    /* Check to see if children available. */
    if(header.numOfKeys > 1 )
    {   
        /* First child. */
        DB_idtree.node[id].child = &DB_idtree.node[id+1];
        
        /* First child will always be a virtual DB. */
        DB_registration[id+1].fname = NULL;

        DB_registration[id+1].len = 0;

        DB_idtree.node[id+1].id = id+1;

        DB_idtree.counter++;

        /* Always put the newly-registered at last. */
        DB_idtree.node[id+1].next = NULL;
        
        /* Only register root database here. */
        DB_idtree.node[id+1].parent = &DB_idtree.node[id];

        /* Set up previous sibling. */
        DB_idtree.node[id+1].prev = NULL;

        /* Set up child default to NULL. */
        DB_idtree.node[id+1].child = NULL;              
        
        /* Points to first child. */
        prevnode = &DB_idtree.node[id+1];;
        
        /* Allocate memory to read back file name pointers. */
        ii = (header.numOfKeys+1)<<1;

#ifdef DB_REGIST2SRAM
        pp = pBuf;
#else
        if ( (pp = (unsigned long *)malloc( ii * sizeof(unsigned long))) 
                == NULL ) RETURN_ERROR_DB;
#endif

        ii <<= 1;

        FAT_fseek(file, sizeof(st_DBHEADER), SEEK_HEAD);
        if( FAT_fread(file, (unsigned short *)pp, ii ) != ii ) RETURN_ERROR_DB;

        /* Skip database name, database parent file name and first child. */
        pp += 5; 
        
        /* Register all its children if any. */
        for( ii = 0; ii < header.numOfKeys - 1; ii++ )
        {
            pC = tmpname;

            FAT_fseek(file, *pp, SEEK_HEAD);

            while(1)
            {
                FAT_fread(file, &tmp, 1);

                /* little endian PC data. */
                *pC++ = tmp >> 8;
                
                *pC++ = tmp & 0x00FF;
                
                if( (tmp & 0x00FF) == 0 ) break;
                
                // Error handling.
                if(pC - tmpname > DB_MAXLFN) RETURN_ERROR_DB;
            }
            
            tmpid = DB__register(tmpname, &DB_idtree.node[id], prevnode); 

            if( tmpid == DB_INVALID_ID )
            { 
                RETURN_ERROR_DB;
            }
            else
            {
                prevnode = &DB_idtree.node[tmpid];
                /* Points to next key file name. */
                pp += 2;
            }
        }
    }   

    /* Close DB header file before return. */
    FAT_fclose(file);

    /* Write ID back to header file. */
#if 0
    file = FAT_fopen(name, r_b);
    FAT_fseek(file, DB_ID_OFFSET, SEEK_HEAD);
    FAT_fwrite(file, &id, 1);
    FAT_fclose(file);
#endif

    return id;
}

#pragma CODE_SECTION(DB__recordPosition, ".db_code")
BOOL DB__recordPosition(    DB_ID               id, 
                            DB_ENTRY *          pPosition, 
                            const DB_DATA *     pRecord,
                            BOOL                bIgnoreRule )
{
    unsigned short  field[DB_MAXFIELDLEN];
    DB_ENTRY        entry;          /* SAI entry number. */
    DB_MDBOFFSET    offset;         /* File offset in MDB file. */
    short           comp;           /* Field compare result. */
    File *          idxfile;
    File *          dbfile;

    /* Open MDB and SAI files. */
    idxfile = FAT_fopen(DB__name(id, SAI), rb);
    dbfile  = FAT_fopen(DB__name(id, MDB), rb);
    
    
    /* Points to the first valid entry. */
    entry = DB_SAIFIRSTENTRY;


    /* SAI entry takes 64bits, 4 words per entry. */
    FAT_fseek(idxfile, (long)entry << 2, SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&offset, 2);

    while(offset)
    {
        FAT_fseek(dbfile, offset, SEEK_HEAD);
        FAT_fread(dbfile, field, DB_MAXFIELDLEN);

        /* Only compare the primary field. */
        comp = DB__compare(field, (unsigned short *)pRecord );

        if( comp == 0)
        {
            /* Record found!. */
            FAT_fclose(idxfile);
            FAT_fclose(dbfile);

            *pPosition = entry;
            return TRUE;
        }
        else if (comp < 0)
        {
            /* ASSUMPTIION:
            ** If data under this rule are not presorted, this rule must 
            ** support multiple record references, which means any record
            ** can possibly occur multiple times under this rule. 
            */
            entry++;

            /* Skip PAI entry. */
            FAT_fseek(idxfile, 2, SEEK_MID);            
            FAT_fread(idxfile, (unsigned short *)&offset, 2);
        }
        else
        {
            if(bIgnoreRule == FALSE) break;
            
            else
            {
                entry++;

                /* Skip PAI entry. */
                FAT_fseek(idxfile, 2, SEEK_MID);            
                FAT_fread(idxfile, (unsigned short *)&offset, 2);
            }
        }
    }


    /* Record does not exist. */
    FAT_fclose(idxfile);
    FAT_fclose(dbfile);

    
    /* Sets up position. */
    *pPosition = entry;

    return FALSE;   
}

#pragma CODE_SECTION(DB__recordLen, ".db_code")
DB_RECLEN DB__recordLen(const DB_DATA * pRecord)
{   
    unsigned short *    pR;
    
    pR = (unsigned short *) pRecord;
    
    if(*pR == DB_RECDLMT)   return 0;

    while( 1 ) 
    {
        pR++;
        
        if( *pR == DB_RECDLMT ) 
        {
            if( *(pR-1) != DB_ESCCHAR ) break;
        }       
    }
    
    return (pR-(unsigned short *)pRecord+1);
}

#pragma CODE_SECTION(DB__name, ".db_code")
DB_FNAME DB__name(DB_ID id, DB_FEXTNAME ext)
{   
    unsigned short  len = DB_registration[id].len;
#ifdef DB_REGIST2SRAM
    static char     DBnameBUF[DB_MAXLFN]; 
    char *          pC = &DBnameBUF[len-1];
    GEN_rdSRAM(DB_registration[id].fname, (unsigned short *)DBnameBUF, len+1);  
#else
    char *          pC = DB_registration[id].fname;
#endif
    
    switch( ext ) 
    {
        case MDB:
            *pC-- = 'b';
            *pC-- = 'd';
            *pC   = 'm';
            break;
        
        case SAI:
            *pC-- = 'i';
            *pC-- = 'a';
            *pC   = 's';
            break;
    
        case PAI:
            *pC-- = 'i';
            *pC-- = 'a';
            *pC   = 'p';
            break;
    }
    
#ifdef DB_REGIST2SRAM
    return (DB_FNAME)DBnameBUF;
#else   
    return DB_registration[id].fname;
#endif      

}
#pragma CODE_SECTION(DB__locateField, ".db_code")
DB_DATA * DB__locateField(const DB_DATA * pRecord, DB_FIELDIDX fldIdx)
{

    const unsigned short *  pSrc;
    unsigned short          count;
    
    count = 0;
    
    /* Skip the record flag. */
    pSrc = (unsigned short *)pRecord + 1;

    if( fldIdx != 0 )
    {
        while( 1 ) 
        {   
            if(*pSrc == DB_ESCCHAR) pSrc += 2;
            
            if(*pSrc == DB_RECDLMT) 
            {               
                /* End of record, field not found. */
                return NULL;
            }
    
            if(*pSrc == DB_FLDDLMT) 
            {               
                /* Field detected. */
                count++;
                
                if( count == fldIdx ) 
                {
                    pSrc++;
                    break;
                }
            }
            
            pSrc++;
        }
    }
    
    return((DB_DATA *)pSrc);
}


#pragma CODE_SECTION(_checkPAI, ".db_code")
static DB_PAIOFFSET _checkPAI(  DB_ID               id, 
                                DB_PAIOFFSET        pai, 
                                DB_MDBOFFSET        mdb )
{

    DB_PAIOFFSET    matchPai;
    DB_MDBOFFSET    matchMdb;
    File *          idxfile;

    matchPai = pai;

    idxfile = FAT_fopen(DB__name(id, PAI), rb);
    FAT_fseek(idxfile, pai, SEEK_HEAD);
    FAT_fread(idxfile, (unsigned short *)&matchMdb, 2); 
    
    while(matchMdb)
    {
        if(matchMdb == mdb) 
        {           
            FAT_fclose(idxfile);
            return matchPai;
        }
        else matchPai += 2;

        FAT_fread(idxfile, (unsigned short *)&matchMdb, 2); 
    }

    FAT_fclose(idxfile);
    
    /* No match found. */
    return 0L;
}

#pragma CODE_SECTION(_createPAIentry, ".db_code")
static DB_PAIOFFSET _createPAIentry(    DB_ID               id, 
                                        DB_MDBOFFSET    parentMdb )
{
    File *              file;
    unsigned long       offset;
    unsigned short      tmp[DB_MINPAILEN];
    unsigned short      len;
    unsigned short      flag;
    unsigned short      ii;
    
        file = FAT_fopen(DB__name(id, PAI), r_b);
        
        offset = (long)DB_PAIHEADERLEN;

        /* Search the first empty module if any. */
        while(1)
        {
            /* Seek to next PAI module. */
            FAT_fseek(file, offset, SEEK_HEAD);

            if(FAT_fread(file, &len, 1) == 0)
            {
                /* End of file. */
                break;
            }

            FAT_fread(file, &flag, 1);
            if( flag & PAI_FREE)
            {
                /* Free PAI found! */

                /* Clear the free flag. */
                flag &= ~PAI_FREE;

                FAT_fseek(file, -1, SEEK_MID);
                FAT_fwrite(file, &flag, 1);

                /* Update entry counter. */
                tmp[0] = 1;

                FAT_fwrite(file, tmp, 1);
                


                /* Skip reserved 3 words. */
                FAT_fseek(file, 3, SEEK_MID);

                /* Write entry. */
                FAT_fwrite(file, (unsigned short *)&parentMdb, 2);
                FAT_fclose(file);

                return (offset + sizeof(st_DBPAICTL));
            }
            offset += len;
        }
        

        /* Add to end of file. */
        FAT_fseek(file, offset, SEEK_HEAD);
        

        /* Following to create a new PAI module. */
        for( ii = 0; ii < DB_MINPAILEN; ii++) tmp[ii] = 0;

        tmp[0] = DB_MINPAILEN;

        tmp[2] = 1;
        
        tmp[sizeof(st_DBPAICTL)] = (unsigned short)((long)parentMdb >> 16);

        tmp[sizeof(st_DBPAICTL) + 1] = (unsigned short)(parentMdb & 0xFFFF);

        FAT_fwrite(file, tmp, DB_MINPAILEN);
        FAT_fclose(file);

        return (offset + sizeof(st_DBPAICTL));
}

#pragma CODE_SECTION(DB__getRecord, ".db_code")
BOOL DB__getRecord(File * file, DB_DATA * pData)
{
    unsigned short *    p;
    unsigned short      len;
    
    // This is from queryFirst.
    if(pData == NULL) return TRUE;
    
    // Let's split it to speed up, since normally record will be 
    // 256 words less.
    
    p = (unsigned short *)pData;
    len = FAT_fread(file, p, DB_MAXRECLEN/2);
    
    // check for record delimiter, for safe?.
    while( 1 ) 
    {
        if( *p == DB_RECDLMT ) 
        {           
            if( *(p-1) != DB_ESCCHAR ) return TRUE;
        }
        p++;
        if ( (p-(unsigned short *)pData) >= len ) break;
    }

    // Second attempt.
    if( len != DB_MAXRECLEN/2) return FALSE;
    
    p = (unsigned short *)pData+DB_MAXRECLEN/2;
    len = FAT_fread(file, p, DB_MAXRECLEN/2);
    
    // check for record delimiter, for safe?.
    while( 1 ) 
    {
        if( *p == DB_RECDLMT ) 
        {           
            if( *(p-1) != DB_ESCCHAR ) return TRUE;
        }
        p++;
        if ( (p-(unsigned short *)pData) == len ) break;
    }
    
    return TRUE;    
}

#pragma CODE_SECTION(DB__fieldIndex, ".db_code")
DB_FIELDIDX DB__fieldIndex(DB_ID id)
{
    st_DBIDNODE *   node;
    DB_FIELDIDX     fldidx;

    fldidx = 0;
    node = &DB_idtree.node[id];
    
    /* The very first child does not have previous node. */
    while(node->prev)
    {
        fldidx++;
        node = node->prev;
    }
    
    return fldidx;
}

#pragma CODE_SECTION(DB__cdDBdir, ".db_code")
BOOL DB__cdDBdir(const DB_FNAME name)
{
    char           dir[DB_MAXLFN];
    char *         pD = &dir[0];
    const char *   pC = name;
    
    // DB always resides in NAND flash.
    FAT_cd(strDISKD);
    
    // Always load DB from database directory.
    if( FAT_cd(strDBDIR) == FALSE ) return FALSE;
    
    while(*pC != '.')
    {
        *pD++ = *pC++;
    }
    *pD = 0;
    
    return(FAT_cd(dir));    
}

#pragma CODE_SECTION(DB__addSAIentry, ".db_code")
BOOL DB__addSAIentry(DB_ID              id, 
                     DB_ENTRY           entry,
                     DB_MDBOFFSET       mdb,
                     DB_PAIOFFSET       pai)
{

    unsigned long   offset[2];
    unsigned long   fsize;
    unsigned short  entryNum;
    File *          idxfile;

    /* Update record number. */
    idxfile = FAT_fopen(DB__name(id, SAI), r_b);
    fsize = idxfile->size;
    
    FAT_fseek(idxfile, DB_SAIENTRYNUMOFFSET, SEEK_HEAD);
    FAT_fread(idxfile, &entryNum, 1);

    entryNum++;

    FAT_fseek(idxfile, -1, SEEK_MID);
    FAT_fwrite(idxfile, &entryNum, 1);


    /* Load buffer. */
    offset[0] = mdb;
    offset[1] = pai;

    /* Check to see if there is any free entries. */
    if((long)fsize >= (long)((unsigned long)(entryNum + DB_SAIFIRSTENTRY + 1)<<2) ){

        FAT_finsert( idxfile, 
                    ( (unsigned long)entry << 2), 
                    (unsigned short *)offset, 
                    4, fsize);
    }
    else
    {
        FAT_finsert(idxfile, 
                    ( (unsigned long)entry << 2), 
                    (unsigned short *)offset, 
                    4, 0L);
    }

    FAT_fclose(idxfile);
    
    return TRUE;
}

//EOF

---