home *** CD-ROM | disk | FTP | other *** search
/ Boston 2 / boston-2.iso / DOS / PROGRAM / C / XRF / SPOOL.C < prev    next >
C/C++ Source or Header  |  1993-12-01  |  9KB  |  217 lines
  1. /****************************************************************************/
  2. /*                MSDOS print spooler interface spool.c                     */
  3. /*                                                                          */
  4. /*  Mike Cole  Digital Equipment Co. Ltd.           3 Jan 85                */
  5. /*  based on PC/MSDOS Tips from Tom Jennings (indirectly).                  */
  6. /*                                                                          */
  7. /*  spool(filename)   adds a 'filename' to print queue.                     */
  8. /*                    return 1 if couldn't queue                            */
  9. /*                           0 if done                                      */
  10. /*                          -1 if error                                     */
  11. /*  unspool(filename) deletes 'filename' from print queue.                  */
  12. /*                    return 0 if done                                      */
  13. /*                          -1 if error                                     */
  14. /*  qspool(namelist)  updates 'namelist' with names in the queue            */
  15. /*                    (starting with the currently printing file.           */
  16. /*                    This will NOT be in queue order.                      */
  17. /*                    return 0..10 as number of 'filenames' in queue.       */
  18. /*                                                                          */
  19. /*  'filename'    char filename[13] as 'filename.sfx',0                     */
  20. /*  'namelist'    char namelist[10][13] each as 'filename.sfx',0            */
  21. /****************************************************************************/
  22. /*   To access DOS' PRINT capabilities:                                     */
  23. /*   MOV AH,func                                                            */
  24. /*   INT 2Fh                                                                */
  25. #define ADD 0x0000        /* AH = 0 adds the file specified by DS:DX to     */
  26.                           /* the print queue.                               */
  27.                           /* DS:DX must point to valid opened FCB.          */
  28. #define CAN 0x0100        /* AH = 1 cancels the file indicated by DS:DX.    */
  29.                           /* DS:DX must point to an FCB, opened or unopened.*/
  30.                           /* The drive byte must not be 0.                  */
  31.                           /* Wildcards are restricted: ? is okay, * isn't.  */
  32. #define QRY 0x0200        /* AH > 1 do nothing.                             */
  33. /****************************************************************************/
  34. /*        Return with registers set as follows:                             */
  35. /*                                                                          */
  36. /*          DS,SI,DI,CX preserved, all others destroyed.                    */
  37. /*          AH = number of files currently in queue.                        */
  38. /*          AL = for AH=0, return 1 if queue was                            */
  39. /*               full.  For all other cases, return 0.                      */
  40. /*          ES:BX = pointer to list of 10 entries in queue.                 */
  41. /*                  each entry is 40 bytes:-                                */
  42. /*                    2  byte queue ordering pointer (ignored by us).       */
  43. /*                       if 1st byte is oxFF, do next??                     */
  44. /*                       else is offset of next entry.                      */
  45. /*                    38 byte FCB. If the first byte of an FCB              */
  46. /*                       FCB is 0xFF, that entry is unused.                 */
  47. /*          ES:DX = pointer to currently printing                           */
  48. /*                  FCB.  If the queue is empty, DX = -1.                   */
  49. /****************************************************************************/
  50. #define TRUE       1
  51. #define FALSE      0
  52. #define NULL       0
  53. #define OPENF      0x0F            /*MSDOS  Open file */
  54. #define CLOSEF     0x10            /*MSDOS  Close file */
  55. #define GETDISK    0x19            /*MSDOS  Current logged in drive */
  56. #define QENTRY     40            /*print queue entry size (fcb+2)*/
  57. #define QLASTENTRY 10*QENTRY        /*print queue #entries in bytes*/
  58.  
  59. struct regval{ unsigned int ax,bx,cx,dx,si,di,ds,es;};
  60.  
  61. typedef struct  fcb_t {        /* NON-EXTENDED FCB */
  62.    unsigned char    f_dr;        /* drive code */
  63.    unsigned char    f_name[8],      /* name */
  64.                     f_ext[3];       /* extension */
  65.             int     f_block;        /* current block (=128 records) */
  66.             int     f_recsz;        /* record size in bytes (=1) */
  67.             long    f_size;         /* file size in bytes (system) */
  68.    unsigned int     f_date;         /* modification date (system) */
  69.    unsigned int     f_time;         /* modification time (system) */
  70.             char    f_sys[8];       /* for system use */
  71.    unsigned char    f_rec;          /* current record in block */
  72.    unsigned long    f_seek;         /* random record position */
  73.     } FCB_T, *FCB_PTR;
  74.  
  75. static FCB_T    mfcb_;            /* local file control block */
  76. /****************************************************************************/
  77. spool(fn)    /*trigger off spool print of output file 'fn'*/
  78. char *fn;    /*return 1 if couldn't queue, 0 if done, -1 if error*/
  79. { struct regval srs,srd;
  80.   FCB_PTR buildfcb();
  81.  
  82.   segread(&srs.si);            /* get ds value */
  83.   srs.ax=ADD;
  84.   if((srs.dx=buildfcb(fn))==NULL)return -1;
  85.   sysint(0x2F,&srs,&srd);
  86.   bdos(CLOSEF,&srs.dx);            /*ensure file closed*/
  87.   if(srs.dx!=srd.dx)return srd.ax & 0xff;    /*ok if queue ptr returned*/
  88.   return -1;                /*error, PRINT not installed*/
  89. }
  90. /****************************************************************************/
  91. unspool(fn)    /*cancel spool print of output file 'fn'*/
  92. char *fn;
  93. { struct regval srs,srd;
  94.   FCB_PTR buildfcb();
  95.  
  96.   segread(&srs.si);            /* get ds value */
  97.   srs.ax=CAN;
  98.   if((srs.dx=buildfcb(fn))==NULL)return -1;
  99.   sysint(0x2F,&srs,&srd);
  100.   bdos(CLOSEF,&srs.dx);            /*ensure file closed*/
  101.   if(srs.dx!=srd.dx)return 0;        /*ok if queue ptr returned*/
  102.   return -1;                /*error, PRINT not installed*/
  103. }
  104. /****************************************************************************/
  105.  
  106. qspool(filelist)        /*return number of printing files*/
  107. char filelist[10][13];    /*return queuelist (printing file first)*/
  108.  
  109. { struct regval srs,srd;
  110.   FCB_PTR buildfcb();
  111.   FCB_T retfcb;
  112.   int i;
  113.   char *fp;  setmem(filelist,130,0);
  114.   segread(&srs.si);            /* get ds value */
  115.   srs.ax=QRY;
  116.   srs.dx=0;
  117.   sysint(0x2F,&srs,&srd);
  118.   if(srs.dx==srd.dx)return -1;        /*error, PRINT not installed*/
  119.   if((int)srs.dx==-1)return 0;        /*queue empty*/
  120.   fp=srd.dx;                /*start with current*/
  121.   if(srd.ax>>8)for(i=0;i<10;i++){
  122.     movblock(fp+2,srd.es,&retfcb,srs.ds,sizeof(retfcb));
  123.     if(retfcb.f_dr!=0xff)asciiz(&filelist[i][0],retfcb.f_name);
  124.     fp+=QENTRY;
  125.     if(fp>=srd.bx+QLASTENTRY)fp=srd.bx;
  126.     }
  127.   return srd.ax>>8;
  128. }
  129.  
  130.  
  131. /****************************************************************************/
  132. FCB_PTR buildfcb(rs)            /*Build an open FCB*/
  133. char rs[];
  134. {
  135.   int i,j;
  136.   char  disk;            /* disk specified in run string */
  137.   setmem(&mfcb_,sizeof(mfcb_),0);
  138.   mfcb_.f_dr=bdos(GETDISK,0)+1;        /* default drive code */
  139.   while (strlen(rs) != 0 && rs[0] == ' ') ++rs;
  140.   if (strlen(rs) == 0)return NULL;
  141.   if (rs[1] == ':' && strlen(rs) == 2)return NULL;
  142.   if (rs[1] == ':') {
  143.     disk = toupper(rs[0]) - '@';
  144.     rs += 2;
  145.         }
  146.    else  disk = 0;
  147.   makefn(rs,mfcb_.f_name);
  148.   if(disk)mfcb_.f_dr=disk+1;        /* drive code */
  149.   if(bdos(OPENF,&mfcb_))return &mfcb_;    /* try open */
  150.   return NULL;                /*failed*/
  151. }
  152. /****************************************************************************/
  153. makefn(infn,opfn)         /* ASCIZ -> expanded file name */
  154. char *infn;
  155. char *opfn;
  156. {
  157.   int i, j, swe, swf;
  158.   char temp[13];
  159.   unsigned char c;
  160.  
  161.   strcpy(temp, "           ");
  162.   j = 0;
  163.   swf = swe = TRUE;
  164.   while (swf == TRUE) {
  165.     c = *infn++;
  166.     switch ( c ) {
  167.         case '.' : swf = FALSE;                break;
  168.         case '*' : for (; j < 8; temp[j++] = '?');    break;
  169.  
  170.         case '\0': swf = swe = FALSE;            break;
  171.         default  : if (j < 8) temp[j++] = toupper(c);    break;
  172.         }
  173.     } /* while swf */
  174.   j = 8;
  175.   while (swe == TRUE) {
  176.     switch ( c ) {
  177.         case '.' :                     break;
  178.         case '*' : for (; j < 11; temp[j++] = '?');    break;
  179.         case '\0': swe = FALSE;                break;
  180.         default  : if (j < 11) temp[j++] = toupper(c);    break;
  181.         }
  182.     c = *infn++;
  183.     } /* while swe */
  184.   for(i = 0; i < 11;*opfn++ = temp[i++]);
  185.   *opfn = '\0';
  186. } /* makefn() */
  187. /****************************************************************************/
  188. asciiz(fo,fi)                /* convert to ASCIZ filename */
  189. char *fo,fi[];
  190. { int i, j;
  191.   i = 0;
  192.   while (fi[i] != ' ' && i < 8)
  193.       *fo++ = fi[i++];
  194.   *fo++ = '.';
  195.   j = 8;
  196.   while (fi[j] != ' ' && j < 11)
  197.       *fo++ = fi[j++];
  198.   *fo = '\0';
  199. }
  200. tracereg(tag,regs)
  201. char *tag;
  202. struct regval *regs;
  203. { 
  204.   printf("%s regdump ",tag);
  205.   printf("ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x ds=%04x es=%04x\n",
  206.       regs->ax,regs->bx,regs->cx,regs->dx,regs->si,regs->di,regs->ds,regs->es);
  207. }
  208. tracedump(tag,area,cnt)
  209. unsigned char *tag;
  210. unsigned char area[];
  211. int cnt;
  212. {int i;
  213.   printf("%s dump ",tag);
  214.  for(i=0;i<cnt;printf("%02x",area[i++]));
  215.  printf("\n");
  216. }
  217.