[J-u-boot.git] / common / cli_getch.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, [email protected].
 *
 * Copyright 2022 Google LLC
 */

#include <cli.h>
#include <stdio.h>
#include <string.h>
#include <linux/errno.h>

/**
 * enum cli_esc_state_t - indicates what to do with an escape character
 *
 * @ESC_REJECT: Invalid escape sequence, so the esc_save[] characters are
 *	returned from each subsequent call to cli_ch_esc()
 * @ESC_SAVE: Character should be saved in esc_save until we have another one
 * @ESC_CONVERTED: Escape sequence has been completed and the resulting
 *	character is available
 */
enum cli_esc_state_t {
	ESC_REJECT,
	ESC_SAVE,
	ESC_CONVERTED
};

void cli_ch_init(struct cli_ch_state *cch)
{
	memset(cch, '\0', sizeof(*cch));
}

/**
 * cli_ch_esc() - Process a character in an ongoing escape sequence
 *
 * @cch: State information
 * @ichar: Character to process
 * @actp: Returns the action to take
 * Returns: Output character if *actp is ESC_CONVERTED, else 0
 */
static int cli_ch_esc(struct cli_ch_state *cch, int ichar,
		      enum cli_esc_state_t *actp)
{
	enum cli_esc_state_t act = ESC_REJECT;

	switch (cch->esc_len) {
	case 1:
		if (ichar == '[' || ichar == 'O')
			act = ESC_SAVE;
		else
			act = ESC_CONVERTED;
		break;
	case 2:
		switch (ichar) {
		case 'D':	/* <- key */
			ichar = CTL_CH('b');
			act = ESC_CONVERTED;
			break;	/* pass off to ^B handler */
		case 'C':	/* -> key */
			ichar = CTL_CH('f');
			act = ESC_CONVERTED;
			break;	/* pass off to ^F handler */
		case 'H':	/* Home key */
			ichar = CTL_CH('a');
			act = ESC_CONVERTED;
			break;	/* pass off to ^A handler */
		case 'F':	/* End key */
			ichar = CTL_CH('e');
			act = ESC_CONVERTED;
			break;	/* pass off to ^E handler */
		case 'A':	/* up arrow */
			ichar = CTL_CH('p');
			act = ESC_CONVERTED;
			break;	/* pass off to ^P handler */
		case 'B':	/* down arrow */
			ichar = CTL_CH('n');
			act = ESC_CONVERTED;
			break;	/* pass off to ^N handler */
		case '1':
		case '2':
		case '3':
		case '4':
		case '7':
		case '8':
			if (cch->esc_save[1] == '[') {
				/* see if next character is ~ */
				act = ESC_SAVE;
			}
			break;
		}
		break;
	case 3:
		switch (ichar) {
		case '~':
			switch (cch->esc_save[2]) {
			case '3':	/* Delete key */
				ichar = CTL_CH('d');
				act = ESC_CONVERTED;
				break;	/* pass to ^D handler */
			case '1':	/* Home key */
			case '7':
				ichar = CTL_CH('a');
				act = ESC_CONVERTED;
				break;	/* pass to ^A handler */
			case '4':	/* End key */
			case '8':
				ichar = CTL_CH('e');
				act = ESC_CONVERTED;
				break;	/* pass to ^E handler */
			}
			break;
		case '0':
			if (cch->esc_save[2] == '2')
				act = ESC_SAVE;
			break;
		}
		break;
	case 4:
		switch (ichar) {
		case '0':
		case '1':
			act = ESC_SAVE;
			break;		/* bracketed paste */
		}
		break;
	case 5:
		if (ichar == '~') {	/* bracketed paste */
			ichar = 0;
			act = ESC_CONVERTED;
		}
	}

	*actp = act;

	return ichar;
}

