/*
 * CHEST, chess analyst.  For Copyright notice read file "COPYRIGHT".
 *
 * $Source: /home/heiner/ca/chest/RCS/input.c,v $
 * $Id: input.c,v 3.25 1999/12/25 12:43:29 heiner Exp $
 *
 *	read a board and a job
 */

#include <stdio.h>
#include "types.h"
#include "str.h"
#include "board.h"
#include "xatt.h"
#include "job.h"
#include "move.h"
#include "lang.h"
#include "output.h"
#include "epdio.h"
#include "input.h"

#define INP_BUF_SIZ	4096


/*
 * Initialize a board to the empty default state.
 */
Eximpl void     empty_board(register Board * bp)
{
    register int    pos;
    register int    i;
    register int    j;
    register Field *p;

    bp->b_tomove = white;
    bp->b_ep = NO_POS;
    bp->b_castle[white] = 0;
    bp->b_castle[black] = 0;
    bp->b_max_piece[white] = 0;
    bp->b_max_piece[black] = 0;
    bp->b_cur_piece[white] = 0;
    bp->b_cur_piece[black] = 0;
    bp->b_bau[white].fs_long[0] = 0;
    bp->b_bau[white].fs_long[1] = 0;
    bp->b_bau[black].fs_long[0] = 0;
    bp->b_bau[black].fs_long[1] = 0;
    bp->b_fig.fs_long[0] = 0;
    bp->b_fig.fs_long[1] = 0;
    for (i = 0; i < (2 * MAX_PIECE); ++i) {
        bp->b_piece[i] = NO_POS;
    }
    for (pos = 0; pos < B_SIZE; ++pos) {
        p = &(bp->b_f[pos]);
        p->f_c = border;
        p->f_f = no_figure;
        F_IATTioXX(bp, p, XATT_TP_intern) = 0;
        F_DATTioXX(bp, p, XATT_TP_intern) = 0;
    }
    for (i = 0; i < 8; ++i) {
        for (j = 0; j < 8; ++j) {
            bp->b_f[MK_POS(i, j)].f_c = empty;
            bp->b_f[MK_POS(i, j)].f_pos64 = MK_POS64(i, j);
        }
    }
    for (i = 0; i < 8; ++i) {
        bp->b_packed.pb_long[i] = 0;
    }
#if WITH_ZHASH
    bp->b_zhash = 0;
#endif
    for (i = 0; i < MAX_FIGURES; ++i) {
        bp->b_fig_cnt[white][i] = 0;
        bp->b_fig_cnt[black][i] = 0;
    }
    /* spare the last element in the downdate stack: */
    bp->b_ddstk.dds_ptr = &(bp->b_ddstk.dds_stack[MAX_DD_ELEMS - 1]);

    XATT_empty(bp);
}


static void     set_nextfig(register Board * bp, Colour colour, Figure fig, Position pos)
{
    register Field *p;

    p = &(bp->b_f[pos]);
    p->f_c = colour;
    p->f_f = fig;
    p->f_idx = COLOUR_IDX(colour) + bp->b_max_piece[colour];
    bp->b_piece[p->f_idx] = pos;
    bp->b_max_piece[colour] += 1;
    bp->b_cur_piece[colour] += 1;
    bp->b_fig.fs_line[LIN64(p->f_pos64)] |= (1 << COL64(p->f_pos64));
    if (fig == bauer) {
        bp->b_bau[colour].fs_line[LIN64(p->f_pos64)] |=
            (1 << COL64(p->f_pos64));
    }
    ins_att(bp, p);
    pacb_sync(&(bp->b_packed), p);
    ZH_UPD(bp->b_zhash, colour, fig, p->f_pos64);
    bp->b_fig_cnt[colour][fig] += 1;
}


static int      inp__lang = LANG_NONE;

static void     set_inp_lang(int lang)
{
    if (is_lang(lang)) {
        inp__lang = lang;
    }
}


static FILE    *inp_file = 0;   /* current input stream */
static Bool     inp_opened = 0;
static long     inp_lino = 0;   /* current line number */
static char    *inp_bufp = 0;   /* current line buffer */
static Bool     inp_eofseen = FALSE;    /* physical | logical */


static void     inp_tell_input(const char *filename)
{
    if (!f_bulkmode) {
        printf("Input file: ");
        if (filename) {
            printf("'%s'\n", filename);
        } else {
            printf("STDIN\n");
        }
        oflush();
    }
}

