home *** CD-ROM | disk | FTP | other *** search
/ Jason Aller Floppy Collection / 267.img / RESIDNTC.ZIP / DEMOS.ZIP / RESCLOCK.C < prev    next >
Text File  |  1990-02-13  |  7KB  |  240 lines
  1. /*
  2.       Module name.
  3.         resclock.c - display clock w/optional comand timer
  4.   
  5. -)    Functional description.
  6.          This program will display a clock in the upper right corner
  7.          of the screen and optionally accept a time and DOS command
  8.          as an argument.  At the specified time the command is passed
  9.          to DOS and the ISR is terminated and freed from memory.  The
  10.          command length is limited to 15 characters, so batch files
  11.          should be used to execute more complex command line
  12.          requirments
  13.   
  14. --)   NOTICE:  Copyright (C) 1990 South Mountain Software, Inc.
  15. */
  16. #include "tsr.h"
  17. #include "resproto.h"
  18. #include "stdio.h"
  19. #include "stdlib.h"
  20. #include "conio.h"
  21. #include "string.h"
  22. #include "process.h"
  23. #include "isr.h"
  24.   
  25. #define  TRUE  1
  26. #define  FALSE 0
  27.   
  28. #define  ROW   0
  29. #define  COL   65
  30. #define  ATTR  0x70   /* black on white */
  31.   
  32. /* int 16h unique function we use to see if loaded */
  33. unsigned int myfunc = 0x7272;
  34.   
  35. /* address to total timmer tics since midnight */
  36. long far * systics = (long far *) 0x0000046CL;
  37.   
  38. int hr,min,sec,hd;
  39. int schr, schm;       /* scheduled time vars */
  40. int  cmdsize;
  41. char cmd[129];
  42. unsigned char stop = 0;
  43.   
  44. extern unsigned kb_in_progress; /* for use with kb_init */
  45. extern char *kb_str_ptr;            /* for use with kb_init */
  46.   
  47. void clock(void);
  48. void keystuff(char *str);
  49. void display(char *str);
  50. void isrpre(void);
  51. int tim_pars(char *str);
  52. void keystuff(char *key_str);
  53.   
  54. void main(int argc,char **argv)
  55. {
  56. int  add_arg;      /* counter for command line arguments */
  57.   
  58.    /* process timed command request */
  59.     if(argc > 2) {
  60.     tim_pars(argv[1]);               /* parse the time into schr & schm */
  61.   
  62.     add_arg = 2;
  63.         while(argc-- > 2) {              /* add all arguments to command line */
  64.         strcat(cmd, argv[add_arg++]);
  65.         strcat(cmd, " ");
  66.         }
  67.     }
  68.   
  69. if (tsrloaded(myfunc) == FALSE)
  70.     {
  71.     isrpre();
  72.     initisr(0x1c, clock, 50, myfunc, SIG, (void far *) NULL,1);
  73.     }
  74. else
  75.     {
  76.     printf("RESCLOCK Already Loaded!\n");
  77.     exit(1);
  78.     }
  79. }
  80.   
  81. void clock()
  82. {
  83. char curtime[15];          /* buffer to hold time */
  84. char temp_ptr[17];          /* temporary buffer for itoa() */
  85. static cnt;                /* times thru int 1Ch */
  86. static unsigned long tmp;  /* will hold tics since midnight */
  87.   
  88. tmp = *systics;                  /* get tics since midnight */
  89.   
  90.    /* this formula converts tics since midnight */
  91. hr = (int) (tmp / 65543L);
  92. tmp %= 65543L;
  93. min = (int) (tmp / 1092);
  94. tmp %= 1092;
  95. sec = (int) (tmp * 100L / 1821L);
  96.   
  97.    /* we'll only update the clock display when sec changes */
  98.     if(cnt != sec) {
  99.     cnt = sec;
  100.   
  101.  /*  cannot use sprintf because it was compiled with
  102.      stack checking on.                                */
  103.  /*     sprintf(curtime," %2d:%2d:%2d ",hr,min,sec); */
  104.   
  105.     /* do it the hard way with itoa */
  106.     curtime[0] = ' ';
  107.     curtime[1] = '\0';
  108.     itoa(hr,temp_ptr,10);
  109.     if(strlen(temp_ptr) == 1)   /* force two digits for each number */
  110.         strcat(curtime,"0");
  111.     strcat(curtime,temp_ptr);
  112.     strcat(curtime,":");
  113.     itoa(min,temp_ptr,10);
  114.     if(strlen(temp_ptr) == 1)   /* force two digits for each number */
  115.         strcat(curtime,"0");
  116.     strcat(curtime,temp_ptr);
  117.     strcat(curtime,":");
  118.     itoa(sec,temp_ptr,10);
  119.     if(strlen(temp_ptr) == 1)   /* force two digits for each number */
  120.         strcat(curtime,"0");
  121.     strcat(curtime,temp_ptr);
  122.     strcat(curtime," ");
  123.     display(curtime);                /* put the time on the screen */
  124.     }
  125.   
  126.    /* process command if one was requested */
  127. if (!stop)
  128.     if(cmdsize && hr == schr && min == schm)
  129.         {
  130.         if (freeisr() == 1)           /* free ISR when done */
  131.             {
  132.             stop = 1;
  133.             return;                         /* return to DOS to execute */
  134.             }
  135.     else
  136.        {
  137.                 /* The following technique limits keyboard
  138.                 stuffing to 15 characters (the size of the
  139.                 keyboard buffer) so that the TSR can free
  140.                 itself before executing the command.  The kb_init()
  141.                 function cannot be used here because this ISR
  142.                 is servicing a hardware interrupt and kb_init()
  143.                 does a DOS call to replace the timer interrupt vector.
  144.                 Instead it calls keystuff() below which physically
  145.                 stuffs the characters in the BIOS data area.
  146.                 */
  147.             keystuff(cmd);
  148.             return;                         /* return to DOS to execute */
  149.        }
  150.         }
  151. }
  152.   
  153. /* Interleave atribute and display time */
  154. void display(str)
  155. char *str;
  156. {
  157. register char *curptr;   /* used to steo thru buffer */
  158. char buf[31];            /* actual buffer to write to screen */
  159.   
  160.   
  161. curptr = buf;
  162.   
  163.    /* merge char and attribute for screen format */
  164.     while(*str) {
  165.     *curptr++ = *str++;
  166.     *curptr++ = ATTR;
  167.     }
  168.   
  169.    /* do the actual display */
  170. memtoscr(10, (ROW * 160) + (COL * 2), buf);
  171. return;
  172. }
  173.   
  174. /*
  175.    This function takes the time in HH:MM format and places it into
  176.    two int variables for hour and minute.
  177. */
  178. int tim_pars(str)
  179. char *str;
  180. {
  181. char *ptr;   /* used to step thru str */
  182.   
  183. for(ptr = str; *ptr != ':' && *ptr; ptr++);
  184.   
  185. if(*ptr == NULL)                     /* no : was found, invalid time */
  186.     return(-1);
  187.   
  188. *ptr++ = '\0';                      /* split hour and point to minute */
  189. schr = atoi(str);
  190. schm = atoi(ptr);
  191.   
  192. return(0);
  193. }
  194.   
  195. void isrpre()   /* simulates tsrpre() to keep this and resclok2.c similar */
  196. {
  197. printf("\nRESCLOCK  By South Mountain Software\n\n");
  198. if((cmdsize = strlen(cmd)) > 0)      /* verify command and time */
  199.     {
  200.     if(cmdsize <= 14)                     /* cmd includes trailing blank here */
  201.         {
  202.         printf("At %02d:%02d Execute %s\n", schr, schm, cmd);
  203.            cmd[cmdsize] = '\0';             /* delete last blank */
  204.         strcat(cmd, "\r\n");         /* cause return at end of command */
  205.         cmdsize += 1;
  206.         }
  207.     else
  208.         {
  209.         putch(7);
  210.         printf("Command length exceeds max of 13 characters!\n");
  211.         printf("Try using a batch file to work around this.\n");
  212.         }
  213.     }
  214. }
  215.   
  216.  
  217. /* keystuff.c    - stuff characters into the keyboard buffer */
  218.  
  219. /* this function clears the keyboard buffer and stuffs a     */
  220. /* string of up to 15 chars into the kybd buffer             */
  221.  
  222. void keystuff(char *str)
  223. {
  224. int i = 0;
  225. char far *pokechar;
  226.  
  227. pokechar = (char far *) 0x0000041eL;        /* address of BIOS keyboard buffer */
  228.  
  229. while(*str){
  230.     *pokechar++ = *str++;  /* poke ascii code into buffer */
  231.     *pokechar++ = 1;     /* poke 1 - will not handle function keys */
  232.     i+=2;                /* i points to next ascii position */
  233. }
  234. pokechar =  (char far *) 0x0000041a;
  235. *pokechar = 0x1e;                                 /* point buffer head to start */
  236. pokechar = (char far *) 0x0000041c;     /* point tail to end */
  237. *pokechar = 0x1e + i;     
  238.  
  239. }
  240.