fld_move.c

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

                    wnum[1] = 0;
                    wtoa(wnum, cnum, sizeof(cnum));
                    num = cnum[0];
#else
                    num = fld[i];
#endif
                    break;
            }
        }
    }

    if (fld[i + 1])
        vftprintf(stderr,
            DB_TEXT("**WARNING** invalid character value - %s\n"), fld);

    return (char) num;
}

/**************************************************************************/


static wchar_t read_wchar(DB_TCHAR *fld)
{
    int num = 0, i = 0, escape = 0;
#if !defined(UNICODE)
    wchar_t wnum[2];
    char cnum[2];
#endif

    if (fld[0] != DB_TEXT('\''))
    {
        vstscanf(fld, DB_TEXT("%d"), &num);
        return (wchar_t) num;
    }

    while ((fld[++i] != DB_TEXT('\'')) || (escape == 1))
    {
        if (escape == 0)    /* No '\' yet. */
        {
            if (fld[i] == DB_TEXT('\\'))   /* We found a '\' character */
                escape = 1;
            else    /* Just a regular character */
            {
#if defined(UNICODE)
                num = fld[i];
#else
                cnum[0] = fld[i];
                cnum[1] = 0;
                atow(cnum, wnum, sizeof(wnum));
                num = wnum[0];
#endif
                escape = -1;
            }
        }
        else if (escape == -1)
        {
            /* a valid character has been found, but no closing "'" */
            vftprintf(stderr, DB_TEXT("**WARNING** invalid char %s\n"), fld);
            return (wchar_t) num;
        }
        else if (fld[i] >= DB_TEXT('0') && fld[i] < DB_TEXT('8'))  /* octal */
        {
            do
            {
                if (i > 4)  /* too many digits */
                {
                    vftprintf(stderr,
                        DB_TEXT("**WARNING** invalid octal value: %s\n"), fld);
                    return (wchar_t) num;
                }
                num *= 8;
                num += fld[i] - DB_TEXT('0');

                if (fld[++i] == DB_TEXT('\''))
                    escape = -1;

            } while (fld[i] >= DB_TEXT('0') && fld[i] < DB_TEXT('8'));

            if (fld[i] != DB_TEXT('\''))
            {
                vftprintf(stderr,
                    DB_TEXT("**WARNING** invalid octal value: %s\n"), fld);
                return (wchar_t) num;
            }
            i--;
        }
        else
        {
            escape = -1;
            switch (fld[i])
            {
                case DB_TEXT('n'):   num = L'\n';   break;
                case DB_TEXT('r'):   num = L'\r';   break;
                case DB_TEXT('f'):   num = L'\f';   break;
                case DB_TEXT('t'):   num = L'\t';   break;
                case DB_TEXT('b'):   num = L'\b';   break;
                case DB_TEXT('v'):   num = L'\v';   break;
                default:
#if defined(UNICODE)
                    num = fld[i];
#else
                    cnum[0] = fld[i];
                    cnum[1] = 0;
                    atow(cnum, wnum, sizeof(wnum));
                    num = wnum[0];
#endif
                    break;
            }
        }
    }

    if (fld[i + 1])
        vftprintf(stderr,
            DB_TEXT("**WARNING** invalid character value - %s\n"), fld);

    return (wchar_t) num;
}


/**************************************************************************/

static DB_ADDR read_dba(DB_TCHAR *fld)
{
    int bracket = 0, colon = 0, i = 0;
    unsigned long fno = 0L;  /* need an ulong cuz may be a number instead */
    unsigned long rno = 0L;  /* of [fno:rno] */
    static DB_ADDR temp_dba;

    if (fld[i] == DB_TEXT('['))
    {
        bracket = 1;
        i++;
    }

    while ((bracket == 1) || (fld[i] != 0))
    {
        if (vistdigit(fld[i]))
        {
            if (colon)
                rno = rno * 10 + (fld[i] - DB_TEXT('0'));
            else
                fno = fno * 10 + (fld[i] - DB_TEXT('0'));
        }
        else
        {
            if (fld[i] == DB_TEXT(':'))
                colon = 1;
            else
            {
                if (fld[i] == DB_TEXT(']'))
                    bracket = -1;
            }
        }
        i++;
    }

    if ((bracket == 1) || (fld[i] != 0))
        vftprintf(stderr,
            DB_TEXT("**WARNING** invalid database address - %s\n"), fld);

    if ((bracket == -1) && (colon == 0))
        vftprintf(stderr,
            DB_TEXT("**WARNING** invalid database address - %s\n"), fld);

    if (colon == 0) /* Just a number, no [fno:rno] */
        temp_dba = fno;
    else
        d_encode_dba((short) fno, rno, &temp_dba);

    return temp_dba;
}

