home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 5 Edit
/
05-Edit.zip
/
word2x0a.zip
/
source
/
reader.h
< prev
next >
Wrap
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__ */