tbl/main.cc

   1 // -*- C++ -*-
   2 /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3      Written by James Clark (jjc@jclark.com)
   4
   5 This file is part of groff.
   6
   7 groff 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 groff 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
  20
  21 #include "table.h"
  22
  23 #define MAX_POINT_SIZE 99
  24 #define MAX_VERTICAL_SPACING 72
  25
  26 static int compatible_flag = 0;
  27
  28 class table_input {
  29   FILE *fp;
  30   enum { START, MIDDLE, REREAD_T, REREAD_TE, REREAD_E, END, ERROR } state;
  31   string unget_stack;
  32 public:
  33   table_input(FILE *);
  34   int get();
  35   int ended() { return unget_stack.empty() && state == END; }
  36   void unget(char);
  37 };
  38
  39 table_input::table_input(FILE *p)
  40 : fp(p), state(START)
  41 {
  42 }
  43
  44 void table_input::unget(char c)
  45 {
  46   assert(c != '\0');
  47   unget_stack += c;
  48   if (c == '\n')
  49     current_lineno--;
  50 }
  51
  52 int table_input::get()
  53 {
  54   int len = unget_stack.length();
  55   if (len != 0) {
  56     unsigned char c = unget_stack[len - 1];
  57     unget_stack.set_length(len - 1);
  58     if (c == '\n')
  59       current_lineno++;
  60     return c;
  61   }
  62   int c;
  63   for (;;) {
  64     switch (state) {
  65     case START:
  66       if ((c = getc(fp)) == '.') {
  67         if ((c = getc(fp)) == 'T') {
  68           if ((c = getc(fp)) == 'E') {
  69             if (compatible_flag) {
  70               state = END;
  71               return EOF;
  72             }
  73             else {
  74               c = getc(fp);
  75               if (c != EOF)
  76                 ungetc(c, fp);
  77               if (c == EOF || c == ' ' || c == '\n') {
  78                 state = END;
  79                 return EOF;
  80               }
  81               state = REREAD_TE;
  82               return '.';
  83             }
  84           }
  85           else {
  86             if (c != EOF)
  87               ungetc(c, fp);
  88             state = REREAD_T;
  89             return '.';
  90           }
  91         }
  92         else {
  93           if (c != EOF)
  94             ungetc(c, fp);
  95           state = MIDDLE;
  96           return '.';
  97         }
  98       }
  99       else if (c == EOF) {
 100         state = ERROR;
 101         return EOF;
 102       }
 103       else {
 104         if (c == '\n')
 105           current_lineno++;
 106         else {
 107           state = MIDDLE;
 108           if (c == '\0') {
 109             error("illegal input character code 0");
 110             break;
 111           }
 112         }
 113         return c;
 114       }
 115       break;
 116     case MIDDLE:
 117       // handle line continuation
 118       if ((c = getc(fp)) == '\\') {
 119         c = getc(fp);
 120         if (c == '\n')
 121           c = getc(fp);         // perhaps state ought to be START now
 122         else {
 123           if (c != EOF)
 124             ungetc(c, fp);
 125           c = '\\';
 126         }
 127       }
 128       if (c == EOF) {
 129         state = ERROR;
 130         return EOF;
 131       }
 132       else {
 133         if (c == '\n') {
 134           state = START;
 135           current_lineno++;
 136         }
 137         else if (c == '\0') {
 138           error("illegal input character code 0");
 139           break;
 140         }
 141         return c;
 142       }
 143     case REREAD_T:
 144       state = MIDDLE;
 145       return 'T';
 146     case REREAD_TE:
 147       state = REREAD_E;
 148       return 'T';
 149     case REREAD_E:
 150       state = MIDDLE;
 151       return 'E';
 152     case END:
 153     case ERROR:
 154       return EOF;
 155     }
 156   }
 157 }
 158
 159 void process_input_file(FILE *);
 160 void process_table(table_input &in);
 161
 162 void process_input_file(FILE *fp)
 163 {
 164   enum { START, MIDDLE, HAD_DOT, HAD_T, HAD_TS, HAD_l, HAD_lf } state;
 165   state = START;
 166   int c;
 167   while ((c = getc(fp)) != EOF)
 168     switch (state) {
 169     case START:
 170       if (c == '.')
 171         state = HAD_DOT;
 172       else {
 173         if (c == '\n')
 174           current_lineno++;
 175         else
 176           state = MIDDLE;
 177         putchar(c);
 178       }
 179       break;
 180     case MIDDLE:
 181       if (c == '\n') {
 182         current_lineno++;
 183         state = START;
 184       }
 185       putchar(c);
 186       break;
 187     case HAD_DOT:
 188       if (c == 'T')
 189         state = HAD_T;
 190       else if (c == 'l')
 191         state = HAD_l;
 192       else {
 193         putchar('.');
 194         putchar(c);
 195         if (c == '\n') {
 196           current_lineno++;
 197           state = START;
 198         }
 199         else
 200           state = MIDDLE;
 201       }
 202       break;
 203     case HAD_T:
 204       if (c == 'S')
 205         state = HAD_TS;
 206       else {
 207         putchar('.');
 208         putchar('T');
 209         putchar(c);
 210         if (c == '\n') {
 211           current_lineno++;
 212           state = START;
 213         }
 214         else
 215           state = MIDDLE;
 216       }
 217       break;
 218     case HAD_TS:
 219       if (c == ' ' || c == '\n' || compatible_flag) {
 220         putchar('.');
 221         putchar('T');
 222         putchar('S');
 223         while (c != '\n') {
 224           if (c == EOF) {
 225             error("end of file at beginning of table");
 226             return;
 227           }
 228           putchar(c);
 229           c = getc(fp);
 230         }
 231         putchar('\n');
 232         current_lineno++;
 233         {
 234           table_input input(fp);
 235           process_table(input);
 236           set_troff_location(current_filename, current_lineno);
 237           if (input.ended()) {
 238             fputs(".TE", stdout);
 239             while ((c = getc(fp)) != '\n') {
 240               if (c == EOF) {
 241                 putchar('\n');
 242                 return;
 243               }
 244               putchar(c);
 245             }
 246             putchar('\n');
 247             current_lineno++;
 248           }
 249         }
 250         state = START;
 251       }
 252       else {
 253         fputs(".TS", stdout);
 254         putchar(c);
 255         state = MIDDLE;
 256       }
 257       break;
 258     case HAD_l:
 259       if (c == 'f')
 260         state = HAD_lf;
 261       else {
 262         putchar('.');
 263         putchar('l');
 264         putchar(c);
 265         if (c == '\n') {
 266           current_lineno++;
 267           state = START;
 268         }
 269         else
 270           state = MIDDLE;
 271       }
 272       break;
 273     case HAD_lf:
 274       if (c == ' ' || c == '\n' || compatible_flag) {
 275         string line;
 276         while (c != EOF) {
 277           line += c;
 278           if (c == '\n') {
 279             current_lineno++;
 280             break;
 281           }
 282           c = getc(fp);
 283         }
 284         line += '\0';
 285         interpret_lf_args(line.contents());
 286         printf(".lf%s", line.contents());
 287         state = START;
 288       }
 289       else {
 290         fputs(".lf", stdout);
 291         putchar(c);
 292         state = MIDDLE;
 293       }
 294       break;
 295     default:
 296       assert(0);
 297     }
 298   switch(state) {
 299   case START:
 300     break;
 301   case MIDDLE:
 302     putchar('\n');
 303     break;
 304   case HAD_DOT:
 305     fputs(".\n", stdout);
 306     break;
 307   case HAD_l:
 308     fputs(".l\n", stdout);
 309     break;
 310   case HAD_T:
 311     fputs(".T\n", stdout);
 312     break;
 313   case HAD_lf:
 314     fputs(".lf\n", stdout);
 315     break;
 316   case HAD_TS:
 317     fputs(".TS\n", stdout);
 318     break;
 319   }
 320   if (fp != stdin)
 321     fclose(fp);
 322 }
 323
 324 struct options {
 325   unsigned flags;
 326   int linesize;
 327   char delim[2];
 328   char tab_char;
 329   char decimal_point_char;
 330
 331   options();
 332 };
 333
 334 options::options()
 335 : flags(0), tab_char('\t'), decimal_point_char('.'), linesize(0)
 336 {
 337   delim[0] = delim[1] = '\0';
 338 }
 339
 340 // Return non-zero if p and q are the same ignoring case.
 341
 342 int strieq(const char *p, const char *q)
 343 {
 344   for (; cmlower(*p) == cmlower(*q); p++, q++)
 345     if (*p == '\0')
 346       return 1;
 347   return 0;
 348 }
 349
 350 // return 0 if we should give up in this table
 351
 352 options *process_options(table_input &in)
 353 {
 354   options *opt = new options;
 355   string line;
 356   int level = 0;
 357   for (;;) {
 358     int c = in.get();
 359     if (c == EOF) {
 360       int i = line.length();
 361       while (--i >= 0)
 362         in.unget(line[i]);
 363       return opt;
 364     }
 365     if (c == '\n') {
 366       in.unget(c);
 367       int i = line.length();
 368       while (--i >= 0)
 369         in.unget(line[i]);
 370       return opt;
 371     }
 372     else if (c == '(')
 373       level++;
 374     else if (c == ')')
 375       level--;
 376     else if (c == ';' && level == 0) {
 377       line += '\0';
 378       break;
 379     }
 380     line += c;
 381   }
 382   if (line.empty())
 383     return opt;
 384   char *p = &line[0];
 385   for (;;) {
 386     while (csspace(*p) || *p == ',')
 387       p++;
 388     if (*p == '\0')
 389       break;
 390     char *q = p;
 391     while (*q != ' ' && *q != '\0' && *q != '\t' && *q != ',' && *q != '(')
 392       q++;
 393     char *arg = 0;
 394     if (*q != '(' && *q != '\0')
 395       *q++ = '\0';
 396     while (csspace(*q))
 397       q++;
 398     if (*q == '(') {
 399       *q++ = '\0';
 400       arg = q;
 401       while (*q != ')' && *q != '\0')
 402         q++;
 403       if (*q == '\0')
 404         error("missing `)'");
 405       else
 406         *q++ = '\0';
 407     }
 408     if (*p == '\0') {
 409       if (arg)
 410         error("argument without option");
 411     }
 412     else if (strieq(p, "tab")) {
 413       if (!arg)
 414         error("`tab' option requires argument in parentheses");
 415       else {
 416         if (arg[0] == '\0' || arg[1] != '\0')
 417           error("argument to `tab' option must be a single character");
 418         else
 419           opt->tab_char = arg[0];
 420       }
 421     }
 422     else if (strieq(p, "linesize")) {
 423       if (!arg)
 424         error("`linesize' option requires argument in parentheses");
 425       else {
 426         if (sscanf(arg, "%d", &opt->linesize) != 1)
 427           error("bad linesize `%s'", arg);
 428         else if (opt->linesize <= 0) {
 429           error("linesize must be positive");
 430           opt->linesize = 0;
 431         }
 432       }
 433     }
 434     else if (strieq(p, "delim")) {
 435       if (!arg)
 436         error("`delim' option requires argument in parentheses");
 437       else if (arg[0] == '\0' || arg[1] == '\0' || arg[2] != '\0')
 438         error("argument to `delim' option must be two characters");
 439       else {
 440         opt->delim[0] = arg[0];
 441         opt->delim[1] = arg[1];
 442       }
 443     }
 444     else if (strieq(p, "center") || strieq(p, "centre")) {
 445       if (arg)
 446         error("`center' option does not take a argument");
 447       opt->flags |= table::CENTER;
 448     }
 449     else if (strieq(p, "expand")) {
 450       if (arg)
 451         error("`expand' option does not take a argument");
 452       opt->flags |= table::EXPAND;
 453     }
 454     else if (strieq(p, "box") || strieq(p, "frame")) {
 455       if (arg)
 456         error("`box' option does not take a argument");
 457       opt->flags |= table::BOX;
 458     }
 459     else if (strieq(p, "doublebox") || strieq(p, "doubleframe")) {
 460       if (arg)
 461         error("`doublebox' option does not take a argument");
 462       opt->flags |= table::DOUBLEBOX;
 463     }
 464     else if (strieq(p, "allbox")) {
 465       if (arg)
 466         error("`allbox' option does not take a argument");
 467       opt->flags |= table::ALLBOX;
 468     }
 469     else if (strieq(p, "nokeep")) {
 470       if (arg)
 471         error("`nokeep' option does not take a argument");
 472       opt->flags |= table::NOKEEP;
 473     }
 474     else if (strieq(p, "decimalpoint")) {
 475       if (!arg)
 476         error("`decimalpoint' option requires argument in parentheses");
 477       else {
 478         if (arg[0] == '\0' || arg[1] != '\0')
 479           error("argument to `decimalpoint' option must be a single character");
 480         else
 481           opt->decimal_point_char = arg[0];
 482       }
 483     }
 484     else {
 485       error("unrecognised global option `%1'", p);
 486       // delete opt;
 487       // return 0;
 488     }
 489     p = q;
 490   }
 491   return opt;
 492 }
 493
 494 entry_modifier::entry_modifier()
 495 : vertical_alignment(CENTER), zero_width(0), stagger(0)
 496 {
 497   vertical_spacing.inc = vertical_spacing.val = 0;
 498   point_size.inc = point_size.val = 0;
 499 }
 500
 501 entry_modifier::~entry_modifier()
 502 {
 503 }
 504
 505 entry_format::entry_format() : type(FORMAT_LEFT)
 506 {
 507 }
 508
 509 entry_format::entry_format(format_type t) : type(t)
 510 {
 511 }
 512
 513 void entry_format::debug_print() const
 514 {
 515   switch (type) {
 516   case FORMAT_LEFT:
 517     putc('l', stderr);
 518     break;
 519   case FORMAT_CENTER:
 520     putc('c', stderr);
 521     break;
 522   case FORMAT_RIGHT:
 523     putc('r', stderr);
 524     break;
 525   case FORMAT_NUMERIC:
 526     putc('n', stderr);
 527     break;
 528   case FORMAT_ALPHABETIC:
 529     putc('a', stderr);
 530     break;
 531   case FORMAT_SPAN:
 532     putc('s', stderr);
 533     break;
 534   case FORMAT_VSPAN:
 535     putc('^', stderr);
 536     break;
 537   case FORMAT_HLINE:
 538     putc('_', stderr);
 539     break;
 540   case FORMAT_DOUBLE_HLINE:
 541     putc('=', stderr);
 542     break;
 543   default:
 544     assert(0);
 545     break;
 546   }
 547   if (point_size.val != 0) {
 548     putc('p', stderr);
 549     if (point_size.inc > 0)
 550       putc('+', stderr);
 551     else if (point_size.inc < 0)
 552       putc('-', stderr);
 553     fprintf(stderr, "%d ", point_size.val);
 554   }
 555   if (vertical_spacing.val != 0) {
 556     putc('v', stderr);
 557     if (vertical_spacing.inc > 0)
 558       putc('+', stderr);
 559     else if (vertical_spacing.inc < 0)
 560       putc('-', stderr);
 561     fprintf(stderr, "%d ", vertical_spacing.val);
 562   }
 563   if (!font.empty()) {
 564     putc('f', stderr);
 565     put_string(font, stderr);
 566     putc(' ', stderr);
 567   }
 568   switch (vertical_alignment) {
 569   case entry_modifier::CENTER:
 570     break;
 571   case entry_modifier::TOP:
 572     putc('t', stderr);
 573     break;
 574   case entry_modifier::BOTTOM:
 575     putc('d', stderr);
 576     break;
 577   }
 578   if (zero_width)
 579     putc('z', stderr);
 580   if (stagger)
 581     putc('u', stderr);
 582 }
 583
 584 struct format {
 585   int nrows;
 586   int ncolumns;
 587   int *separation;
 588   string *width;
 589   char *equal;
 590   entry_format **entry;
 591   char **vline;
 592
 593   format(int nr, int nc);
 594   ~format();
 595   void add_rows(int n);
 596 };
 597
 598 format::format(int nr, int nc) : nrows(nr), ncolumns(nc)
 599 {
 600   int i;
 601   separation = ncolumns > 1 ? new int[ncolumns - 1] : 0;
 602   for (i = 0; i < ncolumns-1; i++)
 603     separation[i] = -1;
 604   width = new string[ncolumns];
 605   equal = new char[ncolumns];
 606   for (i = 0; i < ncolumns; i++)
 607     equal[i] = 0;
 608   entry = new entry_format *[nrows];
 609   for (i = 0; i < nrows; i++)
 610     entry[i] = new entry_format[ncolumns];
 611   vline = new char*[nrows];
 612   for (i = 0; i < nrows; i++) {
 613     vline[i] = new char[ncolumns+1];
 614     for (int j = 0; j < ncolumns+1; j++)
 615       vline[i][j] = 0;
 616   }
 617 }
 618
 619 void format::add_rows(int n)
 620 {
 621   int i;
 622   char **old_vline = vline;
 623   vline = new char*[nrows + n];
 624   for (i = 0; i < nrows; i++)
 625     vline[i] = old_vline[i];
 626   a_delete old_vline;
 627   for (i = 0; i < n; i++) {
 628     vline[nrows + i] = new char[ncolumns + 1];
 629     for (int j = 0; j < ncolumns + 1; j++)
 630       vline[nrows + i][j] = 0;
 631   }
 632   entry_format **old_entry = entry;
 633   entry = new entry_format *[nrows + n];
 634   for (i = 0; i < nrows; i++)
 635     entry[i] = old_entry[i];
 636   a_delete old_entry;
 637   for (i = 0; i < n; i++)
 638     entry[nrows + i] = new entry_format[ncolumns];
 639   nrows += n;
 640 }
 641
 642 format::~format()
 643 {
 644   a_delete separation;
 645   ad_delete(ncolumns) width;
 646   a_delete equal;
 647   for (int i = 0; i < nrows; i++) {
 648     a_delete vline[i];
 649     ad_delete(ncolumns) entry[i];
 650   }
 651   a_delete vline;
 652   a_delete entry;
 653 }
 654
 655 struct input_entry_format : public entry_format {
 656   input_entry_format *next;
 657   string width;
 658   int separation;
 659   int vline;
 660   int pre_vline;
 661   int last_column;
 662   int equal;
 663   input_entry_format(format_type, input_entry_format * = 0);
 664   ~input_entry_format();
 665   void debug_print();
 666 };
 667
 668 input_entry_format::input_entry_format(format_type t, input_entry_format *p)
 669 : entry_format(t), next(p)
 670 {
 671   separation = -1;
 672   last_column = 0;
 673   vline = 0;
 674   pre_vline = 0;
 675   equal = 0;
 676 }
 677
 678 input_entry_format::~input_entry_format()
 679 {
 680 }
 681
 682 void free_input_entry_format_list(input_entry_format *list)
 683 {
 684   while (list) {
 685     input_entry_format *tem = list;
 686     list = list->next;
 687     delete tem;
 688   }
 689 }
 690
 691 void input_entry_format::debug_print()
 692 {
 693   int i;
 694   for (i = 0; i < pre_vline; i++)
 695     putc('|', stderr);
 696   entry_format::debug_print();
 697   if (!width.empty()) {
 698     putc('w', stderr);
 699     putc('(', stderr);
 700     put_string(width, stderr);
 701     putc(')', stderr);
 702   }
 703   if (equal)
 704     putc('e', stderr);
 705   if (separation >= 0)
 706     fprintf(stderr, "%d", separation);
 707   for (i = 0; i < vline; i++)
 708     putc('|', stderr);
 709   if (last_column)
 710     putc(',', stderr);
 711 }
 712
 713 // Return zero if we should give up on this table.
 714 // If this is a continuation format line, current_format will be the current
 715 // format line.
 716
 717 format *process_format(table_input &in, options *opt,
 718                        format *current_format = 0)
 719 {
 720   input_entry_format *list = 0;
 721   int c = in.get();
 722   for (;;) {
 723     int pre_vline = 0;
 724     int got_format = 0;
 725     int got_period = 0;
 726     format_type t;
 727     for (;;) {
 728       if (c == EOF) {
 729         error("end of input while processing format");
 730         free_input_entry_format_list(list);
 731         return 0;
 732       }
 733       switch (c) {
 734       case 'n':
 735       case 'N':
 736         t = FORMAT_NUMERIC;
 737         got_format = 1;
 738         break;
 739       case 'a':
 740       case 'A':
 741         got_format = 1;
 742         t = FORMAT_ALPHABETIC;
 743         break;
 744       case 'c':
 745       case 'C':
 746         got_format = 1;
 747         t = FORMAT_CENTER;
 748         break;
 749       case 'l':
 750       case 'L':
 751         got_format = 1;
 752         t = FORMAT_LEFT;
 753         break;
 754       case 'r':
 755       case 'R':
 756         got_format = 1;
 757         t = FORMAT_RIGHT;
 758         break;
 759       case 's':
 760       case 'S':
 761         got_format = 1;
 762         t = FORMAT_SPAN;
 763         break;
 764       case '^':
 765         got_format = 1;
 766         t = FORMAT_VSPAN;
 767         break;
 768       case '_':
 769       case '-':                 // tbl also accepts this
 770         got_format = 1;
 771         t = FORMAT_HLINE;
 772         break;
 773       case '=':
 774         got_format = 1;
 775         t = FORMAT_DOUBLE_HLINE;
 776         break;
 777       case '.':
 778         got_period = 1;
 779         break;
 780       case '|':
 781         pre_vline++;
 782         break;
 783       case ' ':
 784       case '\t':
 785       case '\n':
 786         break;
 787       default:
 788         if (c == opt->tab_char)
 789           break;
 790         error("unrecognised format `%1'", char(c));
 791         free_input_entry_format_list(list);
 792         return 0;
 793       }
 794       if (got_period)
 795         break;
 796       c = in.get();
 797       if (got_format)
 798         break;
 799     }
 800     if (got_period)
 801       break;
 802     list = new input_entry_format(t, list);
 803     if (pre_vline)
 804       list->pre_vline = pre_vline;
 805     int success = 1;
 806     do {
 807       switch (c) {
 808       case 't':
 809       case 'T':
 810         c = in.get();
 811         list->vertical_alignment = entry_modifier::TOP;
 812         break;
 813       case 'd':
 814       case 'D':
 815         c = in.get();
 816         list->vertical_alignment = entry_modifier::BOTTOM;
 817         break;
 818       case 'u':
 819       case 'U':
 820         c = in.get();
 821         list->stagger = 1;
 822         break;
 823       case 'z':
 824       case 'Z':
 825         c = in.get();
 826         list->zero_width = 1;
 827         break;
 828       case '0':
 829       case '1':
 830       case '2':
 831       case '3':
 832       case '4':
 833       case '5':
 834       case '6':
 835       case '7':
 836       case '8':
 837       case '9':
 838         {
 839           int w = 0;
 840           do {
 841             w = w*10 + (c - '0');
 842             c = in.get();
 843           } while (c != EOF && csdigit(c));
 844           list->separation = w;
 845         }
 846         break;
 847       case 'f':
 848       case 'F':
 849         do {
 850           c = in.get();
 851         } while (c == ' ' || c == '\t');
 852         if (c == EOF) {
 853           error("missing font name");
 854           break;
 855         }
 856         if (c == '(') {
 857           for (;;) {
 858             c = in.get();
 859             if (c == EOF || c == ' ' || c == '\t') {
 860               error("missing `)'");
 861               break;
 862             }
 863             if (c == ')') {
 864               c = in.get();
 865               break;
 866             }
 867             list->font += char(c);
 868           }
 869         }
 870         else {
 871           list->font = c;
 872           char cc = c;
 873           c = in.get();
 874           if (!csdigit(cc)
 875               && c != EOF && c != ' ' && c != '\t' && c != '.' && c != '\n') {
 876             list->font += char(c);
 877             c = in.get();
 878           }
 879         }
 880         break;
 881       case 'v':
 882       case 'V':
 883         c = in.get();
 884         list->vertical_spacing.val = 0;
 885         list->vertical_spacing.inc = 0;
 886         if (c == '+' || c == '-') {
 887           list->vertical_spacing.inc = (c == '+' ? 1 : -1);
 888           c = in.get();
 889         }
 890         if (c == EOF || !csdigit(c)) {
 891           error("`v' modifier must be followed by number");
 892           list->vertical_spacing.inc = 0;
 893         }
 894         else {
 895           do {
 896             list->vertical_spacing.val *= 10;
 897             list->vertical_spacing.val += c - '0';
 898             c = in.get();
 899           } while (c != EOF && csdigit(c));
 900         }
 901         if (list->vertical_spacing.val > MAX_VERTICAL_SPACING
 902             || list->vertical_spacing.val < -MAX_VERTICAL_SPACING) {
 903           error("unreasonable point size");
 904           list->vertical_spacing.val = 0;
 905           list->vertical_spacing.inc = 0;
 906         }
 907         break;
 908       case 'p':
 909       case 'P':
 910         c = in.get();
 911         list->point_size.val = 0;
 912         list->point_size.inc = 0;
 913         if (c == '+' || c == '-') {
 914           list->point_size.inc = (c == '+' ? 1 : -1);
 915           c = in.get();
 916         }
 917         if (c == EOF || !csdigit(c)) {
 918           error("`p' modifier must be followed by number");
 919           list->point_size.inc = 0;
 920         }
 921         else {
 922           do {
 923             list->point_size.val *= 10;
 924             list->point_size.val += c - '0';
 925             c = in.get();
 926           } while (c != EOF && csdigit(c));
 927         }
 928         if (list->point_size.val > MAX_POINT_SIZE
 929             || list->point_size.val < -MAX_POINT_SIZE) {
 930           error("unreasonable point size");
 931           list->point_size.val = 0;
 932           list->point_size.inc = 0;
 933         }
 934         break;
 935       case 'w':
 936       case 'W':
 937         c = in.get();
 938         while (c == ' ' || c == '\t')
 939           c = in.get();
 940         if (c == '(') {
 941           list->width = "";
 942           c = in.get();
 943           while (c != ')') {
 944             if (c == EOF || c == '\n') {
 945               error("missing `)'");
 946               free_input_entry_format_list(list);
 947               return 0;
 948             }
 949             list->width += c;
 950             c = in.get();
 951           }
 952           c = in.get();
 953         }
 954         else {
 955           if (c == '+' || c == '-') {
 956             list->width = char(c);
 957             c = in.get();
 958           }
 959           else
 960             list->width = "";
 961           if (c == EOF || !csdigit(c))
 962             error("bad argument for `w' modifier");
 963           else {
 964             do {
 965               list->width += char(c);
 966               c = in.get();
 967             } while (c != EOF && csdigit(c));
 968           }
 969         }
 970         break;
 971       case 'e':
 972       case 'E':
 973         c = in.get();
 974         list->equal++;
 975         break;
 976       case '|':
 977         c = in.get();
 978         list->vline++;
 979         break;
 980       case 'B':
 981       case 'b':
 982         c = in.get();
 983         list->font = "B";
 984         break;
 985       case 'I':
 986       case 'i':
 987         c = in.get();
 988         list->font = "I";
 989         break;
 990       case ' ':
 991       case '\t':
 992         c = in.get();
 993         break;
 994       default:
 995         if (c == opt->tab_char)
 996           c = in.get();
 997         else
 998           success = 0;
 999         break;
1000       }
1001     } while (success);
1002     if (list->vline > 2) {
1003       list->vline = 2;
1004       error("more than 2 vertical bars between key letters");
1005     }
1006     if (c == '\n' || c == ',') {
1007       c = in.get();
1008       list->last_column = 1;
1009     }
1010   }
1011   if (c == '.') {
1012     do {
1013       c = in.get();
1014     } while (c == ' ' || c == '\t');
1015     if (c != '\n') {
1016       error("`.' not last character on line");
1017       free_input_entry_format_list(list);
1018       return 0;
1019     }
1020   }
1021   if (!list) {
1022     error("no format");
1023     free_input_entry_format_list(list);
1024     return 0;
1025   }
1026   list->last_column = 1;
1027   // now reverse the list so that the first row is at the beginning
1028   input_entry_format *rev = 0;
1029   while (list != 0) {
1030     input_entry_format *tem = list->next;
1031     list->next = rev;
1032     rev = list;
1033     list = tem;
1034   }
1035   list = rev;
1036   input_entry_format *tem;
1037
1038 #if 0
1039   for (tem = list; tem; tem = tem->next)
1040     tem->debug_print();
1041   putc('\n', stderr);
1042 #endif
1043   // compute number of columns and rows
1044   int ncolumns = 0;
1045   int nrows = 0;
1046   int col = 0;
1047   for (tem = list; tem; tem = tem->next) {
1048     if (tem->last_column) {
1049       if (col >= ncolumns)
1050         ncolumns = col + 1;
1051       col = 0;
1052       nrows++;
1053     }
1054     else
1055       col++;
1056   }
1057   int row;
1058   format *f;
1059   if (current_format) {
1060     if (ncolumns > current_format->ncolumns) {
1061       error("cannot increase the number of columns in a continued format");
1062       free_input_entry_format_list(list);
1063       return 0;
1064     }
1065     f = current_format;
1066     row = f->nrows;
1067     f->add_rows(nrows);
1068   }
1069   else {
1070     f = new format(nrows, ncolumns);
1071     row = 0;
1072   }
1073   col = 0;
1074   for (tem = list; tem; tem = tem->next) {
1075     f->entry[row][col] = *tem;
1076     if (col < ncolumns-1) {
1077       // use the greatest separation
1078       if (tem->separation > f->separation[col]) {
1079         if (current_format)
1080           error("cannot change column separation in continued format");
1081         else
1082           f->separation[col] = tem->separation;
1083       }
1084     }
1085     else if (tem->separation >= 0)
1086       error("column separation specified for last column");
1087     if (tem->equal && !f->equal[col]) {
1088       if (current_format)
1089         error("cannot change which columns are equal in continued format");
1090       else
1091         f->equal[col] = 1;
1092     }
1093     if (!tem->width.empty()) {
1094       // use the last width
1095       if (!f->width[col].empty() && f->width[col] != tem->width)
1096         error("multiple widths for column %1", col+1);
1097       f->width[col] = tem->width;
1098     }
1099     if (tem->pre_vline) {
1100       assert(col == 0);
1101       f->vline[row][col] = tem->pre_vline;
1102     }
1103     f->vline[row][col+1] = tem->vline;
1104     if (tem->last_column) {
1105       row++;
1106       col = 0;
1107     }
1108     else
1109       col++;
1110   }
1111   free_input_entry_format_list(list);
1112   for (col = 0; col < ncolumns; col++) {
1113     entry_format *e = f->entry[f->nrows-1] + col;
1114     if (e->type != FORMAT_HLINE
1115         && e->type != FORMAT_DOUBLE_HLINE
1116         && e->type != FORMAT_SPAN)
1117       break;
1118   }
1119   if (col >= ncolumns) {
1120     error("last row of format is all lines");
1121     delete f;
1122     return 0;
1123   }
1124   return f;
1125 }
1126
1127 table *process_data(table_input &in, format *f, options *opt)
1128 {
1129   char tab_char = opt->tab_char;
1130   int ncolumns = f->ncolumns;
1131   int current_row = 0;
1132   int format_index = 0;
1133   int give_up = 0;
1134   enum { DATA_INPUT_LINE, TROFF_INPUT_LINE, SINGLE_HLINE, DOUBLE_HLINE } type;
1135   table *tbl = new table(ncolumns, opt->flags, opt->linesize,
1136                          opt->decimal_point_char);
1137   if (opt->delim[0] != '\0')
1138     tbl->set_delim(opt->delim[0], opt->delim[1]);
1139   for (;;) {
1140     // first determine what type of line this is
1141     int c = in.get();
1142     if (c == EOF)
1143       break;
1144     if (c == '.') {
1145       int d = in.get();
1146       if (d != EOF && csdigit(d)) {
1147         in.unget(d);
1148         type = DATA_INPUT_LINE;
1149       }
1150       else {
1151         in.unget(d);
1152         type = TROFF_INPUT_LINE;
1153       }
1154     }
1155     else if (c == '_' || c == '=') {
1156       int d = in.get();
1157       if (d == '\n') {
1158         if (c == '_')
1159           type = SINGLE_HLINE;
1160         else
1161           type = DOUBLE_HLINE;
1162       }
1163       else {
1164         in.unget(d);
1165         type = DATA_INPUT_LINE;
1166       }
1167     }
1168     else {
1169       type = DATA_INPUT_LINE;
1170     }
1171     switch (type) {
1172     case DATA_INPUT_LINE:
1173       {
1174         string input_entry;
1175         if (format_index >= f->nrows)
1176           format_index = f->nrows - 1;
1177         // A format row that is all lines doesn't use up a data line.
1178         while (format_index < f->nrows - 1) {
1179           int c;
1180           for (c = 0; c < ncolumns; c++) {
1181             entry_format *e = f->entry[format_index] + c;
1182             if (e->type != FORMAT_HLINE
1183                 && e->type != FORMAT_DOUBLE_HLINE
1184                 // Unfortunately tbl treats a span as needing data.
1185                 // && e->type != FORMAT_SPAN
1186                 )
1187               break;
1188           }
1189           if (c < ncolumns)
1190             break;
1191           for (c = 0; c < ncolumns; c++)
1192             tbl->add_entry(current_row, c, input_entry,
1193                            f->entry[format_index] + c, current_filename,
1194                            current_lineno);
1195           tbl->add_vlines(current_row, f->vline[format_index]);
1196           format_index++;
1197           current_row++;
1198         }
1199         entry_format *line_format = f->entry[format_index];
1200         int col = 0;
1201         int row_comment = 0;
1202         for (;;) {
1203           if (c == tab_char || c == '\n') {
1204             int ln = current_lineno;
1205             if (c == '\n')
1206               --ln;
1207             while (col < ncolumns
1208                    && line_format[col].type == FORMAT_SPAN) {
1209               tbl->add_entry(current_row, col, "", &line_format[col],
1210                              current_filename, ln);
1211               col++;
1212             }
1213             if (c == '\n' && input_entry.length() == 2
1214                 && input_entry[0] == 'T' && input_entry[1] == '{') {
1215               input_entry = "";
1216               ln++;
1217               enum {
1218                 START, MIDDLE, GOT_T, GOT_RIGHT_BRACE, GOT_DOT,
1219                 GOT_l, GOT_lf, END
1220               } state = START;
1221               while (state != END) {
1222                 c = in.get();
1223                 if (c == EOF)
1224                   break;
1225                 switch (state) {
1226                 case START:
1227                   if (c == 'T')
1228                     state = GOT_T;
1229                   else if (c == '.')
1230                     state = GOT_DOT;
1231                   else {
1232                     input_entry += c;
1233                     if (c != '\n')
1234                       state = MIDDLE;
1235                   }
1236                   break;
1237                 case GOT_T:
1238                   if (c == '}')
1239                     state = GOT_RIGHT_BRACE;
1240                   else {
1241                     input_entry += 'T';
1242                     input_entry += c;
1243                     state = c == '\n' ? START : MIDDLE;
1244                   }
1245                   break;
1246                 case GOT_DOT:
1247                   if (c == 'l')
1248                     state = GOT_l;
1249                   else {
1250                     input_entry += '.';
1251                     input_entry += c;
1252                     state = c == '\n' ? START : MIDDLE;
1253                   }
1254                   break;
1255                 case GOT_l:
1256                   if (c == 'f')
1257                     state = GOT_lf;
1258                   else {
1259                     input_entry += ".l";
1260                     input_entry += c;
1261                     state = c == '\n' ? START : MIDDLE;
1262                   }
1263                   break;
1264                 case GOT_lf:
1265                   if (c == ' ' || c == '\n' || compatible_flag) {
1266                     string args;
1267                     input_entry += ".lf";
1268                     while (c != EOF) {
1269                       args += c;
1270                       if (c == '\n')
1271                         break;
1272                       c = in.get();
1273                     }
1274                     args += '\0';
1275                     interpret_lf_args(args.contents());
1276                     // remove the '\0'
1277                     args.set_length(args.length() - 1);
1278                     input_entry += args;
1279                     state = START;
1280                   }
1281                   else {
1282                     input_entry += ".lf";
1283                     input_entry += c;
1284                     state = MIDDLE;
1285                   }
1286                   break;
1287                 case GOT_RIGHT_BRACE:
1288                   if (c == '\n' || c == tab_char)
1289                     state = END;
1290                   else {
1291                     input_entry += 'T';
1292                     input_entry += '}';
1293                     input_entry += c;
1294                     state = c == '\n' ? START : MIDDLE;
1295                   }
1296                   break;
1297                 case MIDDLE:
1298                   if (c == '\n')
1299                     state = START;
1300                   input_entry += c;
1301                   break;
1302                 case END:
1303                 default:
1304                   assert(0);
1305                 }
1306               }
1307               if (c == EOF) {
1308                 error("end of data in middle of text block");
1309                 give_up = 1;
1310                 break;
1311               }
1312             }
1313             if (col >= ncolumns) {
1314               if (!input_entry.empty()) {
1315                 if (input_entry.length() >= 2
1316                     && input_entry[0] == '\\'
1317                     && input_entry[1] == '"')
1318                   row_comment = 1;
1319                 else if (!row_comment) {
1320                   if (c == '\n')
1321                     in.unget(c);
1322                   input_entry += '\0';
1323                   error("excess data entry `%1' discarded",
1324                         input_entry.contents());
1325                   if (c == '\n')
1326                     (void)in.get();
1327                 }
1328               }
1329             }
1330             else
1331               tbl->add_entry(current_row, col, input_entry,
1332                              &line_format[col], current_filename, ln);
1333             col++;
1334             if (c == '\n')
1335               break;
1336             input_entry = "";
1337           }
1338           else
1339             input_entry += c;
1340           c = in.get();
1341           if (c == EOF)
1342             break;
1343         }
1344         if (give_up)
1345           break;
1346         input_entry = "";
1347         for (; col < ncolumns; col++)
1348           tbl->add_entry(current_row, col, input_entry, &line_format[col],
1349                          current_filename, current_lineno - 1);
1350         tbl->add_vlines(current_row, f->vline[format_index]);
1351         current_row++;
1352         format_index++;
1353       }
1354       break;
1355     case TROFF_INPUT_LINE:
1356       {
1357         string line;
1358         int ln = current_lineno;
1359         for (;;) {
1360           line += c;
1361           if (c == '\n')
1362             break;
1363           c = in.get();
1364           if (c == EOF) {
1365             break;
1366           }
1367         }
1368         tbl->add_text_line(current_row, line, current_filename, ln);
1369         if (line.length() >= 4
1370             && line[0] == '.' && line[1] == 'T' && line[2] == '&') {
1371           format *newf = process_format(in, opt, f);
1372           if (newf == 0)
1373             give_up = 1;
1374           else
1375             f = newf;
1376         }
1377         if (line.length() >= 3
1378             && line[0] == '.' && line[1] == 'f' && line[2] == 'f') {
1379           line += '\0';
1380           interpret_lf_args(line.contents() + 3);
1381         }
1382       }
1383       break;
1384     case SINGLE_HLINE:
1385       tbl->add_single_hline(current_row);
1386       break;
1387     case DOUBLE_HLINE:
1388       tbl->add_double_hline(current_row);
1389       break;
1390     default:
1391       assert(0);
1392     }
1393     if (give_up)
1394       break;
1395   }
1396   if (!give_up && current_row == 0) {
1397     error("no real data");
1398     give_up = 1;
1399   }
1400   if (give_up) {
1401     delete tbl;
1402     return 0;
1403   }
1404   // Do this here rather than at the beginning in case continued formats
1405   // change it.
1406   int i;
1407   for (i = 0; i < ncolumns - 1; i++)
1408     if (f->separation[i] >= 0)
1409       tbl->set_column_separation(i, f->separation[i]);
1410   for (i = 0; i < ncolumns; i++)
1411     if (!f->width[i].empty())
1412       tbl->set_minimum_width(i, f->width[i]);
1413   for (i = 0; i < ncolumns; i++)
1414     if (f->equal[i])
1415       tbl->set_equal_column(i);
1416   return tbl;
1417 }
1418
1419 void process_table(table_input &in)
1420 {
1421   int c;
1422   options *opt = 0;
1423   format *form = 0;
1424   table *tbl = 0;
1425   if ((opt = process_options(in)) != 0
1426       && (form = process_format(in, opt)) != 0
1427       && (tbl = process_data(in, form, opt)) != 0) {
1428     tbl->print();
1429     delete tbl;
1430   }
1431   else {
1432     error("giving up on this table");
1433     while ((c = in.get()) != EOF)
1434       ;
1435   }
1436   delete opt;
1437   delete form;
1438   if (!in.ended())
1439     error("premature end of file");
1440 }
1441
1442 static void usage()
1443 {
1444   fprintf(stderr, "usage: %s [ -vC ] [ files... ]\n", program_name);
1445   exit(1);
1446 }
1447
1448 int main(int argc, char **argv)
1449 {
1450   program_name = argv[0];
1451   static char stderr_buf[BUFSIZ];
1452   setbuf(stderr, stderr_buf);
1453   int opt;
1454   while ((opt = getopt(argc, argv, "vCT:")) != EOF)
1455     switch (opt) {
1456     case 'C':
1457       compatible_flag = 1;
1458       break;
1459     case 'v':
1460       {
1461         extern const char *version_string;
1462         fprintf(stderr, "GNU tbl version %s\n", version_string);
1463         fflush(stderr);
1464         break;
1465       }
1466     case 'T':
1467       // I'm sick of getting bug reports from IRIX users
1468       break;
1469     case '?':
1470       usage();
1471       break;
1472     default:
1473       assert(0);
1474     }
1475   printf(".if !\\n(.g .ab GNU tbl requires GNU troff.\n"
1476          ".if !dTS .ds TS\n"
1477          ".if !dTE .ds TE\n");
1478   if (argc > optind) {
1479     for (int i = optind; i < argc; i++)
1480       if (argv[i][0] == '-' && argv[i][1] == '\0') {
1481         current_filename = "-";
1482         current_lineno = 1;
1483         printf(".lf 1 -\n");
1484         process_input_file(stdin);
1485       }
1486       else {
1487         errno = 0;
1488         FILE *fp = fopen(argv[i], "r");
1489         if (fp == 0) {
1490           current_lineno = -1;
1491           error("can't open `%1': %2", argv[i], strerror(errno));
1492         }
1493         else {
1494           current_lineno = 1;
1495           current_filename = argv[i];
1496           printf(".lf 1 %s\n", current_filename);
1497           process_input_file(fp);
1498         }
1499       }
1500   }
1501   else {
1502     current_filename = "-";
1503     current_lineno = 1;
1504     printf(".lf 1 -\n");
1505     process_input_file(stdin);
1506   }
1507   if (ferror(stdout) || fflush(stdout) < 0)
1508     fatal("output error");
1509   return 0;
1510 }
1511