libfcns.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 640 行 · 第 1/2 页

                memcpy(&d2, f2 + (elt * sizeof(double)), sizeof(double));
                if (d1 < d2)
                {
                    result = -1;
                    break;
                }
                else if (d1 > d2)
                {
                    result = 1;
                    break;
                }
            }

            break;

        case DBADDR:
            for (elt = 0; !result && elt < entries; ++elt)
            {
                result = ADDRcmp((DB_ADDR *) (f1 + (elt * sizeof(DB_ADDR))),
                        (DB_ADDR *) (f2 + (elt * sizeof(DB_ADDR))));
            }
            break;

        case GROUPED:
            len /= entries;               /* length of each entry */
            fld_last = &task->field_table[task->size_fd - 1];
            cur_len = 0;
            for (elt = 0; !result && elt < entries; ++elt)
            {
                for ( sfld_ptr = fld_ptr + 1;
                      !result && sfld_ptr->fd_flags & STRUCTFLD;
                      ++sfld_ptr)
                {
                    sub_len = cur_len + sfld_ptr->fd_ptr - fld_ptr->fd_ptr;
                    result = fldcmp(sfld_ptr, f1 + sub_len, f2 + sub_len, task);

                    /* This is added because on some protected mode systems
                        (i.e. Phar Lap 286) task->field_table[task->size_fd] (one past end)
                        is not defined.
                    */
                    if (sfld_ptr == fld_last)
                        break;
                }

                cur_len += len;
            }
            break;

        case COMKEY:
            kt_lc = task->size_kt - fld_ptr->fd_ptr;
            key_num = task->key_table[fld_ptr->fd_ptr].kt_key;

            for ( key_ptr = &task->key_table[fld_ptr->fd_ptr];
                  !result && kt_lc-- > 0 && key_ptr->kt_key == key_num;
                  ++key_ptr)
            {
                sub_len = key_ptr->kt_ptr;

                result = fldcmp(&task->field_table[key_ptr->kt_field],
                                f1 + sub_len, f2 + sub_len, task);
            }

            break;

        default:
            dberr(SYS_INVFLDTYPE);     /* should never get here */
            return 0;
    }

    return result;
}


/* ======================================================================
    compare the short variables
*/
int INTERNAL_FCN SHORTcmp(const char *i1, const char *i2)
{
    short I1, I2;

    memcpy(&I1, i1, sizeof(short));
    memcpy(&I2, i2, sizeof(short));
    if (I1 < I2)
        return -1;

    if (I1 > I2)
        return 1;

    return 0;
}


/* ======================================================================
    compare two DB_ADDR variables
*/
int EXTERNAL_FCN ADDRcmp(const DB_ADDR *d1, const DB_ADDR *d2)
{
    DB_ADDR     a1, a2;
    short       f1, f2;
    DB_ULONG    r1, r2;

    memcpy(&a1, d1, DB_ADDR_SIZE);
    memcpy(&a2, d2, DB_ADDR_SIZE);

    DECODE_DBA(a1, &f1, &r1);
    DECODE_DBA(a2, &f2, &r2);

    if (f1 == f2)
    {
        if (r1 < r2)
            return -1;

        if (r1 > r2)
            return 1;

        return 0;
    }

    return (f1 - f2);
}




/* ======================================================================
    check for empty DB_ADDR
*/
int INTERNAL_FCN null_dba(const DB_ADDR db_addr)
{
    return (db_addr == NULL_DBA);
}


/* ======================================================================
    check for valid DB_ADDR
*/
int INTERNAL_FCN check_dba(DB_ADDR dba, DB_TASK *task)
{
    short       fno;
    DB_ULONG    rno, last;

    DECODE_DBA(dba, &fno, &rno);

    if (fno < 0 || fno >= TABLE_SIZE(Size_ft))
        return (dberr(S_INVADDR));

    if (task->file_table[fno + DB_REF(ft_offset)].ft_type != 'd')
        return (dberr(S_INVADDR));

    /* Make sure page 0 has been read */
    if ((last = dio_pznext((FILE_NO) NUM2INT(fno, ft_offset), task)) <= 0)
        return (task->db_status);

    if (rno == 0L || rno >= last)
        dberr(S_INVADDR);

    return (task->db_status);
}


