home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / print / post16.lzh / postop4.c < prev    next >
Text File  |  1991-04-17  |  38KB  |  1,331 lines
  1. /* PostScript interpreter file "postop4.c" - operators (4) */
  2. /* (C) Adrian Aylward 1989, 1991 */
  3.  
  4. # include "post.h"
  5.  
  6. /* arc */
  7.  
  8. void oparc(void)
  9. {   struct object *token1;
  10.     struct point centre, beg, end;
  11.     float radaa[3];
  12.     if (opernest < 5) error(errstackunderflow);
  13.     token1 = &operstack[opernest - 5];
  14.     centre.type = 0;
  15.     if      (token1->type == typeint)
  16.         centre.x = token1->value.ival;
  17.     else if (token1->type == typereal)
  18.         centre.x = token1->value.rval;
  19.     else
  20.         error(errtypecheck);
  21.     token1++;
  22.     if      (token1->type == typeint)
  23.         centre.y = token1->value.ival;
  24.     else if (token1->type == typereal)
  25.         centre.y = token1->value.rval;
  26.     else
  27.         error(errtypecheck);
  28.     token1++;
  29.     if      (token1->type == typeint)
  30.         radaa[0] = token1->value.ival;
  31.     else if (token1->type == typereal)
  32.         radaa[0] = token1->value.rval;
  33.     else
  34.         error(errtypecheck);
  35.     token1++;
  36.     if      (token1->type == typeint)
  37.         radaa[1] = token1->value.ival;
  38.     else if (token1->type == typereal)
  39.         radaa[1] = token1->value.rval;
  40.     else
  41.         error(errtypecheck);
  42.     token1++;
  43.     if      (token1->type == typeint)
  44.         radaa[2] = token1->value.ival;
  45.     else if (token1->type == typereal)
  46.         radaa[2] = token1->value.rval;
  47.     else
  48.         error(errtypecheck);
  49.     if (radaa[0] <= 0.0) error(errrangecheck);
  50.     radaa[1] *= degtorad;
  51.     radaa[2] *= degtorad;
  52.     arc(1, radaa, ¢re, &beg, &end);
  53.     opernest -= 5;
  54. }
  55.  
  56. /* arcn */
  57.  
  58. void oparcn(void)
  59. {   struct object *token1;
  60.     struct point centre, beg, end;
  61.     float radaa[3];
  62.     if (opernest < 5) error(errstackunderflow);
  63.     token1 = &operstack[opernest - 5];
  64.     centre.type = 0;
  65.     if      (token1->type == typeint)
  66.         centre.x = token1->value.ival;
  67.     else if (token1->type == typereal)
  68.         centre.x = token1->value.rval;
  69.     else
  70.         error(errtypecheck);
  71.     token1++;
  72.     if      (token1->type == typeint)
  73.         centre.y = token1->value.ival;
  74.     else if (token1->type == typereal)
  75.         centre.y = token1->value.rval;
  76.     else
  77.         error(errtypecheck);
  78.     token1++;
  79.     if      (token1->type == typeint)
  80.         radaa[0] = token1->value.ival;
  81.     else if (token1->type == typereal)
  82.         radaa[0] = token1->value.rval;
  83.     else
  84.         error(errtypecheck);
  85.     token1++;
  86.     if      (token1->type == typeint)
  87.         radaa[1] = token1->value.ival;
  88.     else if (token1->type == typereal)
  89.         radaa[1] = token1->value.rval;
  90.     else
  91.         error(errtypecheck);
  92.     token1++;
  93.     if      (token1->type == typeint)
  94.         radaa[2] = token1->value.ival;
  95.     else if (token1->type == typereal)
  96.         radaa[2] = token1->value.rval;
  97.     else
  98.         error(errtypecheck);
  99.     if (radaa[0] <= 0.0) error(errrangecheck);
  100.     radaa[1] *= degtorad;
  101.     radaa[2] *= degtorad;
  102.     arc(-1, radaa, ¢re, &beg, &end);
  103.     opernest -= 5;
  104. }
  105.  
  106. /* arcto */
  107.  
  108. void oparcto(void)
  109. {   struct object token, *token1;
  110.     struct point beg, mid, end;
  111.     float radaa[3], angs, angd, radx;
  112.     if (opernest < 5) error(errstackunderflow);
  113.     token1 = &operstack[opernest - 5];
  114.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  115.     beg = patharray[gstate.pathend - 1];
  116.     itransform(&beg, gstate.ctm);
  117.     mid.type = ptline;
  118.     if      (token1->type == typeint)
  119.         mid.x = token1->value.ival;
  120.     else if (token1->type == typereal)
  121.         mid.x = token1->value.rval;
  122.     else
  123.         error(errtypecheck);
  124.     token1++;
  125.     if      (token1->type == typeint)
  126.         mid.y = token1->value.ival;
  127.     else if (token1->type == typereal)
  128.         mid.y = token1->value.rval;
  129.     else
  130.         error(errtypecheck);
  131.     token1++;
  132.     end.type = 0;
  133.     if      (token1->type == typeint)
  134.         end.x = token1->value.ival;
  135.     else if (token1->type == typereal)
  136.         end.x = token1->value.rval;
  137.     else
  138.         error(errtypecheck);
  139.     token1++;
  140.     if      (token1->type == typeint)
  141.         end.y = token1->value.ival;
  142.     else if (token1->type == typereal)
  143.         end.y = token1->value.rval;
  144.     else
  145.         error(errtypecheck);
  146.     token1++;
  147.     if      (token1->type == typeint)
  148.         radaa[0] = token1->value.ival;
  149.     else if (token1->type == typereal)
  150.         radaa[0] = token1->value.rval;
  151.     else
  152.         error(errtypecheck);
  153.     if (radaa[0] <= 0.0) error(errrangecheck);
  154.     radaa[1] = atan2(beg.y - mid.y, beg.x - mid.x);
  155.     radaa[2] = atan2(end.y - mid.y, end.x - mid.x);
  156.     angs = (radaa[2] + radaa[1]) / 2.0;
  157.     angd = (radaa[2] - radaa[1]) / 2.0;
  158.     radx = radaa[0] / sin(angd);
  159.     if (angd < 0) angd += pi;
  160.     if (angd < pi2)
  161.     {   radaa[1] -= pi2;
  162.         radaa[2] += pi2;
  163.     }
  164.     else
  165.     {   radx = -radx;
  166.         radaa[1] += pi2;
  167.         radaa[2] -= pi2;
  168.     }
  169.     mid.x += radx * cos(angs);
  170.     mid.y += radx * sin(angs);
  171.     arc(0, radaa, &mid, &beg, &end);
  172.     token1 -= 4;
  173.     token.type = typereal;
  174.     token.flags = 0;
  175.     token.length = 0;
  176.     token.value.rval = beg.x;
  177.     token1[0] = token;
  178.     token.value.rval = beg.y;
  179.     token1[1] = token;
  180.     token.value.rval = end.x;
  181.     token1[2] = token;
  182.     token.value.rval = end.y;
  183.     token1[3] = token;
  184.     opernest -= 1;
  185. }
  186.  
  187. /* ashow */
  188.  
  189. void opashow(void)
  190. {   struct object *token1, *token2, *token3;
  191.     struct point width[2];
  192.     if (opernest < 3) error(errstackunderflow);
  193.     token3 = &operstack[opernest - 1];
  194.     token2 = token3 - 1;
  195.     token1 = token2 - 1;
  196.     width[0].x = width[0].y = 0.0;
  197.     if      (token1->type == typeint)
  198.         width[1].x = token1->value.ival;
  199.     else if (token1->type == typereal)
  200.         width[1].x = token1->value.rval;
  201.     else
  202.         error(errtypecheck);
  203.     if      (token2->type == typeint)
  204.         width[1].y = token2->value.ival;
  205.     else if (token2->type == typereal)
  206.         width[1].y = token2->value.rval;
  207.     else
  208.         error(errtypecheck);
  209.     dtransform(&width[1], gstate.ctm);
  210.     if (token3->type != typestring) error(errtypecheck);
  211.     if (token3->flags & flagrprot) error(errinvalidaccess);
  212.     show(token3, 3, width, -1, NULL);
  213.     opernest -= 3;
  214. }
  215.  
  216. /* awidthshow */
  217.  
  218. void opawidthshow(void)
  219. {   struct object *token1, *token2, *token3, *token4, *token5, *token6;
  220.     struct point width[2];
  221.     int wchar;
  222.     if (opernest < 6) error(errstackunderflow);
  223.     token6 = &operstack[opernest - 1];
  224.     token5 = token6 - 1;
  225.     token4 = token5 - 1;
  226.     token3 = token4 - 1;
  227.     token2 = token3 - 1;
  228.     token1 = token2 - 1;
  229.     if      (token1->type == typeint)
  230.         width[0].x = token1->value.ival;
  231.     else if (token1->type == typereal)
  232.         width[0].x = token1->value.rval;
  233.     else
  234.         error(errtypecheck);
  235.     if      (token2->type == typeint)
  236.         width[0].y = token2->value.ival;
  237.     else if (token2->type == typereal)
  238.         width[0].y = token2->value.rval;
  239.     else
  240.         error(errtypecheck);
  241.     dtransform(&width[0], gstate.ctm);
  242.     if (token3->type != typeint) error(errtypecheck);
  243.     wchar = token3->value.ival;
  244.     if (wchar < 0 || wchar > 255) error(errrangecheck);
  245.     if      (token4->type == typeint)
  246.         width[1].x = token4->value.ival;
  247.     else if (token4->type == typereal)
  248.         width[1].x = token4->value.rval;
  249.     else
  250.         error(errtypecheck);
  251.     if      (token5->type == typeint)
  252.         width[1].y = token5->value.ival;
  253.     else if (token5->type == typereal)
  254.         width[1].y = token5->value.rval;
  255.     else
  256.         error(errtypecheck);
  257.     dtransform(&width[1], gstate.ctm);
  258.     if (token6->type != typestring) error(errtypecheck);
  259.     if (token6->flags & flagrprot) error(errinvalidaccess);
  260.     show(token6, 3, width, wchar, NULL);
  261.     opernest -= 6;
  262. }
  263.  
  264. /* cachestatus */
  265.  
  266. void opcachestatus(void)
  267. {   struct object token, *token1;
  268.     int status[7], i;
  269.     if (opernest + 7 > operstacksize) error(errstackoverflow);
  270.     token1 = &operstack[opernest];
  271.     cachestatus(status);
  272.     token.type = typeint;
  273.     token.flags = 0;
  274.     token.length = 0;
  275.     for (i = 0; i < 7; i++)
  276.     {   token.value.ival = status[i];
  277.         *token1++ = token;
  278.     }
  279.     opernest += 7;
  280. }
  281.  
  282. /* charpath */
  283.  
  284. void opcharpath(void)
  285. {   struct object *token1, *token2;
  286.     if (opernest < 2) error(errstackunderflow);
  287.     token2 = &operstack[opernest - 1];
  288.     token1 = token2 - 1;
  289.     if (token1->type != typestring) error(errtypecheck);
  290.     if (token1->flags & flagrprot) error(errinvalidaccess);
  291.     if (token2->type != typebool) error(errtypecheck);
  292.     show(token1, token2->value.ival, NULL, -1, NULL);
  293.     opernest -= 2;
  294. }
  295.  
  296. /* clip */
  297.  
  298. void opclip(void)
  299. {   closepath(ptclosei);
  300.     flattenpath();
  301.     clip(-1);
  302. }
  303.  
  304. /* clippath */
  305.  
  306. void opclippath(void)
  307. {   clippath();
  308. }
  309.  
  310. /* closepath */
  311.  
  312. void opclosepath(void)
  313. {   closepath(ptclosex);
  314. }
  315.  
  316. /* colorimage */
  317.  
  318. void opcolorimage(void)
  319. {   struct object *token1, *token2, *token3, *token4,
  320.                   *token5, *token6, *token7, *aptr;
  321.     float matrix[6];
  322.     int ncol, multi, width, height, bps;
  323.     int nproc, i;
  324.     if (gstate.cacheflag) error(errundefined);
  325.     if (opernest < 2) error(errstackunderflow);
  326.     token7 = &operstack[opernest - 1];
  327.     token6 = token7 - 1;
  328.     if (token6->type != typebool) error(errtypecheck);
  329.     multi = token6->value.ival;
  330.     if (token7->type != typeint) error(errtypecheck);
  331.     ncol = token7->value.ival;
  332.     if (ncol != 1 && ncol != 3 && ncol != 4) error(errrangecheck);
  333.     nproc = multi ? ncol : 1;
  334.     if (opernest < nproc + 6) error(errstackunderflow);
  335.     token5 = token6 - nproc;
  336.     aptr = token5;
  337.     for (i = 0; i < nproc; i++)
  338.     {   if (aptr->type != typearray && aptr->type != typepacked)
  339.             error(errtypecheck);
  340.         aptr++;
  341.     }
  342.     token4 = token5 - 1;
  343.     token3 = token4 - 1;
  344.     token2 = token3 - 1;
  345.     token1 = token2 - 1;
  346.     if (token1->type != typeint) error(errtypecheck);
  347.     width = token1->value.ival;
  348.     if (width <= 0) error(errrangecheck);
  349.     if (token2->type != typeint) error(errtypecheck);
  350.     height = token2->value.ival;
  351.     if (height <= 0) error(errrangecheck);
  352.     if (token3->type != typeint) error(errtypecheck);
  353.     bps = token3->value.ival;
  354.     if (bps != 1 && bps != 2 && bps != 4 && bps != 8) error(errrangecheck);
  355.     if (token4->type != typearray) error(errtypecheck);
  356.     if (token4->length != 6) error(errrangecheck);
  357.     if (token4->flags & flagrprot) error(errinvalidaccess);
  358.     getmatrix(token4->value.vref, matrix);
  359.     image(width, height, bps, matrix, -1, ncol, multi, token5);
  360.     opernest -= nproc + 6;
  361. }
  362.  
  363. /* copypage */
  364.  
  365. void opcopypage(void)
  366. {   struct object token;
  367.     int num = 1;
  368.     if (istate.flags & intgraph) error(errundefined);
  369.     if (gstate.dev.depth != 0)
  370.     {   if (dictfind(&copies, &token) != -1)
  371.         {   if (token.type != typeint) error(errtypecheck);
  372.             num = token.value.ival;
  373.             if (num < 0) error(errrangecheck);
  374.         }
  375.         copypage(num);
  376.     }
  377. }
  378.  
  379. /* currentband */
  380.  
  381. void opcurrentband(void)
  382. {   struct object token, *token1;
  383.     if (opernest + 3 > operstacksize) error(errstackoverflow);
  384.     token1 = &operstack[opernest];
  385.     token.type = typeint;
  386.     token.flags = 0;
  387.     token.length = 0;
  388.     token.value.ival = page.ybase;
  389.     token1[0] = token;
  390.     token.value.ival = page.ysize;
  391.     token1[1] = token;
  392.     token.value.ival = page.yheight;
  393.     token1[2] = token;
  394.     opernest += 3;
  395. }
  396.  
  397. /* currentfont */
  398.  
  399. void opcurrentfont(void)
  400. {   if (opernest + 1 > operstacksize) error(errstackoverflow);
  401.     operstack[opernest++] = gstate.font;
  402. }
  403.  
  404. /* currentpoint */
  405.  
  406. void opcurrentpoint(void)
  407. {   struct object token, *token1;
  408.     struct point point;
  409.     if (opernest + 2 > operstacksize) error(errstackoverflow);
  410.     token1 = &operstack[opernest];
  411.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  412.     point = patharray[gstate.pathend - 1];
  413.     itransform(&point, gstate.ctm);
  414.     token.type = typereal;
  415.     token.flags = 0;
  416.     token.length = 0;
  417.     token.value.rval = point.x;
  418.     token1[0] = token;
  419.     token.value.rval = point.y;
  420.     token1[1] = token;
  421.     opernest += 2;
  422. }
  423.  
  424. /* curveto */
  425.  
  426. void opcurveto(void)
  427. {   struct object *token1;
  428.     struct point point[3], *ppoint;
  429.     int i;
  430.     if (opernest < 6) error(errstackunderflow);
  431.     token1 = &operstack[opernest - 6];
  432.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  433.     ppoint = &point[0];
  434.     i = 3;
  435.     while (i--)
  436.     {   ppoint->type = ptcurve;
  437.         if      (token1->type == typeint)
  438.             ppoint->x = token1->value.ival;
  439.         else if (token1->type == typereal)
  440.             ppoint->x = token1->value.rval;
  441.         else
  442.             error(errtypecheck);
  443.         token1++;
  444.         if      (token1->type == typeint)
  445.             ppoint->y = token1->value.ival;
  446.         else if (token1->type == typereal)
  447.             ppoint->y = token1->value.rval;
  448.         else
  449.             error(errtypecheck);
  450.         token1++;
  451.         transform(ppoint, gstate.ctm);
  452.         ppoint++;
  453.     }
  454.     checkpathsize(gstate.pathend + 3);
  455.     ppoint = &patharray[gstate.pathend];
  456.     ppoint[0] = point[0];
  457.     ppoint[1] = point[1];
  458.     ppoint[2] = point[2];
  459.     gstate.pathend += 3;
  460.     opernest -= 6;
  461. }
  462.  
  463. /* definefont */
  464.  
  465. void opdefinefont(void)
  466. {   struct object *token1, *token2;
  467.     if (opernest < 2) error(errstackunderflow);
  468.     token2 = &operstack[opernest - 1];
  469.     token1 = token2 - 1;
  470.     if (token2->type != typedict) error(errtypecheck);
  471.     definefont(token1, token2);
  472.     *token1 = *token2;
  473.     opernest -= 1;
  474. }
  475.  
  476. /* eoclip */
  477.  
  478. void opeoclip(void)
  479. {   closepath(ptclosei);
  480.     flattenpath();
  481.     clip(1);
  482. }
  483.  
  484. /* eofill */
  485.  
  486. void opeofill(void)
  487. {   if (istate.flags & intchar)
  488.     {   if      (istate.type < 2)
  489.         {   charpath();
  490.             return;
  491.         }
  492.         else if (istate.type == 2 && !gstate.cacheflag)
  493.         {   gstate.pathend = gstate.pathbeg;
  494.             return;
  495.         }
  496.     }
  497.     closepath(ptclosei);
  498.     flattenpath();
  499.     setupfill();
  500.     fill(gstate.pathbeg, gstate.pathend, 1);
  501.     gstate.pathend = gstate.pathbeg;
  502. }
  503.  
  504. /* erasepage */
  505.  
  506. void operasepage(void)
  507. {   erasepage();
  508. }
  509.  
  510. /* findfont */
  511.  
  512. void opfindfont(void)
  513. {   struct object token, *token1;
  514.     if (opernest < 1) error(errstackunderflow);
  515.     token1 = &operstack[opernest - 1];
  516.     findfont(token1, &token);
  517.     *token1 = token;
  518. }
  519.  
  520. /* fill */
  521.  
  522. void opfill(void)
  523. {   if (istate.flags & intchar)
  524.     {   if      (istate.type < 2)
  525.         {   charpath();
  526.             return;
  527.         }
  528.         else if (istate.type == 2 && !gstate.cacheflag)
  529.         {   gstate.pathend = gstate.pathbeg;
  530.             return;
  531.         }
  532.     }
  533.     closepath(ptclosei);
  534.     flattenpath();
  535.     setupfill();
  536.     fill(gstate.pathbeg, gstate.pathend, -1);
  537.     gstate.pathend = gstate.pathbeg;
  538. }
  539.  
  540. /* flattenpath */
  541.  
  542. void opflattenpath(void)
  543. {   flattenpath();
  544. }
  545.  
  546. /* image */
  547.  
  548. void opimage(void)
  549. {   struct object *token1, *token2, *token3, *token4, *token5;
  550.     float matrix[6];
  551.     int width, height, bps;
  552.     if (gstate.cacheflag) error(errundefined);
  553.     if (opernest < 5) error(errstackunderflow);
  554.     token5 = &operstack[opernest - 1];
  555.     token4 = token5 - 1;
  556.     token3 = token4 - 1;
  557.     token2 = token3 - 1;
  558.     token1 = token2 - 1;
  559.     if (token1->type != typeint) error(errtypecheck);
  560.     width = token1->value.ival;
  561.     if (width <= 0) error(errrangecheck);
  562.     if (token2->type != typeint) error(errtypecheck);
  563.     height = token2->value.ival;
  564.     if (height <= 0) error(errrangecheck);
  565.     if (token3->type != typeint) error(errtypecheck);
  566.     bps = token3->value.ival;
  567.     if (bps != 1 && bps != 2 && bps != 4 && bps != 8) error(errrangecheck);
  568.     if (token4->type != typearray) error(errtypecheck);
  569.     if (token4->length != 6) error(errrangecheck);
  570.     if (token4->flags & flagrprot) error(errinvalidaccess);
  571.     getmatrix(token4->value.vref, matrix);
  572.     if (token5->type != typearray && token5->type != typepacked)
  573.         error(errtypecheck);
  574.     image(width, height, bps, matrix, -1, 1, 1, token5);
  575.     opernest -= 5;
  576. }
  577.  
  578. /* imagemask */
  579.  
  580. void opimagemask(void)
  581. {   struct object *token1, *token2, *token3, *token4, *token5;
  582.     float matrix[6];
  583.     int width, height, mode;
  584.     if (opernest < 5) error(errstackunderflow);
  585.     token5 = &operstack[opernest - 1];
  586.     token4 = token5 - 1;
  587.     token3 = token4 - 1;
  588.     token2 = token3 - 1;
  589.     token1 = token2 - 1;
  590.     if (token1->type != typeint) error(errtypecheck);
  591.     width = token1->value.ival;
  592.     if (width <= 0) error(errrangecheck);
  593.     if (token2->type != typeint) error(errtypecheck);
  594.     height = token2->value.ival;
  595.     if (height <= 0) error(errrangecheck);
  596.     if (token3->type != typebool) error(errtypecheck);
  597.     mode = token3->value.ival;
  598.     if (token4->type != typearray) error(errtypecheck);
  599.     if (token4->length != 6) error(errrangecheck);
  600.     if (token4->flags & flagrprot) error(errinvalidaccess);
  601.     getmatrix(token4->value.vref, matrix);
  602.     if (token5->type != typearray && token5->type != typepacked)
  603.         error(errtypecheck);
  604.     image(width, height, 1, matrix, mode, 1, 1, token5);
  605.     opernest -= 5;
  606. }
  607.  
  608. /* initclip */
  609.  
  610. void opinitclip(void)
  611. {   cliplength(0);
  612.     gstate.clipflag = 0;
  613. }
  614.  
  615. /* kshow */
  616.  
  617. void opkshow(void)
  618. {   struct object *token1, *token2;
  619.     if (opernest < 2) error(errstackunderflow);
  620.     token2 = &operstack[opernest - 1];
  621.     token1 = token2 - 1;
  622.     if (token1->type != typearray && token1->type != typepacked)
  623.         error(errtypecheck);
  624.     if (token2->type != typestring) error(errtypecheck);
  625.     if (token2->flags & flagrprot) error(errinvalidaccess);
  626.     show(token2, 3, NULL, -1, token1);
  627.     opernest -= 2;
  628. }
  629.  
  630. /* lineto */
  631.  
  632. void oplineto(void)
  633. {   struct object *token1, *token2;
  634.     struct point point;
  635.     if (opernest < 2) error(errstackunderflow);
  636.     token2 = &operstack[opernest - 1];
  637.     token1 = token2 - 1;
  638.     point.type = ptline;
  639.     if      (token1->type == typeint)
  640.         point.x = token1->value.ival;
  641.     else if (token1->type == typereal)
  642.         point.x = token1->value.rval;
  643.     else
  644.         error(errtypecheck);
  645.     if      (token2->type == typeint)
  646.         point.y = token2->value.ival;
  647.     else if (token2->type == typereal)
  648.         point.y = token2->value.rval;
  649.     else
  650.         error(errtypecheck);
  651.     transform(&point, gstate.ctm);
  652.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  653.     checkpathsize(gstate.pathend + 1);
  654.     patharray[gstate.pathend++] = point;
  655.     opernest -= 2;
  656. }
  657.  
  658. /* makefont */
  659.  
  660. void opmakefont(void)
  661. {   struct object *token1, *token2;
  662.     float matrix[6];
  663.     if (opernest < 2) error(errstackunderflow);
  664.     token2 = &operstack[opernest - 1];
  665.     token1 = token2 - 1;
  666.     if (token1->type != typedict) error(errtypecheck);
  667.     if (token2->type != typearray) error(errtypecheck);
  668.     if (token2->length != 6) error(errrangecheck);
  669.     if (token2->flags & flagrprot) error(errinvalidaccess);
  670.     getmatrix(token2->value.vref, matrix);
  671.     makefont(token1, matrix);
  672.     opernest -= 1;
  673. }
  674.  
  675. /* moveto */
  676.  
  677. void opmoveto(void)
  678. {   struct object *token1, *token2;
  679.     struct point point;
  680.     if (opernest < 2) error(errstackunderflow);
  681.     token2 = &operstack[opernest - 1];
  682.     token1 = token2 - 1;
  683.     point.type = ptmove;
  684.     if      (token1->type == typeint)
  685.         point.x = token1->value.ival;
  686.     else if (token1->type == typereal)
  687.         point.x = token1->value.rval;
  688.     else
  689.         error(errtypecheck);
  690.     if      (token2->type == typeint)
  691.         point.y = token2->value.ival;
  692.     else if (token2->type == typereal)
  693.         point.y = token2->value.rval;
  694.     else
  695.         error(errtypecheck);
  696.     transform(&point, gstate.ctm);
  697.     closepath(ptclosei);
  698.     if (gstate.pathbeg == gstate.pathend ||
  699.         patharray[gstate.pathend - 1].type != ptmove)
  700.         checkpathsize(gstate.pathend + 1);
  701.     else
  702.         gstate.pathend--;
  703.     patharray[gstate.pathend++] = point;
  704.     opernest -= 2;
  705. }
  706.  
  707. /* newpath */
  708.  
  709. void opnewpath(void)
  710. {   gstate.pathend = gstate.pathbeg;
  711. }
  712.  
  713. /* nulldevice */
  714.  
  715. void opnulldevice(void)
  716. {   nulldevice();
  717. }
  718.  
  719. /* pathbbox */
  720.  
  721. void oppathbbox(void)
  722. {   struct object token, *token1;
  723.     struct point point, *ppoint, box[4], ll, ur;
  724.     int len;
  725.     if (opernest + 4 > operstacksize) error(errstackoverflow);
  726.     token1 = &operstack[opernest];
  727.     len = gstate.pathend - gstate.pathbeg;
  728.     if (len == 0) error(errnocurrentpoint);
  729.     len--;
  730.     ppoint = &patharray[gstate.pathbeg];
  731.     ll = ur = *ppoint++;
  732.     while (len--)
  733.     {   point = *ppoint++;
  734.         if (len != 0 || point.type != ptmove)
  735.         {   if (point.x < ll.x) ll.x = point.x;
  736.             if (point.x > ur.x) ur.x = point.x;
  737.             if (point.y < ll.y) ll.y = point.y;
  738.             if (point.y > ur.y) ur.y = point.y;
  739.         }
  740.     }
  741.     itransform(&ll, gstate.ctm);
  742.     itransform(&ur, gstate.ctm);
  743.     box[0].x = box[3].x = ll.x;
  744.     box[1].x = box[2].x = ur.x;
  745.     box[0].y = box[1].y = ll.y;
  746.     box[2].y = box[3].y = ur.y;
  747.     ll = ur = box[0];
  748.     ppoint = &box[1];
  749.     len = 4;
  750.     while (--len)
  751.     {   point = *ppoint++;
  752.         if (point.x < ll.x) ll.x = point.x;
  753.         if (point.x > ur.x) ur.x = point.x;
  754.         if (point.y < ll.y) ll.y = point.y;
  755.         if (point.y > ur.y) ur.y = point.y;
  756.     }
  757.     token.type = typereal;
  758.     token.flags = 0;
  759.     token.length = 0;
  760.     token.value.rval = ll.x;
  761.     token1[0] = token;
  762.     token.value.rval = ll.y;
  763.     token1[1] = token;
  764.     token.value.rval = ur.x;
  765.     token1[2] = token;
  766.     token.value.rval = ur.y;
  767.     token1[3] = token;
  768.     opernest += 4;
  769. }
  770.  
  771. /* pathforall */
  772.  
  773. void oppathforall(void)
  774. {   struct object token, *token1, *tokenx;
  775.     struct point point, *ppoint;
  776.     int i, p;
  777.     if (currtoken->flags & flagctrl)
  778.     {   tokenx = &execstack[execnest - 2];
  779.         for (;;)
  780.         {   p = gstate.pathbeg + tokenx->value.ival;
  781.             if (p >= gstate.pathend)
  782.             {   execnest -= 6;
  783.                 return;
  784.             }
  785.             ppoint = &patharray[p];
  786.             if (ppoint->type != ptclosei) break;
  787.             tokenx->value.ival++;
  788.         }
  789.         if      (ppoint->type == ptmove)
  790.         {   i = 1;
  791.             tokenx->value.ival += 1;
  792.             tokenx -= 4;
  793.         }
  794.         else if (ppoint->type == ptline)
  795.         {   i = 1;
  796.             tokenx->value.ival += 1;
  797.             tokenx -= 3;
  798.         }
  799.         else if (ppoint->type == ptcurve)
  800.         {   i = 3;
  801.             tokenx->value.ival += 3;
  802.             tokenx -= 2;
  803.         }
  804.         else
  805.         {   i = 0;
  806.             tokenx->value.ival += 1;
  807.             tokenx -= 1;
  808.         }
  809.         if (opernest + i + i > operstacksize) error(errstackoverflow);
  810.         token1 = &operstack[opernest];
  811.         token.type = typereal;
  812.         token.flags = 0;
  813.         token.length = 0;
  814.         while (i--)
  815.         {   point = *ppoint++;
  816.             itransform(&point, gstate.ctm);
  817.             token.value.rval = point.x;
  818.             token1[0] = token;
  819.             token.value.rval = point.y;
  820.             token1[1] = token;
  821.             token1 += 2;
  822.             opernest += 2;
  823.         }
  824.         execstack[execnest++] = *tokenx;
  825.     }
  826.     else
  827.     {   if (opernest < 4) error(errstackunderflow);
  828.         token1 = &operstack[opernest];
  829.         i = 4;
  830.         while (i--)
  831.         {   token1--;
  832.             if (token1->type != typearray && token1->type != typepacked)
  833.                 error(errtypecheck);
  834.         }
  835.         if (execnest + 7 > execstacksize) error(errexecstackoverflow);
  836.         tokenx = &execstack[execnest];
  837.         tokenx[0] = *token1++;
  838.         tokenx[1] = *token1++;
  839.         tokenx[2] = *token1++;
  840.         tokenx[3] = *token1;
  841.         token.type = typeint;
  842.         token.flags = 0;
  843.         token.length = 0;
  844.         token.value.ival = 0;
  845.         tokenx[4] = token;
  846.         token = *currtoken;
  847.         token.flags &= ~flagexec;
  848.         token.flags |= flagctrl | flagloop;
  849.         token.length = 6;
  850.         tokenx[5] = token;
  851.         execnest += 6;
  852.         opernest -= 4;
  853.     }
  854. }
  855.  
  856. /* rcurveto */
  857.  
  858. void oprcurveto(void)
  859. {   struct object *token1;
  860.     struct point point[3], *ppoint;
  861.     float x, y;
  862.     int i;
  863.     if (opernest < 6) error(errstackunderflow);
  864.     token1 = &operstack[opernest - 6];
  865.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  866.     ppoint = &patharray[gstate.pathend - 1];
  867.     x = ppoint->x;
  868.     y = ppoint->y;
  869.     ppoint = &point[0];
  870.     i = 3;
  871.     while (i--)
  872.     {   ppoint->type = ptcurve;
  873.         if      (token1->type == typeint)
  874.             ppoint->x = token1->value.ival;
  875.         else if (token1->type == typereal)
  876.             ppoint->x = token1->value.rval;
  877.         else
  878.             error(errtypecheck);
  879.         token1++;
  880.         if      (token1->type == typeint)
  881.             ppoint->y = token1->value.ival;
  882.         else if (token1->type == typereal)
  883.             ppoint->y = token1->value.rval;
  884.         else
  885.             error(errtypecheck);
  886.         dtransform(ppoint, gstate.ctm);
  887.         ppoint->x += x;
  888.         ppoint->y += y;
  889.         token1++;
  890.         ppoint++;
  891.     }
  892.     checkpathsize(gstate.pathend + 3);
  893.     ppoint = &patharray[gstate.pathend];
  894.     ppoint[0] = point[0];
  895.     ppoint[1] = point[1];
  896.     ppoint[2] = point[2];
  897.     gstate.pathend += 3;
  898.     opernest -= 6;
  899. }
  900.  
  901. /* reversepath */
  902.  
  903. void opreversepath(void)
  904. {   struct point point, *ppoint1, *ppoint2, *ppoint3;
  905.     int len;
  906.     len = gstate.pathend - gstate.pathbeg;
  907.     ppoint1 = &patharray[gstate.pathbeg];
  908.  
  909.     /* While we have any subpaths left ... */
  910.  
  911.     while (len != 0)
  912.     {   ppoint2 = ppoint1;
  913.  
  914.         /* Scan to the end of the subpath.  If we get to a close then reset
  915.          * its coordinates to the end of the path.  For other cases we copy
  916.          * the type to the previous point - as the type is at the END of
  917.          * the line or curve. */
  918.  
  919.         for (;;)
  920.         {   len--;
  921.             if (ppoint1->type == ptclosex || ppoint1->type == ptclosei)
  922.             {   ppoint1->x = (ppoint1 - 1)->x;
  923.                 ppoint1->y = (ppoint1 - 1)->y;
  924.                 break;
  925.             }
  926.             if (ppoint1 != ppoint2)
  927.                 (ppoint1 - 1)->type = ppoint1->type;
  928.             ppoint1++;
  929.             if (len == 0)
  930.                 break;
  931.         }
  932.  
  933.         /* Now reverse the contents of the subpath.  Make the (new) first
  934.          * element a move. */
  935.  
  936.         ppoint3 = ppoint1 - 1;
  937.         ppoint3->type = ptmove;
  938.         while (ppoint2 < ppoint3)
  939.         {   point = *ppoint2;
  940.             *ppoint2 = *ppoint3;
  941.             *ppoint3 = point;
  942.             ppoint2++;
  943.             ppoint3--;
  944.         }
  945.  
  946.         /* Continue with next subpath. */
  947.  
  948.         ppoint1++;
  949.     }
  950. }
  951.  
  952. /* rlineto */
  953.  
  954. void oprlineto(void)
  955. {   struct object *token1, *token2;
  956.     struct point point, *ppoint;
  957.     if (opernest < 2) error(errstackunderflow);
  958.     token2 = &operstack[opernest - 1];
  959.     token1 = token2 - 1;
  960.     point.type = ptline;
  961.     if      (token1->type == typeint)
  962.         point.x = token1->value.ival;
  963.     else if (token1->type == typereal)
  964.         point.x = token1->value.rval;
  965.     else
  966.         error(errtypecheck);
  967.     if      (token2->type == typeint)
  968.         point.y = token2->value.ival;
  969.     else if (token2->type == typereal)
  970.         point.y = token2->value.rval;
  971.     else
  972.         error(errtypecheck);
  973.     dtransform(&point, gstate.ctm);
  974.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  975.     ppoint = &patharray[gstate.pathend - 1];
  976.     point.x += ppoint->x;
  977.     point.y += ppoint->y;
  978.     checkpathsize(gstate.pathend + 1);
  979.     patharray[gstate.pathend++] = point;
  980.     opernest -= 2;
  981. }
  982.  
  983. /* rmoveto */
  984.  
  985. void oprmoveto(void)
  986. {   struct object *token1, *token2;
  987.     struct point point, *ppoint;
  988.     if (opernest < 2) error(errstackunderflow);
  989.     token2 = &operstack[opernest - 1];
  990.     token1 = token2 - 1;
  991.     point.type = ptmove;
  992.     if      (token1->type == typeint)
  993.         point.x = token1->value.ival;
  994.     else if (token1->type == typereal)
  995.         point.x = token1->value.rval;
  996.     else
  997.         error(errtypecheck);
  998.     if      (token2->type == typeint)
  999.         point.y = token2->value.ival;
  1000.     else if (token2->type == typereal)
  1001.         point.y = token2->value.rval;
  1002.     else
  1003.         error(errtypecheck);
  1004.     dtransform(&point, gstate.ctm);
  1005.     if (gstate.pathbeg == gstate.pathend) error(errnocurrentpoint);
  1006.     ppoint = &patharray[gstate.pathend - 1];
  1007.     point.x += ppoint->x;
  1008.     point.y += ppoint->y;
  1009.     closepath(ptclosei);
  1010.     if (patharray[gstate.pathend - 1].type != ptmove)
  1011.         checkpathsize(gstate.pathend + 1);
  1012.     else
  1013.         gstate.pathend--;
  1014.     patharray[gstate.pathend++] = point;
  1015.     opernest -= 2;
  1016. }
  1017.  
  1018. /* scalefont */
  1019.  
  1020. void opscalefont(void)
  1021. {   struct object *token1, *token2;
  1022.     float matrix[6], scale;
  1023.     if (opernest < 2) error(errstackunderflow);
  1024.     token2 = &operstack[opernest - 1];
  1025.     token1 = token2 - 1;
  1026.     if (token1->type != typedict) error(errtypecheck);
  1027.     if      (token2->type == typeint)
  1028.         scale = token2->value.ival;
  1029.     else if (token2->type == typereal)
  1030.         scale = token2->value.rval;
  1031.     else
  1032.         error(errtypecheck);
  1033.     matrix[1] = matrix[2] = matrix[4] = matrix[5] = 0.0;
  1034.     matrix[0] = matrix[3] = scale;
  1035.     makefont(token1, matrix);
  1036.     opernest -= 1;
  1037. }
  1038.  
  1039. /* setband */
  1040.  
  1041. void opsetband(void)
  1042. {   struct object *token1;
  1043.     int base;
  1044.     if (opernest < 1) error(errstackunderflow);
  1045.     token1 = &operstack[opernest - 1];
  1046.     if (token1->type != typeint) error(errtypecheck);
  1047.     base = token1->value.ival;
  1048.     if (base < 0 || base >= page.yheight)
  1049.         error(errrangecheck);
  1050.     page.ybase = base;
  1051.     setdevice(&page);
  1052.     opernest--;
  1053. }
  1054.  
  1055. /* setcachedevice */
  1056.  
  1057. void opsetcachedevice(void)
  1058. {   struct object *token1;
  1059.     struct point point, width[5], ll, ur;
  1060.     int i;
  1061.     if (opernest < 6) error(errstackunderflow);
  1062.     token1 = &operstack[opernest - 6];
  1063.     for (i = 0; i < 3; i++)
  1064.     {   if      (token1->type == typeint)
  1065.             width[i].x = token1->value.ival;
  1066.         else if (token1->type == typereal)
  1067.             width[i].x = token1->value.rval;
  1068.         else
  1069.             error(errtypecheck);
  1070.         token1++;
  1071.         if      (token1->type == typeint)
  1072.             width[i].y = token1->value.ival;
  1073.         else if (token1->type == typereal)
  1074.             width[i].y = token1->value.rval;
  1075.         else
  1076.             error(errtypecheck);
  1077.         token1++;
  1078.     }
  1079.     width[3].x = width[1].x;
  1080.     width[3].y = width[2].y;
  1081.     width[4].x = width[2].x;
  1082.     width[4].y = width[1].y;
  1083.     for (i = 0; i < 5; i++)
  1084.         dtransform(&width[i], gstate.ctm);
  1085.     setcharwidth(&width[0]);
  1086.     if (istate.type >= 2)
  1087.     {   ll = ur = width[1];
  1088.         for (i = 2; i < 5; i++)
  1089.         {   point = width[i];
  1090.             if (point.x < ll.x) ll.x = point.x;
  1091.             if (point.x > ur.x) ur.x = point.x;
  1092.             if (point.y < ll.y) ll.y = point.y;
  1093.             if (point.y > ur.y) ur.y = point.y;
  1094.         }
  1095.         setcachedevice(&ll, &ur, 3);
  1096.     }
  1097.     opernest -= 6;
  1098. }
  1099.  
  1100. /* setcachelimit */
  1101.  
  1102. void opsetcachelimit(void)
  1103. {   struct object *token1;
  1104.     int limit;
  1105.     if (opernest < 1) error(errstackunderflow);
  1106.     token1 = &operstack[opernest - 1];
  1107.     if      (token1->type == typeint)
  1108.         limit = token1->value.ival;
  1109.     else if (token1->type == typereal)
  1110.         limit = itrunc(token1->value.rval);
  1111.     else
  1112.         error(errtypecheck);
  1113.     if (limit > fclen)
  1114.         fclimit = fclen;
  1115.     else
  1116.         fclimit = limit;
  1117.     opernest -= 1;
  1118. }
  1119.  
  1120. /* setcharwidth */
  1121.  
  1122. void opsetcharwidth(void)
  1123. {   struct object *token1, *token2;
  1124.     struct point width;
  1125.     if (opernest < 2) error(errstackunderflow);
  1126.     token2 = &operstack[opernest - 1];
  1127.     token1 = token2 - 1;
  1128.     if      (token1->type == typeint)
  1129.         width.x = token1->value.ival;
  1130.     else if (token1->type == typereal)
  1131.         width.x = token1->value.rval;
  1132.     else
  1133.         error(errtypecheck);
  1134.     token1++;
  1135.     if      (token1->type == typeint)
  1136.         width.y = token1->value.ival;
  1137.     else if (token1->type == typereal)
  1138.         width.y = token1->value.rval;
  1139.     else
  1140.         error(errtypecheck);
  1141.     dtransform(&width, gstate.ctm);
  1142.     setcharwidth(&width);
  1143.     opernest -= 2;
  1144. }
  1145.  
  1146. /* setfont */
  1147.  
  1148. void opsetfont(void)
  1149. {   struct object *token1;
  1150.     if (opernest < 1) error(errstackunderflow);
  1151.     token1 = &operstack[opernest - 1];
  1152.     if (token1->type != typedict) error(errtypecheck);
  1153.     setfont(token1);
  1154.     opernest -= 1;
  1155. }
  1156.  
  1157. /* show */
  1158.  
  1159. void opshow(void)
  1160. {   struct object *token1;
  1161.     if (opernest < 1) error(errstackunderflow);
  1162.     token1 = &operstack[opernest - 1];
  1163.     if (token1->type != typestring) error(errtypecheck);
  1164.     if (token1->flags & flagrprot) error(errinvalidaccess);
  1165.     show(token1, 3, NULL, -1, NULL);
  1166.     opernest -= 1;
  1167. }
  1168.  
  1169. /* showpage */
  1170.  
  1171. void opshowpage(void)
  1172. {   struct object token;
  1173.     int num = 1;
  1174.     if (istate.flags & intgraph) error(errundefined);
  1175.     if (gstate.dev.depth != 0)
  1176.     {   if (dictfind(&copies, &token) != -1)
  1177.         {   if (token.type != typeint) error(errtypecheck);
  1178.             num = token.value.ival;
  1179.             if (num < 0) error(errrangecheck);
  1180.         }
  1181.         copypage(num);
  1182.         erasepage();
  1183.     }
  1184.     initgraphics();
  1185. }
  1186.  
  1187. /* stringwidth */
  1188.  
  1189. void opstringwidth(void)
  1190. {   struct object token, *token1;
  1191.     struct point width;
  1192.     if (opernest < 1) error(errstackunderflow);
  1193.     if (opernest + 1 > operstacksize) error(errstackoverflow);
  1194.     token1 = &operstack[opernest - 1];
  1195.     if (token1->type != typestring) error(errtypecheck);
  1196.     if (token1->flags & flagrprot) error(errinvalidaccess);
  1197.     show(token1, 2, &width, -1, NULL);
  1198.     idtransform(&width, gstate.ctm);
  1199.     token.type = typereal;
  1200.     token.flags = 0;
  1201.     token.length = 0;
  1202.     token.value.rval = width.x;
  1203.     token1[0] = token;
  1204.     token.value.rval = width.y;
  1205.     token1[1] = token;
  1206.     opernest += 1;
  1207. }
  1208.  
  1209. /* stroke */
  1210.  
  1211. void opstroke(void)
  1212. {   if (istate.flags & intchar)
  1213.     {   if      (istate.type == 0)
  1214.         {   charpath();
  1215.             return;
  1216.         }
  1217.         else if (istate.type == 1)
  1218.         {   flattenpath();
  1219.             strokepath(0);
  1220.             charpath();
  1221.             return;
  1222.         }
  1223.         else if (istate.type == 2 && !gstate.cacheflag)
  1224.         {   gstate.pathend = gstate.pathbeg;
  1225.             return;
  1226.         }
  1227.     }
  1228.     flattenpath();
  1229.     setupfill();
  1230.     strokepath(1);
  1231.     gstate.pathend = gstate.pathbeg;
  1232. }
  1233.  
  1234. /* strokepath */
  1235.  
  1236. void opstrokepath(void)
  1237. {   flattenpath();
  1238.     strokepath(0);
  1239. }
  1240.  
  1241. /* widthshow */
  1242.  
  1243. void opwidthshow(void)
  1244. {   struct object *token1, *token2, *token3, *token4;
  1245.     struct point width[2];
  1246.     int wchar;
  1247.     if (opernest < 4) error(errstackunderflow);
  1248.     token4 = &operstack[opernest - 1];
  1249.     token3 = token4 - 1;
  1250.     token2 = token3 - 1;
  1251.     token1 = token2 - 1;
  1252.     if      (token1->type == typeint)
  1253.         width[0].x = token1->value.ival;
  1254.     else if (token1->type == typereal)
  1255.         width[0].x = token1->value.rval;
  1256.     else
  1257.         error(errtypecheck);
  1258.     if      (token2->type == typeint)
  1259.         width[0].y = token2->value.ival;
  1260.     else if (token2->type == typereal)
  1261.         width[0].y = token2->value.rval;
  1262.     else
  1263.         error(errtypecheck);
  1264.     dtransform(&width[0], gstate.ctm);
  1265.     if (token3->type != typeint) error(errtypecheck);
  1266.     wchar = token3->value.ival;
  1267.     if (wchar < 0 || wchar > 255) error(errrangecheck);
  1268.     width[1].x = width[1].y = 0.0;
  1269.     if (token4->type != typestring) error(errtypecheck);
  1270.     if (token4->flags & flagrprot) error(errinvalidaccess);
  1271.     show(token4, 3, width, wchar, NULL);
  1272.     opernest -= 4;
  1273. }
  1274.  
  1275. /* Initialise the operators (4) */
  1276.  
  1277. void initop4(void)
  1278. {   systemop(oparc,              "arc");
  1279.     systemop(oparcn,             "arcn");
  1280.     systemop(oparcto,            "arcto");
  1281.     systemop(opashow,            "ashow");
  1282.     systemop(opawidthshow,       "awidthshow");
  1283.     systemop(opcachestatus,      "cachestatus");
  1284.     systemop(opcharpath,         "charpath");
  1285.     systemop(opclip,             "clip");
  1286.     systemop(opclippath,         "clippath");
  1287.     systemop(opclosepath,        "closepath");
  1288.     systemop(opcolorimage,       "colorimage");
  1289.     systemop(opcopypage,         "copypage");
  1290.     systemop(opcurrentband,      "currentband");
  1291.     systemop(opcurrentfont,      "currentfont");
  1292.     systemop(opcurrentpoint,     "currentpoint");
  1293.     systemop(opcurveto,          "curveto");
  1294.     systemop(opdefinefont,       "definefont");
  1295.     systemop(opeoclip,           "eoclip");
  1296.     systemop(opeofill,           "eofill");
  1297.     systemop(operasepage,        "erasepage");
  1298.     systemop(opfill,             "fill");
  1299.     systemop(opfindfont,         "findfont");
  1300.     systemop(opflattenpath,      "flattenpath");
  1301.     systemop(opimage,            "image");
  1302.     systemop(opimagemask,        "imagemask");
  1303.     systemop(opinitclip,         "initclip");
  1304.     systemop(opkshow,            "kshow");
  1305.     systemop(oplineto,           "lineto");
  1306.     systemop(opmakefont,         "makefont");
  1307.     systemop(opmoveto,           "moveto");
  1308.     systemop(opnewpath,          "newpath");
  1309.     systemop(opnulldevice,       "nulldevice");
  1310.     systemop(oppathbbox,         "pathbbox");
  1311.     systemop(oppathforall,       "pathforall");
  1312.     systemop(oprcurveto,         "rcurveto");
  1313.     systemop(opreversepath,      "reversepath");
  1314.     systemop(oprlineto,          "rlineto");
  1315.     systemop(oprmoveto,          "rmoveto");
  1316.     systemop(opscalefont,        "scalefont");
  1317.     systemop(opsetband,          "setband");
  1318.     systemop(opsetcachedevice,   "setcachedevice");
  1319.     systemop(opsetcachelimit,    "setcachelimit");
  1320.     systemop(opsetcharwidth,     "setcharwidth");
  1321.     systemop(opsetfont,          "setfont");
  1322.     systemop(opshow,             "show");
  1323.     systemop(opshowpage,         "showpage");
  1324.     systemop(opstringwidth,      "stringwidth");
  1325.     systemop(opstroke,           "stroke");
  1326.     systemop(opstrokepath,       "strokepath");
  1327.     systemop(opwidthshow,        "widthshow");
  1328. }
  1329.  
  1330. /* End of file "postop4.c" */
  1331.