/**************************************************************************/

/* move one field */
int mv_fld(char *record, int offset, int ndx, DB_TCHAR *line)
{
    DB_TCHAR *fld_cont;
    int width;
    int blank;
    char   chnum;
    wchar_t wchnum;
    short  shnum;
    int    inum;
    long   lnum = 0;
    float  fnum;
    double dnum = 0.0;
    DB_ADDR dbanum = 0L;
    DB_TASK *task = imp_g.dbtask;

    fld_cont = find_fld(asc_fld, line, &width);

    if (fld_cont == NULL)
        return FAILURE;

    blank = blanks(fld_cont, width);

    switch (task->field_table[ndx].fd_type)
    {
        case CHARACTER:
            if (blank)
                chnum = 0;
            else
                chnum = read_char(fld_cont);
            memcpy(record + offset, &chnum, sizeof(char));
            break;

        case WIDECHAR:
            if (blank)
                wchnum = 0;
            else
                wchnum = read_wchar(fld_cont);
            memcpy(record + offset, &wchnum, sizeof(wchar_t));
            break;

        case SHORTINT:
            if (!blank)
                vstscanf(fld_cont, DB_TEXT("%ld"), &lnum);
            shnum = (short) lnum;
            memcpy(record + offset, &shnum, sizeof(short));
            break;

        case REGINT:
            if (!blank)
                vstscanf(fld_cont, DB_TEXT("%ld"), &lnum);
            inum = (int) lnum;
            memcpy(record + offset, &inum, sizeof(int));
            break;

        case DBADDR:
            if (blank)
                d_encode_dba(0, 0L, &dbanum);
            else
                dbanum = read_dba(fld_cont);
            memcpy(record + offset, &dbanum, sizeof(DB_ADDR));
            break;

        case LONGINT:
            if (!blank)
                vstscanf(fld_cont, DB_TEXT("%ld"), &lnum);
            memcpy(record + offset, &lnum, sizeof(long));
            break;

        case FLOAT:
            if (!blank)
                vstscanf(fld_cont, DB_TEXT("%lf"), &dnum);
            fnum = (float) dnum;
            memcpy(record + offset, &fnum, sizeof(float));
            break;

        case DOUBLE:
            if (!blank)
                vstscanf(fld_cont, DB_TEXT("%lf"), &dnum);
            memcpy(record + offset, &dnum, sizeof(double));
            break;

        default:
            if (!imp_g.silent)
            {
                vftprintf(stderr,
                    DB_TEXT("**WARNING**  unable to transfer into db.* data type %c\n"),
                    task->field_table[ndx].fd_type);
            }
            break;
    }

    asc_fld++;
    return OK;
}

/**************************************************************************/

static DB_TCHAR fld_cont[1024];

