home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0010 - 0019 / ibm0010-0019 / ibm0010.tar / ibm0010 / PROCWRKB.ZIP / BENCH1.ZIP / PRINT / GETPRINT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-07  |  13.7 KB  |  530 lines
  1. /***( getprint.c )**************************************************************
  2. *                                                                              *
  3. *  Written:  Brent Faulkner - May 25, 1989                                     *
  4. *  Updated:  Brent Faulkner - June 13, 1989                                    *
  5. *                                                                              *
  6. ********************************************************************************
  7. *                                                                              *
  8. * Contents:    get_print() - get a prtcap entry                                *
  9. *                                                                              *
  10. *            open_prtcap() - open prtcap and find printer                      *
  11. *           close_prtcap() - close it                                          *
  12. *           next_prtline() - get next line from prtcap                         *
  13. *                 getdef() - translate a prtcap line                           *
  14. *                                                                              *
  15. *******************************************************************************/
  16. /* include files */
  17. #include <stdio.h>
  18. #include <bench.h>
  19. #include "prt.h"
  20.  
  21. /* define macros */
  22. #define isoctal(dig)    ((dig) >= '0' && (dig) <= '7')
  23.  
  24. /* global variables */
  25. char *prtdef[LAST] = { 0 };               /* table to hold prtcap entries */
  26. int sizdef[LAST] = { 0 };                 /* table of sizes of corresponding entries */
  27. FILE *prtfp = 0;                      /* stream for prtcap file */
  28.  
  29. char NotEnufMem[] = "Not enough memory for printer selection.";
  30.  
  31. /* function prototypes/declarations */
  32. static PROTO (void close_prtcap, (void));
  33. static PROTO (char *getdef, (char *, int *));
  34. static PROTO (int next_prtline, (char*));
  35. static PROTO (int open_prtcap, (char *));
  36.  
  37. /* structure definitions */
  38. struct tokstruct                  /* token structure */
  39. {
  40.     char *tokstring;              /* token */
  41.     int    defindex;                 /* index into prtcap table */
  42. };
  43.  
  44. /* initialize table of token structures */
  45. struct tokstruct token[] =
  46. {
  47.     { "NUM_LINES", NUM_LINES },
  48.     { "NUM_COLS", NUM_COLS },
  49.     { "BS", BS },
  50.     { "HT", HT },
  51.     { "FF", FORMFEED },
  52.     { "CR", CR },
  53.     { "SP", SP },
  54.     { "LF", LINEFEED },
  55.     { "ITALIC_ON", ITALIC_ON },
  56.     { "ITALIC_OFF", ITALIC_OFF },
  57.     { "BOLD_ON", BOLD_ON },
  58.     { "BOLD_OFF", BOLD_OFF },
  59.     { "UNDER_ON", UNDER_ON },
  60.     { "UNDER_OFF", UNDER_OFF },
  61.     { "LQ_ON", LQ_ON },
  62.     { "LQ_OFF", LQ_OFF },
  63.     { "PS_ON", PS_ON },
  64.     { "PS_OFF", PS_OFF },
  65.     { "SUBSCRIPT_ON", SUBSCRIPT_ON },
  66.     { "SUBSCRIPT_OFF", SUBSCRIPT_OFF },
  67.     { "SUPERSCRIPT_ON", SUPERSCRIPT_ON },
  68.     { "SUPERSCRIPT_OFF", SUPERSCRIPT_OFF },
  69.     { "DBL_WIDE_ON", DBL_WIDE_ON },
  70.     { "DBL_WIDE_OFF", DBL_WIDE_OFF },
  71.     { "DBL_HIGH_ON", DBL_HIGH_ON },
  72.     { "DBL_HIGH_OFF", DBL_HIGH_OFF },
  73.     { "CONDENSED_ON", CONDENSED_ON },
  74.     { "CONDENSED_OFF", CONDENSED_OFF },
  75.     { "BOX_ON", BOX_ON },
  76.     { "BOX_OFF", BOX_OFF },
  77.     { "SOLID_BLOCK", SOLID_BLOCK },
  78.     { "SHADE_BLOCK", SHADE_BLOCK },
  79.     { "BOT_BLOCK", BOT_BLOCK },
  80.     { "TOP_BLOCK", TOP_BLOCK },
  81.     { "BOX1_VERT", BOX1_VERT },
  82.     { "BOX1_HORIZ", BOX1_HORIZ },
  83.     { "BOX1_TOP_LFT", BOX1_TOP_LFT },
  84.     { "BOX1_TOP_RT", BOX1_TOP_RT },
  85.     { "BOX1_BOT_LFT", BOX1_BOT_LFT },
  86.     { "BOX1_BOT_RT", BOX1_BOT_RT },
  87.     { "BOX1_TOP_TEE", BOX1_TOP_TEE },
  88.     { "BOX1_BOT_TEE", BOX1_BOT_TEE },
  89.     { "BOX1_LFT_TEE", BOX1_LFT_TEE },
  90.     { "BOX1_RT_TEE", BOX1_RT_TEE },
  91.     { "BOX1_CROSS", BOX1_CROSS },
  92.     { "BOX2_VERT", BOX2_VERT },
  93.     { "BOX2_HORIZ", BOX2_HORIZ },
  94.     { "BOX2_TOP_LFT", BOX2_TOP_LFT },
  95.     { "BOX2_TOP_RT", BOX2_TOP_RT },
  96.     { "BOX2_BOT_LFT", BOX2_BOT_LFT },
  97.     { "BOX2_BOT_RT", BOX2_BOT_RT },
  98.     { "BOX2_TOP_TEE", BOX2_TOP_TEE },
  99.     { "BOX2_BOT_TEE", BOX2_BOT_TEE },
  100.     { "BOX2_LFT_TEE", BOX2_LFT_TEE },
  101.     { "BOX2_RT_TEE", BOX2_RT_TEE },
  102.     { "BOX2_CROSS", BOX2_CROSS },
  103.     { "BOX3_VERT", BOX3_VERT },
  104.     { "BOX3_HORIZ", BOX3_HORIZ },
  105.     { "BOX3_TOP_LFT", BOX3_TOP_LFT },
  106.     { "BOX3_TOP_RT", BOX3_TOP_RT },
  107.     { "BOX3_BOT_LFT", BOX3_BOT_LFT },
  108.     { "BOX3_BOT_RT", BOX3_BOT_RT },
  109.     { "BOX3_TOP_TEE", BOX3_TOP_TEE },
  110.     { "BOX3_BOT_TEE", BOX3_BOT_TEE },
  111.     { "BOX3_LFT_TEE", BOX3_LFT_TEE },
  112.     { "BOX3_RT_TEE", BOX3_RT_TEE },
  113.     { "BOX3_CROSS", BOX3_CROSS },
  114.     { "BOX4_VERT", BOX4_VERT },
  115.     { "BOX4_HORIZ", BOX4_HORIZ },
  116.     { "BOX4_TOP_LFT", BOX4_TOP_LFT },
  117.     { "BOX4_TOP_RT", BOX4_TOP_RT },
  118.     { "BOX4_BOT_LFT", BOX4_BOT_LFT },
  119.     { "BOX4_BOT_RT", BOX4_BOT_RT },
  120.     { "BOX4_TOP_TEE", BOX4_TOP_TEE },
  121.     { "BOX4_BOT_TEE", BOX4_BOT_TEE },
  122.     { "BOX4_LFT_TEE", BOX4_LFT_TEE },
  123.     { "BOX4_RT_TEE", BOX4_RT_TEE },
  124.     { "BOX4_CROSS", BOX4_CROSS },
  125.     { "LPI1", LPI1 },
  126.     { "LPI2", LPI2 },
  127.     { "LPI3", LPI3 },
  128.     { "LPI4", LPI4 },
  129.     { "LPI6", LPI6 },
  130.     { "LPI8", LPI8 },
  131.     { "LPI12", LPI12 },
  132.     { "CPI5", CPI5 },
  133.     { "CPI10", CPI10 },
  134.     { "CPI12", CPI12 },
  135.     { "CPI16", CPI16 },
  136.     { "POSTSCRIPT", POSTSCRIPT },
  137.     { "ATTR_REFRESH", ATTR_REFRESH },
  138.     { NULL, LAST }
  139.     };
  140.  
  141. /*
  142.  * Get a prtcap entry from the file
  143. */
  144. void get_print(prt_name)
  145. char *prt_name;
  146. {
  147.     char lbuf[256];
  148.     int i;
  149.     char *p;
  150.     int defindex;
  151.  
  152. #ifdef PDEBUG
  153.     int dbi;
  154.     FILE *stdbug;
  155.  
  156.     stdbug = fopen("get_print.dbg", "w");
  157. #endif
  158.  
  159.     /*
  160.      * In case it's not the first printer used empty the printer definition
  161.     */
  162.     for(i = 0; i < LAST; i ++)
  163.     {
  164.         if (prtdef[i] != NULL)
  165.         {
  166.             free(prtdef[i]);
  167.             prtdef[i] = NULL;
  168.         }
  169.         if (sizdef[i] != 0)
  170.             sizdef[i] = 0;
  171.     }
  172.  
  173.     /*
  174.      * establish defaults
  175.     */
  176.     prtdef[NUM_COLS] = alloc(sizeof(char));
  177.     sizdef[NUM_COLS] = sizeof(char);
  178.     *prtdef[NUM_COLS] = 80;
  179.  
  180.     prtdef[NUM_LINES] = alloc(sizeof(char));
  181.     sizdef[NUM_LINES] = sizeof(char);
  182.     *prtdef[NUM_LINES] = 66;
  183.  
  184.     prtdef[CR] = alloc(sizeof(char));
  185.     sizdef[CR] = sizeof(char);
  186.     *prtdef[CR] = '\r';
  187.  
  188.     prtdef[LINEFEED] = alloc(sizeof(char));
  189.     sizdef[LINEFEED] = sizeof(char);
  190.     *prtdef[LINEFEED] = '\n';
  191.  
  192.     if (strcmp(prt_name, "") == 0)
  193.         return;
  194.                                   /* open the file */
  195.     if (-1 == open_prtcap(prt_name))
  196.         abort_mess("Unable to get member %s from prtcap\n", prt_name);
  197.  
  198.     for(;;)
  199.     {                             /* get the next prtcap line */
  200.         if (next_prtline(lbuf) == 0 && feof(prtfp))
  201.             abort_mess("Unexpected EOF\n");
  202.                                   /* is it the END? */
  203.         if (strncmp(&lbuf[strspn(lbuf, "\t ")], "END", 3) == 0)
  204.             break;
  205.                                   /* is it a new BEGIN? */
  206.         if (strncmp(&lbuf[strspn(lbuf, "\t ")], "BEGIN(", 6) == 0)
  207.         {
  208.             fprintf(stderr,
  209.                 "WARNING: BEGIN without END.  Assuming entry is complete.\n");
  210.             break;
  211.         }
  212.         
  213.         p = strtok(lbuf, "\t \n");     /* find token in buffer */
  214.         if (p == NULL)                 /* NULL means blank line */
  215.         {
  216. #ifdef PDEBUG
  217.             fprintf(stderr, "DEBUG: warning - Skipping blank line.\n");
  218. #endif
  219.             continue;
  220.         }
  221.         for(i = 0; token[i].tokstring != NULL; i++)    /* look thru token list */
  222.         {
  223.             if (strcmp(p, token[i].tokstring) == 0)
  224.                 break;
  225.         }
  226.  
  227.         if (token[i].tokstring == NULL)    /* unrecognized token or comment */
  228.         {
  229.             if (*p == '#')
  230.             {
  231. #ifdef PDEBUG
  232.                 fprintf(stderr, "DEBUG: warning - Skipping comment.\n");
  233. #endif
  234.             }
  235.             else
  236.                 fprintf(stderr, "WARNING: Skipping unrecognized token (%s).\n", p);
  237.         }
  238.         else
  239.         {
  240.             p = strtok(NULL, "\t \n#");   /* get the data */
  241.  
  242.             defindex = token[i].defindex;   /* get index into prtdef array */
  243.  
  244. #ifdef PDEBUG
  245.             if (prtdef[defindex] != NULL)
  246.                 fprintf(stderr, "WARNING: Redefining %s\n",    token[i].tokstring);
  247. #endif
  248.  
  249.             switch (defindex)
  250.             {
  251.                 case NUM_LINES :                  /* integer members */
  252.                 case NUM_COLS :
  253.                     if (prtdef[defindex] != NULL) /* free if already defined */
  254.                         free(prtdef[defindex]);
  255.                     if (p == NULL)                /* undef table entry */
  256.                     {
  257.                         prtdef[defindex] = p;
  258.                         sizdef[defindex] = 0;
  259.                     }
  260.                     else
  261.                     {                             /* def table entry */
  262.                         prtdef[defindex] = alloc(sizeof(char));
  263.                         *prtdef[defindex] = (char)atoi(p);
  264.                         sizdef[defindex] = sizeof(char);
  265.                     }
  266. #ifdef PDEBUG
  267.                     fputc(*prtdef[defindex], stdbug);
  268.                     fputc(0xff, stdbug);
  269. #endif
  270.                     break;
  271.                 case POSTSCRIPT :
  272.                 case ATTR_REFRESH :
  273.                     if (prtdef[defindex] != NULL)
  274.                         free(prtdef[defindex]);
  275.                     prtdef[defindex] = alloc(1);
  276.                     *prtdef[defindex] = (char) 1;
  277.                     sizdef[defindex] = 1;
  278.                     break;
  279.                 default:                    /* string members */
  280.                     if (prtdef[defindex] != NULL)   /* free if already def'ed */
  281.                         free(prtdef[defindex]);
  282.                     if (p == NULL)                  /* undef table entry */
  283.                         prtdef[defindex] = p;
  284.                     else                            /* def table entry */
  285.                     {
  286.                         prtdef[defindex] = getdef(p, &sizdef[defindex]);
  287.                         if (prtdef[defindex] == NULL)
  288.                             abort_mess("Unable to allocate buffer for %s.\n",
  289.                                 token[i].tokstring);
  290.                     }
  291. #ifdef PDEBUG
  292.                     if (prtdef[defindex] != NULL)
  293.                     for(dbi = 0; dbi < sizdef[defindex]; dbi++)
  294.                         fputc(prtdef[defindex][dbi], stdbug);
  295.                     fputc(0xff, stdbug);
  296. #endif
  297.                     break;
  298.             }
  299.         }
  300.     }
  301.  
  302.     close_prtcap();                    /* close prtcap file */
  303. #ifdef PDEBUG
  304.     fclose(stdbug);
  305. #endif
  306. }
  307.  
  308. /*
  309.  * open prtcap and seek to beginning of entry
  310. */
  311. static int open_prtcap(prt_name)
  312. char *prt_name;
  313. {
  314.     char lbuf[256];
  315.     char searchstr[90];
  316.  
  317.     search_path("prtcap", lbuf, "");
  318.  
  319.     prtfp = fopen(lbuf, "r");      /* open the file */
  320.     if (prtfp == (FILE *)0)
  321.         return(-1);                    /* couldn't open it */
  322.  
  323.                                        /* here's what we're lookin' for */
  324.     sprintf(searchstr, "BEGIN(%s)", prt_name);
  325.  
  326.     for(;;)
  327.     {
  328.         if (next_prtline(lbuf) == 0 && feof(prtfp))    
  329.             break; /* break out if this is EOF */
  330.         if (strncmp(lbuf, searchstr, strlen(searchstr)) == 0)
  331.             break; /* break out if this is it!!! */
  332.     } /* "...and I still haven't found what I'm lookin' for." - U2 */
  333.  
  334.     if (feof(prtfp) && strlen(lbuf) == 0)
  335.         return(-1); /* EOF */
  336.     else
  337.         return(0);  /* BEGIN(...) */
  338. }
  339.  
  340. /*
  341.  * close the file
  342. */
  343. static void close_prtcap()
  344. {
  345.     fclose(prtfp);
  346. }
  347.  
  348. /*
  349.  * get the next line from the prtcap file
  350. */
  351. static int next_prtline(lbuf)
  352. char *lbuf;
  353. {
  354.     int c;
  355.     char *p;
  356.  
  357.     for(p = lbuf;;p++)
  358.     {
  359.         c = fgetc(prtfp);              /* get next character */
  360.         if (c == '\n' || c == EOF)     /* EOL or EOF ?? */
  361.         {
  362.             *p = '\0';
  363.             return(strlen(lbuf));
  364.         }
  365.         *p = (char)c;                        /* put character into buffer */
  366.     }
  367. }
  368.  
  369. /*
  370.  * translate a prtcap entry
  371.  *    \nnn  = octal number
  372.  *    \E    = escape
  373.  *    \S    = space
  374.  *    \n    = newline
  375.  *    \r    = carriage return
  376.  *    \t    = tab
  377.  *    \b    = backspace
  378.  *    \f    = formfeed
  379. */ 
  380. static char *getdef(defptr, defsiz)
  381. char *defptr;
  382. int *defsiz;
  383. {
  384.     char dbuf[128];
  385.     char *p1;
  386.     char *p2;
  387.     int n;
  388.     int i;
  389.     char *retptr;
  390.     int size = 0;
  391.  
  392.     memset(p2 = dbuf, '\0', 128);      /* zero out the buffer */
  393.  
  394.     for(p1 = defptr; *p1 != '\0'; p1++)
  395.     {
  396.         if (*p1 == '\\')               /* escaped char(s) */
  397.         {
  398.             p1++;
  399.             if (isoctal(*p1))          /* octal conversion */
  400.             {
  401.                 n = 0;                 /* up to 3 digit octal number */
  402.                 for(i = 0; (isoctal(*p1) && i < 3); i++)
  403.                 {
  404.                     n <<= 3;
  405.                     n += (*p1 - '0');
  406.                     p1++;
  407.                 }
  408.                 *p2++ = (char)n;
  409.                 size++;
  410.                 p1--;
  411.             }
  412.             else     /* meta character */
  413.             {
  414.                 switch(*p1)
  415.                 {
  416.                     case 'E':          /* escape */
  417.                         *p2++ = 0x1b;
  418.                         break;
  419.                     case 'S':          /* space */
  420.                         *p2++ = ' ';
  421.                         break;
  422.                     case 'n':          /* newline */
  423.                         *p2++ = '\n';
  424.                         break;
  425.                     case 'r':          /* carriage return */
  426.                         *p2++ = '\r';
  427.                         break;
  428.                     case 't':          /* tab */
  429.                         *p2++ = '\t';
  430.                         break;
  431.                     case 'b':          /* backspace */
  432.                         *p2++ = '\b';
  433.                         break;
  434.                     case 'f':          /* formfeed */
  435.                         *p2++ = '\f';
  436.                         break;
  437.                     default:           /* other character (no translation) */
  438.                         *p2++ = *p1;
  439.                         break;
  440.                 }
  441.                 size++;
  442.             }
  443.         }
  444.         else
  445.         {
  446.             *p2++ = *p1;               /* standard character (no translation) */
  447.             size++;
  448.         }
  449.     }
  450.     retptr = alloc(size);             /* allocate buffer */
  451.     *defsiz = size;                    /* store size of buffer */
  452.     if (retptr != NULL)
  453.         memcpy(retptr, dbuf, size);
  454.     return(retptr);
  455. }
  456.  
  457.  
  458.  
  459. /**********************************************************************/
  460. /* GET_PRINTERS - get a list of all the available printers            */ 
  461. /**********************************************************************/
  462.  
  463. # define MAX_PRINTERS 64
  464.  
  465. int nprts = 0;
  466. char *pnames[MAX_PRINTERS];
  467.  
  468. PROTO (int get_printers, (void));
  469.  
  470. int get_printers()
  471. {
  472.     char lbuf[256];
  473.     char searchstr[25];
  474.     int  length = 0;
  475.  
  476.     if( nprts )
  477.         return(0); /* we already read in the list */
  478.  
  479.     search_path("prtcap", lbuf, "");
  480.     prtfp = fopen(lbuf, "r");     /* open the file */
  481.     if (prtfp == (FILE *)0)
  482.         return(-1);                    /* couldn't open it */
  483.  
  484.     strcpy(searchstr, "BEGIN(");      /* here's what we're lookin' for */
  485.  
  486.     while (TRUE)
  487.     {
  488.         if (next_prtline(lbuf) == 0 && feof(prtfp))    
  489.             break; /* break out if this is EOF */
  490.  
  491.         if (strncmp(lbuf, searchstr, strlen(searchstr)) == 0)
  492.         {
  493.             length = strlen( lbuf + strlen( searchstr ) );
  494.             /* 
  495.             * allocate space for another printer name  
  496.             */
  497.             pnames[ nprts ] = alloc( length + 1 );
  498.  
  499.             if ( pnames[ nprts ] == NULL )
  500.             {
  501.                 errmsg(NotEnufMem);
  502.                 break;
  503.             }
  504.             strncpy( pnames[ nprts ],
  505.                 lbuf + strlen( searchstr ), length - 1);
  506.             pnames[ nprts ][ length - 1 ] = '\0';
  507.  
  508.             nprts++;
  509.  
  510.             if( nprts > MAX_PRINTERS )
  511.                 break;
  512.         }
  513.     } 
  514.     fclose (prtfp);
  515.  
  516.     return(0);
  517. }
  518.  
  519. /*
  520. void main( void );
  521.  
  522. void main()
  523. {
  524.     int i;
  525.     get_printers();
  526.     i = rpt_selectkey( pnames, nprts , " Printer Selection ") - 1;
  527.     printf("we selected printer %d '%s' ",i,pnames[i]);
  528. }
  529. */
  530.