ddlp.y

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

    }
                     |       error ';'
    {
        dderror(DB_TEXT("invalid field spec"), $2.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

om_field        :       T_DIRECTREF T_IDENT
    {
        /* Handle DIRECTREF macro for om */
        if ((om = (OM_INFO *) psp_cGetMemory(sizeof(OM_INFO), 0)) == NULL)
            ddlp_abort(DB_TEXT("out of memory"));

        om->related = FALSE;
        if (ti->type_char != 'd')
            dderror(DB_TEXT("invalid field spec"), $1.numline); 
        else
        {
            om->dref = TRUE;
            vtstrcpy(om->dref_name, $2.str); 
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |        T_RELATEDTO T_IDENT T_THRU T_IDENT
    {
        /* Handle RELATEDTO macro for om */
        if ((om = (OM_INFO *) psp_cGetMemory(sizeof(OM_INFO), 0)) == NULL)
	    ddlp_abort(DB_TEXT("out of memory"));

        om->dref = FALSE;
        om->related = TRUE;
        vtstrcpy(om->rel_rec, $2.str);
        vtstrcpy(om->rel_field, vtstrupr($4.str));
    }
                     |
    {
        if ((om = (OM_INFO *)psp_cGetMemory(sizeof(OM_INFO), 0)) == NULL)
	    ddlp_abort(DB_TEXT("out of memory"));

        om->dref = FALSE;
        om->related = FALSE;
    }
                     ;

/* ------------------------------------------------------------------------ */
            
sign            :
    { sign_flag = 0; }
                     |       T_UNSIGNED
    { sign_flag = 1; }
                     ;

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

key_spec        :       opt_key T_UNIQUE T_KEY
    {
        if (!in_db)
            dderror(DB_TEXT("predefined structures cannot contain keys"), $3.numline);
        else
            ddlp_g.fd_entry.fd_key = 'u';
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       opt_key T_KEY
    {
        if (!in_db)
            dderror(DB_TEXT("predefined structures cannot contain keys"), $2.numline);
        else
            ddlp_g.fd_entry.fd_key = 'd';
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |
    {  ddlp_g.fd_entry.fd_flags = 0; ddlp_g.fd_entry.fd_key = 'n'; }
                     ;

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

opt_key         :       T_OPTIONAL
    {
        /* Optional key number will begin with 1 */
        ++n_optkeys;
        if ( n_optkeys > OPTKEY_LIMIT )
        {
            vstprintf(ddlp_g.msg,
                DB_TEXT("optional key per record limit (%d keys) exceeded"),
                OPTKEY_LIMIT);
            dderror(ddlp_g.msg, $1.numline);
        }
        else
            ddlp_g.fd_entry.fd_flags = (short) (n_optkeys << OPTKEYSHIFT);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |
    { ddlp_g.fd_entry.fd_flags = 0; }
                     ;

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

type_spec       :       sign T_IDENT
    { 
        if ((ti = find_type($2.str, sign_flag)) == NULL)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("invalid data type: %s"), $2.str);
            dderror(ddlp_g.msg, $2.strline);
        }
        if ( vtstrcmp($2.str, DB_TEXT("int")) == 0 )
        {
            vstprintf(ddlp_g.msg, DB_TEXT("non-portable data type: %s"), $2.str);
            ddwarning(ddlp_g.msg, $2.strline);
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       struct_spec
                     ;

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

size_specs      :       size_init size_decls
                     |       size_init
                     ;

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

size_init       :
    {
        /* clear array dimension info */
        for ( dim = 0; dim < MAXDIMS; ++dim )
        {
            ddlp_g.fd_entry.fd_dim[dim] = 0;
            ci[dim] = NULL;
        }
        dim = 0;
    }
                     ;

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

size_decls      :       size
                     |       size_decls size
                     ;

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

size            :       '[' T_NUMBER ']'
    {
        if ( dim == MAXDIMS )
        {
            vstprintf(ddlp_g.msg, DB_TEXT("too many array dimensions, maximum is %d"), MAXDIMS);
            dderror(ddlp_g.msg, $2.numline);
        }
        else
            ddlp_g.fd_entry.fd_dim[dim++] = (short) ($2.num);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       '[' T_IDENT ']'
    {
        if (find_const($2.str, &tempnum))
        {
            if (dim == MAXDIMS)
            {
                vstprintf(ddlp_g.msg, DB_TEXT("too many array dimensions, maximum is %d"), MAXDIMS);
                dderror(ddlp_g.msg, $2.strline);
            }
            else
            {
                ddlp_g.fd_entry.fd_dim[dim] = tempnum;
                ci[dim++] = find_const($2.str, &tempnum);
            }
        }
        else
            dderror(DB_TEXT("constant not defined"), $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

key_defs        :       key_field
                     |       key_defs key_field
                     ;

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

key_field       :       T_COMPOUND key_id '{' comfld_defs '}'
                     ;

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

key_id          :       key_spec T_IDENT
    { 
        /* clear array dimension info */
        for ( dim = 0; dim < MAXDIMS; ++dim )
            ddlp_g.fd_entry.fd_dim[dim] = 0, ci[dim] = NULL;
        dim = 0;
        ddlp_g.fd_entry.fd_type = 'k';
        add_field(rec_comp, $2.str, $2.strline, ci, NULL, NULL); 
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

comfld_defs     :       comfld_spec
                     |       comfld_defs comfld_spec
                     ;

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

comfld_spec     :       T_IDENT key_order ';'
    {
        add_key(rec_comp, $1.str, $1.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

key_order       :       T_ASCENDING
    { ddlp_g.kt_entry.kt_sort = 'a'; }
                     |       T_DESCENDING
    { ddlp_g.kt_entry.kt_sort = 'd'; }
                     |
    { ddlp_g.kt_entry.kt_sort = 'a'; }
                     ;

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

set_spec        :       T_BITMAP T_SET set_prefix members closing_brace
    {
        current_set->om_set_type = DB_BITMAP;
    }
                     |       T_BITMAP T_SET error closing_brace
    {
        dderror(DB_TEXT("invalid set spec"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_BLOB T_SET set_prefix members closing_brace
    {
        current_set->om_set_type = DB_BLOB;
    } 
                     |       T_BLOB T_SET error closing_brace
    {
        dderror(DB_TEXT("invalid set spec"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_VARILEN T_SET set_prefix members closing_brace
    {
        current_set->om_set_type = VLTEXT;
    }
                     |       T_VARILEN T_SET error closing_brace
    {
        dderror(DB_TEXT("invalid set spec"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_SET set_prefix members closing_brace
                     |       T_SET error closing_brace
    {
        dderror(DB_TEXT("invalid set spec"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

set_prefix      :       T_IDENT '{' ordering owner
    {
        last_ordering = ddlp_g.st_entry.st_order;
        current_set = add_set($1.str, $4.str, $1.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

ordering        :       T_ORDER order_type ';'
                     ;

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

order_type      :       T_FIRST
    { ddlp_g.st_entry.st_order = 'f'; }
                     |       T_LAST
    { ddlp_g.st_entry.st_order = 'l'; }
                     |       T_ASCENDING
    { ddlp_g.st_entry.st_order = 'a'; }
                     |       T_DESCENDING
    { ddlp_g.st_entry.st_order = 'd'; }
                     |       T_NEXT
    { ddlp_g.st_entry.st_order = 'n'; }
                     |       T_IDENT
    {
        vstprintf(ddlp_g.msg, DB_TEXT("invalid order type, '%s'"), $1.str);
        dderror(ddlp_g.msg, $1.strline);
        ddlp_g.st_entry.st_order = 'f';
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

owner           :       T_OWNER T_IDENT ';'
    { 
        vtstrcpy($$.str, $2.str); 
        add_xref(NULL, $2.str, 'r', $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

members         :       member
    {
        memList = (MEM_INFO *) psp_cGetMemory(sizeof(MEM_INFO), 0);
        if (memList == NULL)
            ddlp_abort(DB_TEXT("out of memory"));

        vtstrcpy(memList->rec_name, $1.str);
        memList->next_mem = NULL;
        currmem = memList;
        if (ddlp_g.abort_flag)
            return(-1);
    } 
                     |       members member
    {
        currmem->next_mem = (MEM_INFO *) psp_cGetMemory(sizeof(MEM_INFO), 0);
        if ((currmem = currmem->next_mem) == NULL)
            ddlp_abort(DB_TEXT("out of memory"));

        vtstrcpy(currmem->rec_name, $2.str);
        currmem->next_mem = NULL;
        if (ddlp_g.abort_flag)
            return(-1);
    } 
                     ;

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

member          :       T_MEMBER T_IDENT ';'
    {
        if ( last_ordering == 'a' || last_ordering == 'd' )
            dderror(DB_TEXT("sort field(s) missing from member clause"), $1.numline);
        if ( vtstrcmp($2.str, DB_TEXT("system")) == 0 )
            dderror(DB_TEXT("'system' cannot be a member"), $2.strline);
        else 
        {
            add_member($2.str, NULL, $2.strline);
            vtstrcpy($$.str, $2.str); 
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_MEMBER T_IDENT T_BY id_list ';'
    {
        if ( last_ordering != 'a' && last_ordering != 'd' )
            dderror(DB_TEXT("sort field(s) not required in member clause"), $1.numline);
        if ( vtstrcmp($2.str, DB_TEXT("system")) == 0 )
            dderror(DB_TEXT("'system' cannot be a member"), $2.strline);
        else
        {
            add_member($2.str, id_list, $2.strline);
            vtstrcpy($$.str, $2.str); 
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;
%%

/* $Revision:   1.25.1.6  $ */