dalexec.c

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

                        dalerror(DB_TEXT("Parameter 2 - Field name not allowed"));
                        stat = DAL_ERR;
                        break;
                    }
                    recnum = getrec(pi->i_p1, DalDbTask);
                    if (recnum < 0)
                    {
                        stat = S_INVREC;
                        dalerror(DB_TEXT("Parameter 1 is invalid record name"));
                        break;
                    }
                    if ((recptr = findvar(RECORD, pi->i_p2, &ndx)) == NULL)
                        recptr = addvar(RECORD, recnum, pi->i_p2,
                                        task->record_table[recnum].rt_len);
                    else if (recnum != ndx)
                    {
                        dalerror(DB_TEXT("Record of same name and different type exists!"));
                        stat = DAL_ERR;
                        break;
                    }

                    stat = (*((int (EXTERNAL_FCN *) (int, char *)) fcns[f].fcn)) (rec_const(recnum), recptr);
                    break;

                case R_RP_TSK_DBN:
                    if (vtstrlen(pi->i_f2))
                    {
                        dalerror(DB_TEXT("Parameter 2 - Field name not allowed"));
                        stat = DAL_ERR;
                        break;
                    }
                    recnum = getrec(pi->i_p1, DalDbTask);
                    if (recnum < 0)
                    {
                        stat = S_INVREC;
                        dalerror(DB_TEXT("Parameter 1 is invalid record name"));
                        break;
                    }
                    if ((recptr = findvar(RECORD, pi->i_p2, &ndx)) == NULL)
                        recptr = addvar(RECORD, recnum, pi->i_p2,
                                        task->record_table[recnum].rt_len);
                    else if (recnum != ndx)
                    {
                        dalerror(DB_TEXT("Record of same name and different type exists!"));
                        stat = DAL_ERR;
                        break;
                    }

                    stat = (*((int (EXTERNAL_FCN *) (int, char *, DB_TASK *, int)) fcns[f].fcn)) (rec_const(recnum), recptr, DalDbTask, CURR_DB);
                    break;

                case F_FP_TSK_DBN:
                    fldnum = (int) getfld(pi->i_p1, -1, DalDbTask);
                    if (fldnum < 0)
                    {
                        stat = S_INVFLD;
                        dalerror(DB_TEXT("Parameter 1 is invalid field name"));
                        break;
                    }
                    if (vtstrlen(pi->i_f2))
                    {
                        if ((recptr = findvar(RECORD, pi->i_p2, &ndx)) == NULL)
                        {
                            dalerror(DB_TEXT("Record variable does not exist!"));
                            stat = DAL_ERR;
                            break;
                        }
                        fldnum2 = (int) getfld(pi->i_f2, ndx, DalDbTask);
                        if (fldnum2 < 0)
                        {
                            stat = S_INVFLD;
                            dalerror(DB_TEXT("Parameter 2 contains invalid field name"));
                            break;
                        }
                        fldptr = recptr + task->field_table[fldnum2].fd_ptr -
                            task->record_table[ndx].rt_data;
                    }
                    else
                    {
                        if ((fldptr = findvar(FIELD, pi->i_p2, &ndx)) == NULL)
                        {
                            if ((fldptr = findvar(LITERAL, pi->i_p2, &ndx)) == NULL)
                            {
                                fldptr = addvar(FIELD, fldnum, pi->i_p2,
                                                task->field_table[fldnum].fd_len);
                            }
#if defined(UNICODE)
                            else if (get_fdtype(fldnum, task) == CHARACTER)
                            {
                                /* field is char, literal is wchar_t */
                                memset(cbuffer, 0, sizeof(cbuffer));
                                wtoa((wchar_t *) fldptr, cbuffer, sizeof(cbuffer));
                                cbuffer[sizeof(cbuffer) - 1] = '\0';
                                fldptr = cbuffer;
#else
                            else if (get_fdtype(fldnum, task) == WIDECHAR)
                            {
                                /* field is wchar_t, literal is char */
                                memset(wbuffer, 0, sizeof(wbuffer));
                                atow(fldptr, wbuffer, sizeof(wbuffer) / sizeof(wchar_t));
                                wbuffer[(sizeof(wbuffer)/sizeof(wchar_t))-1] = 0;
                                fldptr = (char *)wbuffer;
#endif
                            }
                        }
                        else if (fldnum != ndx)
                        {
                            dalerror(DB_TEXT("Field of same name and different type exists!"));
                            stat = DAL_ERR;
                            break;
                        }
                    }

                    stat = (*((int (EXTERNAL_FCN *) (long, char *, DB_TASK *, int)) fcns[f].fcn)) (fld_const(fldnum, DalDbTask), fldptr, DalDbTask, CURR_DB);
                    break;

                case S_F_FP_TSK_DBN:
                    setnum1 = getset(pi->i_p1, DalDbTask);
                    if (setnum1 < 0)
                    {
                        stat = S_INVSET;
                        dalerror(DB_TEXT("Paramter 1 is invalid set name"));
                        break;
                    }
                    fldnum = (int) getfld(pi->i_p2, -1, DalDbTask);
                    if (fldnum < 0)
                    {
                        stat = S_INVFLD;
                        dalerror(DB_TEXT("Parameter 2 is invalid field name"));
                        break;
                    }
                    if (vtstrlen(pi->i_f3))
                    {
                        if ((recptr = findvar(RECORD, pi->i_p3, &ndx)) == NULL)
                        {
                            dalerror(DB_TEXT("Record variable does not exist!"));
                            stat = DAL_ERR;
                            break;
                        }
                        fldnum2 = (int) getfld(pi->i_f3, -1, DalDbTask);
                        if (fldnum2 < 0)
                        {
                            stat = S_INVFLD;
                            dalerror(DB_TEXT("Parameter 2 contains invalid field name"));
                            break;
                        }
                        fldptr = recptr + task->field_table[fldnum].fd_ptr -
                            task->record_table[ndx].rt_data;
                    }
                    else
                    {
                        if ((fldptr = findvar(FIELD, pi->i_p3, &ndx)) == NULL)
                        {
                            if ((fldptr = findvar(LITERAL, pi->i_p3, &ndx)) == NULL)
                                fldptr = addvar(FIELD, fldnum, pi->i_p3,
                                                task->field_table[fldnum].fd_len);
                        }
                        else if (fldnum != ndx)
                        {
                            dalerror(DB_TEXT("Field of same name and different type exists!"));
                            stat = DAL_ERR;
                            break;
                        }
                    }

                    stat = (*((int (EXTERNAL_FCN *) (int, long, char *, DB_TASK *, int)) fcns[f].fcn))
                        (set_const(setnum1), fld_const(fldnum, DalDbTask), fldptr, DalDbTask, CURR_DB);
                    break;

                case U:
                    vtprintf(DB_TEXT("Unimplemented function - %s\n"), pi->i_name);
                    stat = S_OKAY;
                    break;

                    /* Field type, Literal */
                case F_L_TSK_DBN:
                    fldnum = (int) getfld(pi->i_p1, -1, DalDbTask);
                    if (fldnum < 0)
                    {
                        stat = S_INVFLD;
                        dalerror(DB_TEXT("Parameter 1 is invalid field name"));
                        break;
                    }
                    if ((lptr = (DB_TCHAR *)findvar(LITERAL, pi->i_p2, &ndx2)) == NULL)
                    {
                        dalerror(DB_TEXT("Paramter 2 is invalid character string"));
                        break;
                    }

                    stat = (*((int (EXTERNAL_FCN *) (long, DB_TCHAR *, DB_TASK *, int)) fcns[f].fcn)) (fld_const(fldnum, DalDbTask), lptr, DalDbTask, CURR_DB);
                    break;

                    /* Integer, Lock Packet */
                case I_LP_TSK_DBN:
                    dalerror(DB_TEXT("Function is not implemented"));
                    break;

                    /* Record type, Literal */
                case R_L_TSK_DBN:
                    recnum = getrec(pi->i_p1, DalDbTask);
                    if (recnum < 0)
                    {
                        stat = S_INVREC;
                        dalerror(DB_TEXT("Parameter 1 is invalid record name"));
                        break;
                    }
                    if ((lptr = (DB_TCHAR *)findvar(LITERAL, pi->i_p2, &ndx2)) == NULL)
                    {
                        dalerror(DB_TEXT("Paramter 2 is invalid character string"));
                        break;
                    }

                    stat = (*((int (EXTERNAL_FCN *) (int, DB_TCHAR *, DB_TASK *, int)) fcns[f].fcn)) (rec_const(recnum), lptr, DalDbTask, CURR_DB);
                    break;

                    /* Currency buffer Pointer, Integer Pointer */
                case CP_IP_TSK_DBN:
                    dalerror(DB_TEXT("Function is not implemented"));
                    break;

                    /* d_renfile function */
                case REN_TSK:
                    dalerror(DB_TEXT("Function is not implemented"));
                    break;

                case CT:
                    if ((ctptr = findvar(CLOCK_T, pi->i_p1, &ndx)) == NULL)
                    {
                        ctptr = addvar(CLOCK_T, -1, pi->i_p1, sizeof(clock_t));
                    }

                    stat = (*((int (EXTERNAL_FCN *) (clock_t *)) fcns[f].fcn)) ((clock_t *)ctptr);
                    break;

                case CT_CT_CT:
                    if ((ctptr = findvar(CLOCK_T, pi->i_p1, &ndx)) == NULL)
                    {
                        dalerror(DB_TEXT("Parameter 1 is not valid"));
                    }
                    if ((ctptr2 = findvar(CLOCK_T, pi->i_p2, &ndx)) == NULL)
                    {
                        dalerror(DB_TEXT("Parameter 2 is not valid"));
                    }
                    if ((ctptr3 = findvar(CLOCK_T, pi->i_p3, &ndx)) == NULL)
                    {
                        ctptr3 = addvar(CLOCK_T, -1, pi->i_p3, sizeof(clock_t));
                    }

                    stat = (*((int (EXTERNAL_FCN *) (clock_t *, clock_t *, clock_t *)) fcns[f].fcn)) ((clock_t *)ctptr, (clock_t *)ctptr2, (clock_t *)ctptr3);
                    break;

                    /* Currency buffer */
                case C_TSK_DBN:
                    dalerror(DB_TEXT("Function is not implemented"));
                    break;
            }
            if (!batch && stat > 0)
            {
                switch (stat)
                {
                    case S_EOS:
                        vtprintf(DB_TEXT("End of set\n"));
                        break;
                    case S_NOTFOUND:
                        vtprintf(DB_TEXT("Record not found\n"));
                        break;
                    case S_DUPLICATE:
                        vtprintf(DB_TEXT("Duplicate key\n"));
                        break;
                    case S_KEYSEQ:
                        vtprintf(DB_TEXT("Field type used out of sequence in d_keynext\n"));
                        break;
                    case S_UNAVAIL:
                        vtprintf(DB_TEXT("Database is unavailable\n"));
                        break;
                    case S_DELETED:
                        vtprintf(DB_TEXT("Record deleted since last access\n"));
                        break;
                    case S_UPDATED:
                        vtprintf(DB_TEXT("Record updated since last access\n"));
                        break;
                    case S_LOCKED:
                        vtprintf(DB_TEXT("Current record is locked\n"));
                        break;
                    case S_UNLOCKED:
                        vtprintf(DB_TEXT("Current record is not locked\n"));
                        break;
                }
            }

            return (stat);
        }
    }
    if (f == nfcns)
    {
        vftprintf(stderr, DB_TEXT("No such function - %s\n"), pi->i_name);
        return (DAL_ERR);
    }
    return (stat);
}

static char get_fdtype(int fld, DB_TASK *task)
{
    char fd_type = task->field_table[fld].fd_type;

    if (fd_type == COMKEY || fd_type == GROUPED)
    {
        /* If the field is a compound key or a struct, then get the type
            of its first element
        */
        if (fd_type == COMKEY)
            fld = task->key_table[task->field_table[fld].fd_ptr].kt_field;
        else
            fld++;
        fd_type = task->field_table[fld].fd_type;
    }
    return fd_type;
}