DB_TCHAR *find_fld(int fld, DB_TCHAR *line, int *width)
{
    int i, j, commas, nquotes, escaped, new_fld;
    DB_TCHAR *fc, c;

    i = 0;
    commas = 0;
    (*width) = 0;
    fc = fld_cont;
    fld_cont[0] = 0;
    nquotes = 0;
    new_fld = 0;

    /* IF A CHAR FIELD HAS QUOTES AROUND IT, THE CONTENTS OF THE FIELD
       WILL BE WHAT IS BETWEEN THE QUOTES WHILE THE WHITE SPACE OUTSIDE
       THE QUOTES IS IGNORED.  IF THE CHAR FIELD HAS NO QUOTES, EVERYTHING
       INCLUDING THE WHITE SPACE BETWEEN THE COMMAS WILL BE THE CONTENTS
       OF THE FIELD.
    */
    while (commas < fld)
    {
        switch ((c = next_ch(line, &i, &escaped)))
        {
            case DB_TEXT('"'):
                if (escaped)
                {
                    *fc++ = c;
                    *fc = 0;
                    (*width)++;
                }
                else if (nquotes == 1)
                {
                    /* end of quoted string */
                    nquotes = 0;

                    /* IF THERE IS SPACE BETWEEN THE QUOTE AND THE NEXT COMMA,
                        SKIP IT SO THAT IT IS NOT ADDED TO THE STRING.
                    */
                    do
                    {
                        c = next_ch(line, &i, &escaped);
                    } while ((! escaped) && (c != imp_g.sep_char) &&
                                ((c == DB_TEXT(' ')) || (c == DB_TEXT('\t'))));
                    if (c)
                        i--;  /* let the switch handle the non-white char */
                }
                else
                {
                    /* beginning of quoted string */
                    nquotes = 1;
                    (*width) = 0;
                    fld_cont[0] = 0;
                    fc = fld_cont;
                    new_fld = 0;
                }
                break;

            case 0:
                if (nquotes == 1)
                {
                    for (j = 0; j < i - 1; j++)
                        vfputtc(DB_TEXT(' '), stderr);
                    vftprintf(stderr, DB_TEXT("^\n**ERROR** no ending quote\n"));
                    return NULL;
                }
                if (commas <= fld - 2)
                {
                    for (j = 0; j < i - 1; j++)
                        vfputtc(' ', stderr);
                    vftprintf(stderr,
                        DB_TEXT("^\n**ERROR** not enough fields in input record\n"));
                    return NULL;
                }
                if (new_fld)
                {
                    fld_cont[0] = 0;
                    (*width) = 0;
                    fc = fld_cont;
                }
                commas++;
                break;

            default:
                if (c == imp_g.sep_char)
                {
                    if (nquotes == 1)
                    {
                        *fc++ = c;
                        *fc = 0;
                        (*width)++;
                    }
                    else
                    {
                        commas++;
                        if (commas < fld)
                        {
                            (*width) = 0;
                            fld_cont[0] = 0;
                            fc = fld_cont;
                        }
                        new_fld = 1;
                    }
                }
                else
                {
                    if (new_fld)
                    {
                        (*width) = 0;
                        fld_cont[0] = 0;
                        fc = fld_cont;
                        new_fld = 0;
                    }
                    *fc++ = c;
                    *fc = 0;
                    (*width)++;
                }
                break;
        }
    }

    return fld_cont;
}

/**************************************************************************/

static DB_TCHAR next_ch(DB_TCHAR *line, int *pos, int *escaped)
{
    DB_TCHAR retchar, oct[4];
    int i, octint;

    retchar = line[(*pos)];
    *escaped = 0;
    if (retchar == imp_g.esc_char)
    {
        *escaped = 1;
        (*pos)++;
        switch (line[(*pos)])
        {
            case DB_TEXT('n'):   retchar = DB_TEXT('\n');   break;
            case DB_TEXT('r'):   retchar = DB_TEXT('\r');   break;
            case DB_TEXT('t'):   retchar = DB_TEXT('\t');   break;
            case DB_TEXT('f'):   retchar = DB_TEXT('\f');   break;
            case DB_TEXT('b'):   retchar = DB_TEXT('\b');   break;
            default:
                /* convert from \ooo form */
                oct[0] = 0;
                for (i = 0;
                      i < 3 && line[(*pos)] >= DB_TEXT('0') && line[(*pos)] <= DB_TEXT('7');
                      i++, (*pos)++)
                {
                    oct[i] = line[(*pos)];
                    oct[i + 1] = 0;
                }
                if (vtstrlen(oct) > 0)
                {
                    vstscanf(oct, DB_TEXT("%o"), &octint);
                    retchar = (DB_TCHAR) octint;
                    (*pos)--;                    /* done below, causes too far */
                }
                else
                {
                    retchar = line[(*pos)];
                }
                break;
        }
    }
    else if (!retchar)
        return retchar;

    (*pos)++;
    return retchar;
}

/**************************************************************************/

int blanks(DB_TCHAR *s, int n)
{
    while (n--)
    {
        if (*s++ != DB_TEXT(' '))
            return 0;
    }

    return 1;
}

/**************************************************************************/

/* convert vector into index */
int vec_idx(int ndim, short *dim, int *vec, int *idx)
{
    register int i, j, prod;

    *idx = 0;
    if (ndim <= 0)
        return 0;

    for (i = 0; i < ndim - 1; i++)
    {
        prod = 1;
        for (j = i + 1; j < ndim; j++)
            prod *= dim[j];
        *idx += vec[i] * prod;
    }
    *idx += vec[ndim - 1];
    return 0;
}