Eximpl void     inp_start_input(const char *filename)
{
    if (inp_file) {             /* check closing old input */
        if (inp_opened) {
            (void) fclose(inp_file);
        }
        inp_file = 0;
    }
    inp_opened = FALSE;
    inp_lino = 0;
    inp_bufp = 0;
    inp_eofseen = FALSE;
    if (str_equal(filename, "") || str_equal(filename, "-")) {
        inp_file = stdin;
        inp_tell_input((char *) 0);
    } else {
        inp_file = fopen(filename, "r");
        if (!inp_file) {
            inp_eofseen = TRUE; /* do not continue to scan this input */
            printf("Cannot open '%s' for reading, ignored.\n", filename);
            oflush();
        } else {
            inp_opened = TRUE;
            inp_tell_input(filename);
        }
    }
}


Eximpl void     inp_tell_error(const char *what)
{
    if (!what || !*what) {
        what = "syntax error";
    }
    printf("Input error in line %3ld: %s\n", (long) inp_lino, what);
    if (inp_bufp) {
        printf("Input line = '%s'\n", inp_bufp);
    }
}


static          Bool
                is_space(char c)
{
    return IS_SPACE(c);
}

static const char *
                skip_space(const char *p)
{
    SKIP_SPACE(p);
    return p;
}

static void     trim_line(char *buf)
{
    if (buf) {
        register char  *p;
        p = buf + str_len(buf); /* -> 0-byte */
        /* Get rid of line terminator/separator \r\n ... ... and also eat
         * trailing white space ... */
        while ((p > buf)
               && ((p[-1] == '\n') || (p[-1] == '\r') || IS_SPACE(p[-1]))
            ) {
            *--p = 0;
        }
    }
}


static          Bool            /* whether recognized & stored */
                cis_lang(char c, int *langp)
{
    int             lang;

    lang = lang_of_char(c);
    if (is_lang(lang)) {
        *langp = lang;
        return TRUE;
    }
    return FALSE;
}

static          Bool            /* whether recognized & stored */
                cis_colour(char c, Colour * colourp)
{
    Colour          colour;
    int             lang;
    int             mi;
    int             ma;

    if (inp__lang == LANG_NONE) {
        mi = 1;
        ma = LANGS - 1;
    } else {
        mi = ma = inp__lang;
    }
    for (lang = mi; lang <= ma; ++lang) {
        if ((lang_chr_colour(lang, colour = white) == c)
            || (lang_chr_colour(lang, colour = black) == c)) {
            *colourp = colour;
            return TRUE;        /* yes, recognized */
        }
    }
    return FALSE;               /* not recognized */
}

static          Bool            /* whether recognized & stored */
                cis_figure(char c, Figure * figurep)
{
    Figure          f;
    int             lang;
    int             mi;
    int             ma;

    if (inp__lang == LANG_NONE) {
        mi = 1;
        ma = LANGS - 1;
    } else {
        mi = ma = inp__lang;
    }
    for (lang = mi; lang <= ma; ++lang) {
        if ((lang_chr_figure(lang, f = bauer) == c)
            || (lang_chr_figure(lang, f = springer) == c)
            || (lang_chr_figure(lang, f = laeufer) == c)
            || (lang_chr_figure(lang, f = turm) == c)
            || (lang_chr_figure(lang, f = dame) == c)
            || (lang_chr_figure(lang, f = koenig) == c)) {
            *figurep = f;
            return TRUE;        /* yes, recognized */
        }
    }
    return FALSE;               /* not recognized */
}

static          Bool            /* whether recognized & stored */
                cis_Figure(char c, Figure * figurep)
{
    Figure          f;
    int             lang;
    int             mi;
    int             ma;

    if (inp__lang == LANG_NONE) {
        mi = 1;
        ma = LANGS - 1;
    } else {
        mi = ma = inp__lang;
    }
    for (lang = mi; lang <= ma; ++lang) {
        if ((lang_chr_Figure(lang, f = bauer) == c)
            || (lang_chr_Figure(lang, f = springer) == c)
            || (lang_chr_Figure(lang, f = laeufer) == c)
            || (lang_chr_Figure(lang, f = turm) == c)
            || (lang_chr_Figure(lang, f = dame) == c)
            || (lang_chr_Figure(lang, f = koenig) == c)) {
            *figurep = f;
            return TRUE;        /* yes, recognized */
        }
    }
    return FALSE;               /* not recognized */
}

