733 lines
14 KiB
C++
733 lines
14 KiB
C++
// -*- C++ -*-
|
|
/* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
|
|
Written by James Clark (jjc@jclark.com)
|
|
|
|
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 2, 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 COPYING. If not, write to the Free Software
|
|
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
|
|
#ifdef COLUMN
|
|
|
|
#include "troff.h"
|
|
#include "symbol.h"
|
|
#include "dictionary.h"
|
|
#include "hvunits.h"
|
|
#include "env.h"
|
|
#include "request.h"
|
|
#include "node.h"
|
|
#include "token.h"
|
|
#include "div.h"
|
|
#include "reg.h"
|
|
#include "stringclass.h"
|
|
|
|
void output_file::vjustify(vunits, symbol)
|
|
{
|
|
// do nothing
|
|
}
|
|
|
|
struct justification_spec;
|
|
struct output_line;
|
|
|
|
class column : public output_file {
|
|
private:
|
|
output_file *out;
|
|
vunits bottom;
|
|
output_line *col;
|
|
output_line **tail;
|
|
void add_output_line(output_line *);
|
|
void begin_page(int pageno, vunits page_length);
|
|
void flush();
|
|
void print_line(hunits, vunits, node *, vunits, vunits);
|
|
void vjustify(vunits, symbol);
|
|
void transparent_char(unsigned char c);
|
|
void copy_file(hunits, vunits, const char *);
|
|
int is_printing();
|
|
void check_bottom();
|
|
public:
|
|
column();
|
|
~column();
|
|
void start();
|
|
void output();
|
|
void justify(const justification_spec &);
|
|
void trim();
|
|
void reset();
|
|
vunits get_bottom();
|
|
vunits get_last_extra_space();
|
|
int is_active() { return out != 0; }
|
|
};
|
|
|
|
column *the_column = 0;
|
|
|
|
struct transparent_output_line;
|
|
struct vjustify_output_line;
|
|
|
|
class output_line {
|
|
output_line *next;
|
|
public:
|
|
output_line();
|
|
virtual ~output_line();
|
|
virtual void output(output_file *, vunits);
|
|
virtual transparent_output_line *as_transparent_output_line();
|
|
virtual vjustify_output_line *as_vjustify_output_line();
|
|
virtual vunits distance();
|
|
virtual vunits height();
|
|
virtual void reset();
|
|
virtual vunits extra_space(); // post line
|
|
friend class column;
|
|
friend class justification_spec;
|
|
};
|
|
|
|
class position_output_line : public output_line {
|
|
vunits dist;
|
|
public:
|
|
position_output_line(vunits);
|
|
vunits distance();
|
|
};
|
|
|
|
class node_output_line : public position_output_line {
|
|
node *nd;
|
|
hunits page_offset;
|
|
vunits before;
|
|
vunits after;
|
|
public:
|
|
node_output_line(vunits, node *, hunits, vunits, vunits);
|
|
~node_output_line();
|
|
void output(output_file *, vunits);
|
|
vunits height();
|
|
vunits extra_space();
|
|
};
|
|
|
|
class vjustify_output_line : public position_output_line {
|
|
vunits current;
|
|
symbol typ;
|
|
public:
|
|
vjustify_output_line(vunits dist, symbol);
|
|
vunits height();
|
|
vjustify_output_line *as_vjustify_output_line();
|
|
void vary(vunits amount);
|
|
void reset();
|
|
symbol type();
|
|
};
|
|
|
|
inline symbol vjustify_output_line::type()
|
|
{
|
|
return typ;
|
|
}
|
|
|
|
class copy_file_output_line : public position_output_line {
|
|
symbol filename;
|
|
hunits hpos;
|
|
public:
|
|
copy_file_output_line(vunits, const char *, hunits);
|
|
void output(output_file *, vunits);
|
|
};
|
|
|
|
class transparent_output_line : public output_line {
|
|
string buf;
|
|
public:
|
|
transparent_output_line();
|
|
void output(output_file *, vunits);
|
|
void append_char(unsigned char c);
|
|
transparent_output_line *as_transparent_output_line();
|
|
};
|
|
|
|
output_line::output_line() : next(0)
|
|
{
|
|
}
|
|
|
|
output_line::~output_line()
|
|
{
|
|
}
|
|
|
|
void output_line::reset()
|
|
{
|
|
}
|
|
|
|
transparent_output_line *output_line::as_transparent_output_line()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
vjustify_output_line *output_line::as_vjustify_output_line()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void output_line::output(output_file *, vunits)
|
|
{
|
|
}
|
|
|
|
vunits output_line::distance()
|
|
{
|
|
return V0;
|
|
}
|
|
|
|
vunits output_line::height()
|
|
{
|
|
return V0;
|
|
}
|
|
|
|
vunits output_line::extra_space()
|
|
{
|
|
return V0;
|
|
}
|
|
|
|
position_output_line::position_output_line(vunits d)
|
|
: dist(d)
|
|
{
|
|
}
|
|
|
|
vunits position_output_line::distance()
|
|
{
|
|
return dist;
|
|
}
|
|
|
|
node_output_line::node_output_line(vunits d, node *n, hunits po, vunits b, vunits a)
|
|
: position_output_line(d), nd(n), page_offset(po), before(b), after(a)
|
|
{
|
|
}
|
|
|
|
node_output_line::~node_output_line()
|
|
{
|
|
delete_node_list(nd);
|
|
}
|
|
|
|
void node_output_line::output(output_file *out, vunits pos)
|
|
{
|
|
out->print_line(page_offset, pos, nd, before, after);
|
|
nd = 0;
|
|
}
|
|
|
|
vunits node_output_line::height()
|
|
{
|
|
return after;
|
|
}
|
|
|
|
vunits node_output_line::extra_space()
|
|
{
|
|
return after;
|
|
}
|
|
|
|
vjustify_output_line::vjustify_output_line(vunits d, symbol t)
|
|
: position_output_line(d), typ(t)
|
|
{
|
|
}
|
|
|
|
void vjustify_output_line::reset()
|
|
{
|
|
current = V0;
|
|
}
|
|
|
|
vunits vjustify_output_line::height()
|
|
{
|
|
return current;
|
|
}
|
|
|
|
vjustify_output_line *vjustify_output_line::as_vjustify_output_line()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
inline void vjustify_output_line::vary(vunits amount)
|
|
{
|
|
current += amount;
|
|
}
|
|
|
|
transparent_output_line::transparent_output_line()
|
|
{
|
|
}
|
|
|
|
transparent_output_line *transparent_output_line::as_transparent_output_line()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
void transparent_output_line::append_char(unsigned char c)
|
|
{
|
|
assert(c != 0);
|
|
buf += c;
|
|
}
|
|
|
|
void transparent_output_line::output(output_file *out, vunits)
|
|
{
|
|
int len = buf.length();
|
|
for (int i = 0; i < len; i++)
|
|
out->transparent_char(buf[i]);
|
|
}
|
|
|
|
copy_file_output_line::copy_file_output_line(vunits d, const char *f, hunits h)
|
|
: position_output_line(d), hpos(h), filename(f)
|
|
{
|
|
}
|
|
|
|
void copy_file_output_line::output(output_file *out, vunits pos)
|
|
{
|
|
out->copy_file(hpos, pos, filename.contents());
|
|
}
|
|
|
|
column::column()
|
|
: bottom(V0), col(0), tail(&col), out(0)
|
|
{
|
|
}
|
|
|
|
column::~column()
|
|
{
|
|
assert(out != 0);
|
|
error("automatically outputting column before exiting");
|
|
output();
|
|
delete the_output;
|
|
}
|
|
|
|
void column::start()
|
|
{
|
|
assert(out == 0);
|
|
if (!the_output)
|
|
init_output();
|
|
assert(the_output != 0);
|
|
out = the_output;
|
|
the_output = this;
|
|
}
|
|
|
|
void column::begin_page(int pageno, vunits page_length)
|
|
{
|
|
assert(out != 0);
|
|
if (col) {
|
|
error("automatically outputting column before beginning next page");
|
|
output();
|
|
the_output->begin_page(pageno, page_length);
|
|
}
|
|
else
|
|
out->begin_page(pageno, page_length);
|
|
|
|
}
|
|
|
|
void column::flush()
|
|
{
|
|
assert(out != 0);
|
|
out->flush();
|
|
}
|
|
|
|
int column::is_printing()
|
|
{
|
|
assert(out != 0);
|
|
return out->is_printing();
|
|
}
|
|
|
|
vunits column::get_bottom()
|
|
{
|
|
return bottom;
|
|
}
|
|
|
|
void column::add_output_line(output_line *ln)
|
|
{
|
|
*tail = ln;
|
|
bottom += ln->distance();
|
|
bottom += ln->height();
|
|
ln->next = 0;
|
|
tail = &(*tail)->next;
|
|
}
|
|
|
|
void column::print_line(hunits page_offset, vunits pos, node *nd,
|
|
vunits before, vunits after)
|
|
{
|
|
assert(out != 0);
|
|
add_output_line(new node_output_line(pos - bottom, nd, page_offset, before, after));
|
|
}
|
|
|
|
void column::vjustify(vunits pos, symbol typ)
|
|
{
|
|
assert(out != 0);
|
|
add_output_line(new vjustify_output_line(pos - bottom, typ));
|
|
}
|
|
|
|
void column::transparent_char(unsigned char c)
|
|
{
|
|
assert(out != 0);
|
|
transparent_output_line *tl = 0;
|
|
if (*tail)
|
|
tl = (*tail)->as_transparent_output_line();
|
|
if (!tl) {
|
|
tl = new transparent_output_line;
|
|
add_output_line(tl);
|
|
}
|
|
tl->append_char(c);
|
|
}
|
|
|
|
void column::copy_file(hunits page_offset, vunits pos, const char *filename)
|
|
{
|
|
assert(out != 0);
|
|
add_output_line(new copy_file_output_line(pos - bottom, filename, page_offset));
|
|
}
|
|
|
|
void column::trim()
|
|
{
|
|
output_line **spp = 0;
|
|
for (output_line **pp = &col; *pp; pp = &(*pp)->next)
|
|
if ((*pp)->as_vjustify_output_line() == 0)
|
|
spp = 0;
|
|
else if (!spp)
|
|
spp = pp;
|
|
if (spp) {
|
|
output_line *ln = *spp;
|
|
*spp = 0;
|
|
tail = spp;
|
|
while (ln) {
|
|
output_line *tem = ln->next;
|
|
bottom -= ln->distance();
|
|
bottom -= ln->height();
|
|
delete ln;
|
|
ln = tem;
|
|
}
|
|
}
|
|
}
|
|
|
|
void column::reset()
|
|
{
|
|
bottom = V0;
|
|
for (output_line *ln = col; ln; ln = ln->next) {
|
|
bottom += ln->distance();
|
|
ln->reset();
|
|
bottom += ln->height();
|
|
}
|
|
}
|
|
|
|
void column::check_bottom()
|
|
{
|
|
vunits b;
|
|
for (output_line *ln = col; ln; ln = ln->next) {
|
|
b += ln->distance();
|
|
b += ln->height();
|
|
}
|
|
assert(b == bottom);
|
|
}
|
|
|
|
void column::output()
|
|
{
|
|
assert(out != 0);
|
|
vunits vpos(V0);
|
|
output_line *ln = col;
|
|
while (ln) {
|
|
vpos += ln->distance();
|
|
ln->output(out, vpos);
|
|
vpos += ln->height();
|
|
output_line *tem = ln->next;
|
|
delete ln;
|
|
ln = tem;
|
|
}
|
|
tail = &col;
|
|
bottom = V0;
|
|
col = 0;
|
|
the_output = out;
|
|
out = 0;
|
|
}
|
|
|
|
vunits column::get_last_extra_space()
|
|
{
|
|
if (!col)
|
|
return V0;
|
|
for (output_line *p = col; p->next; p = p->next)
|
|
;
|
|
return p->extra_space();
|
|
}
|
|
|
|
class justification_spec {
|
|
vunits height;
|
|
symbol *type;
|
|
vunits *amount;
|
|
int n;
|
|
int maxn;
|
|
public:
|
|
justification_spec(vunits);
|
|
~justification_spec();
|
|
void append(symbol t, vunits v);
|
|
void justify(output_line *, vunits *bottomp) const;
|
|
};
|
|
|
|
justification_spec::justification_spec(vunits h)
|
|
: height(h), n(0), maxn(10)
|
|
{
|
|
type = new symbol[maxn];
|
|
amount = new vunits[maxn];
|
|
}
|
|
|
|
justification_spec::~justification_spec()
|
|
{
|
|
a_delete type;
|
|
a_delete amount;
|
|
}
|
|
|
|
void justification_spec::append(symbol t, vunits v)
|
|
{
|
|
if (v <= V0) {
|
|
if (v < V0)
|
|
warning(WARN_RANGE,
|
|
"maximum space for vertical justification must not be negative");
|
|
else
|
|
warning(WARN_RANGE,
|
|
"maximum space for vertical justification must not be zero");
|
|
return;
|
|
}
|
|
if (n >= maxn) {
|
|
maxn *= 2;
|
|
symbol *old_type = type;
|
|
type = new symbol[maxn];
|
|
int i;
|
|
for (i = 0; i < n; i++)
|
|
type[i] = old_type[i];
|
|
a_delete old_type;
|
|
vunits *old_amount = amount;
|
|
amount = new vunits[maxn];
|
|
for (i = 0; i < n; i++)
|
|
amount[i] = old_amount[i];
|
|
a_delete old_amount;
|
|
}
|
|
assert(n < maxn);
|
|
type[n] = t;
|
|
amount[n] = v;
|
|
n++;
|
|
}
|
|
|
|
void justification_spec::justify(output_line *col, vunits *bottomp) const
|
|
{
|
|
if (*bottomp >= height)
|
|
return;
|
|
vunits total;
|
|
output_line *p;
|
|
for (p = col; p; p = p->next) {
|
|
vjustify_output_line *sp = p->as_vjustify_output_line();
|
|
if (sp) {
|
|
symbol t = sp->type();
|
|
for (int i = 0; i < n; i++) {
|
|
if (t == type[i])
|
|
total += amount[i];
|
|
}
|
|
}
|
|
}
|
|
vunits gap = height - *bottomp;
|
|
for (p = col; p; p = p->next) {
|
|
vjustify_output_line *sp = p->as_vjustify_output_line();
|
|
if (sp) {
|
|
symbol t = sp->type();
|
|
for (int i = 0; i < n; i++) {
|
|
if (t == type[i]) {
|
|
if (total <= gap) {
|
|
sp->vary(amount[i]);
|
|
gap -= amount[i];
|
|
}
|
|
else {
|
|
// gap < total
|
|
vunits v = scale(amount[i], gap, total);
|
|
sp->vary(v);
|
|
gap -= v;
|
|
}
|
|
total -= amount[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert(total == V0);
|
|
*bottomp = height - gap;
|
|
}
|
|
|
|
void column::justify(const justification_spec &js)
|
|
{
|
|
check_bottom();
|
|
js.justify(col, &bottom);
|
|
check_bottom();
|
|
}
|
|
|
|
void column_justify()
|
|
{
|
|
vunits height;
|
|
if (!the_column->is_active())
|
|
error("can't justify column - column not active");
|
|
else if (get_vunits(&height, 'v')) {
|
|
justification_spec js(height);
|
|
symbol nm = get_long_name(1);
|
|
if (!nm.is_null()) {
|
|
vunits v;
|
|
if (get_vunits(&v, 'v')) {
|
|
js.append(nm, v);
|
|
int err = 0;
|
|
while (has_arg()) {
|
|
nm = get_long_name(1);
|
|
if (nm.is_null()) {
|
|
err = 1;
|
|
break;
|
|
}
|
|
if (!get_vunits(&v, 'v')) {
|
|
err = 1;
|
|
break;
|
|
}
|
|
js.append(nm, v);
|
|
}
|
|
if (!err)
|
|
the_column->justify(js);
|
|
}
|
|
}
|
|
}
|
|
skip_line();
|
|
}
|
|
|
|
void column_start()
|
|
{
|
|
if (the_column->is_active())
|
|
error("can't start column - column already active");
|
|
else
|
|
the_column->start();
|
|
skip_line();
|
|
}
|
|
|
|
void column_output()
|
|
{
|
|
if (!the_column->is_active())
|
|
error("can't output column - column not active");
|
|
else
|
|
the_column->output();
|
|
skip_line();
|
|
}
|
|
|
|
void column_trim()
|
|
{
|
|
if (!the_column->is_active())
|
|
error("can't trim column - column not active");
|
|
else
|
|
the_column->trim();
|
|
skip_line();
|
|
}
|
|
|
|
void column_reset()
|
|
{
|
|
if (!the_column->is_active())
|
|
error("can't reset column - column not active");
|
|
else
|
|
the_column->reset();
|
|
skip_line();
|
|
}
|
|
|
|
class column_bottom_reg : public reg {
|
|
public:
|
|
const char *get_string();
|
|
};
|
|
|
|
const char *column_bottom_reg::get_string()
|
|
{
|
|
return itoa(the_column->get_bottom().to_units());
|
|
}
|
|
|
|
class column_extra_space_reg : public reg {
|
|
public:
|
|
const char *get_string();
|
|
};
|
|
|
|
const char *column_extra_space_reg::get_string()
|
|
{
|
|
return itoa(the_column->get_last_extra_space().to_units());
|
|
}
|
|
|
|
class column_active_reg : public reg {
|
|
public:
|
|
const char *get_string();
|
|
};
|
|
|
|
const char *column_active_reg::get_string()
|
|
{
|
|
return the_column->is_active() ? "1" : "0";
|
|
}
|
|
|
|
static int no_vjustify_mode = 0;
|
|
|
|
class vjustify_node : public node {
|
|
symbol typ;
|
|
public:
|
|
vjustify_node(symbol);
|
|
int reread(int *);
|
|
const char *type();
|
|
int same(node *);
|
|
node *copy();
|
|
};
|
|
|
|
vjustify_node::vjustify_node(symbol t)
|
|
: typ(t)
|
|
{
|
|
}
|
|
|
|
node *vjustify_node::copy()
|
|
{
|
|
return new vjustify_node(typ);
|
|
}
|
|
|
|
const char *vjustify_node::type()
|
|
{
|
|
return "vjustify_node";
|
|
}
|
|
|
|
int vjustify_node::same(node *nd)
|
|
{
|
|
return typ == ((vjustify_node *)nd)->typ;
|
|
}
|
|
|
|
int vjustify_node::reread(int *bolp)
|
|
{
|
|
curdiv->vjustify(typ);
|
|
*bolp = 1;
|
|
return 1;
|
|
}
|
|
|
|
void macro_diversion::vjustify(symbol type)
|
|
{
|
|
if (!no_vjustify_mode)
|
|
mac->append(new vjustify_node(type));
|
|
}
|
|
|
|
void top_level_diversion::vjustify(symbol type)
|
|
{
|
|
if (no_space_mode || no_vjustify_mode)
|
|
return;
|
|
assert(first_page_begun); // I'm not sure about this.
|
|
the_output->vjustify(vertical_position, type);
|
|
}
|
|
|
|
void no_vjustify()
|
|
{
|
|
skip_line();
|
|
no_vjustify_mode = 1;
|
|
}
|
|
|
|
void restore_vjustify()
|
|
{
|
|
skip_line();
|
|
no_vjustify_mode = 0;
|
|
}
|
|
|
|
void init_column_requests()
|
|
{
|
|
the_column = new column;
|
|
init_request("cols", column_start);
|
|
init_request("colo", column_output);
|
|
init_request("colj", column_justify);
|
|
init_request("colr", column_reset);
|
|
init_request("colt", column_trim);
|
|
init_request("nvj", no_vjustify);
|
|
init_request("rvj", restore_vjustify);
|
|
number_reg_dictionary.define(".colb", new column_bottom_reg);
|
|
number_reg_dictionary.define(".colx", new column_extra_space_reg);
|
|
number_reg_dictionary.define(".cola", new column_active_reg);
|
|
number_reg_dictionary.define(".nvj",
|
|
new constant_int_reg(&no_vjustify_mode));
|
|
}
|
|
|
|
#endif /* COLUMN */
|