dbe_show.c

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

        }
        dbe_out(task->set_names[i], STDOUT);
        comma = 1;
        j += len;
    }
    dbe_out(DB_TEXT("\n"), STDOUT);
    
    return 0;
}


/* Show details for one set
*/
int show_st(int index, DB_TASK *task)
{
    DB_TCHAR buffer[LINELEN];
    int i, n, first, last, order = 0, fields, comma;

    /* Set Type */

    vstprintf(buffer, DB_TEXT("%s%s (%d)"),
        dbe_getstr(M_SHOWST), task->set_names[index], index);
    dbe_out(buffer, STDOUT);

    /* Order */

    vtstrcpy(buffer, dbe_getstr(M_SHOWSD));
    fields = 0;
    switch (task->set_table[index].st_order)
    {
        case DB_TEXT('f'):
            order = M_SETFST;
            break;
        case DB_TEXT('l'):
            order = M_SETLST;
            break;
        case DB_TEXT('n'):
            order = M_SETNXT;
            break;
        case DB_TEXT('a'):
            order = M_SETASC;
            fields = 1;
            break;
        case DB_TEXT('d'):
            order = M_SETDSC;
            fields = 1;
            break;
    }
    vtstrcat(buffer, dbe_getstr(order));
    dbe_out(buffer, STDOUT);
    if (fields)
    {
        vtstrcpy(buffer, dbe_getstr(M_TAB));
        vtstrcat(buffer, dbe_getstr(M_SHOWSF));
        comma = 0;
        for (i = 0; i < task->size_srt; i++)
        {
            if (task->sort_table[i].se_set == index)
            {
                if (comma)
                    vtstrcat(buffer, DB_TEXT(", "));
                vtstrcat(buffer, task->field_names[task->sort_table[i].se_fld]);
                comma = 1;
            }
        }
        dbe_out(buffer, STDOUT);
    }

    /* Owner */

    n = task->set_table[index].st_own_rt;
    vstprintf(buffer, DB_TEXT("%s%s (%d)"),
        dbe_getstr(M_SHOWSO), task->record_names[n], n);
    dbe_out(buffer, STDOUT);

    /* Members */

    vtstrcpy(buffer, dbe_getstr(M_SHOWSM));
    first = task->set_table[index].st_members;
    last = first + task->set_table[index].st_memtot;
    comma = 0;
    for (i = first; i < last; i++)
    {
        n = task->member_table[i].mt_record;
        vstprintf(buffer + vtstrlen(buffer),
            DB_TEXT("%s (%d)"), task->record_names[n], n);
        if (i != last - 1)
            vtstrcat(buffer, DB_TEXT(", "));
    }
    dbe_out(buffer, STDOUT);

    /* Flags */

    vtstrcpy(buffer, dbe_getstr(M_SHOWSG));
    if (task->set_table[index].st_flags & TIMESTAMPED)
        vtstrcat(buffer, dbe_getstr(M_FLAGST));

    vtstrcat(buffer, DB_TEXT("\n"));
    dbe_out(buffer, STDOUT);

    return 0;
}

/* ********************** Show keys ********************************** */

/* Show list of keys in database, in same format as normal fields
*/
int show_nkt(DB_TASK *task)
{
    int i;

    dbe_out(dbe_getstr(M_SHOWKL), STDOUT);
    for (i = 0; i < task->size_fd;)
        show_fd(&i, 0, 1, task);

    return 0;
}

/* ********************** Show fields ******************************** */

/* Show list of fields in database
*/
int show_nfd(DB_TASK *task)
{
    int i;

    dbe_out(dbe_getstr(M_SHOWRF), STDOUT);
    for (i = 0; i < task->size_fd;)
        show_fd(&i, 0, 0, task);

    return 0;
}


