home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d166 / stevie.lha / Stevie / source / tos.c < prev    next >
C/C++ Source or Header  |  1988-11-22  |  6KB  |  311 lines
  1. /*
  2.  * System-dependent routines for the Atari ST. 
  3.  */
  4.  
  5. #include "stevie.h"
  6.  
  7. #include <osbind.h>
  8.  
  9. /*
  10.  * The following buffer is used to work around a bug in TOS. It appears that
  11.  * unread console input can cause a crash, but only if console output is
  12.  * going on. The solution is to always grab any unread input before putting
  13.  * out a character. The following buffer holds any characters read in this
  14.  * fashion. The problem can be easily produced because STEVIE can't yet keep
  15.  * up with the normal auto-repeat rate in insert mode. 
  16.  */
  17. #define    IBUFSZ    128
  18.  
  19. static long     inbuf[IBUFSZ];    /* buffer for unread input */
  20. static long    *inptr = inbuf;    /* where to put next character */
  21.  
  22. /*
  23.  * inchar() - get a character from the keyboard 
  24.  *
  25.  * Certain special keys are mapped to values above 0x80. These mappings are
  26.  * defined in keymap.h. If the key has a non-zero ascii value, it is simply
  27.  * returned. Otherwise it may be a special key we want to map. 
  28.  *
  29.  * The ST has a bug involving keyboard input that seems to occur when typing
  30.  * quickly, especially typing capital letters. Sometimes a value of
  31.  * 0x02540000 is read. This doesn't correspond to anything on the keyboard,
  32.  * according to my documentation. My solution is to loop when any unknown key
  33.  * is seen. Normally, the bell is rung to indicate the error. If the "bug"
  34.  * value is seen, we ignore it completely. 
  35.  */
  36. char
  37. inchar()
  38. {
  39.     for (;;) {
  40.     long            c, *p;
  41.  
  42.     /*
  43.      * Get the next input character, either from the input buffer or
  44.      * directly from TOS. 
  45.      */
  46.     if (inptr != inbuf) {    /* input in the buffer, use it */
  47.         c = inbuf[0];
  48.         /*
  49.          * Shift everything else in the buffer down. This would be
  50.          * cleaner if we used a circular buffer, but it really isn't
  51.          * worth it. 
  52.          */
  53.         inptr--;
  54.         for (p = inbuf; p < inptr; p++)
  55.         *p = *(p + 1);
  56.     } else
  57.         c = Crawcin();
  58.  
  59.     if ((c & 0xff) != 0)
  60.         return ((char) c);
  61.  
  62.     switch ((int) (c >> 16) & 0xff) {
  63.  
  64.       case 0x62:
  65.         return K_HELP;
  66.       case 0x61:
  67.         return K_UNDO;
  68.       case 0x52:
  69.         return K_INSERT;
  70.       case 0x47:
  71.         return K_HOME;
  72.       case 0x48:
  73.         return K_UARROW;
  74.       case 0x50:
  75.         return K_DARROW;
  76.       case 0x4b:
  77.         return K_LARROW;
  78.       case 0x4d:
  79.         return K_RARROW;
  80.       case 0x29:
  81.         return K_CGRAVE;    /* control grave accent */
  82.  
  83.         /*
  84.          * Occurs due to a bug in TOS. 
  85.          */
  86.       case 0x54:
  87.         break;
  88.         /*
  89.          * Add the function keys here later if we put in support for
  90.          * macros. 
  91.          */
  92.  
  93.       default:
  94.         beep();
  95.         break;
  96.  
  97.     }
  98.     }
  99. }
  100.  
  101. /*
  102.  * get_inchars - snarf away any pending console input 
  103.  *
  104.  * If the buffer overflows, we discard what's left and ring the bell. 
  105.  */
  106. static void
  107. get_inchars()
  108. {
  109.     while (Cconis()) {
  110.     if (inptr >= &inbuf[IBUFSZ]) {    /* no room in buffer? */
  111.         Crawcin();        /* discard the input */
  112.         beep();        /* and sound the alarm */
  113.     } else
  114.         *inptr++ = Crawcin();
  115.     }
  116. }
  117.  
  118. void
  119. outchar(c)
  120.     char            c;
  121. {
  122.     get_inchars();
  123.     Cconout(c);
  124. }
  125.  
  126. void
  127. outstr(s)
  128.     char           *s;
  129. {
  130.     get_inchars();
  131.     Cconws(s);
  132. }
  133.  
  134. #define    BGND    0
  135. #define    TEXT    3
  136.  
  137. /*
  138.  * vbeep() - visual bell 
  139.  */
  140. static void
  141. vbeep()
  142. {
  143.     int             text, bgnd;    /* text and background colors */
  144.     long            l;
  145.  
  146.     text = Setcolor(TEXT, -1);
  147.     bgnd = Setcolor(BGND, -1);
  148.  
  149.     Setcolor(TEXT, bgnd);    /* swap colors */
  150.     Setcolor(BGND, text);
  151.  
  152.     for (l = 0; l < 5000; l++);    /* short pause */
  153.  
  154.     Setcolor(TEXT, text);    /* restore colors */
  155.     Setcolor(BGND, bgnd);
  156. }
  157.  
  158. void
  159. beep()
  160. {
  161.     if (RedrawingDisabled)
  162.     return;
  163.  
  164.     if (P(P_VB))
  165.     vbeep();
  166.     else
  167.     outchar('\007');
  168. }
  169.  
  170. /*
  171.  * remove(file) - remove a file 
  172.  */
  173. void
  174. remove(file)
  175.     char           *file;
  176. {
  177.     Fdelete(file);
  178. }
  179.  
  180. /*
  181.  * rename(of, nf) - rename existing file 'of' to 'nf' 
  182.  */
  183. void
  184. rename(of, nf)
  185.     char           *of, *nf;
  186. {
  187.     Fdelete(nf);        /* if 'nf' exists, remove it */
  188.     Frename(0, of, nf);
  189. }
  190.  
  191. void
  192. windinit()
  193. {
  194.     if (Getrez() == 0)
  195.     Columns = 40;        /* low resolution */
  196.     else
  197.     Columns = 80;        /* medium or high */
  198.  
  199.     P(P_LI) = Rows = 25;
  200.  
  201.     Cursconf(1, NULL);
  202. }
  203.  
  204. void
  205. windexit(r)
  206.     int             r;
  207. {
  208.     exit(r);
  209. }
  210.  
  211. void
  212. windgoto(r, c)
  213.     int             r, c;
  214. {
  215.     outstr("\033Y");
  216.     outchar(r + 040);
  217.     outchar(c + 040);
  218. }
  219.  
  220. /*
  221.  * System calls or library routines missing in TOS. 
  222.  */
  223.  
  224. void
  225. sleep(n)
  226.     int             n;
  227. {
  228.     int             k;
  229.  
  230.     k = Tgettime();
  231.     while (Tgettime() <= k + n);
  232. }
  233.  
  234. void
  235. delay()
  236. {
  237.     long            n;
  238.  
  239.     for (n = 0; n < 8000; n++);
  240. }
  241.  
  242. int
  243. system(cmd)
  244.     char           *cmd;
  245. {
  246.     char            arg[1];
  247.  
  248.     arg[0] = (char) 0;        /* no arguments passed to the shell */
  249.  
  250.     if (Pexec(0, cmd, arg, 0L) < 0)
  251.     return -1;
  252.     else
  253.     return 0;
  254. }
  255.  
  256. #ifdef    MEGAMAX
  257. char           *
  258. strchr(s, c)
  259.     char           *s;
  260.     int             c;
  261. {
  262.     do {
  263.     if (*s == c)
  264.         return (s);
  265.     } while (*s++);
  266.     return (NULL);
  267. }
  268. #endif
  269.  
  270. #ifdef    MEGAMAX
  271.  
  272. FILE           *
  273. fopenb(fname, mode)
  274.     char           *fname;
  275.     char           *mode;
  276. {
  277.     char            modestr[10];
  278.  
  279.     sprintf(modestr, "b%s", mode);
  280.  
  281.     return fopen(fname, modestr);
  282. }
  283.  
  284. #endif
  285.  
  286. /*
  287.  * getenv() - get a string from the environment 
  288.  *
  289.  * Both Alcyon and Megamax are missing getenv(). This routine works for both
  290.  * compilers and with the Beckemeyer and Gulam shells. With gulam, the
  291.  * env_style variable should be set to either "mw" or "gu". 
  292.  */
  293. char           *
  294. getenv(name)
  295.     char           *name;
  296. {
  297.     extern long     _base;
  298.     char           *envp, *p;
  299.  
  300.     envp = *((char **) (_base + 0x2c));
  301.  
  302.     for (; *envp; envp += strlen(envp) + 1) {
  303.     if (strncmp(envp, name, strlen(name)) == 0) {
  304.         p = envp + strlen(name);
  305.         if (*p++ == '=')
  306.         return p;
  307.     }
  308.     }
  309.     return (char *) 0;
  310. }
  311.