int cli_ch_process(struct cli_ch_state *cch, int ichar)
{
	/*
	 * ichar=0x0 when error occurs in U-Boot getchar() or when the caller
	 * wants to check if there are more characters saved in the escape
	 * sequence
	 */
	if (!ichar) {
		if (cch->emitting) {
			if (cch->emit_upto < cch->esc_len)
				return cch->esc_save[cch->emit_upto++];
			cch->emit_upto = 0;
			cch->emitting = false;
			cch->esc_len = 0;
		}
		return 0;
	} else if (ichar == -ETIMEDOUT) {
		/*
		 * If we are in an escape sequence but nothing has followed the
		 * Escape character, then the user probably just pressed the
		 * Escape key. Return it and clear the sequence.
		 */
		if (cch->esc_len) {
			cch->esc_len = 0;
			return '\e';
		}

		/* Otherwise there is nothing to return */
		return 0;
	}

	if (ichar == '\n' || ichar == '\r')
		return '\n';

	/* handle standard linux xterm esc sequences for arrow key, etc. */
	if (cch->esc_len != 0) {
		enum cli_esc_state_t act;

		ichar = cli_ch_esc(cch, ichar, &act);

		switch (act) {
		case ESC_SAVE:
			/* save this character and return nothing */
			cch->esc_save[cch->esc_len++] = ichar;
			ichar = 0;
			break;
		case ESC_REJECT:
			/*
			 * invalid escape sequence, start returning the
			 * characters in it
			 */
			cch->esc_save[cch->esc_len++] = ichar;
			ichar = cch->esc_save[cch->emit_upto++];
			cch->emitting = true;
			return ichar;
		case ESC_CONVERTED:
			/* valid escape sequence, return the resulting char */
			cch->esc_len = 0;
			break;
		}
	}

	if (ichar == '\e') {
		if (!cch->esc_len) {
			cch->esc_save[cch->esc_len] = ichar;
			cch->esc_len = 1;
		} else {
			puts("impossible condition #876\n");
			cch->esc_len = 0;
		}
		return 0;
	}

	return ichar;
}
Commit	Line	Data
b08e9d4b SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* (C) Copyright 2000
	4	* Wolfgang Denk, DENX Software Engineering, [email protected].
	5	*
	6	* Copyright 2022 Google LLC
	7	*/
	8
b08e9d4b	9	#include <cli.h>
03de305e TR	10	#include <stdio.h>
	11	#include <string.h>
	12	#include <linux/errno.h>