static          Bool            /* whether recognized & stored */
                cis_castle(char c, Castle * castlep)
{                               /* FFS: lang */
    static Castle   castles[] = {castle00, castle000};
    static const char *c_ger = {"kl"};  /* kurz, lang */
    static const char *c_eng = {"sl"};  /* short, long */
    int             inx;

    inx = str_pos(c_ger, c);
    if (inx < 0) {
        inx = str_pos(c_eng, c);
    }
    if (inx < 0) {
        return FALSE;           /* not recognized */
    }
    *castlep = castles[inx];
    return TRUE;                /* yes, recognized */
}

static          Bool            /* whether recognized & stored */
                cis_column(char c, int *columnp)
{
    int             inx;

    inx = str_pos("abcdefgh", c);
    if (inx < 0) {
        return FALSE;           /* not recognized */
    }
    *columnp = inx;
    return TRUE;                /* yes, recognized */
}

static          Bool            /* whether recognized & stored */
                cis_line(char c, int *linep)
{
    int             inx;

    inx = str_pos("12345678", c);
    if (inx < 0) {
        return FALSE;           /* not recognized */
    }
    *linep = inx;
    return TRUE;                /* yes, recognized */
}

static          Bool            /* whether recognized & stored */
                cis_pos(char c1, char c2, Position * posp)
{
    int             column;
    int             line;

    if (!cis_column(c1, &column)
        || !cis_line(c2, &line)) {
        return FALSE;           /* not recognized */
    }
    *posp = (Position) MK_POS(column, line);
    return TRUE;                /* yes, recognized */
}

static int      dec_digval(char c)
{
    return str_pos("0123456789", c);
}

static          Bool            /* whether ok (so far) */
                try_set_nextfig(register Board * bp, Colour colour, Figure fig, Position pos)
{
    if (bp->b_f[pos].f_c != empty) {    /* most frequent error */
        inp_tell_error("duplicate piece");
        return FALSE;           /* sorry */
    }
    if (bp->b_max_piece[colour] >= MAX_PIECE) {
        inp_tell_error("too many pieces of one colour");
        return FALSE;           /* sorry */
    }
    set_nextfig(bp, colour, fig, pos);
    return TRUE;                /* ok */
}


static          Bool            /* whether ok */
                chk_eo_buf(const char *buf, const char *errtxt)
{
    buf = skip_space(buf);      /* accept trailing white space */
    if (buf && buf[0]) {        /* something unrecognized */
        inp_tell_error(errtxt);
        return FALSE;           /* sorry */
    }
    return TRUE;                /* ok, the buffer is exhausted */
}


static          Bool            /* whether ok */
                grok_fys_line(const char *buf, Board * bp)
{
    /* As this notation does sort the pieces by their position, we have to
     * reorder at least for the kings, which are needed at the first relative
     * piece index. Hence, we first build an 8x8 intermediate representation,
     * which we then scan for different types of pieces. */
#define FYS_CODE(c,f)	(((((f) << 1) | ((c) & 01)) << 1) | 01)
    int8            fysb[8][8]; /* [lin][col] */
    register const char *p;
    register int    lin;
    register int    col;
    register int    spc;
    register rColour c;
    register int    i;
    Figure          fig = 0;    /* init for lint */
    static Figure   figlist[] = {
        koenig,                 /* MUST be first */
        dame, turm, laeufer,
        springer, bauer,
        no_figure               /* MUST be last */
    };

    for (lin = 0; lin < 8; ++lin) {
        for (col = 0; col < 8; ++col) {
            fysb[lin][col] = 0;
        }
    }
    p = buf;
    p = skip_space(p);          /* skip over leading spaces */
    lin = 7;
    col = 0;
    for (; *p && !is_space(*p); ++p) {
        spc = 0;
        c = empty;
        switch (*p) {
        case '1':
            spc = 1;
            break;
        case '2':
            spc = 2;
            break;
        case '3':
            spc = 3;
            break;
        case '4':
            spc = 4;
            break;
        case '5':
            spc = 5;
            break;
        case '6':
            spc = 6;
            break;
        case '7':
            spc = 7;
            break;
        case '8':
            spc = 8;
            break;
        case '/':
            if (col != 0) {
                inp_tell_error("misplaced / in Forsyth");
                return FALSE;
            }
            spc = 0;
            break;
        default:
            if (cis_Figure(*p, &fig)) { /* upper case */
                c = white;
                spc = 1;
            } else if (cis_figure(*p, &fig)) {  /* lower case */
                c = black;
                spc = 1;
            } else {
                printf("@%c\n", *p);
                inp_tell_error("unrecognized char in Forsyth");
                return FALSE;
            }
            break;
        }
        if ((col + spc) > 8) {
            inp_tell_error("spacing over line boundary");
            return FALSE;       /* sorry */
        }
        if (c != empty) {
            if (lin < 0) {
                inp_tell_error("Forsyth has >64 positions");
                return FALSE;   /* sorry */
            }
            fysb[lin][col] = FYS_CODE(c, fig);
        }
        if (spc) {
            col += spc;
            if (col >= 8) {
                col -= 8;
                lin -= 1;
            }
        }
    }
    if ((lin != -1) || (col != 0)) {
        inp_tell_error("Forsyth has <64 positions");
        return FALSE;           /* sorry */
    }
    for (i = 0; (fig = figlist[i]) != no_figure; ++i) {
        for (c = 0; c < 2; ++c) {
            register int    cod;
            register int    delta;
            cod = FYS_CODE(c, fig);
            for (col = 0; col < 8; ++col) {
                if (c == white) {
                    lin = 0;
                    delta = 1;
                } else {
                    lin = 7;
                    delta = -1;
                }
                for (; (lin >= 0) && (lin < 8); lin += delta) {
                    if (fysb[lin][col] == cod) {
                        if (!try_set_nextfig(bp, c, fig, MK_POS(col, lin))) {
                            return FALSE;       /* sorry */
                        }
                    }
                }
            }
        }
    }
    return chk_eo_buf(p, "garbage after Forsyth");
#undef FYS_CODE
}

