xref: /freebsd/sys/ddb/db_input.c (revision 6be3386466ab79a84b48429ae66244f21526d3df)
1 /*-
2  * SPDX-License-Identifier: MIT-CMU
3  *
4  * Mach Operating System
5  * Copyright (c) 1991,1990 Carnegie Mellon University
6  * All Rights Reserved.
7  *
8  * Permission to use, copy, modify and distribute this software and its
9  * documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie the
26  * rights to redistribute these changes.
27  */
28 /*
29  *	Author: David B. Golub, Carnegie Mellon University
30  *	Date:	7/90
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/cons.h>
39 #include <sys/sysctl.h>
40 
41 #include <ddb/ddb.h>
42 #include <ddb/db_output.h>
43 
44 /*
45  * Character input and editing.
46  */
47 
48 /*
49  * We don't track output position while editing input,
50  * since input always ends with a new-line.  We just
51  * reset the line position at the end.
52  */
53 static char *	db_lbuf_start;	/* start of input line buffer */
54 static char *	db_lbuf_end;	/* end of input line buffer */
55 static char *	db_lc;		/* current character */
56 static char *	db_le;		/* one past last character */
57 
58 /*
59  * Raw input buffer, processed only for certain control characters.
60  */
61 #define	DB_RAW_SIZE	512
62 static char	db_raw[DB_RAW_SIZE];
63 static u_int	db_raw_pos;
64 static u_int	db_raw_cnt;
65 static int	db_raw_warned;
66 static int	ddb_prioritize_control_input = 1;
67 SYSCTL_INT(_debug_ddb, OID_AUTO, prioritize_control_input, CTLFLAG_RWTUN,
68     &ddb_prioritize_control_input, 0,
69     "Drop input when the buffer fills in order to keep servicing ^C/^S/^Q");
70 
71 /*
72  * Simple input line history support.
73  */
74 static char	db_lhistory[2048];
75 static int	db_lhistlsize, db_lhistidx, db_lhistcur;
76 static int	db_lhist_nlines;
77 
78 #define	CTRL(c)		((c) & 0x1f)
79 #define	BLANK		' '
80 #define	BACKUP		'\b'
81 
82 static void	db_delete(int n, int bwd);
83 static int	db_inputchar(int c);
84 static void	db_putnchars(int c, int count);
85 static void	db_putstring(char *s, int count);
86 static int	db_raw_pop(void);
87 static void	db_raw_push(int);
88 static int	db_raw_space(void);
89 
90 static void
91 db_putstring(s, count)
92 	char	*s;
93 	int	count;
94 {
95 	while (--count >= 0)
96 	    cnputc(*s++);
97 }
98 
99 static void
100 db_putnchars(c, count)
101 	int	c;
102 	int	count;
103 {
104 	while (--count >= 0)
105 	    cnputc(c);
106 }
107 
108 /*
109  * Delete N characters, forward or backward
110  */
111 #define	DEL_FWD		0
112 #define	DEL_BWD		1
113 static void
114 db_delete(n, bwd)
115 	int	n;
116 	int	bwd;
117 {
118 	char *p;
119 
120 	if (bwd) {
121 	    db_lc -= n;
122 	    db_putnchars(BACKUP, n);
123 	}
124 	for (p = db_lc; p < db_le-n; p++) {
125 	    *p = *(p+n);
126 	    cnputc(*p);
127 	}
128 	db_putnchars(BLANK, n);
129 	db_putnchars(BACKUP, db_le - db_lc);
130 	db_le -= n;
131 }
132 
133 /* returns true at end-of-line */
134 static int
135 db_inputchar(c)
136 	int	c;
137 {
138 	static int escstate;
139 
140 	if (escstate == 1) {
141 		/* ESC seen, look for [ or O */
142 		if (c == '[' || c == 'O')
143 			escstate++;
144 		else
145 			escstate = 0; /* re-init state machine */
146 		return (0);
147 	} else if (escstate == 2) {
148 		escstate = 0;
149 		/*
150 		 * If a valid cursor key has been found, translate
151 		 * into an emacs-style control key, and fall through.
152 		 * Otherwise, drop off.
153 		 */
154 		switch (c) {
155 		case 'A':	/* up */
156 			c = CTRL('p');
157 			break;
158 		case 'B':	/* down */
159 			c = CTRL('n');
160 			break;
161 		case 'C':	/* right */
162 			c = CTRL('f');
163 			break;
164 		case 'D':	/* left */
165 			c = CTRL('b');
166 			break;
167 		default:
168 			return (0);
169 		}
170 	}
171 
172 	switch (c) {
173 	    case CTRL('['):
174 		escstate = 1;
175 		break;
176 	    case CTRL('b'):
177 		/* back up one character */
178 		if (db_lc > db_lbuf_start) {
179 		    cnputc(BACKUP);
180 		    db_lc--;
181 		}
182 		break;
183 	    case CTRL('f'):
184 		/* forward one character */
185 		if (db_lc < db_le) {
186 		    cnputc(*db_lc);
187 		    db_lc++;
188 		}
189 		break;
190 	    case CTRL('a'):
191 		/* beginning of line */
192 		while (db_lc > db_lbuf_start) {
193 		    cnputc(BACKUP);
194 		    db_lc--;
195 		}
196 		break;
197 	    case CTRL('e'):
198 		/* end of line */
199 		while (db_lc < db_le) {
200 		    cnputc(*db_lc);
201 		    db_lc++;
202 		}
203 		break;
204 	    case CTRL('h'):
205 	    case 0177:
206 		/* erase previous character */
207 		if (db_lc > db_lbuf_start)
208 		    db_delete(1, DEL_BWD);
209 		break;
210 	    case CTRL('d'):
211 		/* erase next character */
212 		if (db_lc < db_le)
213 		    db_delete(1, DEL_FWD);
214 		break;
215 	    case CTRL('u'):
216 	    case CTRL('c'):
217 		/* kill entire line: */
218 		/* at first, delete to beginning of line */
219 		if (db_lc > db_lbuf_start)
220 		    db_delete(db_lc - db_lbuf_start, DEL_BWD);
221 		/* FALLTHROUGH */
222 	    case CTRL('k'):
223 		/* delete to end of line */
224 		if (db_lc < db_le)
225 		    db_delete(db_le - db_lc, DEL_FWD);
226 		break;
227 	    case CTRL('t'):
228 		/* twiddle last 2 characters */
229 		if (db_lc >= db_lbuf_start + 2) {
230 		    c = db_lc[-2];
231 		    db_lc[-2] = db_lc[-1];
232 		    db_lc[-1] = c;
233 		    cnputc(BACKUP);
234 		    cnputc(BACKUP);
235 		    cnputc(db_lc[-2]);
236 		    cnputc(db_lc[-1]);
237 		}
238 		break;
239 	    case CTRL('w'):
240 		/* erase previous word */
241 		for (; db_lc > db_lbuf_start;) {
242 		    if (*(db_lc - 1) != ' ')
243 			break;
244 		    db_delete(1, DEL_BWD);
245 		}
246 		for (; db_lc > db_lbuf_start;) {
247 		    if (*(db_lc - 1) == ' ')
248 			break;
249 		    db_delete(1, DEL_BWD);
250 		}
251 		break;
252 	    case CTRL('r'):
253 		db_putstring("^R\n", 3);
254 	    redraw:
255 		if (db_le > db_lbuf_start) {
256 		    db_putstring(db_lbuf_start, db_le - db_lbuf_start);
257 		    db_putnchars(BACKUP, db_le - db_lc);
258 		}
259 		break;
260 	    case CTRL('p'):
261 		/* Make previous history line the active one. */
262 		if (db_lhistcur >= 0) {
263 		    bcopy(db_lhistory + db_lhistcur * db_lhistlsize,
264 			  db_lbuf_start, db_lhistlsize);
265 		    db_lhistcur--;
266 		    goto hist_redraw;
267 		}
268 		break;
269 	    case CTRL('n'):
270 		/* Make next history line the active one. */
271 		if (db_lhistcur < db_lhistidx - 1) {
272 		    db_lhistcur += 2;
273 		    bcopy(db_lhistory + db_lhistcur * db_lhistlsize,
274 			  db_lbuf_start, db_lhistlsize);
275 		} else {
276 		    /*
277 		     * ^N through tail of history, reset the
278 		     * buffer to zero length.
279 		     */
280 		    *db_lbuf_start = '\0';
281 		    db_lhistcur = db_lhistidx;
282 		}
283 
284 	    hist_redraw:
285 		db_putnchars(BACKUP, db_lc - db_lbuf_start);
286 		db_putnchars(BLANK, db_le - db_lbuf_start);
287 		db_putnchars(BACKUP, db_le - db_lbuf_start);
288 		db_le = strchr(db_lbuf_start, '\0');
289 		if (db_le[-1] == '\r' || db_le[-1] == '\n')
290 		    *--db_le = '\0';
291 		db_lc = db_le;
292 		goto redraw;
293 
294 	    case -1:
295 		/*
296 		 * eek! the console returned eof.
297 		 * probably that means we HAVE no console.. we should try bail
298 		 * XXX
299 		 */
300 		c = '\r';
301 	    case '\n':
302 		/* FALLTHROUGH */
303 	    case '\r':
304 		*db_le++ = c;
305 		return (1);
306 	    default:
307 		if (db_le == db_lbuf_end) {
308 		    cnputc('\007');
309 		}
310 		else if (c >= ' ' && c <= '~') {
311 		    char *p;
312 
313 		    for (p = db_le; p > db_lc; p--)
314 			*p = *(p-1);
315 		    *db_lc++ = c;
316 		    db_le++;
317 		    cnputc(c);
318 		    db_putstring(db_lc, db_le - db_lc);
319 		    db_putnchars(BACKUP, db_le - db_lc);
320 		}
321 		break;
322 	}
323 	return (0);
324 }
325 
326 /* Get a character from the console, first checking the raw input buffer. */
327 int
328 db_getc(void)
329 {
330 	int c;
331 
332 	if (db_raw_cnt == 0) {
333 		c = cngetc();
334 	} else {
335 		c = db_raw_pop();
336 		if (c == '\r')
337 			c = '\n';
338 	}
339 	return (c);
340 }
341 
342 /* Whether the raw input buffer has space to accept another character. */
343 static int
344 db_raw_space(void)
345 {
346 
347 	return (db_raw_cnt < DB_RAW_SIZE);
348 }
349 
350 /* Un-get a character from the console by buffering it. */
351 static void
352 db_raw_push(int c)
353 {
354 
355 	if (!db_raw_space())
356 		db_error(NULL);
357 	db_raw[(db_raw_pos + db_raw_cnt++) % DB_RAW_SIZE] = c;
358 }
359 
360 /* Drain a character from the raw input buffer. */
361 static int
362 db_raw_pop(void)
363 {
364 
365 	if (db_raw_cnt == 0)
366 		return (-1);
367 	db_raw_cnt--;
368 	db_raw_warned = 0;
369 	return (db_raw[db_raw_pos++ % DB_RAW_SIZE]);
370 }
371 
372 int
373 db_readline(lstart, lsize)
374 	char *	lstart;
375 	int	lsize;
376 {
377 
378 	if (lsize < 2)
379 		return (0);
380 	if (lsize != db_lhistlsize) {
381 		/*
382 		 * (Re)initialize input line history.  Throw away any
383 		 * existing history.
384 		 */
385 		db_lhist_nlines = sizeof(db_lhistory) / lsize;
386 		db_lhistlsize = lsize;
387 		db_lhistidx = -1;
388 	}
389 	db_lhistcur = db_lhistidx;
390 
391 	db_force_whitespace();	/* synch output position */
392 
393 	db_lbuf_start = lstart;
394 	db_lbuf_end   = lstart + lsize - 2;	/* Will append NL and NUL. */
395 	db_lc = lstart;
396 	db_le = lstart;
397 
398 	while (!db_inputchar(db_getc()))
399 	    continue;
400 
401 	db_capture_write(lstart, db_le - db_lbuf_start);
402 	db_printf("\n");	/* synch output position */
403 	*db_le = 0;
404 
405 	if (db_le - db_lbuf_start > 1) {
406 	    /* Maintain input line history for non-empty lines. */
407 	    if (++db_lhistidx == db_lhist_nlines) {
408 		/* Rotate history. */
409 		bcopy(db_lhistory + db_lhistlsize, db_lhistory,
410 		      db_lhistlsize * (db_lhist_nlines - 1));
411 		db_lhistidx--;
412 	    }
413 	    bcopy(lstart, db_lhistory + db_lhistidx * db_lhistlsize,
414 		  db_lhistlsize);
415 	}
416 
417 	return (db_le - db_lbuf_start);
418 }
419 
420 static void
421 db_do_interrupt(const char *reason)
422 {
423 
424 	/* Do a pager quit too because some commands have jmpbuf handling. */
425 	db_disable_pager();
426 	db_pager_quit = 1;
427 	db_error(reason);
428 }
429 
430 void
431 db_check_interrupt(void)
432 {
433 	int	c;
434 
435 	/*
436 	 * Check console input for control characters.  Non-control input is
437 	 * buffered.  When buffer space is exhausted, either stop responding to
438 	 * control input or drop further non-control input on the floor.
439 	 */
440 	for (;;) {
441 		if (!ddb_prioritize_control_input && !db_raw_space())
442 			return;
443 		c = cncheckc();
444 		switch (c) {
445 		case -1:		/* no character */
446 			return;
447 
448 		case CTRL('c'):
449 			db_do_interrupt("^C");
450 			/*NOTREACHED*/
451 
452 		case CTRL('s'):
453 			do {
454 				c = cncheckc();
455 				if (c == CTRL('c'))
456 					db_do_interrupt("^C");
457 			} while (c != CTRL('q'));
458 			break;
459 
460 		default:
461 			if (db_raw_space()) {
462 				db_raw_push(c);
463 			} else if (!db_raw_warned) {
464 				db_raw_warned = 1;
465 				db_printf("\n--Exceeded input buffer--\n");
466 			}
467 			break;
468 		}
469 	}
470 }
471