/* Show one field
*/
int show_fd(
    int *index_ptr,      /* Index in field table */
    int level,           /* Recursion level, for tabs */
    int keys,            /* Flag - only show keys */
    DB_TASK *task)
{
    FIELD_ENTRY *fd_ptr;
    DB_TCHAR buffer[LINELEN], dimstr[16];
    int i, j, n, index, comma, optkey, compound;
    short dim, flags;

    n = (index = *index_ptr) + 1;
    fd_ptr = &task->field_table[index];
    flags = fd_ptr->fd_flags;

    /* Just key fields ? */

    if (keys && fd_ptr->fd_key == 'n')
    {
        *index_ptr = n;
        return(0);
    }

    /* Spacing */

    vtstrcpy(buffer, dbe_getstr(M_TAB));
    for (i = 0; i < level; i++)
        vtstrcat(buffer, dbe_getstr(M_TAB));

    /* Key fields - compound / optional / unique */

    if (((compound = (fd_ptr->fd_type == 'k')) != 0) || fd_ptr->fd_key != 'n')
    {
        if (compound)
            vtstrcat(buffer, dbe_getstr(M_COMP));
        if (((flags & OPTKEYMASK) >> OPTKEYSHIFT) & OPTKEYNDX)
            vtstrcat(buffer, dbe_getstr(M_OPT));
        if (fd_ptr->fd_key == 'u')
            vtstrcat(buffer, dbe_getstr(M_UNIQ));
        vtstrcat(buffer, dbe_getstr(M_KEY));
    }

    /* Field type */

    if (flags & UNSIGNEDFLD)
        vtstrcat(buffer, dbe_getstr(M_UNSIGN));
    switch (fd_ptr->fd_type)
    {
        case 'c':
            vtstrcat(buffer, dbe_getstr(M_CHAR));
            break;
        case 'C':
            vtstrcat(buffer, dbe_getstr(M_WIDECHAR));
            break;
        case 's':
            vtstrcat(buffer, dbe_getstr(M_SHORT));
            break;
        case 'i':
            vtstrcat(buffer, dbe_getstr(M_INT));
            break;
        case 'l':
            vtstrcat(buffer, dbe_getstr(M_LONG));
            break;
        case 'f':
            vtstrcat(buffer, dbe_getstr(M_FLOAT));
            break;
        case 'F':
            vtstrcat(buffer, dbe_getstr(M_DOUBLE));
            break;
        case 'd':
            vtstrcat(buffer, dbe_getstr(M_ADDR));
            break;

        case 'g':
            vtstrcat(buffer, dbe_getstr(M_STRUCT));
            vtstrcat(buffer, DB_TEXT("\n"));
            dbe_out(buffer, STDOUT);
            while ((task->field_table[n].fd_flags & STRUCTFLD) && (n < task->size_fd))
                show_fd(&n, level + 1, 0, task);
            vtstrcpy(buffer, dbe_getstr(M_TAB));
            vtstrcat(buffer, DB_TEXT("} "));
            break;
    }

    /* Field name */

    vtstrcat(buffer, task->field_names[index]);

    /* Array dimensions */

    for (i = 0; i < MAXDIMS; i++)
    {
        if (!(dim = fd_ptr->fd_dim[i]))
            break;
        vstprintf(dimstr, DB_TEXT("[%d]"), dim);
        vtstrcat(buffer, dimstr);
    }

    /* Compound keys */

    if (compound)
        vtstrcat(buffer, DB_TEXT(" {"));
    vtstrcat(buffer, DB_TEXT("\n"));
    if (compound)
    {
        dbe_out(buffer, STDOUT);
        for (j = fd_ptr->fd_ptr; task->key_table[j].kt_key == index; j++)
        {
            vtstrcpy(buffer, dbe_getstr(M_TAB));
            for (i = 0; i < level + 1; i++)
                vtstrcat(buffer, dbe_getstr(M_TAB));
            vtstrcat(buffer, task->field_names[task->key_table[j].kt_field]);
            if (task->key_table[j].kt_sort == 'a')
                vtstrcat(buffer, dbe_getstr(M_ASC));
            else
                vtstrcat(buffer, dbe_getstr(M_DESC));
            vtstrcat(buffer, DB_TEXT("\n"));
            dbe_out(buffer, STDOUT);
        }
        vtstrcpy(buffer, dbe_getstr(M_TAB));
        for (i = 0; i < level; i++)
            vtstrcat(buffer, dbe_getstr(M_TAB));
        vtstrcat(buffer, DB_TEXT("}\n"));
    }

    dbe_out(buffer, STDOUT);

    /* Flags */

    if (flags)
    {
        comma = 0;
        vtstrcpy(buffer, dbe_getstr(M_TAB));
        for (i = 0; i < level; i++)
            vtstrcat(buffer, dbe_getstr(M_TAB));
        vtstrcat(buffer, dbe_getstr(M_SHOWFF));
        if (flags & SORTFLD)
        {
            vtstrcat(buffer, dbe_getstr(M_FLAGFF));
            comma = 1;
        }
        if (flags & STRUCTFLD)
        {
            if (comma)
                vtstrcat(buffer, DB_TEXT(", "));
            vtstrcat(buffer, dbe_getstr(M_FLAGFS));
            comma = 1;
        }
        if (flags & UNSIGNEDFLD)
        {
            if (comma)
                vtstrcat(buffer, DB_TEXT(", "));
            vtstrcat(buffer, dbe_getstr(M_FLAGFU));
            comma = 1;
        }
        if (flags & COMKEYED)
        {
            if (comma)
                vtstrcat(buffer, DB_TEXT(", "));
            vtstrcat(buffer, dbe_getstr(M_FLAGFC));
            comma = 1;
        }
        if ((optkey = ((flags & OPTKEYMASK) >> OPTKEYSHIFT) & OPTKEYNDX) != 0)
        {
            optkey--;
            if (comma)
                vtstrcat(buffer, DB_TEXT(", "));
            vstprintf(buffer + vtstrlen(buffer), DB_TEXT("%s%d"),
                dbe_getstr(M_FLAGFO), optkey);
        }
        vtstrcat(buffer, DB_TEXT("\n"));
        dbe_out(buffer, STDOUT);
    }

    *index_ptr = n;

    return 0;
}