Ticket #158: msg-codes.001.diff

File msg-codes.001.diff, 59.0 KB (added by anonymous, 16 years ago)

Added by email2trac

  • edit/editcmd.c

    diff --git a/edit/editcmd.c b/edit/editcmd.c
    index 01262f1..b1c3879 100644
    a b edit_replace_cmd (WEdit *edit, int again) 
    20512051            edit->force |= REDRAW_PAGE; 
    20522052            edit_render_keypress (edit); 
    20532053            if (times_replaced) { 
    2054                 message (0, msg, _(" %ld replacements made. "), 
     2054                message (D_NORMAL, msg, _(" %ld replacements made. "), 
    20552055                         times_replaced); 
    20562056            } else 
    20572057                query_dialog (msg, _(" Search string not found "), 
    void edit_search_cmd (WEdit * edit, int again) 
    21302130                } 
    21312131                if (found) { 
    21322132/* in response to number of bookmarks added because of string being found %d times */ 
    2133                     message (0, _("Search"), _(" %d items found, %d bookmarks added "), found, books); 
     2133                    message (D_NORMAL, _("Search"), _(" %d items found, %d bookmarks added "), found, books); 
    21342134                } else { 
    21352135                    edit_error_dialog (_ ("Search"), _ (" Search string not found ")); 
    21362136                } 
    edit_block_process_cmd (WEdit *edit, const char *shell_cmd, int block) 
    25842584                         quoted_name, (char *) NULL)); 
    25852585    } 
    25862586    g_free (quoted_name); 
    2587     close_error_pipe (0, 0); 
     2587    close_error_pipe (D_NORMAL, NULL); 
    25882588 
    25892589    edit_refresh_cmd (edit); 
    25902590    edit->force |= REDRAW_COMPLETELY; 
  • src/achown.c

    diff --git a/src/achown.c b/src/achown.c
    index 72ddcad..8f436fb 100644
    a b static void apply_advanced_chowns (struct stat *sf) 
    627627    fname = current_panel->dir.list[current_file].fname; 
    628628    need_update = end_chown = 1; 
    629629    if (mc_chmod (fname, get_mode ()) == -1) 
    630         message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
     630        message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
    631631                 fname, unix_error_string (errno)); 
    632632    /* call mc_chown only, if mc_chmod didn't fail */ 
    633633    else if (mc_chown (fname, (ch_flags[9] == '+') ? sf->st_uid : (uid_t) -1, 
    634634                       (ch_flags[10] == '+') ? sf->st_gid : (gid_t) -1) == -1) 
    635         message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
     635        message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
    636636                 fname, unix_error_string (errno)); 
    637637    do_file_mark (current_panel, current_file, 0); 
    638638 
    static void apply_advanced_chowns (struct stat *sf) 
    643643            break; 
    644644        ch_cmode = sf->st_mode; 
    645645        if (mc_chmod (fname, get_mode ()) == -1) 
    646             message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
     646            message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
    647647                     fname, unix_error_string (errno)); 
    648648        /* call mc_chown only, if mc_chmod didn't fail */ 
    649649        else if (mc_chown (fname, (ch_flags[9] == '+') ? a_uid : (uid_t) -1, 
    650650                           (ch_flags[10] == '+') ? a_gid : (gid_t) -1) == -1) 
    651             message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
     651            message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
    652652                     fname, unix_error_string (errno)); 
    653653 
    654654        do_file_mark (current_panel, current_file, 0); 
    chown_advanced_cmd (void) 
    690690        case B_ENTER: 
    691691            need_update = 1; 
    692692            if (mc_chmod (fname, get_mode ()) == -1) 
    693                 message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
     693                message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
    694694                         fname, unix_error_string (errno)); 
    695695            /* call mc_chown only, if mc_chmod didn't fail */ 
    696696            else if (mc_chown (fname, (ch_flags[9] == '+') ? sf_stat->st_uid : (uid_t) -1, 
    697697                               (ch_flags[10] == '+') ? sf_stat->st_gid : (gid_t) -1) == -1) 
    698                 message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
     698                message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
    699699                         fname, unix_error_string (errno)); 
    700700            break; 
    701701        case B_SETALL: 
  • src/background.c

    diff --git a/src/background.c b/src/background.c
    index 7d733dd..fa828dd 100644
    a b background_attention (int fd, void *closure) 
    213213        if (!waitpid (ctx->pid, &status, WNOHANG)) { 
    214214            /* the process is still running, but it misbehaves - kill it */ 
    215215            kill (ctx->pid, SIGTERM); 
    216             message (1, background_process_error, _(" Unknown error in child ")); 
     216            message (D_ERROR, background_process_error, _(" Unknown error in child ")); 
    217217            return 0; 
    218218        } 
    219219 
    background_attention (int fd, void *closure) 
    221221        if (WIFEXITED (status) && (WEXITSTATUS (status) == 0)) 
    222222            return 0; 
    223223 
    224         message (1, background_process_error, _(" Child died unexpectedly ")); 
     224        message (D_ERROR, background_process_error, _(" Child died unexpectedly ")); 
    225225 
    226226        return 0; 
    227227    } 
    228228 
    229229    read (fd, &argc, sizeof (argc)); 
    230230    if (argc > MAXCALLARGS){ 
    231         message (1, _(" Background protocol error "), 
     231        message (D_ERROR, _(" Background protocol error "), 
    232232                 _(" Background process sent us a request for more arguments \n" 
    233233                 " than we can handle. \n")); 
    234234    } 
  • src/boxes.c

    diff --git a/src/boxes.c b/src/boxes.c
    index 0fd2a0b..e672df9 100644
    a b display_bits_box (void) 
    629629        errmsg = 
    630630            init_translation_table (source_codepage, display_codepage); 
    631631        if (errmsg) 
    632             message (1, MSG_ERROR, "%s", errmsg); 
     632            message (D_ERROR, MSG_ERROR, "%s", errmsg); 
    633633#ifndef HAVE_SLANG 
    634634        meta (stdscr, display_codepage != 0); 
    635635#else 
  • src/chmod.c

    diff --git a/src/chmod.c b/src/chmod.c
    index 599c0c0..2671c65 100644
    a b static void do_chmod (struct stat *sf) 
    243243    sf->st_mode &= and_mask; 
    244244    sf->st_mode |= or_mask; 
    245245    if (mc_chmod (current_panel->dir.list [c_file].fname, sf->st_mode) == -1) 
    246         message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
     246        message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
    247247             current_panel->dir.list [c_file].fname, unix_error_string (errno)); 
    248248 
    249249    do_file_mark (current_panel, c_file, 0); 
    void chmod_cmd (void) 
    313313        case B_ENTER: 
    314314            if (mode_change) 
    315315                if (mc_chmod (fname, c_stat) == -1) 
    316                     message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
     316                    message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "), 
    317317                         fname, unix_error_string (errno)); 
    318318            need_update = 1; 
    319319            break; 
  • src/chown.c

    diff --git a/src/chown.c b/src/chown.c
    index 31f8f25..6598b43 100644
    a b static inline void 
    211211do_chown (uid_t u, gid_t g) 
    212212{ 
    213213    if (mc_chown (current_panel->dir.list [current_file].fname, u, g) == -1) 
    214         message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
     214        message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
    215215             current_panel->dir.list [current_file].fname, unix_error_string (errno)); 
    216216 
    217217    do_file_mark (current_panel, current_file, 0); 
    chown_cmd (void) 
    319319            if (ch_dlg->ret_value==B_ENTER) { 
    320320                need_update = 1; 
    321321                if (mc_chown (fname, new_user, new_group) == -1) 
    322                     message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
     322                    message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "), 
    323323                         fname, unix_error_string (errno)); 
    324324            } else 
    325325                apply_chowns (new_user, new_group); 
  • src/cmd.c

    diff --git a/src/cmd.c b/src/cmd.c
    index 01d110f..9fab944 100644
    a b do_view_cmd (int normal) 
    189189        || link_isdir (selection (current_panel))) { 
    190190        if (confirm_view_dir && (current_panel->marked || current_panel->dirs_marked)) { 
    191191            if (query_dialog 
    192                 (_(" Confirmation "), _("Files tagged, want to cd?"), 0, 2, 
     192                (_(" Confirmation "), _("Files tagged, want to cd?"), D_NORMAL, 2, 
    193193                 _("&Yes"), _("&No")) != 0) { 
    194194                return; 
    195195            } 
    196196        } 
    197197        if (!do_cd (selection (current_panel)->fname, cd_exact)) 
    198             message (1, MSG_ERROR, _("Cannot change directory")); 
     198            message (D_ERROR, MSG_ERROR, _("Cannot change directory")); 
    199199 
    200200        return; 
    201201 
    mkdir_cmd (void) 
    365365        repaint_screen (); 
    366366        select_item (current_panel); 
    367367    } else { 
    368         message (1, MSG_ERROR, "  %s  ", unix_error_string (errno)); 
     368        message (D_ERROR, MSG_ERROR, "  %s  ", unix_error_string (errno)); 
    369369    } 
    370370 
    371371    g_free (absdir); 
    select_unselect_cmd (const char *title, int cmd) 
    508508        c = regexp_match (reg_exp_t, current_panel->dir.list[i].fname, 
    509509                          match_file); 
    510510        if (c == -1) { 
    511             message (1, MSG_ERROR, _("  Malformed regular expression  ")); 
     511            message (D_ERROR, MSG_ERROR, _("  Malformed regular expression  ")); 
    512512            g_free (reg_exp); 
    513513            return; 
    514514        } 
    void ext_cmd (void) 
    560560    dir = 0; 
    561561    if (geteuid () == 0){ 
    562562        dir = query_dialog (_("Extension file edit"), 
    563                             _(" Which extension file you want to edit? "), 0, 2, 
     563                            _(" Which extension file you want to edit? "), D_NORMAL, 2, 
    564564                            _("&User"), _("&System Wide")); 
    565565    } 
    566566    extdir = concat_dir_and_file (mc_home, MC_LIB_EXT); 
    menu_edit_cmd (int where) 
    589589    dir = query_dialog ( 
    590590        _(" Menu edit "), 
    591591        _(" Which menu file do you want to edit? "),  
    592         0, geteuid() ? 2 : 3, 
     592        D_NORMAL, geteuid() ? 2 : 3, 
    593593        _("&Local"), _("&User"), _("&System Wide") 
    594594    ); 
    595595 
    void quick_chdir_cmd (void) 
    633633        tree_chdir (the_tree, target); 
    634634    else 
    635635        if (!do_cd (target, cd_exact)) 
    636             message (1, MSG_ERROR, _("Cannot change directory") ); 
     636            message (D_ERROR, MSG_ERROR, _("Cannot change directory") ); 
    637637    g_free (target); 
    638638} 
    639639 
    edit_syntax_cmd (void) 
    663663    if (geteuid () == 0) { 
    664664        dir = 
    665665            query_dialog (_("Syntax file edit"), 
    666                           _(" Which syntax file you want to edit? "), 0, 2, 
     666                          _(" Which syntax file you want to edit? "), D_NORMAL, 2, 
    667667                          _("&User"), _("&System Wide")); 
    668668    } 
    669669    extdir = concat_dir_and_file (mc_home, "syntax" PATH_SEP_STR "Syntax"); 
    void reselect_vfs (void) 
    690690        return; 
    691691 
    692692    if (!do_cd (target, cd_exact)) 
    693         message (1, MSG_ERROR, _("Cannot change directory") ); 
     693        message (D_ERROR, MSG_ERROR, _("Cannot change directory") ); 
    694694    g_free (target); 
    695695} 
    696696#endif /* USE_VFS */ 
    compare_dirs_cmd (void) 
    818818 
    819819    choice = 
    820820        query_dialog (_(" Compare directories "), 
    821                       _(" Select compare method: "), 0, 3, _("&Quick"), 
    822                       _("&Size only"), _("&Thorough"), _("&Cancel")); 
     821                      _(" Select compare method: "), 0, D_NORMAL,  
     822                      _("&Quick"), _("&Size only"), _("&Thorough"), _("&Cancel")); 
    823823 
    824824    if (choice < 0 || choice > 2) 
    825825        return; 
    compare_dirs_cmd (void) 
    831831        compare_dir (current_panel, other_panel, thorough_flag); 
    832832        compare_dir (other_panel, current_panel, thorough_flag); 
    833833    } else { 
    834         message (1, MSG_ERROR, 
     834        message (D_ERROR, MSG_ERROR, 
    835835                 _(" Both panels should be in the " 
    836836                   "listing mode to use this command ")); 
    837837    } 
    history_cmd (void) 
    848848            cmdline->need_push = 0; 
    849849    } 
    850850    if (!cmdline->history) { 
    851         message (1, MSG_ERROR, _(" The command history is empty ")); 
     851        message (D_ERROR, MSG_ERROR, _(" The command history is empty ")); 
    852852        return; 
    853853    } 
    854854    current = g_list_first (cmdline->history); 
    view_other_cmd (void) 
    887887 
    888888    if (!xterm_flag && !console_flag && !use_subshell && !output_starts_shell) { 
    889889        if (message_flag) 
    890             message (1, MSG_ERROR, 
     890            message (D_ERROR, MSG_ERROR, 
    891891                     _(" Not an xterm or Linux console; \n" 
    892892                       " the panels cannot be toggled. ")); 
    893893        message_flag = FALSE; 
    do_link (int symbolic_link, const char *fname) 
    908908            goto cleanup; 
    909909        save_cwds_stat (); 
    910910        if (-1 == mc_link (fname, dest)) 
    911             message (1, MSG_ERROR, _(" link: %s "), 
     911            message (D_ERROR, MSG_ERROR, _(" link: %s "), 
    912912                     unix_error_string (errno)); 
    913913    } else { 
    914914        char *s; 
    do_link (int symbolic_link, const char *fname) 
    931931            goto cleanup; 
    932932        save_cwds_stat (); 
    933933        if (-1 == mc_symlink (dest, src)) 
    934             message (1, MSG_ERROR, _(" symlink: %s "), 
     934            message (D_ERROR, MSG_ERROR, _(" symlink: %s "), 
    935935                     unix_error_string (errno)); 
    936936    } 
    937937    update_panels (UP_OPTIMIZE, UP_KEEPSEL); 
    void edit_symlink_cmd (void) 
    977977                if (*dest && strcmp (buffer, dest)) { 
    978978                    save_cwds_stat (); 
    979979                    if (-1 == mc_unlink (p)){ 
    980                         message (1, MSG_ERROR, _(" edit symlink, unable to remove %s: %s "), 
     980                        message (D_ERROR, MSG_ERROR, _(" edit symlink, unable to remove %s: %s "), 
    981981                                 p, unix_error_string (errno)); 
    982982                    } else { 
    983983                            if (-1 == mc_symlink (dest, p)) 
    984                                     message (1, MSG_ERROR, _(" edit symlink: %s "), 
     984                                    message (D_ERROR, MSG_ERROR, _(" edit symlink: %s "), 
    985985                                             unix_error_string (errno)); 
    986986                    } 
    987987                    update_panels (UP_OPTIMIZE, UP_KEEPSEL); 
    void edit_symlink_cmd (void) 
    992992        } 
    993993        g_free (q); 
    994994    } else { 
    995         message (1, MSG_ERROR, _("`%s' is not a symbolic link"), 
     995        message (D_ERROR, MSG_ERROR, _("`%s' is not a symbolic link"), 
    996996                 selection (current_panel)->fname); 
    997997    } 
    998998} 
    nice_cd (const char *text, const char *xtext, const char *help, const char *pref 
    11101110    if (do_panel_cd (MENU_PANEL, cd_path, 0)) 
    11111111        directory_history_add (MENU_PANEL, (MENU_PANEL)->cwd); 
    11121112    else 
    1113         message (1, MSG_ERROR, _(" Cannot chdir to %s "), cd_path); 
     1113        message (D_ERROR, MSG_ERROR, _(" Cannot chdir to %s "), cd_path); 
    11141114    g_free (cd_path); 
    11151115    g_free (machine); 
    11161116} 
    dirsizes_cmd (void) 
    12231223void 
    12241224save_setup_cmd (void) 
    12251225{ 
    1226     char *str; 
    1227      
    12281226    save_setup (); 
    12291227    sync_profiles (); 
    12301228     
    1231     message (0, _(" Setup "), _(" Setup saved to ~/%s"), PROFILE_NAME); 
     1229    message (D_NORMAL, _(" Setup "), _(" Setup saved to ~/%s"), PROFILE_NAME); 
    12321230} 
    12331231 
    12341232static void 
  • src/command.c

    diff --git a/src/command.c b/src/command.c
    index b204b8d..d118c03 100644
    a b void do_cd_command (char *cmd) 
    183183    } else 
    184184        if (!examine_cd (&cmd [3])) { 
    185185            char *d = strip_password (g_strdup (&cmd [3]), 1); 
    186             message (1, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
     186            message (D_ERROR, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
    187187                     d, unix_error_string (errno)); 
    188188            g_free (d); 
    189189            return; 
    enter (WInput *cmdline) 
    215215        size_t i, j, cmd_len; 
    216216 
    217217        if (!vfs_current_is_local ()) { 
    218             message (1, MSG_ERROR, 
     218            message (D_ERROR, MSG_ERROR, 
    219219                     _ 
    220220                     (" Cannot execute commands on non-local filesystems")); 
    221221 
    enter (WInput *cmdline) 
    225225        /* Check this early before we clean command line 
    226226         * (will be checked again by shell_execute) */ 
    227227        if (use_subshell && subshell_state != INACTIVE) { 
    228             message (1, MSG_ERROR, 
     228            message (D_ERROR, MSG_ERROR, 
    229229                     _(" The shell is already running a command ")); 
    230230            return MSG_NOT_HANDLED; 
    231231        } 
  • src/dir.c

    diff --git a/src/dir.c b/src/dir.c
    index 6992f40..471a044 100644
    a b do_load_dir (const char *path, dir_list *list, sortfn *sort, int reverse, 
    397397 
    398398    dirp = mc_opendir (path); 
    399399    if (!dirp) { 
    400         message (1, MSG_ERROR, _("Cannot read directory contents")); 
     400        message (D_ERROR, MSG_ERROR, _("Cannot read directory contents")); 
    401401        return next_free; 
    402402    } 
    403403    tree_store_start_check (path); 
    do_reload_dir (const char *path, dir_list *list, sortfn *sort, int count, 
    496496 
    497497    dirp = mc_opendir (path); 
    498498    if (!dirp) { 
    499         message (1, MSG_ERROR, _("Cannot read directory contents")); 
     499        message (D_ERROR, MSG_ERROR, _("Cannot read directory contents")); 
    500500        clean_dir (list, count); 
    501501        return set_zero_dir (list); 
    502502    } 
  • src/execute.c

    diff --git a/src/execute.c b/src/execute.c
    index eb31cac..970a177 100644
    a b shell_execute (const char *command, int flags) 
    189189        if (subshell_state == INACTIVE) 
    190190            do_execute (shell, cmd ? cmd : command, flags | EXECUTE_AS_SHELL); 
    191191        else 
    192             message (1, MSG_ERROR, 
     192            message (D_ERROR, MSG_ERROR, 
    193193                     _(" The shell is already running a command ")); 
    194194    else 
    195195#endif                          /* HAVE_SUBSHELL_SUPPORT */ 
    execute_with_vfs_arg (const char *command, const char *filename) 
    352352 
    353353    localcopy = mc_getlocalcopy (filename); 
    354354    if (localcopy == NULL) { 
    355         message (1, MSG_ERROR, _(" Cannot fetch a local copy of %s "), 
     355        message (D_ERROR, MSG_ERROR, _(" Cannot fetch a local copy of %s "), 
    356356                 filename); 
    357357        return; 
    358358    } 
  • src/ext.c

    diff --git a/src/ext.c b/src/ext.c
    index 8e64d2c..1ad3f19 100644
    a b exec_extension (const char *filename, const char *data, int *move_dir, 
    100100    cmd_file_fd = mc_mkstemps (&file_name, "mcext", SCRIPT_SUFFIX); 
    101101 
    102102    if (cmd_file_fd == -1) { 
    103         message (1, MSG_ERROR, 
     103        message (D_ERROR, MSG_ERROR, 
    104104                 _(" Cannot create temporary command file \n %s "), 
    105105                 unix_error_string (errno)); 
    106106        return; 
    regex_command (const char *filename, const char *action, int *move_dir) 
    464464                    char *title = 
    465465                        g_strdup_printf (_(" %s%s file error"), 
    466466                            mc_home, MC_LIB_EXT); 
    467                     message (1, title, _("The format of the %smc.ext " 
     467                    message (D_ERROR, title, _("The format of the %smc.ext " 
    468468                        "file has changed with version 3.0.  It seems that " 
    469469                        "the installation failed.  Please fetch a fresh " 
    470470                        "copy from the Midnight Commander package."), 
    regex_command (const char *filename, const char *action, int *move_dir) 
    477477        if (home_error) { 
    478478            char *title = 
    479479                g_strdup_printf (_(" ~/%s file error "), MC_USER_EXT); 
    480             message (1, title, _("The format of the ~/%s file has " 
     480            message (D_ERROR, title, _("The format of the ~/%s file has " 
    481481                "changed with version 3.0.  You may either want to copy " 
    482482                "it from %smc.ext or use that file as an example of how " 
    483483                "to write it."), MC_USER_EXT, mc_home); 
  • src/file.c

    diff --git a/src/file.c b/src/file.c
    index a19633a..100ab3e 100644
    a b do_transform_source (FileOpContext *ctx, const char *source) 
    212212        case '*': 
    213213            if (next_reg < 0 || next_reg >= RE_NREGS 
    214214                || ctx->regs.start[next_reg] < 0) { 
    215                 message (1, MSG_ERROR, _(" Invalid target mask ")); 
     215                message (D_ERROR, MSG_ERROR, _(" Invalid target mask ")); 
    216216                transform_error = FILE_ABORT; 
    217217                return NULL; 
    218218            } 
    check_hardlinks (const char *src_name, const char *dst_name, struct stat *pstat) 
    312312                    } 
    313313                } 
    314314            } 
    315             message (1, MSG_ERROR, _(" Cannot make the hardlink ")); 
     315            message (D_ERROR, MSG_ERROR, _(" Cannot make the hardlink ")); 
    316316            return 0; 
    317317        } 
    318318    lp = (struct link *) g_malloc (sizeof (struct link) + strlen (src_name) 
    make_symlink (FileOpContext *ctx, const char *src_path, const char *dst_path) 
    366366 
    367367    if (ctx->stable_symlinks) 
    368368        if (!vfs_file_is_local (src_path) || !vfs_file_is_local (dst_path)) { 
    369             message (1, MSG_ERROR, 
     369            message (D_ERROR, MSG_ERROR, 
    370370                        _(" Cannot make stable symlinks across " 
    371371                          "non-local filesystems: \n\n" 
    372372                          " Option Stable Symlinks will be disabled ")); 
    copy_file_file (FileOpContext *ctx, const char *src_path, const char *dst_path, 
    510510    if (dst_exists) { 
    511511        /* Destination already exists */ 
    512512        if (sb.st_dev == sb2.st_dev && sb.st_ino == sb2.st_ino) { 
    513             message (1, MSG_ERROR, 
     513            message (D_ERROR, MSG_ERROR, 
    514514                    _(" `%s' and `%s' are the same file "), src_path, dst_path); 
    515515            do_refresh (); 
    516516            return FILE_SKIP; 
    copy_file_file (FileOpContext *ctx, const char *src_path, const char *dst_path, 
    586586 
    587587    if (ctx->do_reget) { 
    588588        if (mc_lseek (src_desc, ctx->do_reget, SEEK_SET) != ctx->do_reget) { 
    589             message (1, _("Warning"), 
     589            message (D_ERROR, _("Warning"), 
    590590                        _(" Reget failed, about to overwrite file ")); 
    591591            ctx->do_reget = ctx->do_append = 0; 
    592592        } 
    copy_dir_dir (FileOpContext *ctx, const char *s, const char *d, int toplevel, 
    868868 
    869869    if (is_in_linklist (parent_dirs, s, &cbuf)) { 
    870870        /* we found a cyclic symbolic link */ 
    871         message (1, MSG_ERROR, 
     871        message (D_ERROR, MSG_ERROR, 
    872872                    _(" Cannot copy cyclic symbolic link \n `%s' "), s); 
    873873        return FILE_SKIP; 
    874874    } 
    move_file_file (FileOpContext *ctx, const char *s, const char *d, 
    10521052 
    10531053            strcpy (st, path_trunc (s, msize)); 
    10541054            strcpy (dt, path_trunc (d, msize)); 
    1055             message (1, MSG_ERROR, 
     1055            message (D_ERROR, MSG_ERROR, 
    10561056                        _(" `%s' and `%s' are the same file "), st, dt); 
    10571057            do_refresh (); 
    10581058            return FILE_SKIP; 
    10591059        } 
    10601060 
    10611061        if (S_ISDIR (dst_stats.st_mode)) { 
    1062             message (1, MSG_ERROR, 
     1062            message (D_ERROR, MSG_ERROR, 
    10631063                        _(" Cannot overwrite directory `%s' "), d); 
    10641064            do_refresh (); 
    10651065            return FILE_SKIP; 
    move_dir_dir (FileOpContext *ctx, const char *s, const char *d, 
    11751175 
    11761176        strcpy (st, path_trunc (s, msize)); 
    11771177        strcpy (dt, path_trunc (d, msize)); 
    1178         message (1, MSG_ERROR, 
     1178        message (D_ERROR, MSG_ERROR, 
    11791179                    _(" `%s' and `%s' are the same directory "), st, dt); 
    11801180        do_refresh (); 
    11811181        return FILE_SKIP; 
    panel_operate (void *source_panel, FileOperation operation, 
    17531753        } 
    17541754 
    17551755        if (!strcmp (source, "..")) { 
    1756             message (1, MSG_ERROR, _(" Cannot operate on \"..\"! ")); 
     1756            message (D_ERROR, MSG_ERROR, _(" Cannot operate on \"..\"! ")); 
    17571757            return 0; 
    17581758        } 
    17591759    } 
    panel_operate (void *source_panel, FileOperation operation, 
    18081808                           g_strconcat (op_names[operation], ": ", 
    18091809                                        panel->cwd, NULL)); 
    18101810        if (v == -1) { 
    1811             message (1, MSG_ERROR, 
     1811            message (D_ERROR, MSG_ERROR, 
    18121812                     _(" Sorry, I could not put the job in background ")); 
    18131813        } 
    18141814 
  • src/filegui.c

    diff --git a/src/filegui.c b/src/filegui.c
    index 441adb7..c1c8a7c 100644
    a b file_mask_dialog (FileOpContext *ctx, FileOperation operation, const char *text, 
    868868 
    869869    g_return_val_if_fail (ctx != NULL, NULL); 
    870870#if 0 
    871     message (1, __FUNCTION__, "text = `%s' \n def_text = `%s'", text, 
     871    message (D_ERROR, __FUNCTION__, "text = `%s' \n def_text = `%s'", text, 
    872872                def_text); 
    873873#endif 
    874874    fmd_init_i18n (FALSE); 
    file_mask_dialog (FileOpContext *ctx, FileOperation operation, const char *text, 
    946946                                &ctx->rx); 
    947947 
    948948    if (error) { 
    949         message (1, MSG_ERROR, _("Invalid source pattern `%s' \n %s "), 
     949        message (D_ERROR, MSG_ERROR, _("Invalid source pattern `%s' \n %s "), 
    950950                    orig_mask, error); 
    951951        g_free (orig_mask); 
    952952        goto ask_file_mask; 
  • src/find.c

    diff --git a/src/find.c b/src/find.c
    index baf1504..9fce565 100644
    a b find_parm_callback (struct Dlg_head *h, dlg_msg_t msg, int parm) 
    166166            flags |= REG_ICASE; 
    167167 
    168168        if (regcomp (r, in_with->buffer, flags)) { 
    169             message (1, MSG_ERROR, _("  Malformed regular expression  ")); 
     169            message (D_ERROR, MSG_ERROR, _("  Malformed regular expression  ")); 
    170170            dlg_select_widget (in_with); 
    171171            h->running = 1;     /* Don't stop the dialog */ 
    172172        } 
  • src/help.c

    diff --git a/src/help.c b/src/help.c
    index 3261cbb..5ce6868 100644
    a b static void start_link_area (int x, int y, const char *link_name) 
    292292    Link_Area *new; 
    293293 
    294294    if (inside_link_area) 
    295         message (0, _("Warning"), _(" Internal bug: Double start of link area ")); 
     295        message (D_NORMAL, _("Warning"), _(" Internal bug: Double start of link area ")); 
    296296 
    297297    /* Allocate memory for a new link area */ 
    298298    new = g_new (Link_Area, 1); 
    help_index_cmd (void *vp) 
    540540    const char *new_item; 
    541541 
    542542    if (!(new_item = search_string (data, "[Contents]"))) { 
    543         message (1, MSG_ERROR, _(" Cannot find node %s in help file "), 
     543        message (D_ERROR, MSG_ERROR, _(" Cannot find node %s in help file "), 
    544544                 "[Contents]"); 
    545545        return; 
    546546    } 
    interactive_display (const char *filename, const char *node) 
    769769        data = load_mc_home_file ("mc.hlp", &hlpfile); 
    770770 
    771771    if (data == NULL) { 
    772         message (1, MSG_ERROR, _(" Cannot open file %s \n %s "), filename ? filename : hlpfile, 
     772        message (D_ERROR, MSG_ERROR, _(" Cannot open file %s \n %s "), filename ? filename : hlpfile, 
    773773                 unix_error_string (errno)); 
    774774    } 
    775775 
    interactive_display (const char *filename, const char *node) 
    783783        node = "[main]"; 
    784784 
    785785    if (!(main_node = search_string (data, node))) { 
    786         message (1, MSG_ERROR, _(" Cannot find node %s in help file "), 
     786        message (D_ERROR, MSG_ERROR, _(" Cannot find node %s in help file "), 
    787787                 node); 
    788788 
    789789        /* Fallback to [main], return if it also cannot be found */ 
  • src/learn.c

    diff --git a/src/learn.c b/src/learn.c
    index dff560c..fb98033 100644
    a b _("Please press the %s\n" 
    113113        } 
    114114 
    115115        if (!seq_ok) { 
    116             message (0, _(" Cannot accept this key "), 
     116            message (D_NORMAL, _(" Cannot accept this key "), 
    117117                _(" You have entered \"%s\""), seq); 
    118118        } 
    119119         
    learn_check_key (int c) 
    172172                if (query_dialog (learn_title, 
    173173                                  _ 
    174174                                  ("It seems that all your keys already\n" 
    175                                    "work fine. That's great."), 1, 2, 
     175                                   "work fine. That's great."), D_ERROR, 2, 
    176176                                  _("&Save"), _("&Discard")) == 0) 
    177177                    learn_dlg->ret_value = B_ENTER; 
    178178            } else { 
    179                 message (1, learn_title, 
     179                message (D_ERROR, learn_title, 
    180180                         _ 
    181181                         ("Great! You have a complete terminal database!\n" 
    182182                          "All your keys work well.")); 
  • src/main.c

    diff --git a/src/main.c b/src/main.c
    index 949dcf9..150d785 100644
    a b void 
    425425do_possible_cd (const char *new_dir) 
    426426{ 
    427427    if (!do_cd (new_dir, cd_exact)) 
    428         message (1, _("Warning"), 
     428        message (D_ERROR, _("Warning"), 
    429429                 _(" The Commander can't change to the directory that \n" 
    430430                   " the subshell claims you are in.  Perhaps you have \n" 
    431431                   " deleted your working directory, or given yourself \n" 
    quit_cmd_internal (int quiet) 
    471471    } else { 
    472472        if (query_dialog 
    473473            (_(" The Midnight Commander "), 
    474              _(" Do you really want to quit the Midnight Commander? "), 0, 
     474             _(" Do you really want to quit the Midnight Commander? "), D_NORMAL, 
    475475             2, _("&Yes"), _("&No")) == 0) 
    476476            q = 1; 
    477477    } 
    directory_history_list (WPanel *panel) 
    685685    if (_do_panel_cd (panel, s, cd_exact)) 
    686686        directory_history_add (panel, panel->cwd); 
    687687    else 
    688         message (1, MSG_ERROR, _("Cannot change directory")); 
     688        message (D_ERROR, MSG_ERROR, _("Cannot change directory")); 
    689689    g_free (s); 
    690690} 
    691691 
    toggle_fast_reload (void) 
    990990{ 
    991991    fast_reload = !fast_reload; 
    992992    if (fast_reload_w == 0 && fast_reload) { 
    993         message (0, _(" Information "), 
     993        message (D_NORMAL, _(" Information "), 
    994994                 _ 
    995995                 (" Using the fast reload option may not reflect the exact \n" 
    996996                  " directory contents. In this case you'll need to do a   \n" 
  • src/panelize.c

    diff --git a/src/panelize.c b/src/panelize.c
    index c2d2121..9ac3c2f 100644
    a b external_panelize (void) 
    264264    char *target = NULL; 
    265265 
    266266    if (!vfs_current_is_local ()){ 
    267         message (1, MSG_ERROR, 
     267        message (D_ERROR, MSG_ERROR, 
    268268                 _(" Cannot run external panelize in a non-local directory ")); 
    269269        return; 
    270270    } 
    static void do_external_panelize (char *command) 
    367367    open_error_pipe (); 
    368368    external = popen (command, "r"); 
    369369    if (!external){ 
    370         close_error_pipe (1, _("Cannot invoke command.")); 
     370        close_error_pipe (D_ERROR, _("Cannot invoke command.")); 
    371371        return; 
    372372    } 
    373373    /* Clear the counters and the directory list */ 
    static void do_external_panelize (char *command) 
    418418        current_panel->count = set_zero_dir (list); 
    419419    } 
    420420    if (pclose (external) < 0) 
    421         message (0, _("External panelize"), _("Pipe close failed")); 
    422     close_error_pipe (0, 0); 
     421        message (D_NORMAL, _("External panelize"), _("Pipe close failed")); 
     422    close_error_pipe (D_NORMAL, NULL); 
    423423    try_to_select (current_panel, NULL); 
    424424    panel_re_sort (current_panel); 
    425425} 
  • src/screen.c

    diff --git a/src/screen.c b/src/screen.c
    index 74604f4..74b9aca 100644
    a b do_enter_on_file_entry (file_entry *fe) 
    19641964    if (S_ISDIR (fe->st.st_mode) || link_isdir (fe) 
    19651965        || (fe->st.st_mode == 0)) { 
    19661966        if (!do_cd (fe->fname, cd_exact)) 
    1967             message (1, MSG_ERROR, _("Cannot change directory")); 
     1967            message (D_ERROR, MSG_ERROR, _("Cannot change directory")); 
    19681968        return 1; 
    19691969    } 
    19701970 
    do_enter_on_file_entry (file_entry *fe) 
    19831983    if (confirm_execute) { 
    19841984        if (query_dialog 
    19851985            (_(" The Midnight Commander "), 
    1986              _(" Do you really want to execute? "), 0, 2, _("&Yes"), 
     1986             _(" Do you really want to execute? "), D_NORMAL, 2, _("&Yes"), 
    19871987             _("&No")) != 0) 
    19881988            return 1; 
    19891989    } 
    panel_callback (Widget *w, widget_msg_t msg, int parm) 
    22512251        panel->active = 1; 
    22522252        if (mc_chdir (panel->cwd) != 0) { 
    22532253            char *cwd = strip_password (g_strdup (panel->cwd), 1); 
    2254             message (1, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
     2254            message (D_ERROR, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
    22552255                     cwd, unix_error_string (errno)); 
    22562256            g_free(cwd); 
    22572257        } else 
  • src/selcodepage.c

    diff --git a/src/selcodepage.c b/src/selcodepage.c
    index 3e9ec63..4f7fa3e 100644
    a b do_select_codepage (void) 
    9999        errmsg = 
    100100            init_translation_table (source_codepage, display_codepage); 
    101101        if (errmsg) { 
    102             message (1, MSG_ERROR, "%s", errmsg); 
     102            message (D_ERROR, MSG_ERROR, "%s", errmsg); 
    103103            return -1; 
    104104        } 
    105105    } else { 
    106         message (1, _("Warning"), 
     106        message (D_ERROR, _("Warning"), 
    107107                 _("To use this feature select your codepage in\n" 
    108108                   "Setup / Display Bits dialog!\n" 
    109109                   "Do not forget to save options.")); 
  • src/subshell.c

    diff --git a/src/subshell.c b/src/subshell.c
    index 09c9930..32d91fe 100644
    a b void resize_subshell (void) 
    655655int 
    656656exit_subshell (void) 
    657657{ 
    658     int quit = TRUE; 
     658    int subshell_quit = TRUE; 
    659659 
    660660    if (subshell_state != INACTIVE && subshell_alive) 
    661         quit = 
     661        subshell_quit = 
    662662            !query_dialog (_("Warning"), 
    663663                           _(" The shell is still active. Quit anyway? "), 
    664                            0, 2, _("&Yes"), _("&No")); 
     664                           D_NORMAL, 2, _("&Yes"), _("&No")); 
    665665 
    666     if (quit) { 
     666    if (subshell_quit) { 
    667667        if (subshell_type == TCSH) { 
    668668            if (unlink (tcsh_fifo) == -1) 
    669669                fprintf (stderr, "Cannot remove named pipe %s: %s\r\n", 
    exit_subshell (void) 
    676676        pty_buffer = NULL; 
    677677    } 
    678678 
    679     return quit; 
     679    return subshell_quit; 
    680680} 
    681681 
    682682 
  • src/tree.c

    diff --git a/src/tree.c b/src/tree.c
    index 132d170..de93055 100644
    a b static void tree_move (WTree *tree, const char *default_dest) 
    649649        return; 
    650650    } 
    651651    if (stat (dest, &buf)){ 
    652         message (1, MSG_ERROR, _(" Cannot stat the destination \n %s "), 
     652        message (D_ERROR, MSG_ERROR, _(" Cannot stat the destination \n %s "), 
    653653                 unix_error_string (errno)); 
    654654        g_free (dest); 
    655655        return; 
    tree_rmdir_cmd (WTree *tree) 
    714714            g_strdup_printf (_("  Delete %s?  "), 
    715715                             tree->selected_ptr->name); 
    716716        result = 
    717             query_dialog (_(" Delete "), buf, 3, 2, _("&Yes"), _("&No")); 
     717            query_dialog (_(" Delete "), buf, D_ERROR, 2, _("&Yes"), _("&No")); 
    718718        g_free (buf); 
    719719        if (result != 0) 
    720720            return; 
    chdir_sel (WTree *tree) 
    831831    if (do_cd (tree->selected_ptr->name, cd_exact)) { 
    832832        select_item (current_panel); 
    833833    } else { 
    834         message (1, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
     834        message (D_ERROR, MSG_ERROR, _(" Cannot chdir to \"%s\" \n %s "), 
    835835                 tree->selected_ptr->name, unix_error_string (errno)); 
    836836    } 
    837837    change_panel (); 
  • src/user.c

    diff --git a/src/user.c b/src/user.c
    index 01022aa..6a745d2 100644
    a b int check_format_var (const char *p, char **v) 
    130130            return 0; 
    131131 
    132132        if (!dots || dots == q+5){ 
    133             message (1, 
     133            message (D_ERROR, 
    134134                     _(" Format error on file Extensions File "), 
    135135                     !dots ? _(" The %%var macro has no default ") 
    136136                     :       _(" The %%var macro has no variable ")); 
    debug_out (char *start, char *end, int cond) 
    463463            len = strlen (msg); 
    464464            if (len) 
    465465                msg [len - 1] = 0; 
    466             message (0, _(" Debug "), "%s", msg); 
     466            message (D_NORMAL, _(" Debug "), "%s", msg); 
    467467 
    468468        } 
    469469        debug_flag = 0; 
    execute_menu_command (WEdit *edit_widget, const char *commands) 
    580580    cmd_file_fd = mc_mkstemps (&file_name, "mcusr", SCRIPT_SUFFIX); 
    581581 
    582582    if (cmd_file_fd == -1){ 
    583         message (1, MSG_ERROR, _(" Cannot create temporary command file \n %s "), 
     583        message (D_ERROR, MSG_ERROR, _(" Cannot create temporary command file \n %s "), 
    584584                 unix_error_string (errno)); 
    585585        return; 
    586586    } 
    menu_file_own(char* path) 
    688688    } 
    689689    if (verbose) 
    690690    { 
    691         message (0, _(" Warning -- ignoring file "), 
     691        message (D_NORMAL, _(" Warning -- ignoring file "), 
    692692                    _("File %s is not owned by root or you or is world writable.\n" 
    693693                    "Using it may compromise your security"), 
    694694                path 
    user_menu_cmd (struct WEdit *edit_widget) 
    712712    Listbox *listbox; 
    713713     
    714714    if (!vfs_current_is_local ()){ 
    715         message (1, MSG_ERROR, 
     715        message (D_ERROR, MSG_ERROR, 
    716716                 _(" Cannot execute commands on non-local filesystems")); 
    717717        return; 
    718718    } 
    user_menu_cmd (struct WEdit *edit_widget) 
    730730    } 
    731731 
    732732    if ((data = load_file (menu)) == NULL){ 
    733         message (1, MSG_ERROR, _(" Cannot open file %s \n %s "), 
     733        message (D_ERROR, MSG_ERROR, _(" Cannot open file %s \n %s "), 
    734734                 menu, unix_error_string (errno)); 
    735735        g_free (menu); 
    736736        menu = NULL; 
    user_menu_cmd (struct WEdit *edit_widget) 
    811811    } 
    812812 
    813813    if (menu_lines == 0) { 
    814         message (1, MSG_ERROR, _(" No suitable entries found in %s "), menu); 
     814        message (D_ERROR, MSG_ERROR, _(" No suitable entries found in %s "), menu); 
    815815    } else { 
    816816 
    817817    max_cols = min (max (max_cols, col), MAX_ENTRY_LEN); 
  • src/utilunix.c

    diff --git a/src/utilunix.c b/src/utilunix.c
    index 7565eb1..cd3c7cc 100644
    a b static int old_error; /* File descriptor of old standard error */ 
    339339void open_error_pipe (void) 
    340340{ 
    341341    if (pipe (error_pipe) < 0){ 
    342         message (0, _("Warning"), _(" Pipe failed ")); 
     342        message (D_NORMAL, _("Warning"), _(" Pipe failed ")); 
    343343    } 
    344344    old_error = dup (2); 
    345345    if(old_error < 0 || close(2) || dup (error_pipe[1]) != 2){ 
    346         message (0, _("Warning"), _(" Dup failed ")); 
     346        message (D_NORMAL, _("Warning"), _(" Dup failed ")); 
    347347        close (error_pipe[0]); 
    348348        close (error_pipe[1]); 
    349349    } 
  • src/view.c

    diff --git a/src/view.c b/src/view.c
    index ddb093d..2f2c33a 100644
    a b view_growbuf_read_until (WView *view, offset_type ofs) 
    432432                view->growbuf_finished = TRUE; 
    433433                (void) pclose (view->ds_stdio_pipe); 
    434434                display (view); 
    435                 close_error_pipe (0, NULL); 
     435                close_error_pipe (D_NORMAL, NULL); 
    436436                view->ds_stdio_pipe = NULL; 
    437437                return; 
    438438            } 
    view_close_datasource (WView *view) 
    690690            if (view->ds_stdio_pipe != NULL) { 
    691691                (void) pclose (view->ds_stdio_pipe); 
    692692                display (view); 
    693                 close_error_pipe (0, NULL); 
     693                close_error_pipe (D_NORMAL, NULL); 
    694694                view->ds_stdio_pipe = NULL; 
    695695            } 
    696696            view_growbuf_free (view); 
    view_show_error (WView *view, const char *msg) 
    14501450    if (view_is_in_panel (view)) { 
    14511451        view_set_datasource_string (view, msg); 
    14521452    } else { 
    1453         message (1, MSG_ERROR, "%s", msg); 
     1453        message (D_ERROR, MSG_ERROR, "%s", msg); 
    14541454    } 
    14551455} 
    14561456 
    view_load_command_output (WView *view, const char *command) 
    14651465    if ((fp = popen (command, "r")) == NULL) { 
    14661466        /* Avoid two messages.  Message from stderr has priority.  */ 
    14671467        display (view); 
    1468         if (!close_error_pipe (view_is_in_panel (view) ? -1 : 1, NULL)) 
     1468        if (!close_error_pipe (view_is_in_panel (view) ? -1 : D_ERROR, NULL)) 
    14691469            view_show_error (view, _(" Cannot spawn child process ")); 
    14701470        return FALSE; 
    14711471    } 
    view_load_command_output (WView *view, const char *command) 
    14771477 
    14781478        /* Avoid two messages.  Message from stderr has priority.  */ 
    14791479        display (view); 
    1480         if (!close_error_pipe (view_is_in_panel (view) ? -1 : 1, NULL)) 
     1480        if (!close_error_pipe (view_is_in_panel (view) ? -1 : D_ERROR, NULL)) 
    14811481            view_show_error (view, _("Empty output from child filter")); 
    14821482        return FALSE; 
    14831483    } 
    search (WView *view, char *text, 
    24452445        destroy_dlg (d); 
    24462446    } 
    24472447    if (!s) { 
    2448         message (0, _("Search"), _(" Search string not found ")); 
     2448        message (D_NORMAL, _("Search"), _(" Search string not found ")); 
    24492449        view->search_length = 0; 
    24502450    } 
    24512451} 
    hex_search (WView *view, const char *text) 
    25962596 
    25972597    /* No valid bytes in the user input */ 
    25982598    if (block_len <= 0 || parse_error) { 
    2599         message (0, _("Search"), _("Invalid hex search expression")); 
     2599        message (D_NORMAL, _("Search"), _("Invalid hex search expression")); 
    26002600        g_free (buffer); 
    26012601        view->search_length = 0; 
    26022602        return; 
    hex_search (WView *view, const char *text) 
    26082608    g_free (buffer); 
    26092609 
    26102610    if (pos == INVALID_OFFSET) { 
    2611         message (0, _("Search"), _(" Search string not found ")); 
     2611        message (D_NORMAL, _("Search"), _(" Search string not found ")); 
    26122612        view->search_length = 0; 
    26132613        return; 
    26142614    } 
    regexp_view_search (WView *view, char *pattern, char *string, 
    26482648        } 
    26492649        flags |= REG_EXTENDED; 
    26502650        if (regcomp (&r, pattern, flags)) { 
    2651             message (1, MSG_ERROR, _(" Invalid regular expression ")); 
     2651            message (D_ERROR, MSG_ERROR, _(" Invalid regular expression ")); 
    26522652            return -1; 
    26532653        } 
    26542654        old_pattern = g_strdup (pattern); 
  • vfs/cpio.c

    diff --git a/vfs/cpio.c b/vfs/cpio.c
    index fb93d9a..3b1dd89 100644
    a b cpio_open_cpio_file (struct vfs_class *me, struct vfs_s_super *super, 
    157157    struct vfs_s_inode *root; 
    158158 
    159159    if ((fd = mc_open (name, O_RDONLY)) == -1) { 
    160         message (1, MSG_ERROR, _("Cannot open cpio archive\n%s"), name); 
     160        message (D_ERROR, MSG_ERROR, _("Cannot open cpio archive\n%s"), name); 
    161161        return -1; 
    162162    } 
    163163 
    cpio_open_cpio_file (struct vfs_class *me, struct vfs_s_super *super, 
    173173        mc_close (fd); 
    174174        s = g_strconcat (name, decompress_extension (type), (char *) NULL); 
    175175        if ((fd = mc_open (s, O_RDONLY)) == -1) { 
    176             message (1, MSG_ERROR, _("Cannot open cpio archive\n%s"), s); 
     176            message (D_ERROR, MSG_ERROR, _("Cannot open cpio archive\n%s"), s); 
    177177            g_free (s); 
    178178            return -1; 
    179179        } 
    static int cpio_find_head(struct vfs_class *me, struct vfs_s_super *super) 
    239239                top = 128; 
    240240            } 
    241241            if((tmp = mc_read(super->u.arch.fd, buf, top)) == 0 || tmp == -1) { 
    242                 message (1, MSG_ERROR, _("Premature end of cpio archive\n%s"), super->name); 
     242                message (D_ERROR, MSG_ERROR, _("Premature end of cpio archive\n%s"), super->name); 
    243243                cpio_free_archive(me, super); 
    244244                return CPIO_UNKNOWN; 
    245245            } 
    static int cpio_read_bin_head(struct vfs_class *me, struct vfs_s_super *super) 
    284284    g_assert(u.buf.c_magic == 070707); 
    285285 
    286286    if (u.buf.c_namesize == 0 || u.buf.c_namesize > MC_MAXPATHLEN) { 
    287         message (1, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"),  
     287        message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"),  
    288288                super->name); 
    289289        return STATUS_FAIL; 
    290290    } 
    static int cpio_read_oldc_head(struct vfs_class *me, struct vfs_s_super *super) 
    336336              &hd.c_dev, &hd.c_ino, &hd.c_mode, &hd.c_uid, &hd.c_gid, 
    337337              &hd.c_nlink, &hd.c_rdev, &hd.c_mtime, 
    338338              &hd.c_namesize, &hd.c_filesize) < 10) { 
    339         message (1, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
     339        message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
    340340                    super->name); 
    341341        return STATUS_FAIL; 
    342342    } 
    343343 
    344344    if (hd.c_namesize == 0 || hd.c_namesize > MC_MAXPATHLEN) { 
    345         message (1, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
     345        message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
    346346                    super->name); 
    347347        return STATUS_FAIL; 
    348348    } 
    static int cpio_read_crc_head(struct vfs_class *me, struct vfs_s_super *super) 
    396396              &hd.c_nlink,  &hd.c_mtime, &hd.c_filesize, 
    397397              &hd.c_dev, &hd.c_devmin, &hd.c_rdev, &hd.c_rdevmin, 
    398398              &hd.c_namesize, &hd.c_chksum) < 14) { 
    399         message (1, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
     399        message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
    400400                   super->name); 
    401401        return STATUS_FAIL; 
    402402    } 
    static int cpio_read_crc_head(struct vfs_class *me, struct vfs_s_super *super) 
    406406        return STATUS_FAIL; 
    407407 
    408408    if (hd.c_namesize == 0 || hd.c_namesize > MC_MAXPATHLEN) { 
    409         message (1, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
     409        message (D_ERROR, MSG_ERROR, _("Corrupted cpio header encountered in\n%s"), 
    410410                    super->name); 
    411411        return STATUS_FAIL; 
    412412    } 
    cpio_create_entry (struct vfs_class *me, struct vfs_s_super *super, 
    480480            inode = l->inode; 
    481481            if (inode->st.st_size && st->st_size 
    482482                && (inode->st.st_size != st->st_size)) { 
    483                 message (1, MSG_ERROR, 
     483                message (D_ERROR, MSG_ERROR, 
    484484                         _ 
    485485                         ("Inconsistent hardlinks of\n%s\nin cpio archive\n%s"), 
    486486                         name, super->name); 
    cpio_create_entry (struct vfs_class *me, struct vfs_s_super *super, 
    507507                                   'No such file or directory' is such case) */ 
    508508 
    509509        if (!S_ISDIR (entry->ino->st.st_mode)) {        /* This can be considered archive inconsistency */ 
    510             message (1, MSG_ERROR, 
     510            message (D_ERROR, MSG_ERROR, 
    511511                     _("%s contains duplicate entries! Skipping!"), 
    512512                     super->name); 
    513513        } else { 
    cpio_open_archive (struct vfs_class *me, struct vfs_s_super *super, 
    579579 
    580580        switch (status) { 
    581581        case STATUS_EOF: 
    582             message (1, MSG_ERROR, _("Unexpected end of file\n%s"), name); 
     582            message (D_ERROR, MSG_ERROR, _("Unexpected end of file\n%s"), name); 
    583583            return 0; 
    584584        case STATUS_OK: 
    585585            continue; 
  • vfs/direntry.c

    diff --git a/vfs/direntry.c b/vfs/direntry.c
    index 3a52d22..b807414 100644
    a b vfs_s_free_super (struct vfs_class *me, struct vfs_s_super *super) 
    431431#if 0 
    432432    /* FIXME: We currently leak small ammount of memory, sometimes. Fix it if you can. */ 
    433433    if (super->ino_usage) 
    434         message (1, " Direntry warning ", 
     434        message (D_ERROR, " Direntry warning ", 
    435435                         "Super ino_usage is %d, memory leak", 
    436436                         super->ino_usage); 
    437437 
    438438    if (super->want_stale) 
    439         message (1, " Direntry warning ", "Super has want_stale set"); 
     439        message (D_ERROR, " Direntry warning ", "Super has want_stale set"); 
    440440#endif 
    441441 
    442442    if (super->prevp){ 
  • vfs/extfs.c

    diff --git a/vfs/extfs.c b/vfs/extfs.c
    index d634e33..8024ab6 100644
    a b extfs_open_archive (int fstype, const char *name, struct archive **pparc) 
    256256    result = popen (cmd, "r"); 
    257257    g_free (cmd); 
    258258    if (result == NULL) { 
    259         close_error_pipe (1, NULL); 
     259        close_error_pipe (D_ERROR, NULL); 
    260260        if (local_name) { 
    261261            mc_ungetlocalcopy (name, local_name, 0); 
    262262            g_free(local_name); 
    extfs_read_archive (int fstype, const char *name, struct archive **pparc) 
    314314 
    315315    if ((extfsd = 
    316316         extfs_open_archive (fstype, name, &current_archive)) == NULL) { 
    317         message (1, MSG_ERROR, _("Cannot open %s archive\n%s"), 
     317        message (D_ERROR, MSG_ERROR, _("Cannot open %s archive\n%s"), 
    318318                 extfs_prefixes[fstype], name); 
    319319        return -1; 
    320320    } 
    extfs_read_archive (int fstype, const char *name, struct archive **pparc) 
    354354                    /* FIXME: Should clean everything one day */ 
    355355                    g_free (buffer); 
    356356                    pclose (extfsd); 
    357                     close_error_pipe (1, _("Inconsistent extfs archive")); 
     357                    close_error_pipe (D_ERROR, _("Inconsistent extfs archive")); 
    358358                    return -1; 
    359359                } 
    360360                entry = g_new (struct entry, 1); 
    extfs_read_archive (int fstype, const char *name, struct archive **pparc) 
    373373                        /* FIXME: Should clean everything one day */ 
    374374                        g_free (buffer); 
    375375                        pclose (extfsd); 
    376                         close_error_pipe (1, 
     376                        close_error_pipe (D_ERROR, 
    377377                                          _("Inconsistent extfs archive")); 
    378378                        return -1; 
    379379                    } else { 
    extfs_read_archive (int fstype, const char *name, struct archive **pparc) 
    425425    /* Check if extfs 'list' returned 0 */ 
    426426    if (pclose (extfsd) != 0) { 
    427427        extfs_free (current_archive); 
    428         close_error_pipe (1, _("Inconsistent extfs archive")); 
     428        close_error_pipe (D_ERROR, _("Inconsistent extfs archive")); 
    429429        return -1; 
    430430    } 
    431431 
    432     close_error_pipe (1, NULL); 
     432    close_error_pipe (D_ERROR, NULL); 
    433433    *pparc = current_archive; 
    434434    return 0; 
    435435} 
    extfs_cmd (const char *extfs_cmd, struct archive *archive, 
    633633    open_error_pipe (); 
    634634    retval = my_system (EXECUTE_AS_SHELL, shell, cmd); 
    635635    g_free (cmd); 
    636     close_error_pipe (1, NULL); 
     636    close_error_pipe (D_ERROR, NULL); 
    637637    return retval; 
    638638} 
    639639 
  • vfs/fish.c

    diff --git a/vfs/fish.c b/vfs/fish.c
    index 2a2deb6..63e4d60 100644
    a b fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super) 
    239239            /* Currently, this does not work. ssh reads passwords from 
    240240               /dev/tty, not from stdin :-(. */ 
    241241 
    242             message (1, MSG_ERROR, 
     242            message (D_ERROR, MSG_ERROR, 
    243243                     _ 
    244244                     ("Sorry, we cannot do password authenticated connections for now.")); 
    245245            ERRNOR (EPERM, -1); 
  • vfs/ftpfs.c

    diff --git a/vfs/ftpfs.c b/vfs/ftpfs.c
    index 43d363c..4df1737 100644
    a b ftpfs_login_server (struct vfs_class *me, struct vfs_s_super *super, 
    527527            goto login_fail; 
    528528        } 
    529529    } 
    530     message (1, MSG_ERROR, _("ftpfs: Login incorrect for user %s "), 
     530    message (D_ERROR, MSG_ERROR, _("ftpfs: Login incorrect for user %s "), 
    531531             SUP.user); 
    532532  login_fail: 
    533533    wipe_password (pass); 
    static int ftpfs_netrc_bad_mode (const char *netrcname) 
    17861786 
    17871787    if (stat (netrcname, &mystat) >= 0 && (mystat.st_mode & 077)) { 
    17881788        if (be_angry) { 
    1789             message (1, MSG_ERROR, 
     1789            message (D_ERROR, MSG_ERROR, 
    17901790                        _("~/.netrc file has incorrect mode.\n" 
    17911791                          "Remove password or correct mode.")); 
    17921792            be_angry = 0; 
  • vfs/mcfs.c

    diff --git a/vfs/mcfs.c b/vfs/mcfs.c
    index 07de5a3..4c03097 100644
    a b mcfs_login_server (int my_socket, char *user, int port, 
    130130        return 0; 
    131131 
    132132    if (result != MC_VERSION_OK) { 
    133         message (1, _(" MCFS "), 
     133        message (D_ERROR, _(" MCFS "), 
    134134                    _(" The server does not support this version ")); 
    135135        close (my_socket); 
    136136        return 0; 
    mcfs_login_server (int my_socket, char *user, int port, 
    151151                              (" The remote server is not running on a system port \n" 
    152152                               " you need a password to log in, but the information may \n" 
    153153                               " not be safe on the remote side.  Continue? \n"), 
    154                               3, 2, _("&Yes"), _("&No")); 
     154                              D_ERROR, 2, _("&Yes"), _("&No")); 
    155155 
    156156            if (v == 1) { 
    157157                close (my_socket); 
    mcfs_login_server (int my_socket, char *user, int port, 
    175175            return 0; 
    176176 
    177177        if (result != MC_LOGINOK) { 
    178             message (1, _(" MCFS "), _(" Invalid password ")); 
     178            message (D_ERROR, _(" MCFS "), _(" Invalid password ")); 
    179179            rpc_send (my_socket, RPC_INT, MC_QUIT, RPC_END); 
    180180            close (my_socket); 
    181181            return 0; 
    mcfs_create_tcp_link (const char *host, int *port, int *version, const char *cal 
    235235                sizeof (inaddr)); 
    236236    else { 
    237237        if ((hp = gethostbyname (host)) == NULL) { 
    238             message (1, caller, _(" Cannot locate hostname: %s "), 
     238            message (D_ERROR, caller, _(" Cannot locate hostname: %s "), 
    239239                        host); 
    240240            return 0; 
    241241        } 
    mcfs_create_tcp_link (const char *host, int *port, int *version, const char *cal 
    254254    server_address.sin_port = htons (*port); 
    255255 
    256256    if ((my_socket = socket (AF_INET, SOCK_STREAM, 0)) < 0) { 
    257         message (1, caller, _(" Cannot create socket: %s "), 
     257        message (D_ERROR, caller, _(" Cannot create socket: %s "), 
    258258                    unix_error_string (errno)); 
    259259        return 0; 
    260260    } 
    261261    if (connect (my_socket, (struct sockaddr *) &server_address, 
    262262                 sizeof (server_address)) < 0) { 
    263         message (1, caller, _(" Cannot connect to server: %s "), 
     263        message (D_ERROR, caller, _(" Cannot connect to server: %s "), 
    264264                    unix_error_string (errno)); 
    265265        close (my_socket); 
    266266        return 0; 
    mcfs_open_link (char *host, char *user, int *port, char *netrcpass) 
    330330                return &mcfs_connections[i]; 
    331331        } 
    332332    if (mcfs_open_connections == MCFS_MAX_CONNECTIONS) { 
    333         message (1, MSG_ERROR, _(" Too many open connections ")); 
     333        message (D_ERROR, MSG_ERROR, _(" Too many open connections ")); 
    334334        return 0; 
    335335    } 
    336336 
  • vfs/sfs.c

    diff --git a/vfs/sfs.c b/vfs/sfs.c
    index f4989ca..0770482 100644
    a b sfs_vfmake (struct vfs_class *me, const char *name, char *cache) 
    147147    g_free (pqname); 
    148148    open_error_pipe (); 
    149149    if (my_system (EXECUTE_AS_SHELL, "/bin/sh", pad)) { 
    150         close_error_pipe (1, NULL); 
     150        close_error_pipe (D_ERROR, NULL); 
    151151        return -1; 
    152152    } 
    153153 
    154     close_error_pipe (0, NULL); 
     154    close_error_pipe (D_NORMAL, NULL); 
    155155    return 0;                   /* OK */ 
    156156} 
    157157 
  • vfs/smbfs.c

    diff --git a/vfs/smbfs.c b/vfs/smbfs.c
    index a133fa3..74b5c39 100644
    a b smbfs_reconnect(smbfs_connection *conn, int *retries) 
    604604        cli_shutdown(conn->cli); 
    605605 
    606606        if (!(conn->cli = smbfs_do_connect(host, conn->service))) { 
    607                 message (1, MSG_ERROR, 
     607                message (D_ERROR, MSG_ERROR, 
    608608                        _(" reconnect to %s failed\n "), conn->host); 
    609609                g_free(host); 
    610610                return False; 
    smbfs_open_link (char *host, char *path, const char *user, int *port, 
    11621162 
    11631163        if (my_errno != EPERM) 
    11641164            return 0; 
    1165         message (1, MSG_ERROR, _(" Authentication failed ")); 
     1165        message (D_ERROR, MSG_ERROR, _(" Authentication failed ")); 
    11661166 
    11671167        /* authentication failed, try again */ 
    11681168        smbfs_auth_remove (bucket->host, bucket->service); 
    smbfs_mkdir (struct vfs_class * me, const char *path, mode_t mode) 
    16851685 
    16861686    if (!cli_mkdir (sc->cli, cpath)) { 
    16871687        my_errno = cli_error (sc->cli, NULL, &err, NULL); 
    1688         message (1, MSG_ERROR, _(" Error %s creating directory %s "), 
     1688        message (D_ERROR, MSG_ERROR, _(" Error %s creating directory %s "), 
    16891689                    cli_errstr (sc->cli), CNV_LANG (cpath)); 
    16901690        g_free (cpath); 
    16911691        return -1; 
    smbfs_rmdir (struct vfs_class *me, const char *path) 
    17111711 
    17121712        if (!cli_rmdir(sc->cli, cpath)) { 
    17131713                my_errno = cli_error(sc->cli, NULL, &err, NULL); 
    1714                 message (1, MSG_ERROR, _(" Error %s removing directory %s "),  
     1714                message (D_ERROR, MSG_ERROR, _(" Error %s removing directory %s "),  
    17151715                        cli_errstr(sc->cli), CNV_LANG(cpath)); 
    17161716                g_free (cpath); 
    17171717                return -1; 
    smbfs_open_readwrite (smbfs_handle *remote_handle, char *rname, int flags, int m 
    18131813                  flags : O_RDONLY, DENY_NONE); 
    18141814#endif 
    18151815    if (remote_handle->fnum == -1) { 
    1816         message (1, MSG_ERROR, _(" %s opening remote file %s "), 
     1816        message (D_ERROR, MSG_ERROR, _(" %s opening remote file %s "), 
    18171817                    cli_errstr (remote_handle->cli), CNV_LANG (rname)); 
    18181818        DEBUG (1, ("smbfs_open(rname:%s) error:%s\n", 
    18191819                   rname, cli_errstr (remote_handle->cli))); 
    smbfs_open_readwrite (smbfs_handle *remote_handle, char *rname, int flags, int m 
    18291829                        NULL) 
    18301830        && !cli_getattrE (remote_handle->cli, remote_handle->fnum, 
    18311831                          &remote_handle->attr, &size, NULL, NULL, NULL)) { 
    1832         message (1, MSG_ERROR, " getattrib: %s ", 
     1832        message (D_ERROR, MSG_ERROR, " getattrib: %s ", 
    18331833                    cli_errstr (remote_handle->cli)); 
    18341834        DEBUG (1, 
    18351835               ("smbfs_open(rname:%s) getattrib:%s\n", rname, 
    smbfs_unlink (struct vfs_class *me, const char *path) 
    18921892    remote_file = free_after(smbfs_convert_path (remote_file, FALSE), remote_file); 
    18931893 
    18941894    if (!cli_unlink(sc->cli, remote_file)) { 
    1895         message (1, MSG_ERROR, _(" %s removing remote file %s "),  
     1895        message (D_ERROR, MSG_ERROR, _(" %s removing remote file %s "),  
    18961896                        cli_errstr(sc->cli), CNV_LANG(remote_file)); 
    18971897        g_free (remote_file); 
    18981898        return -1; 
    smbfs_rename (struct vfs_class *me, const char *a, const char *b) 
    19271927    g_free (rb); 
    19281928 
    19291929    if (!retval) { 
    1930         message (1, MSG_ERROR, _(" %s renaming files\n"),  
     1930        message (D_ERROR, MSG_ERROR, _(" %s renaming files\n"),  
    19311931                        cli_errstr(sc->cli)); 
    19321932        return -1; 
    19331933    }    
  • vfs/tar.c

    diff --git a/vfs/tar.c b/vfs/tar.c
    index bcde169..6911baa 100644
    a b tar_open_archive_int (struct vfs_class *me, const char *name, 
    223223 
    224224    result = mc_open (name, O_RDONLY); 
    225225    if (result == -1) { 
    226         message (1, MSG_ERROR, _("Cannot open tar archive\n%s"), name); 
     226        message (D_ERROR, MSG_ERROR, _("Cannot open tar archive\n%s"), name); 
    227227        ERRNOR (ENOENT, -1); 
    228228    } 
    229229 
    tar_open_archive_int (struct vfs_class *me, const char *name, 
    241241        s = g_strconcat (archive->name, decompress_extension (type), (char *) NULL); 
    242242        result = mc_open (s, O_RDONLY); 
    243243        if (result == -1) 
    244             message (1, MSG_ERROR, _("Cannot open tar archive\n%s"), s); 
     244            message (D_ERROR, MSG_ERROR, _("Cannot open tar archive\n%s"), s); 
    245245        g_free (s); 
    246246        if (result == -1) 
    247247            ERRNOR (ENOENT, -1); 
    tar_read_header (struct vfs_class *me, struct vfs_s_super *archive, 
    483483            archive->u.arch.type = TAR_GNU; 
    484484 
    485485        if (*h_size > MC_MAXPATHLEN) { 
    486             message (1, MSG_ERROR, _("Inconsistent tar archive")); 
     486            message (D_ERROR, MSG_ERROR, _("Inconsistent tar archive")); 
    487487            return STATUS_BADCHECKSUM; 
    488488        } 
    489489 
    tar_read_header (struct vfs_class *me, struct vfs_s_super *archive, 
    498498            if (data == NULL) { 
    499499                g_free (*longp); 
    500500                *longp = NULL; 
    501                 message (1, MSG_ERROR, 
     501                message (D_ERROR, MSG_ERROR, 
    502502                         _("Unexpected EOF on archive file")); 
    503503                return STATUS_BADCHECKSUM; 
    504504            } 
    tar_read_header (struct vfs_class *me, struct vfs_s_super *archive, 
    513513        if (bp - *longp == MC_MAXPATHLEN && bp[-1] != '\0') { 
    514514            g_free (*longp); 
    515515            *longp = NULL; 
    516             message (1, MSG_ERROR, _("Inconsistent tar archive")); 
     516            message (D_ERROR, MSG_ERROR, _("Inconsistent tar archive")); 
    517517            return STATUS_BADCHECKSUM; 
    518518        } 
    519519        *bp = 0; 
    tar_read_header (struct vfs_class *me, struct vfs_s_super *archive, 
    588588        parent = 
    589589            vfs_s_find_inode (me, archive, q, LINK_NO_FOLLOW, FL_MKDIR); 
    590590        if (parent == NULL) { 
    591             message (1, MSG_ERROR, _("Inconsistent tar archive")); 
     591            message (D_ERROR, MSG_ERROR, _("Inconsistent tar archive")); 
    592592            return STATUS_BADCHECKSUM; 
    593593        } 
    594594 
    tar_read_header (struct vfs_class *me, struct vfs_s_super *archive, 
    597597                vfs_s_find_inode (me, archive, current_link_name, 
    598598                                  LINK_NO_FOLLOW, 0); 
    599599            if (inode == NULL) { 
    600                 message (1, MSG_ERROR, _("Inconsistent tar archive")); 
     600                message (D_ERROR, MSG_ERROR, _("Inconsistent tar archive")); 
    601601            } else { 
    602602                entry = vfs_s_new_entry (me, p, inode); 
    603603                vfs_s_insert_entry (me, parent, entry); 
    tar_open_archive (struct vfs_class *me, struct vfs_s_super *archive, 
    678678 
    679679                /* Error on first record */ 
    680680            case STATUS_EOFMARK: 
    681                 message (1, MSG_ERROR, 
     681                message (D_ERROR, MSG_ERROR, 
    682682                         _ 
    683683                         ("Hmm,...\n%s\ndoesn't look like a tar archive."), 
    684684                         name); 
  • vfs/undelfs.c

    diff --git a/vfs/undelfs.c b/vfs/undelfs.c
    index cea0e79..8502598 100644
    a b undelfs_loaddel (void) 
    188188    num_delarray = 0; 
    189189    delarray = g_try_malloc (sizeof (struct deleted_info) * max_delarray); 
    190190    if (!delarray) { 
    191         message (1, undelfserr, _(" not enough memory ")); 
     191        message (D_ERROR, undelfserr, _(" not enough memory ")); 
    192192        return 0; 
    193193    } 
    194194    block_buf = g_try_malloc (fs->blocksize * 3); 
    195195    if (!block_buf) { 
    196         message (1, undelfserr, _(" while allocating block buffer ")); 
     196        message (D_ERROR, undelfserr, _(" while allocating block buffer ")); 
    197197        goto free_delarray; 
    198198    } 
    199199    if ((retval = ext2fs_open_inode_scan (fs, 0, &scan))) { 
    200         message (1, undelfserr, _(" open_inode_scan: %d "), retval); 
     200        message (D_ERROR, undelfserr, _(" open_inode_scan: %d "), retval); 
    201201        goto free_block_buf; 
    202202    } 
    203203    if ((retval = ext2fs_get_next_inode (scan, &ino, &inode))) { 
    204         message (1, undelfserr, _(" while starting inode scan %d "), 
     204        message (D_ERROR, undelfserr, _(" while starting inode scan %d "), 
    205205                 retval); 
    206206        goto error_out; 
    207207    } 
    undelfs_loaddel (void) 
    227227            ext2fs_block_iterate (fs, ino, 0, block_buf, 
    228228                                  undelfs_lsdel_proc, &lsd); 
    229229        if (retval) { 
    230             message (1, undelfserr, 
     230            message (D_ERROR, undelfserr, 
    231231                     _(" while calling ext2_block_iterate %d "), retval); 
    232232            goto next; 
    233233        } 
    undelfs_loaddel (void) 
    238238                                   sizeof (struct deleted_info) * 
    239239                                   (max_delarray + 50)); 
    240240                if (!delarray_new) { 
    241                     message (1, undelfserr, 
     241                    message (D_ERROR, undelfserr, 
    242242                             _ 
    243243                             (" no more memory while reallocating array ")); 
    244244                    goto error_out; 
    undelfs_loaddel (void) 
    261261      next: 
    262262        retval = ext2fs_get_next_inode (scan, &ino, &inode); 
    263263        if (retval) { 
    264             message (1, undelfserr, _(" while doing inode scan %d "), 
     264            message (D_ERROR, undelfserr, _(" while doing inode scan %d "), 
    265265                     retval); 
    266266            goto error_out; 
    267267        } 
    com_err (const char *whoami, long err_code, const char *fmt, ...) 
    296296    str = g_strdup_vprintf (fmt, ap); 
    297297    va_end (ap); 
    298298 
    299     message (1, _(" Ext2lib error "), " %s (%s: %ld) ", str, whoami, 
     299    message (D_ERROR, _(" Ext2lib error "), " %s (%s: %ld) ", str, whoami, 
    300300             err_code); 
    301301    g_free (str); 
    302302} 
    undelfs_opendir (struct vfs_class *me, const char *dirname) 
    324324    } 
    325325 
    326326    if (ext2fs_open (ext2_fname, 0, 0, 0, unix_io_manager, &fs)){ 
    327         message (1, undelfserr, _(" Cannot open file %s "), ext2_fname); 
     327        message (D_ERROR, undelfserr, _(" Cannot open file %s "), ext2_fname); 
    328328        return 0; 
    329329    } 
    330330    print_vfs_message (_("undelfs: reading inode bitmap...")); 
    331331    if (ext2fs_read_inode_bitmap (fs)){ 
    332         message (1, undelfserr, 
     332        message (D_ERROR, undelfserr, 
    333333                 _(" Cannot load inode bitmap from: \n %s \n"), ext2_fname); 
    334334        goto quit_opendir; 
    335335    } 
    336336    print_vfs_message (_("undelfs: reading block bitmap...")); 
    337337    if (ext2fs_read_block_bitmap (fs)){ 
    338         message (1, undelfserr, 
     338        message (D_ERROR, undelfserr, 
    339339                 _(" Cannot load block bitmap from: \n %s \n"), ext2_fname); 
    340340        goto quit_opendir; 
    341341    } 
    undelfs_readdir(void *vfs_info) 
    359359    static char *const dirent_dest = undelfs_readdir_data.dent.d_name; 
    360360 
    361361    if (vfs_info != fs) { 
    362         message (1, undelfserr, _(" vfs_info is not fs! ")); 
     362        message (D_ERROR, undelfserr, _(" vfs_info is not fs! ")); 
    363363        return NULL; 
    364364    } 
    365365    if (readdir_ptr == num_delarray) 
    undelfs_open (struct vfs_class *me, const char *fname, int flags, int mode) 
    413413        return 0; 
    414414 
    415415    if (!ext2_fname || strcmp (ext2_fname, file)) { 
    416         message (1, undelfserr, 
     416        message (D_ERROR, undelfserr, 
    417417                 _(" You have to chdir to extract files first ")); 
    418418        g_free (file); 
    419419        g_free (f); 
    undelfs_read (void *vfs_info, char *buffer, int count) 
    537537    retval = ext2fs_block_iterate(fs, p->inode, 0, NULL, 
    538538                                  undelfs_dump_read, p); 
    539539    if (retval){ 
    540         message (1, undelfserr, _(" while iterating over blocks ")); 
     540        message (D_ERROR, undelfserr, _(" while iterating over blocks ")); 
    541541        return -1; 
    542542    } 
    543543    if (p->error_code && !p->finished) 
    undelfs_lstat (struct vfs_class *me, const char *path, struct stat *buf) 
    598598    } 
    599599         
    600600    if (!ext2_fname || strcmp (ext2_fname, file)){ 
    601         message (1, undelfserr, _(" You have to chdir to extract files first ")); 
     601        message (D_ERROR, undelfserr, _(" You have to chdir to extract files first ")); 
    602602        g_free (file); 
    603603        g_free (f); 
    604604        return 0; 
    undelfs_chdir(struct vfs_class *me, const char *path) 
    637637    /* this could be fixed by making an ext2fs io manager to use */ 
    638638    /* our vfs, but that is left as an excercise for the reader */ 
    639639    if ((fd = open (file, O_RDONLY)) == -1){ 
    640         message (1, undelfserr, _(" Cannot open file %s "), file); 
     640        message (D_ERROR, undelfserr, _(" Cannot open file %s "), file); 
    641641        g_free (f); 
    642642        g_free (file); 
    643643        return -1; 
  • vfs/utilvfs.c

    diff --git a/vfs/utilvfs.c b/vfs/utilvfs.c
    index 5f3b5a9..ce61f49 100644
    a b vfs_parse_ls_lga (const char *p, struct stat *s, char **filename, 
    818818        static int errorcount = 0; 
    819819 
    820820        if (++errorcount < 5) { 
    821             message (1, _("Cannot parse:"), "%s", 
     821            message (D_ERROR, _("Cannot parse:"), "%s", 
    822822                     (p_copy && *p_copy) ? p_copy : line); 
    823823        } else if (errorcount == 5) 
    824             message (1, MSG_ERROR, 
     824            message (D_ERROR, MSG_ERROR, 
    825825                     _("More parsing errors will be ignored.")); 
    826826    } 
    827827 
    vfs_parse_ls_lga (const char *p, struct stat *s, char **filename, 
    832832void 
    833833vfs_die (const char *m) 
    834834{ 
    835     message (1, _("Internal error:"), "%s", m); 
     835    message (D_ERROR, _("Internal error:"), "%s", m); 
    836836    exit (1); 
    837837} 
    838838 
  • vfs/vfs.c

    diff --git a/vfs/vfs.c b/vfs/vfs.c
    index 21b5404..2d60a51 100644
    a b mc_def_ungetlocalcopy (struct vfs_class *vfs, const char *filename, 
    841841    return 0; 
    842842 
    843843  failed: 
    844     message (1, _("Changes to file lost"), "%s", filename); 
     844    message (D_ERROR, _("Changes to file lost"), "%s", filename); 
    845845    if (fdout != -1) 
    846846        mc_close (fdout); 
    847847    if (fdin != -1)