home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / MPW / SendPS / sendps.c < prev   
Encoding:
C/C++ Source or Header  |  1991-08-05  |  6.1 KB  |  245 lines  |  [TEXT/MPS ]
  1. /*
  2.        File Name:    sendps.c
  3.   
  4.      Description:    PostScript communication MPW Tool
  5.           Author:    Amanda Walker
  6.  */
  7.  
  8. #include <stdio.h>
  9. #include <setjmp.h>
  10. #include <signal.h>
  11. #include <Resources.h>
  12. #include <Memory.h>
  13. #include <CursorCtl.h>
  14. #include <ErrMgr.h>
  15. #include <PrintTraps.h>
  16.  
  17. Handle PAP = 0L;
  18.  
  19. Handle PAPLoad()
  20. {
  21.     static Handle entity;
  22.     short i;
  23.  
  24.     if (PAP) return entity;    /* already loaded */
  25.     PrOpen();
  26.     if (!(PAP = GetResource('PDEF' ,10))) {
  27.         PrClose();
  28.         return 0L;
  29.     }
  30.     HLock(PAP);
  31.     DetachResource(PAP);
  32.     entity = GetResource('PAPA', 0xE000);
  33.     HLock(entity);
  34.     DetachResource(entity);
  35.     PrClose();
  36.     return entity;
  37. }
  38.  
  39. pascal short _PAPOpen(short *refNum, Ptr PrinterName, short FlowQuantum,
  40.                       Ptr StatusBuff, short *CompState, Ptr coderesource)
  41.     = { 0x205F, 0x4E90 };
  42.  
  43. short PAPOpen(refNum, PrinterName, FlowQuantum, StatusBuff, CompState)
  44. short *refNum;
  45. Ptr PrinterName;
  46. short FlowQuantum;
  47. Ptr StatusBuff;
  48. short *CompState;
  49. {
  50.     return _PAPOpen(refNum, PrinterName, FlowQuantum,
  51.                     StatusBuff, CompState, *PAP);
  52. }
  53.  
  54. pascal short _PAPRead(short refNum, Ptr ReadBuff, short *DataSize, short *eof,
  55.                       short *CompState, Ptr coderesource)
  56.     = { 0x205F, 0x4E90 };
  57.  
  58. short PAPRead(refNum, ReadBuff, DataSize, eof, CompState)
  59. short refNum;
  60. Ptr ReadBuff;
  61. short *DataSize;
  62. short *eof;
  63. short *CompState;
  64. {
  65.     return _PAPRead(refNum, ReadBuff, DataSize, eof, CompState, *PAP+4);
  66. }
  67.  
  68. pascal short _PAPWrite(short refNum, Ptr ReadBuff, short DataSize, short eof,
  69.                        short *CompState, Ptr coderesource)
  70.     = { 0x205F, 0x4E90 };
  71.  
  72. short PAPWrite(refNum, WriteBuff, DataSize, eof, CompState)
  73. short refNum;
  74. Ptr WriteBuff;
  75. short DataSize;
  76. short eof;
  77. short *CompState;
  78. {
  79.     return _PAPWrite(refNum, WriteBuff, DataSize, eof, CompState, *PAP+8);
  80. }
  81.  
  82. pascal short _PAPStatus(Ptr PrinterName, Ptr StatusBuff, Ptr coderesource)
  83.     = { 0x205F, 0x4E90 };
  84.  
  85. short PAPStatus(PrinterName, StatusBuff)
  86. Ptr PrinterName;
  87. Ptr StatusBuff;
  88. {
  89.     return _PAPStatus(PrinterName, StatusBuff, *PAP+12);
  90. }
  91.  
  92. pascal short _PAPClose(short refNum, Ptr coderesource)
  93.     = { 0x205F, 0x4E90 };
  94.  
  95. short PAPClose(refNum)
  96. short refNum;
  97. {
  98.     return _PAPClose(refNum, *PAP+16);
  99. }
  100.  
  101.  
  102. pascal short _PAPUnload(Ptr coderesource)
  103.     = { 0x205F, 0x4E90 };
  104.  
  105. short PAPUnload()
  106. {
  107.     short res;
  108.  
  109.     res = _PAPUnload(*PAP+20);
  110.     DisposHandle(PAP);
  111.     PAP = 0L;
  112.     return res;
  113. }
  114.  
  115. volatile short interrupted;
  116.  
  117. void catchInterrupt()
  118. {
  119.     interrupted = 1;
  120.     signal(SIGINT, (void *) catchInterrupt);
  121. }
  122.  
  123. main(int argc, char **argv)
  124. {
  125.     Handle lwname;
  126.     int fd, i;
  127.     char wbuffer[4096], rbuffer[4096], status[2048];
  128.     short rcnt, wcnt, reof;
  129.     short wstate, rstate;
  130.     char msg[256];
  131.     short refNum;
  132.  
  133.     if (argc != 2) {
  134.         fprintf(stderr, "### usage: %s filename\n", argv[0]);
  135.         exit(1);
  136.     }
  137.     lwname = PAPLoad();
  138.     if (!lwname) {
  139.         fprintf(stderr, "### %s: can't find name of printer\n", argv[0]);
  140.         exit(1);
  141.     }
  142.     fd = open(argv[1], 0);
  143.     if (fd < 0) {
  144.         fprintf(stderr, "### %s: can't open '%s' for reading\n",
  145.                 argv[0], argv[1]);
  146.         exit(1);
  147.     }
  148.  
  149.     InitCursorCtl(NULL);
  150.     Show_Cursor(WATCH_CURSOR);
  151.     interrupted = 0;
  152.     signal(SIGINT, (void *) catchInterrupt);
  153.  
  154.     i = PAPOpen(&refNum, (Ptr) *lwname, 8, &status, &wstate);
  155.     if (i) {
  156.         fprintf(stderr, "### %s: %s\n", argv[0], GetSysErrText(i, msg));
  157.         PAPUnload();
  158.         exit(1);
  159.     }
  160.     while (wstate > 0);
  161.     if (wstate) {
  162.         fprintf(stderr, "### %s: %s\n", argv[0], GetSysErrText(wstate, msg));
  163.         PAPClose(refNum);
  164.         PAPUnload();
  165.         exit(1);
  166.     }
  167.     if (interrupted) {
  168.         fprintf(stderr, "### %s: interrupted\n", argv[0]);
  169.         PAPClose(refNum);
  170.         PAPUnload();
  171.         exit(1);
  172.     }
  173.     rcnt = sizeof(rbuffer);
  174.     reof = 0;
  175.     PAPRead(refNum, (Ptr) rbuffer, &rcnt, &reof, &rstate) ;
  176.     while (i = read(fd, (Ptr) wbuffer, sizeof(wbuffer))) {
  177.         wcnt = i;
  178.         RotateCursor(32);
  179.         PAPWrite(refNum, (Ptr) wbuffer, wcnt, 0, &wstate);
  180.         while (wstate > 0) {
  181.             if (rstate == 0) {
  182.                 for (i = 0; i < rcnt; i++)
  183.                     if (rbuffer[i] != '\012') putchar(rbuffer[i]);
  184.                 fflush(stdout);
  185.                 rcnt = sizeof(rbuffer);
  186.                 reof = 0;
  187.                 RotateCursor(-32);
  188.                 PAPRead(refNum, (Ptr) rbuffer, &rcnt, &reof, &rstate);
  189.             } else if (rstate < 0) {
  190.                 fprintf(stderr, "### %s: %s\n", argv[0],
  191.                         GetSysErrText(rstate, msg));
  192.                 PAPClose(refNum);
  193.                 PAPUnload();
  194.                 exit(1);
  195.             }
  196.             if (interrupted) {
  197.                 fprintf(stderr, "### %s: interrupted\n", argv[0]);
  198.                 PAPClose(refNum);
  199.                 PAPUnload();
  200.                 exit(1);
  201.             }
  202.         }
  203.         if (wstate < 0) {
  204.             fprintf(stderr, "### %s: %s\n", argv[0],
  205.                     GetSysErrText(wstate, msg));
  206.             PAPClose(refNum);
  207.             PAPUnload();
  208.             exit(1);
  209.         }
  210.     }
  211.     RotateCursor(32);
  212.     PAPWrite(refNum, (Ptr) "", 0, 1, &wstate);
  213.     for (;;) {
  214.         if (rstate == 0) {
  215.             for (i = 0; i < rcnt; i++)
  216.                 /* translate PS newlines to Mac newlines... */
  217.                 if (rbuffer[i] != '\012')
  218.                     putchar(rbuffer[i]);
  219.                 else
  220.                     putchar('\015');
  221.             fflush(stdout);
  222.             if (reof) break;
  223.             rcnt = sizeof(rbuffer);
  224.             reof = 0;
  225.             RotateCursor(-32);
  226.             PAPRead(refNum, (Ptr) rbuffer, &rcnt, &reof, &rstate);
  227.         } else if (rstate < 0) {
  228.             fprintf(stderr, "### %s: %s\n", argv[0],
  229.                     GetSysErrText(rstate, msg));
  230.             PAPClose(refNum);
  231.             PAPUnload();
  232.             exit(1);
  233.         }
  234.         if (interrupted) {
  235.             fprintf(stderr, "### %s: interrupted\n", argv[0]);
  236.             PAPClose(refNum);
  237.             PAPUnload();
  238.             exit(1);
  239.         }
  240.     }
  241.     PAPClose(refNum);
  242.     PAPUnload();
  243. }
  244.  
  245.