static          Bool            /* whether ok */
                grok_fen_tom(const char *buf, Board * bp)
{
    Colour          colour;

    if (!cis_colour(*buf++, &colour)) {
        inp_tell_error("bad colour to move in FEN");
        return FALSE;           /* sorry */
    }
    bp->b_tomove = colour;
    return chk_eo_buf(buf, "garbage after FEN colour to move");
}

static          Bool            /* whether ok */
                grok_fen_castle(const char *buf, Board * bp)
{
    int             lang;

    lang = inp__lang;
    if (lang == LANG_NONE)
        lang = LANG_ENGLISH;
    bp->b_castle[0] = 0;
    bp->b_castle[1] = 0;
    for (; *buf; ++buf) {
        if ('-' == *buf) {
            /* We accept multiple and intermixed minus signes. */
        } else if (lang_chr_Figure(lang, koenig) == *buf) {
            bp->b_castle[white] |= castle00;    /* king side (short) */
        } else if (lang_chr_Figure(lang, dame) == *buf) {
            bp->b_castle[white] |= castle000;   /* queen side (long) */
        } else if (lang_chr_figure(lang, koenig) == *buf) {
            bp->b_castle[black] |= castle00;    /* king side (short) */
        } else if (lang_chr_figure(lang, dame) == *buf) {
            bp->b_castle[black] |= castle000;   /* queen side (long) */
        } else {
            break;
        }
    }
    return chk_eo_buf(buf, "garbage after FEN castle info");
}

static          Bool            /* whether ok */
                grok_fen_ep(const char *buf, Board * bp)
{
    Position        pos;

    if ('-' == *buf) {
        buf += 1;
    } else if (buf[0] && buf[1] && cis_pos(buf[0], buf[1], &pos)) {
        buf += 2;
        /* FEN specifies the active target (just stepped over by pawn double
         * step), while we need the passive target (destination of the double
         * step). FFS: not yet checked for plausibility/legality. */
        switch (LIN(pos)) {
        case 2:
            pos += MK_DELTA(0, 1);
            break;
        case 5:
            pos -= MK_DELTA(0, 1);
            break;
        default:
            inp_tell_error("bad FEN e.p. info");
            return FALSE;
        }
        bp->b_ep = pos;
    } else {
        inp_tell_error("bad FEN e.p. info");
        return FALSE;
    }
    return chk_eo_buf(buf, "garbage after FEN ep info");
}

