Deleted Added
sdiff udiff text old ( 244941 ) new ( 276881 )
full compact
map.c (244941) map.c (276881)
1/* $NetBSD: map.c,v 1.34 2014/07/06 18:15:34 christos Exp $ */
2
1/*-
2 * Copyright (c) 1992, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Christos Zoulas of Cornell University.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 14 unchanged lines hidden (view full) ---

23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
3/*-
4 * Copyright (c) 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Christos Zoulas of Cornell University.
9 *
10 * Redistribution and use in source and binary forms, with or without

--- 14 unchanged lines hidden (view full) ---

25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
31 *
32 * $NetBSD: map.c,v 1.24 2006/04/09 01:36:51 christos Exp $
33 */
34
33 */
34
35#include "config.h"
35#if !defined(lint) && !defined(SCCSID)
36#if !defined(lint) && !defined(SCCSID)
37#if 0
36static char sccsid[] = "@(#)map.c 8.1 (Berkeley) 6/4/93";
38static char sccsid[] = "@(#)map.c 8.1 (Berkeley) 6/4/93";
39#else
40__RCSID("$NetBSD: map.c,v 1.34 2014/07/06 18:15:34 christos Exp $");
41#endif
37#endif /* not lint && not SCCSID */
38#include <sys/cdefs.h>
42#endif /* not lint && not SCCSID */
43#include <sys/cdefs.h>
39__FBSDID("$FreeBSD: head/lib/libedit/map.c 244941 2013-01-01 19:20:51Z pfg $");
44__FBSDID("$FreeBSD: head/lib/libedit/map.c 276881 2015-01-09 07:40:56Z bapt $");
40
41/*
42 * map.c: Editor function definitions
43 */
45
46/*
47 * map.c: Editor function definitions
48 */
44#include "sys.h"
45#include <stdlib.h>
46#include "el.h"
47
49#include <stdlib.h>
50#include "el.h"
51
48#define N_KEYS 256
49
50private void map_print_key(EditLine *, el_action_t *, const char *);
51private void map_print_some_keys(EditLine *, el_action_t *, int, int);
52private void map_print_key(EditLine *, el_action_t *, const Char *);
53private void map_print_some_keys(EditLine *, el_action_t *, Int, Int);
52private void map_print_all_keys(EditLine *);
53private void map_init_nls(EditLine *);
54private void map_init_meta(EditLine *);
55
56/* keymap tables ; should be N_KEYS*sizeof(KEYCMD) bytes long */
57
58
59private const el_action_t el_map_emacs[] = {

--- 838 unchanged lines hidden (view full) ---

898 if (sizeof(el_map_emacs) != N_KEYS * sizeof(el_action_t))
899 EL_ABORT((el->errfile, "Emacs map incorrect\n"));
900 if (sizeof(el_map_vi_command) != N_KEYS * sizeof(el_action_t))
901 EL_ABORT((el->errfile, "Vi command map incorrect\n"));
902 if (sizeof(el_map_vi_insert) != N_KEYS * sizeof(el_action_t))
903 EL_ABORT((el->errfile, "Vi insert map incorrect\n"));
904#endif
905
54private void map_print_all_keys(EditLine *);
55private void map_init_nls(EditLine *);
56private void map_init_meta(EditLine *);
57
58/* keymap tables ; should be N_KEYS*sizeof(KEYCMD) bytes long */
59
60
61private const el_action_t el_map_emacs[] = {

--- 838 unchanged lines hidden (view full) ---

900 if (sizeof(el_map_emacs) != N_KEYS * sizeof(el_action_t))
901 EL_ABORT((el->errfile, "Emacs map incorrect\n"));
902 if (sizeof(el_map_vi_command) != N_KEYS * sizeof(el_action_t))
903 EL_ABORT((el->errfile, "Vi command map incorrect\n"));
904 if (sizeof(el_map_vi_insert) != N_KEYS * sizeof(el_action_t))
905 EL_ABORT((el->errfile, "Vi insert map incorrect\n"));
906#endif
907
906 el->el_map.alt = (el_action_t *)el_malloc(sizeof(el_action_t) * N_KEYS);
908 el->el_map.alt = el_malloc(sizeof(*el->el_map.alt) * N_KEYS);
907 if (el->el_map.alt == NULL)
909 if (el->el_map.alt == NULL)
908 return (-1);
909 el->el_map.key = (el_action_t *)el_malloc(sizeof(el_action_t) * N_KEYS);
910 return -1;
911 el->el_map.key = el_malloc(sizeof(*el->el_map.key) * N_KEYS);
910 if (el->el_map.key == NULL)
912 if (el->el_map.key == NULL)
911 return (-1);
913 return -1;
912 el->el_map.emacs = el_map_emacs;
913 el->el_map.vic = el_map_vi_command;
914 el->el_map.vii = el_map_vi_insert;
914 el->el_map.emacs = el_map_emacs;
915 el->el_map.vic = el_map_vi_command;
916 el->el_map.vii = el_map_vi_insert;
915 el->el_map.help = (el_bindings_t *) el_malloc(sizeof(el_bindings_t) *
916 EL_NUM_FCNS);
917 el->el_map.help = el_malloc(sizeof(*el->el_map.help) * EL_NUM_FCNS);
917 if (el->el_map.help == NULL)
918 if (el->el_map.help == NULL)
918 return (-1);
919 return -1;
919 (void) memcpy(el->el_map.help, help__get(),
920 (void) memcpy(el->el_map.help, help__get(),
920 sizeof(el_bindings_t) * EL_NUM_FCNS);
921 el->el_map.func = (el_func_t *)el_malloc(sizeof(el_func_t) *
922 EL_NUM_FCNS);
921 sizeof(*el->el_map.help) * EL_NUM_FCNS);
922 el->el_map.func = el_malloc(sizeof(*el->el_map.func) * EL_NUM_FCNS);
923 if (el->el_map.func == NULL)
923 if (el->el_map.func == NULL)
924 return (-1);
925 memcpy(el->el_map.func, func__get(), sizeof(el_func_t) * EL_NUM_FCNS);
924 return -1;
925 memcpy(el->el_map.func, func__get(), sizeof(*el->el_map.func)
926 * EL_NUM_FCNS);
926 el->el_map.nfunc = EL_NUM_FCNS;
927
928#ifdef VIDEFAULT
929 map_init_vi(el);
930#else
931 map_init_emacs(el);
932#endif /* VIDEFAULT */
927 el->el_map.nfunc = EL_NUM_FCNS;
928
929#ifdef VIDEFAULT
930 map_init_vi(el);
931#else
932 map_init_emacs(el);
933#endif /* VIDEFAULT */
933 return (0);
934 return 0;
934}
935
936
937/* map_end():
938 * Free the space taken by the editor maps
939 */
940protected void
941map_end(EditLine *el)
942{
943
935}
936
937
938/* map_end():
939 * Free the space taken by the editor maps
940 */
941protected void
942map_end(EditLine *el)
943{
944
944 el_free((ptr_t) el->el_map.alt);
945 el_free(el->el_map.alt);
945 el->el_map.alt = NULL;
946 el->el_map.alt = NULL;
946 el_free((ptr_t) el->el_map.key);
947 el_free(el->el_map.key);
947 el->el_map.key = NULL;
948 el->el_map.emacs = NULL;
949 el->el_map.vic = NULL;
950 el->el_map.vii = NULL;
948 el->el_map.key = NULL;
949 el->el_map.emacs = NULL;
950 el->el_map.vic = NULL;
951 el->el_map.vii = NULL;
951 el_free((ptr_t) el->el_map.help);
952 el_free(el->el_map.help);
952 el->el_map.help = NULL;
953 el->el_map.help = NULL;
953 el_free((ptr_t) el->el_map.func);
954 el_free(el->el_map.func);
954 el->el_map.func = NULL;
955}
956
957
958/* map_init_nls():
959 * Find all the printable keys and bind them to self insert
960 */
961private void
962map_init_nls(EditLine *el)
963{
964 int i;
965
966 el_action_t *map = el->el_map.key;
967
968 for (i = 0200; i <= 0377; i++)
955 el->el_map.func = NULL;
956}
957
958
959/* map_init_nls():
960 * Find all the printable keys and bind them to self insert
961 */
962private void
963map_init_nls(EditLine *el)
964{
965 int i;
966
967 el_action_t *map = el->el_map.key;
968
969 for (i = 0200; i <= 0377; i++)
969 if (isprint(i))
970 if (Isprint(i))
970 map[i] = ED_INSERT;
971}
972
973
974/* map_init_meta():
975 * Bind all the meta keys to the appropriate ESC-<key> sequence
976 */
977private void
978map_init_meta(EditLine *el)
979{
971 map[i] = ED_INSERT;
972}
973
974
975/* map_init_meta():
976 * Bind all the meta keys to the appropriate ESC-<key> sequence
977 */
978private void
979map_init_meta(EditLine *el)
980{
980 char buf[3];
981 Char buf[3];
981 int i;
982 el_action_t *map = el->el_map.key;
983 el_action_t *alt = el->el_map.alt;
984
985 for (i = 0; i <= 0377 && map[i] != EM_META_NEXT; i++)
986 continue;
987
988 if (i > 0377) {
989 for (i = 0; i <= 0377 && alt[i] != EM_META_NEXT; i++)
990 continue;
991 if (i > 0377) {
992 i = 033;
993 if (el->el_map.type == MAP_VI)
994 map = alt;
995 } else
996 map = alt;
997 }
982 int i;
983 el_action_t *map = el->el_map.key;
984 el_action_t *alt = el->el_map.alt;
985
986 for (i = 0; i <= 0377 && map[i] != EM_META_NEXT; i++)
987 continue;
988
989 if (i > 0377) {
990 for (i = 0; i <= 0377 && alt[i] != EM_META_NEXT; i++)
991 continue;
992 if (i > 0377) {
993 i = 033;
994 if (el->el_map.type == MAP_VI)
995 map = alt;
996 } else
997 map = alt;
998 }
998 buf[0] = (char) i;
999 buf[0] = (Char) i;
999 buf[2] = 0;
1000 for (i = 0200; i <= 0377; i++)
1001 switch (map[i]) {
1002 case ED_INSERT:
1003 case ED_UNASSIGNED:
1004 case ED_SEQUENCE_LEAD_IN:
1005 break;
1006 default:
1007 buf[1] = i & 0177;
1000 buf[2] = 0;
1001 for (i = 0200; i <= 0377; i++)
1002 switch (map[i]) {
1003 case ED_INSERT:
1004 case ED_UNASSIGNED:
1005 case ED_SEQUENCE_LEAD_IN:
1006 break;
1007 default:
1008 buf[1] = i & 0177;
1008 key_add(el, buf, key_map_cmd(el, (int) map[i]), XK_CMD);
1009 keymacro_add(el, buf, keymacro_map_cmd(el, (int) map[i]), XK_CMD);
1009 break;
1010 }
1011 map[(int) buf[0]] = ED_SEQUENCE_LEAD_IN;
1012}
1013
1014
1015/* map_init_vi():
1016 * Initialize the vi bindings

--- 5 unchanged lines hidden (view full) ---

1022 el_action_t *key = el->el_map.key;
1023 el_action_t *alt = el->el_map.alt;
1024 const el_action_t *vii = el->el_map.vii;
1025 const el_action_t *vic = el->el_map.vic;
1026
1027 el->el_map.type = MAP_VI;
1028 el->el_map.current = el->el_map.key;
1029
1010 break;
1011 }
1012 map[(int) buf[0]] = ED_SEQUENCE_LEAD_IN;
1013}
1014
1015
1016/* map_init_vi():
1017 * Initialize the vi bindings

--- 5 unchanged lines hidden (view full) ---

1023 el_action_t *key = el->el_map.key;
1024 el_action_t *alt = el->el_map.alt;
1025 const el_action_t *vii = el->el_map.vii;
1026 const el_action_t *vic = el->el_map.vic;
1027
1028 el->el_map.type = MAP_VI;
1029 el->el_map.current = el->el_map.key;
1030
1030 key_reset(el);
1031 keymacro_reset(el);
1031
1032 for (i = 0; i < N_KEYS; i++) {
1033 key[i] = vii[i];
1034 alt[i] = vic[i];
1035 }
1036
1037 map_init_meta(el);
1038 map_init_nls(el);
1039
1040 tty_bind_char(el, 1);
1032
1033 for (i = 0; i < N_KEYS; i++) {
1034 key[i] = vii[i];
1035 alt[i] = vic[i];
1036 }
1037
1038 map_init_meta(el);
1039 map_init_nls(el);
1040
1041 tty_bind_char(el, 1);
1041 term_bind_arrow(el);
1042 terminal_bind_arrow(el);
1042}
1043
1044
1045/* map_init_emacs():
1046 * Initialize the emacs bindings
1047 */
1048protected void
1049map_init_emacs(EditLine *el)
1050{
1051 int i;
1043}
1044
1045
1046/* map_init_emacs():
1047 * Initialize the emacs bindings
1048 */
1049protected void
1050map_init_emacs(EditLine *el)
1051{
1052 int i;
1052 char buf[3];
1053 Char buf[3];
1053 el_action_t *key = el->el_map.key;
1054 el_action_t *alt = el->el_map.alt;
1055 const el_action_t *emacs = el->el_map.emacs;
1056
1057 el->el_map.type = MAP_EMACS;
1058 el->el_map.current = el->el_map.key;
1054 el_action_t *key = el->el_map.key;
1055 el_action_t *alt = el->el_map.alt;
1056 const el_action_t *emacs = el->el_map.emacs;
1057
1058 el->el_map.type = MAP_EMACS;
1059 el->el_map.current = el->el_map.key;
1059 key_reset(el);
1060 keymacro_reset(el);
1060
1061 for (i = 0; i < N_KEYS; i++) {
1062 key[i] = emacs[i];
1063 alt[i] = ED_UNASSIGNED;
1064 }
1065
1066 map_init_meta(el);
1067 map_init_nls(el);
1068
1069 buf[0] = CONTROL('X');
1070 buf[1] = CONTROL('X');
1071 buf[2] = 0;
1061
1062 for (i = 0; i < N_KEYS; i++) {
1063 key[i] = emacs[i];
1064 alt[i] = ED_UNASSIGNED;
1065 }
1066
1067 map_init_meta(el);
1068 map_init_nls(el);
1069
1070 buf[0] = CONTROL('X');
1071 buf[1] = CONTROL('X');
1072 buf[2] = 0;
1072 key_add(el, buf, key_map_cmd(el, EM_EXCHANGE_MARK), XK_CMD);
1073 keymacro_add(el, buf, keymacro_map_cmd(el, EM_EXCHANGE_MARK), XK_CMD);
1073
1074 tty_bind_char(el, 1);
1074
1075 tty_bind_char(el, 1);
1075 term_bind_arrow(el);
1076 terminal_bind_arrow(el);
1076}
1077
1078
1079/* map_set_editor():
1080 * Set the editor
1081 */
1082protected int
1077}
1078
1079
1080/* map_set_editor():
1081 * Set the editor
1082 */
1083protected int
1083map_set_editor(EditLine *el, char *editor)
1084map_set_editor(EditLine *el, Char *editor)
1084{
1085
1085{
1086
1086 if (strcmp(editor, "emacs") == 0) {
1087 if (Strcmp(editor, STR("emacs")) == 0) {
1087 map_init_emacs(el);
1088 map_init_emacs(el);
1088 return (0);
1089 return 0;
1089 }
1090 }
1090 if (strcmp(editor, "vi") == 0) {
1091 if (Strcmp(editor, STR("vi")) == 0) {
1091 map_init_vi(el);
1092 map_init_vi(el);
1092 return (0);
1093 return 0;
1093 }
1094 }
1094 return (-1);
1095 return -1;
1095}
1096
1097
1098/* map_get_editor():
1099 * Retrieve the editor
1100 */
1101protected int
1096}
1097
1098
1099/* map_get_editor():
1100 * Retrieve the editor
1101 */
1102protected int
1102map_get_editor(EditLine *el, const char **editor)
1103map_get_editor(EditLine *el, const Char **editor)
1103{
1104
1105 if (editor == NULL)
1104{
1105
1106 if (editor == NULL)
1106 return (-1);
1107 return -1;
1107 switch (el->el_map.type) {
1108 case MAP_EMACS:
1108 switch (el->el_map.type) {
1109 case MAP_EMACS:
1109 *editor = "emacs";
1110 return (0);
1110 *editor = STR("emacs");
1111 return 0;
1111 case MAP_VI:
1112 case MAP_VI:
1112 *editor = "vi";
1113 return (0);
1113 *editor = STR("vi");
1114 return 0;
1114 }
1115 }
1115 return (-1);
1116 return -1;
1116}
1117
1118
1119/* map_print_key():
1120 * Print the function description for 1 key
1121 */
1122private void
1117}
1118
1119
1120/* map_print_key():
1121 * Print the function description for 1 key
1122 */
1123private void
1123map_print_key(EditLine *el, el_action_t *map, const char *in)
1124map_print_key(EditLine *el, el_action_t *map, const Char *in)
1124{
1125 char outbuf[EL_BUFSIZ];
1126 el_bindings_t *bp, *ep;
1127
1128 if (in[0] == '\0' || in[1] == '\0') {
1125{
1126 char outbuf[EL_BUFSIZ];
1127 el_bindings_t *bp, *ep;
1128
1129 if (in[0] == '\0' || in[1] == '\0') {
1129 (void) key__decode_str(in, outbuf, sizeof(outbuf), "");
1130 (void) keymacro__decode_str(in, outbuf, sizeof(outbuf), "");
1130 ep = &el->el_map.help[el->el_map.nfunc];
1131 for (bp = el->el_map.help; bp < ep; bp++)
1132 if (bp->func == map[(unsigned char) *in]) {
1133 (void) fprintf(el->el_outfile,
1131 ep = &el->el_map.help[el->el_map.nfunc];
1132 for (bp = el->el_map.help; bp < ep; bp++)
1133 if (bp->func == map[(unsigned char) *in]) {
1134 (void) fprintf(el->el_outfile,
1134 "%s\t->\t%s\n", outbuf, bp->name);
1135 "%s\t->\t" FSTR "\n", outbuf, bp->name);
1135 return;
1136 }
1137 } else
1136 return;
1137 }
1138 } else
1138 key_print(el, in);
1139 keymacro_print(el, in);
1139}
1140
1141
1142/* map_print_some_keys():
1143 * Print keys from first to last
1144 */
1145private void
1140}
1141
1142
1143/* map_print_some_keys():
1144 * Print keys from first to last
1145 */
1146private void
1146map_print_some_keys(EditLine *el, el_action_t *map, int first, int last)
1147map_print_some_keys(EditLine *el, el_action_t *map, Int first, Int last)
1147{
1148 el_bindings_t *bp, *ep;
1148{
1149 el_bindings_t *bp, *ep;
1149 char firstbuf[2], lastbuf[2];
1150 Char firstbuf[2], lastbuf[2];
1150 char unparsbuf[EL_BUFSIZ], extrabuf[EL_BUFSIZ];
1151
1152 firstbuf[0] = first;
1153 firstbuf[1] = 0;
1154 lastbuf[0] = last;
1155 lastbuf[1] = 0;
1156 if (map[first] == ED_UNASSIGNED) {
1157 if (first == last) {
1151 char unparsbuf[EL_BUFSIZ], extrabuf[EL_BUFSIZ];
1152
1153 firstbuf[0] = first;
1154 firstbuf[1] = 0;
1155 lastbuf[0] = last;
1156 lastbuf[1] = 0;
1157 if (map[first] == ED_UNASSIGNED) {
1158 if (first == last) {
1158 (void) key__decode_str(firstbuf, unparsbuf,
1159 (void) keymacro__decode_str(firstbuf, unparsbuf,
1159 sizeof(unparsbuf), STRQQ);
1160 (void) fprintf(el->el_outfile,
1161 "%-15s-> is undefined\n", unparsbuf);
1162 }
1163 return;
1164 }
1165 ep = &el->el_map.help[el->el_map.nfunc];
1166 for (bp = el->el_map.help; bp < ep; bp++) {
1167 if (bp->func == map[first]) {
1168 if (first == last) {
1160 sizeof(unparsbuf), STRQQ);
1161 (void) fprintf(el->el_outfile,
1162 "%-15s-> is undefined\n", unparsbuf);
1163 }
1164 return;
1165 }
1166 ep = &el->el_map.help[el->el_map.nfunc];
1167 for (bp = el->el_map.help; bp < ep; bp++) {
1168 if (bp->func == map[first]) {
1169 if (first == last) {
1169 (void) key__decode_str(firstbuf, unparsbuf,
1170 (void) keymacro__decode_str(firstbuf, unparsbuf,
1170 sizeof(unparsbuf), STRQQ);
1171 sizeof(unparsbuf), STRQQ);
1171 (void) fprintf(el->el_outfile, "%-15s-> %s\n",
1172 (void) fprintf(el->el_outfile, "%-15s-> " FSTR "\n",
1172 unparsbuf, bp->name);
1173 } else {
1173 unparsbuf, bp->name);
1174 } else {
1174 (void) key__decode_str(firstbuf, unparsbuf,
1175 (void) keymacro__decode_str(firstbuf, unparsbuf,
1175 sizeof(unparsbuf), STRQQ);
1176 sizeof(unparsbuf), STRQQ);
1176 (void) key__decode_str(lastbuf, extrabuf,
1177 (void) keymacro__decode_str(lastbuf, extrabuf,
1177 sizeof(extrabuf), STRQQ);
1178 (void) fprintf(el->el_outfile,
1178 sizeof(extrabuf), STRQQ);
1179 (void) fprintf(el->el_outfile,
1179 "%-4s to %-7s-> %s\n",
1180 "%-4s to %-7s-> " FSTR "\n",
1180 unparsbuf, extrabuf, bp->name);
1181 }
1182 return;
1183 }
1184 }
1185#ifdef MAP_DEBUG
1186 if (map == el->el_map.key) {
1181 unparsbuf, extrabuf, bp->name);
1182 }
1183 return;
1184 }
1185 }
1186#ifdef MAP_DEBUG
1187 if (map == el->el_map.key) {
1187 (void) key__decode_str(firstbuf, unparsbuf,
1188 (void) keymacro__decode_str(firstbuf, unparsbuf,
1188 sizeof(unparsbuf), STRQQ);
1189 (void) fprintf(el->el_outfile,
1190 "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1191 (void) fprintf(el->el_outfile, "el->el_map.key[%d] == %d\n",
1192 first, el->el_map.key[first]);
1193 } else {
1189 sizeof(unparsbuf), STRQQ);
1190 (void) fprintf(el->el_outfile,
1191 "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1192 (void) fprintf(el->el_outfile, "el->el_map.key[%d] == %d\n",
1193 first, el->el_map.key[first]);
1194 } else {
1194 (void) key__decode_str(firstbuf, unparsbuf,
1195 (void) keymacro__decode_str(firstbuf, unparsbuf,
1195 sizeof(unparsbuf), STRQQ);
1196 (void) fprintf(el->el_outfile,
1197 "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1198 (void) fprintf(el->el_outfile, "el->el_map.alt[%d] == %d\n",
1199 first, el->el_map.alt[first]);
1200 }
1201#endif
1202 EL_ABORT((el->el_errfile, "Error printing keys\n"));

--- 24 unchanged lines hidden (view full) ---

1227 if (el->el_map.alt[prev] == el->el_map.alt[i])
1228 continue;
1229 map_print_some_keys(el, el->el_map.alt, prev, i - 1);
1230 prev = i;
1231 }
1232 map_print_some_keys(el, el->el_map.alt, prev, i - 1);
1233
1234 (void) fprintf(el->el_outfile, "Multi-character bindings\n");
1196 sizeof(unparsbuf), STRQQ);
1197 (void) fprintf(el->el_outfile,
1198 "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1199 (void) fprintf(el->el_outfile, "el->el_map.alt[%d] == %d\n",
1200 first, el->el_map.alt[first]);
1201 }
1202#endif
1203 EL_ABORT((el->el_errfile, "Error printing keys\n"));

--- 24 unchanged lines hidden (view full) ---

1228 if (el->el_map.alt[prev] == el->el_map.alt[i])
1229 continue;
1230 map_print_some_keys(el, el->el_map.alt, prev, i - 1);
1231 prev = i;
1232 }
1233 map_print_some_keys(el, el->el_map.alt, prev, i - 1);
1234
1235 (void) fprintf(el->el_outfile, "Multi-character bindings\n");
1235 key_print(el, "");
1236 keymacro_print(el, STR(""));
1236 (void) fprintf(el->el_outfile, "Arrow key bindings\n");
1237 (void) fprintf(el->el_outfile, "Arrow key bindings\n");
1237 term_print_arrow(el, "");
1238 terminal_print_arrow(el, STR(""));
1238}
1239
1240
1241/* map_bind():
1242 * Add/remove/change bindings
1243 */
1244protected int
1239}
1240
1241
1242/* map_bind():
1243 * Add/remove/change bindings
1244 */
1245protected int
1245map_bind(EditLine *el, int argc, const char **argv)
1246map_bind(EditLine *el, int argc, const Char **argv)
1246{
1247 el_action_t *map;
1248 int ntype, rem;
1247{
1248 el_action_t *map;
1249 int ntype, rem;
1249 const char *p;
1250 char inbuf[EL_BUFSIZ];
1251 char outbuf[EL_BUFSIZ];
1252 const char *in = NULL;
1253 char *out;
1250 const Char *p;
1251 Char inbuf[EL_BUFSIZ];
1252 Char outbuf[EL_BUFSIZ];
1253 const Char *in = NULL;
1254 Char *out;
1254 el_bindings_t *bp, *ep;
1255 int cmd;
1256 int key;
1257
1258 if (argv == NULL)
1255 el_bindings_t *bp, *ep;
1256 int cmd;
1257 int key;
1258
1259 if (argv == NULL)
1259 return (-1);
1260 return -1;
1260
1261 map = el->el_map.key;
1262 ntype = XK_CMD;
1263 key = rem = 0;
1264 for (argc = 1; (p = argv[argc]) != NULL; argc++)
1265 if (p[0] == '-')
1266 switch (p[1]) {
1267 case 'a':

--- 13 unchanged lines hidden (view full) ---

1281 break;
1282
1283 case 'r':
1284 rem = 1;
1285 break;
1286
1287 case 'v':
1288 map_init_vi(el);
1261
1262 map = el->el_map.key;
1263 ntype = XK_CMD;
1264 key = rem = 0;
1265 for (argc = 1; (p = argv[argc]) != NULL; argc++)
1266 if (p[0] == '-')
1267 switch (p[1]) {
1268 case 'a':

--- 13 unchanged lines hidden (view full) ---

1282 break;
1283
1284 case 'r':
1285 rem = 1;
1286 break;
1287
1288 case 'v':
1289 map_init_vi(el);
1289 return (0);
1290 return 0;
1290
1291 case 'e':
1292 map_init_emacs(el);
1291
1292 case 'e':
1293 map_init_emacs(el);
1293 return (0);
1294 return 0;
1294
1295 case 'l':
1296 ep = &el->el_map.help[el->el_map.nfunc];
1297 for (bp = el->el_map.help; bp < ep; bp++)
1298 (void) fprintf(el->el_outfile,
1295
1296 case 'l':
1297 ep = &el->el_map.help[el->el_map.nfunc];
1298 for (bp = el->el_map.help; bp < ep; bp++)
1299 (void) fprintf(el->el_outfile,
1299 "%s\n\t%s\n",
1300 "" FSTR "\n\t" FSTR "\n",
1300 bp->name, bp->description);
1301 bp->name, bp->description);
1301 return (0);
1302 return 0;
1302 default:
1303 (void) fprintf(el->el_errfile,
1303 default:
1304 (void) fprintf(el->el_errfile,
1304 "%s: Invalid switch `%c'.\n",
1305 "" FSTR ": Invalid switch `%c'.\n",
1305 argv[0], p[1]);
1306 }
1307 else
1308 break;
1309
1310 if (argv[argc] == NULL) {
1311 map_print_all_keys(el);
1306 argv[0], p[1]);
1307 }
1308 else
1309 break;
1310
1311 if (argv[argc] == NULL) {
1312 map_print_all_keys(el);
1312 return (0);
1313 return 0;
1313 }
1314 if (key)
1315 in = argv[argc++];
1316 else if ((in = parse__string(inbuf, argv[argc++])) == NULL) {
1317 (void) fprintf(el->el_errfile,
1314 }
1315 if (key)
1316 in = argv[argc++];
1317 else if ((in = parse__string(inbuf, argv[argc++])) == NULL) {
1318 (void) fprintf(el->el_errfile,
1318 "%s: Invalid \\ or ^ in instring.\n",
1319 "" FSTR ": Invalid \\ or ^ in instring.\n",
1319 argv[0]);
1320 argv[0]);
1320 return (-1);
1321 return -1;
1321 }
1322 if (rem) {
1323 if (key) {
1322 }
1323 if (rem) {
1324 if (key) {
1324 (void) term_clear_arrow(el, in);
1325 return (-1);
1325 (void) terminal_clear_arrow(el, in);
1326 return -1;
1326 }
1327 if (in[1])
1327 }
1328 if (in[1])
1328 (void) key_delete(el, in);
1329 (void) keymacro_delete(el, in);
1329 else if (map[(unsigned char) *in] == ED_SEQUENCE_LEAD_IN)
1330 else if (map[(unsigned char) *in] == ED_SEQUENCE_LEAD_IN)
1330 (void) key_delete(el, in);
1331 (void) keymacro_delete(el, in);
1331 else
1332 map[(unsigned char) *in] = ED_UNASSIGNED;
1332 else
1333 map[(unsigned char) *in] = ED_UNASSIGNED;
1333 return (0);
1334 return 0;
1334 }
1335 if (argv[argc] == NULL) {
1336 if (key)
1335 }
1336 if (argv[argc] == NULL) {
1337 if (key)
1337 term_print_arrow(el, in);
1338 terminal_print_arrow(el, in);
1338 else
1339 map_print_key(el, map, in);
1339 else
1340 map_print_key(el, map, in);
1340 return (0);
1341 return 0;
1341 }
1342#ifdef notyet
1343 if (argv[argc + 1] != NULL) {
1342 }
1343#ifdef notyet
1344 if (argv[argc + 1] != NULL) {
1344 bindkey_usage();
1345 return (-1);
1345 bindkeymacro_usage();
1346 return -1;
1346 }
1347#endif
1348
1349 switch (ntype) {
1350 case XK_STR:
1351 case XK_EXE:
1352 if ((out = parse__string(outbuf, argv[argc])) == NULL) {
1353 (void) fprintf(el->el_errfile,
1347 }
1348#endif
1349
1350 switch (ntype) {
1351 case XK_STR:
1352 case XK_EXE:
1353 if ((out = parse__string(outbuf, argv[argc])) == NULL) {
1354 (void) fprintf(el->el_errfile,
1354 "%s: Invalid \\ or ^ in outstring.\n", argv[0]);
1355 return (-1);
1355 "" FSTR ": Invalid \\ or ^ in outstring.\n", argv[0]);
1356 return -1;
1356 }
1357 if (key)
1357 }
1358 if (key)
1358 term_set_arrow(el, in, key_map_str(el, out), ntype);
1359 terminal_set_arrow(el, in, keymacro_map_str(el, out), ntype);
1359 else
1360 else
1360 key_add(el, in, key_map_str(el, out), ntype);
1361 keymacro_add(el, in, keymacro_map_str(el, out), ntype);
1361 map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1362 break;
1363
1364 case XK_CMD:
1365 if ((cmd = parse_cmd(el, argv[argc])) == -1) {
1366 (void) fprintf(el->el_errfile,
1362 map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1363 break;
1364
1365 case XK_CMD:
1366 if ((cmd = parse_cmd(el, argv[argc])) == -1) {
1367 (void) fprintf(el->el_errfile,
1367 "%s: Invalid command `%s'.\n", argv[0], argv[argc]);
1368 return (-1);
1368 "" FSTR ": Invalid command `" FSTR "'.\n",
1369 argv[0], argv[argc]);
1370 return -1;
1369 }
1370 if (key)
1371 }
1372 if (key)
1371 term_set_arrow(el, in, key_map_cmd(el, cmd), ntype);
1373 terminal_set_arrow(el, in, keymacro_map_cmd(el, cmd), ntype);
1372 else {
1373 if (in[1]) {
1374 else {
1375 if (in[1]) {
1374 key_add(el, in, key_map_cmd(el, cmd), ntype);
1376 keymacro_add(el, in, keymacro_map_cmd(el, cmd), ntype);
1375 map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1376 } else {
1377 map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1378 } else {
1377 key_clear(el, map, in);
1378 map[(unsigned char) *in] = cmd;
1379 keymacro_clear(el, map, in);
1380 map[(unsigned char) *in] = (el_action_t)cmd;
1379 }
1380 }
1381 break;
1382
1381 }
1382 }
1383 break;
1384
1385 /* coverity[dead_error_begin] */
1383 default:
1384 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype));
1385 break;
1386 }
1386 default:
1387 EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype));
1388 break;
1389 }
1387 return (0);
1390 return 0;
1388}
1389
1390
1391/* map_addfunc():
1392 * add a user defined function
1393 */
1394protected int
1391}
1392
1393
1394/* map_addfunc():
1395 * add a user defined function
1396 */
1397protected int
1395map_addfunc(EditLine *el, const char *name, const char *help, el_func_t func)
1398map_addfunc(EditLine *el, const Char *name, const Char *help, el_func_t func)
1396{
1397 void *p;
1399{
1400 void *p;
1398 int nf = el->el_map.nfunc + 1;
1401 size_t nf = el->el_map.nfunc + 1;
1399
1400 if (name == NULL || help == NULL || func == NULL)
1402
1403 if (name == NULL || help == NULL || func == NULL)
1401 return (-1);
1404 return -1;
1402
1405
1403 if ((p = el_realloc(el->el_map.func, nf * sizeof(el_func_t))) == NULL)
1404 return (-1);
1405 el->el_map.func = (el_func_t *) p;
1406 if ((p = el_realloc(el->el_map.help, nf * sizeof(el_bindings_t)))
1406 if ((p = el_realloc(el->el_map.func, nf *
1407 sizeof(*el->el_map.func))) == NULL)
1408 return -1;
1409 el->el_map.func = p;
1410 if ((p = el_realloc(el->el_map.help, nf * sizeof(*el->el_map.help)))
1407 == NULL)
1411 == NULL)
1408 return (-1);
1409 el->el_map.help = (el_bindings_t *) p;
1412 return -1;
1413 el->el_map.help = p;
1410
1414
1411 nf = el->el_map.nfunc;
1415 nf = (size_t)el->el_map.nfunc;
1412 el->el_map.func[nf] = func;
1413
1414 el->el_map.help[nf].name = name;
1416 el->el_map.func[nf] = func;
1417
1418 el->el_map.help[nf].name = name;
1415 el->el_map.help[nf].func = nf;
1419 el->el_map.help[nf].func = (int)nf;
1416 el->el_map.help[nf].description = help;
1417 el->el_map.nfunc++;
1418
1420 el->el_map.help[nf].description = help;
1421 el->el_map.nfunc++;
1422
1419 return (0);
1423 return 0;
1420}
1424}