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