home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c005 / 3.ddi / SAVESCN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-04-13  |  25.8 KB  |  984 lines
  1. /**
  2. *
  3. *  SAVESCN.C    Install a resident program to save the screen image
  4. *        when a "hot key" is pressed.
  5. *
  6. *  This program installs several interrupt service routines to
  7. *  establish a "hot key" function.  When the specified "hot key" is
  8. *  pressed, a window pops up and requests the name of a file.
  9. *  Then the contents of the active video page are saved onto that
  10. *  file.  (After each line of text from the screen, a carriage return
  11. *  and a line feed are saved in the file.)
  12. *
  13. *  Several command line options are supported.    To select a hot key,
  14. *  use the -c option for ASCII characters:
  15. *
  16. *    savescn -cZ        (sets capital Z as the hot key)
  17. *
  18. *  or use the -k option for the extended codes of IBM extended key
  19. *  sequences:
  20. *
  21. *    savescn -k71        (sets "Home" as the hot key)
  22. *
  23. *  (The default hot key is Alt-2).
  24. *
  25. *  To remove a previously-installed copy of SAVESCN, use the -r
  26. *  option:
  27. *
  28. *    savescn -r
  29. *
  30. *  (SAVESCN will not permit itself to be loaded as a resident program
  31. *  twice in succession.  However, it may be loaded twice if its
  32. *  previous interrupt handlers are concealed by an intervening
  33. *  resident program.  SAVESCN 3.02 will not recognize other versions
  34. *  of SAVESCN.)
  35. *
  36. *  To make SAVESCN pause before it terminates and stays resident, use
  37. *  the -w option:
  38. *
  39. *    savescn -w
  40. *
  41. *  (If Ctrl-Break is pressed while SAVESCN is pausing, it will remove
  42. *  its ISRs and abort, leaving no residue.)
  43. *
  44. *  Any of these command-line options may be combined.
  45. *
  46. *  General method:  ISRs are installed for the keystroke (9), clock tick
  47. *  (8), and DOS idle (0x28) interrupts.  The keystroke handler watches
  48. *  for the designated hot key; if the hot key is found, it is removed
  49. *  from the keyboard buffer and the global flag "want_to_save" is set.
  50. *  The clock tick and DOS idle handlers check the flag and perform a
  51. *  screen save if possible.
  52. *
  53. *  Version 3.00  (C)Copyright Blaise Computing Inc.  1986
  54. *
  55. *  Version 3.02  April 9, 1987
  56. *         Modified calculation in emptyq() to avoid MS C 4.00
  57. *             H model compiler bug.
  58. *         Corrected location of call to FLCLOSE in write_file().
  59. *         Corrected last row read from screen in write_file().
  60. *         Corrected recognition of hot keys to allow any
  61. *             combination of ASCII code and key code.
  62. *         Simplified some items:
  63. *             moved usage and Ctrl-C messages;
  64. *             made ISR stacks and screen row buffer static;
  65. *             removed get_fname();
  66. *             used APPROMPT for wait message;
  67. *             moved a few comments.
  68. *
  69. **/
  70.  
  71. #include <stdio.h>
  72. #include <stdlib.h>
  73. #include <string.h>
  74.  
  75. #include <bapplic.h>
  76. #include <bfile.h>
  77. #include <bgenvid.h>
  78. #include <bkeybd.h>
  79. #include <bisr.h>
  80. #include <bprogctl.h>
  81. #include <bstring.h>
  82. #include <bwindow.h>
  83.  
  84. #if MSC300
  85. #include <malloc.h>
  86. #include <memory.h>
  87. #endif
  88.  
  89. #define TIMER_VEC     0x08          /* Interrupt types          */
  90. #define KEY_VEC      0x09
  91. #define CBREAK_VEC     0x23
  92. #define IDLE_VEC     0x28
  93.  
  94. #define ENTER_KEY       13
  95.  
  96. #define STKSIZE      1500          /* Size of one ISR stack          */
  97. #define NUM_STACKS        2          /* Maximum depth of keystroke,  */
  98.                       /* timer, and INT 28H ISR calls.*/
  99.  
  100. #define OK            0          /* Error return codes from      */
  101. #define NO_MEMORY      100          /* main program.              */
  102. #define WINDOW_ERROR      101
  103. #define NO_FILENAME      102
  104. #define TRY_NEW_FILENAME  103
  105. #define TARGET_FULL      104
  106. #define CANT_REMOVE      105
  107. #define USAGE_ERROR      106
  108. #define FALL_OUT      107
  109.  
  110. int    want_to_save   = 0;          /* Internal flag set by          */
  111.                       /* keystroke ISR:  nonzero if   */
  112.                       /* hot key pressed.  This flag  */
  113.                       /* is cleared by do_save().     */
  114.  
  115. char    hot_ch           = '\0';        /* Initial hot key =            */
  116. char    hot_code       = 121;          /* ALT-2                  */
  117.  
  118. int    spec_char      = 1;          /* ASCII character is          */
  119.                       /* significant in identifying   */
  120.                       /* hot key.              */
  121.                       /*                  */
  122. int    spec_code      = 1;          /* Key code is significant in   */
  123.                       /* identifying hot key.          */
  124.  
  125. ADS    key_prev       = {0,0},       /* Previous contents of          */
  126.     tick_prev      = {0,0},       /* interrupt vectors.          */
  127.     idle_prev      = {0,0};
  128.  
  129. ADS    dos_flag_ads   = {0,0};       /* Address of DOS critical      */
  130.                       /* section flag.              */
  131.  
  132. char    scn_buffer[PC_COLS];          /* Buffers used by write_file().*/
  133. ADS    scn_buf_ads    = {0,0};
  134. char    crlf[]           = "\15\12";
  135. ADS    crlf_ads       = {0,0};
  136.  
  137. char    filename[70]   = {'\0'};      /* Name of file on which to     */
  138.                       /* save screen image.          */
  139. int    name_err       = OK;          /* Errors encountered by ISRs.  */
  140. int    file_err       = OK;
  141.  
  142. char    *pspare_mem    = NIL;          /* Spare memory in local          */
  143.                       /*  dynamic memory pool for ISR */
  144.                       /*  window routines.          */
  145. int    have_spare_mem = 0;          /* Nonzero if spare memory has  */
  146.                       /*  been allocated but not freed*/
  147.  
  148. BWINDOW *pwindow       = (BWINDOW *) 0;   /* Window used to collect   */
  149.                       /* name of file.              */
  150. int window_displayed   = 0;          /* Variables to regulate          */
  151. int cursor_was_off     = 0,          /* display and removal of that  */
  152.     high           = 0,          /* window.              */
  153.     low            = 0,
  154.     old_row           = 0,
  155.     old_col           = 0;
  156.  
  157. typedef struct                  /* KEYPAIR:  Character and key  */
  158. {                      /* code as stored in BIOS       */
  159.     char ch;                  /* keyboard buffer.          */
  160.     char keycode;
  161. } KEYPAIR;
  162.  
  163. void cbreak   (ALLREG *,ISRCTRL *,ISRMSG *);    /* The ISRs.          */
  164. void keystroke(ALLREG *,ISRCTRL *,ISRMSG *);
  165. void tick     (ALLREG *,ISRCTRL *,ISRMSG *);
  166. void idle     (ALLREG *,ISRCTRL *,ISRMSG *);
  167.  
  168. int  emptyq(KEYPAIR *);           /* Internal (see below).          */
  169. int  dos_ready(void);
  170. void do_save(void);
  171. int  write_file(char *);
  172. int  display_window(void);
  173. void remove_window(void);
  174. int  prompt(char *,char *,int);
  175. int  warning(char *,int);
  176.  
  177. int main(argc,argv)
  178. int argc;
  179. char *argv[];
  180. {
  181.     ISRCTRL cbrk_ctl,key_ctl,tick_ctl,idle_ctl;
  182.     static char cbrk_stack[STKSIZE],
  183.         key_stack [STKSIZE * NUM_STACKS],
  184.         tick_stack[STKSIZE * NUM_STACKS],
  185.         idle_stack[STKSIZE * NUM_STACKS];
  186.     char    dummy[7];
  187.     int     ercode,i;
  188.     DOSREG  regs;
  189.  
  190.     int bad_arg,have_char,have_code,wait;
  191.     int want_remove,removed;
  192.  
  193.     static char cbrk_ident[] = "SAVESCN3.02CBRK";
  194.     static char key_ident[]  = "SAVESCN3.02 KEY";
  195.     static char tick_ident[] = "SAVESCN3.02TICK";
  196.     static char idle_ident[] = "SAVESCN3.02IDLE";
  197.     unsigned keypsp, tickpsp, idlepsp;
  198.  
  199.     /* First analyze command-line arguments.                  */
  200.  
  201.     want_remove = 0;
  202.     have_char    = 0;
  203.     have_code    = 0;
  204.     wait    = 0;
  205.     for (bad_arg = 0,i = 1; bad_arg == 0 && i < argc; i++)
  206.     {
  207.     if (*argv[i]++ == '-')
  208.     {
  209.         switch (tolower((int) *argv[i]++))
  210.         {
  211.         case 'c':             /* Hot key is ASCII character:  */
  212.                       /* character following "-c" is  */
  213.                       /* the character.           */
  214.             if (   have_char
  215.             || 1 != strlen(argv[i]))
  216.             {
  217.             bad_arg = 1;
  218.             }
  219.             else
  220.             {
  221.             hot_ch      = *argv[i];
  222.             if (!have_code)
  223.                 spec_code = 0;
  224.             spec_char = 1;
  225.             have_char = 1;
  226.             }
  227.             break;
  228.  
  229.         case 'k':             /* Hot key is extended char:    */
  230.                       /* integer following "-k" is    */
  231.                       /* its extended code.          */
  232.             if (   have_code
  233.             || 0 <= stsverfy(argv[i],"0123456789"))
  234.             {
  235.             bad_arg = 1;
  236.             }
  237.             else
  238.             {
  239.             hot_code  = (char) utlobyte(atoi(argv[i]));
  240.             if (!have_char)
  241.                 spec_char = '\0';
  242.             spec_code = 1;
  243.             have_code = 1;
  244.             }
  245.             break;
  246.  
  247.         case 'r':             /* Remove resident copy of      */
  248.                       /* SAVESCN.              */
  249.             if (*argv[i] == '\0')
  250.             want_remove = 1;
  251.             else
  252.             bad_arg = 1;
  253.             break;
  254.  
  255.         case 'w':             /* Await keystroke before       */
  256.             wait = 1;          /* remaining resident.  (This   */
  257.             break;          /* allows a chance to test      */
  258.                       /* Ctrl-Break handling.)          */
  259.  
  260.         default:
  261.             bad_arg = 1;
  262.             break;
  263.         }
  264.     }
  265.     else
  266.         bad_arg = 1;
  267.     }
  268.  
  269.     if (   bad_arg
  270.     || (spec_char == 0 && spec_code == 0))
  271.     {
  272.     printf("usage:  savescn [-r] [-cCHAR] [-kKEYCODE] [-w]\n");
  273.     return USAGE_ERROR;
  274.     }
  275.  
  276.     /* Now check whether this program has been previously installed.  */
  277.  
  278.     if (   0 == isdetect(KEY_VEC,  key_ident, &key_prev, &keypsp )
  279.     && 0 == isdetect(TIMER_VEC,tick_ident,&tick_prev,&tickpsp)
  280.     && 0 == isdetect(IDLE_VEC, idle_ident,&idle_prev,&idlepsp))
  281.     {
  282.     printf("Previous copy of SAVESCN 3.02 detected");
  283.  
  284.     if (want_remove)
  285.     {
  286.         removed = 0;
  287.         if (keypsp == tickpsp && keypsp == idlepsp)
  288.         {
  289.         issetvec(KEY_VEC,  &key_prev);
  290.         issetvec(TIMER_VEC,&tick_prev);
  291.         issetvec(IDLE_VEC, &idle_prev);
  292.         if (0 == pcremove(keypsp))
  293.             removed = 1;
  294.         }
  295.         if (removed)
  296.         {
  297.         printf(" and successfully removed.\n");
  298.         return OK;
  299.         }
  300.         else
  301.         {
  302.         printf(" but it can't be removed -- aborting.\n");
  303.         return CANT_REMOVE;
  304.         }
  305.     }
  306.     else
  307.     {
  308.         printf(" -- aborting.\n");
  309.         return OK;
  310.     }
  311.     }
  312.     else              /* Not detected                  */
  313.     {
  314.     if (want_remove)
  315.     {
  316.         printf("Previous copy of SAVESCN 3.02 not found -- aborting.\n");
  317.         return OK;
  318.     }
  319.     }
  320.  
  321.     /* Now we know that we're going to terminate and stay resident.   */
  322.     /* Proceed to set up what the ISRs need:  window, stack space,    */
  323.     /* and addresses of various buffers.                  */
  324.  
  325.     if (NIL == (pwindow = wncreate(6,29,
  326.                    (BLUE << 4) + WHITE + INTENSITY)))
  327.     return b_wnerr;
  328.  
  329.     utabsptr(scn_buffer,&scn_buf_ads);
  330.     utabsptr(crlf,    &crlf_ads);
  331.  
  332.     /* Make sure local memory pool has some spare memory for ISR      */
  333.     /* window routines (so that PCRESEXT can't release it).           */
  334.  
  335.     if (NIL == (pspare_mem = malloc(2048)))
  336.     return NO_MEMORY;
  337.     else
  338.     have_spare_mem = 1;
  339.  
  340.     /* Obtain address of DOS critical section flag for use by          */
  341.     /* dos_ready().                              */
  342.  
  343.     regs.ax = 0x3400;
  344.     dos(®s);
  345.     dos_flag_ads.r = regs.bx;
  346.     dos_flag_ads.s = regs.es;
  347.  
  348.     /* Install Ctrl-Break handler first, so we can be prepared to     */
  349.     /* remove the other ISRs in case a Ctrl-Break aborts the program. */
  350.  
  351.     isretvec(KEY_VEC,  &key_prev);
  352.     isretvec(TIMER_VEC,&tick_prev);
  353.     isretvec(IDLE_VEC, &idle_prev);
  354.     if (ercode = isinstal(CBREAK_VEC,cbreak,cbrk_ident,
  355.               &cbrk_ctl,cbrk_stack,STKSIZE,1))
  356.     return ercode;
  357.  
  358.     /* Install the three ISRs that will remain effective after the    */
  359.     /* program has terminated and stayed resident.              */
  360.  
  361.     if (ercode = isinstal(KEY_VEC,keystroke,key_ident,
  362.               &key_ctl,key_stack,STKSIZE,NUM_STACKS))
  363.     return ercode;
  364.     if (ercode = isinstal(TIMER_VEC,tick,tick_ident,
  365.               &tick_ctl,tick_stack,STKSIZE,NUM_STACKS))
  366.     return ercode;
  367.     if (ercode = isinstal(IDLE_VEC,idle,idle_ident,
  368.               &idle_ctl,idle_stack,STKSIZE,NUM_STACKS))
  369.     return ercode;
  370.  
  371.     /* Report successful installation.                      */
  372.  
  373.     printf("SAVESCN 3.02 installed");
  374.     if (spec_char)
  375.     printf(", hot character value = %d",hot_ch);
  376.     if (spec_code)
  377.     printf(", hot keycode = %d",hot_code);
  378.     printf(".\n");
  379.  
  380.     if (wait)
  381.     apprompt("Press ENTER to continue or Ctrl-C to abort:  ",
  382.          dummy,sizeof(dummy));
  383.  
  384.     pcresext(OK);
  385.  
  386.     return FALL_OUT;
  387. }
  388.  
  389. /**
  390. *
  391. * Name        cbreak -- Interrupt service routine for Ctrl-Break
  392. *
  393. * Description    This function is installed as a handler for interrupt
  394. *        type 0x23.  It displays a message using BIOS or direct
  395. *        I/O (using no DOS functions) and then returns to DOS via
  396. *        a "RETF", thus causing the program to be aborted.
  397. *
  398. **/
  399.  
  400. void cbreak(pregs,pisrblk,pmsg)
  401. ALLREG    *pregs;
  402. ISRCTRL *pisrblk;
  403. ISRMSG    *pmsg;
  404. {
  405.     int mode,columns,act_page;
  406.     int row,col;
  407.  
  408.     scmode(&mode,&columns,&act_page);
  409.     scpage(act_page);
  410.     sccurpos(&row,&col);
  411.     scwrstr(row,col,
  412.         0,"\015\012Ctrl-C occurred -- removing SAVESCN ISRs.\015\012",
  413.         -1,-1,CHARS_ONLY+MOVE_CUR+CUR_AFTER);
  414.  
  415.     issetvec(KEY_VEC,  &key_prev);
  416.     issetvec(TIMER_VEC,&tick_prev);
  417.     issetvec(IDLE_VEC, &idle_prev);
  418.  
  419.     pmsg->working_flags |= CF_FLAG;
  420.     pmsg->exit_style     = IEXIT_RETF;
  421. }
  422.  
  423. /**
  424. *
  425. * Name        keystroke -- Interrupt service routine for keystrokes.
  426. *
  427. * Description    This function is installed as a handler for interrupt
  428. *        type 0x09, which is invoked whenever a key is pressed or
  429. *        released.  It allows the original INT 09H handler to
  430. *        service the keyboard, then checks the type-ahead buffer
  431. *        for the specified hot key.  If the hot key is found, the
  432. *        global variable want_to_save is set; all other
  433. *        keystrokes are restored in the buffer.
  434. *
  435. *        KBPLACE and emptyq() are used in lieu of functions that
  436. *        invoke the BIOS.
  437. *
  438. **/
  439.  
  440. void keystroke(pregs,pisrblk,pmsg)
  441. ALLREG    *pregs;
  442. ISRCTRL *pisrblk;
  443. ISRMSG    *pmsg;
  444. {
  445.     int     q_wait,stuff_err;
  446.     KEYPAIR    queue[16],*pq;
  447.     static char panic_msg[] =
  448.             "SAVESCN 3.02 can't re-stuff whole string!";
  449.     static int    busy = 0;
  450.  
  451.     utintoff();
  452.     iscalint(&pisrblk->prev_vec,pregs);
  453.     utintoff();
  454.  
  455.     if (busy)
  456.     return;
  457.  
  458.     busy      = 1;
  459.     stuff_err = 0;
  460.  
  461.     pq = queue;
  462.     for (q_wait = emptyq(queue);      /* Examine keystroke(s).          */
  463.      q_wait > 0;
  464.      q_wait--)
  465.     {
  466.     if (   ((!spec_char) || hot_ch     == pq->ch)
  467.         && ((!spec_code) || hot_code == pq->keycode))
  468.  
  469.         want_to_save = 1;          /* Do our work.              */
  470.                       /* Don't re-stuff the hot key.  */
  471.  
  472.     else                  /* Non-hot key:  re-stuff it.   */
  473.         if (kbplace(KB_TAIL,pq->ch,pq->keycode))
  474.         stuff_err = 1;
  475.     pq++;
  476.     }
  477.  
  478.     if (stuff_err)              /* Avoid BIOS call because BIOS */
  479.                       /* enables interrupts.          */
  480.     viwrrect(23,0,23,((int) strlen(panic_msg)) - 1,
  481.          panic_msg,RED,BLACK,CHARS_ONLY);
  482.  
  483.     busy = 0;
  484. }
  485.  
  486. /**
  487. *
  488. * Name        emptyq -- Retrieve contents of keyboard buffer
  489. *              and empty it.
  490. *
  491. * Synopsis    num_typed = emptyq(pbuf);
  492. *
  493. *        int num_typed          Number of waiting keystrokes
  494. *                      returned.
  495. *        KEYPAIR *pbuf          Pointer to buffer in which to
  496. *                      return waiting keystrokes.
  497. *
  498. * Description    This function returns all keystrokes waiting in the BIOS
  499. *        type-ahead buffer and empties the buffer.  It leaves
  500. *        interrupts disabled.
  501. *
  502. **/
  503.  
  504. int emptyq(pbuf)
  505. register KEYPAIR *pbuf;
  506. {
  507.     static ADS head_ads = {0x001a,0x0040};
  508.     static ADS tail_ads = {0x001c,0x0040};
  509. #define Q_OFFSET       0x001e
  510.  
  511.     struct              /* rawbuf = Raw image of BIOS variables.*/
  512.     {
  513.     unsigned head;
  514.     unsigned tail;
  515.     KEYPAIR  queue[16];
  516.     } rawbuf;
  517.  
  518.     ADS      rawbuf_ads;  /* Physical address of rawbuf.          */
  519.     int      num_typed;
  520.     register int j;
  521.  
  522.     utabsptr((char *) &rawbuf,&rawbuf_ads);
  523.     utintoff();
  524.                   /* Extract raw head, tail, and queue.   */
  525.     utslmove(&head_ads,  &rawbuf_ads,sizeof(rawbuf));
  526.                   /* Forcing head=tail empties queue.     */
  527.     utslmove(&rawbuf_ads,&tail_ads,  sizeof(rawbuf.head));
  528.  
  529.     rawbuf.head = (rawbuf.head - Q_OFFSET) / sizeof(KEYPAIR);
  530.     rawbuf.tail = (rawbuf.tail - Q_OFFSET) / sizeof(KEYPAIR);
  531.     num_typed    = (rawbuf.tail + 16 - rawbuf.head) % 16;
  532.  
  533.     for (j = num_typed; j; j--)
  534.     {
  535.     pbuf->ch      = rawbuf.queue[rawbuf.head].ch;
  536.     pbuf->keycode = rawbuf.queue[rawbuf.head].keycode;
  537.     pbuf++;
  538.     rawbuf.head++;
  539.     if (rawbuf.head >= 16)
  540.         rawbuf.head = 0;          /* Wrap around to beginning.    */
  541.     }
  542.     return num_typed;
  543.  
  544. #undef Q_OFFSET
  545. }
  546.  
  547. /**
  548. *
  549. * Name        tick -- Interrupt service routine for clock ticks
  550. *
  551. * Description    This function is installed as a handler for hardware
  552. *        interrupt type 8.  It first calls the previous INT 8
  553. *        handler to service the Intel 8259 Programmable Interrupt
  554. *        Controller.  Then it checks the DOS critical section
  555. *        flag; if DOS is available, do_save() is called.
  556. *
  557. *        This function protects itself against secondary
  558. *        invocations by means of the "busy" flag.
  559. *
  560. **/
  561.  
  562. void tick(pregs,pisrblk,pmsg)
  563. ALLREG    *pregs;
  564. ISRCTRL *pisrblk;
  565. ISRMSG    *pmsg;
  566. {
  567.     static int busy = 0;
  568.  
  569.     utintoff();
  570.     iscalint(&pisrblk->prev_vec,pregs);
  571.  
  572.     utintoff();
  573.     if (!busy)
  574.     {
  575.     busy = 1;
  576.     if (dos_ready())
  577.         do_save();
  578.     busy = 0;
  579.     }
  580. }
  581.  
  582. /**
  583. *
  584. * Name        idle -- Interrupt service routine for INT 28h
  585. *
  586. * Description    This function is installed as a handler for software
  587. *        interrupt type 0x28 (DOS idle).  It first calls the
  588. *        previous INT 28H handler.  Then it calls do_save.
  589. *
  590. *        This function protects itself against secondary
  591. *        invocations by means of the "busy" flag.
  592. *
  593. *        (This function need not check dos_ready() because INT
  594. *        28h handlers are allowed to perform DOS disk I/O.
  595. *        do_save() does not do DOS keyboard I/O.)
  596. *
  597. **/
  598.  
  599. void idle(pregs,pisrblk,pmsg)
  600. ALLREG    *pregs;
  601. ISRCTRL *pisrblk;
  602. ISRMSG    *pmsg;
  603. {
  604.     static int busy = 0;
  605.  
  606.     utintoff();
  607.     iscalint(&pisrblk->prev_vec,pregs);
  608.  
  609.     utintoff();
  610.     if (!busy)
  611.     {
  612.     busy = 1;
  613.     do_save();
  614.     busy = 0;
  615.     }
  616. }
  617.  
  618. /**
  619. *
  620. * Name        dos_ready -- Report whether DOS services are available
  621. *
  622. * Synopsis    ready = dos_ready();
  623. *
  624. *        int ready          0       if DOS is not ready,
  625. *                      nonzero if DOS is ready.
  626. *
  627. * Description    This function checks the DOS critical section flag and
  628. *        reports whether DOS services are available.
  629. *
  630. *        This function makes use of dos_flag_ads, the global
  631. *        variable containing the address of the DOS critical
  632. *        section flag.  This variable must be loaded before
  633. *        dos_ready() is called.
  634. *
  635. * Returns    ready              0       if DOS is not ready,
  636. *                      nonzero if DOS is ready.
  637. *
  638. **/
  639.  
  640. int dos_ready()
  641. {
  642.     char   our_flag;              /* Our copy of the flag.          */
  643.     ADS    our_ads;              /* Address of our_flag.          */
  644.  
  645.     utintoff();
  646.     utabsptr(&our_flag,&our_ads);
  647.     utslmove(&dos_flag_ads,&our_ads,1);
  648.  
  649.     return (our_flag == 0);
  650. }
  651.  
  652. /**
  653. *
  654. * Name        do_save -- Obtain filename and save screen image
  655. *               if want_to_save is nonzero.
  656. *
  657. * Synopsis    do_save();
  658. *
  659. * Description    This function begins by testing the want_to_save flag.
  660. *        If it is nonzero, it proceeds to obtain the name of a
  661. *        file from the user and to save the current screen image
  662. *        onto the file.    This operation is repeated until success
  663. *        occurs or the user gives a null filename.
  664. *
  665. *        This function protects itself against secondary
  666. *        invocations by means of the "busy" flag.
  667. *
  668. * Returns    name_err          OK or WINDOW_ERROR.
  669. *        file_err          OK or DOS file system error.
  670. *        filename          File name entered by user.
  671. *
  672. **/
  673.  
  674. void do_save()
  675. {
  676.     static int busy = 0;
  677.  
  678.     utintoff();
  679.     if ((!busy) && want_to_save)
  680.     {
  681.     busy = 1;
  682.  
  683.     if (have_spare_mem)
  684.     {
  685.         free(pspare_mem);
  686.         have_spare_mem = 0;
  687.     }
  688.  
  689.     do
  690.     {
  691.         name_err = prompt("Enter name of file on which to save screen:  ",
  692.                   filename,
  693.                   sizeof(filename));
  694.     } while (OK != (file_err = write_file(filename)));
  695.     remove_window();
  696.     utintoff();
  697.     want_to_save = 0;
  698.     busy         = 0;
  699.     }
  700.  
  701.     utinton();
  702. }
  703.  
  704. /**
  705. *
  706. * Name        write_file -- Copy screen image to file.
  707. *
  708. * Synopsis    ercode = write_file(pfilename);
  709. *
  710. *        int ercode          OK or DOS file system error.
  711. *        char *pfilename       Pointer to character array
  712. *                      containing file name.
  713. *
  714. * Description    This function attempts to copy the screen image to the
  715. *        named file.  If the file already exists and has nonzero
  716. *        length, it first obtains permission from the user to
  717. *        delete the existing file.
  718. *
  719. *        If any file system error occurs, the error number is
  720. *        displayed in a window.    The program then pauses until
  721. *        the ENTER key is struck.
  722. *
  723. * Returns    ercode              OK or DOS file system error.
  724. *
  725. **/
  726.  
  727. int write_file(pfilename)
  728. char *pfilename;
  729. {
  730.     int  handle;
  731.     long size;
  732.     char answer[3];
  733.     int  mode,columns,act_page,rows,row;
  734.     int  ercode,nwritten;
  735.  
  736.     if (*pfilename == '\0')           /* No filename given.           */
  737.     return OK;
  738.  
  739.     utinton();
  740.     switch (ercode = flopen(pfilename,&handle,WRTONLY))
  741.     {
  742.     case 0:               /* File already exists          */
  743.         size = 0L;
  744.         flseek(handle,ENDFILE,&size);
  745.         if (size == 0L)
  746.         break;
  747.  
  748.         flclose(handle);
  749.         prompt("Delete existing file?  (Y/N) ",answer,sizeof(answer));
  750.         if (*stpcvt(answer,RLWHITE+TOLOW) != 'y')
  751.         return TRY_NEW_FILENAME;
  752.  
  753.     case 2:               /* Truncate existing file       */
  754.                       /* or create new file.          */
  755.         if (ercode = flcreate(pfilename,&handle,AT_GENERAL))
  756.         {
  757.         warning("DOS error creating file:  ",ercode);
  758.         return ercode;
  759.         }
  760.         break;
  761.  
  762.     default:
  763.         warning("DOS error opening file:  ",ercode);
  764.         return ercode;
  765.     }
  766.  
  767.     remove_window();
  768.     scmode(&mode,&columns,&act_page);
  769.     rows = scrows();
  770.     scpage(act_page);
  771.  
  772.     for (row = 0; row < rows; row++)
  773.     {
  774.     gvrdrect(row,0,row,columns - 1,scn_buffer,CHARS_ONLY);
  775.     if (ercode = flwrite(handle,&scn_buf_ads,columns,&nwritten))
  776.     {
  777.         warning("DOS error writing file:  ",ercode);
  778.         return ercode;
  779.     }
  780.     else if (nwritten != columns)
  781.     {
  782.         warning("Target device full",0);
  783.         return TARGET_FULL;
  784.     }
  785.  
  786.     if (ercode = flwrite(handle,&crlf_ads,2,&nwritten))
  787.     {
  788.         warning("DOS error writing file:  ",ercode);
  789.         return ercode;
  790.     }
  791.     else if (nwritten != 2)
  792.     {
  793.         warning("Target device full",0);
  794.         return TARGET_FULL;
  795.     }
  796.     }
  797.  
  798.     if (ercode = flclose(handle))
  799.     warning("DOS error closing file:  ",ercode);
  800.     return ercode;
  801. }
  802.  
  803. /**
  804. *
  805. * Name        display_window -- Display window for user dialog.
  806. *
  807. * Synopsis    ercode = display_window();
  808. *
  809. *        int ercode          OK or WINDOW_ERROR.
  810. *
  811. * Description    This function displays a window (if not already
  812. *        displayed) on the active display page for messages
  813. *        and/or user input.  It also records the previous
  814. *        location and size of the cursor so that the cursor may
  815. *        be restored by remove_window().
  816. *
  817. * Returns    ercode              OK or WINDOW_ERROR.
  818. *
  819. **/
  820.  
  821. int display_window()
  822. {
  823.     static WHERE   where_to_put_window =
  824.     {
  825.     0,                  /* Video display device          */
  826.     0,                  /* Video display page          */
  827.     {6,5}                  /* Row & column              */
  828.     };
  829.     static BORDER  window_border =
  830.     {
  831.     16,                  /* Double box              */
  832.     RED,                  /* Color                  */
  833.     0                  /* Border character (ignored)   */
  834.     };
  835.     int mode,columns,act_page;
  836.  
  837.     if (window_displayed)          /* Quit if window already       */
  838.     return OK;              /* displayed.              */
  839.  
  840.     where_to_put_window.dev  = scmode(&mode,&columns,&act_page);
  841.     where_to_put_window.page = act_page;
  842.  
  843.     scpage(act_page);
  844.                       /* Obtain former cursor state.  */
  845.     cursor_was_off = sccurst(&old_row,&old_col,&high,&low);
  846.  
  847.     b_wnerr = WN_NO_ERROR;          /* Clear residual error code.   */
  848.                       /* Display the window.          */
  849.     if (NIL == wndsplay(pwindow,&where_to_put_window,&window_border))
  850.     return WINDOW_ERROR;
  851.  
  852.     window_displayed = 1;
  853.     return OK;
  854. }
  855.  
  856. /**
  857. *
  858. * Name        remove_window -- Remove window and restore previous
  859. *                 screen.
  860. *
  861. * Synopsis    remove_window();
  862. *
  863. * Description    This function removes the window (if currently
  864. *        displayed) and restores the previous contents of the
  865. *        screen and the state of the cursor.
  866. *
  867. * Returns    (None -- function return type is void.)
  868. *
  869. **/
  870.  
  871. void remove_window()
  872. {
  873.     if (window_displayed)
  874.     {
  875.     wnremove(pwindow);
  876.  
  877.                       /* Restore former cursor state. */
  878.     scpgcur(cursor_was_off,high,low,CUR_NO_ADJUST);
  879.     sccurset(old_row,old_col);
  880.     window_displayed = 0;
  881.     }
  882. }
  883.  
  884. /**
  885. *
  886. * Name        prompt -- Display a message and await a response from
  887. *              the user.
  888. *
  889. * Synopsis    ercode = prompt(pquestion,panswer,ans_size);
  890. *
  891. *        int ercode          OK or WINDOW_ERROR.
  892. *        char *pquestion       Message to display.
  893. *        char *panswer          Buffer in which to place response.
  894. *        int ans_size          Size of answer buffer in bytes
  895. *                      (including one byte for trailing
  896. *                      NUL ('\0')).
  897. *
  898. * Description    This function displays a window (if not already
  899. *        displayed) and the message contained in *pquestion.
  900. *        Then it waits for the user to enter a reply terminated
  901. *        by the ENTER key.
  902. *
  903. * Returns    ercode              OK or WINDOW_ERROR.
  904. *
  905. **/
  906.  
  907. int prompt(pquestion,panswer,ans_size)
  908. char *pquestion,*panswer;
  909. int  ans_size;
  910. {
  911.     int  keycode,ercode;
  912.     int  row,col;
  913.     char key;
  914.  
  915.     *panswer = '\0';                  /* Null answer in case of error */
  916.  
  917.     b_wnerr  = WN_NO_ERROR;
  918.     wnselect(pwindow);
  919.     wnscroll(0,-1,-1,SCR_UP);          /* Clear window.              */
  920.     wncurmov(0,0);
  921.                       /* Display the prompt.          */
  922.     wnwrap(0,pquestion,-1,-1,CHARS_ONLY);
  923.     if (b_wnerr != WN_NO_ERROR)
  924.     return WINDOW_ERROR;
  925.  
  926.     if (OK != (ercode = display_window()))
  927.     return ercode;
  928.  
  929.     kbflush();
  930.     utinton();
  931.  
  932.     b_wnerr = WN_NO_ERROR;
  933.     wncurpos(&row,&col);
  934.     do
  935.     {
  936.     wncurmov(row,col);
  937.     key = wnquery(panswer,ans_size,&keycode);
  938.     } while (b_wnerr == WN_NO_ERROR && key != ENTER_KEY);
  939.  
  940.     if (b_wnerr != WN_NO_ERROR)
  941.     {
  942.     *panswer = '\0';
  943.     return WINDOW_ERROR;
  944.     }
  945.  
  946.     stpcvt(panswer,RWHITE+TOLOW);
  947.     return OK;
  948. }
  949.  
  950. /**
  951. *
  952. * Name        warning -- Report a DOS error and wait for user
  953. *               to press the ENTER key.
  954. *
  955. * Synopsis    ercode = warning(ptext,number);
  956. *
  957. *        int ercode          OK or WINDOW_ERROR.
  958. *        char *pmessage          Message to display.
  959. *        int number          DOS error number to display.
  960. *
  961. * Description    This function displays a window (if not already
  962. *        displayed), the message contained in *pquestion, and the
  963. *        error number.  Then it waits for the user to enter a
  964. *        reply terminated by the ENTER key.
  965. *
  966. * Returns    ercode              OK or WINDOW_ERROR.
  967. *
  968. **/
  969.  
  970. int warning(ptext,number)
  971. char *ptext;
  972. int  number;
  973. {
  974.     char message[81],dummy[2];
  975.  
  976.     message[0] = '\0';
  977.     strcat(message,ptext);
  978.     if (number)
  979.     sprintf(&(message[strlen(message)]),"%d",number);
  980.     strcat(message,"\015\012-- Press ENTER to continue.");
  981.  
  982.     return prompt(message,dummy,sizeof(dummy));
  983. }
  984.