/* ======================================================================
    Compare two strings with sorting according to char-table
*/
int INTERNAL_FCN ctblcmp(
    const unsigned char *s,      /* String 1 */
    const unsigned char *t,      /* String 2 */
    int                  len,     /* Max. String length */
    DB_TASK             *task)
{
    int            x;
    unsigned char  f1, f2,
                        x1, x2;

    /* Always return immediately at first difference found */
    for ( ; len && *s && *t; len--)
    {
        if (task->country_tbl[*s].sort_as1)
            f1 = task->country_tbl[*s].sort_as1;
        else
            f1 = *s;

        if (task->country_tbl[*t].sort_as1)
            f2 = task->country_tbl[*t].sort_as1;
        else
            f2 = *t;

        if ((x = f1 - f2) != 0)
            return (x);

        /* Check sort_as2-values if sort_as1-values are equal */
        /*----------------------------------------------------*/
        x1 = task->country_tbl[*s].sort_as2;
        x2 = task->country_tbl[*t].sort_as2;
        if (x1 && x2)
        {
            /* We have an entry for char. of both strings */
            if ((x = x1 - x2) != 0)
                return x;
        }
        else
        {
            if (x1 || x2)
            {
                /* Only sort_as2 value for one string */
                if (x1)
                {
                    /* Compare with next character in string 2 */
                    t++;
                    if (task->country_tbl[*t].sort_as1)
                        f2 = task->country_tbl[*t].sort_as1;
                    else
                        f2 = *t;

                    if ((x = x1 - f2) != 0)
                        return x;
                }

                if (x2)
                {
                    /* Compare with next character in string 1 */
                    s++;
                    if (task->country_tbl[*s].sort_as1)
                        f1 = task->country_tbl[*s].sort_as1;
                    else
                        f1 = *s;

                    if ((x = f1 - x2) != 0)
                        return x;
                }
            }

            /* if both are equal compare sub_sort values */
            x = task->country_tbl[*s].sub_sort - task->country_tbl[*t].sub_sort;
            if (x != 0)
                return x;
        }

        s++;
        t++;
    }           /* end of for() */

    if (len)
    {
        if (*s)
            return 1;

        if (*t)
            return -1;
    }

    return 0;
}



/* ======================================================================
    Length limited string copy with enforced null termination
*/
DB_TCHAR *vstrnzcpy(
    DB_TCHAR       *s1,
    const DB_TCHAR *s2,
    size_t          len)
{
    size_t s2_len = vtstrlen(s2)+1;
    if (s2_len > len)
        s2_len = len;

    vtstrncpy(s1, s2, s2_len);
    s1[len - 1] = 0;

    return s1;
}


/* ======================================================================
    Functions to simplify construction of null-terminated strings which
    must fit in a fixed size buffer.
*/
DB_TCHAR *STRinit(DB_STRING *dest, DB_TCHAR *src, size_t len)
{
    dest->buflen = len;
    dest->strlen = vtstrlen(src);
    if (dest->strlen >= dest->buflen)
        src[dest->strlen = dest->buflen-1] = DB_TEXT('\0');

    return (dest->strbuf = src);
}

DB_TCHAR *STRcpy(DB_STRING *dest, DB_TCHAR *src)
{
    dest->strlen = vtstrlen(vstrnzcpy(dest->strbuf, src, dest->buflen));
    return dest->strbuf;
}

DB_TCHAR *STRcat(DB_STRING *dest, DB_TCHAR *src)
{
    dest->strlen += vtstrlen(vstrnzcpy(dest->strbuf + dest->strlen, src,
            dest->buflen - dest->strlen));

    return dest->strbuf;
}

DB_TCHAR *STRccat(DB_STRING *dest, int c)
{
    if (STRavail(dest))
    {
        dest->strbuf[dest->strlen++] = (DB_TCHAR)c;
        dest->strbuf[dest->strlen] = DB_TEXT('\0');
    }

    return dest->strbuf;
}

size_t STRavail(DB_STRING *dest)
{
    return dest->buflen - dest->strlen - 1;
}