1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 1997 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1988 AT&T	*/
28 /*	  All Rights Reserved	*/
29 
30 /*
31  * University Copyright- Copyright (c) 1982, 1986, 1988
32  * The Regents of the University of California
33  * All Rights Reserved
34  *
35  * University Acknowledgment- Portions of this document are derived from
36  * software developed by the University of California, Berkeley, and its
37  * contributors.
38  */
39 
40 #pragma ident	"%Z%%M%	%I%	%E% SMI"
41 
42 /*LINTLIBRARY*/
43 
44 #include	<sys/types.h>
45 #include	<stdlib.h>
46 #include	<string.h>
47 #include	"curses_inc.h"
48 
49 static	short	keycodes[] = {
50 		    KEY_BACKSPACE,
51 		    KEY_CATAB,
52 		    KEY_CLEAR,
53 		    KEY_CTAB,
54 		    KEY_DC,
55 		    KEY_DL,
56 		    KEY_DOWN,
57 		    KEY_EIC,
58 		    KEY_EOL,
59 		    KEY_EOS,
60 		    KEY_F(0),
61 		    KEY_F(1),
62 		    KEY_F(10),
63 		    KEY_F(2),
64 		    KEY_F(3),
65 		    KEY_F(4),
66 		    KEY_F(5),
67 		    KEY_F(6),
68 		    KEY_F(7),
69 		    KEY_F(8),
70 		    KEY_F(9),
71 		    KEY_HOME,
72 		    KEY_IC,
73 		    KEY_IL,
74 		    KEY_LEFT,
75 		    KEY_LL,
76 		    KEY_NPAGE,
77 		    KEY_PPAGE,
78 		    KEY_RIGHT,
79 		    KEY_SF,
80 		    KEY_SR,
81 		    KEY_STAB,
82 		    KEY_UP,
83 		    KEY_A1,
84 		    KEY_A3,
85 		    KEY_B2,
86 		    KEY_C1,
87 		    KEY_C3,
88 		    KEY_BTAB,
89 		    KEY_BEG,
90 		    KEY_CANCEL,
91 		    KEY_CLOSE,
92 		    KEY_COMMAND,
93 		    KEY_COPY,
94 		    KEY_CREATE,
95 		    KEY_END,
96 		    KEY_ENTER,
97 		    KEY_EXIT,
98 		    KEY_FIND,
99 		    KEY_HELP,
100 		    KEY_MARK,
101 		    KEY_MESSAGE,
102 		    KEY_MOVE,
103 		    KEY_NEXT,
104 		    KEY_OPEN,
105 		    KEY_OPTIONS,
106 		    KEY_PREVIOUS,
107 		    KEY_PRINT,
108 		    KEY_REDO,
109 		    KEY_REFERENCE,
110 		    KEY_REFRESH,
111 		    KEY_REPLACE,
112 		    KEY_RESTART,
113 		    KEY_RESUME,
114 		    KEY_SAVE,
115 		    KEY_SUSPEND,
116 		    KEY_UNDO,
117 		    KEY_SBEG,
118 		    KEY_SCANCEL,
119 		    KEY_SCOMMAND,
120 		    KEY_SCOPY,
121 		    KEY_SCREATE,
122 		    KEY_SDC,
123 		    KEY_SDL,
124 		    KEY_SELECT,
125 		    KEY_SEND,
126 		    KEY_SEOL,
127 		    KEY_SEXIT,
128 		    KEY_SFIND,
129 		    KEY_SHELP,
130 		    KEY_SHOME,
131 		    KEY_SIC,
132 		    KEY_SLEFT,
133 		    KEY_SMESSAGE,
134 		    KEY_SMOVE,
135 		    KEY_SNEXT,
136 		    KEY_SOPTIONS,
137 		    KEY_SPREVIOUS,
138 		    KEY_SPRINT,
139 		    KEY_SREDO,
140 		    KEY_SREPLACE,
141 		    KEY_SRIGHT,
142 		    KEY_SRSUME,
143 		    KEY_SSAVE,
144 		    KEY_SSUSPEND,
145 		    KEY_SUNDO,
146 		    KEY_MOUSE
147 		};
148 
149 static	_KEY_MAP	*p;
150 static	bool		*funckey;
151 static	short		*codeptr;
152 
153 static	void
154 _laddone(char *txt)
155 {
156 	p->_sends = (txt);
157 	p->_keyval = *codeptr;
158 	funckey[(unsigned char)(txt)[0]] |= _KEY;
159 	p++;
160 }
161 
162 /* Map text into num, updating the map structure p. */
163 
164 static	void
165 _keyfunc(char **keyptr, char **lastkey)
166 {
167 	for (; keyptr <= lastkey; keyptr++, codeptr++)
168 		if (*keyptr) {
169 			p->_sends = (*keyptr);
170 			p->_keyval = *codeptr;
171 			funckey[(unsigned char)(*keyptr)[0]] |= _KEY;
172 			p++;
173 		}
174 }
175 
176 /* Map text into num, updating the map structure p. */
177 
178 static	void
179 _keyfunc2(char **keyptr, char **lastkey)
180 {
181 	short code_value = KEY_F(11);
182 
183 	for (; *keyptr && keyptr <= lastkey; keyptr++, code_value++) {
184 		p->_sends = *keyptr;
185 		p->_keyval = (short) code_value;
186 		funckey[(unsigned char)*keyptr[0]] |= _KEY;
187 		p++;
188 	}
189 }
190 
191 int
192 setkeymap(void)
193 {
194 	_KEY_MAP	keymap[((sizeof (keycodes) / sizeof (short)) +
195 			    ((KEY_F(63) - KEY_F(11)) + 1))], **key_ptrs;
196 	short		numkeys;
197 	int		numbytes, key_size = cur_term->_ksz;
198 
199 	if (cur_term->internal_keys != NULL)
200 		return (ERR);
201 	p = keymap;
202 	codeptr = keycodes;
203 	funckey = cur_term->funckeystarter;
204 
205 	/* If backspace key sends \b, don't map it. */
206 	if (key_backspace && strcmp(key_backspace, "\b"))
207 		_laddone(key_backspace);
208 	codeptr++;
209 
210 	_keyfunc(&key_catab, &key_dl);
211 
212 	/* If down arrow key sends \n, don't map it. */
213 	if (key_down && strcmp(key_down, "\n"))
214 		_laddone(key_down);
215 	codeptr++;
216 
217 	_keyfunc(&key_eic, &key_il);
218 
219 	/* If left arrow key sends \b, don't map it. */
220 	if (key_left && strcmp(key_left, "\b"))
221 		_laddone(key_left);
222 	codeptr++;
223 
224 	_keyfunc(&key_ll, &key_up);
225 	_keyfunc(&key_a1, &key_c3);
226 	_keyfunc(&key_btab, &key_btab);
227 	_keyfunc(&key_beg, &key_sundo);
228 	_keyfunc2(&key_f11, &key_f63);
229 	_keyfunc(&key_mouse, &key_mouse);
230 
231 	/*
232 	 * malloc returns the address of a list of pointers to
233 	 * (_KEY_MAP *) structures
234 	 */
235 
236 	if ((key_ptrs = (_KEY_MAP **)
237 	    /* LINTED */
238 	    malloc((key_size + (numkeys = (short)(p - keymap))) *
239 	    sizeof (_KEY_MAP *))) == NULL) {
240 		goto out;
241 	}
242 
243 	/*
244 	 * Number of bytes needed is the number of structures times their size
245 	 * malloc room for our array of _KEY_MAP structures
246 	 */
247 
248 	if ((p = (_KEY_MAP *) malloc((unsigned)
249 	    /* LINTED */
250 	    (numbytes = (int)(sizeof (_KEY_MAP) * numkeys)))) == NULL) {
251 		/* Can't do it, free list of pointers, indicate */
252 		/* error upon return. */
253 		free((char *) key_ptrs);
254 out:
255 		term_errno = TERM_BAD_MALLOC;
256 #ifdef	DEBUG
257 		strcpy(term_parm_err, "setkeymap");
258 		termerr();
259 #endif	/* DEBUG */
260 		return (ERR);
261 	}
262 
263 	if (key_size != 0) {
264 		(void) memcpy((char *) &(key_ptrs[numkeys]),
265 		    (char *) cur_term->_keys, (key_size *
266 		    sizeof (_KEY_MAP *)));
267 		free(cur_term->_keys);
268 	}
269 	(void) memcpy((char *) (cur_term->internal_keys = p),
270 	    (char *) keymap, numbytes);
271 	cur_term->_keys = key_ptrs;
272 	cur_term->_ksz += numkeys;
273 	/*
274 	 * Reset _lastkey_ordered to -1 since we put the keys read in
275 	 * from terminfo at the beginning of the keys table.
276 	 */
277 	cur_term->_lastkey_ordered = -1;
278 	cur_term->_lastmacro_ordered += numkeys;
279 	cur_term->_first_macro += numkeys;
280 
281 	/* Initialize our pointers to the structures */
282 	while (numkeys--)
283 		*key_ptrs++ = p++;
284 #ifdef	DEBUG
285 	if (outf)
286 		fprintf(outf, "return key structure %x, ending at %x\n",
287 		    keymap, p);
288 #endif	/* DEBUG */
289 	return (OK);
290 }
291