509 lines
12 KiB
C++
509 lines
12 KiB
C++
// -*- C++ -*-
|
|
/* Copyright (C) 1989, 1990 Free Software Foundation, Inc.
|
|
Written by James Clark (jjc@jclark.uucp)
|
|
|
|
This file is part of groff.
|
|
|
|
groff is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 1, or (at your option) any later
|
|
version.
|
|
|
|
groff is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with groff; see the file LICENSE. If not, write to the Free Software
|
|
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
|
|
struct hyphen_list {
|
|
unsigned char hyphen;
|
|
unsigned char breakable;
|
|
unsigned char hyphenation_code;
|
|
hyphen_list *next;
|
|
hyphen_list(unsigned char code, hyphen_list *p = 0);
|
|
};
|
|
|
|
void hyphenate(hyphen_list *, unsigned);
|
|
|
|
enum hyphenation_type { HYPHEN_MIDDLE, HYPHEN_BOUNDARY, HYPHEN_INHIBIT };
|
|
|
|
class ascii_output_file;
|
|
|
|
struct breakpoint;
|
|
struct vertical_size;
|
|
struct charinfo;
|
|
|
|
class macro;
|
|
|
|
class troff_output_file;
|
|
class tfont;
|
|
class environment;
|
|
|
|
class glyph_node;
|
|
class diverted_space_node;
|
|
class token_node;
|
|
|
|
struct node {
|
|
node *next;
|
|
node();
|
|
node(node *n);
|
|
node *add_char(charinfo *c, environment *, hunits *widthp);
|
|
|
|
virtual ~node();
|
|
virtual node *copy() = 0;
|
|
virtual hunits width();
|
|
virtual hunits subscript_correction();
|
|
virtual hunits italic_correction();
|
|
virtual hunits left_italic_correction();
|
|
virtual hunits skew();
|
|
virtual int nspaces();
|
|
virtual int merge_space(hunits);
|
|
virtual vunits vertical_width();
|
|
virtual node *last_char_node();
|
|
virtual void vertical_extent(vunits *min, vunits *max);
|
|
virtual int character_type();
|
|
virtual void set_vertical_size(vertical_size *);
|
|
virtual int ends_sentence();
|
|
virtual node *merge_self(node *);
|
|
virtual node *add_discretionary_hyphen();
|
|
virtual node *add_self(node *, hyphen_list **);
|
|
virtual hyphen_list *get_hyphen_list(hyphen_list *s = 0);
|
|
virtual void ascii_print(ascii_output_file *);
|
|
virtual void asciify(macro *);
|
|
virtual int discardable();
|
|
virtual void spread_space(int *, hunits *);
|
|
virtual void freeze_space();
|
|
virtual breakpoint *get_breakpoints(hunits width, int nspaces,
|
|
breakpoint *rest = 0,
|
|
int is_inner = 0);
|
|
virtual int nbreaks();
|
|
virtual void split(int, node **, node **);
|
|
virtual hyphenation_type get_hyphenation_type();
|
|
virtual int reread(int *);
|
|
virtual token_node *get_token_node();
|
|
virtual int overlaps_vertically();
|
|
virtual int overlaps_horizontally();
|
|
virtual units size();
|
|
virtual int interpret(macro *);
|
|
|
|
virtual node *merge_glyph_node(glyph_node *);
|
|
virtual tfont *get_tfont();
|
|
virtual void tprint(troff_output_file *);
|
|
virtual void zero_width_tprint(troff_output_file *);
|
|
|
|
node *add_italic_correction(hunits *);
|
|
|
|
virtual int same(node *) = 0;
|
|
virtual const char *type() = 0;
|
|
};
|
|
|
|
inline node::node() : next(0)
|
|
{
|
|
}
|
|
|
|
inline node::node(node *n) : next(n)
|
|
{
|
|
}
|
|
|
|
inline node::~node()
|
|
{
|
|
}
|
|
|
|
// 0 means it doesn't, 1 means it does, 2 means it's transparent
|
|
|
|
int node_list_ends_sentence(node *);
|
|
|
|
struct breakpoint {
|
|
breakpoint *next;
|
|
hunits width;
|
|
int nspaces;
|
|
node *nd;
|
|
int index;
|
|
char hyphenated;
|
|
};
|
|
|
|
class line_start_node : public node {
|
|
public:
|
|
line_start_node() {}
|
|
node *copy() { return new line_start_node; }
|
|
int same(node *);
|
|
const char *type();
|
|
void asciify(macro *);
|
|
};
|
|
|
|
class space_node : public node {
|
|
private:
|
|
#if 0
|
|
enum { BLOCK = 1024 };
|
|
static space_node *free_list;
|
|
void operator delete(void *);
|
|
#endif
|
|
protected:
|
|
hunits n;
|
|
char set;
|
|
space_node(hunits, int, node * = 0);
|
|
public:
|
|
space_node(hunits d, node *p = 0);
|
|
#if 0
|
|
~space_node();
|
|
void *operator new(size_t);
|
|
#endif
|
|
node *copy();
|
|
int nspaces();
|
|
hunits width();
|
|
int discardable();
|
|
int merge_space(hunits);
|
|
void freeze_space();
|
|
void spread_space(int*, hunits*);
|
|
void tprint(troff_output_file *);
|
|
breakpoint *get_breakpoints(hunits width, int nspaces, breakpoint *rest = 0,
|
|
int is_inner = 0);
|
|
int nbreaks();
|
|
void split(int, node **, node **);
|
|
void ascii_print(ascii_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class word_space_node : public space_node {
|
|
word_space_node(hunits, int, node * = 0);
|
|
public:
|
|
word_space_node(hunits, node * = 0);
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
|
|
class diverted_space_node : public node {
|
|
public:
|
|
vunits n;
|
|
diverted_space_node(vunits d, node *p = 0);
|
|
node *copy();
|
|
int reread(int *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class diverted_copy_file_node : public node {
|
|
symbol filename;
|
|
public:
|
|
vunits n;
|
|
diverted_copy_file_node(symbol s, node *p = 0);
|
|
node *copy();
|
|
int reread(int *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class extra_size_node : public node {
|
|
vunits n;
|
|
public:
|
|
extra_size_node(vunits i) : n(i) {}
|
|
void set_vertical_size(vertical_size *);
|
|
node *copy();
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class vertical_size_node : public node {
|
|
vunits n;
|
|
public:
|
|
vertical_size_node(vunits i) : n(i) {}
|
|
void set_vertical_size(vertical_size *);
|
|
void asciify(macro *);
|
|
node *copy();
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class hmotion_node : public node {
|
|
protected:
|
|
hunits n;
|
|
public:
|
|
hmotion_node(hunits i, node *next = 0) : node(next), n(i) {}
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
hunits width();
|
|
void ascii_print(ascii_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class space_char_hmotion_node : public hmotion_node {
|
|
public:
|
|
space_char_hmotion_node(hunits i, node *next = 0);
|
|
node *copy();
|
|
void ascii_print(ascii_output_file *);
|
|
void asciify(macro *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class vmotion_node : public node {
|
|
vunits n;
|
|
public:
|
|
vmotion_node(vunits i) : n(i) {}
|
|
void tprint(troff_output_file *);
|
|
node *copy();
|
|
vunits vertical_width();
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
|
|
class hline_node : public node {
|
|
hunits x;
|
|
node *n;
|
|
public:
|
|
hline_node(hunits i, node *c, node *next = 0) : node(next), x(i), n(c) {}
|
|
~hline_node();
|
|
node *copy();
|
|
hunits width();
|
|
void tprint(troff_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class vline_node : public node {
|
|
vunits x;
|
|
node *n;
|
|
public:
|
|
vline_node(vunits i, node *c, node *next= 0) : node(next), x(i), n(c) {}
|
|
~vline_node();
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
hunits width();
|
|
vunits vertical_width();
|
|
void vertical_extent(vunits *, vunits *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
|
|
class dummy_node : public node {
|
|
public:
|
|
dummy_node(node *nd = 0) : node(nd) {}
|
|
node *copy();
|
|
int same(node *);
|
|
const char *type();
|
|
hyphenation_type get_hyphenation_type();
|
|
};
|
|
|
|
class transparent_dummy_node : public node {
|
|
public:
|
|
transparent_dummy_node() {}
|
|
node *copy();
|
|
int same(node *);
|
|
const char *type();
|
|
int ends_sentence();
|
|
hyphenation_type get_hyphenation_type();
|
|
};
|
|
|
|
class zero_width_node : public node {
|
|
node *n;
|
|
public:
|
|
zero_width_node(node *gn);
|
|
~zero_width_node();
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
void append(node *);
|
|
int character_type();
|
|
void vertical_extent(vunits *min, vunits *max);
|
|
};
|
|
|
|
class left_italic_corrected_node : public node {
|
|
node *n;
|
|
hunits x;
|
|
public:
|
|
left_italic_corrected_node(node * = 0);
|
|
~left_italic_corrected_node();
|
|
void tprint(troff_output_file *);
|
|
void ascii_print(ascii_output_file *);
|
|
void asciify(macro *);
|
|
node *copy();
|
|
int same(node *);
|
|
const char *type();
|
|
hunits width();
|
|
node *last_char_node();
|
|
void vertical_extent(vunits *, vunits *);
|
|
int ends_sentence();
|
|
int overlaps_horizontally();
|
|
int overlaps_vertically();
|
|
hyphenation_type get_hyphenation_type();
|
|
tfont *get_tfont();
|
|
int character_type();
|
|
hunits skew();
|
|
hunits italic_correction();
|
|
hunits subscript_correction();
|
|
hyphen_list *get_hyphen_list(hyphen_list *ss = 0);
|
|
node *add_self(node *, hyphen_list **);
|
|
node *merge_glyph_node(glyph_node *);
|
|
};
|
|
|
|
class overstrike_node : public node {
|
|
node *list;
|
|
hunits max_width;
|
|
public:
|
|
overstrike_node();
|
|
~overstrike_node();
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
void overstrike(node *); // add another node to be overstruck
|
|
hunits width();
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class bracket_node : public node {
|
|
node *list;
|
|
hunits max_width;
|
|
public:
|
|
bracket_node();
|
|
~bracket_node();
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
void bracket(node *); // add another node to be overstruck
|
|
hunits width();
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class special_node : public node {
|
|
macro mac;
|
|
void tprint_start(troff_output_file *);
|
|
void tprint_char(troff_output_file *, unsigned char);
|
|
void tprint_end(troff_output_file *);
|
|
public:
|
|
special_node(const macro &);
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
class charinfo;
|
|
|
|
class composite_node : public node {
|
|
charinfo *ci;
|
|
node *n;
|
|
font_size sz;
|
|
public:
|
|
composite_node(node *, charinfo *, font_size, node * = 0);
|
|
~composite_node();
|
|
node *copy();
|
|
hunits width();
|
|
node *last_char_node();
|
|
units size();
|
|
void tprint(troff_output_file *);
|
|
hyphenation_type get_hyphenation_type();
|
|
int overlaps_horizontally();
|
|
int overlaps_vertically();
|
|
void ascii_print(ascii_output_file *);
|
|
void asciify(macro *);
|
|
hyphen_list *get_hyphen_list(hyphen_list *tail);
|
|
node *add_self(node *, hyphen_list **);
|
|
tfont *get_tfont();
|
|
int same(node *);
|
|
const char *type();
|
|
void vertical_extent(vunits *, vunits *);
|
|
vunits vertical_width();
|
|
};
|
|
|
|
struct hvpair {
|
|
hunits h;
|
|
vunits v;
|
|
|
|
hvpair();
|
|
};
|
|
|
|
class draw_node : public node {
|
|
int npoints;
|
|
font_size sz;
|
|
char code;
|
|
hvpair *point;
|
|
public:
|
|
draw_node(char, hvpair *, int, font_size);
|
|
~draw_node();
|
|
hunits width();
|
|
vunits vertical_width();
|
|
node *copy();
|
|
void tprint(troff_output_file *);
|
|
int same(node *);
|
|
const char *type();
|
|
};
|
|
|
|
node *make_node(charinfo *ci, environment *);
|
|
int character_exists(charinfo *, environment *);
|
|
|
|
int same_node_list(node *n1, node *n2);
|
|
node *reverse_node_list(node *n);
|
|
void delete_node_list(node *);
|
|
node *copy_node_list(node *);
|
|
|
|
hunits env_digit_width(environment *);
|
|
hunits env_space_width(environment *);
|
|
hunits env_narrow_space_width(environment *);
|
|
hunits env_half_narrow_space_width(environment *);
|
|
int get_bold_fontno(int f);
|
|
|
|
inline hyphen_list::hyphen_list(unsigned char code, hyphen_list *p)
|
|
: hyphenation_code(code), next(p), hyphen(0), breakable(0)
|
|
{
|
|
}
|
|
|
|
extern void read_desc();
|
|
extern int mount_font(int n, symbol, symbol = NULL_SYMBOL);
|
|
extern void mount_style(int n, symbol);
|
|
extern int is_good_fontno(int n);
|
|
extern int symbol_fontno(symbol);
|
|
extern int next_available_font_position();
|
|
extern void init_size_table(int *);
|
|
extern int get_underline_fontno();
|
|
|
|
class output_file {
|
|
char make_g_plus_plus_shut_up;
|
|
public:
|
|
output_file();
|
|
virtual ~output_file();
|
|
virtual void flush() = 0;
|
|
virtual void transparent_char(unsigned char) = 0;
|
|
virtual void print_line(hunits x, vunits y, node *n,
|
|
vunits before, vunits after) = 0;
|
|
virtual void begin_page(int pageno, vunits page_length) = 0;
|
|
virtual void copy_file(hunits x, vunits y, const char *filename) = 0;
|
|
virtual int is_printing() = 0;
|
|
#ifdef COLUMN
|
|
virtual void vjustify(vunits, symbol);
|
|
#endif /* COLUMN */
|
|
};
|
|
|
|
extern char *pipe_command;
|
|
|
|
extern output_file *the_output;
|
|
extern void init_output();
|
|
int in_output_page_list(int n);
|
|
|
|
static void invalidate_fontno(int);
|
|
|
|
class font_family {
|
|
int *map;
|
|
int map_size;
|
|
public:
|
|
const symbol nm;
|
|
|
|
font_family(symbol);
|
|
~font_family();
|
|
make_definite(int);
|
|
friend void invalidate_fontno(int);
|
|
};
|
|
|
|
font_family *lookup_family(symbol);
|