home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / database / datamage.arj / CODE.ZIP / HCWP_LIB.C next >
Encoding:
C/C++ Source or Header  |  1991-08-06  |  41.8 KB  |  2,368 lines
  1. /*****************************************************************************
  2. *                                                                            *
  3. *   The H.C.W.P. Library contains code that addresses the need to do what    *
  4. *   may be considered low-level processing.  From locating the cursor to     *
  5. *   char-by-char input, these are the routines that amount to the "ante"     *
  6. *   in a poker game.  Without them you go nowhere fast.                      *
  7. *                                                                            *
  8. *   These routines are optimized for PC hardware.  They are not, in many     *
  9. *   cases, portable across platform boundaries.  This software is written    *
  10. *   to run on a PC, AT or what have you.  IF I ever need to change platforms *
  11. *   then I will worry about it.  I don't think it will happen.               *
  12. *                                                                            *
  13. *   Every effort has been made to write code that is OBVIOUS.  Those who     *
  14. *   seek brief or "cute" code will be dis-appointed.  I hope the code can    *
  15. *   jump off the screen into my, and maybe even your head.                   *
  16. *                                                                            *
  17. *   BEFORE COMPILING THIS FILE:                                              *
  18. *                                                                            *
  19. *   The char_ok, del_char, inpt and check_heap routines at the end of this   *
  20. *   file and their prototypes have been commented out as I am using routines *
  21. *   that are "a little more complex" for input, and the check_heap function  *
  22. *   is not in use unless I'm having a heap problem.                          *
  23. *                                                                            *
  24. *   To compile MAGEDEMO.C you'll need to un-comment the inpt routine and     *
  25. *   it's two friends, char_ok and del_char.  You will also need to remove    *
  26. *   the same commenting code in HCWP_LIB.H.                                  *
  27. *                                                                            *
  28. *   Here's a lot of work for free.  If you use it PLEASE register DATAMAGE!  *
  29. *                                                                            *
  30. *****************************************************************************/
  31.  
  32. #include <malloc.h>
  33. #include <stdio.h>
  34. #include <stdlib.h>
  35. #include <string.h>
  36. #include <dos.h>
  37.  
  38. typedef char           SBYTE;
  39. typedef unsigned char  BYTE;
  40.  
  41. typedef short          SWORD;
  42. typedef unsigned short WORD;
  43.  
  44. typedef long           SDWORD;
  45. typedef unsigned long  DWORD;
  46.  
  47. BYTE attr,              /*  stores attribute, see get_vs function  */
  48.     color_enable,      /*  0 = no color, 1 = can diaplay color  */
  49.     ctrl_val,          /*  global byte, 1 of 2  */
  50.     nrml_val,          /*  global byte, 2 of 2  */
  51.     lptr,              /*  holds number of active printer  */
  52.     cga_sw = 0,        /*  1=comand line NO direct screen writes */
  53.     kybd_type,        /*  1=103 key, 0=old style  */
  54.  
  55.     user_enty [255],   /*  string to point the inpt routine at
  56.                        or, is that, at which to point?  */
  57.  
  58.      org_str [81],      /*  holds original path  */
  59.  
  60.     prompts [10] [40], /*  string space for get_v_choice  */
  61.  
  62.     c_s [3] [255],     /*  string space for cntrstrp
  63.                        and decoder functions  */
  64.  
  65.     gp_str [20] [255], /*  provides 20 general-purpose global strings  */
  66.  
  67.     far * v_ram;       /*  pointer to video ram - set by get_vs function  */
  68.  
  69. SWORD char_cntr;        /*  holds lpt pos for various lpt routines  */
  70.  
  71. union REGS regs;
  72.  
  73. typedef struct
  74.     {
  75.     BYTE ulr;
  76.     BYTE ulc;
  77.     BYTE lrr;
  78.     BYTE lrc;
  79.  
  80.     BYTE attr;
  81.  
  82.     BYTE far * save;
  83.     } window_array;
  84.  
  85. /*  allocate 10 windows  */
  86.  
  87. window_array w_a [10];
  88.  
  89. /* FUNCTIONS IN HCWP_LIB  */
  90.  
  91.     void         far range_msg             ();
  92.     void         far despacer             (BYTE);
  93.  
  94.     void           far get_vs              ();
  95.  
  96.     void           far cls                 ();
  97.     void           far clw                 (BYTE);
  98.     void           far c_clw               (BYTE, BYTE);
  99.  
  100.     void           far beep                ();
  101.  
  102.     BYTE           far set_window          (BYTE, BYTE, BYTE ,
  103.                                      BYTE, BYTE, BYTE, BYTE);
  104.  
  105.     void           far window_border       (BYTE);
  106.     void           far scroll_window       (BYTE, BYTE, BYTE);
  107.     BYTE           far save_window         (BYTE);
  108.     void           far repl_window         (BYTE);
  109.  
  110.     void           far _fastcall tele_out      (BYTE);
  111.  
  112.     BYTE           far s_read_char         ();
  113.     BYTE         far s_read_attr         ();
  114.  
  115.     void           far _fastcall crt_out       (BYTE);
  116.     void         far _fastcall c_crt_out     (BYTE, BYTE);
  117.  
  118.     void           far prnt                (BYTE *);
  119.     void           far f_prnt              (BYTE far *);
  120.  
  121.     void           far clr_prnt            (BYTE *, BYTE);
  122.     void           far f_clr_prnt          (BYTE far *, BYTE);
  123.  
  124.     void           far _fastcall line_out      (BYTE, BYTE);
  125.  
  126.     DWORD          far get_timer           ();
  127.     void           far wait                (BYTE);
  128.  
  129.     void           far _fastcall locate        (BYTE, BYTE);
  130.     void           far nrml_cursor         ();
  131.     void           far no_cursor           ();
  132.     void           far full_cursor         ();
  133.     void           far find_cursor         (BYTE *, BYTE *);
  134.  
  135.     void           far lpt_char            (BYTE);
  136.     void           far lpt_spaces          (BYTE);
  137.     void           far lpt_string          (BYTE *);
  138.     void           far lpt_f_string        (BYTE far *);
  139.     void           far lpt_tab             (WORD);
  140.  
  141.     void           far lpt_eol             ();
  142.     void           far lpt_blanks          (BYTE);
  143.  
  144.     void           far lpt_line            (BYTE, BYTE);
  145.  
  146.     void         far get_kybd_type         ();
  147.     void           far _fastcall get_one    (BYTE *, BYTE *);
  148.     BYTE         far check_shift         ();
  149.  
  150.     BYTE           far get_choice          (BYTE);
  151.     void         far y_n                 ();
  152.     void         far n_y                 ();
  153.  
  154.     BYTE         far get_v_choice        (BYTE, BYTE, BYTE *);
  155.  
  156.     void           far flush_kybd          ();
  157.     BYTE         far check_kybd         ();
  158.  
  159.     void           far see_screen          ();
  160.  
  161.     void           far rtrim               (BYTE *);
  162.     BYTE           far cntrstrp            ();
  163.  
  164.     void           far output_fail         ();
  165.     void           far mem_fail            ();
  166.  
  167.     void           far write_eol           (FILE *);
  168.     void           far eol_strip           (BYTE *);
  169.  
  170.     void           far show_help           (BYTE * helpfile);
  171.  
  172.     void           far set_far             (BYTE far *, BYTE *, WORD);
  173.     void           far set_farst           (BYTE far *, BYTE *);
  174.  
  175.     void           far get_far             (BYTE *, BYTE far *, WORD);
  176.     void           far get_farst           (BYTE *, BYTE far *);
  177.  
  178.     BYTE           far dlr_format          (BYTE, BYTE);
  179.  
  180.     void           far hard_err            (BYTE, BYTE, BYTE far *);
  181.  
  182.     BYTE         far parse_date         (BYTE *, BYTE *, BYTE *,
  183.                                           BYTE *, WORD *, double *);
  184.  
  185.     void         far ipt_box             (BYTE, BYTE, BYTE, BYTE,
  186.                                           BYTE, BYTE, BYTE *);
  187.  
  188.     // BYTE         far inpt                 (BYTE, BYTE, BYTE, BYTE,
  189.     //                                   BYTE, BYTE, BYTE *);
  190.  
  191.     // void           far check_heap          ();
  192.  
  193. /*-------------------------------------------------------------------------*/
  194.  
  195. void far range_msg ()
  196.     {
  197.     clw (3); beep(); locate (22, 24);
  198.  
  199.     prnt ("RESPONCE OUT OF RANGE - TRY AGAIN");
  200.  
  201.     wait (4);
  202.     }
  203.  
  204. void far despacer (BYTE cnvt_case)
  205.     {
  206.     BYTE c = 0, d = 0, len = strlen (c_s [0]);
  207.  
  208.     while (c < len)
  209.         {
  210.         if (c_s [0] [c] != 32)
  211.             {
  212.             c_s [2] [d] = c_s [0] [c];
  213.  
  214.             if (cnvt_case && (c_s [2] [d] > 64 && c_s [2] [d] < 91))
  215.                 c_s [2] [d] += 32;
  216.  
  217.             d++;
  218.             }
  219.  
  220.           c++;
  221.         }
  222.  
  223.     c_s [2] [d] = 0;
  224.     }
  225.  
  226. BYTE far cntrstrp ()
  227.  
  228. /*  combines two strings in c_s [0] and c_s [1], returns number of chars to
  229.     space over to center strings.  */
  230.     {
  231.     BYTE wfg = 0, addsw = 0, x, y;
  232.  
  233.     rtrim (c_s [0]); rtrim (c_s [1]);
  234.  
  235.     while (! wfg)
  236.         {
  237.         strcpy (c_s [2], c_s [0]);
  238.         strcat (c_s [2], " ");
  239.  
  240.         if (addsw) strcat (c_s [2], " ");
  241.  
  242.         strcat (c_s [2], c_s [1]);
  243.  
  244.         x = y = strlen (c_s [2]);
  245.  
  246.         /*  emulate BASIC's MOD function  */
  247.  
  248.         while (y >= 2) y -= 2;
  249.  
  250.         if (y) addsw = 1;
  251.         else wfg = 1;
  252.         }
  253.  
  254.     return ((80 - x) / 2);
  255.     }
  256.  
  257. void far set_farst (BYTE far * target, BYTE * source)
  258.     {
  259. /*  sets near string into far memory  */
  260.  
  261.     WORD register x = 0;
  262.  
  263.     while (source [x] && source [x] != 10 && source [x] != 13)
  264.         target [x++] = source [x];
  265.  
  266.     target [x] = 0;
  267.     }
  268.  
  269. void far get_farst (BYTE * target, BYTE far * source)
  270.     {
  271. /*  sets far string into near memory  */
  272.  
  273.     WORD register x = 0;
  274.  
  275.     while (source [x]) target [x++] = source [x];
  276.  
  277.     target [x] = 0;
  278.     }
  279.  
  280. void far set_far (BYTE far * target, BYTE * source, WORD count)
  281.     {
  282. /*  sets near BYTES into far BYTES  */
  283.  
  284.     WORD register x;
  285.  
  286.     for (x = 0; x < count; x++) * (target + x) = * (source + x);
  287.     }
  288.  
  289. void far get_far (BYTE * target, BYTE far * source, WORD count)
  290.     {
  291. /*  sets far BYTES into near BYTES  */
  292.  
  293.     WORD register x = 0;
  294.  
  295.     while (x < count) * (target + x++) = * (source + x);
  296.     }
  297.  
  298. void far _fastcall locate (BYTE row, BYTE col)
  299.     {
  300. /*  locates the cursor  */
  301.  
  302.     regs.h.ah = 2; regs.h.bh = 0;
  303.     regs.h.dh = row; regs.h.dl = col;
  304.  
  305.     int86 (16, ®s, ®s);
  306.     }
  307.  
  308. void far find_cursor (BYTE * row, BYTE * col)
  309.     {
  310. /*  finds cursor  */
  311.  
  312.     regs.h.ah = 3;
  313.     regs.h.al = 0;
  314.  
  315.     int86 (16, ®s, ®s);
  316.  
  317.     * row = regs.h.dh;
  318.     * col = regs.h.dl;
  319.     }
  320.  
  321. void far nrml_cursor ()
  322.     {
  323. /*  sets normal cursor  */
  324.  
  325.     regs.h.ah = 1;
  326.     regs.h.cl = 7;
  327.     regs.h.ch = 6;
  328.  
  329.     int86 (16, ®s, ®s);
  330.     }
  331.  
  332. void far full_cursor ()
  333.     {
  334. /*  sets fat cursor  */
  335.  
  336.     regs.h.ah = 1;
  337.     regs.h.cl = 7;
  338.     regs.h.ch = 0;
  339.  
  340.     int86 (16, ®s, ®s);
  341.     }
  342.  
  343. void far no_cursor ()
  344.     {
  345. /*  turns cursor off  */
  346.  
  347.     regs.h.ah = 1;
  348.     regs.h.ch = 32;
  349.     regs.h.cl = 0;
  350.  
  351.     int86 (16, ®s, ®s);
  352.     }
  353.  
  354. void far prnt (BYTE * target)
  355. {
  356. /*  prints target string to screen  */
  357.  
  358.     BYTE register y = 0;
  359.  
  360.     BYTE row, col, far * t_ram;
  361.  
  362.     switch (cga_sw)
  363.         {
  364.         case 2: _disable;
  365.  
  366.         case 0:
  367.             {
  368.             find_cursor (& row, & col);
  369.  
  370.             t_ram = v_ram + (row * 160) + (col * 2);
  371.  
  372.             while (target [y])
  373.                 {
  374.                 if (cga_sw == 2)
  375.                     {
  376.                     _asm
  377.                         {
  378.                         mov    dx, 986
  379.  
  380. Loop1:
  381.  
  382.                         in    al, dx
  383.                         and    al, 1
  384.                         jnz    Loop1
  385.  
  386. Loop2:
  387.  
  388.                         in    al, dx
  389.                         and    al, 1
  390.                         je    Loop2
  391.                         }
  392.  
  393.                          }
  394.  
  395.                 * t_ram = target [y++];
  396.  
  397.                 t_ram += 2;
  398.                 }
  399.  
  400.             locate (row, col + y);
  401.  
  402.             _enable;
  403.  
  404.             break;
  405.             }
  406.  
  407.         case 1:
  408.             {
  409.             while (target [y])
  410.                 {
  411.                 regs.h.ah = 14;
  412.                 regs.h.al = target [y++];
  413.  
  414.                 int86 (16, ®s, ®s);
  415.                 }
  416.             }
  417.  
  418.         }
  419.  
  420.     }
  421.  
  422. void far f_prnt (BYTE far * target)
  423.     {
  424. /*  prints FAR target string to screen  */
  425.  
  426.     BYTE register y = 0;
  427.  
  428.     BYTE row, col, far * t_ram;
  429.  
  430.     switch (cga_sw)
  431.         {
  432.         case 2: _disable;
  433.  
  434.         case 0:
  435.             {
  436.             find_cursor (& row, & col);
  437.  
  438.             t_ram = v_ram + (row * 160) + (col * 2);
  439.  
  440.             while (target [y])
  441.                 {
  442.                 if (cga_sw == 2)
  443.                     {
  444.                     _asm
  445.                         {
  446.                         mov    dx, 986
  447.  
  448. Loop1:
  449.  
  450.                         in    al, dx
  451.                         and    al, 1
  452.                         jnz    Loop1
  453.  
  454. Loop2:
  455.  
  456.                         in    al, dx
  457.                         and    al, 1
  458.                         je    Loop2
  459.                         }
  460.  
  461.                          }
  462.  
  463.                 * t_ram = target [y++];
  464.  
  465.                 t_ram += 2;
  466.                 }
  467.  
  468.             locate (row, col + y);
  469.  
  470.             _enable;
  471.  
  472.             break;
  473.             }
  474.  
  475.         case 1:
  476.             {
  477.             while (target [y])
  478.                 {
  479.                 regs.h.ah = 14;
  480.                 regs.h.al = target [y++];
  481.  
  482.                 int86 (16, ®s, ®s);
  483.                 }
  484.  
  485.             }
  486.  
  487.         }
  488.  
  489.     }
  490.  
  491. void far clr_prnt (BYTE * target, BYTE attr)
  492.     {
  493. /*  prints string on screen with color passed  */
  494.  
  495.     BYTE row, col, y = 0;
  496.  
  497.     BYTE far * t_ram;
  498.  
  499.     find_cursor (& row, & col);
  500.  
  501.     switch (cga_sw)
  502.         {
  503.         case 2: _disable;
  504.  
  505.         case 0:
  506.             {
  507.             t_ram = v_ram + (row * 160) + (col * 2);
  508.  
  509.             while (target [y])
  510.                 {
  511.                 /*  if cga in use  */
  512.  
  513.                 if (cga_sw == 2)
  514.                     {
  515.                     _asm
  516.                         {
  517.                         mov    dx, 986
  518.  
  519. Loop1:
  520.  
  521.                         in    al, dx
  522.                         and    al, 1
  523.                         jnz    Loop1
  524.  
  525. Loop2:
  526.  
  527.                         in    al, dx
  528.                         and    al, 1
  529.                         je    Loop2
  530.                         }
  531.  
  532.                          }
  533.  
  534.                 * (t_ram++) = target [y++];
  535.  
  536.                 /*  if cga in use  */
  537.  
  538.                 if (cga_sw == 2)
  539.                     {
  540.                     _asm
  541.                         {
  542.                         mov    dx, 986
  543.  
  544. Loop3:
  545.  
  546.                         in    al, dx
  547.                         and    al, 1
  548.                         jnz    Loop3
  549.  
  550. Loop4:
  551.  
  552.                         in    al, dx
  553.                         and    al, 1
  554.                         je    Loop4
  555.                         }
  556.  
  557.                          }
  558.  
  559.                 /*  store attribute  */
  560.  
  561.                 * (t_ram++) = attr;
  562.                 }
  563.  
  564.             locate (row, col + y);
  565.  
  566.             _enable;
  567.  
  568.             break;
  569.             }
  570.  
  571.         case 1:
  572.             {
  573.             regs.h.dh = row; regs.h.dl = col; regs.h.bh = 0;
  574.  
  575.             while (target [y])
  576.                 {
  577.                 regs.h.ah = 9;
  578.                 regs.h.al = target [y++];
  579.                 regs.h.bl = attr;
  580.                 regs.x.cx = 1;
  581.  
  582.                 int86 (16, ®s, ®s);
  583.  
  584.                 regs.h.ah = 2;
  585.                 regs.h.dl++;
  586.  
  587.                 int86 (16, ®s, ®s);
  588.                 }
  589.  
  590.             }
  591.  
  592.         }
  593.  
  594.     }
  595.  
  596. void far f_clr_prnt (BYTE far * target, BYTE attr)
  597.     {
  598. /*  prints FAR string on screen with color passed  */
  599.  
  600.     BYTE row, col, y = 0;
  601.  
  602.     BYTE far * t_ram;
  603.  
  604.     find_cursor (& row, & col);
  605.  
  606.     switch (cga_sw)
  607.         {
  608.         case 2: _disable;
  609.  
  610.         case 0:
  611.             {
  612.             t_ram = v_ram + (row * 160) + (col * 2);
  613.  
  614.             while (target [y])
  615.                 {
  616.                 /*  if cga in use  */
  617.  
  618.                 if (cga_sw == 2)
  619.                     {
  620.                     _asm
  621.                         {
  622.                         mov    dx, 986
  623.  
  624. Loop1:
  625.  
  626.                         in    al, dx
  627.                         and    al, 1
  628.                         jnz    Loop1
  629.  
  630. Loop2:
  631.  
  632.                         in    al, dx
  633.                         and    al, 1
  634.                         je    Loop2
  635.                         }
  636.  
  637.                          }
  638.  
  639.                 * (t_ram++) = target [y++];
  640.  
  641.                 /*  if cga in use  */
  642.  
  643.                 if (cga_sw == 2)
  644.                     {
  645.                     _asm
  646.                         {
  647.                         mov    dx, 986
  648.  
  649. Loop3:
  650.  
  651.                         in    al, dx
  652.                         and    al, 1
  653.                         jnz    Loop3
  654.  
  655. Loop4:
  656.  
  657.                         in    al, dx
  658.                         and    al, 1
  659.                         je    Loop4
  660.                         }
  661.  
  662.                          }
  663.  
  664.                 /*  store attribute  */
  665.  
  666.                 * (t_ram++) = attr;
  667.                 }
  668.  
  669.             locate (row, col + y);
  670.  
  671.             _enable;
  672.  
  673.             break;
  674.             }
  675.  
  676.         case 1:
  677.             {
  678.             regs.h.dh = row; regs.h.dl = col; regs.h.bh = 0;
  679.  
  680.             while (target [y])
  681.                 {
  682.                 regs.h.ah = 9;
  683.                 regs.h.al = target [y++];
  684.                 regs.h.bl = attr;
  685.                 regs.x.cx = 1;
  686.  
  687.                 int86 (16, ®s, ®s);
  688.  
  689.                 regs.h.ah = 2;
  690.                 regs.h.dl++;
  691.  
  692.                 int86 (16, ®s, ®s);
  693.                 }
  694.  
  695.             }
  696.  
  697.         }
  698.  
  699.     }
  700.  
  701. void far mem_fail ()
  702.     {
  703.     clw (3); locate (22, 25);
  704.     prnt ("This computer's out of memory!");
  705.     beep (); wait (4);
  706.     }
  707.  
  708. void far cls ()
  709.     {
  710. /*  clears entire screen to color in attr  */
  711.  
  712.     regs.h.ah = 7; regs.h.al = 0;
  713.     regs.h.ch = 0; regs.h.cl = 0;
  714.     regs.h.dh = 24; regs.h.dl = 79;
  715.     regs.h.bh = attr;
  716.  
  717.     int86 (16, ®s, ®s);
  718.     }
  719.  
  720. void far clw (BYTE w)
  721.     {
  722. /*  clears windows to their color  */
  723.  
  724.     regs.h.ah = 7; regs.h.al = 0;
  725.     regs.h.ch = w_a [w]. ulr;
  726.     regs.h.cl = w_a [w] .ulc;
  727.     regs.h.dh = w_a [w] .lrr;
  728.     regs.h.dl = w_a [w] .lrc;
  729.     regs.h.bh = w_a [w] .attr;
  730.  
  731.     int86 (16, ®s, ®s);
  732.     }
  733.  
  734. void far c_clw (BYTE w, BYTE atr)
  735.     {
  736. /*  clears windows to specified color  */
  737.  
  738.     regs.h.ah = 7; regs.h.al = 0;
  739.     regs.h.ch = w_a [w]. ulr;
  740.     regs.h.cl = w_a [w] .ulc;
  741.     regs.h.dh = w_a [w] .lrr;
  742.     regs.h.dl = w_a [w] .lrc;
  743.     regs.h.bh = atr;
  744.  
  745.     int86 (16, ®s, ®s);
  746.     }
  747.  
  748. void far get_vs ()
  749.     {
  750. /*  gets video adaptor type, color or mono  */
  751.  
  752.     BYTE d, test;
  753.  
  754.     regs.h.ah = 15;
  755.     int86 (16, & regs, & regs);
  756.  
  757.     if (regs.h.ah != 80) {attr = 0; return;}
  758.  
  759.     locate (0,0);
  760.  
  761.     /*  test for mono  */
  762.  
  763.      v_ram = (BYTE far *) 0xb0000000;
  764.  
  765.     test = * v_ram; * v_ram = 255;
  766.  
  767.     d = s_read_char ();
  768.  
  769.     if (d == 255) {attr = 7; color_enable = 0;}
  770.  
  771.     /*  must be color  */
  772.  
  773.     else
  774.         {
  775.         * v_ram = test;
  776.  
  777.         attr = 27; color_enable = 1;
  778.  
  779.         v_ram = (BYTE far *) 0xb8000000;
  780.         }
  781.  
  782.     }
  783.  
  784. BYTE far set_window (BYTE w, BYTE ulr, BYTE ulc, BYTE lrr,
  785.                      BYTE lrc, BYTE attr, BYTE save_it)
  786.     {
  787. /*  defines window  */
  788.  
  789.     WORD size;
  790.  
  791.     w_a [w]. ulr = ulr;
  792.     w_a [w]. ulc = ulc;
  793.     w_a [w]. lrr = lrr;
  794.     w_a [w]. lrc = lrc;
  795.     w_a [w]. attr = attr;
  796.  
  797.     if (save_it)
  798.         {
  799.         size = ((w_a [w] .lrc - w_a [w] .ulc + 1)
  800.             * (w_a [w] .lrr - w_a [w] .ulr + 1)) * 2;
  801.  
  802.         if ((w_a [w].save = _fmalloc (size) ) == NULL)
  803.             {mem_fail(); return (1);}
  804.  
  805.         }
  806.  
  807.     else w_a [w].save = NULL;
  808.  
  809.     return (0);
  810.     }
  811.  
  812. void far scroll_window (BYTE w, BYTE ctrl, BYTE lines)
  813.     {
  814. /*  scrolls windows up/down  */
  815.  
  816.     BYTE ud;
  817.  
  818.     switch (ctrl)
  819.         {
  820.         case 1: ud = 6; break;
  821.  
  822.         case 2: ud = 7;
  823.         }
  824.  
  825.     regs.h.ah = ud; regs.h.al = lines;
  826.     regs.h.ch = w_a [w] .ulr;
  827.     regs.h.cl = w_a [w] .ulc;
  828.     regs.h.dh = w_a [w] .lrr;
  829.     regs.h.dl = w_a [w] .lrc;
  830.     regs.h.bh = w_a [w] .attr;
  831.  
  832.     int86 (16, ®s, ®s);
  833.     }
  834.  
  835. BYTE far save_window (BYTE w)
  836.     {
  837. /*  saves text in windows  */
  838.  
  839.     BYTE c, cols, d, r, rows, x;
  840.  
  841.     BYTE far * incr, far * v_tgt;
  842.  
  843.     rows = w_a [w] .lrr - w_a [w] .ulr + 1;
  844.     cols = (w_a [w] .lrc - w_a [w] .ulc + 1) * 2;
  845.  
  846.     if (cga_sw != 1)
  847.         {
  848.         if (cga_sw == 2) _disable;
  849.  
  850.         for (r = 0; r < rows; r++)
  851.             {
  852.             v_tgt = v_ram + (((w_a [w].ulr + r) * 160)
  853.                     + (w_a [w].ulc * 2));
  854.  
  855.             incr = w_a [w] .save  + (r * cols);
  856.  
  857.             for (c = x = 0; c < cols;)
  858.                 {
  859.                 /*  if cga in use  */
  860.  
  861.                 if (cga_sw == 2)
  862.                     {
  863.                     _asm
  864.                         {
  865.                         mov    dx, 986
  866.  
  867. Loop1:
  868.  
  869.                         in    al, dx
  870.                         and    al, 1
  871.                         jnz    Loop1
  872.  
  873. Loop2:
  874.  
  875.                         in    al, dx
  876.                         and    al, 1
  877.                         je    Loop2
  878.                         }
  879.  
  880.                          }
  881.  
  882.                 /*  read char  */
  883.  
  884.                 * (incr + c++) = * (v_tgt + x++);
  885.  
  886.                 /*  if cga in use  */
  887.  
  888.                 if (cga_sw == 2)
  889.                     {
  890.                     _asm
  891.                         {
  892.                         mov    dx, 986
  893.  
  894. Loop3:
  895.  
  896.                         in    al, dx
  897.                         and    al, 1
  898.                         jnz    Loop3
  899.  
  900. Loop4:
  901.  
  902.                         in    al, dx
  903.                         and    al, 1
  904.                         je    Loop4
  905.                         }
  906.  
  907.                          }
  908.  
  909.                 /*  read attribute  */
  910.  
  911.                 * (incr + c++) = * (v_tgt + x++);
  912.                 }
  913.  
  914.             }
  915.  
  916.         _enable;
  917.         }
  918.  
  919.     else
  920.         {
  921.  
  922.         regs.h.bl = 0; regs.h.bh = 0;
  923.  
  924.         for (r = 0; r < rows; r++)
  925.             {
  926.             incr = w_a [w] .save  + (r * cols);
  927.  
  928.             regs.h.dh = w_a [w] .ulr + r;
  929.  
  930.             for (d = c = 0; c < cols;)
  931.                 {
  932.                 /*  locate  */
  933.  
  934.                 regs.h.ah = 2;
  935.                 regs.h.dl = w_a [w] .ulc + (d++);
  936.  
  937.                 int86 (16, ®s, ®s);
  938.  
  939.                 /*  get char and attribute */
  940.  
  941.                 regs.h.ah = 8;
  942.                 int86 (16, ®s, ®s);
  943.  
  944.                 * (incr + c++) = regs.h.al;
  945.                 * (incr + c++) = regs.h.ah;
  946.                 }
  947.  
  948.             }
  949.  
  950.         }
  951.  
  952.     return (0);
  953.     }
  954.  
  955. void far repl_window (BYTE w)
  956.     {
  957. /*  replaces previously saved text into windows - WINDOW MUST BE SAVED first!  */
  958.  
  959.     BYTE c, cols, d, r, rows, x;
  960.  
  961.     BYTE far * incr, far * v_tgt;
  962.  
  963.     rows = w_a [w] .lrr - w_a [w] .ulr + 1;
  964.     cols = (w_a [w] .lrc - w_a [w] .ulc + 1) * 2;
  965.  
  966.     if (cga_sw != 1)
  967.         {
  968.         if (cga_sw == 2) _disable;
  969.  
  970.         for (r = 0; r < rows; r++)
  971.             {
  972.             v_tgt = v_ram + (((w_a [w].ulr + r) * 160)
  973.                     + (w_a [w].ulc * 2));
  974.  
  975.             incr = w_a [w] .save + (r * cols);
  976.  
  977.             for (c = x = 0; c < cols;)
  978.                 {
  979.                 /*  if cga in use  */
  980.  
  981.                 if (cga_sw == 2)
  982.                     {
  983.                     _asm
  984.                         {
  985.                         mov    dx, 986
  986.  
  987. Loop1:
  988.  
  989.                         in    al, dx
  990.                         and    al, 1
  991.                         jnz    Loop1
  992.  
  993. Loop2:
  994.  
  995.                         in    al, dx
  996.                         and    al, 1
  997.                         je    Loop2
  998.                         }
  999.  
  1000.                          }
  1001.  
  1002.                 /*  store character  */
  1003.  
  1004.                 * (v_tgt + x++) = * (incr + c++);
  1005.  
  1006.                 /*  if cga in use  */
  1007.  
  1008.                 if (cga_sw == 2)
  1009.                     {
  1010.                     _asm
  1011.                         {
  1012.                         mov    dx, 986
  1013.  
  1014. Loop3:
  1015.  
  1016.                         in    al, dx
  1017.                         and    al, 1
  1018.                         jnz    Loop3
  1019.  
  1020. Loop4:
  1021.  
  1022.                         in    al, dx
  1023.                         and    al, 1
  1024.                         je    Loop4
  1025.                         }
  1026.  
  1027.                          }
  1028.  
  1029.                 /*  store attribute  */
  1030.  
  1031.                 * (v_tgt + x++) = * (incr + c++);
  1032.                 }
  1033.  
  1034.             }
  1035.  
  1036.         _enable;
  1037.         }
  1038.  
  1039.     else
  1040.         {
  1041.         regs.h.bh = 0; regs.x.cx = 1;
  1042.  
  1043.         for (r = 0; r < rows; r++)
  1044.             {
  1045.             incr = w_a [w] .save  + (r * cols);
  1046.  
  1047.             regs.h.dh = w_a [w].ulr + r;
  1048.  
  1049.             for (d = c = 0; c < cols;)
  1050.                 {
  1051.                 /* locate  */
  1052.  
  1053.                 regs.h.ah = 2;
  1054.                 regs.h.dl = w_a [w] .ulc + (d++);
  1055.  
  1056.                 int86 (16, ®s, ®s);
  1057.  
  1058.                 /*  write char and attribute  */
  1059.  
  1060.                 regs.h.ah = 9;
  1061.                 regs.h.al = * (incr + c++);
  1062.                 regs.h.bl = * (incr + c++);
  1063.  
  1064.                 int86 (16, ®s, ®s);
  1065.                 }
  1066.  
  1067.             }
  1068.  
  1069.         }
  1070.  
  1071.     }
  1072.  
  1073. BYTE far s_read_char ()
  1074.     {
  1075. /*  readc char from screen  */
  1076.  
  1077.     regs.h.ah = 8;
  1078.     regs.h.bh = 0;
  1079.  
  1080.     int86 (16, ®s, ®s);
  1081.  
  1082.     return (regs.h.al);
  1083.     }
  1084.  
  1085. BYTE far s_read_attr ()
  1086.     {
  1087. /*  readc attribute from screen  */
  1088.  
  1089.     regs.h.ah = 8;
  1090.     regs.h.bh = 0;
  1091.  
  1092.     int86 (16, ®s, ®s);
  1093.  
  1094.     return (regs.h.ah);
  1095.     }
  1096.  
  1097. void far _fastcall tele_out (BYTE ch)
  1098.     {
  1099. /*  prints char, advances cursor  */
  1100.  
  1101.     regs.h.ah = 14;
  1102.     regs.h.al = ch;
  1103.  
  1104.     int86 (16, ®s, ®s);
  1105.     }
  1106.  
  1107. void far _fastcall crt_out (BYTE ch)
  1108.     {
  1109. /*  prints char, no advances cursor  */
  1110.  
  1111.     regs.h.ah = 10;
  1112.     regs.h.al = ch;
  1113.     regs.h.bh = 0;
  1114.     regs.x.cx = 1;
  1115.  
  1116.     int86 (16, ®s, ®s);
  1117.     }
  1118.  
  1119. void far _fastcall c_crt_out (BYTE ch, BYTE atr)
  1120.     {
  1121. /*  prints char, no advances cursor  */
  1122.  
  1123.     regs.h.ah = 9;
  1124.     regs.h.al = ch;
  1125.     regs.h.bh = 0;
  1126.     regs.h.bl = atr;
  1127.     regs.x.cx = 1;
  1128.  
  1129.     int86 (16, ®s, ®s);
  1130.     }
  1131.  
  1132. void far _fastcall line_out (BYTE nmbr, BYTE ch)
  1133.     {
  1134. /*  prints line of chars, no advances cursor  */
  1135.  
  1136.     regs.h.ah = 10;
  1137.     regs.h.al = ch;
  1138.     regs.h.bh = 0;
  1139.     regs.x.cx = nmbr;
  1140.  
  1141.     int86 (16, ®s, ®s);
  1142.     }
  1143.  
  1144. DWORD far get_timer ()
  1145.     {
  1146. /*  gets dos time interger  */
  1147.  
  1148.     regs.h.ah = 0;
  1149.     int86 (26, ®s, ®s);
  1150.     return (regs.x.cx * 0x10000) + regs.x.dx;
  1151.     }
  1152.  
  1153. void far wait (BYTE w)
  1154.     {
  1155. /*  clock independant wait  */
  1156.  
  1157.     DWORD a, b;
  1158.  
  1159.     a = get_timer ();
  1160.     b = a + (w * 18.2);
  1161.  
  1162.     while (a < b) a = get_timer ();
  1163.     }
  1164.  
  1165. void far lpt_char (BYTE c)
  1166.     {
  1167. /*   puts char to line printer in global flag lptr, 0 = lpt1, etc  */
  1168.  
  1169.     regs.h.ah = 0;
  1170.     regs.h.al = c;
  1171.     regs.x.dx = lptr;
  1172.  
  1173.     int86(23, ®s, ®s);
  1174.  
  1175.     if (c == 12 || c == 13) char_cntr = 0;
  1176.     else char_cntr++;
  1177.     }
  1178.  
  1179. void far lpt_spaces (BYTE no)
  1180.     {
  1181.     BYTE register d;
  1182.  
  1183.     for (d = 0; d < no; d++) lpt_char (32);
  1184.     }
  1185.  
  1186. void far lpt_string (BYTE * t_str)
  1187.     {
  1188. /*  lprints string from memory  */
  1189.  
  1190.     BYTE register d = 0;
  1191.  
  1192.     while (t_str [d]) lpt_char (t_str [d++]);
  1193.     }
  1194.  
  1195. void far lpt_f_string (BYTE far * t_str)
  1196.     {
  1197. /*  lprints string from FAR memory  */
  1198.  
  1199.     BYTE register d = 0;
  1200.  
  1201.     while (t_str [d]) lpt_char (t_str [d++]);
  1202.     }
  1203.  
  1204. void far lpt_tab (WORD no)
  1205.     {
  1206.     WORD register d;
  1207.  
  1208.     if (no > char_cntr)
  1209.         for (d = char_cntr; d <= no; d++) lpt_char (32);
  1210.  
  1211.     char_cntr = no;
  1212.     }
  1213.  
  1214. void far lpt_eol ()
  1215.     {
  1216.     lpt_char (10); lpt_char (13); char_cntr = 0;
  1217.     }
  1218.  
  1219. void far lpt_blanks (BYTE howmany)
  1220.     {
  1221.     BYTE d;
  1222.  
  1223.     for (d = 0; d < howmany; d++) lpt_eol ();
  1224.     }
  1225.  
  1226. void far lpt_line (BYTE no, BYTE c)
  1227.     {
  1228.     BYTE register d;
  1229.  
  1230.     for (d = 1; d < no; d++) lpt_char (c);
  1231.     }
  1232.  
  1233. void far beep ()
  1234.     {
  1235.      _asm
  1236.         {
  1237.           mov ah, 2
  1238.           mov dl, 7
  1239.           int 21h
  1240.           }
  1241.  
  1242.     }
  1243.  
  1244. void far get_kybd_type ()
  1245.     {
  1246. /*  returns 1 for 103 key, or 0  */
  1247.  
  1248.     regs.x.ax = 0x12ff;
  1249.  
  1250.     int86 (22, ®s, ®s);
  1251.  
  1252.     kybd_type = ! (regs.h.al == 0xff);
  1253.     }
  1254.  
  1255. void far _fastcall get_one (BYTE * c_val, BYTE * n_val)
  1256.     {
  1257. /*  calls bios keyboard to get chars hit  */
  1258.  
  1259.     if (kybd_type)
  1260.         {
  1261.         regs.h.ah = 16;
  1262.  
  1263.         int86 (22, ®s, ®s);
  1264.  
  1265.         * c_val = regs.h.ah;
  1266.         * n_val = regs.h.al;
  1267.  
  1268.         if (* n_val == 224) * n_val = 0;
  1269.         }
  1270.  
  1271.     else
  1272.         {
  1273.         regs.h.ah = 0;
  1274.  
  1275.         int86 (22, ®s, ®s);
  1276.  
  1277.         * c_val = regs.h.ah;
  1278.         * n_val = regs.h.al;
  1279.         }
  1280.  
  1281.     }
  1282.  
  1283. BYTE far check_shift ()
  1284.     {
  1285.     /*  check shift key  */
  1286.  
  1287.     BYTE a, b;
  1288.  
  1289.     if (kybd_type) regs.h.ah = 18;
  1290.     else regs.h.ah = 2;
  1291.  
  1292.     int86 (22, ®s, ®s);
  1293.  
  1294.     a = b = regs.h.al;
  1295.  
  1296.     if (a & 1 || b & 2) return (1);
  1297.  
  1298.     return (0);
  1299.     }
  1300.  
  1301. BYTE far get_choice (BYTE choices)
  1302.     {
  1303. /*  gets choices from kybd, max allowed is passed, returns legal choice  */
  1304.  
  1305. intake:
  1306.  
  1307.     get_one (& ctrl_val, & nrml_val);
  1308.  
  1309.     if (nrml_val < 49 || nrml_val > choices + 48) {beep (); goto intake;}
  1310.  
  1311.     return (nrml_val - 48);
  1312.     }
  1313.  
  1314. void far y_n ()
  1315.     {
  1316.     strcpy (prompts [1], "1=YES");
  1317.     strcpy (prompts [2], "2=NO");
  1318.     }
  1319.  
  1320. void far n_y ()
  1321.     {
  1322.     strcpy (prompts [1], "1=NO");
  1323.     strcpy (prompts [2], "2=YES");
  1324.     }
  1325.  
  1326. BYTE far get_v_choice (BYTE choices, BYTE help_avail, BYTE * helpfile)
  1327.     {
  1328.     BYTE a, d, c, clr, ctrl_val, nrml_val, pt1,
  1329.          pt2, ret_val, wfg = 0, * where;
  1330.  
  1331.     BYTE starts [10];
  1332.  
  1333.     no_cursor();
  1334.  
  1335.     a = ((w_a [3].attr & 7) << 4);
  1336.     c = ((w_a [3].attr & 112) >> 4);
  1337.  
  1338.     clr = a + c;
  1339.  
  1340.     if (w_a [3].attr & 8) clr += 8;
  1341.  
  1342.     strcpy (c_s [0], prompts [0]);
  1343.  
  1344.     c_s [1] [0] = 0; starts [0] = 0;
  1345.  
  1346.     for (d = 1; d <= choices; d++)
  1347.         {
  1348.         starts [d] = strlen (c_s [1]);
  1349.  
  1350.         strcat (c_s [1], prompts [d]);
  1351.         strcat (c_s [1], "  ");
  1352.         }
  1353.  
  1354.     a = cntrstrp ();
  1355.  
  1356.     where = strstr (c_s [2], prompts [1]);
  1357.  
  1358.     c = (where - c_s [2]) + a;
  1359.  
  1360.     for (d = 1; d <= choices; d++) starts [d] += c;
  1361.  
  1362.     clw (3); locate (22, a);
  1363.     prnt (c_s [2]);
  1364.  
  1365.     if (help_avail)
  1366.         {
  1367.         locate (23,23);
  1368.         prnt ("PRESS THE H KEY FOR ON-SCREEN HELP");
  1369.         }
  1370.  
  1371.     d = choices / 2;
  1372.  
  1373.     locate (22, starts [d]);
  1374.     clr_prnt (prompts [d], clr);
  1375.  
  1376.     while (! wfg)
  1377.         {
  1378.         get_one (& ctrl_val, & nrml_val);
  1379.  
  1380.         if (nrml_val)
  1381.             {
  1382.             switch (nrml_val)
  1383.                 {
  1384.                 case 13:
  1385.                     {
  1386.                     ret_val = d;
  1387.  
  1388.                     wfg = 1;
  1389.  
  1390.                     break;
  1391.                     }
  1392.  
  1393.                 case 'h':
  1394.                 case 'H':
  1395.                     {
  1396.                     if (! help_avail) {beep (); continue;}
  1397.                     save_window (2);
  1398.                     save_window (3);
  1399.  
  1400.                     show_help (helpfile);
  1401.  
  1402.                     repl_window (2);
  1403.                     repl_window (3);
  1404.                     break;
  1405.                     }
  1406.  
  1407.                 default:
  1408.                     {
  1409.                     if (nrml_val > 48 && nrml_val < choices + 49)
  1410.                         {
  1411.                         ret_val = nrml_val - 48;
  1412.  
  1413.                         wfg = 1;
  1414.                         }
  1415.  
  1416.                     else beep();
  1417.                     }
  1418.  
  1419.                 }
  1420.  
  1421.             continue;
  1422.              }
  1423.  
  1424.         if (ctrl_val)
  1425.             {
  1426.             switch (ctrl_val)
  1427.                 {
  1428.                 case 75:
  1429.                     {
  1430.                     locate (22, starts [d]);
  1431.                     clr_prnt (prompts [d], w_a [3].attr);
  1432.  
  1433.                     d -= 1;
  1434.  
  1435.                     if (d < 1) d = choices;
  1436.  
  1437.                     locate (22, starts [d]);
  1438.                     clr_prnt (prompts [d], clr);
  1439.  
  1440.                     break;
  1441.                     }
  1442.  
  1443.                 case 77:
  1444.                     {
  1445.                     locate (22, starts [d]);
  1446.                     clr_prnt (prompts [d], w_a [3].attr);
  1447.  
  1448.                     d += 1;
  1449.  
  1450.                     if (d > choices) d = 1;
  1451.  
  1452.                     locate (22, starts [d]);
  1453.                     clr_prnt (prompts [d], clr);
  1454.  
  1455.                     break;
  1456.                     }
  1457.  
  1458.                 default: beep();
  1459.                 }
  1460.  
  1461.             continue;
  1462.             }
  1463.  
  1464.         }
  1465.  
  1466.     return (ret_val);
  1467.     }
  1468.  
  1469. BYTE far check_kybd ()
  1470.     {
  1471. /*  is a char waiting?  */
  1472.  
  1473.     regs.h.ah = 11;
  1474.  
  1475.     int86 (33, ®s, ®s);
  1476.  
  1477.     if (regs.h.al == 0) return (0);
  1478.     return (1);
  1479.     }
  1480.  
  1481. void far flush_kybd ()
  1482.     {
  1483. /*  empties keyboard buffer  */
  1484.  
  1485.     BYTE bool;
  1486.  
  1487.     bool = check_kybd ();
  1488.  
  1489.     while (bool)
  1490.         {
  1491.         get_one (& ctrl_val, & nrml_val);
  1492.         bool = check_kybd ();
  1493.         }
  1494.  
  1495.     }
  1496.  
  1497. void far see_screen ()
  1498.     {
  1499.     clw(3); locate (22, 27); prnt ("Press any key to continue:");
  1500.     get_one (& ctrl_val, & nrml_val);
  1501.     }
  1502.  
  1503. void far output_fail ()
  1504.     {
  1505.     beep (); clw (3); locate (23,19);
  1506.     prnt ("Unable to open output file!");
  1507.     wait (4);
  1508.     }
  1509.  
  1510. void far rtrim (BYTE * str)
  1511.     {
  1512. /*  removes trailing spaces  */
  1513.  
  1514.     BYTE wfg = 0;
  1515.  
  1516.     SWORD x = strlen (str);
  1517.  
  1518.     while (! wfg && x > -1)
  1519.         {
  1520.         if (str [x] && str [x] != 32) wfg = 1;
  1521.         else x--;
  1522.         }
  1523.  
  1524.     str [++x] = 0;
  1525.     }
  1526.  
  1527. void far window_border (BYTE w)
  1528.     {
  1529. /*  borders window passed  */
  1530.  
  1531.     BYTE register d;
  1532.  
  1533.     clw (w);
  1534.  
  1535.     locate (w_a [w] .ulr, w_a [w] .ulc);
  1536.     tele_out (201);
  1537.     locate (w_a [w] .ulr, w_a [w] .ulc + 1);
  1538.     line_out (w_a [w] .lrc - w_a [w] .ulc, 205);
  1539.     locate (w_a [w] .ulr, w_a [w] .lrc);
  1540.     tele_out (187);
  1541.  
  1542.     for (d = w_a [w] .ulr + 1; d < w_a [w] .lrr; d++)
  1543.         {
  1544.         locate (d, w_a [w] .ulc); tele_out (186);
  1545.         locate (d, w_a [w] .lrc); tele_out (186);
  1546.         }
  1547.  
  1548.     locate (w_a [w] .lrr, w_a [w] .ulc);
  1549.     tele_out (200);
  1550.     locate (w_a [w] .lrr, w_a [w] .ulc + 1);
  1551.     line_out (w_a [w] .lrc - w_a [w] .ulc, 205);
  1552.     locate (w_a [w] .lrr, w_a [w] .lrc);
  1553.     tele_out (188);
  1554.     }
  1555.  
  1556. void far write_eol (FILE * target)
  1557.     {
  1558.     fputc (13, target); fputc (10, target);
  1559.     }
  1560.  
  1561. void far eol_strip (BYTE * target)
  1562.     {
  1563.     WORD register x = 0;
  1564.  
  1565.     while (target [x] != 10 && target [x] && target [x] != 13) x++;
  1566.  
  1567.     if (target [x]) target [x] = 0;
  1568.     }
  1569.  
  1570. void far show_help (BYTE * helpfile)
  1571.     {
  1572. /*  shows help in text file, DOES NOT save/replace window  */
  1573.  
  1574.     BYTE choice, col, row, wfg = 0, x = 0, str [85];
  1575.  
  1576.     FILE * hlp;
  1577.  
  1578.     strcpy (gp_str [8], "HELPFILS\\");
  1579.     strcat (gp_str [8], helpfile);
  1580.  
  1581.     if ( (hlp = fopen (gp_str [8], "r")) == NULL)
  1582.         {
  1583.         clw(3); locate (22,28);
  1584.  
  1585.         prnt ("HELP FILE  WAS NOT FOUND");
  1586.         beep(); wait (4);
  1587.  
  1588.         return;
  1589.         }
  1590.  
  1591.     strcpy (gp_str [14], prompts [1]);
  1592.     strcpy (gp_str [15], prompts [2]);
  1593.  
  1594.     strcpy (prompts [0], "MORE HELP?");
  1595.  
  1596.     y_n ();
  1597.  
  1598.     clw (2); setbuf (hlp, NULL);
  1599.  
  1600.     while (! wfg)
  1601.         {
  1602.         str [0] = 0;
  1603.  
  1604.           locate (x + 2, 5);
  1605.         fgets (str, 80, hlp);
  1606.  
  1607.         if (eof (fileno (hlp)))
  1608.             {
  1609.             wfg = 1;
  1610.  
  1611.             if (! strlen (str)) continue;
  1612.             }
  1613.  
  1614.         eol_strip (str);
  1615.         prnt (str);
  1616.  
  1617.         if (x >= 16)
  1618.             {
  1619.             choice = get_v_choice (2, 0, 0);
  1620.  
  1621.             if (choice == 2) {wfg = 2; continue;}
  1622.  
  1623.             clw (2); x = 0;
  1624.             }
  1625.  
  1626.         else x++;
  1627.         }
  1628.  
  1629.     if (wfg == 1)
  1630.         {
  1631.         clw(3); locate (22,24);
  1632.         prnt ("PRESS ANY KEY TO RESUME PROGRAM");
  1633.  
  1634.         get_one (& row, & col);
  1635.         }
  1636.  
  1637.     fclose (hlp);
  1638.  
  1639.     strcpy (prompts [1], gp_str [14]);
  1640.     strcpy (prompts [2], gp_str [15]);
  1641.     }
  1642.  
  1643. void far hard_err (BYTE deverr, BYTE doserr, BYTE far *hdr)
  1644.     {
  1645. /*  handles hardware errors, kind of  */
  1646.  
  1647.     BYTE c, choice;
  1648.  
  1649.     save_window (3); clw (3);
  1650.     beep(); locate (22, 11);
  1651.  
  1652.     strcpy (prompts [0], "A HARDWARE ERROR HAS OCCURRED!");
  1653.     strcpy (prompts [1], "1=RETRY");
  1654.     strcpy (prompts [2], "2=ABORT PROGRAM");
  1655.  
  1656.     choice = get_v_choice (2, 0, 0);
  1657.  
  1658.     switch (choice)
  1659.         {
  1660.         /* retry */
  1661.  
  1662.         case 1:
  1663.             {
  1664.             repl_window (3);
  1665.             _hardresume(_HARDERR_RETRY);
  1666.             }
  1667.  
  1668.         /* abort */
  1669.  
  1670.         case 2:
  1671.             {
  1672.             cls();
  1673.             _hardresume(_HARDERR_ABORT);
  1674.             }
  1675.  
  1676.         }
  1677.  
  1678.     }
  1679.  
  1680.  
  1681. BYTE far dlr_format (BYTE dollar, BYTE comma)
  1682.     {
  1683. /*  formats the string in c_s [0] according to switches passed  */
  1684.  
  1685.     BYTE d, x, y, decs, len, point;
  1686.  
  1687.     BYTE * where;
  1688.  
  1689.     SBYTE test;
  1690.  
  1691.     len = strlen (c_s [0]);
  1692.  
  1693.     where = strchr (c_s [0], '.');
  1694.  
  1695.     if (where == NULL) {point = len; decs = 0;}
  1696.     else
  1697.         {
  1698.         point = where - c_s [0];
  1699.  
  1700.         if (point) decs = len - point;
  1701.         else decs = 0;
  1702.         }
  1703.  
  1704.     if (dollar)
  1705.         {
  1706.         c_s [2] [0] = '$';
  1707.         c_s [2] [1] = 0;
  1708.         x = 1;
  1709.         }
  1710.  
  1711.     else {x = 0; c_s [2] [0] = 0;}
  1712.  
  1713.     if (point < 3) {strcat (c_s [2], c_s [0]); return (0);}
  1714.  
  1715.     if (comma)
  1716.         {
  1717.         test = point; d = 0;
  1718.  
  1719.         while (test - 3 > -1) test -= 3;
  1720.  
  1721.         if (test) for (; d < test;) c_s [2] [x++] = c_s [0] [d++];
  1722.  
  1723.         while  (d < point)
  1724.             {
  1725.             y = d + 3;
  1726.             if (y > point) y = point;
  1727.  
  1728.             if (d) c_s [2] [x++] = ',';
  1729.  
  1730.             for (;d < y; d++) c_s [2] [x++] = c_s [0] [d];
  1731.             }
  1732.  
  1733.         if (decs) for (d = point; d < len;) c_s [2] [x++] = c_s [0] [d++];
  1734.  
  1735.         c_s [2] [x] = 0;
  1736.         }
  1737.  
  1738.     else strcat (c_s [2], c_s [0]);
  1739.  
  1740.     return (0);
  1741.     }
  1742.  
  1743. void far ipt_box (BYTE cc, BYTE cl, BYTE max, BYTE fill,
  1744.                BYTE seed_sw, BYTE bright, BYTE * t_str)
  1745.     {
  1746.     BYTE a, atrib, b, c, d, e, f, g, h;
  1747.  
  1748.     no_cursor ();
  1749.  
  1750.     a = cl - 1; d = cl + 1; e = cc - 1;
  1751.     f = cc + max;
  1752.  
  1753.     atrib = s_read_attr ();
  1754.  
  1755.     if (color_enable && bright && ! (atrib & 8)) atrib += 8;
  1756.  
  1757.     if (color_enable && ! bright && (atrib & 8)) atrib -= 8;
  1758.  
  1759.     /*  upper left corner  */
  1760.  
  1761.     locate (a, e); c = s_read_char ();
  1762.  
  1763.     switch (c)
  1764.         {
  1765.         default:
  1766.         case 32: {b = 201; break;}
  1767.  
  1768.         case 203:
  1769.         case 205: {b = 203; break;}
  1770.  
  1771.         case 204:
  1772.         case 200: {b = 204; break;}
  1773.         }
  1774.  
  1775.     c_crt_out (b, atrib);
  1776.  
  1777.     /*  top bar  */
  1778.  
  1779.     for (g = 0; g < max; g++)
  1780.         {
  1781.         h = cc + g;
  1782.  
  1783.         locate (a, h); c = s_read_char ();
  1784.  
  1785.         switch (c)
  1786.             {
  1787.             default:
  1788.             case 32: {b = 205; break;}
  1789.  
  1790.             case 200:
  1791.             case 202:
  1792.             case 188: {b = 202; break;}
  1793.             }
  1794.  
  1795.         c_crt_out (b, atrib);
  1796.         }
  1797.  
  1798.     /*  upper rt corner  */
  1799.  
  1800.     locate (a, f); c = s_read_char ();
  1801.  
  1802.     switch (c)
  1803.         {
  1804.         default:
  1805.         case 32: {b = 187; break;}
  1806.  
  1807.         case 188:
  1808.         case 185: {b = 185; break;}
  1809.  
  1810.         case 203:
  1811.         case 205: {b = 203; break;}
  1812.         }
  1813.  
  1814.     c_crt_out (b, atrib);
  1815.  
  1816.     /*  center line  */
  1817.  
  1818.     locate (cl, e); c_crt_out (186, atrib);
  1819.  
  1820.     b = strlen (t_str);
  1821.  
  1822.     for (c = 0, g = cc; c < max; g++, c++)
  1823.         {
  1824.         locate (cl, g);
  1825.  
  1826.         if (c < b) c_crt_out (t_str [c], atrib);
  1827.         else c_crt_out (32, atrib);
  1828.         }
  1829.  
  1830.     locate (cl, f); c_crt_out (186, atrib);
  1831.  
  1832.     locate (d, e); c = s_read_char ();
  1833.  
  1834.     switch (c)
  1835.         {
  1836.         default:
  1837.         case 32: {b = 200; break;}
  1838.  
  1839.         case 204:
  1840.         case 201: {b = 204; break;}
  1841.         }
  1842.  
  1843.  
  1844.     c_crt_out (b, atrib);
  1845.  
  1846.     for (g = 0; g < max; g++)
  1847.         {
  1848.         h = cc + g;
  1849.  
  1850.         locate (d, h); c = s_read_char ();
  1851.  
  1852.         switch (c)
  1853.             {
  1854.             default:
  1855.             case 32: {b = 205; break;}
  1856.  
  1857.             case 201:
  1858.             case 203:
  1859.             case 187: {b = 203; break;}
  1860.             }
  1861.  
  1862.         c_crt_out (b, atrib);
  1863.         }
  1864.  
  1865.     locate (d, f); c = s_read_char ();
  1866.  
  1867.     switch (c)
  1868.         {
  1869.         default:
  1870.         case 32: {b = 188; break;}
  1871.  
  1872.         case 185:
  1873.         case 187: {b = 185; break;}
  1874.  
  1875.         case 205:
  1876.         case 202: {b = 202; break;}
  1877.         }
  1878.  
  1879.     c_crt_out (b, atrib);
  1880.     }
  1881.  
  1882. BYTE far parse_date (BYTE * dte_str, BYTE * fmt, BYTE * day,
  1883.                      BYTE * month, WORD * year, double * met_date)
  1884.  
  1885. /*  parses a date, format byte 1 = MM/DD/YYyy, 2 = DD/MM/YYyy
  1886.     double met_date is set to YYYYMMDD for easy comparisons  */
  1887.         {
  1888.         BYTE d_str [3], m_str [3], y_str [5], met_str [9];
  1889.  
  1890.     BYTE len, m, wfg = 0;
  1891.  
  1892.         BYTE * where;
  1893.  
  1894.     double md;
  1895.  
  1896.     /*  remove trailing spaces, if any  */
  1897.  
  1898.     rtrim (dte_str);
  1899.  
  1900.     /*  check length of date string  */
  1901.  
  1902.     len = strlen (dte_str);
  1903.  
  1904.     if (len < 8) return (1);
  1905.  
  1906.     /*  check for valid chars in date string  */
  1907.  
  1908.     for (m = 0; m < len; m++)
  1909.         {
  1910.         if (m == 2 || m == 5) continue;
  1911.  
  1912.         if (dte_str [m] < 48 || dte_str [m] > 57) wfg = 1;
  1913.         }
  1914.  
  1915.     if (wfg) return (1);
  1916.  
  1917.     /*  process chars 0 & 1  */
  1918.  
  1919.     if (* fmt == 2) where = (BYTE far *) d_str;
  1920.     else where = (BYTE far *) m_str;
  1921.  
  1922.     for (m = 0; m < 2; m++)
  1923.         {
  1924.         * (where + m) = dte_str [m];
  1925.  
  1926.         met_str [m] = dte_str [m];
  1927.         }
  1928.  
  1929.     * (where + m) = 0;
  1930.  
  1931.     if (* fmt == 2) * day = atoi (where);
  1932.     else * month = atoi (where);
  1933.  
  1934.     /*  process chars 3 & 4  */
  1935.  
  1936.     if (* fmt == 2) where = m_str;
  1937.     else where =  d_str;
  1938.  
  1939.     for (m = 3; m < 5; m++)
  1940.         {
  1941.         * (where + m - 3) = dte_str [m];
  1942.  
  1943.         met_str [m - 1] = dte_str [m];
  1944.         }
  1945.  
  1946.     * (where + m - 3) = 0;
  1947.  
  1948.     if (* fmt == 2) * month = atoi (m_str);
  1949.     else * day = atoi (d_str);
  1950.  
  1951.     /*  process remaining chars  */
  1952.  
  1953.     for (m = 6; m < len; m++)
  1954.         {
  1955.         y_str [m - 6] = dte_str [m];
  1956.  
  1957.         met_str [m - 2] = dte_str [m];
  1958.         }
  1959.  
  1960.     y_str [m - 6] = 0; met_str [m - 2] = 0;
  1961.  
  1962.     * year = atoi (y_str);
  1963.  
  1964.     if (* year < 100)
  1965.         {
  1966.         * year += 1900;
  1967.  
  1968.         itoa (* year, y_str, 10);
  1969.         }
  1970.  
  1971.     if (* day < 1 || * day > 31 || * month < 1 || * month > 12) return (1);
  1972.  
  1973.     strcpy (met_str, y_str);
  1974.     strcat (met_str, m_str);
  1975.     strcat (met_str, d_str);
  1976.  
  1977.     * met_date = atof (met_str);
  1978.  
  1979.     return (0);
  1980.     }
  1981.  
  1982. /*
  1983.  
  1984. void char_ok (BYTE * t_str, BYTE * chin, BYTE * ccc, BYTE cl, BYTE cc,
  1985.             BYTE max, BYTE inst, BYTE nrml_val)
  1986.     {
  1987. //  belongs to INPT routine
  1988.  
  1989.     BYTE d, x = * ccc - cc;
  1990.  
  1991.     if (inst == 0)
  1992.         {
  1993.         if (x >= max) {beep (); return;}
  1994.  
  1995.         tele_out (nrml_val);
  1996.         t_str [ x ] = nrml_val;
  1997.         * ccc += 1;
  1998.         if (x >= * chin) * chin += 1;
  1999.         return;
  2000.         }
  2001.  
  2002.     if (* chin >= max) {beep (); return;}
  2003.  
  2004.     for (d = max; d > x; d--) t_str [ d ] = t_str [ d - 1 ];
  2005.  
  2006.     t_str [ x ] = nrml_val;
  2007.  
  2008.     for (d = x; d <= * chin; ++d) tele_out (t_str [ d ]);
  2009.  
  2010.     ++ * ccc; locate (cl, * ccc); * chin += 1;
  2011.     }
  2012.  
  2013. void del_char (BYTE * t_str, BYTE * psw, BYTE * chin, BYTE * ccc,
  2014.             BYTE cl, BYTE cc, BYTE max, BYTE fill)
  2015.     {
  2016. //  belongs to INPT routine
  2017.  
  2018.     BYTE d, x = *ccc - cc;
  2019.  
  2020.     if (t_str [ x ] == 46) * psw = 0;
  2021.  
  2022.     for (d = x; d <= max; ++d) t_str [ d ] = t_str [ d + 1 ];
  2023.  
  2024.     t_str [* chin] = fill; * chin -= 1;
  2025.  
  2026.     for (d = x; d < * chin; d++) tele_out (t_str [ d ]);
  2027.  
  2028.     tele_out (fill); locate (cl, * ccc);
  2029.     }
  2030.  
  2031. BYTE far inpt (BYTE type,  BYTE max,  BYTE box_sw, BYTE seed_sw,
  2032.             BYTE spare, BYTE fill, BYTE * t_str)
  2033.     {
  2034. //  performs char input at current location
  2035.  
  2036.     BYTE cc, ccc, cl, chin = 0, cwfg, d,
  2037.         inst = 0, psw = 0, w, wfg = 0;
  2038.  
  2039.     BYTE * test;
  2040.  
  2041.     void del_char (BYTE *, BYTE *, BYTE *,
  2042.                 BYTE *, BYTE, BYTE, BYTE, BYTE);
  2043.  
  2044.     void char_ok (BYTE *, BYTE *, BYTE *, BYTE, BYTE, BYTE, BYTE, BYTE);
  2045.  
  2046.     nrml_cursor ();
  2047.  
  2048.     find_cursor (& cl, & cc);
  2049.  
  2050.     if (box_sw == 1)
  2051.         {
  2052.         cc += 2;
  2053.  
  2054.         ipt_box (cc, cl, max, fill, seed_sw, 1, t_str);
  2055.         }
  2056.  
  2057.     t_str [ max + 1 ] = 0;
  2058.  
  2059.     locate (cl, cc);
  2060.  
  2061.     if (! seed_sw)
  2062.         {
  2063.         ccc = cc;
  2064.  
  2065.         for (d = 0; d <= max; d++) t_str [d] = fill;
  2066.         }
  2067.  
  2068.     else
  2069.         {
  2070.         if (! box_sw) prnt (t_str);
  2071.  
  2072.         chin = strlen (t_str);
  2073.         if (chin > max) chin = 0;
  2074.  
  2075.         ccc = cc + chin;
  2076.  
  2077.         locate (cl, ccc);
  2078.         }
  2079.  
  2080.     //  detect decimal if numeric seeded input
  2081.  
  2082.     if (type == 2 && seed_sw)
  2083.         {
  2084.         test = strstr (t_str, ".");
  2085.  
  2086.         if (test == NULL) psw = 0;
  2087.         else psw = 1;
  2088.         }
  2089.  
  2090.     if (type == 1 && box_sw == 2)
  2091.         {
  2092.         if (cl <= 9) w = 11; else w = 10;
  2093.  
  2094.         save_window (w); window_border (w);
  2095.  
  2096.         locate (w_a [w].ulr + 1, 21);
  2097.         prnt ("F-KEY:   1  2  3  4  5  6  7  8  9  1");
  2098.  
  2099.         locate (w_a [w].ulr + 2, 19); tele_out (199);
  2100.         line_out (39, 196);
  2101.         locate (w_a [w].ulr + 2, 59); tele_out (182);
  2102.  
  2103.         locate (w_a [w].ulr + 3, 21);
  2104.         prnt ("ALONE    \xa9  \xaa  \xc0  \xd9  \xb3  \xc1  \xcb  \xc6  \xd2  \xc5");
  2105.  
  2106.         locate (w_a [w].ulr + 4, 21);
  2107.         prnt ("SHFT +   \xc9  \xbb  \xc8  \xbc  \xc4  \xc2  \xca  \xb5  \xd0  \xce");
  2108.  
  2109.         locate (w_a [w].ulr + 5, 21);
  2110.         prnt ("ALT  +   \xd5  \xb8  \xd4  \xbe  \xba  \xc3  \xcc  \xc7  \xd1  \xd8");
  2111.  
  2112.         locate (w_a [w].ulr + 6, 21);
  2113.         prnt ("CTRL +   \xd6  \xb7  \xd3  \xbd  \xcd  \xb4  \xb9  \xb6  \xcf  \xd7");
  2114.  
  2115.         locate (cl, cc);
  2116.         }
  2117.  
  2118.     while (! wfg)
  2119.         {
  2120.         get_one (& ctrl_val, & nrml_val); cwfg = 0;
  2121.  
  2122.         if (type == 1 && ! box_sw)
  2123.             {
  2124.             switch (ctrl_val)
  2125.                 {
  2126.                 //  f-key
  2127.  
  2128.                 case 59: nrml_val = 169; cwfg = 1; break;
  2129.                 case 60: nrml_val = 170; cwfg = 1; break;
  2130.                 case 61: nrml_val = 192; cwfg = 1; break;
  2131.                 case 62: nrml_val = 217; cwfg = 1; break;
  2132.                 case 63: nrml_val = 179; cwfg = 1; break;
  2133.                 case 64: nrml_val = 193; cwfg = 1; break;
  2134.                 case 65: nrml_val = 203; cwfg = 1; break;
  2135.                 case 66: nrml_val = 198; cwfg = 1; break;
  2136.                 case 67: nrml_val = 210; cwfg = 1; break;
  2137.                 case 68: nrml_val = 197; cwfg = 1; break;
  2138.  
  2139.                 //  shifted f-key
  2140.  
  2141.                 case 84: nrml_val = 201; cwfg = 1; break;
  2142.                 case 85: nrml_val = 187; cwfg = 1; break;
  2143.                 case 86: nrml_val = 200; cwfg = 1; break;
  2144.                 case 87: nrml_val = 188; cwfg = 1; break;
  2145.                 case 88: nrml_val = 196; cwfg = 1; break;
  2146.                 case 89: nrml_val = 194; cwfg = 1; break;
  2147.                 case 90: nrml_val = 202; cwfg = 1; break;
  2148.                 case 91: nrml_val = 181; cwfg = 1; break;
  2149.                 case 92: nrml_val = 208; cwfg = 1; break;
  2150.                 case 93: nrml_val = 206; cwfg = 1; break;
  2151.  
  2152.                 //  alted f-key
  2153.  
  2154.                 case 104: nrml_val = 213; cwfg = 1; break;
  2155.                 case 105: nrml_val = 184; cwfg = 1; break;
  2156.                 case 106: nrml_val = 212; cwfg = 1; break;
  2157.                 case 107: nrml_val = 190; cwfg = 1; break;
  2158.                 case 108: nrml_val = 186; cwfg = 1; break;
  2159.                 case 109: nrml_val = 195; cwfg = 1; break;
  2160.                 case 110: nrml_val = 204; cwfg = 1; break;
  2161.                 case 111: nrml_val = 199; cwfg = 1; break;
  2162.                 case 112: nrml_val = 209; cwfg = 1; break;
  2163.                 case 113: nrml_val = 216; cwfg = 1; break;
  2164.  
  2165.                 //  ctrled f-key
  2166.  
  2167.                 case 94:  nrml_val = 214; cwfg = 1; break;
  2168.                 case 95:  nrml_val = 183; cwfg = 1; break;
  2169.                 case 96:  nrml_val = 211; cwfg = 1; break;
  2170.                 case 97:  nrml_val = 189; cwfg = 1; break;
  2171.                 case 98:  nrml_val = 205; cwfg = 1; break;
  2172.                 case 99:  nrml_val = 180; cwfg = 1; break;
  2173.                 case 100: nrml_val = 185; cwfg = 1; break;
  2174.                 case 101: nrml_val = 182; cwfg = 1; break;
  2175.                 case 102: nrml_val = 207; cwfg = 1; break;
  2176.                 case 103: nrml_val = 215; cwfg = 1; break;
  2177.  
  2178.                 defualt: ;
  2179.                 }
  2180.  
  2181.             if (cwfg)
  2182.                 {
  2183.                 char_ok (t_str, & chin, & ccc,
  2184.                          cl, cc, max, inst, nrml_val);
  2185.                 continue;
  2186.                 }
  2187.  
  2188.             }
  2189.  
  2190.         if (nrml_val)
  2191.             {
  2192.             if (type == 1 && nrml_val > 31 && nrml_val < 126)
  2193.                 {
  2194.                 char_ok (t_str, & chin, & ccc,
  2195.                      cl, cc, max, inst, nrml_val);
  2196.                 continue;
  2197.                 }
  2198.  
  2199.             if (type == 2 && nrml_val > 46 && nrml_val < 58)
  2200.                 {
  2201.                 char_ok (t_str, & chin, & ccc,
  2202.                      cl, cc, max, inst, nrml_val);
  2203.                 continue;
  2204.                 }
  2205.  
  2206.             switch (nrml_val)
  2207.                 {
  2208.                 case 8 :    //  backspace
  2209.  
  2210.                     if (chin == 0) { beep (); continue; }
  2211.  
  2212.                     if (nrml_val == 8 && ccc - cc == 0)
  2213.                         { beep (); continue; }
  2214.  
  2215.                     --ccc; locate (cl,ccc);
  2216.                     del_char (t_str, & psw,
  2217.                           & chin, & ccc, cl, cc, max, fill);
  2218.                     continue;
  2219.  
  2220.                 case 13 : wfg = 2; continue;  //  return
  2221.  
  2222.                 case 27 :  //  escape
  2223.                     no_cursor (); chin = 0;
  2224.                     locate (cl, cc); line_out (max, fill);
  2225.                     locate (cl, cc); ccc = cc;
  2226.                     nrml_cursor (); inst = 0;
  2227.  
  2228.                     for (d = 0; d <= max; d++)
  2229.                         t_str [d] = fill;
  2230.  
  2231.                     t_str [ max + 1 ] = 0x00;
  2232.                     beep (); continue;
  2233.  
  2234.                 case 45 :
  2235.                     if (ccc - cc > 0 || t_str [0] == 45)
  2236.                         { beep (); continue; }
  2237.  
  2238.                     char_ok (t_str, & chin,
  2239.                          & ccc, cl, cc, max, inst,
  2240.                          nrml_val);
  2241.  
  2242.                     continue;
  2243.  
  2244.                 case 46 :
  2245.                     if (psw == 1) { beep (); continue; }
  2246.  
  2247.                     char_ok (t_str, & chin,
  2248.                          & ccc, cl, cc, max, inst,
  2249.                          nrml_val);
  2250.                     psw = 1; continue;
  2251.  
  2252.                 default : beep (); continue;
  2253.                 }
  2254.  
  2255.             }
  2256.  
  2257.         switch (ctrl_val)
  2258.             {
  2259.             case 71 :
  2260.                 locate (cl, cc);
  2261.                 ccc = cc; continue;
  2262.  
  2263.             case 75 :
  2264.                 if (ccc > cc)
  2265.                     {
  2266.                     --ccc; locate (cl, ccc);
  2267.                     continue;
  2268.                     }
  2269.  
  2270.                 beep (); continue;
  2271.  
  2272.             case 77 :  //  right arrow
  2273.  
  2274.                 if ( (ccc - cc) < chin)
  2275.                     {
  2276.                     locate (cl, ++ccc);
  2277.                     continue;
  2278.                     }
  2279.  
  2280.                 beep (); continue;
  2281.  
  2282.             case 79 :
  2283.                 ccc = cc;
  2284.                 if (chin) ccc += chin - 1;
  2285.  
  2286.                 locate (cl, ccc);
  2287.                 nrml_cursor (); inst = 0;
  2288.                 continue;
  2289.  
  2290.             case 82 :
  2291.                 if (inst == 0)
  2292.                     {
  2293.                     inst = 1; full_cursor ();
  2294.                     continue;
  2295.                     }
  2296.  
  2297.                 inst = 0; nrml_cursor ();
  2298.                 continue;
  2299.  
  2300.             case 83 :  //  delete
  2301.                 if (chin == 0 || ccc - cc > max ||
  2302.                     ccc - cc >= chin)
  2303.                     { beep (); continue; }
  2304.  
  2305.                 del_char (t_str, & psw,
  2306.                 & chin, & ccc, cl, cc, max, fill);
  2307.                 continue;
  2308.  
  2309.             default : beep (); continue;
  2310.             }
  2311.  
  2312.         }
  2313.  
  2314.     if (type == 1 && box_sw == 2) repl_window (w);
  2315.  
  2316.     no_cursor ();
  2317.     t_str [chin] = 0;
  2318.  
  2319.     return (chin);
  2320.     }
  2321.  
  2322. void far check_heap ()
  2323.     {
  2324. //  handy-dandy routine for checking the heap
  2325.  
  2326.     SBYTE h;
  2327.  
  2328.     h = _heapchk ();
  2329.  
  2330.     switch (h)
  2331.         {
  2332.         case _HEAPEND:
  2333.         case _HEAPEMPTY:
  2334.         case _HEAPOK: break;
  2335.  
  2336.         case _HEAPBADBEGIN:
  2337.         case _HEAPBADNODE:
  2338.         case _HEAPBADPTR:
  2339.         case _FREEENTRY:
  2340.         case _USEDENTRY:
  2341.  
  2342.         locate (0,0); prnt ("HEAP ERROR  ");
  2343.         printf ("%i",h);
  2344.         }
  2345.  
  2346.     h = _fheapchk ();
  2347.  
  2348.     switch (h)
  2349.         {
  2350.         case _HEAPEND:
  2351.         case _HEAPEMPTY:
  2352.         case _HEAPOK: break;
  2353.  
  2354.         case _HEAPBADBEGIN:
  2355.         case _HEAPBADNODE:
  2356.         case _HEAPBADPTR:
  2357.         case _FREEENTRY:
  2358.         case _USEDENTRY:
  2359.  
  2360.         locate (0,40); prnt ("FAR HEAP ERROR  ");
  2361.         printf ("%i",h);
  2362.         }
  2363.  
  2364.     }
  2365.  
  2366. */
  2367.  
  2368.