OS/2 Shareware BBS: 5 Edit/05-Edit.zip/word2x0a.zip/source/reader.h

C/C++ Source or Header | 1998-04-20 | 5KB | 274 lines

/* $Id: reader.h,v 1.23 1997/04/17 15:38:19 dps Exp $ */
/* header file for the reader */

#ifndef __w6_reader_h__
#define __w6_reader_h__
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include "tblock.h"
#include "interface.h"
#include "fifo.h"
#include "word6.h"



/* Raw reader output */
typedef enum
{
    CH_PAR=0, CH_FIELD, CH_ROW, CH_SPEC, CH_ENDSPEC, CH_OTHER,
    CH_HDRTN, CH_EOF, CH_PAGE, CH_FOOTNOTE,
    CONTROL_FLAG=(1<<17), PART_FLAG=(1<<18)
} chunk_type;

#define CH_NONL 255
#define CH_SUSPECT 127

/*
 * Anything shorter than in totla this is word abuse an all spec
 * paragraph. This should be kept *very* small.
 */
#define DISPL_TRESHOLD 3
#define PAR_ITEM_SEP_LIMIT 4
#define TEXT_ITEM_SEP_LIMIT 1024

#ifndef __EXCLUDE_READER_CLASSES

struct chunk_rtn
{
    tblock txt;
    int type;
};

/* This class converts raw word 6 into chunks for easier digestion */
class chunk_reader
{
 private:
    tblock text;
    FILE *in;            /* Maybe should use istream here */
    const char *tptr;        /* Points to tblock text */
    int type;            /* Type */

    void read_chunk_raw(void);    /* Reads a lot */
 protected:
    struct chunk_rtn read_chunk(void); /* Returns the next bit */

    int seek_start(FILE *);    /* Find data start */
    inline chunk_reader(FILE *f)
    {
    tptr=NULL;
    in=f;
    seek_start(f);
    }
    inline ~chunk_reader(void) {}; /* Avoids compiler bug */
};


/*
 * This class interpolates stuff not in the chunks, for example the
 * the start and statistics of tables.
 */
class tok_seq: private chunk_reader
{
    /* Classes used here */
public:
    /* Public token class */
    class tok
    {
    private:
    enum {TABLE=0, TEXT} dtype;

    public:
    enum { TOK_START=0, TOK_END };
    token tok;
    union
    {
        struct
        {
        int rows;
        int cols;
        } table;
        const char *d;
    } data;
    int end;

    friend ostream &operator <<(ostream &, const tok *f);
    tok &operator=(const tok &d);
    /* Avoid the need to cast NULL everywhere  for NULL defined as
       (void *) 0 */
    inline tok(token t, void *d, int e)
    {
        tok=t;
        data.d=(const char *) d;
        dtype=TEXT;
        end=e;
    }
    /* Avoid the need to cast NULL everywhere for NULL defined as 0 */
    inline tok(token t, int d, int e)
    {
        d=d;
        tok=t;
        data.d=(const char *) NULL;
        dtype=TEXT;
        end=e;
    }
    /* Avoid the need to cast NULL everywhere for NULL defined as 0L */
    inline tok(token t, long int d, int e)
    {
        d=d;
        tok=t;
        data.d=(const char *) NULL;
        dtype=TEXT;
        end=e;
    }

    inline tok(token t, const char *d, int e)
    {
        tok=t;
        if (d!=NULL)
        data.d=strdup(d);
        else
        data.d=NULL;
        dtype=TEXT;
        end=e;
    }
    inline tok(token t, int c, int r, int e)
    {
        tok=t;
        data.table.rows=r;
        data.table.cols=c;
        dtype=TABLE;
        end=e;
    }
    inline ~tok(void)
    {
        if (dtype==TEXT && data.d!=NULL)
        free((void *) data.d);
    }
    };


private:
    /* Private class for table information */
    class table_info
    {
    private:
    fifo<tok> toks;

    public:
    int rows;
    int cols;
    int col;

    inline table_info(void)
    {
        cols=0;
        col=0;
        rows=0;
    }

    inline void tok_push(token t, tblock *s)
    {
        tok *td;
        td=new(tok)(t, (const char *) (*s), tok::TOK_START);
        toks.enqueue(td);
        td=new(tok)(t, (void *) NULL, tok::TOK_END);
        toks.enqueue(td);
    }

    inline void enqueue(const tok *t)
    {
        toks.enqueue(t);
    }

    inline void finish(fifo<tok> *out)
    {
        tok *t;

        t=new(tok)(T_TABLE, cols, rows, tok::TOK_START);
        out->enqueue(t);
        out->transfer(&toks);
        t=new(tok)(T_TABLE, cols, rows, tok::TOK_END);
        out->enqueue(t);
    }
    inline ~table_info(void) {} // Avoid compiler bug
    };

private:
    fifo<tok> output;        /* Output with equation cleaned up */
    const tok *saved_tok;
    int done_end;
    table_info *table;
    int rd_token(void);
    const tok *feed_token(void);
    const tok *math_collect(void);

    /* Token pusher */
    inline void tok_push(token t, tblock *s)
    {
    tok *td;
    td=new(tok)(t, (const char *) (*s), tok::TOK_START);
    output.enqueue(td);
    td=new(tok)(t, (void *) NULL, tok::TOK_END);
    output.enqueue(td);
    }

    const tok *eqn_rd_token(void);

    /* List handling */
    typedef enum { LIST_BULLET, LIST_ENUMERATE, LIST_ENUM_ALPHA } l_type;
    struct list_info
    {
    struct list_info *next_list;
    l_type list_type;
    int obj_cnt;
    int text_cnt;
    int items;
    union
    {
        int item_no;
        int lbullet;
    } ldata;
    fifo<tok_seq::tok> *last_item;
    };
    struct list_info *lp;    /* List pointer */
    fifo<tok> outqueue;        /* Final output (so far...) */
    fifo<tok> *recycled;    /* elements to be processed again */
    struct list_info *list_type(const char *);
    const char *list_check(const char *, struct list_info **);
    const char *l_type_name(const struct list_info *);

 public:


    tok_seq(FILE *in):  chunk_reader(in)
    {
    tok *t=new(tok)(T_DOC, "Converted by word2x", tok::TOK_START);
    table=NULL;        /* No table */
    saved_tok=NULL;        /* No saved token */
    lp=NULL;        /* No list */
    recycled=NULL;        /* Nothing recycled */
    done_end=0;

    output.enqueue(t);
    }

    inline void return_toks(fifo<tok> *tp)
    {
    if (recycled==NULL)
        recycled=new(fifo<tok>);
    recycled->ins_trans(tp);
    }

    inline ~tok_seq(void) {}    // Avoids compiler bug

    const tok *read_token(void);

};
#endif /* __EXCLUDE_READER_CLASSES */
#endif /* __w6_reader_h__ */