home *** CD-ROM | disk | FTP | other *** search
/ Jason Aller Floppy Collection / 125.img / PRO-C4.ZIP / BENCH1.ZIP / PRINT / TAKE24.C < prev   
Encoding:
C/C++ Source or Header  |  1990-05-28  |  7.7 KB  |  402 lines
  1. #include <stdio.h>
  2. #include <bench.h>
  3. #include <dos.h>
  4.  
  5. #define GET_SEG(p)    (*((unsigned *)&(p) + 1))
  6. #define GET_OFF(p)    (*((unsigned *)&(p)))
  7.  
  8. int com_id;
  9. char far *embuf = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
  10.  
  11. #ifdef MSC
  12. void handle24(unsigned, unsigned, unsigned far *);
  13. #else
  14. int handle24(unsigned, unsigned, unsigned far *);
  15. #endif
  16.  
  17. void bios_errmsg(char *, ...);
  18. int bios_warning(char *, ...);
  19. unsigned char get_dpage(void);
  20. void bios_pos(int, int);
  21. void bios_poke(int, int, unsigned char, unsigned char, int);
  22. void get_dregion(int, int, int, int);
  23. void mk_bioswin(int, int, int, int);
  24. void put_msg(int, int, char *, int);
  25. int get_key(void);
  26. void put_dregion(int, int, int, int);
  27.  
  28. #ifdef MSC
  29. void handle24(deverr, errcode, devhdr)
  30. #else
  31. int handle24(deverr, errcode, devhdr)
  32. #endif
  33.     unsigned    deverr;
  34.     unsigned    errcode;
  35.     unsigned far * devhdr;
  36. {
  37.     union REGS r;
  38.     char *locus;
  39.     int cts = 0;
  40.  
  41.     r.h.ah = 0x59;
  42.     r.x.bx = 0x00;
  43.  
  44.     int86(0x21, &r, &r);
  45.  
  46.     switch(r.h.ch)
  47.     {
  48.         case 2:
  49.             locus = "Block device";
  50.             break;
  51.         case 3:
  52.             locus = "Network";
  53.             break;
  54.         case 4:
  55.             locus = "Serial device";
  56.             break;
  57.         case 5:
  58.             locus = "Memory related";
  59.             break;
  60.         default:
  61.             locus = "Unknown";
  62.             break;
  63.     }
  64.  
  65.     switch(r.x.ax)
  66.     {
  67.         case 0x0F:          /* invalid drive */
  68.             bios_errmsg("Invalid Drive.");
  69.             break;
  70.         case 0x13:          /* disk write-protected */
  71.             bios_errmsg("Disk Is Write-Protected.");
  72.             break;
  73.         case 0x15:          /* drive not ready */
  74.         case 0x19:          /* seek error */
  75.         case 0x1A:          /* unknown media type */
  76.         case 0x1B:          /* sector not found */
  77.             if (r.h.ch == 2)
  78.                 bios_errmsg("Drive Not Ready.");
  79.             else
  80.             {
  81.                 bios_errmsg("Write error.");
  82. #ifdef HMMMMMMM
  83. #ifdef MSC
  84.                 _hardretn(_HARDERR_ABORT);
  85. #else
  86. # ifdef __TURBOC__
  87.                 hardretn(2);
  88. # else
  89.                 return(2);
  90. # endif
  91. #endif
  92. #endif
  93.             }
  94.             break;
  95.         case 0x1C:          /* out of paper */
  96.             bios_errmsg("Printer Out Of Paper.");
  97.             break;
  98.         case 0x1D:          /* write fault */
  99.             if (r.h.ch == 4)
  100.             {
  101.                 r.h.ah = 0x03;
  102.                 r.x.dx = com_id;
  103.                 int86(0x14, &r, &r);      /* get status of COM port */
  104.  
  105.                 if (!(r.h.al & 0x20))     /* no DSR - printer offline */
  106.                 {
  107.                     bios_errmsg("Printer Offline...");
  108. #ifdef MSC
  109.                     _hardresume(_HARDERR_RETRY);
  110. #else
  111. # ifdef __TURBOC__
  112.                     hardresume(1);
  113. # else
  114.                     return(1);
  115. # endif
  116. #endif
  117.                 }
  118.                 else if (!(cts = (r.h.al & 0x10)))  /* no CTS - retry after cts restored */
  119.                 {
  120.                     while(!cts)   /* loop until cts is restored */
  121.                     {
  122.                         r.h.ah = 0x03;
  123.                         r.x.dx = com_id;
  124.                         int86(0x14, &r, &r);
  125.                         cts = r.h.al & 0x10;
  126.                     }
  127. #ifdef MSC
  128.                     _hardresume(_HARDERR_RETRY);
  129. #else
  130. # ifdef __TURBOC__
  131.                     hardresume(1);
  132. # else
  133.                     return(1);
  134. # endif
  135. #endif
  136.                 }
  137.                 else
  138.                 {
  139.                     bios_errmsg("Error writing to COM%d:", com_id + 1);
  140. #ifdef MSC
  141.                     _hardresume(_HARDERR_FAIL);
  142. #else
  143. # ifdef __TURBOC__
  144.                     hardresume(2);
  145. # else
  146.                     return(2);
  147. # endif
  148. #endif
  149.                 }
  150.             }
  151.             else
  152.                 bios_errmsg("Write Fault (%s).", locus);
  153.             break;
  154.         case 0x1E:          /* read fault */
  155.             bios_errmsg("Read Fault (%s).", locus);
  156.             break;
  157.         case 0x1F:          /* general failure */
  158.             bios_errmsg("General Failure (%s).", locus);
  159.             break;
  160.         default:
  161.             printf("UNRECOGNIZED EXTENDED ERROR CODE !!!\n");
  162.             printf("Extended Error Code = %2X\n", r.x.ax);
  163.             printf("Error Class Code = %2X\n", r.h.bh);
  164.             printf("Error Locus Code = %d (%s)\n", r.h.ch, locus);
  165. #ifdef MSC
  166.             _hardresume(_HARDERR_FAIL);    /* Fail back to MSDOS */
  167. #else
  168. # ifdef __TURBOC__
  169.             hardresume(2);
  170. # else
  171.             return(2);
  172. # endif
  173. #endif
  174.             break;
  175.     }
  176. #ifdef MSC
  177.     _hardretn(r.x.ax);
  178. #else
  179. # ifdef __TURBOC__
  180.     hardretn(r.x.ax);
  181. # else
  182.     return(r.x.ax);
  183. # endif
  184. #endif
  185. }
  186.  
  187. void take24()
  188. {
  189. #ifdef MSC
  190.     void (*h24)();
  191. #else
  192. #ifdef __TURBOC__
  193.     int (*h24)();
  194. #else
  195.     union REGS r;
  196.     struct SREGS sr;
  197. #endif
  198. #endif
  199.  
  200.     h24 = handle24;
  201.  
  202. #ifdef MSC
  203.     _harderr(h24);
  204. #else
  205. # ifdef __TURBOC__
  206.     harderr(h24);
  207. # else
  208.     r.h.ah = 0x25;
  209.     r.h.al = 0x24;
  210.     sr.ds = GET_SEG(h24);
  211.     r.x.dx = GET_OFF(h24);
  212.     int86x(0x21, &r, &r, &sr);
  213. # endif
  214. #endif
  215. }
  216.  
  217. unsigned char saveattr[5][40];
  218. unsigned char savechar[5][40];
  219.  
  220. unsigned char get_dpage()
  221. {
  222.     unsigned char dpage;
  223.     union REGS r;
  224.  
  225.     r.h.ah = 0x0f;
  226.     int86(0x10, &r, &r);
  227.     dpage = r.h.bh;
  228.  
  229.     return(dpage);
  230. }
  231.  
  232. void bios_pos(row, col)
  233. int row, col;
  234. {
  235.     unsigned char dpage;
  236.     union REGS r;
  237.  
  238.     dpage = get_dpage();
  239.  
  240.     r.h.ah = 0x02;
  241.     r.h.bh = dpage;
  242.     r.h.dh = row - 1;
  243.     r.h.dl = col - 1;
  244.     int86(0x10, &r, &r);
  245. }
  246.  
  247. void bios_poke(row, col, ch, attr, rep)
  248. int row, col;
  249. unsigned char ch, attr;
  250. int rep;
  251. {
  252.     unsigned char dpage;
  253.     union REGS r;
  254.  
  255.     dpage = get_dpage();
  256.  
  257.     bios_pos(row, col);
  258.  
  259.     r.h.ah = 0x09;
  260.     r.h.al = ch;
  261.     r.h.bh = dpage;
  262.     r.h.bl = attr;
  263.     r.x.cx = rep;
  264.     int86(0x10, &r, &r);
  265. }
  266.  
  267. void get_dregion(row, col, h, w)
  268. int row;
  269. int col;
  270. int h;
  271. int w;
  272. {
  273.     int rctr, cctr;
  274.     union REGS r;
  275.     unsigned char dpage;
  276.  
  277.     dpage = get_dpage();
  278.  
  279.     for (rctr = 0; rctr < h; rctr++)
  280.     {
  281.         for (cctr = 0; cctr < w; cctr++)
  282.         {
  283.             bios_pos(row + rctr, col + cctr);
  284.             r.h.ah = 0x08;
  285.             r.h.bh = dpage;
  286.             int86(0x10, &r, &r);
  287.             saveattr[rctr][cctr] = r.h.ah;
  288.             savechar[rctr][cctr] = r.h.al;
  289.         }
  290.     }
  291. }
  292.  
  293. void put_dregion(row, col, h, w)
  294. int row, col, h, w;
  295. {
  296.     int rctr, cctr;
  297.  
  298.     for (rctr = 0; rctr < h; rctr++)
  299.         for (cctr = 0; cctr < w; cctr++)
  300.             bios_poke(row + rctr, col + cctr, savechar[rctr][cctr], saveattr[rctr][cctr], 1);
  301. }
  302.  
  303. void mk_bioswin(row, col, h, w)
  304. int row, col, h, w;
  305. {
  306.     int ctr;
  307.  
  308.     bios_poke(row, col, 0xda, colour[REVVID], 1);
  309.     bios_poke(row, col + 1, 0xc4, colour[REVVID], w - 2);
  310.     bios_poke(row, col + w - 1, 0xbf, colour[REVVID], 1);
  311.     for(ctr = 1; ctr < h - 1; ctr++)
  312.     {
  313.         bios_poke(row + ctr, col, 0xb3, colour[REVVID], 1);
  314.         bios_poke(row + ctr, col + 1, 0x20, colour[REVVID], w - 2);
  315.         bios_poke(row + ctr, col + w - 1, 0xb3, colour[REVVID], 1);
  316.     }
  317.     bios_poke(row + h - 1, col, 0xc0, colour[REVVID], 1);
  318.     bios_poke(row + h - 1, col + 1, 0xc4, colour[REVVID], w - 2);
  319.     bios_poke(row + h - 1, col + w - 1, 0xd9, colour[REVVID], 1);
  320. }
  321.  
  322. int get_key()
  323. {
  324.     union REGS r;
  325.     r.h.ah = 0x00;
  326.     int86(0x16, &r, &r);
  327.     return(r.h.al);
  328. }
  329.  
  330. void put_msg(row, col, msgtxt, attr)
  331. int row, col;
  332. char *msgtxt;
  333. int attr;
  334. {
  335.     while(*msgtxt)
  336.         bios_poke(row, col++, *msgtxt++, attr, 1);
  337. }
  338.  
  339. void bios_errmsg(char *va_alist, ...)
  340. {
  341.     va_list ap;
  342.     char *fmt;
  343.     char dispbuff[512];
  344.  
  345.    /*
  346.     * Vararg section for status box
  347.    */
  348.     va_start(ap, va_alist);
  349.     fmt = va_alist;
  350.     vsprintf(dispbuff, fmt, ap);
  351.     get_dregion(10, 21, 5, 40);
  352.     mk_bioswin(10, 21, 5, 40);
  353.     put_msg(11, 21 + (40 - strlen(dispbuff))/2, dispbuff, colour[REVVID]);
  354.     put_msg(13, 34, "Press ENTER...", colour[REVVID]);
  355.     while (get_key() != '\r')
  356.         ;
  357.     put_dregion(10, 21, 5, 40);
  358. }
  359.  
  360. int bios_warning(char *va_alist, ...)
  361. {
  362.     va_list ap;
  363.     char *fmt;
  364.     char dispbuff[512];
  365.     int k;
  366.  
  367.    /*
  368.     * Vararg section for status box
  369.    */
  370.     va_start(ap, va_alist);
  371.     fmt = va_alist;
  372.     vsprintf(dispbuff, fmt, ap);
  373.     get_dregion(10, 21, 5, 40);
  374.     mk_bioswin(10, 21, 5, 40);
  375.     put_msg(11, 21 + (40 - strlen(dispbuff))/2, dispbuff, colour[REVVID]);
  376.     put_msg(13, 32, "Abort or Retry ?", colour[REVVID]);
  377.     bios_poke(13, 32, 'A', colour[NORMAL], 1);
  378.     bios_poke(13, 41, 'R', colour[NORMAL], 1);
  379.     do
  380.     {
  381.         k = get_key();
  382.     } while (k != 'y' && k!= 'Y' && k != 'n' && k != 'N');
  383.  
  384.     put_dregion(10, 21, 5, 40);
  385.     if (k == 'y' || k == 'Y')
  386.         return(1);
  387.     else
  388.         return(0);
  389. }
  390.  
  391. #ifdef MAIN24
  392. main()
  393. {
  394.     init_w(24, 80);
  395.     std_scr("Hello there!");
  396.     inchar();
  397.     bios_errmsg("Hello again!");
  398.     inchar();
  399.     end_w(TRUE);
  400. }
  401. #endif
  402.