home *** CD-ROM | disk | FTP | other *** search
/ synchro.net / synchro.net.tar / synchro.net / modem.madness / SMMPROG / ISC366.ZIP / DOSFREE / DOSFREE.CPP next >
Encoding:
C/C++ Source or Header  |  1993-09-01  |  6.0 KB  |  248 lines
  1. ///////////////////////////////////////////////////////////////////////////
  2. //                                                                       //
  3. //            File: DosFree.cpp                                          //
  4. //            started on: 28/7/93                                        //
  5. //                                                                       //
  6. ///////////////////////////////////////////////////////////////////////////
  7. //                                                                       //
  8. //  DosFree allows you to use dos within your TSRs. Just derive from     //
  9. //    this class and call func. Go and your dos-free application         //
  10. //    overloading func. AppFunc will run as soon as dos is free.         //
  11. //                                                                       //
  12. ///////////////////////////////////////////////////////////////////////////
  13. //                                                                       //
  14. //                    by Ofer Laor (AKA LeucroTTA)                       //
  15. //                                                                       //
  16. ///////////////////////////////////////////////////////////////////////////
  17.  
  18. #include "dosfree.h"; // DOSFREE.
  19. #include <dos.h>;     // disable, REGS, SREGS, intdos, intdosx.
  20.  
  21. // Abort/Retry/Fail==> Fail.
  22. void TRAP24::isr(IREGS& regs)
  23. {
  24.     regs.h.al= 3;
  25. }
  26.  
  27. // start up.
  28. DOSFREE::DOSFREE()
  29. {
  30.     fRunning= 0; // start by not running.
  31.  
  32.     // now enlarge the stack that ISC uses.
  33.     disable();
  34.     reallocStack(5500);
  35.     enable();
  36. }
  37.  
  38. // run AppFunc as soon as possible.
  39. void DOSFREE::Go(void)
  40. {
  41.     fRunning= 1;
  42. }
  43.  
  44. // application should overload this function.
  45. void DOSFREE::AppFunc(void)
  46. {
  47.      // Do nothing....
  48. }
  49.  
  50. // local function - insures that AppFunc is running in "protected DOS" session.
  51. void DOSFREE::ShellFunc(void)
  52. {
  53.     static int fInFlag= 0;
  54.  
  55.     if (fInFlag|| !fRunning) // prevent recursion + is app supposed to run?
  56.        return;
  57.  
  58.     fInFlag++;
  59.  
  60.     REGS regs;
  61.     SREGS sregs;
  62.  
  63.     // now disable break_checking.
  64.  
  65.     regs.x.ax= 0x3300; // get break state.
  66.     intdos(®s, ®s);
  67.  
  68.     unsigned char bPrevBreak= regs.h.dl;
  69.  
  70.     regs.h.dl= 0;
  71.     regs.x.ax= 0x3301; // set break state.
  72.     intdos(®s, ®s);
  73.  
  74.     // set new psp.
  75.  
  76.     regs.x.ax= 0x5100;    // get current psp.
  77.     intdos(®s, ®s);
  78.  
  79.     unsigned wPrevPSP= regs.x.bx;
  80.  
  81.     regs.x.bx= _psp;
  82.     regs.x.ax= 0x5000;    // set current psp.
  83.     intdos(®s, ®s);
  84.  
  85.  
  86.     // set new DTA area.
  87.  
  88.     regs.x.ax= 0x2f00;              // get DTA area.
  89.     intdosx(®s, ®s, &sregs);
  90.     unsigned wPrevDTAoff= regs.x.bx;
  91.     unsigned wPrevDTAseg= sregs.es;
  92.  
  93.     sregs.ds= _psp;
  94.     regs.x.dx= 0x80;
  95.     regs.x.ax= 0x1a00;
  96.     intdosx(®s, ®s, &sregs);  // set DTA to psp:0x80.
  97.  
  98.  
  99.     // deactivate for next time (once per go)..
  100.     fRunning= 0;
  101.  
  102.  
  103.     // HANDLE EXTENDED ERRORS (and traps!).
  104.     // DOS 3.1 and up!
  105.  
  106.     regs.x.ax= 0x5900;                  // get extended error info.
  107.     regs.x.bx= 0;
  108.     intdosx(®s, ®s, &sregs);
  109.  
  110.  
  111.     struct {
  112.            unsigned ax;
  113.            unsigned bx;
  114.            unsigned cx;
  115.            unsigned dx;
  116.            unsigned si;
  117.            unsigned di;
  118.            unsigned ds;
  119.            unsigned es;
  120.            unsigned dummy[3];
  121.     } ErrorRegs;
  122.  
  123.  
  124.     ErrorRegs.ax= regs.x.ax;
  125.     ErrorRegs.bx= regs.x.bx;
  126.     ErrorRegs.cx= regs.x.cx;
  127.     ErrorRegs.dx= regs.x.dx;
  128.     ErrorRegs.si= regs.x.si;
  129.     ErrorRegs.di= regs.x.di;
  130.     ErrorRegs.es= sregs.es;
  131.     ErrorRegs.ds= sregs.ds;
  132.  
  133.     ErrorRegs.dummy[0]= ErrorRegs.dummy[1]= ErrorRegs.dummy[2]= 0;
  134.  
  135.  
  136.     // SET TRAPS --> THIS MIGHT NOT WORK IN LARGER MEM MODELS!!!!!
  137.     TrapCBreak.activate(0x1b);
  138.     TrapMSDOSCriticalError.activate(0x23);
  139.     TrapAbortRetryFail.activate(0x24);
  140.  
  141.     //////////////////////////////////////////////////////////////////////
  142.  
  143.     // run application.
  144.     AppFunc();
  145.  
  146.     //////////////////////////////////////////////////////////////////////
  147.  
  148.     // RESTORE OLD TRAPS.
  149.  
  150.     TrapCBreak.deactivate();
  151.     TrapMSDOSCriticalError.deactivate();
  152.     TrapAbortRetryFail.deactivate();
  153.  
  154.     // RESTORE EXTENDED ERRORS .
  155.  
  156.     regs.x.dx= FP_OFF((void far *)&ErrorRegs);
  157.     sregs.ds=  FP_SEG((void far *)&ErrorRegs);
  158.     regs.x.ax= 0x5d0a;
  159.     intdosx(®s, ®s, &sregs);           // set extended error.
  160.  
  161.  
  162.     // reset to old DTA area.
  163.     sregs.ds=  wPrevDTAseg;
  164.     regs.x.dx= wPrevDTAoff;
  165.     regs.x.ax= 0x1a00;
  166.     intdosx(®s, ®s, &sregs);  // set DTA area to old DTA area.
  167.  
  168.  
  169.     // reset old psp.
  170.     regs.x.bx= wPrevPSP;
  171.     regs.x.ax= 0x5000;
  172.     intdos(®s, ®s); // set old psp.
  173.  
  174.  
  175.     // re-enable break_checking.
  176.  
  177.     regs.h.dl= bPrevBreak;
  178.     regs.x.ax= 0x3301;
  179.     intdos(®s, ®s);
  180.  
  181.     fInFlag--;
  182. }
  183.  
  184. // Timer for DOSFREE.
  185. INT8::INT8()
  186. {
  187.     activate(0x8);
  188.  
  189.     // now check for Dosfree.
  190.  
  191.     REGS regs;
  192.     SREGS sregs;
  193.  
  194.     regs.x.ax= 0x3400;
  195.     intdosx(®s, ®s, &sregs);
  196.  
  197.     // inDOS flag (*inDOS> 0 when forground is using DOS).
  198.     inDOS= (char far *)MK_FP(sregs.es, regs.x.bx);
  199. }
  200.  
  201. // Timer interrupt routine, checks for DOS-free on the forground session.
  202. void INT8::isr(void)
  203. {
  204.     // call old interrupt vector.
  205.     old_vect();
  206.  
  207.     static int fInFlag= 0;
  208.  
  209.     // disallow recursion.
  210.     if (fInFlag)
  211.        return;
  212.  
  213.     fInFlag++;
  214.  
  215.     // allow DOSFREE to hook into the Timer also.
  216.     TimerHook();
  217.  
  218.     // run the shell function (provided that DOS is free).
  219.     if (!*inDOS)
  220.        ShellFunc();
  221.  
  222.     fInFlag--;
  223. }
  224.  
  225. // DOS idle interrupt vector.
  226. void INT28::isr(void)
  227. {
  228.     // keep all the other TSRs in the background working.
  229.     old_vect();
  230.  
  231.     static int fInFlag= 0;
  232.  
  233.     // diallow any recursion.
  234.     if (fInFlag)
  235.        return;
  236.  
  237.     fInFlag++;
  238.  
  239.     // allow DOSFREE to hook into the DOS idle usage.
  240.     DosIdleHook();
  241.  
  242.     // run the shell function.
  243.     ShellFunc();
  244.  
  245.     fInFlag--;
  246. }
  247.  
  248.