dalio.c

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

                if (out)
                {
                     memcpy(&ctval, val, sizeof(clock_t));
                     vftprintf(fp, DB_TEXT("%4.2f seconds"), (float)ctval/CLOCKS_PER_SEC);
                }
                break;

            case LITERAL:
                if (out)
                    vftprintf(fp, (DB_TCHAR *)val);
                break;

            case INTPTR:
                if (out)
                {
                    memcpy(&intval, val, sizeof(int));
                    vftprintf(fp, DB_TEXT("%6d"), intval);
                }
                else
                {
                    if (stat = gettstring(line, 7, fp))
                        return (stat);
                    vstscanf(line, DB_TEXT("%d"), (int *) val);
                }
                break;

            case DBAPTR:
                if (out)
                {
                    memcpy(&dba, val, DB_ADDR_SIZE);
                    d_decode_dba(dba, &file, &slot);
                    vftprintf(fp, DB_TEXT("[%d:%lu]"), (int)file, slot);
                }
                else
                {
                    if (fp == stdin)
                        vtprintf(DB_TEXT("\n   Enter file_no: "));
                    stat = gettstring(line, 7, fp);
                    if (stat)
                        return (stat);
                    vstscanf(line, DB_TEXT("%d"), &file_no);
                    if (fp == stdin)
                        vtprintf(DB_TEXT("   Enter rec_no : "));
                    stat = gettstring(line, 14, fp);
                    if (stat)
                        return (stat);
                    vstscanf(line, DB_TEXT("%ld"), &rec_no);
                    d_encode_dba((short)file_no, rec_no, &dba);
                    memcpy(val, &dba, DB_ADDR_SIZE);
                }
                break;

            default:
                break;
        }
        p = p->pf_next;
    }
    
    if (out)
    {
        vftprintf(fp, DB_TEXT("\n"));
        fflush(fp);
    }
    
    return (stat);
}

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

static int getfield(int ndx, char *val, DB_TASK *task)
{
    short       shortval;
    int         intval,
                stat,
                len;
    long        longval;
    float       flval;
    double      dbval;

    stat = S_OKAY;

    switch (task->field_table[ndx].fd_type)
    {
        case CHARACTER:
            stat = getcstring(val, task->field_table[ndx].fd_len + 1, fp);
            len = strlen(val);
            if (len && val[len-1] == '\n')
                val[len-1] = '\0';
            break;

        case WIDECHAR:
            stat = getwstring((wchar_t *)val,
                (task->field_table[ndx].fd_len / sizeof(wchar_t)) + 1, fp);
            len = vwcslen((wchar_t *)val);
            if (len && val[len-1] == L'\n')
                val[len-1] = 0;
            break;

        case SHORTINT:
            stat = gettstring(line, 7, fp);
            vstscanf(line, DB_TEXT("%hd"), &shortval);
            memcpy(val, &shortval, sizeof(short));
            break;

        case REGINT:
            stat = gettstring(line, 7, fp);
            vstscanf(line, DB_TEXT("%d"), &intval);
            memcpy(val, &intval, sizeof(int));
            break;

        case LONGINT:
            stat = gettstring(line, 11, fp);
            vstscanf(line, DB_TEXT("%ld"), &longval);
            memcpy(val, &longval, sizeof(long));
            break;

        case FLOAT:
            stat = gettstring(line, 11, fp);
            vstscanf(line, DB_TEXT("%f"), &flval);
            memcpy(val, &flval, sizeof(float));
            break;

        case DOUBLE:
            stat = gettstring(line, 11, fp);
            vstscanf(line, DB_TEXT("%lf"), &dbval);
            memcpy(val, &dbval, sizeof(double));
            break;
    }
    return (stat);
}

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

