keep, _dos_keep

Exits and remains resident.

Defined in header <dos.h>

Syntax

#include <dos.h>
void keep(unsigned  char status, unsigned size);
void _dos_keep(unsigned   char status, unsigned size);

Portability

Remarks

keep and _dos_keep return to DOS with the exit status in status. The current program remains resident, however. The program is set to size paragraphs in length, and the remainder of the memory of the program is freed.

keep and _dos_keep can be used when instalHng TSR programs, keep and _dos_keep use DOS function 0x31.

Before _dos_keep exits, it calls any registered "exit functions" (posted with atexit), flushes file buffers, and restores interrupt vectors modified by the startup code.

Return value

None.

See also

• abort
• exit

Example

/* This is an interrupt service routine. You can NOT compile this program with
   Test Stack Overflow turned on and get an executable file which will operate
   correctly. Due to the nature of this function the formula used to compute the
   number of paragraphs may not necessarily work in all cases. Use with care!
   Terminate Stay Resident (TSR) programs are complex and no other support for
   them is provided. Refer to the MS-DOS technical documentation for more
   information. */

#include <dos.h>
   /* The clock tick interrupt */
#define INTR OxlC
   /* Screen attribute (blue on grey) */
ttdefine ATTR 0x7900
#ifdef   cplusplus
    #def ine _CPPARGS ...
#else
    #define _CPPARGS
ttendif

/* Reduce heaplength and stacklength to make a smaller program in memory.  */
extern unsigned _heaplen = 1024;
extern unsigned _stklen  = 512;
void interrupt ( *oldhandler) (_CPPARGS);

typedef unsigned int (far *s_arrayptr);

void interrupt handler (_CPPARGS)
{
   s_arrayptr screen[80];
   static int count;
   /* For a color screen the video memory is at B800:0000.
      For a monochrome system use B000:000.
   */
   screen[0] = (s_arrayptr) MK_FP(0xB800,0);

   /* increase the counter and keep it within 0 to 9 */
   count++;
   count 1= 10;
   /* put the number on the screen */
   screen[0][79] = count + '0' + ATTR;
   /* call the old interrupt handler */
   oldhandlerO ;
}
int main(void)
{
   /* Get the address of the current clock tick interrupt */
   oldhandler = getvect(INTR);
   /* install the new interrupt handler */
   setvect(INTR, handler);
   /* _psp is the starting address of the program in memory. The top of the  stack
      is the end of the program. Using _SS and _SP together we can get the  end of
      the stack. You may want to allow a bit of safety space to insure that
      enough room is being allocated ie:
      (_SS + ((_SP + safety space)/16) - _psp)
   */
   keep(0, (_SS + (_SP/16) -_psp));
   return 0;
/* note: This is an interrupt service routine. You CANNOT  compile this program
   with Test Stack Overflow turned on and get an executable  file which v/ill
   operate correctly. Due to the nature of this  function the formula used to
   compute the number of paragraphs may not necessarily work  in all cases. Use
   with care! Terminate Stay Resident  (TSR) programs are complex and no other
   support for them is provided. Refer to the MS-DOS technical documentation  for
   more information. */
#include <dos.h>
   /* The clock tick interrupt */
#define INTR OxlC
   /* Screen attribute  (blue on grey) */
ffdefine ATTR 0x7900
#ifdef   cplusplus
    #define _CPPARGS   ...
#else
    tdefine _CPPARGS
#endif

/* Reduce heaplength and stacklength to make a smaller program in memory  */
extern unsigned _heaplen = 1024;
extern unsigned _stklen  = 512;

void interrupt  ( *oldhandler) {_CPPARGS);

typedef unsigned int  (far *s_arrayptr);

void interrupt handler ( CPPARGS)
{
   s_arrayptr screen [80];
   static int count;

/* For a color screen- the video memory is at B800:0000.
   For a monochrome system use B000:000 */
   screen[0] = (s_arrayptr) MK_FP(0xB800,0);
/* Increase the counter and keep it within 0 to 9. */
   count++;
   count %= 10;

/* Put the number on the screen. */
   screen[0][79] = count + '0' + ATTR;
/* Call the old interrupt handler. */
   oldhandler();
}
int main(void)
{
/* Get the address of the current clock tick interrupt. */
   oldhandler = _dos_getvect(INTR);

/* install the new interrupt handler */
   _dos_setvect(INTR, handler);
/* _psp is the starting address of the program in memory. The top of the stack is
   the end of the program. Using _SS and _SP together we can get the end of the
   stack. You may want to allow a bit of safety space to insure that enough room
   is being allocated ie:
   (_SS + ((_SP + safety space)/15) - _psp) */
   _dos_keep(0, (_SS + (_SP/n     _psp)
   return 0';

Differences from modern implementations

Nothing recorded yet.

Modern references

• Microsoft C runtime (search)

These are search links, not yet checked by hand.

Stable link: /3.1/dos.h/keep/ · short form /3.1/keep/