usr/src/lib/libcurses/screen/setkeymap.c

   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 }