b08e9d4b SG	13
	14	/**
	15	* enum cli_esc_state_t - indicates what to do with an escape character
	16	*
	17	* @ESC_REJECT: Invalid escape sequence, so the esc_save[] characters are
	18	* returned from each subsequent call to cli_ch_esc()
	19	* @ESC_SAVE: Character should be saved in esc_save until we have another one
	20	* @ESC_CONVERTED: Escape sequence has been completed and the resulting
	21	* character is available
	22	*/
	23	enum cli_esc_state_t {
	24	ESC_REJECT,
	25	ESC_SAVE,
	26	ESC_CONVERTED
	27	};
	28
	29	void cli_ch_init(struct cli_ch_state *cch)
	30	{
	31	memset(cch, '\0', sizeof(*cch));
	32	}
	33
	34	/**
	35	* cli_ch_esc() - Process a character in an ongoing escape sequence
	36	*
	37	* @cch: State information
	38	* @ichar: Character to process
	39	* @actp: Returns the action to take
	40	* Returns: Output character if *actp is ESC_CONVERTED, else 0
	41	*/
	42	static int cli_ch_esc(struct cli_ch_state *cch, int ichar,
	43	enum cli_esc_state_t *actp)
	44	{
	45	enum cli_esc_state_t act = ESC_REJECT;
	46
	47	switch (cch->esc_len) {
	48	case 1:
	49	if (ichar == '[' \|\| ichar == 'O')
	50	act = ESC_SAVE;
2dd86b90 YM	51	else
2dd86b90 YM	52	act = ESC_CONVERTED;
b08e9d4b SG	53	break;
	54	case 2:
	55	switch (ichar) {
	56	case 'D': /* <- key */
	57	ichar = CTL_CH('b');
	58	act = ESC_CONVERTED;
	59	break; /* pass off to ^B handler */
	60	case 'C': /* -> key */
	61	ichar = CTL_CH('f');
	62	act = ESC_CONVERTED;
	63	break; /* pass off to ^F handler */
	64	case 'H': /* Home key */
	65	ichar = CTL_CH('a');
	66	act = ESC_CONVERTED;
	67	break; /* pass off to ^A handler */
	68	case 'F': /* End key */
	69	ichar = CTL_CH('e');
	70	act = ESC_CONVERTED;
	71	break; /* pass off to ^E handler */
	72	case 'A': /* up arrow */
	73	ichar = CTL_CH('p');
	74	act = ESC_CONVERTED;
	75	break; /* pass off to ^P handler */
	76	case 'B': /* down arrow */
	77	ichar = CTL_CH('n');
	78	act = ESC_CONVERTED;
	79	break; /* pass off to ^N handler */
	80	case '1':
	81	case '2':
	82	case '3':
	83	case '4':
	84	case '7':
	85	case '8':
	86	if (cch->esc_save[1] == '[') {
	87	/* see if next character is ~ */
	88	act = ESC_SAVE;
	89	}
	90	break;
	91	}
	92	break;
	93	case 3:
	94	switch (ichar) {
	95	case '~':
	96	switch (cch->esc_save[2]) {
	97	case '3': /* Delete key */
	98	ichar = CTL_CH('d');
	99	act = ESC_CONVERTED;
	100	break; /* pass to ^D handler */
	101	case '1': /* Home key */
	102	case '7':
	103	ichar = CTL_CH('a');
	104	act = ESC_CONVERTED;
	105	break; /* pass to ^A handler */
	106	case '4': /* End key */
	107	case '8':
	108	ichar = CTL_CH('e');
	109	act = ESC_CONVERTED;
	110	break; /* pass to ^E handler */
	111	}
	112	break;
	113	case '0':
	114	if (cch->esc_save[2] == '2')
	115	act = ESC_SAVE;
	116	break;
117	}
118	break;
119	case 4:
120	switch (ichar) {
121	case '0':
122	case '1':
123	act = ESC_SAVE;
124	break; /* bracketed paste */
125	}
126	break;
127	case 5:
128	if (ichar == '~') { /* bracketed paste */
129	ichar = 0;
130	act = ESC_CONVERTED;
131	}
132	}
133
134	*actp = act;
135
17b45e68	136	return ichar;
b08e9d4b SG	137	}
	138
	139	int cli_ch_process(struct cli_ch_state *cch, int ichar)
	140	{
	141	/*
	142	* ichar=0x0 when error occurs in U-Boot getchar() or when the caller
	143	* wants to check if there are more characters saved in the escape
	144	* sequence
	145	*/
	146	if (!ichar) {
32bab0ea	147	if (cch->emitting) {
b08e9d4b SG	148	if (cch->emit_upto < cch->esc_len)
	149	return cch->esc_save[cch->emit_upto++];
	150	cch->emit_upto = 0;
32bab0ea	151	cch->emitting = false;
17b45e68	152	cch->esc_len = 0;
b08e9d4b SG	153	}
	154	return 0;
	155	} else if (ichar == -ETIMEDOUT) {
	156	/*
	157	* If we are in an escape sequence but nothing has followed the
	158	* Escape character, then the user probably just pressed the
	159	* Escape key. Return it and clear the sequence.
	160	*/
	161	if (cch->esc_len) {
	162	cch->esc_len = 0;
	163	return '\e';
	164	}
	165
	166	/* Otherwise there is nothing to return */
	167	return 0;
	168	}
	169
	170	if (ichar == '\n' \|\| ichar == '\r')
	171	return '\n';
	172
	173	/* handle standard linux xterm esc sequences for arrow key, etc. */
	174	if (cch->esc_len != 0) {
	175	enum cli_esc_state_t act;
	176
	177	ichar = cli_ch_esc(cch, ichar, &act);
	178
	179	switch (act) {
	180	case ESC_SAVE:
	181	/* save this character and return nothing */
	182	cch->esc_save[cch->esc_len++] = ichar;
32bab0ea SG	183	ichar = 0;
32bab0ea SG	184	break;
b08e9d4b SG	185	case ESC_REJECT:
	186	/*
	187	* invalid escape sequence, start returning the
	188	* characters in it
	189	*/
	190	cch->esc_save[cch->esc_len++] = ichar;
32bab0ea SG	191	ichar = cch->esc_save[cch->emit_upto++];
32bab0ea SG	192	cch->emitting = true;
17b45e68	193	return ichar;
b08e9d4b SG	194	case ESC_CONVERTED:
	195	/* valid escape sequence, return the resulting char */
	196	cch->esc_len = 0;
32bab0ea	197	break;
b08e9d4b SG	198	}
	199	}
	200
	201	if (ichar == '\e') {
	202	if (!cch->esc_len) {
	203	cch->esc_save[cch->esc_len] = ichar;
	204	cch->esc_len = 1;
	205	} else {
	206	puts("impossible condition #876\n");
	207	cch->esc_len = 0;
	208	}
	209	return 0;
	210	}
	211
	212	return ichar;
	213	}