![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to termio.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 / bin / me|
Return to termio.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / me |
1.1 ! root 1: /* ! 2: * The functions in this file negotiate with the operating system ! 3: * for characters, and write characters in a barely buffered fashion ! 4: * on the display. ! 5: * All operating systems. ! 6: */ ! 7: #include <stdio.h> ! 8: #include "ed.h" ! 9: ! 10: #if IBM ! 11: #define lo(r) ((r)&0xFF) /* low-order byte of word register */ ! 12: #define hi(r) ((r)>>8) /* high-order byte of word register */ ! 13: #endif ! 14: ! 15: #if VMS ! 16: #include <stsdef.h> ! 17: #include <ssdef.h> ! 18: #include <descrip.h> ! 19: #include <iodef.h> ! 20: #include <ttdef.h> ! 21: ! 22: #define NIBUF 128 /* Input buffer size */ ! 23: #define NOBUF 1024 /* MM says bug buffers win! */ ! 24: #define EFN 0 /* Event flag */ ! 25: ! 26: uchar obuf[NOBUF]; /* Output buffer */ ! 27: int nobuf; /* # of bytes in above */ ! 28: uchar ibuf[NIBUF]; /* Input buffer */ ! 29: int nibuf; /* # of bytes in above */ ! 30: int ibufi; /* Read index */ ! 31: int oldmode[2]; /* Old TTY mode bits */ ! 32: int newmode[2]; /* New TTY mode bits */ ! 33: short iochan; /* TTY I/O channel */ ! 34: #endif ! 35: ! 36: #if CPM ! 37: #include <bdos.h> ! 38: #endif ! 39: ! 40: #if MSDOS ! 41: #include <dos.h> ! 42: #endif ! 43: ! 44: #if GEM ! 45: #include <osbind.h> ! 46: #endif ! 47: ! 48: #if V7 ! 49: #include <sgtty.h> /* for stty/gtty functions */ ! 50: struct sgttyb ostate; /* saved tty state */ ! 51: struct sgttyb nstate; /* values for editor mode */ ! 52: #endif ! 53: ! 54: /* ! 55: * This function is called once ! 56: * to set up the terminal device streams. ! 57: * On VMS, it translates SYS$INPUT until it ! 58: * finds the terminal, then assigns a channel to it ! 59: * and sets it raw. On CPM it is a no-op. ! 60: */ ! 61: ttopen() ! 62: { ! 63: #if VMS ! 64: struct dsc$descriptor idsc; ! 65: struct dsc$descriptor odsc; ! 66: uchar oname[40]; ! 67: int iosb[2]; ! 68: int status; ! 69: ! 70: odsc.dsc$a_pointer = "SYS$INPUT"; ! 71: odsc.dsc$w_length = strlen(odsc.dsc$a_pointer); ! 72: odsc.dsc$b_dtype = DSC$K_DTYPE_T; ! 73: odsc.dsc$b_class = DSC$K_CLASS_S; ! 74: idsc.dsc$b_dtype = DSC$K_DTYPE_T; ! 75: idsc.dsc$b_class = DSC$K_CLASS_S; ! 76: do { ! 77: idsc.dsc$a_pointer = odsc.dsc$a_pointer; ! 78: idsc.dsc$w_length = odsc.dsc$w_length; ! 79: odsc.dsc$a_pointer = &oname[0]; ! 80: odsc.dsc$w_length = sizeof(oname); ! 81: status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc); ! 82: if (status!=SS$_NORMAL && status!=SS$_NOTRAN) ! 83: exit(status); ! 84: if (oname[0] == 0x1B) { ! 85: odsc.dsc$a_pointer += 4; ! 86: odsc.dsc$w_length -= 4; ! 87: } ! 88: } while (status == SS$_NORMAL); ! 89: status = SYS$ASSIGN(&odsc, &iochan, 0, 0); ! 90: if (status != SS$_NORMAL) ! 91: exit(status); ! 92: status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0, ! 93: oldmode, sizeof(oldmode), 0, 0, 0, 0); ! 94: if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) ! 95: exit(status); ! 96: newmode[0] = oldmode[0]; ! 97: newmode[1] = oldmode[1] | TT$M_PASSALL | TT$M_NOECHO; ! 98: status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, ! 99: newmode, sizeof(newmode), 0, 0, 0, 0); ! 100: if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) ! 101: exit(status); ! 102: #endif ! 103: #if CPM ! 104: #endif ! 105: #if MSDOS ! 106: #if !IBM ! 107: /* ! 108: * Redefine cursor keys (as described in DOS Technical Reference Manual ! 109: * p. 2-11, DOS BASIC Manual p. G-6) to mean what the user might expect. ! 110: */ ! 111: static char *control[] = { ! 112: "\033[0;72;16p", /* up = <ctrl-p> */ ! 113: "\033[0;77;6p", /* right = <ctrl-f> */ ! 114: "\033[0;75;2p", /* left = <ctrl-b> */ ! 115: "\033[0;80;14p", /* down = <ctrl-n> */ ! 116: "\033[0;81;22p", /* pg dn = <ctrl-v> */ ! 117: "\033[0;73;27;86p", /* pg up = <esc>V */ ! 118: "\033[0;71;27;60p", /* home = <esc>< */ ! 119: "\033[0;79;27;62p", /* end = <esc>> */ ! 120: "\033[0;83;127p", /* del = del */ ! 121: "\033[0;3;27;46p" /* <ctrl-@> = <esc>. */ ! 122: }; ! 123: register uchar *cp; ! 124: register int i; ! 125: ! 126: for (i = 0; i < sizeof(control)/sizeof(uchar *); i++) { ! 127: for (cp = control[i]; *cp; ) ! 128: ttputc(*cp++); ! 129: } ! 130: ! 131: #endif ! 132: #endif ! 133: #if V7 ! 134: gtty(1, &ostate); /* save old state */ ! 135: nstate = ostate; /* get base of new state */ ! 136: nstate.sg_flags |= RAW; ! 137: nstate.sg_flags &= ~(ECHO|CRMOD); /* no echo for now... */ ! 138: stty(1, &nstate); /* set mode */ ! 139: #endif ! 140: } ! 141: ! 142: /* ! 143: * This function gets called just ! 144: * before we go back home to the command interpreter. ! 145: * On VMS it puts the terminal back in a reasonable state. ! 146: * Another no-operation on CPM. ! 147: */ ! 148: ttclose() ! 149: { ! 150: #if VMS ! 151: int status; ! 152: int iosb[1]; ! 153: ! 154: ttflush(); ! 155: status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0, ! 156: oldmode, sizeof(oldmode), 0, 0, 0, 0); ! 157: if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL) ! 158: exit(status); ! 159: status = SYS$DASSGN(iochan); ! 160: if (status != SS$_NORMAL) ! 161: exit(status); ! 162: #endif ! 163: #if CPM ! 164: #endif ! 165: #if MSDOS ! 166: #if !IBM ! 167: /* Redefine cursor keys to default values. */ ! 168: static char *control[] = { ! 169: "\033[0;72;0;72p", ! 170: "\033[0;77;0;77p", ! 171: "\033[0;75;0;75p", ! 172: "\033[0;80;0;80p", ! 173: "\033[0;81;0;81p", ! 174: "\033[0;73;0;73p", ! 175: "\033[0;71;0;71p", ! 176: "\033[0;79;0;79p", ! 177: "\033[0;83;0;83p", ! 178: "\033[0;3;0;3p" ! 179: }; ! 180: register uchar *cp; ! 181: register int i; ! 182: ! 183: for (i = 0; i < sizeof(control)/sizeof(uchar *); i++) { ! 184: for (cp = control[i]; *cp; ) ! 185: ttputc(*cp++); ! 186: } ! 187: #endif ! 188: #endif ! 189: #if V7 ! 190: stty(1, &ostate); ! 191: #endif ! 192: } ! 193: ! 194: #ifndef IBM ! 195: /* ! 196: * Write a character to the display. ! 197: * On VMS, terminal output is buffered, and ! 198: * we just put the characters in the big array, ! 199: * after cheching for overflow. On CPM terminal I/O ! 200: * unbuffered, so we just write the byte out. ! 201: * Ditto on MS-DOS (use the very very raw console ! 202: * output routine). ! 203: */ ! 204: ttputc(c) ! 205: { ! 206: #if VMS ! 207: if (nobuf >= NOBUF) ! 208: ttflush(); ! 209: obuf[nobuf++] = c; ! 210: #endif ! 211: #if CPM ! 212: bios(BCONOUT, c, 0); ! 213: #endif ! 214: #if GEM ! 215: #if NATIVE ! 216: Bconout(2, c); ! 217: #else ! 218: Crawio(c); ! 219: #endif ! 220: #endif ! 221: #if MSDOS ! 222: dosb(CONDIO, c, 0); ! 223: #endif ! 224: #if V7 ! 225: fputc(c, stdout); ! 226: #endif ! 227: } ! 228: #endif ! 229: /* ! 230: * Flush terminal buffer. Does real work ! 231: * where the terminal output is buffered up. A ! 232: * no-operation on systems where byte at a time ! 233: * terminal I/O is done. ! 234: */ ! 235: ttflush() ! 236: { ! 237: #if VMS ! 238: int status; ! 239: int iosb[2]; ! 240: ! 241: status = SS$_NORMAL; ! 242: if (nobuf != 0) { ! 243: status = SYS$QIOW(EFN, iochan, IO$_WRITELBLK|IO$M_NOFORMAT, ! 244: iosb, 0, 0, obuf, nobuf, 0, 0, 0, 0); ! 245: if (status == SS$_NORMAL) ! 246: status = iosb[0] & 0xFFFF; ! 247: nobuf = 0; ! 248: } ! 249: return (status); ! 250: #endif ! 251: #if CPM ! 252: #endif ! 253: #if MSDOS ! 254: #endif ! 255: #if V7 ! 256: fflush(stdout); ! 257: #endif ! 258: } ! 259: ! 260: /* ! 261: * Read a character from the terminal, ! 262: * performing no editing and doing no echo at all. ! 263: * More complex in VMS that almost anyplace else, which ! 264: * figures. Very simple on CPM, because the system can ! 265: * do exactly what you want. ! 266: */ ! 267: ttgetc() ! 268: { ! 269: #if VMS ! 270: int status; ! 271: int iosb[2]; ! 272: int term[2]; ! 273: ! 274: while (ibufi >= nibuf) { ! 275: ibufi = 0; ! 276: term[0] = 0; ! 277: term[1] = 0; ! 278: status = SYS$QIOW(EFN, iochan, IO$_READLBLK|IO$M_TIMED, ! 279: iosb, 0, 0, ibuf, NIBUF, 0, term, 0, 0); ! 280: if (status != SS$_NORMAL) ! 281: exit(status); ! 282: status = iosb[0] & 0xFFFF; ! 283: if (status!=SS$_NORMAL && status!=SS$_TIMEOUT) ! 284: exit(status); ! 285: nibuf = (iosb[0]>>16) + (iosb[1]>>16); ! 286: if (nibuf == 0) { ! 287: status = sys$qiow(EFN, iochan, IO$_READLBLK, ! 288: iosb, 0, 0, ibuf, 1, 0, term, 0, 0); ! 289: if (status != SS$_NORMAL ! 290: || (status = (iosb[0]&0xFFFF)) != SS$_NORMAL) ! 291: exit(status); ! 292: nibuf = (iosb[0]>>16) + (iosb[1]>>16); ! 293: } ! 294: } ! 295: return (ibuf[ibufi++] & 0xFF); /* Allow multinational */ ! 296: #endif ! 297: #if CPM ! 298: return (biosb(BCONIN, 0, 0)); ! 299: #endif ! 300: #if GEM ! 301: register long c; ! 302: ! 303: #if NATIVE ! 304: c = Bconin(2); ! 305: #else ! 306: c = Crawcin(); ! 307: #endif ! 308: /* ! 309: * Convert arrow keys to ctrl-p,n,f,b, and function keys to ! 310: * various things. (No longer return 0 for function keys.) ! 311: */ ! 312: switch ((int)(c >> 16)) { ! 313: case 0x48: /* Up arrow to ^P */ ! 314: return (OBND|0x10); ! 315: case 0x50: /* Down arrow to ^N */ ! 316: return (OBND|0x0E); ! 317: case 0x4D: /* Right arrow to ^F */ ! 318: return (OBND|0x06); ! 319: case 0x4B: /* Left arrow to ^B */ ! 320: return (OBND|0x02); ! 321: #if EXKEYS ! 322: case 0x3B: /* F1 */ ! 323: return (FN1); ! 324: case 0x3C: /* F2 */ ! 325: return (FN2); ! 326: case 0x3D: /* F3 */ ! 327: return (FN3); ! 328: case 0x3E: /* F4 */ ! 329: return (FN4); ! 330: case 0x3F: /* F5 */ ! 331: return (FN5); ! 332: case 0x40: /* F6 */ ! 333: return (FN6); ! 334: case 0x41: /* F7 */ ! 335: return (FN7); ! 336: case 0x42: /* F8 */ ! 337: return (FN8); ! 338: case 0x43: /* F9 */ ! 339: return (FN9); ! 340: case 0x44: /* F10 */ ! 341: return (FN10); ! 342: case 0x47: /* Clr/Home */ ! 343: return (FN1D); /* Delete this window */ ! 344: case 0x52: /* Insert */ ! 345: return (FN1C); /* perform macro */ ! 346: case 0x61: /* Undo */ ! 347: return (FN1B); /* Remove help window */ ! 348: case 0x62: /* Help */ ! 349: return (FN1A); /* Prompt for help */ ! 350: #else ! 351: case 0x3B: /* F1 */ ! 352: case 0x3C: /* F2 */ ! 353: case 0x3D: /* F3 */ ! 354: case 0x3E: /* F4 */ ! 355: case 0x3F: /* F5 */ ! 356: case 0x40: /* F6 */ ! 357: case 0x41: /* F7 */ ! 358: case 0x42: /* F8 */ ! 359: case 0x43: /* F9 */ ! 360: case 0x44: /* F10 */ ! 361: return (0x07|OBND); /* Ctrl-G */ ! 362: case 0x47: /* Clr/Home */ ! 363: return (OBND|META|'1'); /* Delete this window */ ! 364: case 0x52: /* Insert */ ! 365: return (OBND|PFX1|'E'); /* perform macro */ ! 366: case 0x61: /* Undo */ ! 367: return (OBND|META|'2'); /* Remove help window */ ! 368: case 0x62: /* Help */ ! 369: return (OBND|META|'?'); /* Prompt for help */ ! 370: #endif ! 371: default: /* Return the keyboard character */ ! 372: return ((int)c); ! 373: } ! 374: #endif ! 375: #if MSDOS ! 376: #if IBM ! 377: unsigned i; ! 378: ! 379: for (;;) { /* try again on bad stuff */ ! 380: /* Read a character through IBM PC ROM BIOS keyboard interrupt. */ ! 381: i = ibmrbkey(0); /* read character fn */ ! 382: if (lo(i)) ! 383: return (lo(i)); /* got a char */ ! 384: ! 385: switch (hi(i)) { /* else translate scan code */ ! 386: case 03: /* <ctl-@> = <esc>. */ ! 387: return OBND| '.' | META; ! 388: case 71: /* home = <esc>< */ ! 389: return OBND| '<' | META; ! 390: case 72: /* up = <ctl>p */ ! 391: return OBND| 'P' | CTRL; ! 392: case 73: /* pg up = <esc>v */ ! 393: return OBND| 'V' | META; ! 394: case 75: /* left = <ctl>b */ ! 395: return OBND| 'B' | CTRL; ! 396: case 77: /* right = <ctl>f */ ! 397: return OBND| 'F' | CTRL; ! 398: case 79: /* end = <esc>> */ ! 399: return OBND| '>' | META; ! 400: case 80: /* down = <ctl>n */ ! 401: return OBND| 'N' | CTRL; ! 402: case 81: /* pg dn = <ctl>v */ ! 403: return OBND| 'V' | CTRL; ! 404: case 83: /* del = del */ ! 405: return OBND| 127; ! 406: #if EXKEYS ! 407: case 0x3B: /* F1 */ ! 408: return (FN1); ! 409: case 0x3C: /* F2 */ ! 410: return (FN2); ! 411: case 0x3D: /* F3 */ ! 412: return (FN3); ! 413: case 0x3E: /* F4 */ ! 414: return (FN4); ! 415: case 0x3F: /* F5 */ ! 416: return (FN5); ! 417: case 0x40: /* F6 */ ! 418: return (FN6); ! 419: case 0x41: /* F7 */ ! 420: return (FN7); ! 421: case 0x42: /* F8 */ ! 422: return (FN8); ! 423: case 0x43: /* F9 */ ! 424: return (FN9); ! 425: case 0x44: /* F10 */ ! 426: return (FN10); ! 427: case 0x52: /* Insert */ ! 428: return (FN1C); /* perform macro */ ! 429: case 0x61: /* Undo */ ! 430: return (FN1B); /* Remove help window */ ! 431: case 0x62: /* Help */ ! 432: return (FN1A); /* Prompt for help */ ! 433: #endif ! 434: } ! 435: } ! 436: #else ! 437: return (dosb(CONRAW, 0, 0)); ! 438: #endif ! 439: #endif ! 440: #if V7 ! 441: return (fgetc(stdin)); ! 442: #endif ! 443: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.