2009-01-19 Chris Allegretta <chrisa@asty.org>

        * Change funcion definitions to shorts instead of (void *)s.  New mapping function
          iso_me_harder_funcmap().  Fixes compilation complaints with -pedantic,
          reported by Eitan Adler <eitanadlerlist@gmail.com>.

git-svn-id: svn://svn.savannah.gnu.org/nano/trunk/nano@4349 35c25a1d-7b9e-4130-9fde-d3aeb78583b8

diff --git a/ChangeLog b/ChangeLog
index 03e274eb72fba4f3b6e408b43d7a8e1aaafdacd2..9252d402db75d151e02832e74119da726f0f37a8 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2009-01-19 Chris Allegretta <chrisa@asty.org>
+       * Change funcion definitions to shorts instead of (void *)s.  New mapping function
+          iso_me_harder_funcmap().  Fixes compilation complaints with -pedantic, 
+         reported by Eitan Adler <eitanadlerlist@gmail.com>.
+
 GNU nano 2.1.7 - 2008.11.10
 2008-10-20 Chris Allegretta <chrisa@asty.org>
        * files.c (do_writeout): Add check for file modification when saving

diff --git a/src/browser.c b/src/browser.c
index 407101235b0aba05e1841a9a729bc75b1bd91d7b..d7260ceafd3f99f919bb2916b4f643c99989b50d 100644 (file)
--- a/src/browser.c
+++ b/src/browser.c
@@ -156,7 +156,7 @@ char *do_browser(char *path, DIR *dir)
                         * time, put back the Enter key so that it's
                         * read in. */
                        if (old_selected == selected)
-                           unget_kbinput(sc_seq_or(do_enter, 0), FALSE, FALSE);
+                           unget_kbinput(sc_seq_or(DO_ENTER, 0), FALSE, FALSE);
                    }
        }
 #endif /* !DISABLE_MOUSE */
@@ -169,9 +169,9 @@ char *do_browser(char *path, DIR *dir)
         if (!f)
             break;
 
-       if (f->scfunc == total_refresh) {
+       if (f->scfunc == TOTAL_REFRESH) {
                total_redraw();
-       } else if (f->scfunc == do_help_void) {
+       } else if (f->scfunc == DO_HELP_VOID) {
 #ifndef DISABLE_HELP
            do_browser_help();
            curs_set(0);
@@ -179,33 +179,33 @@ char *do_browser(char *path, DIR *dir)
                nano_disabled_msg();
 #endif
            /* Search for a filename. */
-       } else if (f->scfunc == do_search) {
+       } else if (f->scfunc == DO_SEARCH) {
                curs_set(1);
                do_filesearch();
                curs_set(0);
            /* Search for another filename. */
-       } else if (f->scfunc == (void *) whereis_next_msg) {
+       } else if (f->scfunc ==  WHEREIS_NEXT_MSG) {
                do_fileresearch();
-       } else if (f->scfunc == do_page_up) {
+       } else if (f->scfunc == DO_PAGE_UP) {
                if (selected >= (editwinrows + fileline % editwinrows) *
                        width)
                    selected -= (editwinrows + fileline % editwinrows) *
                        width;
                else
                    selected = 0;
-       } else if (f->scfunc == do_page_down) {
+       } else if (f->scfunc == DO_PAGE_DOWN) {
                selected += (editwinrows - fileline % editwinrows) *
                        width;
                if (selected > filelist_len - 1)
                    selected = filelist_len - 1;
-       } else if (f->scfunc == (void *) first_file_msg) {
+       } else if (f->scfunc ==  FIRST_FILE_MSG) {
                if (meta_key)
                    selected = 0;
-       } else if (f->scfunc == (void *) last_file_msg) {
+       } else if (f->scfunc ==  LAST_FILE_MSG) {
                if (meta_key)
                    selected = filelist_len - 1;
            /* Go to a specific directory. */
-       } else if (f->scfunc == (void *) goto_dir_msg) {
+       } else if (f->scfunc ==  GOTO_DIR_MSG) {
                curs_set(1);
 
                i = do_prompt(TRUE,
@@ -238,7 +238,7 @@ char *do_browser(char *path, DIR *dir)
                     * answer in ans, so that the file list is displayed
                     * again, the prompt is displayed again, and what we
                     * typed before at the prompt is displayed again. */
-                   unget_kbinput(sc_seq_or(do_gotolinecolumn_void, 0), FALSE, FALSE);
+                   unget_kbinput(sc_seq_or(DO_GOTOLINECOLUMN_VOID, 0), FALSE, FALSE);
                    ans = mallocstrcpy(ans, answer);
                    break;
                }
@@ -285,19 +285,19 @@ char *do_browser(char *path, DIR *dir)
                free(path);
                path = new_path;
                goto change_browser_directory;
-       } else if (f->scfunc == do_up_void) {
+       } else if (f->scfunc == DO_UP_VOID) {
                if (selected >= width)
                    selected -= width;
-       } else if (f->scfunc == do_left) {
+       } else if (f->scfunc == DO_LEFT) {
                if (selected > 0)
                    selected--;
-       } else if (f->scfunc == do_down_void) {
+       } else if (f->scfunc == DO_DOWN_VOID) {
                if (selected + width <= filelist_len - 1)
                    selected += width;
-       } else if (f->scfunc == do_right) {
+       } else if (f->scfunc == DO_RIGHT) {
                if (selected < filelist_len - 1)
                    selected++;
-       } else if (f->scfunc == do_enter) {
+       } else if (f->scfunc == DO_ENTER) {
                /* We can't move up from "/". */
                if (strcmp(filelist[selected], "/..") == 0) {
                    statusbar(_("Can't move up a directory"));
@@ -355,7 +355,7 @@ char *do_browser(char *path, DIR *dir)
                /* Start over again with the new path value. */
                goto change_browser_directory;
            /* Abort the file browser. */
-       } else if (f->scfunc == do_exit) {
+       } else if (f->scfunc == DO_EXIT) {
                abort = TRUE;
        }
     }
@@ -552,32 +552,32 @@ void parse_browser_input(int *kbinput, bool *meta_key, bool *func_key)
     if (!*meta_key) {
        switch (*kbinput) {
            case ' ':
-               *kbinput = sc_seq_or(do_page_down, 0);
+               *kbinput = sc_seq_or(DO_PAGE_DOWN, 0);
                break;
            case '-':
-               *kbinput = sc_seq_or(do_page_up, 0);
+               *kbinput = sc_seq_or(DO_PAGE_UP, 0);
                break;
            case '?':
 #ifndef DISABLE_HELP
-               *kbinput = sc_seq_or(do_help_void, 0);
+               *kbinput = sc_seq_or(DO_HELP_VOID, 0);
 #endif
                break;
            /* Cancel equivalent to Exit here. */
            case 'E':
            case 'e':
-               *kbinput = sc_seq_or(do_exit, 0);
+               *kbinput = sc_seq_or(DO_EXIT, 0);
                break;
            case 'G':
            case 'g':
-               *kbinput = sc_seq_or((void *) goto_dir_msg, 0);
+               *kbinput = sc_seq_or(GOTO_DIR_MSG, 0);
                break;
            case 'S':
            case 's':
-               *kbinput = sc_seq_or(do_enter, 0);
+               *kbinput = sc_seq_or(DO_ENTER, 0);
                break;
            case 'W':
            case 'w':
-               *kbinput = sc_seq_or(do_search, 0);
+               *kbinput = sc_seq_or(DO_SEARCH, 0);
                break;
        }
     }
@@ -841,18 +841,18 @@ int filesearch_init(void)
 #endif
        } else
 #ifndef NANO_TINY
