ddltable.c

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

CONST_INFO *find_const(DB_TCHAR *name, short *value)
{
    CONST_INFO *p = const_list;

    while (p)
    {
        if (vtstrcmp(p->const_name, name) == 0)
        {
            *value = p->value;
            return (p);
        }
        p = p->next_const;
    }
    return (NULL);
}

/* Add a structure element to the element list
*/
int add_elem(DB_TCHAR *name, char key, TYPE_INFO *ti, short *dims, CONST_INFO **ci)
{
    ELEM_INFO *p = ddlp_g.elem_list;
    unsigned short i, j;

    if (ddlp_g.s_flag)
        vtstrlwr(name);

    while (p)
    {
        if (vtstrcmp(p->field_name, name) == 0)
            return (0);
        p = p->next_elem;
    }

    if ((p = (ELEM_INFO *) psp_cGetMemory(sizeof(ELEM_INFO), 0)) == NULL)
    {
        ddlp_abort(DB_TEXT("out of memory"));
        return (0);
    }

    if (ddlp_g.elem_last == NULL)
        ddlp_g.elem_list = p;
    else
        ddlp_g.elem_last->next_elem = p;

    ddlp_g.elem_last = p;
    p->next_elem = NULL;
    vtstrcpy(p->field_name, name);
    p->field_type = ti;
    p->use_count = 0;
    p->key = key;
    for (i = 0; ti && (i < MAXDIMS) && ti->dims[i]; i++)
        p->dims[i] = ti->dims[i];
    for (j = 0; i < MAXDIMS; i++, j++)
    {
        p->dims[i] = dims[j];
        p->dim_const[i] = ci[j];
    }
    return (1);
}

static void free_elems(ELEM_INFO *elem)
{
    ELEM_INFO *p = elem, *q;

    while (p)
    {
        q = p->next_elem;
        psp_freeMemory(p, 0);
        p = q;
    }
}

/* Add fields for a predefined structure
*/
void add_struct_fields(DB_TCHAR *rec_name, int line_num, ELEM_INFO *elem)
{
    int i;

    while (elem)
    {
        ddlp_g.fd_entry.fd_len = elem->field_type->type_size;
        ddlp_g.fd_entry.fd_type = elem->field_type->type_char;
        ddlp_g.fd_entry.fd_flags = (short) (elem->field_type->type_sign ? UNSIGNEDFLD : 0);
        ddlp_g.fd_entry.fd_key = elem->key;
        for (i = 0; i < MAXDIMS; i++)
        {
            ddlp_g.fd_entry.fd_dim[i] = elem->dims[i];
            if (ddlp_g.fd_entry.fd_dim[i])
                ddlp_g.fd_entry.fd_len *= ddlp_g.fd_entry.fd_dim[i];
        }
        add_field(rec_name, elem->field_name, line_num, elem->dim_const,
                elem->field_type, NULL);
        elem = elem->next_elem;
    }
}

/* Find file associated with specified record or field name
*/
static struct file_info *find_file(DB_TCHAR *rname, DB_TCHAR *name, short *fno)
{
    struct file_info *p;
    ID_INFO *q;

    for (*fno = 0, p = ddlp_g.file_list; p; p = p->next_file, ++(*fno))
    {
        for (q = p->name_list; q; q = q->next_id)
        {
            if (vtstrcmp(name, q->id_name) == 0)
            {
                if (rname)
                {
                    if (vtstrcmp(rname, q->id_rec) == 0)
                    {
                        /* match */
                        return (p);
                    }
                    else if (vtstrlen(q->id_rec) == 0)
                    {
                        /* be ready to check for future match */
                        vtstrcpy(q->id_rec, rname);
                        return (p);
                    }
                }
                else
                {
                    return (p);
                }
            }
        }
    }

    return (NULL);
}


/* Find record name in record list
*/
struct record_info *find_rec(DB_TCHAR *rname, short *rno)
{
    struct record_info *p;

    for (*rno = 0, p = ddlp_g.rec_list; p; p = p->next_rec, ++(*rno))
    {
        if (vtstrcmp(rname, p->rec_name) == 0)
            break;
    }
    return (p);
}


/* Find field name in field list
*/
static struct field_info *find_fld(DB_TCHAR *rname, DB_TCHAR *fname, short *fno)
{
    struct field_info *p;
    short rno;

