![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to edit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / korn|
Return to edit.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / korn |
1.1 root 1: /*
2: * EDIT.C -- Emacs-like command line editing and history
3: *
4: * created by Ron Natalie at BRL
5: * modified by Doug Kingston, Doug Gwyn, and Lou Salkind
6: * adapted to PD ksh by Eric Gisin
7: */
8:
9: #if EDIT
10:
11: static char *RCSid = "$Header: /newbits/usr/bin/korn/RCS/edit.c,v 1.2 91/08/01 12:39:10 bin Exp Locker: bin $";
12:
13: #include <stddef.h>
14: #include <stdlib.h>
15: #include <string.h>
16: #include <stdio.h>
17: #include <unistd.h>
18: #include <signal.h>
19: #if !COHERENT
20: #include <sys/types.h>
21: #endif
22: #include <sys/stat.h>
23: #include "dirent.h"
24: #include <sys/fcntl.h>
25: #include <ctype.h>
26: #include <errno.h>
27: #include <setjmp.h>
28: #include "sh.h"
29: #include "lex.h"
30: #include "tree.h" /* DOTILDE */
31: #include "tty.h"
32: #include "table.h"
33: #include "expand.h"
34:
35: #if COHERENT
36: struct dirent *readdir(); /* missing from headers */
37: DIR *opendir();
38: #endif
39:
40: Area aedit;
41: #define AEDIT &aedit /* area for kill ring and macro defns */
42:
43: #undef CTRL /* _BSD brain damage */
44: #define CTRL(x) ((x) == '?' ? 0x7F : (x) & 0x1F) /* ASCII */
45: #define UNCTRL(x) ((x) == 0x7F ? '?' : (x) | 0x40) /* ASCII */
46:
47: #if ! defined S_ISDIR
48: #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
49: #endif
50:
51: #if ! defined S_ISREG
52: #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
53: #endif
54:
55: #if defined _CRAY2
56: extern unsigned sleep();
57: #endif
58:
59: /* values returned by keyboard functions */
60: #define KSTD 0
61: #define KPREF 1 /* ^[, ^X */
62: #define KEOL 2 /* ^M, ^J */
63: #define KINTR 3 /* ^G, ^C */
64:
65: struct x_ftab {
66: int (*xf_func)();
67: char *xf_name;
68: char xf_db_tab;
69: char xf_db_char;
70: short xf_flags;
71: };
72:
73: #define XF_NINPUT 1
74: #define XF_ALLOC 2
75: #define XF_NOBIND 4
76:
77: #define isfs(c) (c == ' ' || c == '\t')
78: #define BEL 0x07
79: #define CMASK 0x7F /* 7-bit ASCII character mask */
80:
81: static bool_t x_mode = FALSE;
82: static int x_prefix1 = CTRL('['), x_prefix2 = CTRL('X');
83: static char **x_histp; /* history position */
84: static char *xbuf; /* beg input buffer */
85: static char *xend; /* end input buffer */
86: static char *xcp;
87: static char *xep;
88: static int (*x_last_command)();
89: /*static struct x_ftab *x_tab[3][128];*/
90: static struct x_ftab Const *(*x_tab)[128] = NULL; /* key definition */
91: static char *(*x_atab)[128] = NULL; /* macro definitions */
92: #define KILLSIZE 20
93: static char *killstack[KILLSIZE];
94: static int killsp, killtp;
95: static int x_curprefix;
96: static char *macroptr;
97: static int first_time = 1;
98: static int x_maxlen; /* to determine column width */
99: static int x_cols = 80; /* todo: $COLUMNS */
100:
101: static void x_flush(), x_putc(), x_puts();
102: static void x_goto(), x_bs(), x_delete(), x_ins(), x_mapin();
103: static int x_fword(), x_bword(), x_size(), x_size_str();
104: static void x_zotc(), x_zots(), x_push(), x_redraw(), x_load_hist();
105: static void compl_command(), compl_dec(), compl_file();
106: static int x_insert(), x_ins_string(), x_del_back();
107: static int x_del_char(), x_del_bword(), x_mv_bword(), x_mv_fword();
108: static int x_del_fword(), x_mv_back(), x_mv_forw(), x_search_char();
109: static int x_newline(), x_end_of_text(), x_abort(), x_error();
110: static int x_beg_hist(), x_end_hist(), x_prev_com(), x_next_com();
111: static int x_search_hist(), x_del_line(), x_mv_end(), x_mv_begin();
112: static int x_draw_line(), x_transpose(), x_meta1(), x_meta2();
113: static int x_kill(), x_yank(), x_meta_yank(), x_literal();
114: static int x_stuffreset(), x_stuff(), x_complete(), x_enumerate();
115: #if SILLY
116: static int x_game_of_life();
117: #endif
118: static int x_comp_file(), x_comp_comm();
119: static int x_list_file(), x_list_comm();
120: static int strmatch();
121:
122: static struct x_ftab Const x_ftab[] = {
123: {x_insert, "auto-insert", 0, 0, 0 },
124: {x_error, "error", 0, 0, 0 },
125: {x_ins_string, "macro-string", 0, 0, XF_NOBIND|XF_ALLOC},
126: /* Do not move the above! */
127: {x_del_back, "delete-char-backward", 0, CTRL('H'), 0 },
128: {x_del_char, "delete-char-forward", 0, CTRL('D'), 0 },
129: {x_del_bword, "delete-word-backward", 0, CTRL('W'), 0 },
130: {x_mv_bword, "backward-word", 1, 'b', 0 },
131: {x_mv_fword, "forward-word", 1, 'f', 0 },
132: {x_del_fword, "delete-word-forward", 1, 'd', 0 },
133: {x_mv_back, "backward-char", 0, CTRL('B'), 0 },
134: {x_mv_forw, "forward-char", 0, CTRL('F'), 0 },
135: {x_search_char, "search-character", 0, CTRL(']'), 0 },
136: {x_newline, "newline", 0, CTRL('M'), 0 },
137: {x_newline, "newline", 0, CTRL('J'), 0 },
138: {x_end_of_text, "eot", 0, CTRL('_'), 0 },
139: {x_abort, "abort", 0, CTRL('G'), 0 },
140: {x_prev_com, "up-history", 0, CTRL('P'), XF_NINPUT},
141: {x_next_com, "down-history", 0, CTRL('N'), XF_NINPUT},
142: {x_search_hist, "search-history", 0, CTRL('R'), XF_NINPUT},
143: {x_beg_hist, "beginning-of-history", 1, '<', XF_NINPUT},
144: {x_end_hist, "end-of-history", 1, '>', XF_NINPUT},
145: {x_del_line, "kill-line", 0, CTRL('U'), 0 },
146: {x_mv_end, "end-of-line", 0, CTRL('E'), 0 },
147: {x_mv_begin, "beginning-of-line", 0, CTRL('A'), 0 },
148: {x_draw_line, "redraw", 0, CTRL('L'), 0 },
149: {x_meta1, "prefix-1", 0, CTRL('['), 0 },
150: {x_meta2, "prefix-2", 0, CTRL('X'), 0 },
151: {x_kill, "kill-to-eol", 0, CTRL('K'), 0 },
152: {x_yank, "yank", 0, CTRL('Y'), 0 },
153: {x_meta_yank, "yank-pop", 1, 'y', 0 },
154: {x_literal, "quote", 0, CTRL('^'), 0 },
155: {x_stuffreset, "stuff-reset", 0, 0, 0 },
156: #if BRL && defined(TIOCSTI)
157: {x_stuff, "stuff", 0, CTRL('T'), 0 },
158: {x_transpose, "transpose-chars", 0, 0, 0 },
159: #else
160: {x_stuff, "stuff", 0, 0, 0 },
161: {x_transpose, "transpose-chars", 0, CTRL('T'), 0 },
162: #endif
163: {x_complete, "complete", 1, CTRL('['), 0 },
164: {x_enumerate, "list", 1, '?', 0 },
165: {x_comp_file, "complete-file", 2, CTRL('X'), 0 },
166: {x_comp_comm, "complete-command", 2, CTRL('['), 0 },
167: {x_list_file, "list-file", 0, 0, 0 },
168: {x_list_comm, "list-command", 2, '?', 0 },
169: #if SILLY
170: {x_game_of_life, "play-game-of-life", 0, 0, 0 },
171: #endif
172: { 0 }
173: };
174:
175: #define xft_insert &x_ftab[0]
176: #define xft_error &x_ftab[1]
177: #define xft_ins_string &x_ftab[2]
178:
179: int
180: x_read(fd, buf, len)
181: int fd; /* not used */
182: char *buf;
183: size_t len;
184: {
185: char c;
186: int i;
187: int (*func)();
188: extern x_insert();
189:
190: (void)set_xmode(TRUE);
191: xbuf = buf; xend = buf + len;
192: xcp = xep = buf;
193: *xcp = 0;
194: x_curprefix = 0;
195: macroptr = null;
196: x_histp = histptr + 1;
197:
198: while (1) {
199: x_flush();
200: if (*macroptr) {
201: c = *macroptr++;
202: if (*macroptr == 0)
203: macroptr = null;
204: } else {
205: i = read(ttyfd, &c, 1);
206: if (i != 1)
207: goto Exit;
208: }
209:
210: if (x_curprefix == -1)
211: func = x_insert;
212: else
213: func = x_tab[x_curprefix][c&CMASK]->xf_func;
214: if (func == NULL)
215: func = x_error;
216: i = c | (x_curprefix << 8);
217: x_curprefix = 0;
218: switch (i = (*func)(i)) {
219: case KSTD:
220: x_last_command = func;
221: case KPREF:
222: break;
223: case KEOL:
224: i = xep - xbuf;
225: x_last_command = 0;
226: /* XXX -- doesn't get them all */
227: if (strncmp(xbuf, "stty", 4) == 0)
228: first_time = 1;
229: goto Exit;
230: case KINTR: /* special case for interrupt */
231: i = -1;
232: errno = EINTR;
233: *xbuf = '\0';
234: goto Exit;
235: }
236: }
237: Exit:
238: (void)set_xmode(FALSE);
239: if (i < 0 && errno == EINTR)
240: trapsig(SIGINT);
241: return i;
242: }
243:
244: static int
245: x_insert(c) {
246: char str[2];
247:
248: /*
249: * Should allow tab and control chars.
250: */
251: if (c == 0) {
252: x_putc(BEL);
253: return KSTD;
254: }
255: str[0] = c;
256: str[1] = 0;
257: x_ins(str);
258: return KSTD;
259: }
260:
261: static int
262: x_ins_string(c)
263: {
264: if (*macroptr) {
265: x_putc(BEL);
266: return KSTD;
267: }
268: macroptr = x_atab[c>>8][c & CMASK];
269: return KSTD;
270: }
271:
272: static void
273: x_ins(cp)
274: char *cp;
275: {
276: int count, i;
277:
278: count = strlen(cp);
279: if (xep+count >= xend) {
280: x_putc(BEL);
281: return;
282: }
283:
284: if (xcp != xep)
285: memmove(xcp+count, xcp, xep - xcp + 1);
286: else
287: xcp[count] = 0;
288: memmove(xcp, cp, count);
289: x_zots(xcp);
290: xcp += count;
291: xep += count;
292: i = xep - xcp;
293: cp = xep;
294: while (i--)
295: x_bs(*--cp);
296: return;
297: }
298:
299: static int
300: x_del_back(c) {
301: if (xcp == xbuf) {
302: x_putc(BEL);
303: return KSTD;
304: }
305: x_goto(xcp - 1);
306: x_delete(1);
307: return KSTD;
308: }
309:
310: static int
311: x_del_char(c) {
312: if (xcp == xep) {
313: x_putc(BEL);
314: return KSTD;
315: }
316: x_delete(1);
317: return KSTD;
318: }
319:
320: static void
321: x_delete(nc) {
322: int i,j;
323: char *cp;
324:
325: if (nc == 0)
326: return;
327: xep -= nc;
328: cp = xcp;
329: j = 0;
330: i = nc;
331: while (i--) {
332: j += x_size(*cp++);
333: }
334: memmove(xcp, xcp+nc, xep - xcp + 1); /* Copies the null */
335: x_zots(xcp);
336: i = j;
337: while (i--)
338: x_putc(' ');
339: i = j;
340: while (i--)
341: x_putc('\b');
342: /*x_goto(xcp);*/
343: i = xep - xcp;
344: cp = xep;
345: while (i--)
346: x_bs(*--cp);
347: return;
348: }
349:
350: static int
351: x_del_bword(c) {
352: x_delete(x_bword());
353: return KSTD;
354: }
355:
356: static int
357: x_mv_bword(c) {
358: (void)x_bword();
359: return KSTD;
360: }
361:
362: static int
363: x_mv_fword(c) {
364: x_goto(xcp + x_fword());
365: return KSTD;
366: }
367:
368: static int
369: x_del_fword(c) {
370: x_delete(x_fword());
371: return KSTD;
372: }
373:
374: static int
375: x_bword() {
376: int nc = 0;
377: register char *cp = xcp;
378:
379: if (cp == xbuf) {
380: x_putc(BEL);
381: return 0;
382: }
383: while (cp != xbuf && isfs(cp[-1])) {
384: cp--;
385: nc++;
386: }
387: while (cp != xbuf && !isfs(cp[-1])) {
388: cp--;
389: nc++;
390: }
391: x_goto(cp);
392: return nc;
393: }
394:
395: static int
396: x_fword() {
397: int nc = 0;
398: char *cp = xcp;
399:
400: if (cp == xep) {
401: x_putc(BEL);
402: return 0;
403: }
404: while (cp != xep && !isfs(*cp)) {
405: cp++;
406: nc++;
407: }
408: while (cp != xep && isfs(*cp)) {
409: cp++;
410: nc++;
411: }
412: return nc;
413: }
414:
415: static void
416: x_goto(cp)
417: register char *cp;
418: {
419: if (cp < xcp) { /* move back */
420: while (cp < xcp)
421: x_bs(*--xcp);
422: } else
423: if (cp > xcp) { /* move forward */
424: while (cp > xcp)
425: x_zotc(*xcp++);
426: }
427: }
428:
429: static void
430: x_bs(c) {
431: register i;
432: i = x_size(c);
433: while (i--)
434: x_putc('\b');
435: }
436:
437: static int
438: x_size_str(cp)
439: register char *cp;
440: {
441: register size = 0;
442: while (*cp)
443: size += x_size(*cp++);
444: return size;
445: }
446:
447: static int
448: x_size(c) {
449: if (c=='\t')
450: return 4; /* Kludge, tabs are always four spaces. */
451: if (c < ' ' || c == 0x7F) /* ASCII control char */
452: return 2;
453: return 1;
454: }
455:
456: static void
457: x_zots(str)
458: register char *str;
459: {
460: while (*str)
461: x_zotc(*str++);
462: }
463:
464: static void
465: x_zotc(c)
466: int c;
467: {
468: if (c == '\t') {
469: /* Kludge, tabs are always four spaces. */
470: x_puts(" ");
471: } else if (c < ' ' || c == 0x7F) { /* ASCII */
472: x_putc('^');
473: x_putc(UNCTRL(c));
474: } else
475: x_putc(c);
476: }
477:
478: /* tty output */
479:
480: void
481: x_flush()
482: {
483: fflush(stdout);
484: }
485:
486: void
487: x_putc(c)
488: int c;
489: {
490: putc(c, stdout);
491: }
492:
493: void
494: x_puts(s)
495: register char *s;
496: {
497: while (*s != 0)
498: putc(*s++, stdout);
499: }
500:
501: static int
502: x_mv_back(c) {
503: if (xcp == xbuf) {
504: x_putc(BEL);
505: return KSTD;
506: }
507: x_goto(xcp-1);
508: return KSTD;
509: }
510:
511: static int
512: x_mv_forw(c) {
513: if (xcp == xep) {
514: x_putc(BEL);
515: return KSTD;
516: }
517: x_goto(xcp+1);
518: return KSTD;
519: }
520:
521: static int
522: x_search_char(c) {
523: char ci, *cp;
524:
525: *xep = '\0';
526: if (read(ttyfd, &ci, 1) != 1 ||
527: /* we search forward, I don't know what Korn does */
528: (cp = (xcp == xep) ? NULL : strchr(xcp+1, ci)) == NULL &&
529: (cp = strchr(xbuf, ci)) == NULL) {
530: x_putc(BEL);
531: return KSTD;
532: }
533: x_goto(cp);
534: return KSTD;
535: }
536:
537: static int
538: x_newline(c) {
539: x_putc('\n');
540: x_flush();
541: *xep++ = '\n';
542: return KEOL;
543: }
544:
545: static int
546: x_end_of_text(c) {
547: #if 0
548: x_store_hist();
549: #endif
550: return KEOL;
551: }
552:
553: static int x_beg_hist(c) {x_load_hist(history); return KSTD;}
554:
555: static int x_end_hist(c) {x_load_hist(histptr); return KSTD;}
556:
557: static int x_prev_com(c) {x_load_hist(x_histp-1); return KSTD;}
558:
559: static int x_next_com(c) {x_load_hist(x_histp+1); return KSTD;}
560:
561: static void
562: x_load_hist(hp)
563: register char **hp;
564: {
565: int oldsize;
566:
567: if (hp < history || hp > histptr) {
568: x_putc(BEL);
569: return;
570: }
571: x_histp = hp;
572: oldsize = x_size_str(xbuf);
573: (void)strcpy(xbuf, *hp);
574: xep = xcp = xbuf + strlen(*hp);
575: x_redraw(oldsize);
576: }
577:
578: static int x_search(), x_match();
579:
580: /* reverse incremental history search */
581: static int
582: x_search_hist(ci)
583: {
584: int offset = -1; /* offset of match in xbuf, else -1 */
585: static char c[2]; /* input buffer */
586: char pat [256+1]; /* pattern buffer */
587: register char *p = pat;
588: int (*func)();
589:
590: *p = 0;
591: while (1) {
592: if (offset < 0) {
593: x_puts("\nI-search: ");
594: x_zots(pat);
595: }
596: x_flush();
597: if (read(ttyfd, c, 1) < 1)
598: return KSTD;
599: func = x_tab[0][*c&CMASK]->xf_func;
600: if (*c == CTRL('['))
601: break;
602: else if (func == x_search_hist)
603: offset = x_search(pat, offset);
604: else if (func == x_del_back)
605: continue; /* todo */
606: else if (func == x_insert) {
607: /* add char to pattern */
608: *p++ = *c, *p = 0;
609: if (offset >= 0) {
610: /* already have partial match */
611: offset = x_match(xbuf, pat);
612: if (offset >= 0) {
613: x_goto(xbuf + offset + (p - pat) - (*pat == '^'));
614: continue;
615: }
616: }
617: offset = x_search(pat, offset);
618: } else { /* other command */
619: macroptr = c; /* push command */
620: break;
621: }
622: }
623: if (offset < 0)
624: x_redraw(-1);
625: return KSTD;
626: }
627:
628: /* search backward from current line */
629: static int
630: x_search(pat, offset)
631: char *pat;
632: int offset;
633: {
634: register char **hp;
635: int i;
636:
637: for (hp = x_histp; --hp >= history; ) {
638: i = x_match(*hp, pat);
639: if (i >= 0) {
640: if (offset < 0)
641: x_putc('\n');
642: x_load_hist(hp);
643: x_goto(xbuf + i + strlen(pat) - (*pat == '^'));
644: return i;
645: }
646: }
647: x_putc(BEL);
648: x_histp = histptr;
649: return -1;
650: }
651:
652: /* return position of first match of pattern in string, else -1 */
653: static int
654: x_match(str, pat)
655: char *str, *pat;
656: {
657: if (*pat == '^') {
658: return (strncmp(str, pat+1, strlen(pat+1)) == 0) ? 0 : -1;
659: } else {
660: char *q = strstr(str, pat);
661: return (q == NULL) ? -1 : q - str;
662: }
663: }
664:
665: static int
666: x_del_line(c) {
667: int i, j;
668:
669: *xep = 0;
670: i = xep- xbuf;
671: j = x_size_str(xbuf);
672: xcp = xbuf;
673: x_push(i);
674: xep = xbuf;
675: *xcp = 0;
676: x_redraw(j);
677: return KSTD;
678: }
679:
680: static int
681: x_mv_end(c) {
682: x_goto(xep);
683: return KSTD;
684: }
685:
686: static int
687: x_mv_begin(c) {
688: x_goto(xbuf);
689: return KSTD;
690: }
691:
692: static int
693: x_draw_line(c)
694: {
695: x_redraw(-1);
696: return KSTD;
697:
698: }
699:
700: static void
701: x_redraw(limit) {
702: int i, j;
703: char *cp;
704:
705: if (limit == -1)
706: x_putc('\n');
707: else
708: x_putc('\r');
709: x_flush();
710: pprompt(prompt);
711: x_zots(xbuf);
712: if (limit != -1) {
713: i = limit - x_size_str(xbuf);
714: j = 0;
715: while (j < i) {
716: x_putc(' ');
717: j++;
718: }
719: while (j--)
720: x_putc('\b');
721: }
722: i = xep - xcp;
723: cp = xep;
724: while (i--)
725: x_bs(*--cp);
726: return;
727: }
728:
729: static int
730: x_transpose(c) {
731: char tmp;
732: if (xcp == xbuf || xcp == xep) {
733: x_putc(BEL);
734: return KSTD;
735: }
736: x_bs(xcp[-1]);
737: x_zotc(xcp[0]);
738: x_zotc(xcp[-1]);
739: tmp = xcp[-1];
740: xcp[-1] = xcp[0];
741: xcp[0] = tmp;
742: x_bs(xcp[0]);
743: return KSTD;
744: }
745:
746: static int
747: x_literal(c) {
748: x_curprefix = -1;
749: return KSTD;
750: }
751:
752: static int
753: x_meta1(c) {
754: x_curprefix = 1;
755: return KPREF;
756: }
757:
758: static int
759: x_meta2(c) {
760: x_curprefix = 2;
761: return KPREF;
762: }
763:
764: static int
765: x_kill(c) {
766: int i;
767:
768: i = xep - xcp;
769: x_push(i);
770: x_delete(i);
771: return KSTD;
772: }
773:
774: static void
775: x_push(nchars) {
776: char *cp;
777: cp = alloc((size_t)(nchars+1), AEDIT);
778: memmove(cp, xcp, nchars);
779: cp[nchars] = 0;
780: if (killstack[killsp])
781: afree((Void *)killstack[killsp], AEDIT);
782: killstack[killsp] = cp;
783: killsp = (killsp + 1) % KILLSIZE;
784: }
785:
786: static int
787: x_yank(c) {
788: if (killsp == 0)
789: killtp = KILLSIZE;
790: else
791: killtp = killsp;
792: killtp --;
793: if (killstack[killtp] == 0) {
794: x_puts("\nnothing to yank");
795: x_redraw(-1);
796: return KSTD;
797: }
798: x_ins(killstack[killtp]);
799: return KSTD;
800: }
801:
802: static int
803: x_meta_yank(c) {
804: int len;
805: if (x_last_command != x_yank && x_last_command != x_meta_yank) {
806: x_puts("\nyank something first");
807: x_redraw(-1);
808: return KSTD;
809: }
810: len = strlen(killstack[killtp]);
811: x_goto(xcp - len);
812: x_delete(len);
813: do {
814: if (killtp == 0)
815: killtp = KILLSIZE - 1;
816: else
817: killtp--;
818: } while (killstack[killtp] == 0);
819: x_ins(killstack[killtp]);
820: return KSTD;
821: }
822:
823: static int
824: x_abort(c) {
825: /* x_zotc(c); */
826: return KINTR;
827: }
828:
829: static int
830: x_error(c) {
831: x_putc(BEL);
832: return KSTD;
833: }
834:
835: #if _BSD
836: #if defined TIOCGATC
837: static struct ttychars lchars, lcharsorig;
838: #else
839: static struct tchars tchars, tcharsorig;
840: static struct ltchars ltchars, ltcharsorig;
841: #endif
842: #endif
843:
844: #if _BSD || (COHERENT && !MWC_HP)
845: bool_t
846: set_xmode(onoff)
847: bool_t onoff;
848: {
849: bool_t prev;
850: typedef struct sgttyb Sgttyb;
851: static Sgttyb cb;
852: static Sgttyb orig;
853:
854: if (x_mode == onoff) return x_mode;
855: prev = x_mode;
856: x_mode = onoff;
857: if (onoff) {
858: if (first_time) {
859: (void)ioctl(0, TIOCGETP, &cb);
860: orig = cb;
861: cb.sg_flags &= ~ECHO;
862: cb.sg_flags |= CBREAK;
863: #if defined TIOCGATC
864: (void)ioctl(0, TIOCGATC, &lcharsorig);
865: lchars = lcharsorig;
866: lchars.tc_suspc = -1;
867: lchars.tc_dsuspc = -1;
868: lchars.tc_lnextc = -1;
869: lchars.tc_statc = -1;
870: lchars.tc_intrc = -1;
871: lchars.tc_quitc = -1;
872: lchars.tc_rprntc = -1;
873: #else
874: #if !COHERENT
875: (void)ioctl(0, TIOCGETC, &tcharsorig);
876: (void)ioctl(0, TIOCGLTC, <charsorig);
877: tchars = tcharsorig;
878: ltchars = ltcharsorig;
879: ltchars.t_suspc = -1;
880: ltchars.t_dsuspc = -1;
881: ltchars.t_lnextc = -1;
882: tchars.t_intrc = -1;
883: tchars.t_quitc = -1;
884: ltchars.t_rprntc = -1;
885: #endif
886: #endif
887: first_time = 0;
888: }
889: (void)ioctl(0, TIOCSETN, &cb);
890: #if defined TIOCGATC
891: (void)ioctl(0, TIOCSATC, &lchars);
892: #else
893: #if !COHERENT
894: (void)ioctl(0, TIOCSETC, &tchars);
895: (void)ioctl(0, TIOCSLTC, <chars);
896: #endif
897: #endif
898: }
899: else {
900: (void)ioctl(0, TIOCSETN, &orig);
901: #if defined TIOCGATC
902: (void)ioctl(0, TIOCSATC, &lcharsorig);
903: #else
904: #if !COHERENT
905: (void)ioctl(0, TIOCSETC, &tcharsorig);
906: (void)ioctl(0, TIOCSLTC, <charsorig);
907: #endif
908: #endif
909: }
910: return prev;
911: }
912:
913: #else /* !_BSD */
914:
915: bool_t
916: set_xmode(onoff)
917: bool_t onoff;
918: {
919: bool_t prev;
920: static struct termio cb, orig;
921:
922: if (x_mode == onoff) return x_mode;
923: prev = x_mode;
924: x_mode = onoff;
925:
926: if (onoff) {
927: if (first_time) {
928: (void)ioctl(0, TCGETA, &cb);
929: orig = cb;
930: #if defined _CRAY2 /* brain-damaged terminal handler */
931: cb.c_lflag &= ~(ICANON|ECHO);
932: /* rely on print routine to map '\n' to CR,LF */
933: #else
934: cb.c_iflag &= ~(INLCR|ICRNL);
935: #if _BSD_SYSV /* need to force CBREAK instead of RAW (need CRMOD on output) */
936: cb.c_lflag &= ~(ICANON|ECHO);
937: #else
938: cb.c_lflag &= ~(ISIG|ICANON|ECHO);
939: #endif
940: cb.c_cc[VTIME] = 0;
941: cb.c_cc[VMIN] = 1;
942: #endif /* _CRAY2 */
943: first_time = 0;
944: }
945: #if ! defined TCSETAW /* e.g. Cray-2 */
946: /* first wait for output to drain */
947: #if defined TCSBRK
948: (void)ioctl(0, TCSBRK, 1);
949: #else /* the following kludge is minimally intrusive, but sometimes fails */
950: (void)sleep((unsigned)1); /* fake it */
951: #endif
952: #endif
953: #if _BSD_SYSV || !defined(TCSETAW)
954: /* _BSD_SYSV needs to force TIOCSETN instead of TIOCSETP (preserve type-ahead) */
955: (void)ioctl(0, TCSETA, &cb);
956: #else
957: (void)ioctl(0, TCSETAW, &cb);
958: #endif
959: }
960: else {
961: #if ! defined TCSETAW /* e.g. Cray-2 */
962: /* first wait for output to drain */
963: #if defined TCSBRK
964: (void)ioctl(0, TCSBRK, 1);
965: #else
966: /* doesn't seem to be necessary when leaving xmode */
967: /* (void)sleep((unsigned)1); */
968: #endif
969: #endif
970: #if _BSD_SYSV || !defined(TCSETAW)
971: /* _BSD_SYSV needs to force TIOCSETN instead of TIOCSETP (preserve type-ahead) */
972: (void)ioctl(0, TCSETA, &orig);
973: #else
974: (void)ioctl(0, TCSETAW, &orig);
975: #endif
976: }
977: return prev;
978: }
979: #endif /* _BSD */
980:
981: static int
982: x_stuffreset(c)
983: {
984: #if defined TIOCSTI
985: (void)x_stuff(c);
986: return KINTR;
987: #else
988: x_zotc(c);
989: xcp = xep = xbuf;
990: *xcp = 0;
991: x_redraw(-1);
992: return KSTD;
993: #endif
994: }
995:
996: static int
997: x_stuff(c)
998: {
999: #if defined TIOCSTI
1000: char ch = c;
1001: bool_t savmode = set_xmode(FALSE);
1002:
1003: (void)ioctl(0, TIOCSTI, &ch);
1004: (void)set_xmode(savmode);
1005: x_redraw(-1);
1006: #endif
1007: return KSTD;
1008: }
1009:
1010: static void
1011: x_mapin(cp)
1012: char *cp;
1013: {
1014: char *op;
1015:
1016: op = cp;
1017: while (*cp) {
1018: /* XXX -- should handle \^ escape? */
1019: if (*cp == '^') {
1020: cp++;
1021: if (*cp >= '?') /* includes '?'; ASCII */
1022: *op++ = CTRL(*cp);
1023: else {
1024: *op++ = '^';
1025: cp--;
1026: }
1027: } else
1028: *op++ = *cp;
1029: cp++;
1030: }
1031: *op = 0;
1032: }
1033:
1034: static char *
1035: x_mapout(c)
1036: int c;
1037: {
1038: static char buf[8];
1039: register char *p = buf;
1040:
1041: if (c < ' ' || c == 0x7F) { /* ASCII */
1042: *p++ = '^';
1043: *p++ = (c == 0x7F) ? '?' : (c | 0x40);
1044: } else
1045: *p++ = c;
1046: *p = 0;
1047: return buf;
1048: }
1049:
1050: static void
1051: x_print(prefix, key)
1052: int prefix, key;
1053: {
1054: if (prefix == 1)
1055: shellf("%s", x_mapout(x_prefix1));
1056: if (prefix == 2)
1057: shellf("%s", x_mapout(x_prefix2));
1058: shellf("%s = ", x_mapout(key));
1059: if (x_tab[prefix][key]->xf_func != x_ins_string)
1060: shellf("%s\n", x_tab[prefix][key]->xf_name);
1061: else
1062: shellf("'%s'\n", x_atab[prefix][key]);
1063: }
1064:
1065: void
1066: x_bind(a1, a2, macro)
1067: char *a1, *a2;
1068: int macro; /* bind -m */
1069: {
1070: struct x_ftab Const *fp;
1071: int prefix, key;
1072: char *sp = NULL;
1073:
1074: if (x_tab == NULL)
1075: errorf("cannot bind, not a tty\n");
1076:
1077: if (a1 == NULL) {
1078: for (prefix = 0; prefix < 3; prefix++)
1079: for (key = 0; key < 0x80; key++) {
1080: fp = x_tab[prefix][key];
1081: if (fp == NULL ||
1082: fp->xf_func == x_insert || fp->xf_func == x_error)
1083: continue;
1084: x_print(prefix, key);
1085: }
1086: return;
1087: }
1088:
1089: x_mapin(a1);
1090: prefix = key = 0;
1091: for (;; a1++) {
1092: key = *a1;
1093: if (x_tab[prefix][key]->xf_func == x_meta1)
1094: prefix = 1;
1095: else
1096: if (x_tab[prefix][key]->xf_func == x_meta2)
1097: prefix = 2;
1098: else
1099: break;
1100: }
1101:
1102: if (a2 == NULL) {
1103: x_print(prefix, key);
1104: return;
1105: }
1106:
1107: if (*a2 == 0)
1108: fp = xft_insert;
1109: else if (!macro) {
1110: for (fp = x_ftab; fp->xf_func; fp++)
1111: if (strcmp(fp->xf_name, a2) == 0)
1112: break;
1113: if (fp->xf_func == NULL || (fp->xf_flags & XF_NOBIND))
1114: errorf("%s: no such function\n", a2);
1115: if (fp->xf_func == x_meta1)
1116: x_prefix1 = key;
1117: if (fp->xf_func == x_meta2)
1118: x_prefix2 = key;
1119: } else {
1120: fp = xft_ins_string;
1121: x_mapin(a2);
1122: sp = strsave(a2, AEDIT);
1123: }
1124:
1125: if ((x_tab[prefix][key]->xf_flags & XF_ALLOC) && x_atab[prefix][key])
1126: afree((Void *)x_atab[prefix][key], AEDIT);
1127: x_tab[prefix][key] = fp;
1128: x_atab[prefix][key] = sp;
1129: }
1130:
1131: void
1132: x_init()
1133: {
1134: register int i, j;
1135: struct x_ftab Const *fp;
1136:
1137: ainit(AEDIT);
1138:
1139: x_tab = alloc(sizeofN(*x_tab, 3), AEDIT);
1140: for (j = 0; j < 128; j++)
1141: x_tab[0][j] = xft_insert;
1142: for (i = 1; i < 3; i++)
1143: for (j = 0; j < 128; j++)
1144: x_tab[i][j] = xft_error;
1145: for (fp = x_ftab; fp->xf_func; fp++)
1146: if (fp->xf_db_char || fp->xf_db_tab)
1147: x_tab[fp->xf_db_tab][fp->xf_db_char] = fp;
1148:
1149: x_atab = alloc(sizeofN(*x_atab, 3), AEDIT);
1150: for (i = 1; i < 3; i++)
1151: for (j = 0; j < 128; j++)
1152: x_atab[i][j] = NULL;
1153: }
1154:
1155: #if SILLY
1156: static int
1157: x_game_of_life(c) {
1158: char newbuf [256+1];
1159: register char *ip, *op;
1160: int i, len;
1161:
1162: i = xep - xbuf;
1163: *xep = 0;
1164: len = x_size_str(xbuf);
1165: xcp = xbuf;
1166: memmove(newbuf+1, xbuf, i);
1167: newbuf[0] = 'A';
1168: newbuf[i] = 'A';
1169: for (ip = newbuf+1, op = xbuf; --i >= 0; ip++, op++) {
1170: /* Empty space */
1171: if (*ip < '@' || *ip == '_' || *ip == 0x7F) {
1172: /* Two adults, make whoopee */
1173: if (ip[-1] < '_' && ip[1] < '_') {
1174: /* Make kid look like parents. */
1175: *op = '`' + ((ip[-1] + ip[1])/2)%32;
1176: if (*op == 0x7F) /* Birth defect */
1177: *op = '`';
1178: }
1179: else
1180: *op = ' '; /* nothing happens */
1181: continue;
1182: }
1183: /* Child */
1184: if (*ip > '`') {
1185: /* All alone, dies */
1186: if (ip[-1] == ' ' && ip[1] == ' ')
1187: *op = ' ';
1188: else /* Gets older */
1189: *op = *ip-'`'+'@';
1190: continue;
1191: }
1192: /* Adult */
1193: /* Overcrowded, dies */
1194: if (ip[-1] >= '@' && ip[1] >= '@') {
1195: *op = ' ';
1196: continue;
1197: }
1198: *op = *ip;
1199: }
1200: *op = 0;
1201: x_redraw(len);
1202: return KSTD;
1203: }
1204: #endif
1205:
1206: /*
1207: * File/command name completion routines
1208: */
1209:
1210: /* type: 0 for list, 1 for completion */
1211:
1212: static XPtrV words;
1213:
1214: static void
1215: add_stash(dirnam, name)
1216: char *dirnam; /* directory name, if file */
1217: char *name;
1218: {
1219: char *cp;
1220: register int type = 0; /* '*' if executable, '/' if directory, else 0 */
1221: register int len = strlen(name);
1222:
1223: /* determine file type */
1224: if (dirnam) {
1225: struct stat statb;
1226: char *buf = alloc((size_t)(strlen(dirnam)+len+2), ATEMP);
1227:
1228: if (strcmp(dirnam, ".") == 0)
1229: *buf = '\0';
1230: else if (strcmp(dirnam, "/") == 0)
1231: (void)strcpy(buf, "/");
1232: else
1233: (void)strcat(strcpy(buf, dirnam), "/");
1234: (void)strcat(buf, name);
1235: if (stat(buf, &statb)==0)
1236: if (S_ISDIR(statb.st_mode))
1237: type = '/';
1238: else if (S_ISREG(statb.st_mode) && eaccess(buf, 01)==0)
1239: type = '*';
1240: if (type)
1241: ++len;
1242: afree((Void *)buf, ATEMP);
1243: }
1244:
1245: if (len > x_maxlen)
1246: x_maxlen = len;
1247:
1248: /* stash name for later sorting */
1249: cp = alloc((size_t)(len+1), ATEMP);
1250: (void)strcpy(cp = alloc((size_t)(len+1), ATEMP), name);
1251: if (dirnam && type) { /* append file type indicator */
1252: cp[len-1] = type;
1253: cp[len] = '\0';
1254: }
1255: XPput(words, cp);
1256: }
1257:
1258: static void
1259: list_stash()
1260: {
1261: register char **array, **record;
1262: int items = 0, tabstop, loc, nrows, jump, offset;
1263:
1264: items = XPsize(words);
1265: array = (char**) XPptrv(words);
1266: if (items == 0)
1267: return;
1268: qsortp(XPptrv(words), (size_t)XPsize(words), xstrcmp);
1269:
1270: /* print names */
1271: x_maxlen = (x_maxlen/8 + 1) * 8; /* column width */
1272: nrows = (items-1) / (x_cols/x_maxlen) + 1;
1273: for (offset = 0; offset < nrows; ++offset) {
1274: tabstop = loc = 0;
1275: x_putc('\n');
1276: for (jump = 0; offset+jump < items; jump += nrows) {
1277: if (jump)
1278: while (loc < tabstop) {
1279: x_putc('\t');
1280: loc = (loc/8 + 1) * 8;
1281: }
1282: record = array + (offset + jump);
1283: x_puts(*record);
1284: afree((Void *)*record, ATEMP);
1285: loc += strlen(*record);
1286: tabstop += x_maxlen; /* next tab stop */
1287: }
1288: }
1289:
1290: afree((Void*)array, ATEMP);
1291: x_redraw(-1);
1292: }
1293:
1294: static int
1295: x_comp_comm(c) {
1296: compl_command(1);
1297: return KSTD;
1298: }
1299: static int
1300: x_list_comm(c) {
1301: compl_command(0);
1302: return KSTD;
1303: }
1304: static int
1305: x_complete(c) {
1306: compl_dec(1);
1307: return KSTD;
1308: }
1309: static int
1310: x_enumerate(c) {
1311: compl_dec(0);
1312: return KSTD;
1313: }
1314: static int
1315: x_comp_file(c) {
1316: compl_file(1);
1317: return KSTD;
1318: }
1319: static int
1320: x_list_file(c) {
1321: compl_file(0);
1322: return KSTD;
1323: }
1324:
1325: static void
1326: compl_dec(type)
1327: {
1328: char *cp;
1329: cp = xcp;
1330:
1331: while (cp != xbuf && !isfs(*cp))
1332: cp--;
1333: if (cp == xbuf && strchr(cp, '/') == NULL)
1334: compl_command(type);
1335: else
1336: compl_file(type);
1337: }
1338:
1339: static void
1340: compl_file(type)
1341: {
1342: char *str;
1343: register char *cp, *xp;
1344: char *lastp;
1345: char *dirnam;
1346: char buf [256+1];
1347: char bug [256+1];
1348: DIR *dirp;
1349: struct dirent *dp;
1350: long loc = -1;
1351: int len;
1352: int multi = 0;
1353:
1354: str = xcp;
1355: cp = buf;
1356: xp = str;
1357: while (xp != xbuf) {
1358: --xp;
1359: if (isfs(*xp)) {
1360: xp++;
1361: break;
1362: }
1363: }
1364: if (digit(*xp) && (xp[1] == '<' || xp[1] == '>'))
1365: xp++;
1366: while (*xp == '<' || *xp == '>')
1367: xp++;
1368: if (type)
1369: while (*xcp && !isfs(*xcp))
1370: x_zotc(*xcp++);
1371: else {
1372: x_maxlen = 0;
1373: XPinit(words, 16);
1374: }
1375: while (*xp && !isfs(*xp))
1376: *cp++ = *xp++;
1377:
1378: *cp = 0;
1379: strcpy(buf, cp = substitute(buf, DOTILDE));
1380: afree((Void*)cp, ATEMP);
1381: lastp = strrchr(buf, '/');
1382: if (lastp)
1383: *lastp = 0;
1384:
1385: dirnam = (lastp == NULL) ? "." : (lastp == buf) ? "/" : buf;
1386: dirp = opendir(dirnam);
1387: if (dirp == NULL) {
1388: x_putc(BEL);
1389: return;
1390: }
1391:
1392: if (lastp == NULL)
1393: lastp = buf;
1394: else
1395: lastp++;
1396: len = strlen(lastp);
1397:
1398: while ((dp = readdir(dirp)) != NULL) {
1399: cp = dp->d_name;
1400: if (cp[0] == '.' &&
1401: (cp[1] == '\0' || cp[1] == '.' && cp[2] == '\0'))
1402: continue; /* always ignore . and .. */
1403: if (strncmp(lastp, cp, len) == 0)
1404: if (type) {
1405: if (loc == -1) {
1406: (void)strcpy(bug, cp);
1407: loc = strlen(cp);
1408: } else {
1409: multi = 1;
1410: loc = strmatch(bug, cp);
1411: bug[loc] = 0;
1412: }
1413: } else
1414: add_stash(dirnam, cp);
1415: }
1416: (void)closedir(dirp);
1417:
1418: if (type) {
1419: if (loc <= 0) {
1420: x_putc(BEL);
1421: return;
1422: }
1423: cp = bug + len;
1424: x_ins(cp);
1425: if (!multi) {
1426: struct stat statb;
1427: if (lastp == buf)
1428: buf[0] = 0;
1429: else if (lastp == buf + 1) {
1430: buf[1] = 0;
1431: buf[0] = '/';
1432: } else
1433: (void)strcat(buf, "/");
1434: (void)strcat(buf, bug);
1435: if (stat(buf, &statb) == 0 && S_ISDIR(statb.st_mode))
1436: x_ins("/");
1437: else
1438: x_ins(" ");
1439: }
1440: } else
1441: list_stash();
1442: }
1443:
1444: static void
1445: compl_command(type)
1446: {
1447: register struct tbl *tp;
1448: char *str;
1449: char buf [256+1];
1450: char bug [256+1];
1451: char *xp;
1452: char *cp;
1453: int len;
1454: int multi;
1455: int loc;
1456:
1457: str = xcp;
1458: cp = buf;
1459: xp = str;
1460: while (xp != xbuf) {
1461: --xp;
1462: if (isfs(*xp)) {
1463: xp++;
1464: break;
1465: }
1466: }
1467: if (type)
1468: while (*xcp && !isfs(*xcp))
1469: x_zotc(*xcp++);
1470: else {
1471: x_maxlen = 0;
1472: XPinit(words, 16);
1473: }
1474: while (*xp && !isfs(*xp))
1475: *cp++ = *xp++;
1476: *cp = 0;
1477:
1478: len = strlen(buf);
1479: loc = -1;
1480: multi = 0;
1481:
1482: for (twalk(&commands); (tp = tnext()) != NULL; ) {
1483: int klen;
1484:
1485: if (!(tp->flag&ISSET))
1486: continue;
1487: klen = strlen(tp->name);
1488: if (klen < len)
1489: return;
1490: if (strncmp(buf, tp->name, len) ==0)
1491: if (type) {
1492: if (loc == -1) {
1493: (void)strcpy(bug, tp->name);
1494: loc = klen;
1495: } else {
1496: multi = 1;
1497: loc = strmatch(bug, tp->name);
1498: bug[loc] = 0;
1499: }
1500: } else
1501: add_stash((char *)0, tp->name);
1502: }
1503:
1504: if (type) {
1505: if (loc <= 0) {
1506: x_putc(BEL);
1507: return;
1508: }
1509: cp = bug + len;
1510: x_ins(cp);
1511: if (!multi)
1512: x_ins(" ");
1513: } else
1514: list_stash();
1515: }
1516:
1517: static int
1518: strmatch(s1, s2)
1519: register char *s1, *s2;
1520: {
1521: register char *p;
1522:
1523: for (p = s1; *p == *s2++ && *p != 0; p++)
1524: ;
1525: return p - s1;
1526: }
1527:
1528: #endif /* EDIT */
1529:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.