ddlp.y

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

%{
/***************************************************************************
 *                                                                         *
 * db.*                                                                    *
 * open source database, ddlp utility                                      *
 *                                                                         *
 * Copyright (c) 2000 Centura Software Corporation. All rights reserved.   *
 *                                                                         *
 * Use of this software, whether in source code format, or in executable,  *
 * binary object code form, is governed by the CENTURA OPEN SOURCE LICENSE *
 * which is fully described in the LICENSE.TXT file, included within this  *
 * distribution of source code files.                                      * 
 *                                                                         *
 **************************************************************************/

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

    db.* Database Definition Language Processor

    ddlp.y -- YACC grammar and semantics source

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

#include "db.star.h"
#include "parser.h"
#include "ddldefs.h"

#if defined(UNICODE)
#define yyerror(s) yyerror(L ## s)
#endif

#define YYMAXDEPTH 480

static  DB_TCHAR fld_comp[NAMELEN];
static  DB_TCHAR rec_comp[NAMELEN];
static  short pagesize = 0;  /* if it is still zero, figure it out later */

static  CONST_INFO *ci[MAXDIMS];
static  TYPE_INFO *ti;
static  OM_INFO *om;

static  ID_INFO *id_list, *currid, *ids;
static  MEM_INFO *memList, *currmem, *mem;
static  struct set_info *current_set;
static  int last_ordering;
static  int dim = 0;        /* current # of array dimensions */
static  int elts;
static  int n_optkeys;      /* number of optional keys in record */
static  short tempnum;
static  int sign_flag;
static  int inline_struct = 0;
static  FIELD_ENTRY struct_fd; /* save struct def when processing struct flds */
static  int in_db = 0;


/*lint -e525 */
/*lint -e778 */     /* constant expression evaluates to 0 */

/* Initialize static variables, etc. */
void ddlpInit (void)
{
     pagesize = 0;
     inline_struct = 0;
     dim = 0;
     ddlp_g.abort_flag = 0;
}

/* QNX yacc and byacc (GNU) takes care of this */
#if !defined(QNX) && !defined(VXWORKS) && !defined(yyerrok) && !defined(YYBISON)
#define yyerrok yyerrflag = 0
#endif
%}

%start ddl

%union {
    STRTOK tstr;
    NUMTOK tnum;
}

%token <tnum> T_ALLOCATION T_ASCENDING T_BITMAP T_BLOB T_BY T_COMPOUND
%token <tnum> T_CONST T_CONTAINS T_DATA T_DATABASE T_DEFINE T_DESCENDING
%token <tnum> T_DIRECTREF T_FILE T_FIRST T_INCLUDE T_INITIAL T_KEY T_LAST
%token <tnum> T_LINE T_MEMBER T_NEXT T_NUMBER T_OPTIONAL T_ORDER T_OWNER
%token <tnum> T_PCTINCREASE T_PAGESIZE T_RECORD T_RECS T_RELATEDTO T_SET
%token <tnum> T_SETS T_STATIC T_STRUCT T_THRU T_TIMESTAMP T_TYPEDEF T_UNIQUE
%token <tnum> T_UNSIGNED T_VARILEN
%token <tstr> T_IDENT T_STRING

%token <tnum> '{' '}' ';' ','

%type <tnum> closing_brace const_cmnd cpp_cmnd cpp_cmnds db_spec ddl ddl_stmt
%type <tnum> ddl_stmts define_cmnd file_spec include_cmnd key_defs key_field
%type <tnum> ordering rec_id rec_type record_spec set_spec struct_cmnd
%type <tnum> struct_spec timestamp type_spec typedef_cmnd
%type <tstr> owner member
%%

ddl             :       cpp_cmnds db_spec ddl_stmts closing_brace
                     |       db_spec ddl_stmts closing_brace
                     ;