    if (rname)
    {
        if (find_rec(rname, &rno) == NULL)
            return (struct field_info *) NULL;
    }
    else
    {
        rno = -1;
    }

    for (*fno = 0, p = ddlp_g.field_list; p; p = p->next_field, ++(*fno))
    {
        if (vtstrcmp(fname, p->fld_name) == 0)
        {
            if (rno >= 0)
            {
                if (rno == p->fd.fd_rec)
                    break;
            }
            else
            {
                break;
            }
        }
    }
    return (p);
}


/* Find set name in set list
*/
static struct set_info *find_set(DB_TCHAR *sname)
{
    struct set_info *p;

    for (p = ddlp_g.set_list; p; p = p->next_set)
    {
        if (vtstrcmp(p->set_name, sname) == 0)
            break;
    }
    return (p);
}


static int check_dup_name(
    DB_TCHAR *name,   /* name to check */
    DB_TCHAR *rname,  /* record name if this is a field, NULL otherwise */
    int line_num,     /* ddlp_g.line for error report */
    int fatal)        /* 1 if FATAL error, 0 otherwise */
{
    struct record_info *rec;
    struct set_info *set;
    struct field_info *field;
    short rno;
    short fno;

    /* Is it a Set name */
    for (set = ddlp_g.set_list; set; set = set->next_set)
    {
        if (vtstrcmp(set->set_name, name) == 0)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("set type %s previously defined"), name);
            if (fatal)
                ddlp_abort(ddlp_g.msg);
            else
                dderror(ddlp_g.msg, line_num);
            return (1);
        }
    }

    /* It it a record name */
    for (rec = ddlp_g.rec_list; rec; rec = rec->next_rec)
    {
        if (vtstrcmp(rec->rec_name, name) == 0)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("record type %s is already defined"), name);
            if (fatal)
                ddlp_abort(ddlp_g.msg);
            else
                dderror(ddlp_g.msg, line_num);
            return (1);
        }
    }

    /* Is it a Field name */
    /* if the ddlp_g.d_flag is not set then check all
       records because no dups are allowed
    */
    if (!ddlp_g.d_flag)
    {
        for ( fno = 0, field = ddlp_g.field_list;
              field;
              field = field->next_field, ++fno)
        {
            if (vtstrcmp(name, field->fld_name) == 0)
            {
                vstprintf(ddlp_g.msg, DB_TEXT("field '%s' is already defined"), name);
                if (fatal)
                    ddlp_abort(ddlp_g.msg);
                else
                    dderror(ddlp_g.msg, line_num);
                return (1);
            }
        }
    }
    else
    {
        /* we only need to check the given record name, otherwise OK */
        if (rname)
        {
            if (find_rec(rname, &rno) != NULL)
            {
                for ( fno = 0, field = ddlp_g.field_list;
                      field;
                      field = field->next_field, ++fno)
                {
                    if (vtstrcmp(name, field->fld_name) == 0)
                    {
                        if (rno == field->fd.fd_rec)
                        {
                            vstprintf(ddlp_g.msg,
                                DB_TEXT("field '%s' is already defined for this record"),
                                name);
                            if (fatal)
                                ddlp_abort(ddlp_g.msg);
                            else
                                dderror(ddlp_g.msg, line_num);
                            return (1);
                        }
                    }
                }
            }
        }
    }

    return (0);
}


/* Copy a file name, checking its format and length
*/
void cpfile(DB_TCHAR *ft_name, DB_TCHAR *str, int line_num)
{

    /* check the length */
    if (vtstrlen(str) > FILENMLEN - 1)
    {
        vtstrncpy(ft_name, str, FILENMLEN);
        ft_name[FILENMLEN-1] = '\0';
        vstprintf(ddlp_g.msg, DB_TEXT("file id/name %s is too long"), str);
        dderror(ddlp_g.msg, line_num);
        return;
    }
    vtstrcpy(ft_name, str);               /* unix */
}


/* Add file to file_info
*/
struct file_info *add_file(DB_TCHAR *fileid, ID_INFO *idlist, int line_num)
{
    short i;
    struct file_info *p;
    ID_INFO *q;

