keyfcns.c

db.* (pronounced dee-be star) is an advanced, high performance, small footprint embedded database fo

            /* move left orphan to child of slot 0 in right node */
            l_node_slot_ptr += task->slot_len - sizeof(F_ADDR);
            memcpy(r_node->slots, l_node_slot_ptr, sizeof(F_ADDR));

            /* delete end slot from left node */
            --l_node->used_slots;
        }

        dio_touch(task->keyfile, l_pg, PGFREE, task);
        dio_touch(task->keyfile, r_pg, PGFREE, task);
        dio_touch(task->keyfile, p_pg, PGFREE, task);
    }
    else
        dio_touch(task->keyfile, pg, PGFREE, task);

    return task->db_status;
}



/* ======================================================================
    Open n slots in node
*/
static void INTERNAL_FCN open_slots(NODE *node, int slot_pos, int n,
                                                DB_TASK *task)
{
    char *dst,
          *src;

    src = &node->slots[slot_pos];
    dst = src + n * task->slot_len;
    memmove(dst,src, NODE_WIDTH(node) - slot_pos);

    node->used_slots += (short) n;
}



/* ======================================================================
    Close n slots in node
*/
static void INTERNAL_FCN close_slots(NODE *node, int slot_pos, int n,
                                                 DB_TASK *task)
{
    char *dst,
          *src;

    node->used_slots -= (short) n;

    dst = &node->slots[slot_pos];
    src = dst + n * task->slot_len;
    memmove(dst, src, NODE_WIDTH(node) - slot_pos);
}


/* ======================================================================
    Read value of last key scanned
*/
int INTERNAL_FCN dkeyread(void *key_val, DB_TASK *task)
{
    float        fv;
    double       dv;
    int          kt_lc;                 /* loop control */
    int          entries, i;
    short        lstat;
    short       *dim_ptr;
    char        *fptr;
    char        *kptr;
    FIELD_ENTRY *fld_ptr;
    KEY_ENTRY   *key_ptr;

    key_init(task->last_keyfld, task);

    lstat = task->curkey->lstat;
    if (lstat != KEYFOUND && lstat != KEYNOTFOUND && lstat != KEYREPOS)
        return (task->db_status = S_KEYSEQ);

    /* clear key area */
    memset(key_val, '\0', task->cfld_ptr->fd_len);

    if (task->cfld_ptr->fd_type == COMKEY)
    {
        /* copy compound key fields */
        for (kt_lc = task->size_kt - task->cfld_ptr->fd_ptr,
             key_ptr = &task->key_table[task->cfld_ptr->fd_ptr];
             (--kt_lc >= 0) && (key_ptr->kt_key == task->fldno); ++key_ptr)
        {
            fld_ptr = &task->field_table[key_ptr->kt_field];
            fptr = task->key_type.ks.data + key_ptr->kt_ptr;
            kptr = (char *) key_val + key_ptr->kt_ptr;
            if (key_ptr->kt_sort == 'd')
            {
                entries = 1;
                for (i = 0, dim_ptr = fld_ptr->fd_dim;
                     (i < MAXDIMS) && *dim_ptr;
                     ++i, ++dim_ptr)
                {
                    entries *= *dim_ptr;
                }

                switch (fld_ptr->fd_type)
                {
                    case FLOAT:
                    {
                        float *float_fptr = (float *)fptr,
                              *float_kptr = (float *)kptr;

                        for(i = 0; i < entries; i++,float_fptr++,float_kptr++)
                        {
                            memcpy(&fv, float_fptr, sizeof(float));
                            fv = (float) 0.0 - fv;
                            memcpy( float_kptr, &fv, sizeof(float));
                        }
                        break;
                    }

                    case DOUBLE:
                    {
                        double *double_fptr = (double *)fptr,
                               *double_kptr = (double *)kptr;

                        for(i = 0; i < entries; i++,double_fptr++,double_kptr++)
                        {
                            memcpy(&dv, double_fptr, sizeof(double));
                            dv = (double) 0.0 - dv;
                            memcpy( double_kptr, &dv, sizeof(double));
                        }
                        break;
                    }
                    
                    case CHARACTER:
                        if (fld_ptr->fd_dim[0] > 1 && fld_ptr->fd_dim[1] == 0)
                            key_acpy(kptr, fptr, fld_ptr->fd_len);
                        else
                            key_cmpcpy(kptr, fptr, fld_ptr->fd_len);
                        break;

                    case WIDECHAR:
                        if (fld_ptr->fd_dim[0] > 1 && fld_ptr->fd_dim[1] == 0)
                        {
                            key_wacpy((wchar_t *)kptr, (wchar_t *)fptr,
                                      (short)(fld_ptr->fd_len / sizeof(wchar_t)));
                            break;
                        }

                    default:
                        key_cmpcpy(kptr, fptr, fld_ptr->fd_len);
                        break;
                }
            }
            else
                if (fld_ptr->fd_type == CHARACTER && fld_ptr->fd_dim[1] == 0)
                    strncpy(kptr, fptr, fld_ptr->fd_len);
                else if (fld_ptr->fd_type == WIDECHAR && fld_ptr->fd_dim[1] == 0)
                    vwcsncpy((wchar_t *)kptr, (wchar_t *)fptr, fld_ptr->fd_len / sizeof(wchar_t));
                else
                    memcpy(kptr, fptr, fld_ptr->fd_len);
        }
    }
    else
    {
        if (task->cfld_ptr->fd_type == CHARACTER && task->cfld_ptr->fd_dim[1] == 0)
            strncpy(key_val, task->key_type.ks.data, task->key_len);
        else if (task->cfld_ptr->fd_type == WIDECHAR && task->cfld_ptr->fd_dim[1] == 0)
            vwcsncpy((wchar_t *)key_val, (wchar_t *)task->key_type.ks.data, task->key_len / sizeof(wchar_t));
        else
            memcpy(key_val, task->key_type.ks.data, task->key_len);
    }

    return (task->db_status);
}



