![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lib_options.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses|
Return to lib_options.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses |
1.1 ! root 1: /********************************************************************* ! 2: * COPYRIGHT NOTICE * ! 3: ********************************************************************** ! 4: * This software is copyright (C) 1982 by Pavel Curtis * ! 5: * * ! 6: * Permission is granted to reproduce and distribute * ! 7: * this file by any means so long as no fee is charged * ! 8: * above a nominal handling fee and so long as this * ! 9: * notice is always included in the copies. * ! 10: * * ! 11: * Other rights are reserved except as explicitly granted * ! 12: * by written permission of the author. * ! 13: * Pavel Curtis * ! 14: * Computer Science Dept. * ! 15: * 405 Upson Hall * ! 16: * Cornell University * ! 17: * Ithaca, NY 14853 * ! 18: * * ! 19: * Ph- (607) 256-4934 * ! 20: * * ! 21: * Pavel.Cornell@Udel-Relay (ARPAnet) * ! 22: * decvax!cornell!pavel (UUCPnet) * ! 23: *********************************************************************/ ! 24: ! 25: /* ! 26: ** lib_options.c ! 27: ** ! 28: ** The routines to handle option setting. ! 29: ** ! 30: ** $Log: RCS/lib_options.v $ ! 31: * Revision 2.4 92/11/08 15:41:44 munk ! 32: * Correct definition of malloc() and ! 33: * usage of the cast operator ! 34: * ! 35: * Revision 2.3 91/12/03 21:51:11 munk ! 36: * Added KEY_LL in function init_keytry() ! 37: * ! 38: * Revision 2.2 91/04/20 21:29:33 munk ! 39: * Usage of register variables ! 40: * ! 41: * Revision 2.1 82/10/25 14:48:24 pavel ! 42: * Added Copyright Notice ! 43: * ! 44: * Revision 2.0 82/10/25 13:47:45 pavel ! 45: * Beta-one Test Release ! 46: * ! 47: ** ! 48: */ ! 49: ! 50: #ifdef RCSHDR ! 51: static char RCSid[] = ! 52: "$Header: RCS/lib_options.v Revision 2.2 91/04/20 21:29:33 munk Exp$"; ! 53: #endif ! 54: ! 55: #include "term.h" ! 56: #include "curses.h" ! 57: #include "curses.priv.h" ! 58: ! 59: char *malloc(); ! 60: ! 61: ! 62: static ! 63: outc(ch) ! 64: char ch; ! 65: { ! 66: putc(ch, SP->_ofp); ! 67: } ! 68: ! 69: ! 70: idlok(win, flag) ! 71: WINDOW *win; ! 72: int flag; ! 73: { ! 74: #ifdef TRACE ! 75: if (_tracing) ! 76: _tracef("idlok(%o,%d) called", win, flag); ! 77: #endif ! 78: ! 79: if ((insert_line && delete_line) ! 80: #ifdef UNIMPLEMENTED ! 81: || (change_scroll_region) ! 82: #endif ! 83: ) ! 84: curscr->_idlok = flag; ! 85: } ! 86: ! 87: ! 88: clearok(win, flag) ! 89: WINDOW *win; ! 90: int flag; ! 91: { ! 92: #ifdef TRACE ! 93: if (_tracing) ! 94: _tracef("clearok(%o,%d) called", win, flag); ! 95: #endif ! 96: ! 97: if (win == curscr) ! 98: newscr->_clear = flag; ! 99: else ! 100: win->_clear = flag; ! 101: } ! 102: ! 103: ! 104: leaveok(win, flag) ! 105: WINDOW *win; ! 106: int flag; ! 107: { ! 108: #ifdef TRACE ! 109: if (_tracing) ! 110: _tracef("leaveok(%o,%d) called", win, flag); ! 111: #endif ! 112: ! 113: win->_leave = flag; ! 114: } ! 115: ! 116: ! 117: scrollok(win, flag) ! 118: WINDOW *win; ! 119: int flag; ! 120: { ! 121: #ifdef TRACE ! 122: if (_tracing) ! 123: _tracef("scrollok(%o,%d) called", win, flag); ! 124: #endif ! 125: ! 126: win->_scroll = flag; ! 127: } ! 128: ! 129: ! 130: nodelay(win, flag) ! 131: WINDOW *win; ! 132: int flag; ! 133: { ! 134: #ifdef TRACE ! 135: if (_tracing) ! 136: _tracef("nodelay(%o,%d) called", win, flag); ! 137: #endif ! 138: ! 139: win->_nodelay = flag; ! 140: } ! 141: ! 142: ! 143: keypad(win, flag) ! 144: WINDOW *win; ! 145: int flag; ! 146: { ! 147: #ifdef TRACE ! 148: if (_tracing) ! 149: _tracef("keypad(%o,%d) called", win, flag); ! 150: #endif ! 151: ! 152: win->_use_keypad = flag; ! 153: ! 154: if (flag && keypad_xmit) ! 155: tputs(keypad_xmit, 1, outc); ! 156: else if (! flag && keypad_local) ! 157: tputs(keypad_local, 1, outc); ! 158: ! 159: if (SP->_keytry == UNINITIALISED) ! 160: init_keytry(); ! 161: } ! 162: ! 163: ! 164: meta(win, flag) ! 165: WINDOW *win; ! 166: int flag; ! 167: { ! 168: #ifdef TRACE ! 169: if (_tracing) ! 170: _tracef("meta(%o,%d) called", win, flag); ! 171: #endif ! 172: ! 173: win->_use_meta = flag; ! 174: ! 175: if (flag && meta_on) ! 176: tputs(meta_on, 1, outc); ! 177: else if (! flag && meta_off) ! 178: tputs(meta_off, 1, outc); ! 179: } ! 180: ! 181: ! 182: /* ! 183: ** init_keytry() ! 184: ** ! 185: ** Construct the try for the current terminal's keypad keys. ! 186: ** ! 187: */ ! 188: ! 189: static struct try *newtry; ! 190: ! 191: static ! 192: init_keytry() ! 193: { ! 194: newtry = NULL; ! 195: ! 196: add_to_try(key_backspace, KEY_BACKSPACE); ! 197: add_to_try(key_catab, KEY_CATAB); ! 198: add_to_try(key_clear, KEY_CLEAR); ! 199: add_to_try(key_ctab, KEY_CTAB); ! 200: add_to_try(key_dc, KEY_DC); ! 201: add_to_try(key_dl, KEY_DL); ! 202: add_to_try(key_down, KEY_DOWN); ! 203: add_to_try(key_eic, KEY_EIC); ! 204: add_to_try(key_eol, KEY_EOL); ! 205: add_to_try(key_eos, KEY_EOS); ! 206: add_to_try(key_f0, KEY_F(0)); ! 207: add_to_try(key_f1, KEY_F(1)); ! 208: add_to_try(key_f2, KEY_F(2)); ! 209: add_to_try(key_f3, KEY_F(3)); ! 210: add_to_try(key_f4, KEY_F(4)); ! 211: add_to_try(key_f5, KEY_F(5)); ! 212: add_to_try(key_f6, KEY_F(6)); ! 213: add_to_try(key_f7, KEY_F(7)); ! 214: add_to_try(key_f8, KEY_F(8)); ! 215: add_to_try(key_f9, KEY_F(9)); ! 216: add_to_try(key_f10, KEY_F(10)); ! 217: add_to_try(key_home, KEY_HOME); ! 218: add_to_try(key_ll, KEY_LL); ! 219: add_to_try(key_ic, KEY_IC); ! 220: add_to_try(key_il, KEY_IL); ! 221: add_to_try(key_left, KEY_LEFT); ! 222: add_to_try(key_npage, KEY_NPAGE); ! 223: add_to_try(key_ppage, KEY_PPAGE); ! 224: add_to_try(key_right, KEY_RIGHT); ! 225: add_to_try(key_sf, KEY_SF); ! 226: add_to_try(key_sr, KEY_SR); ! 227: add_to_try(key_stab, KEY_STAB); ! 228: add_to_try(key_up, KEY_UP); ! 229: ! 230: SP->_keytry = newtry; ! 231: } ! 232: ! 233: ! 234: add_to_try(str, code) ! 235: register char *str; ! 236: short code; ! 237: { ! 238: void free(); ! 239: static bool out_of_memory = FALSE; ! 240: register struct try *ptr, *savedptr; ! 241: ! 242: if (! str || out_of_memory) ! 243: return; ! 244: ! 245: if (newtry != NULL) ! 246: { ! 247: ptr = newtry; ! 248: ! 249: for (;;) ! 250: { ! 251: while (ptr->ch != *str && ptr->sibling != NULL) ! 252: ptr = ptr->sibling; ! 253: ! 254: if (ptr->ch == *str) ! 255: { ! 256: if (*(++str)) ! 257: { ! 258: if (ptr->child != NULL) ! 259: ptr = ptr->child; ! 260: else ! 261: break; ! 262: } ! 263: else ! 264: { ! 265: ptr->value = code; ! 266: return; ! 267: } ! 268: } ! 269: else ! 270: { ! 271: if ((ptr->sibling = (struct try *) malloc(sizeof *ptr)) == NULL) ! 272: { ! 273: out_of_memory = TRUE; ! 274: return; ! 275: } ! 276: ! 277: savedptr = ptr = ptr->sibling; ! 278: ptr->child = ptr->sibling = NULL; ! 279: ptr->ch = *str++; ! 280: ptr->value = 0; ! 281: ! 282: break; ! 283: } ! 284: } /* end for (;;) */ ! 285: } ! 286: else /* newtry == NULL :: First sequence to be added */ ! 287: { ! 288: savedptr = ptr = newtry = (struct try *) malloc(sizeof *ptr); ! 289: ! 290: if (ptr == NULL) ! 291: { ! 292: out_of_memory = TRUE; ! 293: return; ! 294: } ! 295: ! 296: ptr->child = ptr->sibling = NULL; ! 297: ptr->ch = *(str++); ! 298: ptr->value = 0; ! 299: } ! 300: ! 301: /* at this point, we are adding to the try. ptr->child == NULL */ ! 302: ! 303: while (*str) ! 304: { ! 305: ptr->child = (struct try *) malloc(sizeof *ptr); ! 306: ! 307: ptr = ptr->child; ! 308: ! 309: if (ptr == NULL) ! 310: { ! 311: out_of_memory = TRUE; ! 312: ! 313: ptr = savedptr; ! 314: while (ptr != NULL) ! 315: { ! 316: savedptr = ptr->child; ! 317: free(ptr); ! 318: ptr = savedptr; ! 319: } ! 320: ! 321: return; ! 322: } ! 323: ! 324: ptr->child = ptr->sibling = NULL; ! 325: ptr->ch = *(str++); ! 326: ptr->value = 0; ! 327: } ! 328: ! 329: ptr->value = code; ! 330: return; ! 331: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.