src/troff/column.cpp

   1 /*@
   2  * Copyright (c) 2014 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   3  *
   4  * Copyright (C) 1989 - 1992, 2000 Free Software Foundation, Inc.
   5  *      Written by James Clark (jjc@jclark.com)
   6  *
   7  * This is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2, or (at your option) any later
  10  * version.
  11  *
  12  * This is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with groff; see the file COPYING.  If not, write to the Free Software
  19  * Foundation, 51 Franklin St - Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21 #ifdef COLUMN
  22
  23 #include "config.h"
  24 #include "troff-config.h"
  25
  26 #include "stringclass.h"
  27 #include "symbol.h"
  28
  29 #include "div.h"
  30 #include "dictionary.h"
  31 #include "env.h"
  32 #include "hvunits.h"
  33 #include "node.h"
  34 #include "reg.h"
  35 #include "request.h"
  36 #include "token.h"
  37 #include "troff.h"
  38
  39 void output_file::vjustify(vunits, symbol)
  40 {
  41   // do nothing
  42 }
  43
  44 struct justification_spec;
  45 struct output_line;
  46
  47 class column
  48 : public output_file
  49 {
  50   output_file *out;
  51   vunits bottom;
  52   output_line *col;
  53   output_line **tail;
  54
  55   void add_output_line(output_line *);
  56   void begin_page(int pageno, vunits page_length);
  57   void flush();
  58   void print_line(hunits, vunits, node *, vunits, vunits);
  59   void vjustify(vunits, symbol);
  60   void transparent_char(unsigned char c);
  61   void copy_file(hunits, vunits, const char *);
  62   int is_printing();
  63   void check_bottom();
  64
  65 public:
  66   column();
  67   ~column();
  68   void start();
  69   void output();
  70   void justify(const justification_spec &);
  71   void trim();
  72   void reset();
  73   vunits get_bottom();
  74   vunits get_last_extra_space();
  75   int is_active() { return out != 0; }
  76 };
  77
  78 column *the_column = 0;
  79
  80 struct transparent_output_line;
  81 struct vjustify_output_line;
  82
  83 class output_line
  84 {
  85   friend class column;
  86   friend class justification_spec;
  87
  88   output_line *next;
  89
  90 public:
  91   output_line();
  92   virtual ~output_line();
  93   virtual void output(output_file *, vunits);
  94   virtual transparent_output_line *as_transparent_output_line();
  95   virtual vjustify_output_line *as_vjustify_output_line();
  96   virtual vunits distance();
  97   virtual vunits height();
  98   virtual void reset();
  99   virtual vunits extra_space(); // post line
 100 };
 101
 102 class position_output_line
 103 : public output_line
 104 {
 105   vunits dist;
 106
 107 public:
 108   position_output_line(vunits);
 109   vunits distance();
 110 };
 111
 112 class node_output_line
 113 : public position_output_line
 114 {
 115   node *nd;
 116   hunits page_offset;
 117   vunits before;
 118   vunits after;
 119
 120 public:
 121   node_output_line(vunits, node *, hunits, vunits, vunits);
 122   ~node_output_line();
 123   void output(output_file *, vunits);
 124   vunits height();
 125   vunits extra_space();
 126 };
 127
 128 class vjustify_output_line
 129 : public position_output_line
 130 {
 131   vunits current;
 132   symbol typ;
 133
 134 public:
 135   vjustify_output_line(vunits dist, symbol);
 136   vunits height();
 137   vjustify_output_line *as_vjustify_output_line();
 138   void vary(vunits amount);
 139   void reset();
 140   symbol type();
 141 };
 142
 143 inline symbol vjustify_output_line::type()
 144 {
 145   return typ;
 146 }
 147
 148 class copy_file_output_line
 149 : public position_output_line
 150 {
 151   symbol filename;
 152   hunits hpos;
 153
 154 public:
 155   copy_file_output_line(vunits, const char *, hunits);
 156   void output(output_file *, vunits);
 157 };
 158
 159 class transparent_output_line
 160 : public output_line
 161 {
 162   string buf;
 163
 164 public:
 165   transparent_output_line();
 166   void output(output_file *, vunits);
 167   void append_char(unsigned char c);
 168   transparent_output_line *as_transparent_output_line();
 169 };
 170
 171 output_line::output_line() : next(0)
 172 {
 173 }
 174
 175 output_line::~output_line()
 176 {
 177 }
 178
 179 void output_line::reset()
 180 {
 181 }
 182
 183 transparent_output_line *output_line::as_transparent_output_line()
 184 {
 185   return 0;
 186 }
 187
 188 vjustify_output_line *output_line::as_vjustify_output_line()
 189 {
 190   return 0;
 191 }
 192
 193 void output_line::output(output_file *, vunits)
 194 {
 195 }
 196
 197 vunits output_line::distance()
 198 {
 199   return V0;
 200 }
 201
 202 vunits output_line::height()
 203 {
 204   return V0;
 205 }
 206
 207 vunits output_line::extra_space()
 208 {
 209   return V0;
 210 }
 211
 212 position_output_line::position_output_line(vunits d)
 213 : dist(d)
 214 {
 215 }
 216
 217 vunits position_output_line::distance()
 218 {
 219   return dist;
 220 }
 221
 222 node_output_line::node_output_line(vunits d, node *n, hunits po, vunits b, vunits a)
 223 : position_output_line(d), nd(n), page_offset(po), before(b), after(a)
 224 {
 225 }
 226
 227 node_output_line::~node_output_line()
 228 {
 229   delete_node_list(nd);
 230 }
 231
 232 void node_output_line::output(output_file *out, vunits pos)
 233 {
 234   out->print_line(page_offset, pos, nd, before, after);
 235   nd = 0;
 236 }
 237
 238 vunits node_output_line::height()
 239 {
 240   return after;
 241 }
 242
 243 vunits node_output_line::extra_space()
 244 {
 245   return after;
 246 }
 247
 248 vjustify_output_line::vjustify_output_line(vunits d, symbol t)
 249 : position_output_line(d), typ(t)
 250 {
 251 }
 252
 253 void vjustify_output_line::reset()
 254 {
 255   current = V0;
 256 }
 257
 258 vunits vjustify_output_line::height()
 259 {
 260   return current;
 261 }
 262
 263 vjustify_output_line *vjustify_output_line::as_vjustify_output_line()
 264 {
 265   return this;
 266 }
 267
 268 inline void vjustify_output_line::vary(vunits amount)
 269 {
 270   current += amount;
 271 }
 272
 273 transparent_output_line::transparent_output_line()
 274 {
 275 }
 276
 277 transparent_output_line *transparent_output_line::as_transparent_output_line()
 278 {
 279   return this;
 280 }
 281
 282 void transparent_output_line::append_char(unsigned char c)
 283 {
 284   assert(c != 0);
 285   buf += c;
 286 }
 287
 288 void transparent_output_line::output(output_file *out, vunits)
 289 {
 290   int len = buf.length();
 291   for (int i = 0; i < len; i++)
 292     out->transparent_char(buf[i]);
 293 }
 294
 295 copy_file_output_line::copy_file_output_line(vunits d, const char *f, hunits h)
 296 : position_output_line(d), hpos(h), filename(f)
 297 {
 298 }
 299
 300 void copy_file_output_line::output(output_file *out, vunits pos)
 301 {
 302   out->copy_file(hpos, pos, filename.contents());
 303 }
 304
 305 column::column()
 306 : bottom(V0), col(0), tail(&col), out(0)
 307 {
 308 }
 309
 310 column::~column()
 311 {
 312   assert(out != 0);
 313   error("automatically outputting column before exiting");
 314   output();
 315   delete the_output;
 316 }
 317
 318 void column::start()
 319 {
 320   assert(out == 0);
 321   if (!the_output)
 322     init_output();
 323   assert(the_output != 0);
 324   out = the_output;
 325   the_output = this;
 326 }
 327
 328 void column::begin_page(int pageno, vunits page_length)
 329 {
 330   assert(out != 0);
 331   if (col) {
 332     error("automatically outputting column before beginning next page");
 333     output();
 334     the_output->begin_page(pageno, page_length);
 335   }
 336   else
 337     out->begin_page(pageno, page_length);
 338
 339 }
 340
 341 void column::flush()
 342 {
 343   assert(out != 0);
 344   out->flush();
 345 }
 346
 347 int column::is_printing()
 348 {
 349   assert(out != 0);
 350   return out->is_printing();
 351 }
 352
 353 vunits column::get_bottom()
 354 {
 355   return bottom;
 356 }
 357
 358 void column::add_output_line(output_line *ln)
 359 {
 360   *tail = ln;
 361   bottom += ln->distance();
 362   bottom += ln->height();
 363   ln->next = 0;
 364   tail = &(*tail)->next;
 365 }
 366
 367 void column::print_line(hunits page_offset, vunits pos, node *nd,
 368                         vunits before, vunits after)
 369 {
 370   assert(out != 0);
 371   add_output_line(new node_output_line(pos - bottom, nd, page_offset, before, after));
 372 }
 373
 374 void column::vjustify(vunits pos, symbol typ)
 375 {
 376   assert(out != 0);
 377   add_output_line(new vjustify_output_line(pos - bottom, typ));
 378 }
 379
 380 void column::transparent_char(unsigned char c)
 381 {
 382   assert(out != 0);
 383   transparent_output_line *tl = 0;
 384   if (*tail)
 385     tl = (*tail)->as_transparent_output_line();
 386   if (!tl) {
 387     tl = new transparent_output_line;
 388     add_output_line(tl);
 389   }
 390   tl->append_char(c);
 391 }
 392
 393 void column::copy_file(hunits page_offset, vunits pos, const char *filename)
 394 {
 395   assert(out != 0);
 396   add_output_line(new copy_file_output_line(pos - bottom, filename, page_offset));
 397 }
 398
 399 void column::trim()
 400 {
 401   output_line **spp = 0;
 402   for (output_line **pp = &col; *pp; pp = &(*pp)->next)
 403     if ((*pp)->as_vjustify_output_line() == 0)
 404       spp = 0;
 405     else if (!spp)
 406       spp = pp;
 407   if (spp) {
 408     output_line *ln = *spp;
 409     *spp = 0;
 410     tail = spp;
 411     while (ln) {
 412       output_line *tem = ln->next;
 413       bottom -= ln->distance();
 414       bottom -= ln->height();
 415       delete ln;
 416       ln = tem;
 417     }
 418   }
 419 }
 420
 421 void column::reset()
 422 {
 423   bottom = V0;
 424   for (output_line *ln = col; ln; ln = ln->next) {
 425     bottom += ln->distance();
 426     ln->reset();
 427     bottom += ln->height();
 428   }
 429 }
 430
 431 void column::check_bottom()
 432 {
 433   vunits b;
 434   for (output_line *ln = col; ln; ln = ln->next) {
 435     b += ln->distance();
 436     b += ln->height();
 437   }
 438   assert(b == bottom);
 439 }
 440
 441 void column::output()
 442 {
 443   assert(out != 0);
 444   vunits vpos(V0);
 445   output_line *ln = col;
 446   while (ln) {
 447     vpos += ln->distance();
 448     ln->output(out, vpos);
 449     vpos += ln->height();
 450     output_line *tem = ln->next;
 451     delete ln;
 452     ln = tem;
 453   }
 454   tail = &col;
 455   bottom = V0;
 456   col = 0;
 457   the_output = out;
 458   out = 0;
 459 }
 460
 461 vunits column::get_last_extra_space()
 462 {
 463   if (!col)
 464     return V0;
 465   for (output_line *p = col; p->next; p = p->next)
 466     ;
 467   return p->extra_space();
 468 }
 469
 470 class justification_spec
 471 {
 472   vunits height;
 473   symbol *type;
 474   vunits *amount;
 475   int n;
 476   int maxn;
 477
 478 public:
 479   justification_spec(vunits);
 480   ~justification_spec();
 481   void append(symbol t, vunits v);
 482   void justify(output_line *, vunits *bottomp) const;
 483 };
 484
 485 justification_spec::justification_spec(vunits h)
 486 : height(h), n(0), maxn(10)
 487 {
 488   type = new symbol[maxn];
 489   amount = new vunits[maxn];
 490 }
 491
 492 justification_spec::~justification_spec()
 493 {
 494   a_delete type;
 495   a_delete amount;
 496 }
 497
 498 void justification_spec::append(symbol t, vunits v)
 499 {
 500   if (v <= V0) {
 501     if (v < V0)
 502       warning(WARN_RANGE,
 503               "maximum space for vertical justification must not be negative");
 504     else
 505       warning(WARN_RANGE,
 506               "maximum space for vertical justification must not be zero");
 507     return;
 508   }
 509   if (n >= maxn) {
 510     maxn *= 2;
 511     symbol *old_type = type;
 512     type = new symbol[maxn];
 513     int i;
 514     for (i = 0; i < n; i++)
 515       type[i] = old_type[i];
 516     a_delete old_type;
 517     vunits *old_amount = amount;
 518     amount = new vunits[maxn];
 519     for (i = 0; i < n; i++)
 520       amount[i] = old_amount[i];
 521     a_delete old_amount;
 522   }
 523   assert(n < maxn);
 524   type[n] = t;
 525   amount[n] = v;
 526   n++;
 527 }
 528
 529 void justification_spec::justify(output_line *col, vunits *bottomp) const
 530 {
 531   if (*bottomp >= height)
 532     return;
 533   vunits total;
 534   output_line *p;
 535   for (p = col; p; p = p->next) {
 536     vjustify_output_line *sp = p->as_vjustify_output_line();
 537     if (sp) {
 538       symbol t = sp->type();
 539       for (int i = 0; i < n; i++) {
 540         if (t == type[i])
 541           total += amount[i];
 542       }
 543     }
 544   }
 545   vunits gap = height - *bottomp;
 546   for (p = col; p; p = p->next) {
 547     vjustify_output_line *sp = p->as_vjustify_output_line();
 548     if (sp) {
 549       symbol t = sp->type();
 550       for (int i = 0; i < n; i++) {
 551         if (t == type[i]) {
 552           if (total <= gap) {
 553             sp->vary(amount[i]);
 554             gap -= amount[i];
 555           }
 556           else {
 557             // gap < total
 558             vunits v = scale(amount[i], gap, total);
 559             sp->vary(v);
 560             gap -= v;
 561           }
 562           total -= amount[i];
 563         }
 564       }
 565     }
 566   }
 567   assert(total == V0);
 568   *bottomp = height - gap;
 569 }
 570
 571 void column::justify(const justification_spec &js)
 572 {
 573   check_bottom();
 574   js.justify(col, &bottom);
 575   check_bottom();
 576 }
 577
 578 void column_justify()
 579 {
 580   vunits height;
 581   if (!the_column->is_active())
 582     error("can't justify column - column not active");
 583   else if (get_vunits(&height, 'v')) {
 584     justification_spec js(height);
 585     symbol nm = get_long_name(1);
 586     if (!nm.is_null()) {
 587       vunits v;
 588       if (get_vunits(&v, 'v')) {
 589         js.append(nm, v);
 590         int err = 0;
 591         while (has_arg()) {
 592           nm = get_long_name(1);
 593           if (nm.is_null()) {
 594             err = 1;
 595             break;
 596           }
 597           if (!get_vunits(&v, 'v')) {
 598             err = 1;
 599             break;
 600           }
 601           js.append(nm, v);
 602         }
 603         if (!err)
 604           the_column->justify(js);
 605       }
 606     }
 607   }
 608   skip_line();
 609 }
 610
 611 void column_start()
 612 {
 613   if (the_column->is_active())
 614     error("can't start column - column already active");
 615   else
 616     the_column->start();
 617   skip_line();
 618 }
 619
 620 void column_output()
 621 {
 622   if (!the_column->is_active())
 623     error("can't output column - column not active");
 624   else
 625     the_column->output();
 626   skip_line();
 627 }
 628
 629 void column_trim()
 630 {
 631   if (!the_column->is_active())
 632     error("can't trim column - column not active");
 633   else
 634     the_column->trim();
 635   skip_line();
 636 }
 637
 638 void column_reset()
 639 {
 640   if (!the_column->is_active())
 641     error("can't reset column - column not active");
 642   else
 643     the_column->reset();
 644   skip_line();
 645 }
 646
 647 class column_bottom_reg
 648 : public reg
 649 {
 650 public:
 651   const char *get_string();
 652 };
 653
 654 const char *column_bottom_reg::get_string()
 655 {
 656   return i_to_a(the_column->get_bottom().to_units());
 657 }
 658
 659 class column_extra_space_reg
 660 : public reg
 661 {
 662 public:
 663   const char *get_string();
 664 };
 665
 666 const char *column_extra_space_reg::get_string()
 667 {
 668   return i_to_a(the_column->get_last_extra_space().to_units());
 669 }
 670
 671 class column_active_reg
 672 : public reg
 673 {
 674 public:
 675   const char *get_string();
 676 };
 677
 678 const char *column_active_reg::get_string()
 679 {
 680   return the_column->is_active() ? "1" : "0";
 681 }
 682
 683 static int no_vjustify_mode = 0;
 684
 685 class vjustify_node
 686 : public node
 687 {
 688   symbol typ;
 689
 690 public:
 691   vjustify_node(symbol);
 692   int reread(int *);
 693   const char *type();
 694   int same(node *);
 695   node *copy();
 696 };
 697
 698 vjustify_node::vjustify_node(symbol t)
 699 : typ(t)
 700 {
 701 }
 702
 703 node *vjustify_node::copy()
 704 {
 705   return new vjustify_node(typ, div_nest_level);
 706 }
 707
 708 const char *vjustify_node::type()
 709 {
 710   return "vjustify_node";
 711 }
 712
 713 int vjustify_node::same(node *nd)
 714 {
 715   return typ == ((vjustify_node *)nd)->typ;
 716 }
 717
 718 int vjustify_node::reread(int *bolp)
 719 {
 720   curdiv->vjustify(typ);
 721   *bolp = 1;
 722   return 1;
 723 }
 724
 725 void macro_diversion::vjustify(symbol type)
 726 {
 727   if (!no_vjustify_mode)
 728     mac->append(new vjustify_node(type));
 729 }
 730
 731 void top_level_diversion::vjustify(symbol type)
 732 {
 733   if (no_space_mode || no_vjustify_mode)
 734     return;
 735   assert(first_page_begun);     // I'm not sure about this.
 736   the_output->vjustify(vertical_position, type);
 737 }
 738
 739 void no_vjustify()
 740 {
 741   skip_line();
 742   no_vjustify_mode = 1;
 743 }
 744
 745 void restore_vjustify()
 746 {
 747   skip_line();
 748   no_vjustify_mode = 0;
 749 }
 750
 751 void init_column_requests()
 752 {
 753   the_column = new column;
 754   init_request("cols", column_start);
 755   init_request("colo", column_output);
 756   init_request("colj", column_justify);
 757   init_request("colr", column_reset);
 758   init_request("colt", column_trim);
 759   init_request("nvj", no_vjustify);
 760   init_request("rvj", restore_vjustify);
 761   number_reg_dictionary.define(".colb", new column_bottom_reg);
 762   number_reg_dictionary.define(".colx", new column_extra_space_reg);
 763   number_reg_dictionary.define(".cola", new column_active_reg);
 764   number_reg_dictionary.define(".nvj",
 765                                new constant_int_reg(&no_vjustify_mode));
 766 }
 767
 768 #endif /* COLUMN */
 769 // s-it2-mode