if (!aliases)
{
- mutt_error _("You have no aliases!");
+ mutt_error (_("You have no aliases!"));
return;
}
/* check to see if the user already has an alias defined */
if (mutt_lookup_alias (buf))
{
- mutt_error _("You already have an alias defined with that name!");
+ mutt_error (_("You already have an alias defined with that name!"));
return;
}
command, sizeof (command)))
{
/* For now, editing requires a file, no piping */
- mutt_error _("Mailcap compose entry requires %%s");
+ mutt_error (_("Mailcap compose entry requires %%s"));
}
else
{
if ((fp = safe_fopen (a->filename, "r")) == NULL)
{
- mutt_perror _("Failure to open file to parse headers.");
+ mutt_perror (_("Failure to open file to parse headers."));
goto bailout;
}
mutt_mktemp (tempfile, sizeof (tempfile));
if ((tfp = safe_fopen (tempfile, "w")) == NULL)
{
- mutt_perror _("Failure to open file to strip headers.");
+ mutt_perror (_("Failure to open file to strip headers."));
goto bailout;
}
mutt_copy_stream (fp, tfp);
mutt_unlink (a->filename);
if (mutt_rename_file (tempfile, a->filename) != 0)
{
- mutt_perror _("Failure to rename file.");
+ mutt_perror (_("Failure to rename file."));
goto bailout;
}
command, sizeof (command)))
{
/* For now, editing requires a file, no piping */
- mutt_error _("Mailcap Edit entry requires %%s");
+ mutt_error (_("Mailcap Edit entry requires %%s"));
goto bailout;
}
else
{
/* fallback to view as text */
rfc1524_free_entry (&entry);
- mutt_error _("No matching mailcap entry found. Viewing as text.");
+ mutt_error (_("No matching mailcap entry found. Viewing as text."));
flag = MUTT_AS_TEXT;
use_mailcap = 0;
}
{
if (!entry->command)
{
- mutt_error _("MIME type not defined. Cannot view attachment.");
+ mutt_error (_("MIME type not defined. Cannot view attachment."));
goto return_error;
}
strfcpy (command, entry->command, sizeof (command));
if(tempfd != -1)
close(tempfd);
- mutt_error _("Cannot create filter");
+ mutt_error (_("Cannot create filter"));
goto return_error;
}
if (thepid < 0)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
goto bail;
}
if (thepid < 0)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
safe_fclose (&ifp);
goto bail;
}
if (mutt_copy_stream (ofp, nfp) == -1)
{
- mutt_error _("Write fault!");
+ mutt_error (_("Write fault!"));
safe_fclose (&ofp);
safe_fclose (&nfp);
return (-1);
if ((thepid = mutt_create_filter (command, &fpout, NULL, NULL)) < 0)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
rfc1524_free_entry (&entry);
safe_fclose (&ifp);
return 0;
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (NONULL(PrintCmd), &fpout, NULL, NULL)) < 0)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
goto bail0;
}
}
else
{
- mutt_error _("I don't know how to print that!");
+ mutt_error (_("I don't know how to print that!"));
return 0;
}
}
int ot;
if (S_ISDIR (ff->mode) || (S_ISLNK (ff->mode) && link_is_dir (LastDir, ff->name)))
{
- mutt_error _("Can't attach a directory!");
+ mutt_error (_("Can't attach a directory!"));
return 0;
}
if (!state.entrylen)
{
- mutt_error _("No files match the file mask");
+ mutt_error (_("No files match the file mask"));
break;
}
imap_parse_path (state.entry[nentry].name, &mx);
if (!mx.mbox)
{
- mutt_error _("Cannot delete root folder");
+ mutt_error (_("Cannot delete root folder"));
break;
}
snprintf (msg, sizeof (msg), _("Really delete mailbox \"%s\"?"),
memset (&state.entry[state.entrylen - 1], 0,
sizeof (struct folder_file));
state.entrylen--;
- mutt_message _("Mailbox deleted.");
+ mutt_message (_("Mailbox deleted."));
init_menu (&state, menu, title, sizeof (title), buffy);
MAYBE_REDRAW (menu->redraw);
}
}
else
- mutt_message _("Mailbox not deleted.");
+ mutt_message (_("Mailbox not deleted."));
FREE (&mx.mbox);
}
break;
strfcpy (LastDir, buf, sizeof (LastDir));
else
{
- mutt_error _("Error scanning directory.");
+ mutt_error (_("Error scanning directory."));
if (examine_directory (menu, &state, LastDir, prefix) == -1)
{
mutt_menuDestroy (&menu);
init_menu (&state, menu, title, sizeof (title), buffy);
else
{
- mutt_error _("Error scanning directory.");
+ mutt_error (_("Error scanning directory."));
mutt_menuDestroy (&menu);
goto bail;
}
killPrefix = 0;
if (!state.entrylen)
{
- mutt_error _("No files match the file mask");
+ mutt_error (_("No files match the file mask"));
break;
}
}
case OP_BROWSER_VIEW_FILE:
if (!state.entrylen)
{
- mutt_error _("No files match the file mask");
+ mutt_error (_("No files match the file mask"));
break;
}
(S_ISLNK (state.entry[menu->current].mode) &&
link_is_dir (LastDir, state.entry[menu->current].name)))
{
- mutt_error _("Can't view a directory");
+ mutt_error (_("Can't view a directory"));
break;
}
else
menu->redraw = REDRAW_FULL;
}
else
- mutt_error _("Error trying to view file");
+ mutt_error (_("Error trying to view file"));
}
break;
mutt_mktemp (tempfile, sizeof (tempfile));
if ((fpout = safe_fopen (tempfile, "w")) == NULL)
{
- mutt_error _("Could not create temporary file!");
+ mutt_error (_("Could not create temporary file!"));
return (0);
}
if (cur->security & GOODSIGN)
{
if (!crypt_smime_verify_sender(cur))
- mutt_message ( _("S/MIME signature successfully verified."));
+ mutt_message (_("S/MIME signature successfully verified."));
else
- mutt_error ( _("S/MIME certificate owner does not match sender."));
+ mutt_error (_("S/MIME certificate owner does not match sender."));
}
else if (cur->security & PARTSIGN)
mutt_message (_("Warning: Part of this message has not been signed."));
else if (cur->security & SIGN || cur->security & BADSIGN)
- mutt_error ( _("S/MIME signature could NOT be verified."));
+ mutt_error (_("S/MIME signature could NOT be verified."));
}
if (WithCrypto
mutt_set_flag (Context, cur, MUTT_READ, 1);
if (r != -1 && option (OPTPROMPTAFTER))
{
- mutt_unget_event (mutt_any_key_to_continue _("Command: "), 0);
+ mutt_unget_event (mutt_any_key_to_continue(_("Command: ")), 0);
rc = km_dokey (MENU_PAGER);
}
else
{
if (!h->env->from)
{
- mutt_error _("Warning: message contains no From: header");
+ mutt_error (_("Warning: message contains no From: header"));
mutt_sleep (2);
}
}
{
if (Context->hdrs[rc]->tagged && !Context->hdrs[rc]->env->from)
{
- mutt_error _("Warning: message contains no From: header");
+ mutt_error (_("Warning: message contains no From: header"));
mutt_sleep (2);
break;
}
if (!(adr = mutt_parse_adrlist (adr, buf)))
{
- mutt_error _("Error parsing address!");
+ mutt_error (_("Error parsing address!"));
return;
}
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
- mutt_perror _("Can't create filter process");
+ mutt_perror (_("Can't create filter process"));
return 1;
}
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
- mutt_perror _("Can't create filter process");
+ mutt_perror (_("Can't create filter process"));
return 1;
}
pipe_msg (Context->hdrs[Context->v2r[i]], fpout, decode, print);
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
- mutt_perror _("Can't create filter process");
+ mutt_perror (_("Can't create filter process"));
return 1;
}
for (i = 0; i < Context->vcount; i++)
static const char* There_are_no_attachments = N_("There are no attachments.");
-#define CHECK_COUNT if (idxlen == 0) { mutt_error _(There_are_no_attachments); break; }
+#define CHECK_COUNT if (idxlen == 0) { mutt_error(_(There_are_no_attachments)); break; }
if (!chain)
{
- addstr ("<no chain defined>");
+ addstr (_("<no chain defined>"));
mutt_window_clrtoeol (MuttIndexWindow);
return;
}
if (x == 0 && menu->max == 1)
{
- mutt_error _("You may not delete the only attachment.");
+ mutt_error (_("You may not delete the only attachment."));
idx[x]->content->tagged = 0;
return (-1);
}
error = 0;
if (numfiles > 1)
- mutt_message _("Attaching selected files...");
+ mutt_message (_("Attaching selected files..."));
for (i = 0; i < numfiles; i++)
{
char *att = files[i];
{
mx_close_mailbox (ctx, NULL);
FREE (&ctx);
- mutt_error _("No messages in that folder.");
+ mutt_error (_("No messages in that folder."));
break;
}
Context = ctx;
set_option(OPTATTACHMSG);
- mutt_message _("Tag the messages you want to attach!");
+ mutt_message (_("Tag the messages you want to attach!"));
close = mutt_index_menu ();
unset_option(OPTATTACHMSG);
update_idx (menu, idx, idxlen++);
else
{
- mutt_error _("Unable to attach!");
+ mutt_error (_("Unable to attach!"));
FREE (&idx[idxlen]);
}
}
mutt_clear_error();
}
else
- mutt_error _("Invalid encoding.");
+ mutt_error (_("Invalid encoding."));
}
mutt_message_hook (NULL, msg, MUTT_SEND2HOOK);
break;
if (!(p = strchr (type, '/')))
{
- mutt_error _("Content-Type is of the form base/sub");
+ mutt_error (_("Content-Type is of the form base/sub"));
continue;
}
*p++ = 0;
if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL)
{
- mutt_error _("What we have here is a failure to make an attachment");
+ mutt_error (_("What we have here is a failure to make an attachment"));
continue;
}
update_idx (menu, idx, idxlen++);
if (mutt_write_fcc (fname, msg, NULL, 0, NULL, NULL) < 0)
msg->content = mutt_remove_multipart (msg->content);
else
- mutt_message _("Message written.");
+ mutt_message (_("Message written."));
}
break;
if (ferror (fp))
{
- mutt_perror ("[tempfile]");
+ mutt_perror (_("[tempfile]"));
return -1;
}
}
}
if ((fp = safe_fopen (tempf, tempf == tempfb ? "w+" : "a+")) == NULL)
{
- mutt_perror _("Can't create temporary file");
+ mutt_perror (_("Can't create temporary file"));
return NULL;
}
}
mutt_free_body (&tattach);
- mutt_message _("PGP message successfully decrypted.");
+ mutt_message (_("PGP message successfully decrypted."));
}
else
{
- mutt_error _("Could not decrypt PGP message");
+ mutt_error (_("Could not decrypt PGP message"));
mutt_sleep (2);
rc = -1;
}
mutt_mktemp (tempfile, sizeof (tempfile));
if (!(fp = safe_fopen (tempfile, "w")))
{
- mutt_perror _("Can't create temporary file");
+ mutt_perror (_("Can't create temporary file"));
return;
}
- mutt_message _("Collecting data...");
+ mutt_message (_("Collecting data..."));
print_key_info (key->kobj, fp);
if (!i && unusable)
{
- mutt_error _("All matching keys are marked expired/revoked.");
+ mutt_error (_("All matching keys are marked expired/revoked."));
mutt_sleep (1);
return NULL;
}
{
if (!crypt_key_is_valid (key_table[menu->current]))
{
- mutt_error _("This key can't be used: "
- "expired/disabled/revoked.");
+ mutt_error(_("This key can't be used: "
+ "expired/disabled/revoked."));
break;
}
}
crypt_smime_void_passphrase ();
if (WithCrypto)
- mutt_message _("Passphrase(s) forgotten.");
+ mutt_message(_("Passphrase(s) forgotten."));
}
if (query_quadoption (OPT_PGPMIMEAUTO,
_("Inline PGP can't be used with attachments. Revert to PGP/MIME?")) != MUTT_YES)
{
- mutt_error _("Mail not sent: inline PGP can't be used with attachments.");
+ mutt_error (_("Mail not sent: inline PGP can't be used with attachments."));
return -1;
}
}
else
{
/* they really want to send it inline... go for it */
- if (!isendwin ()) mutt_endwin _("Invoking PGP...");
+ if (!isendwin ()) mutt_endwin(_("Invoking PGP..."));
pbody = crypt_pgp_traditional_encryptsign (msg->content, flags, keylist);
if (pbody)
{
/* otherwise inline won't work...ask for revert */
if (query_quadoption (OPT_PGPMIMEAUTO, _("Message can't be sent inline. Revert to using PGP/MIME?")) != MUTT_YES)
{
- mutt_error _("Mail not sent.");
+ mutt_error (_("Mail not sent."));
return -1;
}
}
void crypt_invoke_message (int type)
{
if ((WithCrypto & APPLICATION_PGP) && (type & APPLICATION_PGP))
- mutt_message _("Invoking PGP...");
+ mutt_message (_("Invoking PGP..."));
else if ((WithCrypto & APPLICATION_SMIME) && (type & APPLICATION_SMIME))
- mutt_message _("Invoking S/MIME...");
+ mutt_message (_("Invoking S/MIME..."));
}
#define CHECK_IN_MAILBOX if (!Context) \
{ \
mutt_flushinp (); \
- mutt_error _(No_mailbox_is_open); \
+ mutt_error(_(No_mailbox_is_open)); \
break; \
}
#define CHECK_MSGCOUNT if (!Context) \
{ \
mutt_flushinp (); \
- mutt_error _(No_mailbox_is_open); \
+ mutt_error(_(No_mailbox_is_open)); \
break; \
} \
else if (!Context->msgcount) \
{ \
mutt_flushinp (); \
- mutt_error _(There_are_no_messages); \
+ mutt_error(_(There_are_no_messages)); \
break; \
}
#define CHECK_VISIBLE if (Context && menu->current >= Context->vcount) \
{\
mutt_flushinp (); \
- mutt_error _(No_visible); \
+ mutt_error(_(No_visible)); \
break; \
}
#define CHECK_READONLY if (Context->readonly) \
{ \
mutt_flushinp (); \
- mutt_error _(Mailbox_is_read_only); \
+ mutt_error(_(Mailbox_is_read_only)); \
break; \
}
#define CHECK_ATTACH if(option(OPTATTACHMSG)) \
{\
mutt_flushinp (); \
- mutt_error _(Function_not_permitted_in_attach_message_mode); \
+ mutt_error(_(Function_not_permitted_in_attach_message_mode)); \
break; \
}
if (ctx->readonly)
{
- mutt_error _("Cannot toggle write on a readonly mailbox!");
+ mutt_error (_("Cannot toggle write on a readonly mailbox!"));
return -1;
}
if (ctx->dontwrite)
{
ctx->dontwrite = 0;
- mutt_message _("Changes to folder will be written on folder exit.");
+ mutt_message (_("Changes to folder will be written on folder exit."));
}
else
{
ctx->dontwrite = 1;
- mutt_message _("Changes to folder will not be written.");
+ mutt_message (_("Changes to folder will not be written."));
}
return 0;
{
/* notify the user of new mail */
if (check == MUTT_REOPENED)
- mutt_error _("Mailbox was externally modified. Flags may be wrong.");
+ mutt_error (_("Mailbox was externally modified. Flags may be wrong."));
else if (check == MUTT_NEW_MAIL)
{
for (i = oldcount; i < Context->msgcount; i++)
}
}
} else if (check == MUTT_FLAGS)
- mutt_message _("Mailbox was externally modified.");
+ mutt_message (_("Mailbox was externally modified."));
/* avoid the message being overwritten by buffy */
do_buffy_notify = 0;
{
if (!Context)
{
- mutt_error _("No mailbox is open.");
+ mutt_error (_("No mailbox is open."));
continue;
}
if (!Context->tagged)
{
- mutt_error _("No tagged messages.");
+ mutt_error (_("No tagged messages."));
continue;
}
tag = 1;
{
if (!Context)
{
- mutt_error _("No mailbox is open.");
+ mutt_error (_("No mailbox is open."));
continue;
}
if (!Context->tagged)
{
mutt_flush_macro_to_endcond ();
- mutt_message _("Nothing to do.");
+ mutt_message (_("Nothing to do."));
continue;
}
tag = 1;
if (mutt_atoi (buf, &i) < 0)
{
- mutt_error _("Argument must be a message number.");
+ mutt_error (_("Argument must be a message number."));
break;
}
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("That message is not visible.");
+ mutt_error (_("That message is not visible."));
}
else
- mutt_error _("Invalid message number.");
+ mutt_error (_("Invalid message number."));
break;
case OP_MAIN_SHOW_LIMIT:
CHECK_IN_MAILBOX;
if (!Context->pattern)
- mutt_message _("No limit pattern is in effect.");
+ mutt_message (_("No limit pattern is in effect."));
else
{
char buf[STRING];
menu->redraw = REDRAW_FULL;
}
if (Context->pattern)
- mutt_message _("To view all messages, limit to \"all\".");
+ mutt_message (_("To view all messages, limit to \"all\"."));
break;
case OP_QUIT:
FREE (&Context);
}
imap_logout_all();
- mutt_message _("Logged out of IMAP servers.");
+ mutt_message (_("Logged out of IMAP servers."));
set_option (OPTSEARCHINVALID);
menu->redraw = REDRAW_FULL;
break;
mutt_buffy (buf, sizeof (buf));
if (!buf[0])
{
- mutt_error _("No mailboxes have new mail");
+ mutt_error (_("No mailboxes have new mail"));
break;
}
}
CHECK_ACL(MUTT_ACL_WRITE, _("Cannot break thread"));
if ((Sort & SORT_MASK) != SORT_THREADS)
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
else if (CURHDR->env->in_reply_to || CURHDR->env->references)
{
{
}
Context->changed = 1;
- mutt_message _("Thread broken");
+ mutt_message (_("Thread broken"));
if (menu->menu == MENU_PAGER)
{
menu->redraw |= REDRAW_INDEX;
}
else
- mutt_error _("Thread cannot be broken, message is not part of a thread");
+ mutt_error (_("Thread cannot be broken, message is not part of a thread"));
break;
CHECK_ACL(MUTT_ACL_WRITE, _("Cannot link threads"));
if ((Sort & SORT_MASK) != SORT_THREADS)
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
else if (!CURHDR->env->message_id)
- mutt_error _("No Message-ID: header available to link thread");
+ mutt_error (_("No Message-ID: header available to link thread"));
else if (!tag && (!Context->last_tag || !Context->last_tag->tagged))
- mutt_error _("First, please tag a message to be linked here");
+ mutt_error (_("First, please tag a message to be linked here"));
else
{
HEADER *oldcur = CURHDR;
menu->current = oldcur->virtual;
Context->changed = 1;
- mutt_message _("Threads linked");
+ mutt_message (_("Threads linked"));
}
else
- mutt_error _("No thread linked");
+ mutt_error (_("No thread linked"));
}
if (menu->menu == MENU_PAGER)
if (menu->current >= Context->vcount - 1)
{
if (menu->menu == MENU_MAIN)
- mutt_error _("You are on the last message.");
+ mutt_error (_("You are on the last message."));
break;
}
if ((menu->current = ci_next_undeleted (menu->current)) == -1)
{
menu->current = menu->oldcurrent;
if (menu->menu == MENU_MAIN)
- mutt_error _("No undeleted messages.");
+ mutt_error (_("No undeleted messages."));
}
else if (menu->menu == MENU_PAGER)
{
if (menu->current >= Context->vcount - 1)
{
if (menu->menu == MENU_MAIN)
- mutt_error _("You are on the last message.");
+ mutt_error (_("You are on the last message."));
break;
}
menu->current++;
CHECK_VISIBLE;
if (menu->current < 1)
{
- mutt_error _("You are on the first message.");
+ mutt_error (_("You are on the first message."));
break;
}
if ((menu->current = ci_previous_undeleted (menu->current)) == -1)
{
menu->current = menu->oldcurrent;
if (menu->menu == MENU_MAIN)
- mutt_error _("No undeleted messages.");
+ mutt_error (_("No undeleted messages."));
}
else if (menu->menu == MENU_PAGER)
{
CHECK_VISIBLE;
if (menu->current < 1)
{
- if (menu->menu == MENU_MAIN) mutt_error _("You are on the first message.");
+ if (menu->menu == MENU_MAIN) mutt_error (_("You are on the first message."));
break;
}
menu->current--;
i++;
if (i > Context->vcount - 1)
{
- mutt_message _("Search wrapped to top.");
+ mutt_message (_("Search wrapped to top."));
i = 0;
}
}
i--;
if (i < 0)
{
- mutt_message _("Search wrapped to bottom.");
+ mutt_message (_("Search wrapped to bottom."));
i = Context->vcount - 1;
}
}
{
menu->current = menu->oldcurrent;
if (op == OP_MAIN_NEXT_THREAD || op == OP_MAIN_NEXT_SUBTHREAD)
- mutt_error _("No more threads.");
+ mutt_error (_("No more threads."));
else
- mutt_error _("You are on the first thread.");
+ mutt_error (_("You are on the first thread."));
}
else if (menu->menu == MENU_PAGER)
{
if ((Sort & SORT_MASK) != SORT_THREADS)
{
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
break;
}
}
else
{
- mutt_error _("Thread contains unread messages.");
+ mutt_error (_("Thread contains unread messages."));
break;
}
if ((Sort & SORT_MASK) != SORT_THREADS)
{
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
return (-1);
}
if (thepid < 0)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
if (s->flags & MUTT_DISPLAY)
{
state_mark_attach (s);
mutt_mktemp (tempfile, sizeof (tempfile));
if ((s->fpout = safe_fopen (tempfile, "w")) == NULL)
{
- mutt_error _("Unable to open temporary file!");
+ mutt_error (_("Unable to open temporary file!"));
dprint (1, (debugfile, "Can't open %s.\n", tempfile));
return -1;
}
s->fpin = safe_fopen ("/dev/null", "r");
}
if (!s->fpin) {
- mutt_perror ("failed to re-open memstream!");
+ mutt_perror (_("failed to re-open memstream!"));
return -1;
}
#else
p = mutt_get_parameter ("protocol", b->parameter);
if (!p)
- mutt_error _("Error: multipart/signed has no protocol.");
+ mutt_error (_("Error: multipart/signed has no protocol."));
else if (s->flags & MUTT_VERIFY)
handler = mutt_signed_handler;
}
if (idata->conn->account.user[0] != '\0')
return IMAP_AUTH_UNAVAIL;
- mutt_message _("Authenticating (anonymous)...");
+ mutt_message (_("Authenticating (anonymous)..."));
imap_cmd_start (idata, "AUTHENTICATE ANONYMOUS");
return IMAP_AUTH_SUCCESS;
bail:
- mutt_error _("Anonymous authentication failed.");
+ mutt_error (_("Anonymous authentication failed."));
mutt_sleep (2);
return IMAP_AUTH_FAILURE;
}
if (!mutt_bit_isset (idata->capabilities, ACRAM_MD5))
return IMAP_AUTH_UNAVAIL;
- mutt_message _("Authenticating (CRAM-MD5)...");
+ mutt_message (_("Authenticating (CRAM-MD5)..."));
/* get auth info */
if (mutt_account_getlogin (&idata->conn->account))
return IMAP_AUTH_SUCCESS;
bail:
- mutt_error _("CRAM-MD5 authentication failed.");
+ mutt_error (_("CRAM-MD5 authentication failed."));
mutt_sleep (2);
return IMAP_AUTH_FAILURE;
}
}
/* now begin login */
- mutt_message _("Authenticating (GSSAPI)...");
+ mutt_message (_("Authenticating (GSSAPI)..."));
imap_cmd_start (idata, "AUTHENTICATE GSSAPI");
while (rc == IMAP_CMD_CONTINUE);
bail:
- mutt_error _("GSSAPI authentication failed.");
+ mutt_error (_("GSSAPI authentication failed."));
mutt_sleep (2);
return IMAP_AUTH_FAILURE;
}
if (mutt_bit_isset (idata->capabilities, LOGINDISABLED))
{
- mutt_message _("LOGIN disabled on this server.");
+ mutt_message (_("LOGIN disabled on this server."));
return IMAP_AUTH_UNAVAIL;
}
if (mutt_account_getpass (&idata->conn->account))
return IMAP_AUTH_FAILURE;
- mutt_message _("Logging in...");
+ mutt_message (_("Logging in..."));
imap_quote_string (q_user, sizeof (q_user), idata->conn->account.user);
imap_quote_string (q_pass, sizeof (q_pass), idata->conn->account.pass);
return IMAP_AUTH_SUCCESS;
}
- mutt_error _("Login failed.");
+ mutt_error (_("Login failed."));
mutt_sleep (2);
return IMAP_AUTH_FAILURE;
}
if (mutt_account_getpass(&idata->conn->account))
return IMAP_AUTH_FAILURE;
- mutt_message _("Logging in...");
+ mutt_message(_("Logging in..."));
mutt_sasl_plain_msg(buf, STRING, "AUTHENTICATE PLAIN",
idata->conn->account.user, idata->conn->account.user,
}
else if (rc == IMAP_CMD_NO)
{
- mutt_error _("Login failed.");
+ mutt_error(_("Login failed."));
mutt_sleep(2);
res = IMAP_AUTH_FAILURE;
}
return IMAP_AUTH_UNAVAIL;
}
- mutt_error _("SASL authentication failed.");
+ mutt_error (_("SASL authentication failed."));
mutt_sleep(2);
return IMAP_AUTH_FAILURE;
if (!(idata = imap_conn_find (&(mx.account), 0)))
goto fail;
- mutt_message _("Getting folder list...");
+ mutt_message (_("Getting folder list..."));
/* skip check for parents when at the root */
if (mx.mbox && mx.mbox[0] != '\0')
if (!state->entrylen)
{
- mutt_error _("No such folder");
+ mutt_error (_("No such folder"));
goto fail;
}
if (imap_create_mailbox (idata, buf) < 0)
goto fail;
- mutt_message _("Mailbox created.");
+ mutt_message (_("Mailbox created."));
mutt_sleep (0);
FREE (&mx.mbox);
if (!mx.mbox)
{
- mutt_error _("Cannot rename root folder");
+ mutt_error (_("Cannot rename root folder"));
goto fail;
}
if (option(OPTSSLFORCETLS) && ! idata->conn->ssf)
{
- mutt_error _("Encrypted connection unavailable");
+ mutt_error (_("Encrypted connection unavailable"));
mutt_sleep (1);
goto err_close_conn;
}
if (count && (imap_read_headers (idata, 0, count-1) < 0))
{
- mutt_error _("Error opening mailbox");
+ mutt_error (_("Error opening mailbox"));
mutt_sleep (1);
goto fail;
}
}
}
else
- mutt_error _("Error saving flags");
+ mutt_error (_("Error saving flags"));
rc = -1;
goto out;
}
if (expunge && !(ctx->closing) &&
mutt_bit_isset(ctx->rights, MUTT_ACL_DELETE))
{
- mutt_message _("Expunging messages from server...");
+ mutt_message (_("Expunging messages from server..."));
/* Set expunge bit so we don't get spurious reopened messages */
idata->reopen |= IMAP_EXPUNGE_EXPECTED;
if (imap_exec (idata, "EXPUNGE", 0) != 0)
}
else
{ /* Unable to fetch headers for lower versions */
- mutt_error _("Unable to fetch headers from this IMAP server version.");
+ mutt_error (_("Unable to fetch headers from this IMAP server version."));
mutt_sleep (2); /* pause a moment to let the user see the error */
goto error_out_0;
}
}
if (!isendwin())
- mutt_message _("Fetching message...");
+ mutt_message (_("Fetching message..."));
if (!(msg->fp = msg_cache_put (idata, h)))
{
if (op == '?') {
mutt_endwin (NULL);
fflush (stdout);
- printf("\nCurrent attachments settings:\n\n");
+ printf(_("\nCurrent attachments settings:\n\n"));
print_attach_list(AttachAllow, '+', "A");
print_attach_list(AttachExclude, '-', "A");
print_attach_list(InlineAllow, '+', "I");
if (option (OPTIGNOREMACROEVENTS))
{
- mutt_error _("Macros are currently disabled.");
+ mutt_error (_("Macros are currently disabled."));
return -1;
}
if (n++ == 10)
{
mutt_flushinp ();
- mutt_error _("Macro loop detected.");
+ mutt_error (_("Macro loop detected."));
return -1;
}
if(!(km_expand_key(buf, sizeof(buf), key)))
{
- mutt_error _("Key is not bound.");
+ mutt_error (_("Key is not bound."));
return;
}
tokenize_unget_string (buf);
if (km_dokey (menu) != OP_HELP)
{
- mutt_error _("Key is not bound.");
+ mutt_error (_("Key is not bound."));
return;
}
if (((size_t) -1) / nmemb <= size)
{
- mutt_error _("Integer overflow -- can't allocate memory!");
+ mutt_error (_("Integer overflow -- can't allocate memory!"));
sleep (1);
mutt_exit (1);
}
if (!(p = calloc (nmemb, size)))
{
- mutt_error _("Out of memory!");
+ mutt_error (_("Out of memory!"));
sleep (1);
mutt_exit (1);
}
return 0;
if ((p = malloc (siz)) == 0) /* __MEM_CHECKED__ */
{
- mutt_error _("Out of memory!");
+ mutt_error (_("Out of memory!"));
sleep (1);
mutt_exit (1);
}
if (!r)
{
- mutt_error _("Out of memory!");
+ mutt_error (_("Out of memory!"));
sleep (1);
mutt_exit (1);
}
# ifdef ENABLE_NLS
# include <libintl.h>
-# define _(a) (gettext (a))
+# define _(a) gettext (a)
# ifdef gettext_noop
# define N_(a) gettext_noop (a)
# else
{
puts (mutt_make_version ());
- puts _(
+ puts (_(
"usage: mutt [<options>] [-z] [-f <file> | -yZ]\n\
mutt [<options>] [-Ex] [-Hi <file>] [-s <subj>] [-bc <addr>] [-a <file> [...] --] <addr> [...]\n\
mutt [<options>] [-x] [-s <subj>] [-bc <addr>] [-a <file> [...] --] <addr> [...] < message\n\
mutt [<options>] -A <alias> [...]\n\
mutt [<options>] -Q <query> [...]\n\
mutt [<options>] -D [-S]\n\
- mutt -v[v]\n");
+ mutt -v[v]\n"));
- puts _("\
+ puts (_("\
options:\n\
-A <alias>\texpand the given alias\n\
-a <file> [...] --\tattach file(s) to the message\n\
-b <address>\tspecify a blind carbon-copy (BCC) address\n\
-c <address>\tspecify a carbon-copy (CC) address\n\
-D\t\tprint the value of all variables to stdout\n\
- -D -S\t\tlike -D, but hide the value of sensitive variables");
+ -D -S\t\tlike -D, but hide the value of sensitive variables"));
#if DEBUG
- puts _(" -d <level>\tlog debugging output to ~/.muttdebug0");
+ puts (_(" -d <level>\tlog debugging output to ~/.muttdebug0"));
#endif
- puts _(
+ puts (_(
" -E\t\tedit the draft (-H) or include (-i) file\n\
-e <command>\tspecify a command to be executed after initialization\n\
-f <file>\tspecify which mailbox to read\n\
-i <file>\tspecify a file which Mutt should include in the body\n\
-m <type>\tspecify a default mailbox type\n\
-n\t\tcauses Mutt not to read the system Muttrc\n\
- -p\t\trecall a postponed message");
+ -p\t\trecall a postponed message"));
- puts _("\
+ puts (_("\
-Q <variable>\tquery a configuration variable\n\
-R\t\topen mailbox in read-only mode\n\
-s <subj>\tspecify a subject (must be in quotes if it has spaces)\n\
-y\t\tselect a mailbox specified in your `mailboxes' list\n\
-z\t\texit immediately if there are no messages in the mailbox\n\
-Z\t\topen the first folder with new message, exit immediately if none\n\
- -h\t\tthis help message");
+ -h\t\tthis help message"));
exit (0);
}
#endif
if (initscr () == NULL)
{
- puts _("Error initializing terminal.");
+ puts (_("Error initializing terminal."));
exit (1);
}
#if 1 /* USE_SLANG_CURSES - commenting out suggested in #455. */
}
printf (_("Debugging at level %d.\n"), debuglevel);
#else
- printf _("DEBUG was not defined during compilation. Ignored.\n");
+ printf (_("DEBUG was not defined during compilation. Ignored.\n"));
#endif
break;
if (mutt_yesorno (msg, MUTT_YES) == MUTT_YES)
{
if (mkdir (fpath, 0700) == -1 && errno != EEXIST)
- mutt_error ( _("Can't create %s: %s."), Maildir, strerror (errno));
+ mutt_error (_("Can't create %s: %s."), Maildir, strerror (errno));
}
}
}
{
if (!mutt_buffy_check (0))
{
- mutt_endwin _("No mailbox with new mail.");
+ mutt_endwin (_("No mailbox with new mail."));
exit (1);
}
folder[0] = 0;
else
#endif
if (!Incoming) {
- mutt_endwin _("No incoming mailboxes defined.");
+ mutt_endwin (_("No incoming mailboxes defined."));
exit (1);
}
folder[0] = 0;
mutt_endwin (strerror (errno));
exit (1);
case 1:
- mutt_endwin _("Mailbox is empty.");
+ mutt_endwin (_("Mailbox is empty."));
exit (1);
}
}
if (fseeko (ctx->fp, loc, SEEK_SET) != 0)
{
dprint (1, (debugfile, "mmdf_parse_mailbox: fseek() failed\n"));
- mutt_error _("Mailbox is corrupt!");
+ mutt_error (_("Mailbox is corrupt!"));
return (-1);
}
}
else
{
dprint (1, (debugfile, "mmdf_parse_mailbox: corrupt mailbox!\n"));
- mutt_error _("Mailbox is corrupt!");
+ mutt_error (_("Mailbox is corrupt!"));
return (-1);
}
}
if ((fflush (msg->fp) == EOF) ||
(fsync (fileno (msg->fp)) == -1))
{
- mutt_perror _("Can't write message");
+ mutt_perror (_("Can't write message"));
return -1;
}
if ((fflush (msg->fp) == EOF) ||
(fsync (fileno (msg->fp)) == -1))
{
- mutt_perror _("Can't write message");
+ mutt_perror (_("Can't write message"));
return -1;
}
mbox_unlock_mailbox (ctx);
mx_fastclose_mailbox (ctx);
mutt_unblock_signals ();
- mutt_error _("Mailbox was corrupted!");
+ mutt_error (_("Mailbox was corrupted!"));
return (-1);
}
if ((ctx->fp = freopen (ctx->path, "r+", ctx->fp)) == NULL)
{
mx_fastclose_mailbox (ctx);
- mutt_error _("Fatal error! Could not reopen mailbox!");
+ mutt_error (_("Fatal error! Could not reopen mailbox!"));
return (-1);
}
if (mbox_lock_mailbox (ctx, 1, 1) == -1)
{
mutt_unblock_signals ();
- mutt_error _("Unable to lock mailbox!");
+ mutt_error (_("Unable to lock mailbox!"));
goto bail;
}
close (i);
unlink (tempfile);
}
- mutt_error _("Could not create temporary file!");
+ mutt_error (_("Could not create temporary file!"));
mutt_sleep (5);
goto bail;
}
* messages were found to be changed or deleted. This should
* never happen, is we presume it is a bug in mutt.
*/
- mutt_error _("sync: mbox modified, but no modified messages! (report this bug)");
+ mutt_error (_("sync: mbox modified, but no modified messages! (report this bug)"));
mutt_sleep(5); /* the mutt_error /will/ get cleared! */
dprint(1, (debugfile, "mbox_sync_mailbox(): no modified messages.\n"));
unlink (tempfile);
* change/deleted message
*/
if (!ctx->quiet)
- mutt_message _("Committing changes...");
+ mutt_message (_("Committing changes..."));
i = mutt_copy_stream (fp, ctx->fp);
if (ferror (ctx->fp))
unlink (tempfile);
mutt_unblock_signals ();
mx_fastclose_mailbox (ctx);
- mutt_error _("Fatal error! Could not reopen mailbox!");
+ mutt_error (_("Fatal error! Could not reopen mailbox!"));
return (-1);
}
if ((ctx->fp = freopen (ctx->path, "r", ctx->fp)) == NULL)
{
- mutt_error _("Could not reopen mailbox!");
+ mutt_error (_("Could not reopen mailbox!"));
mx_fastclose_mailbox (ctx);
return (-1);
}
ctx->quiet = 1;
if (!ctx->quiet)
- mutt_message _("Reopening mailbox...");
+ mutt_message (_("Reopening mailbox..."));
/* our heuristics require the old mailbox to be unsorted */
if (Sort != SORT_ORDER)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("Invalid index number.");
+ mutt_error (_("Invalid index number."));
}
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_next_line (MUTTMENU *menu)
menu->redraw = REDRAW_INDEX;
}
else
- mutt_error _("You cannot scroll down farther.");
+ mutt_error (_("You cannot scroll down farther."));
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_prev_line (MUTTMENU *menu)
menu->redraw = REDRAW_INDEX;
}
else
- mutt_error _("You cannot scroll up farther.");
+ mutt_error (_("You cannot scroll up farther."));
}
/*
menu->current = MAX (menu->current, 0);
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
#undef DIRECTION
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_middle_page (MUTTMENU *menu)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_first_entry (MUTTMENU *menu)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_last_entry (MUTTMENU *menu)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_current_top (MUTTMENU *menu)
menu->redraw = REDRAW_INDEX;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_current_middle (MUTTMENU *menu)
menu->redraw = REDRAW_INDEX;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
void menu_current_bottom (MUTTMENU *menu)
menu->redraw = REDRAW_INDEX;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
static void menu_next_entry (MUTTMENU *menu)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("You are on the last entry.");
+ mutt_error (_("You are on the last entry."));
}
static void menu_prev_entry (MUTTMENU *menu)
menu->redraw = REDRAW_MOTION;
}
else
- mutt_error _("You are on the first entry.");
+ mutt_error (_("You are on the first entry."));
}
static int default_color (int i)
goto search_next;
}
regfree (&re);
- mutt_error _("Not found.");
+ mutt_error (_("Not found."));
return (-1);
}
}
else if (i == OP_TAG_PREFIX)
{
- mutt_error _("No tagged entries.");
+ mutt_error (_("No tagged entries."));
i = -1;
}
else /* None tagged, OP_TAG_PREFIX_COND */
{
mutt_flush_macro_to_endcond ();
- mutt_message _("Nothing to do.");
+ mutt_message (_("Nothing to do."));
i = -1;
}
}
menu->current = menu->oldcurrent;
}
else
- mutt_error _("Search is not implemented for this menu.");
+ mutt_error (_("Search is not implemented for this menu."));
break;
case OP_JUMP:
if (menu->dialog)
- mutt_error _("Jumping is not implemented for dialogs.");
+ mutt_error (_("Jumping is not implemented for dialogs."));
else
menu_jump (menu);
break;
menu->redraw = REDRAW_CURRENT;
}
else
- mutt_error _("No entries.");
+ mutt_error (_("No entries."));
}
else
- mutt_error _("Tagging is not supported.");
+ mutt_error (_("Tagging is not supported."));
break;
case OP_SHELL_ESCAPE:
return NULL;
}
#else
- mutt_error _("SSL is unavailable.");
+ mutt_error (_("SSL is unavailable."));
mutt_sleep (2);
mutt_socket_free (conn);
#ifdef USE_POP
if (magic == MUTT_POP)
{
- mutt_error _("Can't save message to POP mailbox.");
+ mutt_error (_("Can't save message to POP mailbox."));
return 1;
}
#endif
}
else
{
- mutt_error ( _("Can't dotlock %s.\n"), path);
+ mutt_error (_("Can't dotlock %s.\n"), path);
}
}
return (r == DL_EX_OK ? 0 : -1);
if (prev_sb.st_size == sb.st_size && ++count >= (timeout?MAXLOCKATTEMPT:0))
{
if (timeout)
- mutt_error _("Timeout exceeded while attempting fcntl lock!");
+ mutt_error (_("Timeout exceeded while attempting fcntl lock!"));
return -1;
}
if (prev_sb.st_size == sb.st_size && ++count >= (timeout?MAXLOCKATTEMPT:0))
{
if (timeout)
- mutt_error _("Timeout exceeded while attempting flock lock!");
+ mutt_error (_("Timeout exceeded while attempting flock lock!"));
r = -1;
break;
}
set_option (OPTCONFIRMAPPEND);
if (rc != 0)
{
- mutt_error _("message(s) not deleted");
+ mutt_error (_("message(s) not deleted"));
return -1;
}
}
else
{
- mutt_error _("Can't open trash folder");
+ mutt_error (_("Can't open trash folder"));
return -1;
}
else if (!ctx->changed && ctx->deleted == 0)
{
if (!ctx->quiet)
- mutt_message _("Mailbox is unchanged.");
+ mutt_message (_("Mailbox is unchanged."));
if (ctx->magic == MUTT_MBOX || ctx->magic == MUTT_MMDF)
mbox_reset_atime (ctx, NULL);
mx_fastclose_mailbox (ctx);
}
else if (ctx->readonly)
{
- mutt_error _("Mailbox is read-only.");
+ mutt_error (_("Mailbox is read-only."));
return -1;
}
if (!ctx->changed && !ctx->deleted)
{
if (!ctx->quiet)
- mutt_message _("Mailbox is unchanged.");
+ mutt_message (_("Mailbox is unchanged."));
return (0);
}
if (ctx->magic == MUTT_IMAP && !purge)
{
if (!ctx->quiet)
- mutt_message _("Mailbox checkpointed.");
+ mutt_message (_("Mailbox checkpointed."));
}
else
#endif
if ((ctx->hdrmax + 25) * s < ctx->hdrmax * s)
{
- mutt_error _("Integer overflow -- can't allocate memory.");
+ mutt_error (_("Integer overflow -- can't allocate memory."));
sleep (1);
mutt_exit (1);
}
time_t now;
struct tm *tm;
char buf[LONG_STRING];
- char *msg = _("Checking for new newsgroups...");
+ char *msg = (_("Checking for new newsgroups..."));
unsigned int i;
int rc, update_active = false;
#define CHECK_MODE(x) if (!(x)) \
{ \
mutt_flushinp (); \
- mutt_error _(Not_available_in_this_menu); \
+ mutt_error(_(Not_available_in_this_menu)); \
break; \
}
#define CHECK_READONLY if (!Context || Context->readonly) \
{ \
mutt_flushinp (); \
- mutt_error _(Mailbox_is_read_only); \
+ mutt_error(_(Mailbox_is_read_only)); \
break; \
}
#define CHECK_ATTACH if(option(OPTATTACHMSG)) \
{\
mutt_flushinp (); \
- mutt_error _(Function_not_permitted_in_attach_message_mode); \
+ mutt_error(_(Function_not_permitted_in_attach_message_mode)); \
break; \
}
else if (option (OPTPAGERSTOP))
{
/* emulate "less -q" and don't go on to the next message. */
- mutt_error _("Bottom of message is shown.");
+ mutt_error (_("Bottom of message is shown."));
}
else
{
topline = upNLines (pager_window->rows-PagerContext, lineInfo, topline, hideQuoted);
}
else
- mutt_error _("Top of message is shown.");
+ mutt_error (_("Top of message is shown."));
break;
case OP_NEXT_LINE:
}
}
else
- mutt_error _("Bottom of message is shown.");
+ mutt_error (_("Bottom of message is shown."));
break;
case OP_PREV_LINE:
if (topline)
topline = upNLines (1, lineInfo, topline, hideQuoted);
else
- mutt_error _("Top of message is shown.");
+ mutt_error (_("Top of message is shown."));
break;
case OP_PAGER_TOP:
if (topline)
topline = 0;
else
- mutt_error _("Top of message is shown.");
+ mutt_error (_("Top of message is shown."));
break;
case OP_HALF_UP:
if (topline)
topline = upNLines (pager_window->rows/2, lineInfo, topline, hideQuoted);
else
- mutt_error _("Top of message is shown.");
+ mutt_error (_("Top of message is shown."));
break;
case OP_HALF_DOWN:
else if (option (OPTPAGERSTOP))
{
/* emulate "less -q" and don't go on to the next message. */
- mutt_error _("Bottom of message is shown.");
+ mutt_error (_("Bottom of message is shown."));
}
else
{
if (i < lastLine)
topline = i;
else if (wrapped || !option (OPTWRAPSEARCH))
- mutt_error _("Not found.");
+ mutt_error (_("Not found."));
else
{
- mutt_message _("Search wrapped to top.");
+ mutt_message (_("Search wrapped to top."));
wrapped = 1;
goto search_next;
}
if (i >= 0)
topline = i;
else if (wrapped || !option (OPTWRAPSEARCH))
- mutt_error _("Not found.");
+ mutt_error (_("Not found."));
else
{
- mutt_message _("Search wrapped to bottom.");
+ mutt_message (_("Search wrapped to bottom."));
wrapped = 1;
goto search_next;
}
if (lineInfo[topline].search_cnt == 0)
{
SearchFlag = 0;
- mutt_error _("Not found.");
+ mutt_error (_("Not found."));
}
else
{
InHelp = 0;
}
else
- mutt_error _("Help is currently being shown.");
+ mutt_error (_("Help is currently being shown."));
break;
case OP_PAGER_HIDE_QUOTED:
if (dretval < 0)
{
- mutt_error _("No more quoted text.");
+ mutt_error (_("No more quoted text."));
break;
}
if (dretval < 0)
{
- mutt_error _("No more unquoted text after quoted text.");
+ mutt_error (_("No more unquoted text after quoted text."));
break;
}
topline = new_topline;
topline = upNLines (pager_window->rows, lineInfo, lastLine, hideQuoted);
}
else
- mutt_error _("Bottom of message is shown.");
+ mutt_error (_("Bottom of message is shown."));
break;
case OP_REDRAW:
if (!boundary)
{
- mutt_error _("multipart message has no boundary parameter!");
+ mutt_error (_("multipart message has no boundary parameter!"));
return (NULL);
}
#ifdef USE_FMEMOPEN
s.fpout = open_memstream (&temp, &tempsize);
if (!s.fpout) {
- mutt_perror ("Error opening memstream");
+ mutt_perror (_("Error opening memstream"));
return 0;
}
#else
if (tempsize) {
fp = fmemopen (temp, tempsize, "r");
if (!fp) {
- mutt_perror ("Error re-opening memstream");
+ mutt_perror (_("Error re-opening memstream"));
return 0;
}
} else { /* fmemopen cannot handle empty buffers */
fp = safe_fopen ("/dev/null", "r");
if (!fp) {
- mutt_perror ("Error opening /dev/null");
+ mutt_perror (_("Error opening /dev/null"));
return 0;
}
}
if (mutt_get_field (prompt, buf, sizeof (buf), MUTT_PATTERN | MUTT_CLEAR) != 0 || !buf[0])
return (-1);
- mutt_message _("Compiling search pattern...");
+ mutt_message (_("Compiling search pattern..."));
simple = safe_strdup (buf);
mutt_check_simple (buf, sizeof (buf), NONULL (SimpleSearch));
mutt_pattern_free (&Context->limit_pattern);
if (Context->msgcount && !Context->vcount)
- mutt_error _("No messages matched criteria.");
+ mutt_error (_("No messages matched criteria."));
/* record new limit pattern, unless match all */
if (mutt_strcmp (buf, "~A") != 0)
mutt_buffer_init (&err);
set_option (OPTSEARCHINVALID);
strfcpy (LastSearch, buf, sizeof (LastSearch));
- mutt_message _("Compiling search pattern...");
+ mutt_message (_("Compiling search pattern..."));
mutt_pattern_free (&SearchPattern);
err.dsize = STRING;
err.data = safe_malloc (err.dsize);
msg = _("Search wrapped to top.");
else
{
- mutt_message _("Search hit bottom without finding match");
+ mutt_message (_("Search hit bottom without finding match"));
return (-1);
}
}
msg = _("Search wrapped to bottom.");
else
{
- mutt_message _("Search hit top without finding match");
+ mutt_message (_("Search hit top without finding match"));
return (-1);
}
}
if (SigInt)
{
- mutt_error _("Search interrupted.");
+ mutt_error (_("Search interrupted."));
SigInt = 0;
return (-1);
}
i += incr;
}
- mutt_error _("Not found.");
+ mutt_error (_("Not found."));
return (-1);
}
void pgp_forget_passphrase (void)
{
pgp_void_passphrase ();
- mutt_message _("PGP passphrase forgotten.");
+ mutt_message (_("PGP passphrase forgotten."));
}
int pgp_use_gpg_agent (void)
if (could_not_decrypt && !(s->flags & MUTT_DISPLAY))
{
- mutt_error _("Could not decrypt PGP message");
+ mutt_error (_("Could not decrypt PGP message"));
mutt_sleep (1);
rc = -1;
goto out;
{
state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
if (could_not_decrypt)
- mutt_error _("Could not decrypt PGP message");
+ mutt_error (_("Could not decrypt PGP message"));
else
- mutt_message _("PGP message successfully decrypted.");
+ mutt_message (_("PGP message successfully decrypted."));
}
else if (pgp_keyblock)
state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
{
if(!fp)
{
- mutt_error _("Internal error. Please submit a bug report.");
+ mutt_error (_("Internal error. Please submit a bug report."));
return;
}
rewind (pgperr);
if (pgp_check_decryption_okay (pgperr) < 0)
{
- mutt_error _("Decryption failed");
+ mutt_error (_("Decryption failed"));
pgp_void_passphrase ();
return NULL;
}
if (fgetc (fpout) == EOF)
{
- mutt_error _("Decryption failed");
+ mutt_error (_("Decryption failed"));
pgp_void_passphrase ();
return NULL;
}
mutt_free_body (&tattach);
/* clear 'Invoking...' message, since there's no error */
- mutt_message _("PGP message successfully decrypted.");
+ mutt_message (_("PGP message successfully decrypted."));
}
else
{
- mutt_error _("Could not decrypt PGP message");
+ mutt_error (_("Could not decrypt PGP message"));
mutt_sleep (2);
/* void the passphrase, even if it's not necessarily the problem */
pgp_void_passphrase ();
if ((thepid = pgp_invoke_sign (&pgpin, &pgpout, &pgperr,
-1, -1, -1, signedfile)) == -1)
{
- mutt_perror _("Can't open PGP subprocess!");
+ mutt_perror (_("Can't open PGP subprocess!"));
safe_fclose (&fp);
unlink(sigfile);
unlink(signedfile);
-1, fileno (pgpout), fileno (pgperr),
pgpinfile, keylist, flags)) == -1)
{
- mutt_perror _("Can't invoke PGP");
+ mutt_perror (_("Can't invoke PGP"));
safe_fclose (&pgpout);
safe_fclose (&pgperr);
mutt_unlink (pgpinfile);
devnull = open ("/dev/null", O_RDWR);
- if (!isendwin ()) mutt_message _("Fetching PGP key...");
+ if (!isendwin ()) mutt_message (_("Fetching PGP key..."));
mutt_system (cmd);
if (!i && unusable)
{
- mutt_error _("All matching keys are expired, revoked, or disabled.");
+ mutt_error (_("All matching keys are expired, revoked, or disabled."));
mutt_sleep (1);
return NULL;
}
mutt_mktemp (tempfile, sizeof (tempfile));
if ((devnull = fopen ("/dev/null", "w")) == NULL) /* __FOPEN_CHECKED__ */
{
- mutt_perror _("Can't open /dev/null");
+ mutt_perror (_("Can't open /dev/null"));
break;
}
if ((fp = safe_fopen (tempfile, "w")) == NULL)
{
safe_fclose (&devnull);
- mutt_perror _("Can't create temporary file");
+ mutt_perror (_("Can't create temporary file"));
break;
}
- mutt_message _("Invoking PGP...");
+ mutt_message (_("Invoking PGP..."));
snprintf (tmpbuf, sizeof (tmpbuf), "0x%s",
pgp_fpr_or_lkeyid (pgp_principal_key (KeyTable[menu->current]->parent)));
if ((thepid = pgp_invoke_verify_key (NULL, NULL, NULL, -1,
fileno (fp), fileno (devnull), tmpbuf)) == -1)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
unlink (tempfile);
safe_fclose (&fp);
safe_fclose (&devnull);
if (option (OPTPGPCHECKTRUST))
if (!pgp_key_is_valid (KeyTable[menu->current]->parent))
{
- mutt_error _("This key can't be used: expired/disabled/revoked.");
+ mutt_error (_("This key can't be used: expired/disabled/revoked."));
break;
}
if ((tempfp = safe_fopen (tempf, tempf == tempfb ? "w" : "a")) == NULL)
{
- mutt_perror _("Can't create temporary file");
+ mutt_perror (_("Can't create temporary file"));
return NULL;
}
if ((devnull = fopen ("/dev/null", "w")) == NULL) /* __FOPEN_CHECKED__ */
{
- mutt_perror _("Can't open /dev/null");
+ mutt_perror (_("Can't open /dev/null"));
safe_fclose (&tempfp);
if (tempf == tempfb)
unlink (tempf);
return NULL;
}
- mutt_message _("Invoking PGP...");
+ mutt_message (_("Invoking PGP..."));
if ((thepid =
pgp_invoke_export (NULL, NULL, NULL, -1,
fileno (tempfp), fileno (devnull), tmp)) == -1)
{
- mutt_perror _("Can't create filter");
+ mutt_perror (_("Can't create filter"));
unlink (tempf);
safe_fclose (&tempfp);
safe_fclose (&devnull);
}
case -3:
{
- mutt_error _("Can't write header to temporary file!");
+ mutt_error (_("Can't write header to temporary file!"));
break;
}
}
ctx->size = pop_data->size;
- mutt_message _("Fetching list of messages...");
+ mutt_message (_("Fetching list of messages..."));
ret = pop_fetch_headers (ctx);
/* verify that massage index is correct */
if (h->refno < 0)
{
- mutt_error _("The message index is incorrect. Try reopening the mailbox.");
+ mutt_error (_("The message index is incorrect. Try reopening the mailbox."));
mutt_sleep (2);
return -1;
}
if (ret == -3)
{
- mutt_error _("Can't write message to temporary file!");
+ mutt_error (_("Can't write message to temporary file!"));
mutt_sleep (2);
return -1;
}
ctx->size = pop_data->size;
- mutt_message _("Checking for new messages...");
+ mutt_message (_("Checking for new messages..."));
ret = pop_fetch_headers (ctx);
pop_clear_cache (pop_data);
if (!PopHost)
{
- mutt_error _("POP host is not defined.");
+ mutt_error (_("POP host is not defined."));
return;
}
conn->data = pop_data;
- mutt_message _("Checking for new messages...");
+ mutt_message (_("Checking for new messages..."));
/* find out how many messages are in the mailbox. */
strfcpy (buffer, "STAT\r\n", sizeof (buffer));
if (msgs <= last)
{
- mutt_message _("No new mail in POP mailbox.");
+ mutt_message (_("No new mail in POP mailbox."));
goto finish;
}
}
if (ret == -3)
{
- mutt_error _("Error while writing mailbox!");
+ mutt_error (_("Error while writing mailbox!"));
break;
}
return;
fail:
- mutt_error _("Server closed connection!");
+ mutt_error (_("Server closed connection!"));
mutt_socket_close (conn);
FREE (&pop_data);
}
*/
client_start = olen;
- mutt_message _("Authenticating (SASL)...");
+ mutt_message (_("Authenticating (SASL)..."));
bufsize = ((olen * 2) > LONG_STRING) ? (olen * 2) : LONG_STRING;
buf = safe_malloc (bufsize);
}
FREE (&buf);
- mutt_error _("SASL authentication failed.");
+ mutt_error (_("SASL authentication failed."));
mutt_sleep (2);
return POP_A_FAILURE;
if (rfc822_valid_msgid (pop_data->timestamp) < 0)
{
- mutt_error _("POP timestamp is invalid!");
+ mutt_error (_("POP timestamp is invalid!"));
mutt_sleep (2);
return POP_A_UNAVAIL;
}
- mutt_message _("Authenticating (APOP)...");
+ mutt_message (_("Authenticating (APOP)..."));
/* Compute the authentication hash to send to the server */
md5_init_ctx (&ctx);
return POP_A_SOCKET;
}
- mutt_error _("APOP authentication failed.");
+ mutt_error (_("APOP authentication failed."));
mutt_sleep (2);
return POP_A_FAILURE;
if (!pop_data->cmd_user)
return POP_A_UNAVAIL;
- mutt_message _("Logging in...");
+ mutt_message (_("Logging in..."));
snprintf (buf, sizeof (buf), "USER %s\r\n", pop_data->conn->account.user);
ret = pop_query (pop_data, buf, sizeof (buf));
if (option(OPTSSLFORCETLS) && !pop_data->conn->ssf)
{
- mutt_error _("Encrypted connection unavailable");
+ mutt_error (_("Encrypted connection unavailable"));
mutt_sleep (1);
return -2;
}
err_conn:
pop_data->status = POP_DISCONNECTED;
- mutt_error _("Server closed connection!");
+ mutt_error (_("Server closed connection!"));
mutt_sleep (2);
return -1;
}
if (pop_data->status == POP_CONNECTED)
{
- mutt_message _("Closing connection to POP server...");
+ mutt_message (_("Closing connection to POP server..."));
if (ctx->readonly)
{
if ((PostContext = mx_open_mailbox (Postponed, MUTT_NOSORT, NULL)) == NULL)
{
PostCount = 0;
- mutt_error _("No postponed messages.");
+ mutt_error (_("No postponed messages."));
return (-1);
}
PostCount = 0;
mx_close_mailbox (PostContext, NULL);
FREE (&PostContext);
- mutt_error _("No postponed messages.");
+ mutt_error (_("No postponed messages."));
return (-1);
}
if (*p!='>')
{
- mutt_error _("Illegal crypto header");
+ mutt_error (_("Illegal crypto header"));
return 0;
}
}
;
if(*p != '>')
{
- mutt_error _("Illegal crypto header");
+ mutt_error (_("Illegal crypto header"));
return 0;
}
}
if(*p != '>')
{
- mutt_error _("Illegal S/MIME header");
+ mutt_error (_("Illegal S/MIME header"));
return 0;
}
}
break;
default:
- mutt_error _("Illegal crypto header");
+ mutt_error (_("Illegal crypto header"));
return 0;
}
if (!crypt_valid_passphrase (sec_type))
goto err;
- mutt_message _("Decrypting message...");
+ mutt_message (_("Decrypting message..."));
if ((crypt_pgp_decrypt_mime (fp, &bfp, newhdr->content, &b) == -1)
|| b == NULL)
{
mx_close_message (ctx, &msg);
mutt_free_envelope (&newhdr->env);
mutt_free_body (&newhdr->content);
- mutt_error _("Decryption failed.");
+ mutt_error (_("Decryption failed."));
return -1;
}
return 0;
}
if (!quiet)
- mutt_message _("Waiting for response...");
+ mutt_message (_("Waiting for response..."));
fgets (msg, sizeof (msg), fp);
if ((p = strrchr (msg, '\n')))
*p = '\0';
if (!QueryCmd)
{
- mutt_error _("Query command not defined.");
+ mutt_error (_("Query command not defined."));
return 0;
}
{
if (!QueryCmd)
{
- mutt_error _("Query command not defined.");
+ mutt_error (_("Query command not defined."));
return;
}
#define CHECK_READONLY if (Context->readonly) \
{\
mutt_flushinp (); \
- mutt_error _(Mailbox_is_read_only); \
+ mutt_error(_(Mailbox_is_read_only)); \
break; \
}
}
}
- mutt_message _("Saving...");
+ mutt_message (_("Saving..."));
if (mutt_save_attachment (fp, body, tfile, append, (hdr || !is_message) ? hdr : body->hdr) == 0)
{
- mutt_message _("Attachment saved.");
+ mutt_message (_("Attachment saved."));
return 0;
}
else
}
if (!option (OPTATTACHSPLIT) && (rc == 0))
- mutt_message _("Attachment saved.");
+ mutt_message (_("Attachment saved."));
}
static void
mutt_unlink (body->filename);
mutt_rename_file (tfile, body->filename);
mutt_update_encoding (body);
- mutt_message _("Attachment filtered.");
+ mutt_message (_("Attachment filtered."));
}
}
else
#define CHECK_ATTACH if(option(OPTATTACHMSG)) \
{\
mutt_flushinp (); \
- mutt_error _(Function_not_permitted); \
+ mutt_error(_(Function_not_permitted)); \
break; \
}
if (need_secured && !secured)
{
mx_close_message (Context, &msg);
- mutt_error _("Can't decrypt encrypted message!");
+ mutt_error (_("Can't decrypt encrypted message!"));
return;
}
}
case OP_ATTACH_COLLAPSE:
if (!idx[menu->current]->content->parts)
{
- mutt_error _("There are no subparts to show!");
+ mutt_error (_("There are no subparts to show!"));
break;
}
if (!idx[menu->current]->content->collapsed)
if (Context->magic == MUTT_POP)
{
mutt_flushinp ();
- mutt_error _("Can't delete attachment from POP server.");
+ mutt_error (_("Can't delete attachment from POP server."));
break;
}
#endif
if (WithCrypto && (hdr->security & ENCRYPT))
{
- mutt_message _(
- "Deletion of attachments from encrypted messages is unsupported.");
+ mutt_message(_(
+ "Deletion of attachments from encrypted messages is unsupported."));
break;
}
if (WithCrypto && (hdr->security & (SIGN | PARTSIGN)))
{
- mutt_message _(
- "Deletion of attachments from signed messages may invalidate the signature.");
+ mutt_message(_(
+ "Deletion of attachments from signed messages may invalidate the signature."));
}
if (!menu->tagprefix)
{
menu->redraw = REDRAW_CURRENT;
}
else
- mutt_message _(
- "Only deletion of multipart attachments is supported.");
+ mutt_message(_(
+ "Only deletion of multipart attachments is supported."));
}
else
{
menu->redraw = REDRAW_INDEX;
}
else
- mutt_message _(
- "Only deletion of multipart attachments is supported.");
+ mutt_message(_(
+ "Only deletion of multipart attachments is supported."));
}
}
}
if (!mutt_is_message_type (b->type, b->subtype))
{
if (err)
- mutt_error _("You may only bounce message/rfc822 parts.");
+ mutt_error (_("You may only bounce message/rfc822 parts."));
return -1;
}
return 0;
{
if (!cur->hdr->env->from)
{
- mutt_error _("Warning: message contains no From: header");
+ mutt_error (_("Warning: message contains no From: header"));
mutt_sleep (2);
mutt_clear_error ();
}
{
if (!idx[i]->content->hdr->env->from)
{
- mutt_error _("Warning: message contains no From: header");
+ mutt_error (_("Warning: message contains no From: header"));
mutt_sleep (2);
mutt_clear_error ();
break;
if (!(adr = rfc822_parse_adrlist (adr, buf)))
{
- mutt_error _("Error parsing address!");
+ mutt_error (_("Error parsing address!"));
return;
}
if (curenv == NULL || curhdr == NULL)
{
- mutt_error _("Can't find any tagged messages.");
+ mutt_error (_("Can't find any tagged messages."));
return -1;
}
/* first, generate the "random" remailer */
p = mix_new_remailer ();
- p->shortname = safe_strdup ("<random>");
+ p->shortname = safe_strdup (_("<random>"));
mix_add_entry (&type2_list, p, &slots, &used);
while (fgets (line, sizeof (line), fp))
if (!(type2_list = mix_type2_list (&ttll)))
{
- mutt_error _("Can't get mixmaster's type2.list!");
+ mutt_error (_("Can't get mixmaster's type2.list!"));
return;
}
if (chain->cl && chain->ch[chain->cl - 1] &&
(type2_list[chain->ch[chain->cl-1]]->caps & MIX_CAP_MIDDLEMAN))
{
- mutt_error ( _("Error: %s can't be used as the final remailer of a chain."),
+ mutt_error (_("Error: %s can't be used as the final remailer of a chain."),
type2_list[chain->ch[chain->cl - 1]]->shortname);
}
else
c_redraw = 1;
}
else
- mutt_error ( _("Mixmaster chains are limited to %d elements."),
+ mutt_error (_("Mixmaster chains are limited to %d elements."),
MAXMIXES);
break;
}
else
{
- mutt_error _("The remailer chain is already empty.");
+ mutt_error (_("The remailer chain is already empty."));
}
break;
}
if (c_cur)
c_cur--;
else
- mutt_error _("You already have the first chain element selected.");
+ mutt_error (_("You already have the first chain element selected."));
break;
}
if (chain->cl && c_cur < chain->cl - 1)
c_cur++;
else
- mutt_error _("You already have the last chain element selected.");
+ mutt_error (_("You already have the last chain element selected."));
break;
}
if (msg->env->cc || msg->env->bcc)
{
- mutt_error _("Mixmaster doesn't accept Cc or Bcc headers.");
+ mutt_error (_("Mixmaster doesn't accept Cc or Bcc headers."));
return -1;
}
if (!(fqdn = mutt_fqdn (1)))
{
- mutt_error _("Please set the hostname variable to a proper value when using mixmaster!");
+ mutt_error (_("Please set the hostname variable to a proper value when using mixmaster!"));
return (-1);
}
if (!option (OPTNOCURSES))
{
mutt_any_key_to_continue (NULL);
- mutt_error _("Error sending message.");
+ mutt_error (_("Error sending message."));
}
}
*/
if (!curr || !*curr)
{
- mutt_error _("No mailcap path specified");
+ mutt_error (_("No mailcap path specified"));
return 0;
}
*/
if (n < 0)
{
- mutt_error _("Out of memory!");
+ mutt_error (_("Out of memory!"));
sleep (1);
mutt_exit (1);
}
if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) != 0 ||
(!buf[0] && query_quadoption (OPT_SUBJECT, _("No subject, abort?")) != MUTT_NO))
{
- mutt_message _("No subject, aborting.");
+ mutt_message (_("No subject, aborting."));
return (-1);
}
mutt_str_replace (&en->subject, buf);
/* This could happen if the user tagged some messages and then did
* a limit such that none of the tagged message are visible.
*/
- mutt_error _("No tagged messages are visible!");
+ mutt_error (_("No tagged messages are visible!"));
return (-1);
}
}
if ((flags & SENDLISTREPLY) && !env->to)
{
- mutt_error _("No mailing lists found!");
+ mutt_error (_("No mailing lists found!"));
return (-1);
}
if (i == MUTT_YES)
{
- mutt_message _("Including quoted message...");
+ mutt_message (_("Including quoted message..."));
if (!cur)
{
for (i = 0; i < ctx->vcount; i++)
{
if (include_reply (ctx, h, tempfp) == -1)
{
- mutt_error _("Could not include all requested messages!");
+ mutt_error (_("Could not include all requested messages!"));
return (-1);
}
fputc ('\n', tempfp);
{
BODY *last = msg->content;
- mutt_message _("Preparing forwarded message...");
+ mutt_message (_("Preparing forwarded message..."));
while (last && last->next)
last = last->next;
if (mtime == st.st_mtime && !msg->content->next &&
query_quadoption (OPT_ABORT, _("Abort unmodified message?")) == MUTT_YES)
{
- mutt_message _("Aborted unmodified message.");
+ mutt_message (_("Aborted unmodified message."));
goto cleanup;
}
}
mutt_message (_("Article not posted."));
else
#endif
- mutt_message _("Mail not sent.");
+ mutt_message (_("Mail not sent."));
goto cleanup;
}
else if (i == 1)
goto main_loop;
}
mutt_update_num_postponed ();
- mutt_message _("Message postponed.");
+ mutt_message (_("Message postponed."));
rv = 1;
goto cleanup;
}
{
if (! (flags & SENDBATCH))
{
- mutt_error _("No recipients are specified!");
+ mutt_error (_("No recipients are specified!"));
goto main_loop;
}
else
{
- puts _("No recipients were specified.");
+ puts (_("No recipients were specified."));
goto cleanup;
}
}
{
/* if the abort is automatic, print an error message */
if (quadoption (OPT_SUBJECT) == MUTT_YES)
- mutt_error _("No subject specified.");
+ mutt_error (_("No subject specified."));
goto main_loop;
}
#ifdef USE_NNTP
}
if (!option (OPTNOCURSES) && !(flags & SENDMAILX))
- mutt_message _("Sending message...");
+ mutt_message (_("Sending message..."));
mutt_prepare_envelope (msg->env, 1);
}
else
{
- puts _("Could not send the message.");
+ puts (_("Could not send the message."));
goto cleanup;
}
}
if (!(p = mutt_get_parameter ("boundary", a->parameter)))
{
dprint (1, (debugfile, "mutt_write_mime_body(): no boundary parameter found!\n"));
- mutt_error _("No boundary parameter found! [report this error]");
+ mutt_error (_("No boundary parameter found! [report this error]"));
return (-1);
}
strfcpy (boundary, p, sizeof (boundary));
if (empty)
{
/* fatal error while trying to encrypt message */
- if (!err) mutt_any_key_to_continue _("No output from OpenSSL...");
+ if (!err) mutt_any_key_to_continue (_("No output from OpenSSL..."));
mutt_unlink (tempfile);
return (NULL);
}
if (!SmimeDefaultKey)
{
- mutt_error _("Can't sign: No key specified. Use Sign As.");
+ mutt_error (_("Can't sign: No key specified. Use Sign As."));
return NULL;
}
if ((thepid = smime_invoke_sign (&smimein, NULL, &smimeerr,
-1, fileno (smimeout), -1, filetosign)) == -1)
{
- mutt_perror _("Can't open OpenSSL subprocess!");
+ mutt_perror (_("Can't open OpenSSL subprocess!"));
safe_fclose (&smimeout);
mutt_unlink (signedfile);
mutt_unlink (filetosign);
if (empty)
{
- mutt_any_key_to_continue _("No output from OpenSSL...");
+ mutt_any_key_to_continue (_("No output from OpenSSL..."));
mutt_unlink (signedfile);
return (NULL); /* fatal error while signing */
}
}
if (!ctx->quiet)
- mutt_message _("Sorting mailbox...");
+ mutt_message (_("Sorting mailbox..."));
if (option (OPTNEEDRESCORE) && option (OPTSCORE))
{
else if ((sortfunc = mutt_get_sort_func (Sort)) == NULL ||
(AuxSort = mutt_get_sort_func (SortAux)) == NULL)
{
- mutt_error _("Could not find sorting function! [report this bug]");
+ mutt_error (_("Could not find sorting function! [report this bug]"));
mutt_sleep (1);
return;
}
if ((Sort & SORT_MASK) != SORT_THREADS)
{
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
return (hdr->virtual);
}
if ((Sort & SORT_MASK) != SORT_THREADS)
{
- mutt_error _("Threading is not enabled.");
+ mutt_error (_("Threading is not enabled."));
return (hdr->virtual);
}
projects / neomutt / commitdiff