ddlp.c

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

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

  case 38:
#line 373 "ddlp.y"
    {
        in_db = 1;
        yyerrok;
        dderror(DB_TEXT("missing '{'"), yyvsp[-1].tstr.strline);
        vtstrcpy(ddlp_g.db_name, yyvsp[-1].tstr.str);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 39:
#line 386 "ddlp.y"
    {
        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)
        {
            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);
    }
    break;

  case 40:
#line 404 "ddlp.y"
    {
        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);
    }
    break;

  case 41:
#line 444 "ddlp.y"
    {
        dderror(DB_TEXT("non-identifier specified in list"), yyvsp[0].tnum.numline);
        ddlp_unput(DB_TEXT(';'));
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 42:
#line 455 "ddlp.y"
    {
        if (vtstricmp(yyvsp[0].tstr.str, DB_TEXT("SYSTEM")) == 0)
            vtstrcpy(fld_comp, DB_TEXT("system"));
        else
            vtstrcpy(fld_comp, yyvsp[0].tstr.str);
        rec_comp[0] = 0;
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 43:
#line 465 "ddlp.y"
    {
        vtstrcpy(fld_comp, yyvsp[0].tstr.str);
        if ( !ddlp_g.d_flag )
            ddwarning(DB_TEXT("must use '-d' switch to qualify field names"), ddlp_g.line);
        else
            vtstrcpy(rec_comp, yyvsp[-2].tstr.str);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 49:
#line 488 "ddlp.y"
    {
        while (memList)
        {
            mem = memList->next_mem;
            psp_freeMemory(memList, 0);
            memList = mem;
        }
    }
    break;

  case 50:
#line 497 "ddlp.y"
    {
        yyerror("invalid ddl statement");
    }
    break;

  case 51:
#line 505 "ddlp.y"
    {
        ts_recs(id_list);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 52:
#line 511 "ddlp.y"
    {
        ts_recs(NULL);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 53:
#line 517 "ddlp.y"
    {
        ts_sets(id_list);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 54:
#line 523 "ddlp.y"
    {
        ts_sets(NULL);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 55:
#line 529 "ddlp.y"
    {
        dderror(DB_TEXT("invalid timestamp statement"), yyvsp[-2].tnum.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 56:
#line 539 "ddlp.y"
    {
        add_file(NULL, id_list, yyvsp[-2].tnum.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 57:
#line 545 "ddlp.y"
    {
        add_file(yyvsp[-6].tstr.str, id_list, yyvsp[-6].tstr.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 58:
#line 551 "ddlp.y"
    {
        dderror(DB_TEXT("invalid file specification"), yyvsp[-2].tnum.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 59:
#line 561 "ddlp.y"
    { }
    break;

  case 60:
#line 563 "ddlp.y"
    { }
    break;

  case 63:
#line 575 "ddlp.y"
    { ddlp_g.ft_entry.ft_initial = yyvsp[0].tnum.num; }
    break;

  case 64:
#line 577 "ddlp.y"
    { ddlp_g.ft_entry.ft_next = yyvsp[0].tnum.num; }
    break;

  case 65:
#line 579 "ddlp.y"
    { ddlp_g.ft_entry.ft_pctincrease = yyvsp[0].tnum.num; }
    break;

  case 66:
#line 581 "ddlp.y"
    {
        if (yyvsp[0].tnum.num < 128)
        {
            ddwarning(DB_TEXT("file page size must be at least 128"), yyvsp[0].tnum.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else if (yyvsp[0].tnum.num > 32766)
        {
            ddwarning(DB_TEXT("maximum file page size is 32766"), yyvsp[0].tnum.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else
        {
            ddlp_g.ft_entry.ft_pgsize = (short) yyvsp[0].tnum.num;
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 67:
#line 604 "ddlp.y"
    { ddlp_g.ft_entry.ft_initial = ddlp_g.ft_entry.ft_next = ddlp_g.ft_entry.ft_pctincrease = 0; }
    break;

  case 68:
#line 610 "ddlp.y"
    { ddlp_g.ft_entry.ft_type = 'd'; }
    break;

  case 69:
#line 612 "ddlp.y"
    { ddlp_g.ft_entry.ft_type = 'k'; }
    break;

  case 70:
#line 618 "ddlp.y"
    {
        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;
    }
    break;

  case 71:
#line 625 "ddlp.y"
    {
        if ( yyvsp[-1].tnum.num < 128 )
        {
            ddwarning(DB_TEXT("file page size must be at least 128"), yyvsp[-1].tnum.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else if ( yyvsp[-1].tnum.num > 32766 )
        {
            ddwarning(DB_TEXT("maximum file page size is 32766"), yyvsp[-1].tnum.numline);
            ddlp_g.ft_entry.ft_pgsize = pagesize;
        }
        else
        {
            ddlp_g.ft_entry.ft_pgsize = (short) yyvsp[-1].tnum.num;
        }
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 72:
#line 644 "ddlp.y"
    {
        if (find_const(yyvsp[-1].tstr.str, &tempnum))
        {
            if (tempnum < 128)
            {
                ddwarning(DB_TEXT("file page size must be at least 128"), yyvsp[-1].tstr.strline);
                ddlp_g.ft_entry.ft_pgsize = pagesize;
            }
            else if (tempnum > 32766)
            {
                ddwarning(DB_TEXT("maximum file page size is 32766"), yyvsp[-1].tstr.strline);
                ddlp_g.ft_entry.ft_pgsize = pagesize;
            }
            else
                ddlp_g.ft_entry.ft_pgsize = (short) tempnum;
        }
        else
            dderror(DB_TEXT("constant not defined"), yyvsp[-1].tstr.strline);

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

  case 73:
#line 671 "ddlp.y"
    {
        cpfile(ddlp_g.ft_entry.ft_name, yyvsp[0].tstr.str, yyvsp[0].tstr.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 74:
#line 677 "ddlp.y"
    {
        cpfile(ddlp_g.ft_entry.ft_name, yyvsp[0].tstr.str, yyvsp[0].tstr.strline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 78:
#line 690 "ddlp.y"
    {
        dderror(DB_TEXT("invalid record spec"), yyvsp[-2].tnum.numline);
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 79:
#line 700 "ddlp.y"
    {
        if (vtstrcmp(yyvsp[-1].tstr.str, DB_TEXT("system")) == 0)
            ddlp_abort(DB_TEXT("'system' is a reserved record name"));
        vtstrcpy(rec_comp, yyvsp[-1].tstr.str);
        add_record(yyvsp[-1].tstr.str, yyvsp[-1].tstr.strline);
        n_optkeys = 0;
        if (ddlp_g.abort_flag)
            return(-1);
    }
    break;

  case 80:
#line 714 "ddlp.y"
    { ddlp_g.rt_entry.rt_flags = 0; }
    break;

  case 81:
#line 716 "ddlp.y"
    { ddlp_g.rt_entry.rt_flags = STATIC; }
    break;

  case 84:
#line 728 "ddlp.y"
    { 
        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, yyvsp[-3].tstr.strline);
                        break;
                    }
                    tmp_dims[tot_dims] = ddlp_g.fd_entry.fd_dim[dim];
                    elts = elts