home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mitsch75.zip / scheme-7_5_17-src.zip / scheme-7.5.17 / src / microcode / os2ctty.c < prev    next >
C/C++ Source or Header  |  1999-01-02  |  6KB  |  196 lines
  1. /* -*-C-*-
  2.  
  3. $Id: os2ctty.c,v 1.4 1999/01/02 06:11:34 cph Exp $
  4.  
  5. Copyright (c) 1994-1999 Massachusetts Institute of Technology
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or (at
  10. your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful, but
  13. WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "os2.h"
  23. #include "osctty.h"
  24. #include "ossig.h"
  25.  
  26. #define CONTROL_B_ENABLE        (0x1)
  27. #define CONTROL_G_ENABLE        (0x2)
  28. #define CONTROL_U_ENABLE        (0x4)
  29. #define CONTROL_X_ENABLE        (0x8)
  30. #define INTERACTIVE_INTERRUPT_ENABLE    (0x10)
  31. #define TERMINATE_INTERRUPT_ENABLE    (0x20)
  32.  
  33. #define ALL_ENABLES                            \
  34.   (CONTROL_B_ENABLE | CONTROL_G_ENABLE | CONTROL_U_ENABLE | CONTROL_X_ENABLE)
  35.  
  36. #define CONTROL_B            '\002'
  37. #define CONTROL_G            '\007'
  38. #define CONTROL_U            '\025'
  39. #define CONTROL_X            '\030'
  40. #define CONTROL_C            '\003'
  41.  
  42. #define KB_INT_CHARS_SIZE 5
  43. #define KB_INT_TABLE_SIZE 256
  44.  
  45. static char keyboard_interrupt_characters [KB_INT_CHARS_SIZE];
  46. static enum interrupt_handler keyboard_interrupt_handlers [KB_INT_CHARS_SIZE];
  47. static enum interrupt_handler keyboard_interrupt_table [KB_INT_TABLE_SIZE];
  48. static enum interrupt_handler keyboard_break_interrupt;
  49. static Tinterrupt_enables keyboard_interrupt_enables;
  50.  
  51. static void
  52. update_keyboard_interrupt_characters (void)
  53. {
  54.   unsigned int i;
  55.   for (i = 0; (i < KB_INT_TABLE_SIZE); i += 1)
  56.     (keyboard_interrupt_table[i]) = interrupt_handler_ignore;
  57.   for (i = 0; (i < KB_INT_CHARS_SIZE); i += 1)
  58.     (keyboard_interrupt_table [keyboard_interrupt_characters [i]]) =
  59.       (keyboard_interrupt_handlers[i]);
  60. }
  61.  
  62. void
  63. OS2_initialize_keyboard_interrupts (void)
  64. {
  65.   (keyboard_interrupt_characters[0]) = CONTROL_B;
  66.   (keyboard_interrupt_handlers[0]) = interrupt_handler_control_b;
  67.   (keyboard_interrupt_characters[1]) = CONTROL_G;
  68.   (keyboard_interrupt_handlers[1]) = interrupt_handler_control_g;
  69.   (keyboard_interrupt_characters[2]) = CONTROL_U;
  70.   (keyboard_interrupt_handlers[2]) = interrupt_handler_control_u;
  71.   (keyboard_interrupt_characters[3]) = CONTROL_X;
  72.   (keyboard_interrupt_handlers[3]) = interrupt_handler_control_x;
  73.   (keyboard_interrupt_characters[4]) = CONTROL_C;
  74.   (keyboard_interrupt_handlers[4]) = interrupt_handler_interactive;
  75.   keyboard_break_interrupt = interrupt_handler_terminate;
  76.   update_keyboard_interrupt_characters ();
  77.   keyboard_interrupt_enables = ALL_ENABLES;
  78. }
  79.  
  80. void
  81. OS_ctty_get_interrupt_enables (Tinterrupt_enables * mask)
  82. {
  83.   (*mask) = keyboard_interrupt_enables;
  84. }
  85.  
  86. void
  87. OS_ctty_set_interrupt_enables (Tinterrupt_enables * mask)
  88. {
  89.   keyboard_interrupt_enables = ((*mask) & ALL_ENABLES);
  90. }
  91.  
  92. unsigned int
  93. OS_ctty_num_int_chars (void)
  94. {
  95.   return (KB_INT_CHARS_SIZE + 1);
  96. }
  97.  
  98. cc_t
  99. OS_tty_map_interrupt_char (cc_t int_char)
  100. {
  101.   return (int_char);
  102. }
  103.  
  104. cc_t *
  105. OS_ctty_get_int_chars (void)
  106. {
  107.   static cc_t characters [KB_INT_CHARS_SIZE + 1];
  108.   unsigned int i;
  109.   for (i = 0; (i < KB_INT_CHARS_SIZE); i += 1)
  110.     (characters[i]) = (keyboard_interrupt_characters[i]);
  111.   (characters[i]) = '\0';    /* dummy for control-break */
  112.   return (characters);
  113. }
  114.  
  115. void
  116. OS_ctty_set_int_chars (cc_t * characters)
  117. {
  118.   unsigned int i;
  119.   for (i = 0; (i < KB_INT_CHARS_SIZE); i += 1)
  120.     (keyboard_interrupt_characters[i]) = (characters[i]);
  121.   update_keyboard_interrupt_characters ();
  122. }
  123.  
  124. cc_t *
  125. OS_ctty_get_int_char_handlers (void)
  126. {
  127.   static cc_t handlers [KB_INT_CHARS_SIZE + 1];
  128.   unsigned int i;
  129.   for (i = 0; (i < KB_INT_CHARS_SIZE); i += 1)
  130.     (handlers[i]) = ((cc_t) (keyboard_interrupt_handlers[i]));
  131.   (handlers[i]) = ((cc_t) keyboard_break_interrupt);
  132.   return (handlers);
  133. }
  134.  
  135. void
  136. OS_ctty_set_int_char_handlers (cc_t * handlers)
  137. {
  138.   unsigned int i;
  139.   for (i = 0; (i < KB_INT_CHARS_SIZE); i += 1)
  140.     (keyboard_interrupt_handlers[i]) =
  141.       ((enum interrupt_handler) (handlers[i]));
  142.   keyboard_break_interrupt = ((enum interrupt_handler) (handlers[i]));
  143.   update_keyboard_interrupt_characters ();
  144. }
  145.  
  146. static char
  147. check_if_enabled (enum interrupt_handler handler)
  148. {
  149.   unsigned int bitmask;
  150.   char result;
  151.   switch (handler)
  152.     {
  153.     case interrupt_handler_control_b:
  154.       bitmask = CONTROL_B_ENABLE;
  155.       result = 'B';
  156.       break;
  157.     case interrupt_handler_control_g:
  158.       bitmask = CONTROL_G_ENABLE;
  159.       result = 'G';
  160.       break;
  161.     case interrupt_handler_control_u:
  162.       bitmask = CONTROL_U_ENABLE;
  163.       result = 'U';
  164.       break;
  165.     case interrupt_handler_control_x:
  166.       bitmask = CONTROL_X_ENABLE;
  167.       result = 'X';
  168.       break;
  169.     case interrupt_handler_interactive:
  170.       bitmask = INTERACTIVE_INTERRUPT_ENABLE;
  171.       result = '!';
  172.       break;
  173.     case interrupt_handler_terminate:
  174.       bitmask = TERMINATE_INTERRUPT_ENABLE;
  175.       result = '@';
  176.       break;
  177.     default:
  178.       bitmask = 0;
  179.       result = '\0';
  180.       break;
  181.     }
  182.   return (((keyboard_interrupt_enables & bitmask) == 0) ? '\0' : result);
  183. }
  184.  
  185. char
  186. OS2_keyboard_interrupt_handler (char c)
  187. {
  188.   return (check_if_enabled (keyboard_interrupt_table[c]));
  189. }
  190.  
  191. char
  192. OS2_keyboard_break_interrupt_handler (void)
  193. {
  194.   return (check_if_enabled (keyboard_break_interrupt));
  195. }
  196.