closing_brace   :       '}'
                     |       '}' ';'
    {
        ddwarning(DB_TEXT("';' not required after '}'"), $2.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       error
    {
        yyerrok;
        dderror(DB_TEXT("missing '}'"), ddlp_g.line);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

cpp_cmnds       :       cpp_cmnd
                     |       cpp_cmnd cpp_cmnds
                     ;

cpp_cmnd        :       const_cmnd
                     |       define_cmnd
                     |       include_cmnd
                     |       struct_cmnd
                     |       typedef_cmnd
                     ;

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

const_cmnd      :       T_CONST T_IDENT '=' T_NUMBER ';'
    {
        if (!add_const($2.str, (short) $4.num))
            ddwarning(DB_TEXT("constant redefined"), $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_CONST T_IDENT '=' T_IDENT ';'
    {
        if (find_const($4.str, &tempnum))
        {
            if (!add_const($2.str, tempnum))
                ddwarning(DB_TEXT("constant redefined"), $2.strline);
        }
        else
            dderror(DB_TEXT("constant not defined"), $4.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_CONST T_IDENT '=' T_NUMBER error
    {
        dderror(DB_TEXT("missing ';'"), $4.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_CONST T_IDENT '=' T_IDENT error
    {
        dderror(DB_TEXT("missing ';'"), $4.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_CONST T_IDENT error
    {
        dderror(DB_TEXT("missing '=' after identifier"), $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_CONST error
    {
        dderror(DB_TEXT("missing identifier after const"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

define_cmnd     :       T_DEFINE T_IDENT T_NUMBER
    {
        if (!add_const($2.str, (short) $3.num))
            ddwarning(DB_TEXT("constant redefined"), $2.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_DEFINE T_IDENT T_IDENT
    {
        if (find_const($3.str, &tempnum))
        {
            if (!add_const($2.str, tempnum))
                ddwarning(DB_TEXT("const redefined"), $2.strline);
        }
        else
            dderror(DB_TEXT("constant not defined"), $3.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

include_cmnd    :       T_INCLUDE T_IDENT
                     ;

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

struct_cmnd     :       struct_spec ';'
                     |       struct_spec error
    {
        dderror(DB_TEXT("missing ';'"), ddlp_g.line);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

struct_spec     :       struct_init T_IDENT '{' struct_elems '}'
    {
        DB_TCHAR tempbuff[NAMELEN];

        vtstrcpy(tempbuff, DB_TEXT("_s_"));
        vtstrcat(tempbuff, $2.str);
        
        if (ddlp_g.elem_list)
        {
            if (!add_struct_type(tempbuff))
            {
                vstprintf(ddlp_g.msg, DB_TEXT("type already defined: %s"), $2.str);
                dderror(ddlp_g.msg, $2.strline);
            }
        }
        
        if ((ti = find_type(tempbuff, 0)) == NULL)
        {
            vstprintf(ddlp_g.msg, DB_TEXT("structure '%s' not defined.\n"), $2.str);
            dderror(ddlp_g.msg, $2.strline);
        }

        memcpy(&ddlp_g.fd_entry, &struct_fd, sizeof(FIELD_ENTRY));

        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |        struct_init '{' struct_elems '}'
    {
        if (!add_struct_type(DB_TEXT("_s_temp_")))
            dderror(DB_TEXT("cannot nest structures"), $2.numline);
        else
        {
            ti = find_type(DB_TEXT("_s_temp_"), 0);
            memcpy(&ddlp_g.fd_entry, &struct_fd, sizeof(FIELD_ENTRY));
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

struct_init     :        T_STRUCT
    { memcpy(&struct_fd, &ddlp_g.fd_entry, sizeof(FIELD_ENTRY)); }
                     ;

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

struct_elems    :       struct_elem
                     |       struct_elem struct_elems
                     ;

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

struct_elem     :       key_spec type_spec T_IDENT size_specs ';'
    {
        if (!add_elem($3.str, ddlp_g.fd_entry.fd_key, ti, (short *) ddlp_g.fd_entry.fd_dim, ci))
        {
            vstprintf(ddlp_g.msg, DB_TEXT("element already defined: %s"), $3.str);
            dderror(ddlp_g.msg, $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);
    }
                     ;

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

typedef_cmnd    :       T_TYPEDEF type_spec T_IDENT size_specs ';'
    {
        if (!add_type($3.str, ti))
            dderror(DB_TEXT("type already defined"), $3.strline);
        del_type(DB_TEXT("_s_temp_"));
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TYPEDEF type_spec T_IDENT size_specs error
    {
        dderror(DB_TEXT("missing ';'"), $3.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_TYPEDEF type_spec error
    {
        dderror(DB_TEXT("invalid type"), $1.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

db_spec         :       T_DATABASE T_IDENT '{'
    {
        in_db = 1;
        vtstrcpy(ddlp_g.db_name, $2.str);
    }
                     |       T_DATABASE T_IDENT '[' T_NUMBER ']' '{'
    {
        in_db = 1;
        if ( $4.num < 128 )
        {
            ddwarning(DB_TEXT("database page size must be at least 128 bytes"),
                $4.numline);
            pagesize = 0;
        }
        else if ( $4.num > 32766 )
        {
            ddwarning(DB_TEXT("maximum database page size is 32766"), $4.numline);
            pagesize = 0;
        }
        else
        {
            pagesize = (short) $4.num;
        }
        vtstrcpy(ddlp_g.db_name, $2.str);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_DATABASE T_IDENT '[' T_IDENT ']' '{'
    {
        in_db = 1;
        if (find_const($4.str, &tempnum))
        {
            if (tempnum < 128)
            {
                ddwarning(DB_TEXT("database page size must be at least 128 bytes"),
                        $4.strline);
                pagesize = 0;
            }
            else if (tempnum > 32766)
            {
                ddwarning(DB_TEXT("maximum database page size is 32766"), $4.strline);
                pagesize = 0;
            }
            else
                pagesize = tempnum;

            vtstrcpy(ddlp_g.db_name, $2.str);
        }
        else
            dderror(DB_TEXT("constant not defined"), $4.strline);

        if (ddlp_g.abort_flag)
            return(-1);
    }
                     |       T_DATABASE T_IDENT error
    {
        in_db = 1;
        yyerrok;
        dderror(DB_TEXT("missing '{'"), $2.strline);
        vtstrcpy(ddlp_g.db_name, $2.str);
        if (ddlp_g.abort_flag)
            return(-1);
    }
                     ;

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

id_list         :       id_item
    {
        if ((id_list = (ID_INFO *) psp_cGetMemory(sizeof(ID_INFO), 0)) == NULL)
            ddlp_abort(DB_TEXT("out of memory"));

        vtstrcpy(id_list->id_name, fld_comp);
        vtstrcpy(id_list->id_rec, rec_comp);
        if (ddlp_g.s_flag)