/* ======================================================================
    Build compound key value from record
*/
int EXTERNAL_FCN key_bldcom(
    int fld,            /* compound key field number */
    char *rec,          /* ptr to record data */
    char *key,          /* ptr to array to recv constructed key */
    int cflag,          /* TRUE to compliment compound descending keys */
    DB_TASK *task)
{
    float        fv;
    double       dv;
    int          kt_lc;         /* loop control */
    int          entries, i;
    short       *dim_ptr;
    short        header_size;

    char        *fptr;
    char        *tptr;
    FIELD_ENTRY *fld_ptr,
                *kfld_ptr;
    KEY_ENTRY   *key_ptr;

    /* clear key area */
    fld_ptr = &task->field_table[fld];
    memset(key, '\0', fld_ptr->fd_len);

    /* create compound key value */
    header_size = task->record_table[fld_ptr->fd_rec].rt_data;
    for (kt_lc = task->size_kt - fld_ptr->fd_ptr,
         key_ptr = &task->key_table[fld_ptr->fd_ptr];
         (--kt_lc >= 0) && (key_ptr->kt_key == fld); ++key_ptr)
    {
        kfld_ptr = &task->field_table[key_ptr->kt_field];
        fptr = rec + (kfld_ptr->fd_ptr - header_size);
        tptr = (char *)&key[key_ptr->kt_ptr];

        /* Complement descending keys if permitted (cflag) */
        if (cflag && (key_ptr->kt_sort == 'd'))
        {
            entries = 1;
            for (i = 0, dim_ptr = kfld_ptr->fd_dim;
                 (i < MAXDIMS) && *dim_ptr;
                 ++i, ++dim_ptr)
            {
                entries *= *dim_ptr;
            }

            switch (kfld_ptr->fd_type)
            {
                case FLOAT:
                {
                    float *float_fptr = (float *)fptr,
                          *float_tptr = (float *)tptr;

                    for (i = 0; i < entries; i++,float_fptr++,float_tptr++)
                    {
                        memcpy(&fv, float_fptr, sizeof(float));
                        fv = (float) 0.0 - fv;
                        memcpy( float_tptr, &fv, sizeof(float));
                    }

                    break;
                }

                case DOUBLE:
                {
                    double *double_fptr = (double *)fptr,
                           *double_tptr = (double *)tptr;

                    for(i = 0; i < entries; i++,double_fptr++,double_tptr++)
                    {
                        memcpy(&dv, double_fptr, sizeof(double));
                        dv = (double) 0.0 - dv;
                        memcpy( double_tptr, &dv, sizeof(double));
                    }

                    break;
                }
                
                case CHARACTER:
                    if (kfld_ptr->fd_dim[0] > 1 && kfld_ptr->fd_dim[1] == 0)
                        key_acpy(tptr, fptr, kfld_ptr->fd_len);
                    else
                        key_cmpcpy(tptr, fptr, kfld_ptr->fd_len);
                    break;

                case WIDECHAR:
                    if (kfld_ptr->fd_dim[0] > 1 && kfld_ptr->fd_dim[1] == 0)
                    {
                        key_wacpy((wchar_t *)tptr, (wchar_t *)fptr,
                                  (short)(kfld_ptr->fd_len / sizeof(wchar_t)));
                        break;
                    }

                default:
                    key_cmpcpy(tptr, fptr, kfld_ptr->fd_len);
                    break;
            }
        }
        else
        {
            if (kfld_ptr->fd_type == CHARACTER && kfld_ptr->fd_dim[1] == 0)
                strncpy(tptr, fptr, kfld_ptr->fd_len);
            else if (kfld_ptr->fd_type == WIDECHAR && kfld_ptr->fd_dim[1] == 0)
                vwcsncpy((wchar_t *)tptr, (wchar_t *)fptr, kfld_ptr->fd_len / sizeof(wchar_t));
            else
                memcpy(tptr, fptr, kfld_ptr->fd_len);
        }
    }

    return (task->db_status);
}



