home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Libraries / stdwin / Appls / dpv / dpvparse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-11-17  |  4.5 KB  |  209 lines  |  [TEXT/????]
  1. /* dpv -- ditroff previewer.  Parser for ditroff output. */
  2.  
  3. #include "dpv.h"
  4. #include "dpvmachine.h"
  5. #include "dpvoutput.h"
  6. #include "dpvdoc.h" /* Descripton of ditroff output format */
  7.  
  8. /* Parser main loop.  Read input from fp.
  9.    Stop when EOF hit, 'x stop' found, or nextpage returns < 0.
  10.    This makes calls to the machine module to update the
  11.    virtual machine's state, and to the output module to perform
  12.    actual output.
  13.    Code derived from a (not very robust) ditroff filter by BWK. */
  14.  
  15. parse(fp)
  16.     register FILE *fp;
  17. {
  18.     register int c, k;
  19.     int m, n, n1, m1;
  20.     char str[100], buf[300];
  21.     
  22.     while ((c = getc(fp)) != EOF) {
  23.         switch (c) {
  24.         case '\n':    /* when input is text */
  25.         case '\0':    /* occasional noise creeps in */
  26.         case '\t':
  27.         case ' ':
  28.             break;
  29.         case '{':    /* push down current environment */
  30.             t_push();
  31.             break;
  32.         case '}':
  33.             t_pop();
  34.             break;
  35.         case '0': case '1': case '2': case '3': case '4':
  36.         case '5': case '6': case '7': case '8': case '9':
  37.             /* two motion digits plus a character */
  38.             k= (c-'0')*10;
  39.             c= getc(fp);
  40.             k += c-'0';
  41.             hmot(k);
  42.             c= getc(fp);
  43.             put1(c);
  44.             break;
  45.         case 'c':    /* single ascii character */
  46.             c= getc(fp);
  47.             put1(c);
  48.             break;
  49.         case 'C':
  50.             fscanf(fp, "%s", str);
  51.             put1s(str);
  52.             break;
  53.         case 't':    /* straight text */
  54.             if (fgets(buf, sizeof(buf), fp) == NULL)
  55.                 error(FATAL, "unexpected end of input");
  56.             t_text(buf);
  57.             break;
  58.         case 'D':    /* draw function */
  59.             if (fgets(buf, sizeof(buf), fp) == NULL)
  60.                 error(FATAL, "unexpected end of input");
  61.             switch (buf[0]) {
  62.             case 'l':    /* draw a line */
  63.                 sscanf(buf+1, "%d %d", &n, &m);
  64.                 drawline(n, m);
  65.                 break;
  66.             case 'c':    /* circle */
  67.                 sscanf(buf+1, "%d", &n);
  68.                 drawcirc(n);
  69.                 break;
  70.             case 'e':    /* ellipse */
  71.                 sscanf(buf+1, "%d %d", &m, &n);
  72.                 drawellip(m, n);
  73.                 break;
  74.             case 'a':    /* arc */
  75.                 sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
  76.                 drawarc(n, m, n1, m1);
  77.                 break;
  78.             case '~':    /* wiggly line */
  79.                 /* HIRO: how to scan? */
  80.                 drawwig(buf+1, fp, 1);
  81.                 break;
  82.             default:
  83.                 error(FATAL, "unknown drawing function %s", buf);
  84.                 break;
  85.             }
  86.             recheck();
  87.             break;
  88.         case 's':
  89.             fscanf(fp, "%d", &n);
  90.             setsize(t_size(n));
  91.             break;
  92.         case 'f':
  93.             fscanf(fp, "%s", str);
  94.             setfont(t_font(str));
  95.             break;
  96.         case 'H':    /* absolute horizontal motion */
  97.             while ((c = getc(fp)) == ' ')
  98.                 ;
  99.             k = 0;
  100.             do {
  101.                 k = 10 * k + c - '0';
  102.             } while (isdigit(c = getc(fp)));
  103.             ungetc(c, fp);
  104.             hgoto(k);
  105.             break;
  106.         case 'h':    /* relative horizontal motion */
  107.             while ((c = getc(fp)) == ' ')
  108.                 ;
  109.             k = 0;
  110.             do {
  111.                 k = 10 * k + c - '0';
  112.             } while (isdigit(c = getc(fp)));
  113.             ungetc(c, fp);
  114.             hmot(k);
  115.             break;
  116.         case 'w':    /* word space */
  117.             break;
  118.         case 'V':
  119.             fscanf(fp, "%d", &n);
  120.             vgoto(n);
  121.             break;
  122.         case 'v':
  123.             fscanf(fp, "%d", &n);
  124.             vmot(n);
  125.             break;
  126.         case 'P':    /* new spread (Versatec hack) */
  127.             break;
  128.         case 'p':    /* new page */
  129.             fscanf(fp, "%d", &n);
  130.             if (t_page(n) < 0)
  131.                 return;
  132.             break;
  133.         case 'n':    /* end of line */
  134.             t_newline();
  135.         /* Fall through */
  136.         case '#':    /* comment */
  137.             do {
  138.                 c = getc(fp);
  139.             } while (c != EOL && c != EOF);
  140.             break;
  141.         case 'x':    /* device control */
  142.             if (devcntrl(fp) < 0)
  143.                 return;
  144.             break;
  145.         default:
  146.             error(FATAL, "unknown input character %o %c", c, c);
  147.         }
  148.     }
  149.     error(WARNING, "read till EOF");
  150. }
  151.  
  152. /* Parse rest of device control line.
  153.    Returns -1 upon receiving EOF or "stop" command. */
  154.  
  155. static int
  156. devcntrl(fp)
  157.     FILE *fp;
  158. {
  159.         char str[20], str1[50], buf[50];
  160.     extern char *namemap(); /* ??? */
  161.     int c, n;
  162.  
  163.     fscanf(fp, "%s", str);
  164.     switch (str[0]) {    /* crude for now */
  165.     case 'i':    /* initialize */
  166.         t_init();
  167.         break;
  168.     case 't':    /* trailer */
  169.         break;
  170.     case 'p':    /* pause -- can restart */
  171.         t_reset('p');
  172.         break;
  173.     case 's':    /* stop */
  174.         t_reset('s');
  175.         return -1;
  176.     case 'r':    /* resolution assumed when prepared */
  177.         fscanf(fp, "%d", &res);
  178.         break;
  179.     case 'f':    /* font used */
  180.         fscanf(fp, "%d %s", &n, str);
  181.         (void) fgets(buf, sizeof buf, fp);   /* in case of filename */
  182.         ungetc(EOL, fp);        /* fgets goes too far */
  183.         str1[0] = 0;            /* in case nothing comes in */
  184.         (void) sscanf(buf, "%s", str1);
  185.         loadfont(n, str, str1);
  186.         break;
  187.     case 'H':    /* char height */
  188.         fscanf(fp, "%d", &n);
  189.         t_charht(n);
  190.         break;
  191.     case 'S':    /* slant */
  192.         fscanf(fp, "%d", &n);
  193.         t_slant(n);
  194.         break;
  195.     case 'T':    /* device name */
  196.         buf[0]= EOS;
  197.         fscanf(fp, "%s", buf);
  198.         if (buf[0] != EOS)
  199.             devname= strdup(buf);
  200.         break;
  201.  
  202.     }
  203.     while ((c = getc(fp)) != EOL) {    /* skip rest of input line */
  204.         if (c == EOF)
  205.             return -1;
  206.     }
  207.     return 0;
  208. }
  209.