← Back to branch summary

~ubuntu-branches/ubuntu/raring/mysql-5.5/raring-proposed

« back to all changes in this revision

Viewing changes to cmd-line-utils/libedit/map.c

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-02-14 23:59:22 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120214235922-cux5uek1e5l0hje9
Tags: 5.5.20-0ubuntu1
https://launchpad.net/bugs/688541
https://launchpad.net/bugs/907465
https://launchpad.net/bugs/917542
https://launchpad.net/bugs/912487
http://bugs.debian.org/659566
* New upstream release.
* d/mysql-server-5.5.mysql.upstart: Fix stop on to make sure mysql is
  fully stopped before shutdown commences. (LP: #688541) Also simplify
  start on as it is redundant.
* d/control: Depend on upstart version which has apparmor profile load
  script to prevent failure on upgrade from lucid to precise.
  (LP: #907465)
* d/apparmor-profile: need to allow /run since that is the true path
  of /var/run files. (LP: #917542)
* d/control: mysql-server-5.5 has files in it that used to be owned
  by libmysqlclient-dev, so it must break/replace it. (LP: #912487)
* d/rules, d/control: 5.5.20 Fixes segfault on tests with gcc 4.6,
  change compiler back to system default.
* d/rules: Turn off embedded libedit/readline.(Closes: #659566)

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd-line-utils/libedit/map.c
1
 
/*      $NetBSD: map.c,v 1.24 2006/04/09 01:36:51 christos Exp $        */
 
1
/*      $NetBSD: map.c,v 1.30 2011/08/16 16:25:15 christos Exp $        */
2
2
 
3
3
/*-
4
4
 * Copyright (c) 1992, 1993
46
46
#include <stdlib.h>
47
47
#include "el.h"
48
48
 
49
 
#define N_KEYS 256
50
 
 
51
 
private void    map_print_key(EditLine *, el_action_t *, const char *);
52
 
private void    map_print_some_keys(EditLine *, el_action_t *, int, int);
 
49
private void    map_print_key(EditLine *, el_action_t *, const Char *);
 
50
private void    map_print_some_keys(EditLine *, el_action_t *, Int, Int);
53
51
private void    map_print_all_keys(EditLine *);
54
52
private void    map_init_nls(EditLine *);
55
53
private void    map_init_meta(EditLine *);
904
902
                EL_ABORT((el->errfile, "Vi insert map incorrect\n"));
905
903
#endif
906
904
 
907
 
        el->el_map.alt = (el_action_t *)el_malloc(sizeof(el_action_t) * N_KEYS);
 
905
        el->el_map.alt = el_malloc(sizeof(*el->el_map.alt) * N_KEYS);
908
906
        if (el->el_map.alt == NULL)
909
 
                return (-1);
910
 
        el->el_map.key = (el_action_t *)el_malloc(sizeof(el_action_t) * N_KEYS);
 
907
                return -1;
 
908
        el->el_map.key = el_malloc(sizeof(*el->el_map.key) * N_KEYS);
911
909
        if (el->el_map.key == NULL)
912
 
                return (-1);
 
910
                return -1;
913
911
        el->el_map.emacs = el_map_emacs;
914
912
        el->el_map.vic = el_map_vi_command;
915
913
        el->el_map.vii = el_map_vi_insert;
916
 
        el->el_map.help = (el_bindings_t *) el_malloc(sizeof(el_bindings_t) *
917
 
            EL_NUM_FCNS);
 
914
        el->el_map.help = el_malloc(sizeof(*el->el_map.help) * EL_NUM_FCNS);
918
915
        if (el->el_map.help == NULL)
919
 
                return (-1);
 
916
                return -1;
920
917
        (void) memcpy(el->el_map.help, help__get(),
921
 
            sizeof(el_bindings_t) * EL_NUM_FCNS);
922
 
        el->el_map.func = (el_func_t *)el_malloc(sizeof(el_func_t) *
923
 
            EL_NUM_FCNS);
 
918
            sizeof(*el->el_map.help) * EL_NUM_FCNS);
 
919
        el->el_map.func = el_malloc(sizeof(*el->el_map.func) * EL_NUM_FCNS);
924
920
        if (el->el_map.func == NULL)
925
 
                return (-1);
926
 
        memcpy(el->el_map.func, func__get(), sizeof(el_func_t) * EL_NUM_FCNS);
 
921
                return -1;
 
922
        memcpy(el->el_map.func, func__get(), sizeof(*el->el_map.func)
 
923
            * EL_NUM_FCNS);
927
924
        el->el_map.nfunc = EL_NUM_FCNS;
928
925
 
929
926
#ifdef VIDEFAULT
931
928
#else
932
929
        map_init_emacs(el);
933
930
#endif /* VIDEFAULT */
934
 
        return (0);
 
931
        return 0;
935
932
}
936
933
 
937
934
 
942
939
map_end(EditLine *el)
943
940
{
944
941
 
945
 
        el_free((ptr_t) el->el_map.alt);
 
942
        el_free(el->el_map.alt);
946
943
        el->el_map.alt = NULL;
947
 
        el_free((ptr_t) el->el_map.key);
 
944
        el_free(el->el_map.key);
948
945
        el->el_map.key = NULL;
949
946
        el->el_map.emacs = NULL;
950
947
        el->el_map.vic = NULL;
951
948
        el->el_map.vii = NULL;
952
 
        el_free((ptr_t) el->el_map.help);
 
949
        el_free(el->el_map.help);
953
950
        el->el_map.help = NULL;
954
 
        el_free((ptr_t) el->el_map.func);
 
951
        el_free(el->el_map.func);
955
952
        el->el_map.func = NULL;
956
953
}
957
954
 
967
964
        el_action_t *map = el->el_map.key;
968
965
 
969
966
        for (i = 0200; i <= 0377; i++)
970
 
                if (el_isprint(i))
 
967
                if (Isprint(i))
971
968
                        map[i] = ED_INSERT;
972
969
}
973
970
 
978
975
private void
979
976
map_init_meta(EditLine *el)
980
977
{
981
 
        char buf[3];
 
978
        Char buf[3];
982
979
        int i;
983
980
        el_action_t *map = el->el_map.key;
984
981
        el_action_t *alt = el->el_map.alt;
996
993
                } else
997
994
                        map = alt;
998
995
        }
999
 
        buf[0] = (char) i;
 
996
        buf[0] = (Char) i;
1000
997
        buf[2] = 0;
1001
998
        for (i = 0200; i <= 0377; i++)
1002
999
                switch (map[i]) {
1006
1003
                        break;
1007
1004
                default:
1008
1005
                        buf[1] = i & 0177;
1009
 
                        key_add(el, buf, key_map_cmd(el, (int) map[i]), XK_CMD);
 
1006
                        keymacro_add(el, buf, keymacro_map_cmd(el, (int) map[i]), XK_CMD);
1010
1007
                        break;
1011
1008
                }
1012
1009
        map[(int) buf[0]] = ED_SEQUENCE_LEAD_IN;
1028
1025
        el->el_map.type = MAP_VI;
1029
1026
        el->el_map.current = el->el_map.key;
1030
1027
 
1031
 
        key_reset(el);
 
1028
        keymacro_reset(el);
1032
1029
 
1033
1030
        for (i = 0; i < N_KEYS; i++) {
1034
1031
                key[i] = vii[i];
1039
1036
        map_init_nls(el);
1040
1037
 
1041
1038
        tty_bind_char(el, 1);
1042
 
        term_bind_arrow(el);
 
1039
        terminal_bind_arrow(el);
1043
1040
}
1044
1041
 
1045
1042
 
1050
1047
map_init_emacs(EditLine *el)
1051
1048
{
1052
1049
        int i;
1053
 
        char buf[3];
 
1050
        Char buf[3];
1054
1051
        el_action_t *key = el->el_map.key;
1055
1052
        el_action_t *alt = el->el_map.alt;
1056
1053
        const el_action_t *emacs = el->el_map.emacs;
1057
1054
 
1058
1055
        el->el_map.type = MAP_EMACS;
1059
1056
        el->el_map.current = el->el_map.key;
1060
 
        key_reset(el);
 
1057
        keymacro_reset(el);
1061
1058
 
1062
1059
        for (i = 0; i < N_KEYS; i++) {
1063
1060
                key[i] = emacs[i];
1070
1067
        buf[0] = CONTROL('X');
1071
1068
        buf[1] = CONTROL('X');
1072
1069
        buf[2] = 0;
1073
 
        key_add(el, buf, key_map_cmd(el, EM_EXCHANGE_MARK), XK_CMD);
 
1070
        keymacro_add(el, buf, keymacro_map_cmd(el, EM_EXCHANGE_MARK), XK_CMD);
1074
1071
 
1075
1072
        tty_bind_char(el, 1);
1076
 
        term_bind_arrow(el);
 
1073
        terminal_bind_arrow(el);
1077
1074
}
1078
1075
 
1079
1076
 
1081
1078
 *      Set the editor
1082
1079
 */
1083
1080
protected int
1084
 
map_set_editor(EditLine *el, char *editor)
 
1081
map_set_editor(EditLine *el, Char *editor)
1085
1082
{
1086
1083
 
1087
 
        if (strcmp(editor, "emacs") == 0) {
 
1084
        if (Strcmp(editor, STR("emacs")) == 0) {
1088
1085
                map_init_emacs(el);
1089
 
                return (0);
 
1086
                return 0;
1090
1087
        }
1091
 
        if (strcmp(editor, "vi") == 0) {
 
1088
        if (Strcmp(editor, STR("vi")) == 0) {
1092
1089
                map_init_vi(el);
1093
 
                return (0);
 
1090
                return 0;
1094
1091
        }
1095
 
        return (-1);
 
1092
        return -1;
1096
1093
}
1097
1094
 
1098
1095
 
1100
1097
 *      Retrieve the editor
1101
1098
 */
1102
1099
protected int
1103
 
map_get_editor(EditLine *el, const char **editor)
 
1100
map_get_editor(EditLine *el, const Char **editor)
1104
1101
{
1105
1102
 
1106
1103
        if (editor == NULL)
1107
 
                return (-1);
 
1104
                return -1;
1108
1105
        switch (el->el_map.type) {
1109
1106
        case MAP_EMACS:
1110
 
                *editor = "emacs";
1111
 
                return (0);
 
1107
                *editor = STR("emacs");
 
1108
                return 0;
1112
1109
        case MAP_VI:
1113
 
                *editor = "vi";
1114
 
                return (0);
 
1110
                *editor = STR("vi");
 
1111
                return 0;
1115
1112
        }
1116
 
        return (-1);
 
1113
        return -1;
1117
1114
}
1118
1115
 
1119
1116
 
1121
1118
 *      Print the function description for 1 key
1122
1119
 */
1123
1120
private void
1124
 
map_print_key(EditLine *el, el_action_t *map, const char *in)
 
1121
map_print_key(EditLine *el, el_action_t *map, const Char *in)
1125
1122
{
1126
1123
        char outbuf[EL_BUFSIZ];
1127
1124
        el_bindings_t *bp, *ep;
1128
1125
 
1129
1126
        if (in[0] == '\0' || in[1] == '\0') {
1130
 
                (void) key__decode_str(in, outbuf, sizeof(outbuf), "");
 
1127
                (void) keymacro__decode_str(in, outbuf, sizeof(outbuf), "");
1131
1128
                ep = &el->el_map.help[el->el_map.nfunc];
1132
1129
                for (bp = el->el_map.help; bp < ep; bp++)
1133
1130
                        if (bp->func == map[(unsigned char) *in]) {
1134
1131
                                (void) fprintf(el->el_outfile,
1135
 
                                    "%s\t->\t%s\n", outbuf, bp->name);
 
1132
                                    "%s\t->\t" FSTR "\n", outbuf, bp->name);
1136
1133
                                return;
1137
1134
                        }
1138
1135
        } else
1139
 
                key_print(el, in);
 
1136
                keymacro_print(el, in);
1140
1137
}
1141
1138
 
1142
1139
 
1144
1141
 *      Print keys from first to last
1145
1142
 */
1146
1143
private void
1147
 
map_print_some_keys(EditLine *el, el_action_t *map, int first, int last)
 
1144
map_print_some_keys(EditLine *el, el_action_t *map, Int first, Int last)
1148
1145
{
1149
1146
        el_bindings_t *bp, *ep;
1150
 
        char firstbuf[2], lastbuf[2];
 
1147
        Char firstbuf[2], lastbuf[2];
1151
1148
        char unparsbuf[EL_BUFSIZ], extrabuf[EL_BUFSIZ];
1152
1149
 
1153
1150
        firstbuf[0] = first;
1156
1153
        lastbuf[1] = 0;
1157
1154
        if (map[first] == ED_UNASSIGNED) {
1158
1155
                if (first == last) {
1159
 
                        (void) key__decode_str(firstbuf, unparsbuf, 
 
1156
                        (void) keymacro__decode_str(firstbuf, unparsbuf, 
1160
1157
                            sizeof(unparsbuf), STRQQ);
1161
1158
                        (void) fprintf(el->el_outfile,
1162
1159
                            "%-15s->  is undefined\n", unparsbuf);
1167
1164
        for (bp = el->el_map.help; bp < ep; bp++) {
1168
1165
                if (bp->func == map[first]) {
1169
1166
                        if (first == last) {
1170
 
                                (void) key__decode_str(firstbuf, unparsbuf, 
 
1167
                                (void) keymacro__decode_str(firstbuf, unparsbuf, 
1171
1168
                                    sizeof(unparsbuf), STRQQ);
1172
 
                                (void) fprintf(el->el_outfile, "%-15s->  %s\n",
 
1169
                                (void) fprintf(el->el_outfile, "%-15s->  " FSTR "\n",
1173
1170
                                    unparsbuf, bp->name);
1174
1171
                        } else {
1175
 
                                (void) key__decode_str(firstbuf, unparsbuf, 
 
1172
                                (void) keymacro__decode_str(firstbuf, unparsbuf, 
1176
1173
                                    sizeof(unparsbuf), STRQQ);
1177
 
                                (void) key__decode_str(lastbuf, extrabuf, 
 
1174
                                (void) keymacro__decode_str(lastbuf, extrabuf, 
1178
1175
                                    sizeof(extrabuf), STRQQ);
1179
1176
                                (void) fprintf(el->el_outfile,
1180
 
                                    "%-4s to %-7s->  %s\n",
 
1177
                                    "%-4s to %-7s->  " FSTR "\n",
1181
1178
                                    unparsbuf, extrabuf, bp->name);
1182
1179
                        }
1183
1180
                        return;
1185
1182
        }
1186
1183
#ifdef MAP_DEBUG
1187
1184
        if (map == el->el_map.key) {
1188
 
                (void) key__decode_str(firstbuf, unparsbuf, 
 
1185
                (void) keymacro__decode_str(firstbuf, unparsbuf, 
1189
1186
                    sizeof(unparsbuf), STRQQ);
1190
1187
                (void) fprintf(el->el_outfile,
1191
1188
                    "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1192
1189
                (void) fprintf(el->el_outfile, "el->el_map.key[%d] == %d\n",
1193
1190
                    first, el->el_map.key[first]);
1194
1191
        } else {
1195
 
                (void) key__decode_str(firstbuf, unparsbuf, 
 
1192
                (void) keymacro__decode_str(firstbuf, unparsbuf, 
1196
1193
                    sizeof(unparsbuf), STRQQ);
1197
1194
                (void) fprintf(el->el_outfile,
1198
1195
                    "BUG!!! %s isn't bound to anything.\n", unparsbuf);
1233
1230
        map_print_some_keys(el, el->el_map.alt, prev, i - 1);
1234
1231
 
1235
1232
        (void) fprintf(el->el_outfile, "Multi-character bindings\n");
1236
 
        key_print(el, "");
 
1233
        keymacro_print(el, STR(""));
1237
1234
        (void) fprintf(el->el_outfile, "Arrow key bindings\n");
1238
 
        term_print_arrow(el, "");
 
1235
        terminal_print_arrow(el, STR(""));
1239
1236
}
1240
1237
 
1241
1238
 
1243
1240
 *      Add/remove/change bindings
1244
1241
 */
1245
1242
protected int
1246
 
map_bind(EditLine *el, int argc, const char **argv)
 
1243
map_bind(EditLine *el, int argc, const Char **argv)
1247
1244
{
1248
1245
        el_action_t *map;
1249
1246
        int ntype, rem;
1250
 
        const char *p;
1251
 
        char inbuf[EL_BUFSIZ];
1252
 
        char outbuf[EL_BUFSIZ];
1253
 
        const char *in = NULL;
1254
 
        char *out = NULL;
 
1247
        const Char *p;
 
1248
        Char inbuf[EL_BUFSIZ];
 
1249
        Char outbuf[EL_BUFSIZ];
 
1250
        const Char *in = NULL;
 
1251
        Char *out = NULL;
1255
1252
        el_bindings_t *bp, *ep;
1256
1253
        int cmd;
1257
1254
        int key;
1258
1255
 
1259
1256
        if (argv == NULL)
1260
 
                return (-1);
 
1257
                return -1;
1261
1258
 
1262
1259
        map = el->el_map.key;
1263
1260
        ntype = XK_CMD;
1287
1284
 
1288
1285
                        case 'v':
1289
1286
                                map_init_vi(el);
1290
 
                                return (0);
 
1287
                                return 0;
1291
1288
 
1292
1289
                        case 'e':
1293
1290
                                map_init_emacs(el);
1294
 
                                return (0);
 
1291
                                return 0;
1295
1292
 
1296
1293
                        case 'l':
1297
1294
                                ep = &el->el_map.help[el->el_map.nfunc];
1298
1295
                                for (bp = el->el_map.help; bp < ep; bp++)
1299
1296
                                        (void) fprintf(el->el_outfile,
1300
 
                                            "%s\n\t%s\n",
 
1297
                                            "" FSTR "\n\t" FSTR "\n",
1301
1298
                                            bp->name, bp->description);
1302
 
                                return (0);
 
1299
                                return 0;
1303
1300
                        default:
1304
1301
                                (void) fprintf(el->el_errfile,
1305
 
                                    "%s: Invalid switch `%c'.\n",
 
1302
                                    "" FSTR ": Invalid switch `%c'.\n",
1306
1303
                                    argv[0], p[1]);
1307
1304
                        }
1308
1305
                else
1310
1307
 
1311
1308
        if (argv[argc] == NULL) {
1312
1309
                map_print_all_keys(el);
1313
 
                return (0);
 
1310
                return 0;
1314
1311
        }
1315
1312
        if (key)
1316
1313
                in = argv[argc++];
1317
1314
        else if ((in = parse__string(inbuf, argv[argc++])) == NULL) {
1318
1315
                (void) fprintf(el->el_errfile,
1319
 
                    "%s: Invalid \\ or ^ in instring.\n",
 
1316
                    "" FSTR ": Invalid \\ or ^ in instring.\n",
1320
1317
                    argv[0]);
1321
 
                return (-1);
 
1318
                return -1;
1322
1319
        }
1323
1320
        if (rem) {
1324
1321
                if (key) {
1325
 
                        (void) term_clear_arrow(el, in);
1326
 
                        return (-1);
 
1322
                        (void) terminal_clear_arrow(el, in);
 
1323
                        return -1;
1327
1324
                }
1328
1325
                if (in[1])
1329
 
                        (void) key_delete(el, in);
 
1326
                        (void) keymacro_delete(el, in);
1330
1327
                else if (map[(unsigned char) *in] == ED_SEQUENCE_LEAD_IN)
1331
 
                        (void) key_delete(el, in);
 
1328
                        (void) keymacro_delete(el, in);
1332
1329
                else
1333
1330
                        map[(unsigned char) *in] = ED_UNASSIGNED;
1334
 
                return (0);
 
1331
                return 0;
1335
1332
        }
1336
1333
        if (argv[argc] == NULL) {
1337
1334
                if (key)
1338
 
                        term_print_arrow(el, in);
 
1335
                        terminal_print_arrow(el, in);
1339
1336
                else
1340
1337
                        map_print_key(el, map, in);
1341
 
                return (0);
 
1338
                return 0;
1342
1339
        }
1343
1340
#ifdef notyet
1344
1341
        if (argv[argc + 1] != NULL) {
1345
 
                bindkey_usage();
1346
 
                return (-1);
 
1342
                bindkeymacro_usage();
 
1343
                return -1;
1347
1344
        }
1348
1345
#endif
1349
1346
 
1352
1349
        case XK_EXE:
1353
1350
                if ((out = parse__string(outbuf, argv[argc])) == NULL) {
1354
1351
                        (void) fprintf(el->el_errfile,
1355
 
                            "%s: Invalid \\ or ^ in outstring.\n", argv[0]);
1356
 
                        return (-1);
 
1352
                            "" FSTR ": Invalid \\ or ^ in outstring.\n", argv[0]);
 
1353
                        return -1;
1357
1354
                }
1358
1355
                if (key)
1359
 
                        term_set_arrow(el, in, key_map_str(el, out), ntype);
 
1356
                        terminal_set_arrow(el, in, keymacro_map_str(el, out), ntype);
1360
1357
                else
1361
 
                        key_add(el, in, key_map_str(el, out), ntype);
 
1358
                        keymacro_add(el, in, keymacro_map_str(el, out), ntype);
1362
1359
                map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1363
1360
                break;
1364
1361
 
1365
1362
        case XK_CMD:
1366
1363
                if ((cmd = parse_cmd(el, argv[argc])) == -1) {
1367
1364
                        (void) fprintf(el->el_errfile,
1368
 
                            "%s: Invalid command `%s'.\n", argv[0], argv[argc]);
1369
 
                        return (-1);
 
1365
                            "" FSTR ": Invalid command `" FSTR "'.\n",
 
1366
                            argv[0], argv[argc]);
 
1367
                        return -1;
1370
1368
                }
1371
1369
                if (key)
1372
 
                        term_set_arrow(el, in, key_map_str(el, out), ntype);
 
1370
                        terminal_set_arrow(el, in, keymacro_map_str(el, out), ntype);
1373
1371
                else {
1374
1372
                        if (in[1]) {
1375
 
                                key_add(el, in, key_map_cmd(el, cmd), ntype);
 
1373
                                keymacro_add(el, in, keymacro_map_cmd(el, cmd), ntype);
1376
1374
                                map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
1377
1375
                        } else {
1378
 
                                key_clear(el, map, in);
1379
 
                                map[(unsigned char) *in] = cmd;
 
1376
                                keymacro_clear(el, map, in);
 
1377
                                map[(unsigned char) *in] = (el_action_t)cmd;
1380
1378
                        }
1381
1379
                }
1382
1380
                break;
1385
1383
                EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype));
1386
1384
                break;
1387
1385
        }
1388
 
        return (0);
 
1386
        return 0;
1389
1387
}
1390
1388
 
1391
1389
 
1393
1391
 *      add a user defined function
1394
1392
 */
1395
1393
protected int
1396
 
map_addfunc(EditLine *el, const char *name, const char *help, el_func_t func)
 
1394
map_addfunc(EditLine *el, const Char *name, const Char *help, el_func_t func)
1397
1395
{
1398
1396
        void *p;
1399
 
        int nf = el->el_map.nfunc + 1;
 
1397
        size_t nf = (size_t)el->el_map.nfunc + 1;
1400
1398
 
1401
1399
        if (name == NULL || help == NULL || func == NULL)
1402
 
                return (-1);
 
1400
                return -1;
1403
1401
 
1404
 
        if ((p = el_realloc(el->el_map.func, nf * sizeof(el_func_t))) == NULL)
1405
 
                return (-1);
1406
 
        el->el_map.func = (el_func_t *) p;
1407
 
        if ((p = el_realloc(el->el_map.help, nf * sizeof(el_bindings_t)))
 
1402
        if ((p = el_realloc(el->el_map.func, nf *
 
1403
            sizeof(*el->el_map.func))) == NULL)
 
1404
                return -1;
 
1405
        el->el_map.func = p;
 
1406
        if ((p = el_realloc(el->el_map.help, nf * sizeof(*el->el_map.help)))
1408
1407
            == NULL)
1409
 
                return (-1);
1410
 
        el->el_map.help = (el_bindings_t *) p;
 
1408
                return -1;
 
1409
        el->el_map.help = p;
1411
1410
 
1412
 
        nf = el->el_map.nfunc;
 
1411
        nf = (size_t)el->el_map.nfunc;
1413
1412
        el->el_map.func[nf] = func;
1414
1413
 
1415
1414
        el->el_map.help[nf].name = name;
1416
 
        el->el_map.help[nf].func = nf;
 
1415
        el->el_map.help[nf].func = (int)nf;
1417
1416
        el->el_map.help[nf].description = help;
1418
1417
        el->el_map.nfunc++;
1419
1418
 
1420
 
        return (0);
 
1419
        return 0;
1421
1420
}