static          Bool            /* whether ok */
                grok_fen(const char *buf, Board * bp)
{
    /* We expect/accept the first 4 FEN fields: board, colour, castling, ep.
     * The next 2 fields are meaningless for us: we ignore all the rest. */
    char            fen[INP_BUF_SIZ];   /* cannot overflow */
    const char     *ip;
    char           *op;
    char           *part[4];
    int             i;

    ip = buf;
    op = fen;
    for (i = 0; i < 4; ++i) {
        ip = skip_space(ip);
        part[i] = op;
        while (*ip && !IS_SPACE(*ip)) {
            *op++ = *ip++;
        }
        *op++ = '\0';           /* terminate that part */
        if (!part[i][0]) {
            inp_tell_error("missing part in FEN");
            return FALSE;
        }
    }
    return grok_fys_line(part[0], bp)
        && grok_fen_tom(part[1], bp)
        && grok_fen_castle(part[2], bp)
        && grok_fen_ep(part[3], bp);
}


static          Bool            /* whether job is complete */
                grok_line(const char *buf, Board * bp, int *depthp)
{
    const char     *p;
    Colour          colour;
    Figure          figure;
    Position        pos;
    Castle          castle;
    int             dig;
    int             dep;
    int             lang;

    p = buf;
    p = skip_space(p);          /* skip over leading spaces */
    /* The next character determines interpretation of the rest of the line:
     * O	output language I	input language L	input &
     * output language j	job type z	depth & colour to move c
     * allow castling C	FEN castling e	e.p. info E	FEN e.p. info f
     * Forsyth notation F	FEN .	eoj/eof #	comment >	title
     * line % ;	copied "comment" (PGN escape & comment) */
    switch (*p) {
    case 'O':                   /* set output language */
        p = skip_space(++p);
        if (!cis_lang(*p++, &lang)) {
            inp_tell_error("bad output language");
            goto err;
        }
        set_out_lang(lang);
        break;
    case 'I':                   /* set input language */
        p = skip_space(++p);
        if (!cis_lang(*p++, &lang)) {
            inp_tell_error("bad input language");
            goto err;
        }
        set_inp_lang(lang);
        break;
    case 'L':                   /* set language (input & output) */
        p = skip_space(++p);
        if (!cis_lang(*p++, &lang)) {
            inp_tell_error("bad input language");
            goto err;
        }
        set_inp_lang(lang);
        set_out_lang(lang);
        break;
    case 'f':                   /* accept Forsyth notation of board contents */
        p = skip_space(++p);
        if (!grok_fys_line(p, bp)) {
            goto err;
        }
        break;
    case 'F':                   /* accept FEN (first 4 fields) */
        p = skip_space(++p);
        if (!grok_fen(p, bp)) {
            goto err;
        }
        break;
    default:
        if (cis_colour(*p, &colour)) {  /* new piece */
            ++p;
            if (!(cis_figure(*p, &figure)
                  || cis_Figure(*p, &figure))) {
                inp_tell_error("bad figure code");
                goto err;
            }
            p += 1;
            if (!cis_pos(p[0], p[1], &pos)) {
                inp_tell_error("bad position for piece");
                goto err;
            }
            p += 2;
            if (!try_set_nextfig(bp, colour, figure, pos)) {
                goto err;
            }
            break;
        }
        inp_tell_error("bad first character");
        goto err;
    case 'j':
        ++p;
        switch (*p++) {
        default:
            inp_tell_error("bad job type");
            goto err;
        case '\0':
        case 'o':               /* orthodox */
        case 'n':
            set_jobtype(JT_normal);
            break;
        case 'O':
        case 'N':
            set_jobtype(JT_stalemate);
            break;
        case 'h':
            set_jobtype(JT_helpmate);
            break;
        case 'H':
            set_jobtype(JT_helpstalemate);
            break;
        case 's':
            set_jobtype(JT_selfmate);
            break;
        case 'S':
            set_jobtype(JT_selfstalemate);
            break;
        }
        break;
    case 'z':
        ++p;
        if ((dig = dec_digval(*p)) >= 0) {
            ++p;
            dep = dig;
            while ((dig = dec_digval(*p)) >= 0) {
                ++p;
                dep *= 10;
                dep += dig;
                if (dep > 999) {
                    inp_tell_error("job depth too large");
                    goto err;
                }
            }
            if (!cis_colour(*p++, &colour)) {
                inp_tell_error("bad colour to move");
                goto err;
            }
            bp->b_tomove = colour;
            *depthp = dep;
        } else {
            inp_tell_error("missing job-depth");
            goto err;
        }
        break;
    case 'c':                   /* allow a castling */
        ++p;
        if (!cis_colour(*p++, &colour)) {
            inp_tell_error("bad colour for castling");
            goto err;
        }
        if (!cis_castle(*p++, &castle)) {
            inp_tell_error("bad castling code");
            goto err;
        }
        bp->b_castle[colour] |= castle;
        break;
    case 'C':                   /* FEN castling */
        p = skip_space(++p);
        if (!grok_fen_castle(p, bp)) {
            goto err;
        }
        break;
    case 'e':                   /* ep-info */
        ++p;
        if (!cis_pos(p[0], p[1], &pos)) {
            inp_tell_error("bad position");
            goto err;
        }
        bp->b_ep = pos;
        p += 2;
        break;
    case 'E':                   /* FEN ep-info */
        p = skip_space(++p);
        if (!grok_fen_ep(p, bp)) {
            goto err;
        }
        break;
    case '.':
        if (*++p == '.') {      /* ".." */
            inp_eofseen = TRUE;
        }
        goto rdy;               /* this job is complete */
    case '\0':                  /* empty line is comment */
    case '#':                   /* guaranteed to be comment */
        break;
    case '>':                   /* title line */
        ++p;
        if (is_space(*p))
            ++p;                /* skip 1 leading space/tab */
        tit_put_line(p);
        break;
    case '%':                   /* PGN escape */
    case ';':                   /* PGN comment line */
        printf("%s\n", p);      /* without leading white space */
        break;
    }
    return FALSE;               /* not yet complete */
rdy:;
    return TRUE;                /* this job is complete */
err:;
    inp_eofseen = TRUE;         /* do not continue to scan this input */
    *depthp = 0;                /* do not process this input */
    return TRUE;                /* this job is complete */
}