static int putfield(int ndx, char *val, DB_TASK *task)
{
    DB_TCHAR    fmt[10];
    short       shortval;
    int         intval;
    long        longval;
    float       flval;
    double      dbval;
#if defined(UNICODE)
    wchar_t     wbuffer[FILENMLEN];
#else
    char        cbuffer[FILENMLEN];
#endif

    switch (task->field_table[ndx].fd_type)
    {
        case CHARACTER:
            vstprintf(fmt, DB_TEXT("%%-%d.%ds"),
                task->field_table[ndx].fd_len, task->field_table[ndx].fd_len);
#if defined(UNICODE)
            atow(val, wbuffer, sizeof(wbuffer) / sizeof(wchar_t));
            wbuffer[sizeof(wbuffer) / sizeof(wchar_t) - 1] = 0;
            vftprintf(fp, fmt, wbuffer);
#else
            vftprintf(fp, fmt, val);
#endif
            break;

        case WIDECHAR:
            vstprintf(fmt, DB_TEXT("%%-%d.%ds"),
                task->field_table[ndx].fd_len / sizeof(wchar_t),
                task->field_table[ndx].fd_len / sizeof(wchar_t));
#if defined(UNICODE)
            vftprintf(fp, fmt, val);
#else
            wtoa((wchar_t *)val, cbuffer, sizeof(cbuffer));
            cbuffer[sizeof(cbuffer) - 1] = '\0';
            vftprintf(fp, fmt, cbuffer);
#endif
            break;

        case SHORTINT:
            memcpy(&shortval, val, sizeof(short));
            vftprintf(fp, DB_TEXT("%6d"), shortval);
            break;

        case REGINT:
            memcpy(&intval, val, sizeof(int));
            vftprintf(fp, DB_TEXT("%6d"), intval);
            break;

        case LONGINT:
            memcpy(&longval, val, sizeof(long));
            vftprintf(fp, DB_TEXT("%10ld"), longval);
            break;

        case FLOAT:
            memcpy(&flval, val, sizeof(float));
            vftprintf(fp, DB_TEXT("%10.10g"), flval);
            break;

        case DOUBLE:
            memcpy(&dbval, val, sizeof(double));
            vftprintf(fp, DB_TEXT("%10.10g"), dbval);
            break;
    }
    return S_OKAY;
}

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

int getcstring(char *str, int len, FILE *fp)
{
    int c = 0;
    char *save;

    save = str;

    while (--len > 0)
    {
        c = getc(fp);
        if (c == EOF)
            break;
        if (c == '\n')
        {
            EOLN = 1;
            break;
        }
        *str++ = (char) c;
    }

    if (len)
        *str = 0;
    else
        *--str = 0;

    len = strlen(save);
    while (len && (save[len - 1] == ' '))
    {
        save[len - 1] = 0;
        len--;
    }

    if (c == EOF)
        return (S_EOS);
    else
        return (S_OKAY);
}

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


int getwstring(wchar_t *str, int len, FILE *fp)
{
    wint_t c = 0;
    wchar_t *save;

    save = str;

    while (--len > 0)
    {
        c = vgetwc(fp);
        if (c == DB_WEOF)
            break;
        if (c == L'\n')
        {
            EOLN = 1;
            break;
        }
        *str++ = (wchar_t) c;
    }

    if (len)
        *str = 0;
    else
        *--str = 0;

    len = vwcslen(save);
    while (len && (save[len - 1] == L' '))
    {
        save[len - 1] = 0;
        len--;
    }

    if (c == DB_WEOF)
        return (S_EOS);
    else
        return (S_OKAY);
}


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

int dal_rewind(INST *pi)
{
    int found, j;
    DB_TCHAR *pmode;

    /* check to see if it's the right command */
    if (vtstrcmp(pi->i_name, DB_TEXT("rewind")) != 0)
        return (DAL_ERR);

    /* check if name is on list of files being used */
    for (found = FALSE, j = 0; j < nio; j++)
    {
        if (!vtstrcmp(pi->i_p1, f[j].io_name))
        {
            found = TRUE;
            break;
        }
    }
    if (!found)
    {
        vftprintf(stderr, DB_TEXT("file '%s' not rewound\n"), pi->i_p1);
        return (DAL_ERR);
    }
    else if (f[j].io_type == INPUT)
    {                                   /* it's an input file */
        if (f[j].io_fp != NULL)
        {                                /* it's open */
            if (fseek(f[j].io_fp, (long) 0, 0) != 0)
            {
                vftprintf(stderr, DB_TEXT("Problem rewinding file - %s\n"),
                          f[j].io_name);
                return (DAL_ERR);
            }
        }
        else
        {
            /* file's closed so let's open it */
            pmode = dal_unicode ? DB_TEXT("rb") : DB_TEXT("r");
            if ((f[j].io_fp = vtfopen(f[j].io_name, pmode)) == NULL)
            {
                vftprintf(stderr, DB_TEXT("Problem rewinding file - %s\n"),
                          f[j].io_name);
                return (DAL_ERR);
            }
        }
    }
    else
    {                                   /* file is an output file */
        if (f[j].io_fp != NULL)          /* it's open */
            fclose(f[j].io_fp);
        pmode = dal_unicode ? DB_TEXT("wb") : DB_TEXT("w");
        if ((f[j].io_fp = vtfopen(f[j].io_name, pmode)) == NULL)
        {
            vftprintf(stderr, DB_TEXT("Problem rewinding file - %s\n"),
                      f[j].io_name);
            return (DAL_ERR);
        }
    }
    return (S_OKAY);
}