ddlp.y

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

        {
            vtstrlwr(id_list->id_name);
            vtstrlwr(id_list->id_rec);
        }
        id_list->id_line = ddlp_g.line;
        id_list->next_id = NULL;
        currid = id_list;
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       id_list ',' id_item
    {
        for ( ids = id_list; ids; ids = ids->next_id )
        {
            if ( vtstrcmp(ids->id_name, fld_comp) == 0 )
            {
                if ( vtstrcmp(ids->id_rec, rec_comp) == 0 )
                {
                    if ( vtstrlen(rec_comp) )
                        vstprintf(ddlp_g.msg,
                            DB_TEXT("identifier %s.%s is already specified in this list"),
                            ids->id_rec, ids->id_name);
                    else
                        vstprintf(ddlp_g.msg,
                            DB_TEXT("identifier %s is already specified in this list"),
                            ids->id_name);
                    dderror(ddlp_g.msg, ddlp_g.line);
                    break;
                }
            }
        }
        if ( !ids )
        {
            currid->next_id = (ID_INFO *) psp_cGetMemory(sizeof(ID_INFO), 0);
            if ((currid = currid->next_id) == NULL)
                ddlp_abort(DB_TEXT("out of memory"));

            vtstrcpy(currid->id_name, fld_comp);
            vtstrcpy(currid->id_rec, rec_comp);
            if (ddlp_g.s_flag)
            {
                vtstrlwr(currid->id_name);
                vtstrlwr(currid->id_rec);
            }   
            currid->id_line = ddlp_g.line;
            currid->next_id = NULL;
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       error ';'
    {
        dderror(DB_TEXT("non-identifier specified in list"), $2.numline);
        ddlp_unput(DB_TEXT(';'));
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

id_item         :       T_IDENT
    {
        if (vtstricmp($1.str, DB_TEXT("SYSTEM")) == 0)
            vtstrcpy(fld_comp, DB_TEXT("system"));
        else
            vtstrcpy(fld_comp, $1.str);
        rec_comp[0] = 0;
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_IDENT '.' T_IDENT
    {
        vtstrcpy(fld_comp, $3.str);
        if ( !ddlp_g.d_flag )
            ddwarning(DB_TEXT("must use '-d' switch to qualify field names"), ddlp_g.line);
        else
            vtstrcpy(rec_comp, $1.str);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

ddl_stmts       :       ddl_stmt
                     |       ddl_stmts ddl_stmt
                     ;

/* ------------------------------------------------------------------------ */

ddl_stmt        :       timestamp
                     |       file_spec
                     |       record_spec
                     |       set_spec
    {
        while (memList)
        {
            mem = memList->next_mem;
            psp_freeMemory(memList, 0);
            memList = mem;
        }
    } 
                     |       error 
    {
        yyerror("invalid ddl statement");
    }
                     ;

/* ------------------------------------------------------------------------ */

timestamp       :       T_TIMESTAMP T_RECS id_list ';'
    {
        ts_recs(id_list);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TIMESTAMP T_RECS ';'
    {
        ts_recs(NULL);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TIMESTAMP T_SETS id_list ';'
    {
        ts_sets(id_list);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TIMESTAMP T_SETS ';'
    {
        ts_sets(NULL);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TIMESTAMP error ';'
    {
        dderror(DB_TEXT("invalid timestamp statement"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

file_spec       :       file_type file_id allocation T_CONTAINS id_list ';'
    {
        add_file(NULL, id_list, $4.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       file_type T_IDENT '=' file_id allocation T_CONTAINS id_list ';'
    {
        add_file($2.str, id_list, $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       file_type T_FILE error ';'
    {
        dderror(DB_TEXT("invalid file specification"), $2.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

allocation      :      
    { }
                     |       '(' alloc_opts ')'
    { }
                     ;

/* ------------------------------------------------------------------------ */

alloc_opts      :       alloc_opt
                     |       alloc_opts alloc_opt
                     ;

/* ------------------------------------------------------------------------ */

alloc_opt       :       T_INITIAL '=' T_NUMBER
    { ddlp_g.ft_entry.ft_initial = $3.num; }
                     |       T_NEXT '=' T_NUMBER
    { ddlp_g.ft_entry.ft_next = $3.num; }
                     |       T_PCTINCREASE '=' T_NUMBER
    { ddlp_g.ft_entry.ft_pctincrease = $3.num; }
                     |       T_PAGESIZE '=' T_NUMBER
    {
        if ($3.num < 128)
        {
            ddwarning(DB_TEXT("file page size must be at least 128"), $3.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else if ($3.num > 32766)
        {
            ddwarning(DB_TEXT("maximum file page size is 32766"), $3.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else
        {
            ddlp_g.ft_entry.ft_pgsize = (short) $3.num;
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

file_type       :       data_or_key T_FILE file_size
    { ddlp_g.ft_entry.ft_initial = ddlp_g.ft_entry.ft_next = ddlp_g.ft_entry.ft_pctincrease = 0; }
                     ;

/* ------------------------------------------------------------------------ */

data_or_key     :       T_DATA
    { ddlp_g.ft_entry.ft_type = 'd'; }
                     |       T_KEY
    { ddlp_g.ft_entry.ft_type = 'k'; }
                     ;

/* ------------------------------------------------------------------------ */

file_size       :
    {
        if (pagesize == 0 && ddlp_g.ft_entry.ft_type == 'k')
            ddlp_g.ft_entry.ft_pgsize = 1024;     /* THIS SHOULD CHANGE IF MAXKEYSIZE CHANGES */
        else
            ddlp_g.ft_entry.ft_pgsize = pagesize;
    }
                     |       '[' T_NUMBER ']' 
    {
        if ( $2.num < 128 )
        {
            ddwarning(DB_TEXT("file page size must be at least 128"), $2.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else if ( $2.num > 32766 )
        {
            ddwarning(DB_TEXT("maximum file page size is 32766"), $2.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else
        {
            ddlp_g.ft_entry.ft_pgsize = (short) $2.num;
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       '[' T_IDENT ']'
    {
        if (find_const($2.str, &tempnum))
        {
            if (tempnum < 128)
            {
                ddwarning(DB_TEXT("file page size must be at least 128"), $2.strline);
                ddlp_g.ft_entry.ft_pgsize = pagesize;
            }
            else if (tempnum > 32766)
            {
                ddwarning(DB_TEXT("maximum file page size is 32766"), $2.strline);
                ddlp_g.ft_entry.ft_pgsize = pagesize;
            }
            else
                ddlp_g.ft_entry.ft_pgsize = (short) tempnum;
        }
        else
            dderror(DB_TEXT("constant not defined"), $2.strline);

        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

file_id         :       T_IDENT
    {
        cpfile(ddlp_g.ft_entry.ft_name, $1.str, $1.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_STRING
    {
        cpfile(ddlp_g.ft_entry.ft_name, $1.str, $1.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

record_spec     :       rec_id field_defs key_defs closing_brace
                     |       rec_id field_defs closing_brace
                     |       rec_id closing_brace
                     |       rec_type error closing_brace
    {
        dderror(DB_TEXT("invalid record spec"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

rec_id          :       rec_type T_IDENT '{'
    {
        if (vtstrcmp($2.str, DB_TEXT("system")) == 0)
            ddlp_abort(DB_TEXT("'system' is a reserved record name"));
        vtstrcpy(rec_comp, $2.str);
        add_record($2.str, $2.strline);
        n_optkeys = 0;
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

/* ------------------------------------------------------------------------ */

rec_type        :       T_RECORD
    { ddlp_g.rt_entry.rt_flags = 0; }
                     |       T_STATIC T_RECORD
    { ddlp_g.rt_entry.rt_flags = STATIC; }
                     ;

/* ------------------------------------------------------------------------ */

field_defs      :       field_spec
                     |       field_defs field_spec
                     ;

/* ------------------------------------------------------------------------ */

field_spec      :       key_spec type_spec T_IDENT size_specs om_field ';'
    { 
        if (ti)
        {
            /* If the name has not been entered */
            if (ti->elem == NULL)
            {
                int tot_dims;
                short tmp_dims[MAXDIMS];

                ddlp_g.fd_entry.fd_type = ti->type_char;
                ddlp_g.fd_entry.fd_len  = ti->type_size;
                ddlp_g.fd_entry.fd_flags |= (unsigned short)(ti->type_sign ? UNSIGNEDFLD : 0);
                /* calculate length of field */
                memset(tmp_dims, 0, sizeof(tmp_dims));
                for (elts = 1, tot_dims = 0; dim < MAXDIMS && ti->dims[tot_dims]; ++tot_dims)
                {  
                    tmp_dims[tot_dims] = ti->dims[tot_dims];
                    elts = elts * ti->dims[tot_dims];
                }
                for (dim = 0; dim < MAXDIMS && ddlp_g.fd_entry.fd_dim[dim]; ++dim, ++tot_dims)
                {
                    if (tot_dims >= MAXDIMS)
                    {
                        vstprintf(ddlp_g.msg,
                            DB_TEXT("too many array dimensions, maximum is %d"),
                            MAXDIMS);
                        dderror(ddlp_g.msg, $3.strline);
                        break;
                    }
                    tmp_dims[tot_dims] = ddlp_g.fd_entry.fd_dim[dim];
                    elts = elts * ddlp_g.fd_entry.fd_dim[dim];
                }
                memcpy(ddlp_g.fd_entry.fd_dim, tmp_dims, sizeof(tmp_dims));
                if (elts)
                    ddlp_g.fd_entry.fd_len *= (short) elts;
                add_field(rec_comp, $3.str, $3.strline, ci, ti, om);
            }
            else
            {
                add_field(rec_comp, NULL, $3.strline, ci, ti, om);
                add_struct_fields(rec_comp, $3.strline, ti->elem);
                if (!vtstrcmp(ti->type_name, DB_TEXT("_s_temp_")))
                {
                    del_type(DB_TEXT("_s_temp_"));
                    ti = NULL;
                }
                close_struct(rec_comp, $3.str, $3.strline);
            }
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       key_spec type_spec error
    {
        dderror(DB_TEXT("invalid field name"), ddlp_g.line);
        if (ddlp_g.abort_flag)
            return(-1);