/* ======================================================================
    Complement and copy bytes
*/
void INTERNAL_FCN key_cmpcpy(char *s1, char *s2, short n)
{
    while (n--)
    {
        *s1++ = (char) ~(*s2++);
    }
}

/* ======================================================================
    Complement and copy bytes till 0 encounted [1358],[1387]
*/
void INTERNAL_FCN key_acpy(char *s1, char *s2, short n)
{
    while (n--)
    {
        if (! *s2)
        {
            *s1 = '\0';
             break;
        }

        *s1++ = (char) ~(*s2++);
    }
}

/* ======================================================================
    Same as above, but for widechar
*/
void INTERNAL_FCN key_wacpy(wchar_t *s1, wchar_t *s2, short n)
{
    wchar_t w;

    while (n--)
    {
        /*
            Use memcpy rather than dereferencing pointer, as Windows CE
            requires wchar_t variables to be on even byte addresses.
        */
        memcpy(&w, s2++, sizeof(wchar_t));
        if (!w)
        {
            memcpy(s1, &w, sizeof(wchar_t));
            break;
        }

        w = ~w;
        memcpy(s1++, &w, sizeof(wchar_t));
    }
}

/* ======================================================================
    Position all key on this record to point to this record
*/
int INTERNAL_FCN dcurkey(DB_TASK *task, int dbn)
{
    short         rt;
    int           i;
    char          ckey[MAXKEYSIZE];    /* compound key data */
    char         *rec;                 /* ptr to record slot */
    char         *fptr;                /* field data ptr */
    RECORD_ENTRY *rec_ptr;
    FIELD_ENTRY  *fld_ptr;
    KEY_INFO     *ki_ptr;

    if (! task->curr_rec)
        return (dberr(S_NOCR));

    /* get the record type of the current record */
    if (dio_read(task->curr_rec, &rec, NOPGHOLD, task) != S_OKAY)
        return (task->db_status);

    memcpy(&rt, rec, sizeof(short));
    if (rt < 0)
        return (dberr(S_INVADDR));   /* record was deleted */

    rt &= ~RLBMASK;                     /* mask off rlb */
    rt += task->curr_db_table->rt_offset;

    rec_ptr = &task->record_table[rt];

    /* position any key fields from the key files */
    for (i = 0, ki_ptr = task->key_info; i < task->no_of_keys; ++i, ++ki_ptr)
    {
        fld_ptr = &task->field_table[ki_ptr->fldno];
        if (fld_ptr->fd_rec != rt)
            continue;

        /* Reset the key if it exists */
        if ((! (fld_ptr->fd_flags & OPTKEYMASK)) || r_tstopt(fld_ptr, rec, task))
        {
            ki_ptr->lstat = KEYREPOS;
            ki_ptr->dba = task->curr_rec;
            if (fld_ptr->fd_type == COMKEY)
            {
                key_bldcom(ki_ptr->fldno, rec + rec_ptr->rt_data, ckey, TRUE, task);
                fptr = ckey;
            }
            else
                fptr = rec + fld_ptr->fd_ptr;

            memcpy(ki_ptr->keyval, fptr, fld_ptr->fd_len);
        }
    }

    dio_release(task->curr_rec, NOPGFREE, task);
    return (task->db_status);
}