    if (ddlp_g.s_flag)
        vtstrlwr(fileid);

    if (ddlp_g.tot_files >= (FILEMASK + 1))
    {
        ddlp_abort(DB_TEXT("too many files defined in database"));
        return (NULL);
    }

    /* check to see if file already defined */
    for (p = ddlp_g.file_list; p; p = p->next_file)
    {
        if (fileid && vtstrcmp(p->fileid, fileid) == 0)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("file id %s has been previously defined"), fileid);
            dderror(ddlp_g.msg, line_num);
            return (NULL);
        }
        if (vtstrcmp(p->ft.ft_name, ddlp_g.ft_entry.ft_name) == 0)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("file name %s has been previously defined"), ddlp_g.ft_entry.ft_name);
            dderror(ddlp_g.msg, line_num);
            return (NULL);
        }
    }

    /* verify that rec/field names in idlist are not in other files */
    for (q = idlist; q; q = q->next_id)
    {
        if (find_file(q->id_rec, q->id_name, &i))
        {
            vstprintf(ddlp_g.msg, DB_TEXT("record/field %s is contained in another file"),
                q->id_name);
            dderror(ddlp_g.msg, line_num);
            return (NULL);
        }
        if (ddlp_g.x_flag)
        {
            add_xref(q->id_rec, q->id_name,
                (char) ((ddlp_g.ft_entry.ft_type == 'd') ? 'r' : 'f'), q->id_line);
        }
    }

    /* allocate space and fill file info */
    p = (struct file_info *) psp_cGetMemory(sizeof(struct file_info), 0);
    if (p == NULL)
    {
        ddlp_abort(DB_TEXT("out of memory"));
        return (NULL);
    }

    if (ddlp_g.file_last == NULL)
        ddlp_g.file_list = p;
    else
        ddlp_g.file_last->next_file = p;
    ddlp_g.file_last = p;
    p->next_file = NULL;
    p->name_list = idlist;
    if (fileid)
        vtstrcpy(p->fileid, fileid);
    else
        p->fileid[0] = 0;
    memcpy(&(p->ft), &ddlp_g.ft_entry, sizeof(FILE_ENTRY));
    p->ft.ft_status = 'c';


    ++ddlp_g.tot_files;
    return (p);
}


/* Add record definition
*/
struct record_info *add_record(DB_TCHAR *rname, int line_num)
{
    short fno;
    struct file_info *f;
    struct record_info *p;

    if (ddlp_g.s_flag)
        vtstrlwr(rname);

    /* Ensure record not previously defined */
    check_dup_name(rname, NULL, line_num, FATAL);

    /* Ensure record contained in specified file */
    if ((f = find_file(NULL, rname, &fno)) == NULL)
    {
        vstprintf(ddlp_g.msg, DB_TEXT("record type %s is not contained in a file"), rname);
        ddlp_abort(ddlp_g.msg);
        return (NULL);
    }
    if (f->ft.ft_type != 'd')
    {
        vstprintf(ddlp_g.msg,
            DB_TEXT("record type %s needs to be contained in a data file, not a key file"),
            rname);
        ddlp_abort(ddlp_g.msg);
        return (NULL);
    }

    /* allocate space and initialize record */
    p = (struct record_info *) psp_cGetMemory(sizeof(struct record_info), 0);
    if (p == NULL)
    {
        ddlp_abort(DB_TEXT("out of memory"));
        return (NULL);
    }
    if (ddlp_g.last_rec == NULL)
        ddlp_g.rec_list = p;
    else
        ddlp_g.last_rec->next_rec = p;
    ddlp_g.last_rec = p;
    vtstrncpy(p->rec_name, rname, NAMELEN - 1);
    p->rec_name[NAMELEN - 1] = 0;
    memcpy(&(p->rt), &ddlp_g.rt_entry, sizeof(RECORD_ENTRY));
    p->rt.rt_data = 0;
    p->rt.rt_len = 0;
    p->rt.rt_fdtot = (short) (vtstricmp(rname, DB_TEXT("system")) ? 0 : -1);
    p->rt.rt_fields = ddlp_g.tot_fields;
    p->rt.rt_file = fno;

    if (ts_all_recs)
        p->rt.rt_flags |= TIMESTAMPED;

    p->totown = 0;