home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / groff-1.09-src.lha / src / amiga / groff-1.09 / pic / main.cc < prev    next >
C/C++ Source or Header  |  1993-05-27  |  12KB  |  612 lines
  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, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "pic.h"
  22.  
  23. extern int yyparse();
  24.  
  25. output *out;
  26.  
  27. int flyback_flag;
  28. int zero_length_line_flag = 0;
  29. // Non-zero means we're using a groff driver.
  30. int driver_extension_flag = 1;
  31. int compatible_flag = 0;
  32. int command_char = '.';        // the character that introduces lines
  33.                 // that should be passed through tranparently
  34. static int lf_flag = 1;        // non-zero if we should attempt to understand
  35.                 // lines beginning with `.lf'
  36.  
  37. void do_file(const char *filename);
  38.  
  39. class top_input : public input {
  40.   FILE *fp;
  41.   int bol;
  42.   int eof;
  43.   int push_back[3];
  44.   int start_lineno;
  45. public:
  46.   top_input(FILE *);
  47.   int get();
  48.   int peek();
  49.   int get_location(const char **, int *);
  50. };
  51.  
  52. top_input::top_input(FILE *p) : fp(p), bol(1), eof(0)
  53. {
  54.   push_back[0] = push_back[1] = push_back[2] = EOF;
  55.   start_lineno = current_lineno;
  56. }
  57.  
  58. int top_input::get()
  59. {
  60.   if (eof)
  61.     return EOF;
  62.   if (push_back[2] != EOF) {
  63.     int c = push_back[2];
  64.     push_back[2] = EOF;
  65.     return c;
  66.   }
  67.   else if (push_back[1] != EOF) {
  68.     int c = push_back[1];
  69.     push_back[1] = EOF;
  70.     return c;
  71.   }
  72.   else if (push_back[0] != EOF) {
  73.     int c = push_back[0];
  74.     push_back[0] = EOF;
  75.     return c;
  76.   }
  77.   int c = getc(fp);
  78.   while (illegal_input_char(c)) {
  79.     error("illegal input character code %1", int(c));
  80.     c = getc(fp);
  81.     bol = 0;
  82.   }
  83.   if (bol && c == '.') {
  84.     c = getc(fp);
  85.     if (c == 'P') {
  86.       c = getc(fp);
  87.       if (c == 'F' || c == 'E') {
  88.     int d = getc(fp);
  89.     if (d != EOF)
  90.       ungetc(d, fp);
  91.     if (d == EOF || d == ' ' || d == '\n' || compatible_flag) {
  92.       eof = 1;
  93.       flyback_flag = c == 'F';
  94.       return EOF;
  95.     }
  96.     push_back[0] = c;
  97.     push_back[1] = 'P';
  98.     return '.';
  99.       }
  100.       if (c == 'S') {
  101.     c = getc(fp);
  102.     if (c != EOF)
  103.       ungetc(c, fp);
  104.     if (c == EOF || c == ' ' || c == '\n' || compatible_flag) {
  105.       error("nested .PS");
  106.       eof = 1;
  107.       return EOF;
  108.     }
  109.     push_back[0] = 'S';
  110.     push_back[1] = 'P';
  111.     return '.';
  112.       }
  113.       if (c != EOF)
  114.     ungetc(c, fp);
  115.       push_back[0] = 'P';
  116.       return '.';
  117.     }
  118.     else {
  119.       if (c != EOF)
  120.     ungetc(c, fp);
  121.       return '.';
  122.     }
  123.   }
  124.   if (c == '\n') {
  125.     bol = 1;
  126.     current_lineno++;
  127.     return '\n';
  128.   }
  129.   bol = 0;
  130.   if (c == EOF) {
  131.     eof = 1;
  132.     error("end of file before .PE or .PF");
  133.     error_with_file_and_line(current_filename, start_lineno - 1,
  134.                  ".PS was here");
  135.   }
  136.   return c;
  137. }
  138.  
  139. int top_input::peek()
  140. {
  141.   if (eof)
  142.     return EOF;
  143.   if (push_back[2] != EOF)
  144.     return push_back[2];
  145.   if (push_back[1] != EOF)
  146.     return push_back[1];
  147.   if (push_back[0] != EOF)
  148.     return push_back[0];
  149.   int c = getc(fp);
  150.   while (illegal_input_char(c)) {
  151.     error("illegal input character code %1", int(c));
  152.     c = getc(fp);
  153.     bol = 0;
  154.   }
  155.   if (bol && c == '.') {
  156.     c = getc(fp);
  157.     if (c == 'P') {
  158.       c = getc(fp);
  159.       if (c == 'F' || c == 'E') {
  160.     int d = getc(fp);
  161.     if (d != EOF)
  162.       ungetc(d, fp);
  163.     if (d == EOF || d == ' ' || d == '\n' || compatible_flag) {
  164.       eof = 1;
  165.       flyback_flag = c == 'F';
  166.       return EOF;
  167.     }
  168.     push_back[0] = c;
  169.     push_back[1] = 'P';
  170.     push_back[2] = '.';
  171.     return '.';
  172.       }
  173.       if (c == 'S') {
  174.     c = getc(fp);
  175.     if (c != EOF)
  176.       ungetc(c, fp);
  177.     if (c == EOF || c == ' ' || c == '\n' || compatible_flag) {
  178.       error("nested .PS");
  179.       eof = 1;
  180.       return EOF;
  181.     }
  182.     push_back[0] = 'S';
  183.     push_back[1] = 'P';
  184.     push_back[2] = '.';
  185.     return '.';
  186.       }
  187.       if (c != EOF)
  188.     ungetc(c, fp);
  189.       push_back[0] = 'P';
  190.       push_back[1] = '.';
  191.       return '.';
  192.     }
  193.     else {
  194.       if (c != EOF)
  195.     ungetc(c, fp);
  196.       push_back[0] = '.';
  197.       return '.';
  198.     }
  199.   }
  200.   if (c != EOF)
  201.     ungetc(c, fp);
  202.   if (c == '\n')
  203.     return '\n';
  204.   return c;
  205. }
  206.  
  207. int top_input::get_location(const char **filenamep, int *linenop)
  208. {
  209.   *filenamep = current_filename;
  210.   *linenop = current_lineno;
  211.   return 1;
  212. }
  213.  
  214. void do_picture(FILE *fp)
  215. {
  216.   flyback_flag = 0;
  217.   int c;
  218.   while ((c = getc(fp)) == ' ')
  219.     ;
  220.   if (c == '<') {
  221.     string filename;
  222.     while ((c = getc(fp)) == ' ')
  223.       ;
  224.     while (c != EOF && c != ' ' && c != '\n') {
  225.       filename += char(c);
  226.       c = getc(fp);
  227.     }
  228.     if (c == ' ') {
  229.       do {
  230.     c = getc(fp);
  231.       } while (c != EOF && c != '\n');
  232.     }
  233.     if (c == '\n') 
  234.       current_lineno++;
  235.     if (filename.length() == 0)
  236.       error("missing filename after `<'");
  237.     else {
  238.       filename += '\0';
  239.       const char *old_filename = current_filename;
  240.       int old_lineno = current_lineno;
  241.       // filenames must be permanent
  242.       do_file(strsave(filename.contents()));
  243.       current_filename = old_filename;
  244.       current_lineno = old_lineno;
  245.     }
  246.     out->set_location(current_filename, current_lineno);
  247.   }
  248.   else {
  249.     out->set_location(current_filename, current_lineno);
  250.     string start_line;
  251.     while (c != EOF) {
  252.       if (c == '\n') {
  253.     current_lineno++;
  254.     break;
  255.       }
  256.       start_line += c;
  257.       c = getc(fp);
  258.     }
  259.     if (c == EOF)
  260.       return;
  261.     start_line += '\0';
  262.     double wid, ht;
  263.     switch (sscanf(&start_line[0], "%lf %lf", &wid, &ht)) {
  264.     case 1:
  265.       ht = 0.0;
  266.       break;
  267.     case 2:
  268.       break;
  269.     default:
  270.       ht = wid = 0.0;
  271.       break;
  272.     }
  273.     out->set_desired_width_height(wid, ht);
  274.     out->set_args(start_line.contents());
  275.     lex_init(new top_input(fp));
  276.     if (yyparse())
  277.       lex_error("giving up on this picture");
  278.     parse_cleanup();
  279.     lex_cleanup();
  280.  
  281.     // skip the rest of the .PF/.PE line
  282.     while ((c = getc(fp)) != EOF && c != '\n')
  283.       ;
  284.     if (c == '\n')
  285.       current_lineno++;
  286.     out->set_location(current_filename, current_lineno);
  287.   }
  288. }
  289.  
  290. void do_file(const char *filename)
  291. {
  292.   FILE *fp;
  293.   if (strcmp(filename, "-") == 0)
  294.     fp = stdin;
  295.   else {
  296.     errno = 0;
  297.     fp = fopen(filename, "r");
  298.     if (fp == 0)
  299.       fatal("can't open `%1': %2", filename, strerror(errno));
  300.   }
  301.   out->set_location(filename, 1);
  302.   current_filename = filename;
  303.   current_lineno = 1;
  304.   enum { START, MIDDLE, HAD_DOT, HAD_P, HAD_PS, HAD_l, HAD_lf } state = START;
  305.   for (;;) {
  306.     int c = getc(fp);
  307.     if (c == EOF)
  308.       break;
  309.     switch (state) {
  310.     case START:
  311.       if (c == '.')
  312.     state = HAD_DOT;
  313.       else {
  314.     putchar(c);
  315.     if (c == '\n') {
  316.       current_lineno++;
  317.       state = START;
  318.     }
  319.     else
  320.       state = MIDDLE;
  321.       }
  322.       break;
  323.     case MIDDLE:
  324.       putchar(c);
  325.       if (c == '\n') {
  326.     current_lineno++;
  327.     state = START;
  328.       }
  329.       break;
  330.     case HAD_DOT:
  331.       if (c == 'P')
  332.     state = HAD_P;
  333.       else if (lf_flag && c == 'l')
  334.     state = HAD_l;
  335.       else {
  336.     putchar('.');
  337.     putchar(c);
  338.     if (c == '\n') {
  339.       current_lineno++;
  340.       state = START;
  341.     }
  342.     else
  343.       state = MIDDLE;
  344.       }
  345.       break;
  346.     case HAD_P:
  347.       if (c == 'S')
  348.     state = HAD_PS;
  349.       else  {
  350.     putchar('.');
  351.     putchar('P');
  352.     putchar(c);
  353.     if (c == '\n') {
  354.       current_lineno++;
  355.       state = START;
  356.     }
  357.     else
  358.       state = MIDDLE;
  359.       }
  360.       break;
  361.     case HAD_PS:
  362.       if (c == ' ' || c == '\n' || compatible_flag) {
  363.     ungetc(c, fp);
  364.     do_picture(fp);
  365.     state = START;
  366.       }
  367.       else {
  368.     fputs(".PS", stdout);
  369.     putchar(c);
  370.     state = MIDDLE;
  371.       }
  372.       break;
  373.     case HAD_l:
  374.       if (c == 'f')
  375.     state = HAD_lf;
  376.       else {
  377.     putchar('.');
  378.     putchar('l');
  379.     putchar(c);
  380.     if (c == '\n') {
  381.       current_lineno++;
  382.       state = START;
  383.     }
  384.     else
  385.       state = MIDDLE;
  386.       }
  387.       break;
  388.     case HAD_lf:
  389.       if (c == ' ' || c == '\n' || compatible_flag) {
  390.     string line;
  391.     while (c != EOF) {
  392.       line += c;
  393.       if (c == '\n') {
  394.         current_lineno++;
  395.         break;
  396.       }
  397.       c = getc(fp);
  398.     }
  399.     line += '\0';
  400.     interpret_lf_args(line.contents());
  401.     printf(".lf%s", line.contents());
  402.     state = START;
  403.       }
  404.       else {
  405.     fputs(".lf", stdout);
  406.     putchar(c);
  407.     state = MIDDLE;
  408.       }
  409.       break;
  410.     default:
  411.       assert(0);
  412.     }
  413.   }
  414.   switch (state) {
  415.   case START:
  416.     break;
  417.   case MIDDLE:
  418.     putchar('\n');
  419.     break;
  420.   case HAD_DOT:
  421.     fputs(".\n", stdout);
  422.     break;
  423.   case HAD_P:
  424.     fputs(".P\n", stdout);
  425.     break;
  426.   case HAD_PS:
  427.     fputs(".PS\n", stdout);
  428.     break;
  429.   case HAD_l:
  430.     fputs(".l\n", stdout);
  431.     break;
  432.   case HAD_lf:
  433.     fputs(".lf\n", stdout);
  434.     break;
  435.   }
  436.   if (fp != stdin)
  437.     fclose(fp);
  438. }
  439.  
  440. #ifdef FIG_SUPPORT
  441. void do_whole_file(const char *filename)
  442. {
  443.   // Do not set current_filename.
  444.   FILE *fp;
  445.   if (strcmp(filename, "-") == 0)
  446.     fp = stdin;
  447.   else {
  448.     errno = 0;
  449.     fp = fopen(filename, "r");
  450.     if (fp == 0)
  451.       fatal("can't open `%1': %2", filename, strerror(errno));
  452.   }
  453.   lex_init(new file_input(fp, filename));
  454.   yyparse();
  455.   parse_cleanup();
  456.   lex_cleanup();
  457. }
  458. #endif
  459.  
  460. void usage()
  461. {
  462.   fprintf(stderr, "usage: %s [ -nvC ] [ filename ... ]\n", program_name);
  463. #ifdef TEX_SUPPORT
  464.   fprintf(stderr, "       %s -t [ -cvzC ] [ filename ... ]\n", program_name);
  465. #endif
  466. #ifdef FIG_SUPPORT
  467.   fprintf(stderr, "       %s -f [ -v ] [ filename ]\n", program_name);
  468. #endif
  469.   exit(1);
  470. }
  471.  
  472. #ifdef __MSDOS__
  473. static char *fix_program_name(char *arg, char *dflt)
  474. {
  475.   if (!arg)
  476.     return dflt;
  477.   char *prog = strchr(arg, '\0');
  478.   for (;;) {
  479.     if (prog == arg)
  480.       break;
  481.     --prog;
  482.     if (strchr("\\/:", *prog)) {
  483.       prog++;
  484.       break;
  485.     }
  486.   }    
  487.   char *ext = strchr(prog, '.');
  488.   if (ext)
  489.     *ext = '\0';
  490.   for (char *p = prog; *p; p++)
  491.     if ('A' <= *p && *p <= 'Z')
  492.       *p = 'a' + (*p - 'A');
  493.   return prog;
  494. }
  495. #endif /* __MSDOS__ */
  496.  
  497. int main(int argc, char **argv)
  498. {
  499. #ifdef __MSDOS__
  500.   argv[0] = fix_program_name(argv[0], "pic");
  501. #endif /* __MSDOS__ */
  502.   program_name = argv[0];
  503.   static char stderr_buf[BUFSIZ];
  504.   setbuf(stderr, stderr_buf);
  505.   int opt;
  506. #ifdef TEX_SUPPORT
  507.   int tex_flag = 0;
  508.   int tpic_flag = 0;
  509. #endif
  510. #ifdef FIG_SUPPORT
  511.   int whole_file_flag = 0;
  512.   int fig_flag = 0;
  513. #endif
  514.   while ((opt = getopt(argc, argv, "T:CDtcvnxzpf")) != EOF)
  515.     switch (opt) {
  516.     case 'C':
  517.       compatible_flag = 1;
  518.       break;
  519.     case 'D':
  520.     case 'T':
  521.       break;
  522.     case 'f':
  523. #ifdef FIG_SUPPORT
  524.       whole_file_flag++;
  525.       fig_flag++;
  526. #else
  527.       fatal("fig support not included");
  528. #endif
  529.       break;
  530.     case 'n':
  531.       driver_extension_flag = 0;
  532.       break;
  533.     case 'p':
  534.     case 'x':
  535.       warning("-%1 option is obsolete", char(opt));
  536.       break;
  537.     case 't':
  538. #ifdef TEX_SUPPORT
  539.       tex_flag++;
  540. #else
  541.       fatal("TeX support not included");
  542. #endif
  543.       break;
  544.     case 'c':
  545. #ifdef TEX_SUPPORT
  546.       tpic_flag++;
  547. #else
  548.       fatal("TeX support not included");
  549. #endif
  550.       break;
  551.     case 'v':
  552.       {
  553.     extern const char *version_string;
  554.     fprintf(stderr, "GNU pic version %s\n", version_string);
  555.     fflush(stderr);
  556.     break;
  557.       }
  558.     case 'z':
  559.       // zero length lines will be printed as dots
  560.       zero_length_line_flag++;
  561.       break;
  562.     case '?':
  563.       usage();
  564.       break;
  565.     default:
  566.       assert(0);
  567.     }
  568.   parse_init();
  569. #ifdef TEX_SUPPORT
  570.   if (tpic_flag) {
  571.     out = make_tpic_output();
  572.     lf_flag = 0;
  573.   }
  574.   else if (tex_flag) {
  575.     out = make_tex_output();
  576.     command_char = '\\';
  577.     lf_flag = 0;
  578.   }
  579.   else
  580. #endif
  581. #ifdef FIG_SUPPORT
  582.   if (fig_flag)
  583.     out = make_fig_output();
  584.   else
  585. #endif
  586.     out = make_troff_output();
  587. #ifdef FIG_SUPPORT
  588.   if (whole_file_flag) {
  589.     if (optind >= argc)
  590.       do_whole_file("-");
  591.     else if (argc - optind > 1)
  592.       usage();
  593.     else
  594.       do_whole_file(argv[optind]);
  595.   }
  596.   else {
  597. #endif
  598.     if (optind >= argc)
  599.       do_file("-");
  600.     else
  601.       for (int i = optind; i < argc; i++)
  602.     do_file(argv[i]);
  603. #ifdef FIG_SUPPORT
  604.   }
  605. #endif
  606.   delete out;
  607.   if (ferror(stdout) || fflush(stdout) < 0)
  608.     fatal("output error");
  609.   return 0;
  610. }
  611.  
  612.