static          Bool            /* whether job is complete */
                grok_epd_line(const char *buf, Board * bp, EpdJob * ejp, int dftdep,
                                              int *depthp)
{
    int             rc;

    set_inp_lang(LANG_ENGLISH); /* fixed by standard */
    set_out_lang(LANG_ENGLISH); /* fixed by standard */
    epd_clear(ejp);
    rc = epd_fill_line(ejp, buf);
    if (rc != TRUE) {           /* no job in this line */
        if (rc < 0) {           /* logical end-of-input */
            inp_eofseen = TRUE;
            return TRUE;        /* empty & complete: stop further reading */
        }
        return FALSE;           /* not complete: continue reading */
    }
    /* Now we have the data parsed, but not yet made effective. */
    if (!grok_fys_line(ejp->fys, bp)
        || !grok_fen_tom(ejp->tom, bp)
        || !grok_fen_castle(ejp->castle, bp)
        || !grok_fen_ep(ejp->ep, bp)
        ) {
        empty_board(bp);        /* clear garbage for next try */
        return FALSE;           /* not complete: continue reading */
    }
    /* The board is built.  Remains to determine the job from the additional
     * EPD data. */
    /* epd_print(ejp); */

    *depthp = epd_get_dep_prog(ejp, dftdep);
    if (*depthp <= 0) {
        empty_board(bp);        /* clear garbage for next try */
    }
#if 0
    printf("# depth = %2d, jobtype %d, attr 0x%02x, prog 0x%02x\n",
           depth, f_jobtype, f_jobattr, f_jobprog);
#endif
    return *depthp > 0;         /* filled & complete: stop further reading */
}


/*
 * read_board()
 *	Read a board and return the depth of the wanted analysis.
 */
Eximpl int /* 0 | analysis depth */ read_board(Board * bp, EpdJob * ejp, int dftdep)
{
    char            buf[INP_BUF_SIZ];
    int             depth = 0;

    empty_board(bp);
    set_jobtype(JT_normal);     /* default */
    tit_clear();
    if (inp_eofseen) {          /* don't try to read further */
        goto out;
    }
    if (!inp_file) {
        inp_start_input("-");   /* stdin */
        if (!inp_file) {
            goto out;
        }
    }
    inp_bufp = buf;
    if (!f_bulkmode) {
        printf("Reading job:\n");
        oflush();
    }
    for (;;) {
        if (NULL == fgets(buf, sizeof(buf), inp_file)) {
            inp_eofseen = TRUE;
            goto out;
        }
        inp_lino += 1;          /* got one more input line */
        trim_line(buf);
        if (f_bulkmode) {       /* bulk: EPD in/out */
            if (grok_epd_line(buf, bp, ejp, dftdep, &depth)) {
                goto out;       /* this job is complete */
            }
        } else {                /* normal/old input */
            if (grok_line(buf, bp, &depth)) {
                goto out;       /* this job is complete */
            }
        }
    }
out:;
    inp_bufp = 0;
    return depth;
}