-       if (s && s->scfunc == (void *) case_sens_msg) {
+       if (s && s->scfunc == CASE_SENS_MSG) {
                TOGGLE(CASE_SENSITIVE);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;
-       } else if (s && s->scfunc == (void *) backwards_msg) {
+       } else if (s && s->scfunc == BACKWARDS_MSG) {
                TOGGLE(BACKWARDS_SEARCH);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;
        } else
 #endif
 #ifdef HAVE_REGEX_H
-       if (s && s->scfunc == (void *) regexp_msg) {
+       if (s && s->scfunc ==  REGEXP_MSG) {
                TOGGLE(USE_REGEXP);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;

diff --git a/src/files.c b/src/files.c
index 3b884ca99a5ab4cdb1c797cc113b02a1397f9667..08c7d3a42fc1d01da487495e6a03fa4c2f5ffcb9 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -780,14 +780,14 @@ void do_insertfile(
 #ifndef NANO_TINY
 #ifdef ENABLE_MULTIBUFFER
 
-           if (s && s->scfunc == (void *) new_buffer_msg) {
+           if (s && s->scfunc == NEW_BUFFER_MSG) {
                /* Don't allow toggling if we're in view mode. */
                if (!ISSET(VIEW_MODE))
                    TOGGLE(MULTIBUFFER);
                continue;
            } else
 #endif
-           if (s && s->scfunc == (void *) ext_cmd_msg) {
+           if (s && s->scfunc == EXT_CMD_MSG) {
                execute = !execute;
                continue;
            }
@@ -797,7 +797,7 @@ void do_insertfile(
 #endif /* !NANO_TINY */
 
 #ifndef DISABLE_BROWSER
-           if (s && s->scfunc == (void *) to_files_msg) {
+           if (s && s->scfunc == TO_FILES_MSG) {
                char *tmp = do_browse_from(answer);
 
                if (tmp == NULL)
@@ -1917,7 +1917,7 @@ bool do_writeout(bool exiting)
             s = get_shortcut(currmenu, &i, &meta_key, &func_key);
 
 #ifndef DISABLE_BROWSER
-           if (s && s->scfunc == (void *) to_files_msg) {
+           if (s && s->scfunc == TO_FILES_MSG) {
                char *tmp = do_browse_from(answer);
 
                if (tmp == NULL)
@@ -1929,26 +1929,26 @@ bool do_writeout(bool exiting)
            } else
 #endif /* !DISABLE_BROWSER */
 #ifndef NANO_TINY
-           if (s && s->scfunc == (void *) dos_format_msg) {
+           if (s && s->scfunc ==  DOS_FORMAT_MSG) {
                openfile->fmt = (openfile->fmt == DOS_FILE) ? NIX_FILE :
                        DOS_FILE;
                continue;
-           } else if (s && s->scfunc == (void *) mac_format_msg) {
+           } else if (s && s->scfunc ==  MAC_FORMAT_MSG) {
                openfile->fmt = (openfile->fmt == MAC_FILE) ? NIX_FILE :
                        MAC_FILE;
                continue;
-           } else if (s && s->scfunc == (void *) backup_file_msg) {
+           } else if (s && s->scfunc ==  BACKUP_FILE_MSG) {
                TOGGLE(BACKUP_FILE);
                continue;
            } else
 #endif /* !NANO_TINY */
-           if (s && s->scfunc == (void *) prepend_msg) {
+           if (s && s->scfunc ==  PREPEND_MSG) {
                append = (append == PREPEND) ? OVERWRITE : PREPEND;
                continue;
-           } else if (s && s->scfunc == (void *) append_msg) {
+           } else if (s && s->scfunc ==  APPEND_MSG) {
                append = (append == APPEND) ? OVERWRITE : APPEND;
                continue;
-           } else if (s && s->scfunc == do_help_void) {
+           } else if (s && s->scfunc == DO_HELP_VOID) {
                continue;
            }
 

diff --git a/src/global.c b/src/global.c
index b2f837e4ace248e417f60ea8cf3e71556ef49932..fabd494ee28e863e20de49416c8f7eca2f5f55e4 100644 (file)
--- a/src/global.c
+++ b/src/global.c
@@ -218,7 +218,7 @@ function_type strtokeytype(char *str)
 
 /* Add a string to the new function list strict.
    Does not allow updates, yet anyway */
-void add_to_funcs(void *func, int menus, const char *desc, const char *help,
+void add_to_funcs(short func, int menus, const char *desc, const char *help,
     bool blank_after, bool viewok)
 {
     subnfunc *f;
@@ -247,7 +247,7 @@ void add_to_funcs(void *func, int menus, const char *desc, const char *help,
 #endif
 }
 
-const sc *first_sc_for(int menu, void *func) {
+const sc *first_sc_for(int menu, short func) {
     const sc *s;
     const sc *metasc = NULL;
 
@@ -279,7 +279,7 @@ const sc *first_sc_for(int menu, void *func) {
 
 /* Add a string to the new shortcut list implementation
    Allows updates to existing entries in the list */
-void add_to_sclist(int menu, char *scstring, void *func, int toggle, int execute)
+void add_to_sclist(int menu, char *scstring, short func, int toggle, int execute)
 {
     sc *s;
 
@@ -318,7 +318,7 @@ void add_to_sclist(int menu, char *scstring, void *func, int toggle, int execute
 
 /* Return the given menu's first shortcut sequence, or the default value
   (2nd arg).  Assumes currmenu for the menu to check*/
-int sc_seq_or (void *func, int defaultval) 
+int sc_seq_or (short func, int defaultval) 
 {
     const sc *s = first_sc_for(currmenu, func);
 
@@ -642,33 +642,33 @@ void shortcut_init(bool unjustify)
         free(f);
     }
 
-    add_to_funcs(do_help_void, MALL, get_help_msg, IFSCHELP(nano_help_msg),
+    add_to_funcs(DO_HELP_VOID, MALL, get_help_msg, IFSCHELP(nano_help_msg),
        FALSE, VIEW);
 
-    add_to_funcs((void *) cancel_msg,
+    add_to_funcs( CANCEL_MSG,
        (MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MWHEREISFILE|MGOTODIR|MYESNO),
        cancel_msg, IFSCHELP(nano_cancel_msg), FALSE, VIEW);
 
-    add_to_funcs(do_exit, MMAIN,
+    add_to_funcs(DO_EXIT, MMAIN,
 #ifdef ENABLE_MULTIBUFFER
        /* TRANSLATORS: Try to keep this at most 10 characters. */
        openfile != NULL && openfile != openfile->next ? N_("Close") :
 #endif
        exit_msg, IFSCHELP(nano_exit_msg), FALSE, VIEW);
 
-    add_to_funcs(do_exit, MHELP, exit_msg, IFSCHELP(nano_exit_msg), FALSE, VIEW);
+    add_to_funcs(DO_EXIT, MHELP, exit_msg, IFSCHELP(nano_exit_msg), FALSE, VIEW);
 
 #ifndef DISABLE_BROWSER
-    add_to_funcs(do_exit, MBROWSER, exit_msg, IFSCHELP(nano_exitbrowser_msg), FALSE, VIEW);
+    add_to_funcs(DO_EXIT, MBROWSER, exit_msg, IFSCHELP(nano_exitbrowser_msg), FALSE, VIEW);
 #endif
 
     /* TRANSLATORS: Try to keep this at most 10 characters. */
-    add_to_funcs(do_writeout_void, MMAIN, N_("WriteOut"),
+    add_to_funcs(DO_WRITEOUT_VOID, MMAIN, N_("WriteOut"),
        IFSCHELP(nano_writeout_msg), FALSE, NOVIEW);
 
 #ifndef DISABLE_JUSTIFY
     /* TRANSLATORS: Try to keep this at most 10 characters. */
-    add_to_funcs(do_justify_void, MMAIN, N_("Justify"),
+    add_to_funcs(DO_JUSTIFY_VOID, MMAIN, N_("Justify"),
        nano_justify_msg, TRUE, NOVIEW);
 #endif
 
@@ -677,7 +677,7 @@ void shortcut_init(bool unjustify)
      * restricted mode, inserting files is disabled, since it allows
      * reading from or writing to files not specified on the command
      * line. */
-    add_to_funcs(!ISSET(RESTRICTED) ? do_insertfile_void : nano_disabled_msg,
+    add_to_funcs(!ISSET(RESTRICTED) ? DO_INSERTFILE_VOID : NANO_DISABLED_MSG,
        /* TRANSLATORS: Try to keep this at most 10 characters. */
        MMAIN, N_("Read File"), IFSCHELP(nano_insert_msg), FALSE,
 #ifdef ENABLE_MULTIBUFFER
@@ -686,32 +686,32 @@ void shortcut_init(bool unjustify)
        NOVIEW);
 #endif
 
-    add_to_funcs(do_search, MMAIN|MBROWSER, whereis_msg,
+    add_to_funcs(DO_SEARCH, MMAIN|MBROWSER, whereis_msg,
        IFSCHELP(nano_whereis_msg), FALSE, VIEW);
 
-    add_to_funcs(do_page_up, MMAIN|MHELP,
+    add_to_funcs(DO_PAGE_UP, MMAIN|MHELP,
        prev_page_msg, IFSCHELP(nano_prevpage_msg), FALSE, VIEW);
-    add_to_funcs(do_page_down, MMAIN|MHELP,
+    add_to_funcs(DO_PAGE_DOWN, MMAIN|MHELP,
        next_page_msg, IFSCHELP(nano_nextpage_msg), TRUE, VIEW);
 
 
     /* TRANSLATORS: Try to keep this at most 10 characters. */
-    add_to_funcs(do_cut_text_void, MMAIN, N_("Cut Text"), IFSCHELP(nano_cut_msg),
+    add_to_funcs(DO_CUT_TEXT_VOID, MMAIN, N_("Cut Text"), IFSCHELP(nano_cut_msg),
        FALSE, NOVIEW);
 
     if (unjustify)
        /* TRANSLATORS: Try to keep this at most 10 characters. */
-       add_to_funcs(do_uncut_text, MMAIN, N_("UnJustify"), "",
+       add_to_funcs(DO_UNCUT_TEXT, MMAIN, N_("UnJustify"), "",
            FALSE, NOVIEW);
 
     else
        /* TRANSLATORS: Try to keep this at most 10 characters. */
-       add_to_funcs(do_uncut_text, MMAIN, N_("UnCut Text"), IFSCHELP(nano_uncut_msg),
+       add_to_funcs(DO_UNCUT_TEXT, MMAIN, N_("UnCut Text"), IFSCHELP(nano_uncut_msg),
            FALSE, NOVIEW);
 
 #ifndef NANO_TINY
     /* TRANSLATORS: Try to keep this at most 10 characters. */
-    add_to_funcs(do_cursorpos_void, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
+    add_to_funcs(DO_CURSORPOS_VOID, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
        FALSE, VIEW);
 #endif
 
@@ -721,30 +721,30 @@ void shortcut_init(bool unjustify)
 #ifndef DISABLE_SPELLER
        if (!ISSET(RESTRICTED))
            /* TRANSLATORS: Try to keep this at most 10 characters. */
-           add_to_funcs(do_spell, MMAIN, N_("To Spell"), IFSCHELP(nano_spell_msg),
+           add_to_funcs(DO_SPELL, MMAIN, N_("To Spell"), IFSCHELP(nano_spell_msg),
                TRUE, NOVIEW);
 #endif
 
-    add_to_funcs(do_first_line,
+    add_to_funcs(DO_FIRST_LINE,
        (MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP),
        first_line_msg, IFSCHELP(nano_firstline_msg), FALSE, VIEW);
 
-    add_to_funcs(do_last_line,
+    add_to_funcs(DO_LAST_LINE,
        (MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP),
        last_line_msg, IFSCHELP(nano_lastline_msg), TRUE, VIEW);
 
 
-    add_to_funcs(do_gotolinecolumn_void, (MMAIN|MWHEREIS),
+    add_to_funcs(DO_GOTOLINECOLUMN_VOID, (MMAIN|MWHEREIS),
        go_to_line_msg, IFSCHELP(nano_gotoline_msg), FALSE, VIEW);
 
 #ifdef NANO_TINY
     /* TRANSLATORS: Try to keep this at most 10 characters. */
-    add_to_funcs(do_cursorpos_void, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
+    add_to_funcs(DO_CURSORPOS_VOID, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
        FALSE, VIEW);
 #endif
 
 
-    add_to_funcs(do_replace, (MMAIN|MWHEREIS), replace_msg, IFSCHELP(nano_replace_msg),
+    add_to_funcs(DO_REPLACE, (MMAIN|MWHEREIS), replace_msg, IFSCHELP(nano_replace_msg),
 
 #ifndef NANO_TINY
        FALSE,
@@ -755,104 +755,104 @@ void shortcut_init(bool unjustify)
 
 #ifndef NANO_TINY
 
-    add_to_funcs(do_mark, MMAIN, N_("Mark Text"), 
+    add_to_funcs(DO_MARK, MMAIN, N_("Mark Text"), 
        IFSCHELP(nano_mark_msg), FALSE, VIEW);
 
-    add_to_funcs(do_research, (MMAIN|MBROWSER), whereis_next_msg,
+    add_to_funcs(DO_RESEARCH, (MMAIN|MBROWSER), whereis_next_msg,
        IFSCHELP(nano_whereis_next_msg), TRUE, VIEW);
 
-    add_to_funcs(do_copy_text, MMAIN, N_("Copy Text"),
+    add_to_funcs(DO_COPY_TEXT, MMAIN, N_("Copy Text"),
        IFSCHELP(nano_copy_msg), FALSE, NOVIEW);
 
-    add_to_funcs(do_indent_void, MMAIN, N_("Indent Text"),
+    add_to_funcs(DO_INDENT_VOID, MMAIN, N_("Indent Text"),
        IFSCHELP(nano_indent_msg), FALSE, NOVIEW);
 
-    add_to_funcs(do_unindent, MMAIN, N_("Unindent Text"),
+    add_to_funcs(DO_UNINDENT, MMAIN, N_("Unindent Text"),
        IFSCHELP(nano_unindent_msg), FALSE, NOVIEW);
 
-    add_to_funcs(do_undo, MMAIN, N_("Undo"),
+    add_to_funcs(DO_UNDO, MMAIN, N_("Undo"),
        IFSCHELP(nano_undo_msg), FALSE, NOVIEW);
 
-    add_to_funcs(do_redo, MMAIN, N_("Redo"),
+    add_to_funcs(DO_REDO, MMAIN, N_("Redo"),
        IFSCHELP(nano_redo_msg), TRUE, NOVIEW);
 
 #endif
 
-    add_to_funcs(do_page_up, MBROWSER,
+    add_to_funcs(DO_PAGE_UP, MBROWSER,
        prev_page_msg, IFSCHELP(nano_prevpage_msg), FALSE, VIEW);
-    add_to_funcs(do_page_down, MBROWSER,
+    add_to_funcs(DO_PAGE_DOWN, MBROWSER,
        next_page_msg, IFSCHELP(nano_nextpage_msg), TRUE, VIEW);
 
 
-    add_to_funcs(do_right, (MMAIN|MBROWSER), N_("Forward"), IFSCHELP(nano_forward_msg),
+    add_to_funcs(DO_RIGHT, (MMAIN|MBROWSER), N_("Forward"), IFSCHELP(nano_forward_msg),
        FALSE, VIEW);
-    add_to_funcs(do_right, MALL, "", "", FALSE, VIEW);
+    add_to_funcs(DO_RIGHT, MALL, "", "", FALSE, VIEW);
 
-    add_to_funcs(do_left, (MMAIN|MBROWSER), N_("Back"), IFSCHELP(nano_back_msg),
+    add_to_funcs(DO_LEFT, (MMAIN|MBROWSER), N_("Back"), IFSCHELP(nano_back_msg),
        FALSE, VIEW);
-    add_to_funcs(do_left, MALL, "", "", FALSE, VIEW);
+    add_to_funcs(DO_LEFT, MALL, "", "", FALSE, VIEW);
 
 #ifndef NANO_TINY
-    add_to_funcs(do_next_word_void, MMAIN, N_("Next Word"),
+    add_to_funcs(DO_NEXT_WORD_VOID, MMAIN, N_("Next Word"),
        IFSCHELP(nano_nextword_msg), FALSE, VIEW);
 
-    add_to_funcs(do_prev_word_void, MMAIN, N_("Prev Word"),
+    add_to_funcs(DO_PREV_WORD_VOID, MMAIN, N_("Prev Word"),
        IFSCHELP(nano_prevword_msg), FALSE, VIEW);
 #endif
 
-    add_to_funcs(do_up_void, (MMAIN|MHELP|MBROWSER), N_("Prev Line"),
+    add_to_funcs(DO_UP_VOID, (MMAIN|MHELP|MBROWSER), N_("Prev Line"),
        IFSCHELP(nano_prevline_msg), FALSE, VIEW);
 
-    add_to_funcs(do_down_void, (MMAIN|MHELP|MBROWSER), N_("Next Line"),
+    add_to_funcs(DO_DOWN_VOID, (MMAIN|MHELP|MBROWSER), N_("Next Line"),
        IFSCHELP(nano_nextline_msg), TRUE, VIEW);
 
-    add_to_funcs(do_home, MMAIN, N_("Home"), IFSCHELP(nano_home_msg),
+    add_to_funcs(DO_HOME, MMAIN, N_("Home"), IFSCHELP(nano_home_msg),
        FALSE, VIEW);
 
-    add_to_funcs(do_end, MMAIN, N_("End"), IFSCHELP(nano_end_msg),
+    add_to_funcs(DO_END, MMAIN, N_("End"), IFSCHELP(nano_end_msg),
        FALSE, VIEW);
 
 #ifndef DISABLE_JUSTIFY
-    add_to_funcs(do_para_begin_void, (MMAIN|MWHEREIS), beg_of_par_msg,
+    add_to_funcs(DO_PARA_BEGIN_VOID, (MMAIN|MWHEREIS), beg_of_par_msg,
        IFSCHELP(nano_parabegin_msg), FALSE, VIEW);
 
-    add_to_funcs(do_para_end_void, (MMAIN|MWHEREIS), end_of_par_msg,
+    add_to_funcs(DO_PARA_END_VOID, (MMAIN|MWHEREIS), end_of_par_msg,
        IFSCHELP(nano_paraend_msg), FALSE, VIEW);
 #endif
 
 #ifndef NANO_TINY
-    add_to_funcs(do_find_bracket, MMAIN, _("Find Other Bracket"),
+    add_to_funcs(DO_FIND_BRACKET, MMAIN, _("Find Other Bracket"),
        IFSCHELP(nano_bracket_msg), FALSE, VIEW);
 
-    add_to_funcs(do_scroll_up, MMAIN, N_("Scroll Up"),
+    add_to_funcs(DO_SCROLL_UP, MMAIN, N_("Scroll Up"),
        IFSCHELP(nano_scrollup_msg), FALSE, VIEW);
 
-    add_to_funcs(do_scroll_down, MMAIN, N_("Scroll Down"),
+    add_to_funcs(DO_SCROLL_DOWN, MMAIN, N_("Scroll Down"),
        IFSCHELP(nano_scrolldown_msg), FALSE, VIEW);
 #endif
 
 #ifdef ENABLE_MULTIBUFFER
-    add_to_funcs(switch_to_prev_buffer_void, MMAIN, _("Previous File"),
+    add_to_funcs(SWITCH_TO_PREV_BUFFER_VOID, MMAIN, _("Previous File"),
        IFSCHELP(nano_prevfile_msg), FALSE, VIEW);
-    add_to_funcs(switch_to_next_buffer_void, MMAIN, N_("Next File"),
+    add_to_funcs(SWITCH_TO_NEXT_BUFFER_VOID, MMAIN, N_("Next File"),
        IFSCHELP(nano_nextfile_msg), TRUE, VIEW);
 #endif
 
-    add_to_funcs(do_verbatim_input, MMAIN, N_("Verbatim Input"),
+    add_to_funcs(DO_VERBATIM_INPUT, MMAIN, N_("Verbatim Input"),
        IFSCHELP(nano_verbatim_msg), FALSE, NOVIEW);
-    add_to_funcs(do_verbatim_input, MWHEREIS|MREPLACE|MREPLACE2|MEXTCMD|MSPELL,
+    add_to_funcs(DO_VERBATIM_INPUT, MWHEREIS|MREPLACE|MREPLACE2|MEXTCMD|MSPELL,
        "", "", FALSE, NOVIEW);
 
-    add_to_funcs(do_tab, MMAIN, N_("Tab"), IFSCHELP(nano_tab_msg),
+    add_to_funcs(DO_TAB, MMAIN, N_("Tab"), IFSCHELP(nano_tab_msg),
        FALSE, NOVIEW);
-    add_to_funcs(do_tab, MALL, "", "", FALSE, NOVIEW);
-    add_to_funcs(do_enter, MMAIN, N_("Enter"), IFSCHELP(nano_enter_msg),
+    add_to_funcs(DO_TAB, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(DO_ENTER, MMAIN, N_("Enter"), IFSCHELP(nano_enter_msg),
        FALSE, NOVIEW);
-    add_to_funcs(do_enter, MALL, "", "", FALSE, NOVIEW);
-    add_to_funcs(do_delete, MMAIN, N_("Delete"), IFSCHELP(nano_delete_msg),
+    add_to_funcs(DO_ENTER, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(DO_DELETE, MMAIN, N_("Delete"), IFSCHELP(nano_delete_msg),
        FALSE, NOVIEW);
-    add_to_funcs(do_delete, MALL, "", "", FALSE, NOVIEW);
-    add_to_funcs(do_backspace, MMAIN, N_("Backspace"), IFSCHELP(nano_backspace_msg),
+    add_to_funcs(DO_DELETE, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(DO_BACKSPACE, MMAIN, N_("Backspace"), IFSCHELP(nano_backspace_msg),
 #ifndef NANO_TINY
        FALSE,
 #else
@@ -860,7 +860,7 @@ void shortcut_init(bool unjustify)
 #endif
        NOVIEW);
 
-    add_to_funcs(do_backspace, MALL, "", "",
+    add_to_funcs(DO_BACKSPACE, MALL, "", "",
 #ifndef NANO_TINY
        FALSE,
 #else
@@ -869,64 +869,64 @@ void shortcut_init(bool unjustify)
        NOVIEW);
 
 #ifndef NANO_TINY
-    add_to_funcs(do_cut_till_end, MMAIN, N_("CutTillEnd"),
+    add_to_funcs(DO_CUT_TILL_END, MMAIN, N_("CutTillEnd"),
        IFSCHELP(nano_cut_till_end_msg), TRUE, NOVIEW);
 #endif
 
-    add_to_funcs(xon_complaint, MMAIN, "", "", FALSE, VIEW);
-    add_to_funcs(xoff_complaint, MMAIN, "", "", FALSE, VIEW);
+    add_to_funcs(XON_COMPLAINT, MMAIN, "", "", FALSE, VIEW);
+    add_to_funcs(XOFF_COMPLAINT, MMAIN, "", "", FALSE, VIEW);
 
 #ifndef DISABLE_JUSTIFY
-    add_to_funcs(do_full_justify, (MMAIN|MWHEREIS), fulljstify_msg,
+    add_to_funcs(DO_FULL_JUSTIFY, (MMAIN|MWHEREIS), fulljstify_msg,
        IFSCHELP(nano_fulljustify_msg), FALSE, NOVIEW);
 #endif
 
 #ifndef NANO_TINY
-    add_to_funcs(do_wordlinechar_count, MMAIN, N_("Word Count"),
+    add_to_funcs(DO_WORDLINECHAR_COUNT, MMAIN, N_("Word Count"),
        IFSCHELP(nano_wordcount_msg), FALSE, VIEW);
 #endif
 
-    add_to_funcs(total_refresh, (MMAIN|MHELP), refresh_msg, 
+    add_to_funcs(TOTAL_REFRESH, (MMAIN|MHELP), refresh_msg, 
        IFSCHELP(nano_refresh_msg), FALSE, VIEW);
 
-    add_to_funcs(do_suspend_void, MMAIN, suspend_msg,
+    add_to_funcs(DO_SUSPEND_VOID, MMAIN, suspend_msg,
        IFSCHELP(nano_suspend_msg), TRUE, VIEW);
 
 #ifndef NANO_TINY
-    add_to_funcs((void *) case_sens_msg,
+    add_to_funcs( CASE_SENS_MSG,
        (MWHEREIS|MREPLACE|MWHEREISFILE),
        case_sens_msg, IFSCHELP(nano_case_msg), FALSE, VIEW);
 
-    add_to_funcs((void *) backwards_msg,
+    add_to_funcs( BACKWARDS_MSG,
        (MWHEREIS|MREPLACE|MWHEREISFILE),
        backwards_msg, IFSCHELP(nano_reverse_msg), FALSE, VIEW);
 #endif
 
 #ifdef HAVE_REGEX_H
-    add_to_funcs((void *) regexp_msg,
+    add_to_funcs( REGEXP_MSG,
        (MWHEREIS|MREPLACE|MWHEREISFILE),
        regexp_msg, IFSCHELP(nano_regexp_msg), FALSE, VIEW);
 #endif
 
 #ifndef NANO_TINY
-    add_to_funcs((void *) prev_history_msg,
+    add_to_funcs( PREV_HISTORY_MSG,
        (MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE),
        prev_history_msg, IFSCHELP(nano_prev_history_msg), FALSE, VIEW);
 
-    add_to_funcs((void *) next_history_msg,
+    add_to_funcs( NEXT_HISTORY_MSG,
        (MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE),
        next_history_msg, IFSCHELP(nano_next_history_msg), FALSE, VIEW);
 #endif
 
-    add_to_funcs((void *) no_replace_msg, MREPLACE,
+    add_to_funcs( NO_REPLACE_MSG, MREPLACE,
        no_replace_msg, IFSCHELP(nano_whereis_msg), FALSE, VIEW);
 
-    add_to_funcs((void *) gototext_msg, MGOTOLINE,
+    add_to_funcs( GOTOTEXT_MSG, MGOTOLINE,
        gototext_msg, IFSCHELP(nano_whereis_msg), TRUE, VIEW);
 
 #ifndef DISABLE_BROWSER
     if (!ISSET(RESTRICTED))
-       add_to_funcs((void *) to_files_msg,
+       add_to_funcs( TO_FILES_MSG,
            (MGOTOLINE|MINSERTFILE),
            to_files_msg, IFSCHELP(nano_tofiles_msg), FALSE, VIEW);
 #endif
@@ -939,23 +939,23 @@ void shortcut_init(bool unjustify)
      * specified on the command line, and the fifth is useless since
      * backups are disabled. */
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) dos_format_msg, MWRITEFILE,
+        add_to_funcs( DOS_FORMAT_MSG, MWRITEFILE,
             dos_format_msg, IFSCHELP(nano_dos_msg), FALSE, NOVIEW);
 
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) mac_format_msg, MWRITEFILE,
+        add_to_funcs( MAC_FORMAT_MSG, MWRITEFILE,
             mac_format_msg, IFSCHELP(nano_mac_msg), FALSE, NOVIEW);
 
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) append_msg, MWRITEFILE,
+        add_to_funcs( APPEND_MSG, MWRITEFILE,
             append_msg, IFSCHELP(nano_append_msg), FALSE, NOVIEW);
 
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) prepend_msg, MWRITEFILE,
+        add_to_funcs( PREPEND_MSG, MWRITEFILE,
             prepend_msg, IFSCHELP(nano_prepend_msg), FALSE, NOVIEW);
 
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) backup_file_msg, MWRITEFILE,
+        add_to_funcs( BACKUP_FILE_MSG, MWRITEFILE,
             backup_file_msg, IFSCHELP(nano_backup_msg), FALSE, NOVIEW);
 #endif
 
@@ -963,219 +963,219 @@ void shortcut_init(bool unjustify)
     /* If we're using restricted mode, command execution is disabled.
      * It's useless since inserting files is disabled. */
     if (!ISSET(RESTRICTED))
-        add_to_funcs((void *) ext_cmd_msg, MINSERTFILE,
+        add_to_funcs( EXT_CMD_MSG, MINSERTFILE,
            ext_cmd_msg, IFSCHELP(nano_execute_msg), FALSE, NOVIEW);
 
 #ifdef ENABLE_MULTIBUFFER
     /* If we're using restricted mode, the multibuffer toggle is
      * disabled.  It's useless since inserting files is disabled. */
     if (!ISSET(RESTRICTED))
-       add_to_funcs((void *) new_buffer_msg, MINSERTFILE,
+       add_to_funcs( NEW_BUFFER_MSG, MINSERTFILE,
        new_buffer_msg, IFSCHELP(nano_multibuffer_msg), FALSE, NOVIEW);
 #endif
 
-    add_to_funcs((void *)  insert_file_msg, MEXTCMD,
+    add_to_funcs(  INSERT_FILE_MSG, MEXTCMD,
        insert_file_msg, IFSCHELP(nano_insert_msg), FALSE, VIEW);
 
 #ifdef ENABLE_MULTIBUFFER
-     add_to_funcs((void *) new_buffer_msg, MEXTCMD,
+     add_to_funcs( NEW_BUFFER_MSG, MEXTCMD,
        new_buffer_msg, IFSCHELP(nano_multibuffer_msg), FALSE, NOVIEW);
 #endif
 #endif
 
 #ifndef DISABLE_HELP
-    add_to_funcs((void *) refresh_msg, MHELP,
+    add_to_funcs( REFRESH_MSG, MHELP,
        refresh_msg, nano_refresh_msg, FALSE, VIEW);
 #endif
 
 #ifndef DISABLE_BROWSER
 
-    add_to_funcs((void *) first_file_msg,
+    add_to_funcs( FIRST_FILE_MSG,
        (MBROWSER|MWHEREISFILE),
        first_file_msg, IFSCHELP(nano_firstfile_msg), FALSE, VIEW);
 
-    add_to_funcs((void *) last_file_msg,
+    add_to_funcs( LAST_FILE_MSG,
        (MBROWSER|MWHEREISFILE),
        last_file_msg, IFSCHELP(nano_lastfile_msg), FALSE, VIEW);
 
-    add_to_funcs((void *) goto_dir_msg, MBROWSER,
+    add_to_funcs( GOTO_DIR_MSG, MBROWSER,
        goto_dir_msg, IFSCHELP(nano_gotodir_msg), FALSE, VIEW);
 #endif
 
     currmenu = MMAIN;
 
-    add_to_sclist(MALL, "^G", do_help_void, 0, TRUE);
-    add_to_sclist(MALL, "F1", do_help_void, 0, TRUE);
-    add_to_sclist(MMAIN|MHELP|MBROWSER, "^X", do_exit, 0, TRUE);
-    add_to_sclist(MMAIN|MHELP|MBROWSER, "F2", do_exit, 0, TRUE);
-    add_to_sclist(MMAIN, "^_", do_gotolinecolumn_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F13", do_gotolinecolumn_void, 0, TRUE);
-    add_to_sclist(MMAIN, "^O", do_writeout_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F3", do_writeout_void, 0, TRUE);
+    add_to_sclist(MALL, "^G", DO_HELP_VOID, 0, TRUE);
+    add_to_sclist(MALL, "F1", DO_HELP_VOID, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "^X", DO_EXIT, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "F2", DO_EXIT, 0, TRUE);
+    add_to_sclist(MMAIN, "^_", DO_GOTOLINECOLUMN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F13", DO_GOTOLINECOLUMN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "^O", DO_WRITEOUT_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F3", DO_WRITEOUT_VOID, 0, TRUE);
 #ifndef DISABLE_JUSTIFY
-    add_to_sclist(MMAIN, "^J", do_justify_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F4", do_justify_void, 0, TRUE);
-#endif
-    add_to_sclist(MMAIN, "^R", do_insertfile_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F5", do_insertfile_void, 0, TRUE);
-    add_to_sclist(MMAIN, "kinsert", do_insertfile_void, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER, "^W", do_search, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER, "F6", do_search, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^Y", do_page_up, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F7", do_page_up, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpup", do_page_up, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^V", do_page_down, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F8", do_page_down, 0, TRUE);
-    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpdown", do_page_down, 0, TRUE);
-    add_to_sclist(MMAIN, "^K", do_cut_text_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F9", do_cut_text_void, 0, TRUE);
-    add_to_sclist(MMAIN, "^U", do_uncut_text, 0, TRUE);
-    add_to_sclist(MMAIN, "F10", do_uncut_text, 0, TRUE);
-    add_to_sclist(MMAIN, "^C", do_cursorpos_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F11", do_cursorpos_void, 0, TRUE);
+    add_to_sclist(MMAIN, "^J", DO_JUSTIFY_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F4", DO_JUSTIFY_VOID, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "^R", DO_INSERTFILE_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F5", DO_INSERTFILE_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "kinsert", DO_INSERTFILE_VOID, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "^W", DO_SEARCH, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "F6", DO_SEARCH, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^Y", DO_PAGE_UP, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F7", DO_PAGE_UP, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpup", DO_PAGE_UP, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^V", DO_PAGE_DOWN, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F8", DO_PAGE_DOWN, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpdown", DO_PAGE_DOWN, 0, TRUE);
+    add_to_sclist(MMAIN, "^K", DO_CUT_TEXT_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F9", DO_CUT_TEXT_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "^U", DO_UNCUT_TEXT, 0, TRUE);
+    add_to_sclist(MMAIN, "F10", DO_UNCUT_TEXT, 0, TRUE);
+    add_to_sclist(MMAIN, "^C", DO_CURSORPOS_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F11", DO_CURSORPOS_VOID, 0, TRUE);
 #ifndef DISABLE_SPELLER
-    add_to_sclist(MMAIN, "^T", do_spell, 0, TRUE);
-    add_to_sclist(MMAIN, "F12", do_spell, 0, TRUE);
-#endif
-    add_to_sclist(MMAIN, "^_", do_gotolinecolumn_void, 0, TRUE);
-    add_to_sclist(MMAIN, "F13", do_gotolinecolumn_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M-G", do_gotolinecolumn_void, 0, TRUE);
-    add_to_sclist(MMAIN, "^\\", do_replace, 0, TRUE);
-    add_to_sclist(MMAIN, "F14", do_replace, 0, TRUE);
-    add_to_sclist(MMAIN, "M-R", do_replace, 0, TRUE);
-    add_to_sclist(MWHEREIS, "^R", do_replace, 0, FALSE);
-    add_to_sclist(MREPLACE, "^R", (void *) no_replace_msg, 0, FALSE);
-    add_to_sclist(MWHEREIS, "^T", do_gotolinecolumn_void, 0, FALSE);
+    add_to_sclist(MMAIN, "^T", DO_SPELL, 0, TRUE);
+    add_to_sclist(MMAIN, "F12", DO_SPELL, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "^_", DO_GOTOLINECOLUMN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "F13", DO_GOTOLINECOLUMN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M-G", DO_GOTOLINECOLUMN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "^\\", DO_REPLACE, 0, TRUE);
+    add_to_sclist(MMAIN, "F14", DO_REPLACE, 0, TRUE);
+    add_to_sclist(MMAIN, "M-R", DO_REPLACE, 0, TRUE);
+    add_to_sclist(MWHEREIS, "^R", DO_REPLACE, 0, FALSE);
+    add_to_sclist(MREPLACE, "^R", NO_REPLACE_MSG, 0, FALSE);
+    add_to_sclist(MWHEREIS, "^T", DO_GOTOLINECOLUMN_VOID, 0, FALSE);
 #ifndef NANO_TINY
-    add_to_sclist(MMAIN, "^^", do_mark, 0, TRUE);
-    add_to_sclist(MMAIN, "F15", do_mark, 0, TRUE);
-    add_to_sclist(MMAIN, "M-A", do_mark, 0, TRUE);
-    add_to_sclist(MALL, "M-W", do_research, 0, TRUE);
-    add_to_sclist(MALL, "F16", do_research, 0, TRUE);
-    add_to_sclist(MMAIN, "M-^", do_copy_text, 0, TRUE);
-    add_to_sclist(MMAIN, "M-6", do_copy_text, 0, TRUE);
-    add_to_sclist(MMAIN, "M-}", do_indent_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M-{", do_unindent, 0, TRUE);
-    add_to_sclist(MMAIN, "M-U", do_undo, 0, TRUE);
-    add_to_sclist(MMAIN, "M-E", do_redo, 0, TRUE);
-    add_to_sclist(MALL, "^F", do_right, 0, TRUE);
-    add_to_sclist(MALL, "^B", do_left, 0, TRUE);
-    add_to_sclist(MMAIN, "^Space", do_next_word_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M-Space", do_prev_word_void, 0, TRUE);
-#endif
-    add_to_sclist(MALL, "kright", do_right, 0, TRUE);
-    add_to_sclist(MALL, "kleft", do_left, 0, TRUE);
-    add_to_sclist(MMAIN, "^Q", xon_complaint, 0, TRUE);
-    add_to_sclist(MMAIN, "^S", xoff_complaint, 0, TRUE);
-    add_to_sclist(MMAIN, "^P", do_up_void, 0, TRUE);
-    add_to_sclist(MMAIN, "kup", do_up_void, 0, TRUE);
-    add_to_sclist(MMAIN, "^N", do_down_void, 0, TRUE);
-    add_to_sclist(MMAIN, "kdown", do_down_void, 0, TRUE);
-    add_to_sclist(MALL, "^A", do_home, 0, TRUE);
-    add_to_sclist(MALL, "khome", do_home, 0, TRUE);
-    add_to_sclist(MALL, "^E", do_end, 0, TRUE);
-    add_to_sclist(MALL, "kend", do_end, 0, TRUE);
+    add_to_sclist(MMAIN, "^^", DO_MARK, 0, TRUE);
+    add_to_sclist(MMAIN, "F15", DO_MARK, 0, TRUE);
+    add_to_sclist(MMAIN, "M-A", DO_MARK, 0, TRUE);
+    add_to_sclist(MALL, "M-W", DO_RESEARCH, 0, TRUE);
+    add_to_sclist(MALL, "F16", DO_RESEARCH, 0, TRUE);
+    add_to_sclist(MMAIN, "M-^", DO_COPY_TEXT, 0, TRUE);
+    add_to_sclist(MMAIN, "M-6", DO_COPY_TEXT, 0, TRUE);
+    add_to_sclist(MMAIN, "M-}", DO_INDENT_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M-{", DO_UNINDENT, 0, TRUE);
+    add_to_sclist(MMAIN, "M-U", DO_UNDO, 0, TRUE);
+    add_to_sclist(MMAIN, "M-E", DO_REDO, 0, TRUE);
+    add_to_sclist(MALL, "^F", DO_RIGHT, 0, TRUE);
+    add_to_sclist(MALL, "^B", DO_LEFT, 0, TRUE);
+    add_to_sclist(MMAIN, "^Space", DO_NEXT_WORD_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M-Space", DO_PREV_WORD_VOID, 0, TRUE);
+#endif
+    add_to_sclist(MALL, "kright", DO_RIGHT, 0, TRUE);
+    add_to_sclist(MALL, "kleft", DO_LEFT, 0, TRUE);
+    add_to_sclist(MMAIN, "^Q", XON_COMPLAINT, 0, TRUE);
+    add_to_sclist(MMAIN, "^S", XOFF_COMPLAINT, 0, TRUE);
+    add_to_sclist(MMAIN, "^P", DO_UP_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "kup", DO_UP_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "^N", DO_DOWN_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "kdown", DO_DOWN_VOID, 0, TRUE);
+    add_to_sclist(MALL, "^A", DO_HOME, 0, TRUE);
+    add_to_sclist(MALL, "khome", DO_HOME, 0, TRUE);
+    add_to_sclist(MALL, "^E", DO_END, 0, TRUE);
+    add_to_sclist(MALL, "kend", DO_END, 0, TRUE);
 #ifndef NANO_TINY
-    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^P", (void *) prev_history_msg, 0, FALSE);
-    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kup", (void *) prev_history_msg, 0, FALSE);
-    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^N", (void *) next_history_msg, 0, FALSE);
-    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kdown", (void *) next_history_msg, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^P",  PREV_HISTORY_MSG, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kup",  PREV_HISTORY_MSG, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^N",  NEXT_HISTORY_MSG, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kdown",  NEXT_HISTORY_MSG, 0, FALSE);
 #endif
 #ifndef DISABLE_JUSTIFY
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
-       "^W", do_para_begin_void, 0, TRUE);
+       "^W", DO_PARA_BEGIN_VOID, 0, TRUE);
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
-       "^O", do_para_end_void, 0, TRUE);
-    add_to_sclist(MALL, "M-(", do_para_begin_void, 0, TRUE);
-    add_to_sclist(MALL, "M-9", do_para_begin_void, 0, TRUE);
-    add_to_sclist(MALL, "M-)", do_para_end_void, 0, TRUE);
-    add_to_sclist(MALL, "M-0", do_para_end_void, 0, TRUE);
+       "^O", DO_PARA_END_VOID, 0, TRUE);
+    add_to_sclist(MALL, "M-(", DO_PARA_BEGIN_VOID, 0, TRUE);
+    add_to_sclist(MALL, "M-9", DO_PARA_BEGIN_VOID, 0, TRUE);
+    add_to_sclist(MALL, "M-)", DO_PARA_END_VOID, 0, TRUE);
+    add_to_sclist(MALL, "M-0", DO_PARA_END_VOID, 0, TRUE);
 #endif
     add_to_sclist(MWHEREIS,
-       "M-C", (void *) case_sens_msg, 0, FALSE);
+       "M-C", CASE_SENS_MSG, 0, FALSE);
     add_to_sclist(MREPLACE,
-       "M-C", (void *) case_sens_msg, 0, FALSE);
+       "M-C", CASE_SENS_MSG, 0, FALSE);
     add_to_sclist(MREPLACE2,
-       "M-C", (void *) case_sens_msg, 0, FALSE);
+       "M-C", CASE_SENS_MSG, 0, FALSE);
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
-       "M-B", (void *) backwards_msg, 0, FALSE);
+       "M-B", BACKWARDS_MSG, 0, FALSE);
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
-       "M-R", (void *) regexp_msg, 0, FALSE);
+       "M-R", REGEXP_MSG, 0, FALSE);
 
-    add_to_sclist(MMAIN, "M-\\", do_first_line, 0, TRUE);
-    add_to_sclist(MMAIN, "M-|", do_first_line, 0, TRUE);
-    add_to_sclist(MMAIN, "M-/", do_last_line, 0, TRUE);
-    add_to_sclist(MMAIN, "M-?", do_last_line, 0, TRUE);
+    add_to_sclist(MMAIN, "M-\\", DO_FIRST_LINE, 0, TRUE);
+    add_to_sclist(MMAIN, "M-|", DO_FIRST_LINE, 0, TRUE);
+    add_to_sclist(MMAIN, "M-/", DO_LAST_LINE, 0, TRUE);
+    add_to_sclist(MMAIN, "M-?", DO_LAST_LINE, 0, TRUE);
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP,
-       "^Y", do_first_line, 0, TRUE);
+       "^Y", DO_FIRST_LINE, 0, TRUE);
     add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP,
-       "^V", do_last_line, 0, TRUE);
+       "^V", DO_LAST_LINE, 0, TRUE);
 
-    add_to_sclist(MBROWSER|MWHEREISFILE, "M-\\", (void *) first_file_msg, 0, TRUE);
-    add_to_sclist(MBROWSER|MWHEREISFILE, "M-|", (void *) first_file_msg, 0, TRUE);
-    add_to_sclist(MBROWSER|MWHEREISFILE, "M-/", (void *) last_file_msg, 0, TRUE);
-    add_to_sclist(MBROWSER|MWHEREISFILE, "M-?", (void *) last_file_msg, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-\\",  FIRST_FILE_MSG, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-|",  FIRST_FILE_MSG, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-/",  LAST_FILE_MSG, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-?",  LAST_FILE_MSG, 0, TRUE);
 #ifndef NANO_TINY
-    add_to_sclist(MMAIN, "M-]", do_find_bracket, 0, TRUE);
-    add_to_sclist(MMAIN, "M--", do_scroll_up, 0, TRUE);
-    add_to_sclist(MMAIN, "M-_", do_scroll_up, 0, TRUE);
-    add_to_sclist(MMAIN, "M-+", do_scroll_down, 0, TRUE);
-    add_to_sclist(MMAIN, "M-=", do_scroll_down, 0, TRUE);
+    add_to_sclist(MMAIN, "M-]", DO_FIND_BRACKET, 0, TRUE);
+    add_to_sclist(MMAIN, "M--", DO_SCROLL_UP, 0, TRUE);
+    add_to_sclist(MMAIN, "M-_", DO_SCROLL_UP, 0, TRUE);
+    add_to_sclist(MMAIN, "M-+", DO_SCROLL_DOWN, 0, TRUE);
+    add_to_sclist(MMAIN, "M-=", DO_SCROLL_DOWN, 0, TRUE);
 #endif
 
 #ifdef ENABLE_MULTIBUFFER
-    add_to_sclist(MMAIN, "M-<", switch_to_prev_buffer_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M-,", switch_to_prev_buffer_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M->", switch_to_next_buffer_void, 0, TRUE);
-    add_to_sclist(MMAIN, "M-.", switch_to_next_buffer_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-<", SWITCH_TO_PREV_BUFFER_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M-,", SWITCH_TO_PREV_BUFFER_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M->", SWITCH_TO_NEXT_BUFFER_VOID, 0, TRUE);
+    add_to_sclist(MMAIN, "M-.", SWITCH_TO_NEXT_BUFFER_VOID, 0, TRUE);
 #endif
-    add_to_sclist(MALL, "M-V", do_verbatim_input, 0, TRUE);
+    add_to_sclist(MALL, "M-V", DO_VERBATIM_INPUT, 0, TRUE);
 #ifndef NANO_TINY
-    add_to_sclist(MALL, "M-T", do_cut_till_end, 0, TRUE);
+    add_to_sclist(MALL, "M-T", DO_CUT_TILL_END, 0, TRUE);
 #ifndef DISABLE_JUSTIFY
-    add_to_sclist(MALL, "M-J", do_full_justify, 0, TRUE);
-#endif
-    add_to_sclist(MMAIN, "M-D", do_wordlinechar_count, 0, TRUE);
-    add_to_sclist(MMAIN, "M-X", do_toggle, NO_HELP, TRUE);
-    add_to_sclist(MMAIN, "M-C", do_toggle, CONST_UPDATE, TRUE);
-    add_to_sclist(MMAIN, "M-O", do_toggle, MORE_SPACE, TRUE);
-    add_to_sclist(MMAIN, "M-S", do_toggle, SMOOTH_SCROLL, TRUE);
-    add_to_sclist(MMAIN, "M-P", do_toggle, WHITESPACE_DISPLAY, TRUE);
-    add_to_sclist(MMAIN, "M-Y", do_toggle, NO_COLOR_SYNTAX, TRUE);
-    add_to_sclist(MMAIN, "M-H", do_toggle, SMART_HOME, TRUE);
-    add_to_sclist(MMAIN, "M-I", do_toggle, AUTOINDENT, TRUE);
-    add_to_sclist(MMAIN, "M-K", do_toggle, CUT_TO_END, TRUE);
-    add_to_sclist(MMAIN, "M-L", do_toggle, NO_WRAP, TRUE);
-    add_to_sclist(MMAIN, "M-Q", do_toggle, TABS_TO_SPACES, TRUE);
-    add_to_sclist(MMAIN, "M-B", do_toggle, BACKUP_FILE, TRUE);
-    add_to_sclist(MMAIN, "M-F", do_toggle, MULTIBUFFER, TRUE);
-    add_to_sclist(MMAIN, "M-M", do_toggle, USE_MOUSE, TRUE);
-    add_to_sclist(MMAIN, "M-N", do_toggle, NO_CONVERT, TRUE);
-    add_to_sclist(MMAIN, "M-Z", do_toggle, SUSPEND, TRUE);
-#endif
-    add_to_sclist(MGOTOLINE, "^T", (void *) gototext_msg, 0, FALSE);
-    add_to_sclist(MINSERTFILE|MEXTCMD, "M-F", (void *) new_buffer_msg, 0, FALSE);
+    add_to_sclist(MALL, "M-J", DO_FULL_JUSTIFY, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "M-D", DO_WORDLINECHAR_COUNT, 0, TRUE);
+    add_to_sclist(MMAIN, "M-X", DO_TOGGLE, NO_HELP, TRUE);
+    add_to_sclist(MMAIN, "M-C", DO_TOGGLE, CONST_UPDATE, TRUE);
+    add_to_sclist(MMAIN, "M-O", DO_TOGGLE, MORE_SPACE, TRUE);
+    add_to_sclist(MMAIN, "M-S", DO_TOGGLE, SMOOTH_SCROLL, TRUE);
+    add_to_sclist(MMAIN, "M-P", DO_TOGGLE, WHITESPACE_DISPLAY, TRUE);
+    add_to_sclist(MMAIN, "M-Y", DO_TOGGLE, NO_COLOR_SYNTAX, TRUE);
+    add_to_sclist(MMAIN, "M-H", DO_TOGGLE, SMART_HOME, TRUE);
+    add_to_sclist(MMAIN, "M-I", DO_TOGGLE, AUTOINDENT, TRUE);
+    add_to_sclist(MMAIN, "M-K", DO_TOGGLE, CUT_TO_END, TRUE);
+    add_to_sclist(MMAIN, "M-L", DO_TOGGLE, NO_WRAP, TRUE);
+    add_to_sclist(MMAIN, "M-Q", DO_TOGGLE, TABS_TO_SPACES, TRUE);
+    add_to_sclist(MMAIN, "M-B", DO_TOGGLE, BACKUP_FILE, TRUE);
+    add_to_sclist(MMAIN, "M-F", DO_TOGGLE, MULTIBUFFER, TRUE);
+    add_to_sclist(MMAIN, "M-M", DO_TOGGLE, USE_MOUSE, TRUE);
+    add_to_sclist(MMAIN, "M-N", DO_TOGGLE, NO_CONVERT, TRUE);
+    add_to_sclist(MMAIN, "M-Z", DO_TOGGLE, SUSPEND, TRUE);
+#endif
+    add_to_sclist(MGOTOLINE, "^T",  GOTOTEXT_MSG, 0, FALSE);
+    add_to_sclist(MINSERTFILE|MEXTCMD, "M-F",  NEW_BUFFER_MSG, 0, FALSE);
     add_to_sclist((MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MWHEREISFILE|MGOTODIR|MYESNO),
-       "^C", (void *) cancel_msg, 0, FALSE);
-    add_to_sclist(MHELP, "^X", do_exit, 0, TRUE);
-    add_to_sclist(MHELP, "F2", do_exit, 0, TRUE);
-    add_to_sclist(MWRITEFILE, "M-D", (void *) dos_format_msg, 0, FALSE);
-    add_to_sclist(MWRITEFILE, "M-M", (void *) mac_format_msg, 0, FALSE);
-    add_to_sclist(MWRITEFILE, "M-A", (void *) append_msg, 0, FALSE);
-    add_to_sclist(MWRITEFILE, "M-P", (void *) prepend_msg, 0, FALSE);
-    add_to_sclist(MWRITEFILE, "M-B", (void *) backup_file_msg, 0, FALSE);
-    add_to_sclist(MWRITEFILE, "^T", (void *) to_files_msg, 0, FALSE);
-    add_to_sclist(MINSERTFILE, "^T", (void *) to_files_msg, 0, FALSE);
-    add_to_sclist(MINSERTFILE, "^X", (void *) ext_cmd_msg, 0, FALSE);
-    add_to_sclist(MMAIN, "^Z", do_suspend_void, 0, FALSE);
-    add_to_sclist(MMAIN, "^L", total_refresh, 0, TRUE);
-    add_to_sclist(MALL, "^I", do_tab, 0, TRUE);
-    add_to_sclist(MALL, "^M", do_enter, 0, TRUE);
-    add_to_sclist(MALL, "kenter", do_enter, 0, TRUE);
-    add_to_sclist(MALL, "^D", do_delete, 0, TRUE);
-    add_to_sclist(MALL, "kdel", do_delete, 0, TRUE);
-    add_to_sclist(MALL, "^H", do_backspace, 0, TRUE);
-    add_to_sclist(MALL, "kbsp", do_backspace, 0, TRUE);
+       "^C", CANCEL_MSG, 0, FALSE);
+    add_to_sclist(MHELP, "^X", DO_EXIT, 0, TRUE);
+    add_to_sclist(MHELP, "F2", DO_EXIT, 0, TRUE);
+    add_to_sclist(MWRITEFILE, "M-D",  DOS_FORMAT_MSG, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-M",  MAC_FORMAT_MSG, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-A",  APPEND_MSG, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-P",  PREPEND_MSG, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-B",  BACKUP_FILE_MSG, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "^T",  TO_FILES_MSG, 0, FALSE);
+    add_to_sclist(MINSERTFILE, "^T",  TO_FILES_MSG, 0, FALSE);
+    add_to_sclist(MINSERTFILE, "^X",  EXT_CMD_MSG, 0, FALSE);
+    add_to_sclist(MMAIN, "^Z", DO_SUSPEND_VOID, 0, FALSE);
+    add_to_sclist(MMAIN, "^L", TOTAL_REFRESH, 0, TRUE);
+    add_to_sclist(MALL, "^I", DO_TAB, 0, TRUE);
+    add_to_sclist(MALL, "^M", DO_ENTER, 0, TRUE);
+    add_to_sclist(MALL, "kenter", DO_ENTER, 0, TRUE);
+    add_to_sclist(MALL, "^D", DO_DELETE, 0, TRUE);
+    add_to_sclist(MALL, "kdel", DO_DELETE, 0, TRUE);
+    add_to_sclist(MALL, "^H", DO_BACKSPACE, 0, TRUE);
+    add_to_sclist(MALL, "kbsp", DO_BACKSPACE, 0, TRUE);
 
 #ifdef DEBUG
     print_sclist();
@@ -1183,6 +1183,119 @@ void shortcut_init(bool unjustify)
 
 }
 
+/* Given a function alias, execute the proper
+   function, and then me */
+void iso_me_harder_funcmap(short func)
+{
+    if (func == TOTAL_REFRESH)
+       total_refresh();
+    else if (func == DO_HELP_VOID)
+       do_help_void();
+    else if (func == DO_SEARCH)
+       do_search();
+    else if (func == DO_PAGE_UP)
+       do_page_up();
+    else if (func == DO_PAGE_DOWN)
+       do_page_down();
+    else if (func == DO_UP_VOID)
+       do_up_void();
+    else if (func == DO_LEFT)
+       do_left();
+    else if (func == DO_DOWN_VOID)
+       do_down_void();
+    else if (func == DO_RIGHT)
+       do_right();
+    else if (func == DO_ENTER)
+       do_enter();
+    else if (func == DO_EXIT)
+       do_exit();
+    else if (func == DO_FIRST_LINE)
+       do_first_line();
+    else if (func == DO_LAST_LINE)
+       do_last_line();
+    else if (func == DO_BACKSPACE)
+       do_backspace();
+    else if (func == DO_DELETE)
+       do_delete();
+    else if (func == DO_TAB)
+       do_tab();
+    else if (func == DO_VERBATIM_INPUT)
+       do_verbatim_input();
+    else if (func == SWITCH_TO_NEXT_BUFFER_VOID)
+       switch_to_next_buffer_void();
+    else if (func == SWITCH_TO_PREV_BUFFER_VOID)
+       switch_to_prev_buffer_void();
+    else if (func == DO_END)
+       do_end();
+    else if (func == DO_HOME)
+       do_home();
+    else if (func == DO_REDO)
+       do_redo();
+    else if (func == DO_UNDO)
+       do_undo();
+    else if (func == DO_WORDLINECHAR_COUNT)
+       do_wordlinechar_count();
+    else if (func == DO_FIND_BRACKET)
+       do_find_bracket();
+    else if (func == DO_PREV_WORD_VOID)
+       do_prev_word_void();
+    else if (func == DO_SUSPEND_VOID)
+       do_suspend_void();
+    else if (func == DO_WRITEOUT_VOID)
+       do_writeout_void();
+    else if (func == DO_INSERTFILE_VOID)
+       do_insertfile_void();
+    else if (func == DO_CUT_TEXT_VOID)
+       do_cut_text_void();
+    else if (func == DO_UNCUT_TEXT)
+       do_uncut_text();
+    else if (func == DO_CURSORPOS_VOID)
+       do_cursorpos_void();
+    else if (func == DO_GOTOLINECOLUMN_VOID)
+       do_gotolinecolumn_void();
+    else if (func == DO_REPLACE)
+       do_replace();
+    else if (func == DO_JUSTIFY_VOID)
+       do_justify_void();
+    else if (func == DO_PARA_BEGIN_VOID)
+       do_para_begin_void();
+    else if (func == DO_PARA_END_VOID)
+       do_para_end_void();
+    else if (func == DO_FULL_JUSTIFY)
+       do_full_justify();
+    else if (func == DO_MARK)
+       do_mark();
+    else if (func == DO_RESEARCH)
+       do_research();
+    else if (func == DO_COPY_TEXT)
+       do_copy_text();
+    else if (func == DO_INDENT_VOID)
+       do_indent_void();
+    else if (func == DO_UNINDENT)
+       do_unindent();
+    else if (func == DO_SCROLL_UP)
+       do_scroll_up();
+    else if (func == DO_SCROLL_DOWN)
+       do_scroll_down();
+    else if (func == DO_NEXT_WORD_VOID)
+       do_next_word_void();
+    else if (func == DO_CUT_TILL_END)
+       do_cut_till_end();
+    else if (func == XOFF_COMPLAINT)
+       xoff_complaint();
+    else if (func == XON_COMPLAINT)
+       xon_complaint();
+    else if (func == DO_SPELL)
+       do_spell();
+    else if (func == DO_CUT_TEXT)
+       do_cut_text_void();
+    else if (func == DO_NEXT_WORD)
+       do_next_word_void();
+    else if (func == DO_PREV_WORD)
+       do_prev_word_void();
+}
+
+
 /* Free the given shortcut. */
 void free_shortcutage(shortcut **shortcutage)
 {
@@ -1261,234 +1374,234 @@ sc *strtosc(int menu, char *input)
 
 #ifndef DISABLE_HELP
     if (!strcasecmp(input, "help"))
-       s->scfunc = do_help_void;
+       s->scfunc = DO_HELP_VOID;
     else 
 #endif
     if (!strcasecmp(input, "cancel")) {
-       s->scfunc = (void *) cancel_msg;
+       s->scfunc =  CANCEL_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "exit"))
-       s->scfunc = do_exit;
+       s->scfunc = DO_EXIT;
     else if (!strcasecmp(input, "writeout"))
-       s->scfunc = do_writeout_void;
+       s->scfunc = DO_WRITEOUT_VOID;
     else if (!strcasecmp(input, "insert"))
-       s->scfunc = do_insertfile_void;
+       s->scfunc = DO_INSERTFILE_VOID;
     else if (!strcasecmp(input, "whereis"))
-       s->scfunc = do_search;
+       s->scfunc = DO_SEARCH;
     else if (!strcasecmp(input, "up"))
-       s->scfunc = do_up_void;
+       s->scfunc = DO_UP_VOID;
     else if (!strcasecmp(input, "down"))
-       s->scfunc = do_down_void;
+       s->scfunc = DO_DOWN_VOID;
     else if (!strcasecmp(input, "pageup")
        || !strcasecmp(input, "prevpage"))
-       s->scfunc = do_page_up;
+       s->scfunc = DO_PAGE_UP;
     else if (!strcasecmp(input, "pagedown")
        || !strcasecmp(input, "nextpage"))
-       s->scfunc = do_page_down;
+       s->scfunc = DO_PAGE_DOWN;
     else if (!strcasecmp(input, "cut"))
-       s->scfunc = do_cut_text_void;
+       s->scfunc = DO_CUT_TEXT_VOID;
     else if (!strcasecmp(input, "uncut"))
-       s->scfunc = do_uncut_text;
+       s->scfunc = DO_UNCUT_TEXT;
     else if (!strcasecmp(input, "curpos") ||
        !strcasecmp(input, "cursorpos"))
-       s->scfunc = do_cursorpos_void;
+       s->scfunc = DO_CURSORPOS_VOID;
     else if (!strcasecmp(input, "firstline"))
-       s->scfunc = do_first_line;
+       s->scfunc = DO_FIRST_LINE;
     else if (!strcasecmp(input, "lastline"))
-       s->scfunc = do_last_line;
+       s->scfunc = DO_LAST_LINE;
     else if (!strcasecmp(input, "gotoline"))
-       s->scfunc = do_gotolinecolumn_void;
+       s->scfunc = DO_GOTOLINECOLUMN_VOID;
     else if (!strcasecmp(input, "replace"))
-       s->scfunc = do_replace;
+       s->scfunc = DO_REPLACE;
 #ifndef DISABLE_JUSTIFY
     else if (!strcasecmp(input, "justify"))
-       s->scfunc = do_justify_void;
+       s->scfunc = DO_JUSTIFY_VOID;
     else if (!strcasecmp(input, "beginpara"))
-       s->scfunc = do_para_begin_void;
+       s->scfunc = DO_PARA_BEGIN_VOID;
     else if (!strcasecmp(input, "endpara"))
-       s->scfunc = do_para_end_void;
+       s->scfunc = DO_PARA_END_VOID;
     else if (!strcasecmp(input, "fulljustify"))
-       s->scfunc = do_full_justify;
+       s->scfunc = DO_FULL_JUSTIFY;
 #endif
 #ifndef NANO_TINY
     else if (!strcasecmp(input, "mark"))
-       s->scfunc = do_mark;
+       s->scfunc = DO_MARK;
     else if (!strcasecmp(input, "searchagain") ||
                !strcasecmp(input, "research"))
-       s->scfunc = do_research;
+       s->scfunc = DO_RESEARCH;
     else if (!strcasecmp(input, "copytext"))
-       s->scfunc = do_copy_text;
+       s->scfunc = DO_COPY_TEXT;
     else if (!strcasecmp(input, "indent"))
-       s->scfunc = do_indent_void;
+       s->scfunc = DO_INDENT_VOID;
     else if (!strcasecmp(input, "unindent"))
-       s->scfunc = do_unindent;
+       s->scfunc = DO_UNINDENT;
     else if (!strcasecmp(input, "scrollup"))
-       s->scfunc = do_scroll_up;
+       s->scfunc = DO_SCROLL_UP;
     else if (!strcasecmp(input, "scrolldown"))
-       s->scfunc = do_scroll_down;
+       s->scfunc = DO_SCROLL_DOWN;
     else if (!strcasecmp(input, "nextword"))
-       s->scfunc = do_next_word_void;
+       s->scfunc = DO_NEXT_WORD_VOID;
     else if (!strcasecmp(input, "suspend"))
-       s->scfunc = do_suspend_void;
+       s->scfunc = DO_SUSPEND_VOID;
     else if (!strcasecmp(input, "prevword"))
-       s->scfunc = do_prev_word_void;
+       s->scfunc = DO_PREV_WORD_VOID;
     else if (!strcasecmp(input, "findbracket"))
-       s->scfunc = do_find_bracket;
+       s->scfunc = DO_FIND_BRACKET;
     else if (!strcasecmp(input, "wordcount"))
-       s->scfunc = do_wordlinechar_count;
+       s->scfunc = DO_WORDLINECHAR_COUNT;
     else if (!strcasecmp(input, "undo"))
-       s->scfunc = do_undo;
+       s->scfunc = DO_UNDO;
     else if (!strcasecmp(input, "redo"))
-       s->scfunc = do_redo;
+       s->scfunc = DO_REDO;
     else if (!strcasecmp(input, "prevhistory")) {
-       s->scfunc = (void *) prev_history_msg;
+       s->scfunc =  PREV_HISTORY_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "nexthistory")) {
-       s->scfunc = (void *) next_history_msg;
+       s->scfunc =  NEXT_HISTORY_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "nohelp") ||
                !strcasecmp(input, "nohelp")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = NO_HELP;
     } else if (!strcasecmp(input, "constupdate")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = CONST_UPDATE;
     } else if (!strcasecmp(input, "morespace")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = MORE_SPACE;
     } else if (!strcasecmp(input, "smoothscroll")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = SMOOTH_SCROLL;
     } else if (!strcasecmp(input, "whitespacedisplay")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = WHITESPACE_DISPLAY;
     } else if (!strcasecmp(input, "nosyntax")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = NO_COLOR_SYNTAX;
     } else if (!strcasecmp(input, "smarthome")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = SMART_HOME;
     } else if (!strcasecmp(input, "autoindent")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = AUTOINDENT;
     } else if (!strcasecmp(input, "cuttoend")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = CUT_TO_END;
     } else if (!strcasecmp(input, "nowrap")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = NO_WRAP;
     } else if (!strcasecmp(input, "tabstospaces")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = TABS_TO_SPACES;
     } else if (!strcasecmp(input, "backupfile")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = BACKUP_FILE;
     } else if (!strcasecmp(input, "mutlibuffer")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = MULTIBUFFER;
     } else if (!strcasecmp(input, "mouse")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = USE_MOUSE;
     } else if (!strcasecmp(input, "noconvert")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = NO_CONVERT;
     } else if (!strcasecmp(input, "suspendenable")) {
-       s->scfunc = (void *) do_toggle;
+       s->scfunc =  DO_TOGGLE;
        s->execute = FALSE;
        s->toggle = SUSPEND;
     }
 #endif /* NANO_TINY */
     else if (!strcasecmp(input, "right") ||
                !strcasecmp(input, "forward"))
-       s->scfunc = do_right;
+       s->scfunc = DO_RIGHT;
     else if (!strcasecmp(input, "left") ||
                !strcasecmp(input, "back"))
-       s->scfunc = do_left;
+       s->scfunc = DO_LEFT;
     else if (!strcasecmp(input, "up") ||
                !strcasecmp(input, "prevline"))
-       s->scfunc = do_up_void;
+       s->scfunc = DO_UP_VOID;
     else if (!strcasecmp(input, "down") ||
                !strcasecmp(input, "nextline"))
-       s->scfunc = do_down_void;
+       s->scfunc = DO_DOWN_VOID;
     else if (!strcasecmp(input, "home"))
-       s->scfunc = do_home;
+       s->scfunc = DO_HOME;
     else if (!strcasecmp(input, "end"))
-       s->scfunc = do_end;
+       s->scfunc = DO_END;
 #ifdef ENABLE_MULTIBUFFER
     else if (!strcasecmp(input, "prevbuf"))
-       s->scfunc = switch_to_prev_buffer_void;
+       s->scfunc = SWITCH_TO_PREV_BUFFER_VOID;
     else if (!strcasecmp(input, "nextbuf"))
-       s->scfunc = switch_to_next_buffer_void;
+       s->scfunc = SWITCH_TO_NEXT_BUFFER_VOID;
 #endif
     else if (!strcasecmp(input, "verbatim"))
-       s->scfunc = do_verbatim_input;
+       s->scfunc = DO_VERBATIM_INPUT;
     else if (!strcasecmp(input, "tab"))
-       s->scfunc = do_tab;
+       s->scfunc = DO_TAB;
     else if (!strcasecmp(input, "enter"))
-       s->scfunc = do_enter;
+       s->scfunc = DO_ENTER;
     else if (!strcasecmp(input, "delete"))
-       s->scfunc = do_delete;
+       s->scfunc = DO_DELETE;
     else if (!strcasecmp(input, "backspace"))
-       s->scfunc = do_backspace;
+       s->scfunc = DO_BACKSPACE;
     else if (!strcasecmp(input, "refresh"))
-       s->scfunc = total_refresh;
+       s->scfunc = TOTAL_REFRESH;
     else if (!strcasecmp(input, "casesens")) {
-       s->scfunc = (void *) case_sens_msg;
+       s->scfunc =  CASE_SENS_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "regexp") ||
                !strcasecmp(input, "regex")) {
-       s->scfunc = (void *) regexp_msg;
+       s->scfunc =  REGEXP_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "dontreplace")) {
-       s->scfunc = (void *) no_replace_msg;
+       s->scfunc =  NO_REPLACE_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "gototext")) {
-       s->scfunc = (void *) gototext_msg;
+       s->scfunc =  GOTOTEXT_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "browser") ||
                !strcasecmp(input, "tofiles")) {
-       s->scfunc = (void *) to_files_msg;
+       s->scfunc =  TO_FILES_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "dosformat")) {
-       s->scfunc = (void *) dos_format_msg;
+       s->scfunc =  DOS_FORMAT_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "macformat")) {
-       s->scfunc = (void *) mac_format_msg;
+       s->scfunc =  MAC_FORMAT_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "append")) {
-       s->scfunc = (void *) append_msg;
+       s->scfunc =  APPEND_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "prepend")) {
-       s->scfunc = (void *) prepend_msg;
+       s->scfunc =  PREPEND_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "backup")) {
-       s->scfunc = (void *) backup_file_msg;
+       s->scfunc =  BACKUP_FILE_MSG;
        s->execute = FALSE;
 #ifdef ENABLE_MULTIBUFFER
     } else if (!strcasecmp(input, "newbuffer")) {
-       s->scfunc = (void *) new_buffer_msg;
+       s->scfunc =  NEW_BUFFER_MSG;
        s->execute = FALSE;
 #endif
     } else if (!strcasecmp(input, "firstfile")) {
-       s->scfunc = (void *) first_file_msg;
+       s->scfunc =  FIRST_FILE_MSG;
        s->execute = FALSE;
     } else if (!strcasecmp(input, "lastfile")) {
-       s->scfunc = (void *) last_file_msg;
+       s->scfunc =  LAST_FILE_MSG;
        s->execute = FALSE;
     } else {
        free(s);

diff --git a/src/help.c b/src/help.c
index f1f03979a838b74b480c0845fd76c3b242a3af37..d3912291ea17026132ca4f2c0f7fcdecc95ab695 100644 (file)
--- a/src/help.c
+++ b/src/help.c
@@ -145,35 +145,35 @@ void do_help(void (*refresh_func)(void))
        if (!f)
            continue;
 
-         if (f->scfunc == total_refresh) {
+         if (f->scfunc == TOTAL_REFRESH) {
                total_redraw();
                break;
-       } else if (f->scfunc == do_page_up) {
+       } else if (f->scfunc == DO_PAGE_UP) {
                if (line > editwinrows - 2)
                    line -= editwinrows - 2;
                else
                    line = 0;
-       } else if (f->scfunc == do_page_down) {
+       } else if (f->scfunc == DO_PAGE_DOWN) {
                if (line + (editwinrows - 1) < last_line)
                    line += editwinrows - 2;
-       } else if (f->scfunc == do_up_void) {
+       } else if (f->scfunc == DO_UP_VOID) {
                if (line > 0)
                    line--;
-       } else if (f->scfunc == do_down_void) {
+       } else if (f->scfunc == DO_DOWN_VOID) {
                if (line + (editwinrows - 1) < last_line)
                    line++;
-       } else if (f->scfunc == do_first_line) {
+       } else if (f->scfunc == DO_FIRST_LINE) {
                if (meta_key)
                    line = 0;
                break;
-       } else if (f->scfunc == do_last_line) {
+       } else if (f->scfunc == DO_LAST_LINE) {
                if (meta_key) {
                    if (line + (editwinrows - 1) < last_line)
                        line = last_line - (editwinrows - 1);
                }
                break;
            /* Abort the help browser. */
-       } else if (f->scfunc == do_exit) {
+       } else if (f->scfunc == DO_EXIT) {
                abort = TRUE;
                break;
        }
@@ -407,7 +407,7 @@ void help_init(void)
        size_t endis_len = strlen(_("enable/disable"));
 
        for (s = sclist; s != NULL; s = s->next)
-            if (s->scfunc == (void *) do_toggle)
+            if (s->scfunc ==  DO_TOGGLE)
                allocsize += strlen(_(flagtostr(s->toggle))) + endis_len + 9;
 
     }
@@ -478,7 +478,7 @@ void help_init(void)
     /* And the toggles... */
     if (currmenu == MMAIN)
         for (s = sclist; s != NULL; s = s->next)
-            if (s->scfunc == (void *) do_toggle)
+            if (s->scfunc ==  DO_TOGGLE)
                ptr += sprintf(ptr, "(%s)\t\t\t%s %s\n",
                    s->keystr, _(flagtostr(s->toggle)), _("enable/disable"));
 
@@ -507,15 +507,15 @@ void parse_help_input(int *kbinput, bool *meta_key, bool *func_key)
        switch (*kbinput) {
            /* For consistency with the file browser. */
            case ' ':
-               *kbinput = sc_seq_or(do_page_up, 0);
+               *kbinput = sc_seq_or(DO_PAGE_UP, 0);
                break;
            case '-':
-               *kbinput = sc_seq_or(do_page_down, 0);;
+               *kbinput = sc_seq_or(DO_PAGE_DOWN, 0);;
                break;
            /* Cancel is equivalent to Exit here. */
            case 'E':
            case 'e':
-               *kbinput = sc_seq_or(do_exit, 0);;
+               *kbinput = sc_seq_or(DO_EXIT, 0);;
                break;
        }
     }

diff --git a/src/nano.c b/src/nano.c
index 0a017dd64cfba5404758a766a0ebc94de9589aaa..8fa7f8eb7261766f183083e95349e330de8ebaaf 100644 (file)
--- a/src/nano.c
+++ b/src/nano.c
@@ -67,6 +67,11 @@ filestruct *make_new_node(filestruct *prevnode)
     newnode->next = NULL;
     newnode->lineno = (prevnode != NULL) ? prevnode->lineno + 1 : 1;
 
+#ifdef ENABLE_COLOR
+    newnode->colors = NULL;
+    newnode->colorclean = FALSE;
+#endif
+
     return newnode;
 }
 
@@ -1453,7 +1458,7 @@ int do_input(bool *meta_key, bool *func_key, bool *s_or_t, bool
             * for verbatim input, turn off prepending of wrapped
             * text. */
            if (have_shortcut && (!have_shortcut || s == NULL || s->scfunc !=
-               do_verbatim_input))
+               DO_VERBATIM_INPUT))
                wrap_reset();
 #endif
 
@@ -1488,26 +1493,26 @@ int do_input(bool *meta_key, bool *func_key, bool *s_or_t, bool
                default:
                    /* If the function associated with this shortcut is
                     * cutting or copying text, indicate this. */
-                   if (s->scfunc == do_cut_text_void
+                   if (s->scfunc == DO_CUT_TEXT_VOID
 #ifndef NANO_TINY
-                       || s->scfunc == do_copy_text || s->scfunc ==
-                       do_cut_till_end
+                       || s->scfunc == DO_COPY_TEXT || s->scfunc ==
+                       DO_CUT_TILL_END
 #endif
                        )
                        cut_copy = TRUE;
 
-                   if (s->scfunc != NULL) {
+                   if (s->scfunc != 0) {
                        const subnfunc *f = sctofunc((sc *) s);
                        *ran_func = TRUE;
                        if (ISSET(VIEW_MODE) && f && !f->viewok)
                            print_view_warning();
                        else
 #ifndef NANO_TINY
-                           if (s->scfunc == (void *) do_toggle)
+                           if (s->scfunc ==  DO_TOGGLE)
                                do_toggle(s->toggle);
                            else
 #endif
-                               s->scfunc();
+                               iso_me_harder_funcmap(s->scfunc);
                    }
                    *finished = TRUE;
                    break;

diff --git a/src/nano.h b/src/nano.h
index 04f00232d8d5392b08a15734f6a283343315290e..7accb1045d1cd6fd9d64cf127bdf6485505e0013 100644 (file)
--- a/src/nano.h
+++ b/src/nano.h
@@ -173,36 +173,6 @@ typedef enum {
     ADD, DEL, REPLACE, SPLIT, UNSPLIT, CUT, UNCUT, INSERT, OTHER
 } undo_type;
 
-/* Structure types. */
-typedef struct filestruct {
-    char *data;
-       /* The text of this line. */
-    ssize_t lineno;
-       /* The number of this line. */
-    struct filestruct *next;
-       /* Next node. */
-    struct filestruct *prev;
-       /* Previous node. */
-} filestruct;
-
-typedef struct partition {
-    filestruct *fileage;
-       /* The top line of this portion of the file. */
-    filestruct *top_prev;
-       /* The line before the top line of this portion of the file. */
-    char *top_data;
-       /* The text before the beginning of the top line of this portion
-        * of the file. */
-    filestruct *filebot;
-       /* The bottom line of this portion of the file. */
-    filestruct *bot_next;
-       /* The line after the bottom line of this portion of the
-        * file. */
-    char *bot_data;
-       /* The text after the end of the bottom line of this portion of
-        * the file. */
-} partition;
-
 #ifdef ENABLE_COLOR
 typedef struct colortype {
     short fg;
@@ -251,6 +221,41 @@ typedef struct syntaxtype {
 } syntaxtype;
 #endif /* ENABLE_COLOR */
 
+
+/* Structure types. */
+typedef struct filestruct {
+    char *data;
+       /* The text of this line. */
+    ssize_t lineno;
+       /* The number of this line. */
+    struct filestruct *next;
+       /* Next node. */
+    struct filestruct *prev;
+       /* Previous node. */
+#ifdef ENABLE_COLOR
+    colortype **colors;                /* Will be a series of pointers to the colorstrings we're painting */
+    bool colorclean;           /* Did we do something to the line which necessitates recalculating the colors */
+#endif
+} filestruct;
+
+typedef struct partition {
+    filestruct *fileage;
+       /* The top line of this portion of the file. */
+    filestruct *top_prev;
+       /* The line before the top line of this portion of the file. */
+    char *top_data;
+       /* The text before the beginning of the top line of this portion
+        * of the file. */
+    filestruct *filebot;
+       /* The bottom line of this portion of the file. */
+    filestruct *bot_next;
+       /* The line after the bottom line of this portion of the
+        * file. */
+    char *bot_data;
+       /* The text after the end of the bottom line of this portion of
+        * the file. */
+} partition;
+
 #ifndef NANO_TINY
 typedef struct undo {
     ssize_t lineno;
@@ -380,7 +385,7 @@ typedef struct sc {
         /* The actual sequence to check on the the type is determined */
     int menu;
         /* What list does this apply to */
-    void (*scfunc)(void);
+    short scfunc;
         /* The function we're going to run */
     int toggle;
         /* If a toggle, what we're toggling */
@@ -392,7 +397,7 @@ typedef struct sc {
 } sc;
 
 typedef struct subnfunc {
-   void (*scfunc)(void);
+    short scfunc;
        /* What function is this */
     int menus;
        /* In what menus does this function applu */
@@ -696,6 +701,164 @@ typedef struct subnfunc {
 #define UNDO_DEL_DEL           (1<<0)
 #define UNDO_DEL_BACKSPACE     (1<<1)
 
+/* Since in ISO C you can't pass around function pointers anymore,
+  let's make some integer macros for function names, and then I
+  can go cut my wrists after writing the big switch statement
+  that will necessitate. */
+
+#define CASE_SENS_MSG 1
+#define BACKWARDS_MSG 2
+#define REGEXP_MSG 3
+#define WHEREIS_NEXT_MSG 4
+#define FIRST_FILE_MSG 5
+#define LAST_FILE_MSG 6
+#define GOTO_DIR_MSG 7
+#define TOTAL_REFRESH 8
+#define DO_HELP_VOID 9
+#define DO_SEARCH 10
+#define DO_PAGE_UP 11
+#define DO_PAGE_DOWN 12
+#define DO_UP_VOID 13
+#define DO_LEFT 14
+#define DO_DOWN_VOID 15
+#define DO_RIGHT 16
+#define DO_ENTER 17
+#define DO_EXIT 18
+#define NEW_BUFFER_MSG 19
+#define EXT_CMD_MSG 20
+#define TO_FILES_MSG 21
+#define DOS_FORMAT_MSG 23
+#define MAC_FORMAT_MSG 24
+#define BACKUP_FILE_MSG 25
+#define PREPEND_MSG 26
+#define APPEND_MSG 27
+#define DO_FIRST_LINE 28
+#define DO_LAST_LINE 29
+#define DO_TOGGLE 30
+#define GOTOTEXT_MSG 31
+#define NO_REPLACE_MSG 32
+#define DO_BACKSPACE 33
+#define DO_DELETE 34
+#define DO_TAB 35
+#define DO_VERBATIM_INPUT 36
+#define SWITCH_TO_NEXT_BUFFER_VOID 37
+#define SWITCH_TO_PREV_BUFFER_VOID 38
+#define DO_END 39
+#define DO_HOME 40
+#define NEXT_HISTORY_MSG 41
+#define PREV_HISTORY_MSG 42
+#define DO_REDO 43
+#define DO_UNDO 44
+#define DO_WORDLINECHAR_COUNT 45
+#define DO_FIND_BRACKET 46
+#define DO_PREV_WORD_VOID 47
+#define DO_SUSPEND_VOID 48
+#define CANCEL_MSG 49
+#define DO_WRITEOUT_VOID 50
+#define DO_INSERTFILE_VOID 51
+#define DO_CUT_TEXT_VOID 52
+#define DO_UNCUT_TEXT 53
+#define DO_CURSORPOS_VOID 54
+#define DO_GOTOLINECOLUMN_VOID 55
+#define DO_REPLACE 56
+#define DO_JUSTIFY_VOID 57
+#define DO_PARA_BEGIN_VOID 58
+#define DO_PARA_END_VOID 59
+#define DO_FULL_JUSTIFY 60
+#define DO_MARK 61
+#define DO_RESEARCH 62
+#define DO_COPY_TEXT 63
+#define DO_INDENT_VOID 64
+#define DO_UNINDENT 65
+#define DO_SCROLL_UP 66
+#define DO_SCROLL_DOWN 67
+#define DO_NEXT_WORD_VOID 68
+#define DO_CUT_TILL_END 69
+#define NANO_GOTODIR_MSG 70
+#define NANO_LASTFILE_MSG 71
+#define NANO_FIRSTFILE_MSG 72
+#define INSERT_FILE_MSG 73
+#define NANO_MULTIBUFFER_MSG 74
+#define NANO_EXECUTE_MSG 75
+#define NANO_BACKUP_MSG 76
+#define NANO_PREPEND_MSG 77
+#define NANO_APPEND_MSG 78
+#define NANO_MAC_MSG 79
+#define NANO_DOS_MSG 80
+#define NANO_TOFILES_MSG 81
+#define NANO_NEXT_HISTORY_MSG 82
+#define NANO_PREV_HISTORY_MSG 83
+#define NANO_REGEXP_MSG 84
+#define NANO_REVERSE_MSG 85
+#define NANO_CASE_MSG 86
+#define NANO_SUSPEND_MSG 87
+#define SUSPEND_MSG 88
+#define NANO_REFRESH_MSG 89
+#define REFRESH_MSG 90
+#define NANO_WORDCOUNT_MSG 91
+#define NANO_FULLJUSTIFY_MSG 92
+#define FULLJSTIFY_MSG 93
+#define XOFF_COMPLAINT 94
+#define XON_COMPLAINT 95
+#define NANO_CUT_TILL_END_MSG 96
+#define NANO_BACKSPACE_MSG 97
+#define NANO_DELETE_MSG 98
+#define NANO_ENTER_MSG 99
+#define NANO_TAB_MSG 100
+#define NANO_VERBATIM_MSG 101
+#define NANO_NEXTFILE_MSG 102
+#define NANO_PREVFILE_MSG 103
+#define NANO_SCROLLDOWN_MSG 104
+#define NANO_SCROLLUP_MSG 105
+#define NANO_BRACKET_MSG 106
+#define NANO_PARAEND_MSG 107
+#define END_OF_PAR_MSG 108
+#define NANO_PARABEGIN_MSG 109
+#define BEG_OF_PAR_MSG 110
+#define NANO_END_MSG 111
+#define NANO_HOME_MSG 112
+#define NANO_NEXTLINE_MSG 113
+#define NANO_PREVLINE_MSG 114
+#define NANO_PREVWORD_MSG 115
+#define NANO_NEXTWORD_MSG 116
+#define NANO_BACK_MSG 117
+#define NANO_FORWARD_MSG 118
+#define NANO_REDO_MSG 119
+#define NANO_UNDO_MSG 120
+#define NANO_UNINDENT_MSG 121
+#define NANO_INDENT_MSG 122
+#define NANO_COPY_MSG 123
+#define NANO_WHEREIS_NEXT_MSG 124
+#define NANO_MARK_MSG 125
+#define NANO_REPLACE_MSG 126
+#define REPLACE_MSG 127
+#define NANO_GOTOLINE_MSG 128
+#define NANO_LASTLINE_MSG 129
+#define NANO_FIRSTLINE_MSG 130
+#define NANO_SPELL_MSG 131
+#define DO_SPELL 132
+#define NANO_CURSORPOS_MSG 133
+#define NANO_UNCUT_MSG 134
+#define GET_HELP_MSG 135
+#define NANO_HELP_MSG 136
+#define NANO_CANCEL_MSG 137
+#define NANO_EXIT_MSG 138
+#define EXIT_MSG 139
+#define NANO_EXITBROWSER_MSG 140
+#define NANO_WRITEOUT_MSG 141
+#define NANO_DISABLED_MSG 142
+#define NANO_INSERT_MSG 143
+#define WHEREIS_MSG 144
+#define NANO_WHEREIS_MSG 145
+#define NANO_PREVPAGE_MSG 146
+#define NANO_NEXTPAGE_MSG 147
+#define NANO_CUT_MSG 148
+#define DO_CUT_TEXT 149
+#define DO_NEXT_WORD 150
+#define DO_PREV_WORD 151
+
+
+
 #endif /* !NANO_TINY */
 
 #define VIEW TRUE

diff --git a/src/prompt.c b/src/prompt.c
index 30ee75ef20b12c907e9f9a416c01e84d0ec6c429..24e5c25b6fff37a731e986e494a56be9648567c3 100644 (file)
--- a/src/prompt.c
+++ b/src/prompt.c
@@ -152,38 +152,38 @@ int do_statusbar_input(bool *meta_key, bool *func_key, bool *have_shortcut,
        }
 
        if (*have_shortcut) {
-           if (s->scfunc == do_tab || s->scfunc == do_enter)
+           if (s->scfunc == DO_TAB || s->scfunc == DO_ENTER)
                ;
-           else if (s->scfunc == total_refresh)
+           else if (s->scfunc == TOTAL_REFRESH)
                total_statusbar_refresh(refresh_func);
-            else if (s->scfunc == (void *) do_cut_text) {
+            else if (s->scfunc ==  DO_CUT_TEXT) {
                /* If we're using restricted mode, the filename
                 * isn't blank, and we're at the "Write File"
                 * prompt, disable Cut. */
                if (!ISSET(RESTRICTED) || openfile->filename[0] ==
                        '\0' || currmenu != MWRITEFILE)
                    do_statusbar_cut_text();
-           } else if (s->scfunc == do_right)
+           } else if (s->scfunc == DO_RIGHT)
                do_statusbar_right();
-           else if (s->scfunc == do_left)
+           else if (s->scfunc == DO_LEFT)
                do_statusbar_left();
 
 #ifndef NANO_TINY
-           else if (s->scfunc == (void *) do_next_word)
+           else if (s->scfunc ==  DO_NEXT_WORD)
                do_statusbar_next_word(FALSE);
-           else if (s->scfunc == (void *) do_prev_word)
+           else if (s->scfunc ==  DO_PREV_WORD)
                    do_statusbar_prev_word(FALSE);
 #endif
-           else if (s->scfunc == do_home)
+           else if (s->scfunc == DO_HOME)
                    do_statusbar_home();
-           else if (s->scfunc == do_end)
+           else if (s->scfunc == DO_END)
                    do_statusbar_end();
 
 #ifndef NANO_TINY
-           else if (s->scfunc == do_find_bracket)
+           else if (s->scfunc == DO_FIND_BRACKET)
                do_statusbar_find_bracket();
 #endif
-           else if (s->scfunc == do_verbatim_input) {
+           else if (s->scfunc == DO_VERBATIM_INPUT) {
                    /* If we're using restricted mode, the filename
                     * isn't blank, and we're at the "Write File"
                     * prompt, disable verbatim input. */
@@ -201,18 +201,18 @@ int do_statusbar_input(bool *meta_key, bool *func_key, bool *have_shortcut,
                             * to indicate that we're done. */
                            if (got_enter) {
                                get_input(NULL, 1);
-                               input = sc_seq_or(do_enter, 0);
+                               input = sc_seq_or(DO_ENTER, 0);
                                *finished = TRUE;
                            }
                    }
-           } else if (s->scfunc == do_delete) {
+           } else if (s->scfunc == DO_DELETE) {
                /* If we're using restricted mode, the filename
                 * isn't blank, and we're at the "Write File"
                 * prompt, disable Delete. */
                if (!ISSET(RESTRICTED) || openfile->filename[0] ==
                        '\0' || currmenu != MWRITEFILE)
                    do_statusbar_delete();
-           } else if (s->scfunc == do_backspace) {
+           } else if (s->scfunc == DO_BACKSPACE) {
                /* If we're using restricted mode, the filename
                 * isn't blank, and we're at the "Write File"
                 * prompt, disable Backspace. */
@@ -227,10 +227,10 @@ int do_statusbar_input(bool *meta_key, bool *func_key, bool *have_shortcut,
             * associated functions. */
 
                f = sctofunc((sc *) s);
-               if (s->scfunc != NULL &&  s->execute == TRUE) {
+               if (s->scfunc != 0 &&  s->execute == TRUE) {
                        *ran_func = TRUE;
                    if (!ISSET(VIEW_MODE) || f->viewok)
-                       f->scfunc();
+                       iso_me_harder_funcmap(f->scfunc);
                }
                *finished = TRUE;
            }
@@ -979,19 +979,19 @@ fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %d\n", answer
        s = get_shortcut(currmenu, &kbinput, meta_key, func_key);
 
        if (s)
-           if (s->scfunc == (void *) cancel_msg || s->scfunc == do_enter)
+           if (s->scfunc ==  CANCEL_MSG || s->scfunc == DO_ENTER)
                break;
 
 #ifndef DISABLE_TABCOMP
-       if (s && s->scfunc != do_tab)
+       if (s && s->scfunc != DO_TAB)
            tabbed = FALSE;
 #endif
 
 #ifndef DISABLE_TABCOMP
 #ifndef NANO_TINY
-       if (s && s->scfunc == do_tab) {
+       if (s && s->scfunc == DO_TAB) {
                if (history_list != NULL) {
-                   if (last_kbinput != sc_seq_or(do_tab, NANO_CONTROL_I))
+                   if (last_kbinput != sc_seq_or(DO_TAB, NANO_CONTROL_I))
                        complete_len = strlen(answer);
 
                    if (complete_len > 0) {
@@ -1010,7 +1010,7 @@ fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %d\n", answer
        } else 
 #endif /* !DISABLE_TABCOMP */
 #ifndef NANO_TINY
-       if (s && s->scfunc == (void *) prev_history_msg) {
+       if (s && s->scfunc ==  PREV_HISTORY_MSG) {
                if (history_list != NULL) {
                    /* If we're scrolling up at the bottom of the
                     * history list and answer isn't blank, save answer
@@ -1038,7 +1038,7 @@ fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %d\n", answer
                     * statusbar prompt. */
                    finished = FALSE;
                }
-       } else if (s && s->scfunc == (void *) next_history_msg) {
+       } else if (s && s->scfunc ==  NEXT_HISTORY_MSG) {
                if (history_list != NULL) {
                    /* Get the newer search from the history list and
                     * save it in answer.  If there is no newer search,
@@ -1071,7 +1071,7 @@ fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %d\n", answer
        } else
 #endif /* !NANO_TINY */
 #ifndef DISABLE_HELP
-       if (s && s->scfunc == do_help_void) {
+       if (s && s->scfunc == DO_HELP_VOID) {
                update_statusbar_line(answer, statusbar_x);
 
                /* This key has a shortcut list entry when it's used to
@@ -1116,7 +1116,7 @@ fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %d\n", answer
      * we've finished putting in an answer, reset the statusbar cursor
      * position too. */
     if (s) {
-       if (s->scfunc == (void *) cancel_msg || s->scfunc == do_enter ||
+       if (s->scfunc ==  CANCEL_MSG || s->scfunc == DO_ENTER ||
        ran_func) {
            statusbar_x = old_statusbar_x;
            statusbar_pww = old_pww;
@@ -1203,9 +1203,9 @@ int do_prompt(bool allow_tabs,
 
     /* If we left the prompt via Cancel or Enter, set the return value
      * properly. */
-    if (s && s->scfunc == (void *) cancel_msg)
+    if (s && s->scfunc ==  CANCEL_MSG)
        retval = -1;
-    else if (s && s->scfunc == do_enter)
+    else if (s && s->scfunc == DO_ENTER)
        retval = (*answer == '\0') ? -2 : 0;
 
     blank_statusbar();
@@ -1313,7 +1313,7 @@ int do_yesno_prompt(bool all, const char *msg)
        kbinput = get_kbinput(bottomwin, &meta_key, &func_key);
        s = get_shortcut(currmenu, &kbinput, &meta_key, &func_key);
 
-       if (s && s->scfunc == (void *) cancel_msg)
+       if (s && s->scfunc ==  CANCEL_MSG)
            ok = -1;
 #ifndef DISABLE_MOUSE
        else if (kbinput == KEY_MOUSE) {
@@ -1345,7 +1345,7 @@ int do_yesno_prompt(bool all, const char *msg)
                }
        }
 #endif /* !DISABLE_MOUSE */
-       else if  (s && s->scfunc == total_refresh) {
+       else if  (s && s->scfunc == TOTAL_REFRESH) {
            total_redraw();
            continue;
        } else {

diff --git a/src/proto.h b/src/proto.h
index 731e8cf0f7f874c8ed1299de79725416c5e9ced5..5a8d611dce1901223cecd1d3d82b6af4b562cd2a 100644 (file)
--- a/src/proto.h
+++ b/src/proto.h
@@ -743,7 +743,7 @@ int get_mouseinput(int *mouse_x, int *mouse_y, bool allow_shortcuts);
 #endif
 const sc *get_shortcut(int menu, int *kbinput, bool
        *meta_key, bool *func_key);
-const sc *first_sc_for(int menu, void *func);
+const sc *first_sc_for(int menu, short func);
 void blank_line(WINDOW *win, int y, int x, int n);
 void blank_titlebar(void);
 void blank_topbar(void);
@@ -783,7 +783,7 @@ int strtomenu(char *input);
 void assign_keyinfo(sc *s);
 void xon_complaint(void);
 void xoff_complaint(void);
-int sc_seq_or (void *func, int defaultval);
+int sc_seq_or (short func, int defaultval);
 void do_suspend_void(void);
 
 const char *cancel_msg;
@@ -814,6 +814,7 @@ const char *prepend_msg;
 const char *backup_file_msg;
 const char *gototext_msg;
 const char *new_buffer_msg;
+void iso_me_harder_funcmap(short func);
 
 #ifdef HAVE_REGEX_H
 const char *regexp_msg;

diff --git a/src/rcfile.c b/src/rcfile.c
index bd041691069d54fab52f976afcb5a240bb7b3079..05ba82d95dd5bdd6ea6d412e9f0ae22df975b8d5 100644 (file)
--- a/src/rcfile.c
+++ b/src/rcfile.c
@@ -427,7 +427,7 @@ void parse_keybinding(char *ptr)
 
 #ifdef DEBUG
     fprintf(stderr, "newsc now address %d, menu func assigned = %d, menu = %d\n",
-       &newsc, &newsc->scfunc, menu);
+       &newsc, newsc->scfunc, menu);
 #endif
 
 
@@ -791,7 +791,7 @@ static void check_vitals_mapped(void)
     subnfunc *f;
     int v;
 #define VITALS 5
-    void *vitals[VITALS] = { do_exit, do_exit, (void *) cancel_msg, (void *) cancel_msg, (void *) cancel_msg };
+    short vitals[VITALS] = { DO_EXIT, DO_EXIT, CANCEL_MSG, CANCEL_MSG, CANCEL_MSG };
     int inmenus[VITALS] = { MMAIN, MHELP, MWHEREIS, MREPLACE, MGOTOLINE };
 
     for  (v = 0; v < VITALS; v++) {

diff --git a/src/search.c b/src/search.c
index 3e7123cf225ab3a3b7b99cbcf1cf75e26094d650..e00af02e2cf7a5c3c1abe8522d0dbd26833563c5 100644 (file)
--- a/src/search.c
+++ b/src/search.c
@@ -137,7 +137,7 @@ int search_init(bool replacing, bool use_answer)
     int i = 0;
     char *buf;
     sc *s;
-    void *func = NULL;
+    char func = 0;
     bool meta_key = FALSE, func_key = FALSE;
     static char *backupstring = NULL;
        /* The search string we'll be using. */
@@ -235,26 +235,26 @@ int search_init(bool replacing, bool use_answer)
 #endif
                ;
 #ifndef NANO_TINY
-       } else if (func == (void *) case_sens_msg) {
+       } else if (func == CASE_SENS_MSG) {
                TOGGLE(CASE_SENSITIVE);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;
-       } else if (func == (void *) backwards_msg) {
+       } else if (func == BACKWARDS_MSG) {
                TOGGLE(BACKWARDS_SEARCH);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;
 #endif
 #ifdef HAVE_REGEX_H
-       } else if (func == (void *) regexp_msg) {
+       } else if (func == REGEXP_MSG) {
                TOGGLE(USE_REGEXP);
                backupstring = mallocstrcpy(backupstring, answer);
                return 1;
 #endif
-       } else if (func == (void *) do_replace || 
-         func == (void *) no_replace_msg) {
+       } else if (func == DO_REPLACE || 
+         func == NO_REPLACE_MSG) {
                backupstring = mallocstrcpy(backupstring, answer);
                return -2;      /* Call the opposite search function. */
-       } else if (func == do_gotolinecolumn_void) {
+       } else if (func == DO_GOTOLINECOLUMN_VOID) {
                do_gotolinecolumn(openfile->current->lineno,
                        openfile->placewewant + 1, TRUE, TRUE, FALSE,
                        TRUE);
@@ -1021,7 +1021,7 @@ void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
 
 
        s = get_shortcut(currmenu, &i, &meta_key, &func_key);
-       if (s && s->scfunc == (void *) gototext_msg) {
+       if (s && s->scfunc ==  GOTOTEXT_MSG) {
            /* Keep answer up on the statusbar. */
            search_init(TRUE, TRUE);
 

diff --git a/src/text.c b/src/text.c
index d6dcfbe2d40d9491c4e639b0a882925330147f6d..4483ec11697f2539ea49c5ef9bf4a5e5810ebe10 100644 (file)
--- a/src/text.c
+++ b/src/text.c
@@ -2220,7 +2220,7 @@ void do_justify(bool full_justify)
        &finished, FALSE);
     s = get_shortcut(currmenu, &kbinput, &meta_key, &func_key);
 
-    if (s && s->scfunc == do_uncut_text) {
+    if (s && s->scfunc == DO_UNCUT_TEXT) {
        /* Splice the justify buffer back into the file, but only if we
         * actually justified something. */
        if (first_par_line != NULL) {

diff --git a/src/winio.c b/src/winio.c
index 9660f791db392ca7a9f79e012bc0a2bd6b95ee73..69a1f789386f1bc6391f82a333ecbab7d65ebe13 100644 (file)
--- a/src/winio.c
+++ b/src/winio.c
@@ -489,36 +489,36 @@ int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
     if (retval != ERR) {
        switch (retval) {
            case NANO_CONTROL_8:
-               retval = ISSET(REBIND_DELETE) ? sc_seq_or(do_delete, 0) :
-                       sc_seq_or(do_backspace, 0);
+               retval = ISSET(REBIND_DELETE) ? sc_seq_or(DO_DELETE, 0) :
+                       sc_seq_or(DO_BACKSPACE, 0);
                break;
            case KEY_DOWN:
 #ifdef KEY_SDOWN
            /* ncurses and Slang don't support KEY_SDOWN. */
            case KEY_SDOWN:
 #endif
-               retval = sc_seq_or((void *) do_down_void, *kbinput);
+               retval = sc_seq_or(DO_DOWN_VOID, *kbinput);
                break;
            case KEY_UP:
 #ifdef KEY_SUP
            /* ncurses and Slang don't support KEY_SUP. */
            case KEY_SUP:
 #endif
-               retval = sc_seq_or((void *) do_up_void, *kbinput);
+               retval = sc_seq_or(DO_UP_VOID, *kbinput);
                break;
            case KEY_LEFT:
 #ifdef KEY_SLEFT
            /* Slang doesn't support KEY_SLEFT. */
            case KEY_SLEFT:
 #endif
-               retval = sc_seq_or((void *) do_left, *kbinput);
+               retval = sc_seq_or(DO_LEFT, *kbinput);
                break;
            case KEY_RIGHT:
 #ifdef KEY_SRIGHT
            /* Slang doesn't support KEY_SRIGHT. */
            case KEY_SRIGHT:
 #endif
-               retval = sc_seq_or((void *) do_right, *kbinput);
+               retval = sc_seq_or(DO_RIGHT, *kbinput);
                break;
 #ifdef KEY_SHOME
            /* HP-UX 10-11 and Slang don't support KEY_SHOME. */
@@ -526,36 +526,36 @@ int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
 #endif
            case KEY_A1:        /* Home (7) on numeric keypad with
                                 * NumLock off. */
-               retval = sc_seq_or((void *) do_home, *kbinput);
+               retval = sc_seq_or(DO_HOME, *kbinput);
                break;
            case KEY_BACKSPACE:
-               retval = sc_seq_or((void *) do_backspace, *kbinput);
+               retval = sc_seq_or(DO_BACKSPACE, *kbinput);
                break;
 #ifdef KEY_SDC
            /* Slang doesn't support KEY_SDC. */
            case KEY_SDC:
                if (ISSET(REBIND_DELETE))
-                  retval = sc_seq_or((void *) do_delete, *kbinput);
+                  retval = sc_seq_or(DO_DELETE, *kbinput);
                else
-                  retval = sc_seq_or((void *) do_backspace, *kbinput);
+                  retval = sc_seq_or(DO_BACKSPACE, *kbinput);
                break;
 #endif
 #ifdef KEY_SIC
            /* Slang doesn't support KEY_SIC. */
            case KEY_SIC:
-               retval = sc_seq_or((void *) do_insertfile_void, *kbinput);
+               retval = sc_seq_or(DO_INSERTFILE_VOID, *kbinput);
                break;
 #endif
            case KEY_C3:        /* PageDown (4) on numeric keypad with
                                 * NumLock off. */
-               retval = sc_seq_or((void *) do_page_down, *kbinput);
+               retval = sc_seq_or(DO_PAGE_DOWN, *kbinput);
                break;
            case KEY_A3:        /* PageUp (9) on numeric keypad with
                                 * NumLock off. */
-               retval = sc_seq_or((void *) do_page_up, *kbinput);
+               retval = sc_seq_or(DO_PAGE_UP, *kbinput);
                break;
            case KEY_ENTER:
-               retval = sc_seq_or((void *) do_enter, *kbinput);
+               retval = sc_seq_or(DO_ENTER, *kbinput);
                break;
            case KEY_B2:        /* Center (5) on numeric keypad with
                                 * NumLock off. */
@@ -567,7 +567,7 @@ int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
            /* HP-UX 10-11 and Slang don't support KEY_SEND. */
            case KEY_SEND:
 #endif
-               retval = sc_seq_or((void *) do_end, *kbinput);
+               retval = sc_seq_or(DO_END, *kbinput);
                break;
 #ifdef KEY_BEG
            /* Slang doesn't support KEY_BEG. */
@@ -583,7 +583,7 @@ int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
            /* Slang doesn't support KEY_SCANCEL. */
            case KEY_SCANCEL:
 #endif
-               retval = first_sc_for(currmenu, (void *) cancel_msg)->seq;
+               retval = first_sc_for(currmenu, CANCEL_MSG)->seq;
                break;
 #endif
 #ifdef KEY_SBEG
@@ -596,13 +596,13 @@ int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
 #ifdef KEY_SSUSPEND
            /* Slang doesn't support KEY_SSUSPEND. */
            case KEY_SSUSPEND:
-               retval = sc_seq_or(do_suspend_void, 0);
+               retval = sc_seq_or(DO_SUSPEND_VOID, 0);
                break;
 #endif
 #ifdef KEY_SUSPEND
            /* Slang doesn't support KEY_SUSPEND. */
            case KEY_SUSPEND:
-               retval =  sc_seq_or(do_suspend_void, 0);
+               retval =  sc_seq_or(DO_SUSPEND_VOID, 0);
                break;
 #endif
 #ifdef PDCURSES
@@ -750,15 +750,15 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                        retval = KEY_B2;
                        break;
                    case 'F': /* Esc O F == End on xterm/Terminal. */
-                       retval = sc_seq_or(do_end, 0);
+                       retval = sc_seq_or(DO_END, 0);
                        break;
                    case 'H': /* Esc O H == Home on xterm/Terminal. */
-                       retval = sc_seq_or(do_home, 0);;
+                       retval = sc_seq_or(DO_HOME, 0);;
                        break;
                    case 'M': /* Esc O M == Enter on numeric keypad with
                               * NumLock off on VT100/VT220/VT320/xterm/
                               * rxvt/Eterm. */
-                       retval = sc_seq_or(do_home, 0);;
+                       retval = sc_seq_or(DO_HOME, 0);;
                        break;
                    case 'P': /* Esc O P == F1 on VT100/VT220/VT320/Mach
                               * console. */
@@ -823,7 +823,7 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                    case 'n': /* Esc O n == Delete (.) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * xterm/rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_delete, 0);;
+                       retval = sc_seq_or(DO_DELETE, 0);;
                        break;
                    case 'o': /* Esc O o == '/' on numeric keypad with
                               * NumLock off on VT100/VT220/VT320/xterm/
@@ -833,27 +833,27 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                    case 'p': /* Esc O p == Insert (0) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_insertfile_void, 0);;
+                       retval = sc_seq_or(DO_INSERTFILE_VOID, 0);;
                        break;
                    case 'q': /* Esc O q == End (1) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_end, 0);;
+                       retval = sc_seq_or(DO_END, 0);;
                        break;
                    case 'r': /* Esc O r == Down (2) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_down_void, 0);;
+                       retval = sc_seq_or(DO_DOWN_VOID, 0);;
                        break;
                    case 's': /* Esc O s == PageDown (3) on numeric
                               * keypad with NumLock off on VT100/VT220/
                               * VT320/rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_page_down, 0);;
+                       retval = sc_seq_or(DO_PAGE_DOWN, 0);;
                        break;
                    case 't': /* Esc O t == Left (4) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_left, 0);;
+                       retval = sc_seq_or(DO_LEFT, 0);;
                        break;
                    case 'u': /* Esc O u == Center (5) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
@@ -863,22 +863,22 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                    case 'v': /* Esc O v == Right (6) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_right, 0);
+                       retval = sc_seq_or(DO_RIGHT, 0);
                        break;
                    case 'w': /* Esc O w == Home (7) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_home, 0);;
+                       retval = sc_seq_or(DO_HOME, 0);
                        break;
                    case 'x': /* Esc O x == Up (8) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_up_void, 0);;
+                       retval = sc_seq_or(DO_UP_VOID, 0);
                        break;
                    case 'y': /* Esc O y == PageUp (9) on numeric keypad
                               * with NumLock off on VT100/VT220/VT320/
                               * rxvt/Eterm/Terminal. */
-                       retval = sc_seq_or(do_up, 0);;
+                       retval = sc_seq_or(DO_PAGE_UP, 0);
                        break;
                }
                break;
@@ -972,7 +972,7 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                                    break;
                                default: /* Esc [ 1 ~ == Home on
                                          * VT320/Linux console. */
-                                   retval = sc_seq_or(do_home, 0);;
+                                   retval = sc_seq_or(DO_HOME, 0);;
                                    break;
                            }
                        }
@@ -1023,40 +1023,40 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                                default: /* Esc [ 2 ~ == Insert on
                                          * VT220/VT320/Linux console/
                                          * xterm/Terminal. */
-                                   retval = sc_seq_or(do_insertfile_void, 0);;
+                                   retval = sc_seq_or(DO_INSERTFILE_VOID, 0);;
                                    break;
                            }
                        }
                        break;
                    case '3': /* Esc [ 3 ~ == Delete on VT220/VT320/
                               * Linux console/xterm/Terminal. */
-                       retval = sc_seq_or(do_delete, 0);;
+                       retval = sc_seq_or(DO_DELETE, 0);;
                        break;
                    case '4': /* Esc [ 4 ~ == End on VT220/VT320/Linux
                               * console/xterm. */
-                       retval = sc_seq_or(do_end, 0);;
+                       retval = sc_seq_or(DO_END, 0);;
                        break;
                    case '5': /* Esc [ 5 ~ == PageUp on VT220/VT320/
                               * Linux console/xterm/Terminal;
                               * Esc [ 5 ^ == PageUp on Eterm. */
-                       retval = sc_seq_or(do_page_up, 0);;
+                       retval = sc_seq_or(DO_PAGE_UP, 0);;
                        break;
                    case '6': /* Esc [ 6 ~ == PageDown on VT220/VT320/
                               * Linux console/xterm/Terminal;
                                * Esc [ 6 ^ == PageDown on Eterm. */
-                       retval = sc_seq_or(do_page_down, 0);;
+                       retval = sc_seq_or(DO_PAGE_DOWN, 0);;
                        break;
                    case '7': /* Esc [ 7 ~ == Home on rxvt. */
-                       retval = sc_seq_or(do_home, 0);
+                       retval = sc_seq_or(DO_HOME, 0);
                        break;
                    case '8': /* Esc [ 8 ~ == End on rxvt. */
-                       retval = sc_seq_or(do_end, 0);
+                       retval = sc_seq_or(DO_END, 0);
                        break;
                    case '9': /* Esc [ 9 == Delete on Mach console. */
-                       retval = sc_seq_or(do_delete, 0);;
+                       retval = sc_seq_or(DO_DELETE, 0);;
                        break;
                    case '@': /* Esc [ @ == Insert on Mach console. */
-                       retval = sc_seq_or(do_insertfile_void, 0);;
+                       retval = sc_seq_or(DO_INSERTFILE_VOID, 0);;
                        break;
                    case 'A': /* Esc [ A == Up on ANSI/VT220/Linux
                               * console/FreeBSD console/Mach console/
@@ -1079,23 +1079,23 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                        break;
                    case 'F': /* Esc [ F == End on FreeBSD
                               * console/Eterm. */
-                       retval = sc_seq_or(do_end, 0);
+                       retval = sc_seq_or(DO_END, 0);
                        break;
                    case 'G': /* Esc [ G == PageDown on FreeBSD
                               * console. */
-                       retval = sc_seq_or(do_page_down, 0);
+                       retval = sc_seq_or(DO_PAGE_DOWN, 0);
                        break;
                    case 'H': /* Esc [ H == Home on ANSI/VT220/FreeBSD
                               * console/Mach console/Eterm. */
-                       retval = sc_seq_or(do_home, 0);
+                       retval = sc_seq_or(DO_HOME, 0);
                        break;
                    case 'I': /* Esc [ I == PageUp on FreeBSD
                               * console. */
-                       retval = sc_seq_or(do_page_up, 0);
+                       retval = sc_seq_or(DO_PAGE_UP, 0);
                        break;
                    case 'L': /* Esc [ L == Insert on ANSI/FreeBSD
                               * console. */
-                       retval = sc_seq_or(do_insertfile_void, 0);
+                       retval = sc_seq_or(DO_INSERTFILE_VOID, 0);
                        break;
                    case 'M': /* Esc [ M == F1 on FreeBSD console. */
                        retval = KEY_F(1);
@@ -1143,10 +1143,10 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                        retval = KEY_F(8);
                        break;
                    case 'U': /* Esc [ U == PageDown on Mach console. */
-                       retval = sc_seq_or(do_page_down, 0);
+                       retval = sc_seq_or(DO_PAGE_DOWN, 0);
                        break;
                    case 'V': /* Esc [ V == PageUp on Mach console. */
-                       retval = sc_seq_or(do_page_up, 0);
+                       retval = sc_seq_or(DO_PAGE_UP, 0);
                        break;
                    case 'W': /* Esc [ W == F11 on FreeBSD console. */
                        retval = KEY_F(11);
@@ -1155,7 +1155,7 @@ int get_escape_seq_kbinput(const int *seq, size_t seq_len)
                        retval = KEY_F(12);
                        break;
                    case 'Y': /* Esc [ Y == End on Mach console. */
-                       retval = sc_seq_or(do_end, 0);
+                       retval = sc_seq_or(DO_END, 0);
                        break;
                    case 'Z': /* Esc [ Z == F14 on FreeBSD console. */
                        retval = KEY_F(14);
@@ -1212,13 +1212,13 @@ int get_escape_seq_abcd(int kbinput)
 {
     switch (tolower(kbinput)) {
        case 'a':
-           return sc_seq_or(do_up_void, 0);;
+           return sc_seq_or(DO_UP_VOID, 0);;
        case 'b':
-           return sc_seq_or(do_down_void, 0);;
+           return sc_seq_or(DO_DOWN_VOID, 0);;
        case 'c':
-           return sc_seq_or(do_right, 0);;
+           return sc_seq_or(DO_RIGHT, 0);;
        case 'd':
-           return sc_seq_or(do_left, 0);;
+           return sc_seq_or(DO_LEFT, 0);;
        default:
            return ERR;
     }
@@ -1709,7 +1709,7 @@ int get_mouseinput(int *mouse_x, int *mouse_y, bool allow_shortcuts)
 
            /* And put back the equivalent key. */
            if (f != NULL) {
-                const sc *s = first_sc_for(currmenu, (void *) f->scfunc);
+                const sc *s = first_sc_for(currmenu, f->scfunc);
                if (s != NULL)
                    unget_kbinput(s->seq, s->type == META, FALSE);
            }
@@ -1738,7 +1738,7 @@ int get_mouseinput(int *mouse_x, int *mouse_y, bool allow_shortcuts)
             * wheel is equivalent to moving down three lines. */
            for (i = 0; i < 3; i++)
                unget_kbinput((mevent.bstate & BUTTON4_PRESSED) ?
-                        sc_seq_or(do_up_void, 0) : sc_seq_or(do_down_void, 0);, FALSE,
+                        sc_seq_or(do_up_void, 0) : sc_seq_or(DO_DOWN_VOID, 0);, FALSE,
                        FALSE);
 
            return 1;