static void
print_descr (int n, const char *s)
{
do
{
const char *p;
const char *space = NULL;
for (; n < OPT_DOC_COL; n++)
putchar (' ');
for (p = s; *p && p < s + (RMARGIN - OPT_DOC_COL); p++)
if (mu_isspace (*p))
space = p;
if (!space || p < s + (RMARGIN - OPT_DOC_COL))
{
printf ("%s", s);
s += strlen (s);
}
else
{
for (; s < space; s++)
putchar (*s);
for (; *s && mu_isspace (*s); s++)
;
}
putchar ('\n');
n = 1;
}
while (*s);
}
int
mu_true_answer_p (const char *p)
{
if (!p)
return -1;
while (*p && mu_isspace (*p))
p++;
if (*p)
{
/* TRANSLATORS: This is a list of characters which start
an affirmative answer. Whenever possible, please preserve
'yY' in your translation, e.g., for Euskara:
msgstr "yYbB";
*/
if (strchr (_("yY"), *p))
return 1;
/* TRANSLATORS: This is a list of characters which start
a negative answer. Whenever possible, please preserve
'nN' in your translation, e.g., for Euskara:
msgstr "nNeE";
*/
else if (strchr (_("nN"), *p))
return 0;
}
return -1;
}
oo\n\
";
int
main (int argc, char **argv)
{
int i;
char *p;
mu_message_t msg;
mu_stream_t stream = NULL;
mu_header_t hdr;
mu_body_t body;
mu_set_program_name (argv[0]);
mu_static_memory_stream_create (&stream, text, strlen (text));
assert (mu_stream_to_message (stream, &msg) == 0);
mu_stream_unref (stream);
assert (mu_message_get_header (msg, &hdr) == 0);
assert (mu_message_get_body (msg, &body) == 0);
assert (mu_body_get_streamref (body, &stream) == 0);
assert (mu_stream_seek (stream, 0, MU_SEEK_END, NULL) == 0);
for (i = 1; i < argc; i++)
{
if (strcmp (argv[i], "-h") == 0)
{
mu_printf ("usage: %s [-a HDR:VAL] [-t TEXT]\n", mu_program_name);
return 0;
}
if (strcmp (argv[i], "-a") == 0)
{
i++;
assert (argv[i] != NULL);
p = strchr (argv[i], ':');
assert (p != NULL);
*p++ = 0;
while (*p && mu_isspace (*p))
p++;
assert (mu_header_set_value (hdr, argv[i], p, 1) == 0);
}
else if (strcmp (argv[i], "-l") == 0)
{
mu_off_t off;
int whence = MU_SEEK_SET;
i++;
assert (argv[i] != NULL);
off = strtol (argv[i], &p, 10);
assert (*p == 0);
if (off < 0)
whence = MU_SEEK_END;
assert (mu_stream_seek (stream, off, whence, NULL) == 0);
}
else if (strcmp (argv[i], "-t") == 0)
{
mu_wordsplit_t ws;
i++;
assert (argv[i] != NULL);
if (mu_wordsplit (argv[i], &ws,
MU_WRDSF_NOSPLIT | MU_WRDSF_DEFFLAGS))
{
mu_error ("mu_wordsplit: %s", mu_wordsplit_strerror (&ws));
exit (1);
}
else
assert (mu_stream_write (stream, ws.ws_wordv[0],
strlen (ws.ws_wordv[0]), NULL) == 0);
mu_wordsplit_free (&ws);
}
else
mu_error ("ignoring unknown argument %s", argv[i]);
}
mu_stream_unref (stream);
assert (mu_message_get_streamref (msg, &stream) == 0);
assert (mu_stream_copy (mu_strout, stream, 0, NULL) == 0);
mu_stream_unref (stream);
return 0;
}
int
main (int argc, char **argv)
{
int index;
int rc;
mu_stream_t in, tmp;
mu_message_t msg;
mu_header_t hdr;
mu_iterator_t itr;
const char *file;
char *newval;
mu_off_t size;
mu_body_t body;
mu_stream_t bstr;
MU_APP_INIT_NLS ();
mh_argp_init ();
mh_argp_parse (&argc, &argv, 0, options, mh_option, args_doc, doc,
opt_handler, NULL, &index);
if (index == argc)
{
mu_error (_("file name not given"));
exit (1);
}
file = argv[index];
prompter_init ();
if (erase_seq)
prompter_set_erase (erase_seq);
if (kill_seq)
prompter_set_erase (kill_seq);
if ((rc = mu_stdio_stream_create (&strout, MU_STDOUT_FD, MU_STREAM_WRITE)))
{
mu_error (_("cannot open stdout: %s"), mu_strerror (rc));
return 1;
}
if ((rc = mu_file_stream_create (&in, file, MU_STREAM_RDWR)))
{
mu_error (_("cannot open input file `%s': %s"),
file, mu_strerror (rc));
return 1;
}
rc = mu_stream_to_message (in, &msg);
mu_stream_unref (in);
if (rc)
{
mu_error (_("input stream %s is not a message (%s)"),
file, mu_strerror (rc));
return 1;
}
if ((rc = mu_temp_file_stream_create (&tmp, NULL, 0)))
{
mu_error (_("Cannot open temporary file: %s"),
mu_strerror (rc));
return 1;
}
/* Copy headers */
mu_message_get_header (msg, &hdr);
mu_header_get_iterator (hdr, &itr);
for (mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
const char *name, *val;
mu_iterator_current_kv (itr, (const void **)&name, (void**)&val);
if (!is_empty_string (val))
{
mu_stream_printf (tmp, "%s: %s\n", name, val);
mu_stream_printf (strout, "%s: %s\n", name, val);
}
else
{
int cont = 0;
mu_opool_t opool;
const char *prompt = name;
mu_opool_create (&opool, 1);
do
{
size_t len;
char *p;
p = prompter_get_value (prompt);
if (!p)
return 1;
prompt = NULL;
if (cont)
{
mu_opool_append_char (opool, '\n');
if (!mu_isspace (p[0]))
mu_opool_append_char (opool, '\t');
}
len = strlen (p);
if (len > 0 && p[len-1] == '\\')
{
len--;
cont = 1;
}
else
cont = 0;
mu_opool_append (opool, p, len);
free (p);
}
while (cont);
mu_opool_append_char (opool, 0);
newval = mu_opool_finish (opool, NULL);
if (!is_empty_string (newval))
mu_stream_printf (tmp, "%s: %s\n", name, newval);
mu_opool_destroy (&opool);
}
}
mu_iterator_destroy (&itr);
mu_stream_printf (strout, "--------\n");
mu_stream_write (tmp, "\n", 1, NULL);
/* Copy body */
if (prepend_option)
{
mu_stream_printf (strout, "\n--------%s\n\n", _("Enter initial text"));
while ((newval = prompter_get_line ()))
{
mu_stream_write (tmp, newval, strlen (newval), NULL);
free (newval);
mu_stream_write (tmp, "\n", 1, NULL);
}
}
mu_message_get_body (msg, &body);
mu_body_get_streamref (body, &bstr);
if (!prepend_option && !rapid_option)
{
mu_stream_copy (strout, bstr, 0, NULL);
mu_stream_seek (bstr, 0, MU_SEEK_SET, NULL);
}
mu_stream_copy (tmp, bstr, 0, NULL);
mu_stream_unref (bstr);
if (!prepend_option && !rapid_option)
{
printf ("\n--------%s\n\n", _("Enter additional text"));
while ((newval = prompter_get_line ()))
{
mu_stream_write (tmp, newval, strlen (newval), NULL);
free (newval);
mu_stream_write (tmp, "\n", 1, NULL);
}
}
/* Destroy the message */
mu_message_destroy (&msg, mu_message_get_owner (msg));
/* Rewind the streams and copy data back to in. */
mu_stream_seek (in, 0, MU_SEEK_SET, NULL);
mu_stream_seek (tmp, 0, MU_SEEK_SET, NULL);
mu_stream_copy (in, tmp, 0, &size);
mu_stream_truncate (in, size);
mu_stream_destroy (&in);
mu_stream_destroy (&tmp);
mu_stream_destroy (&strout);
prompter_done ();
return 0;
}
static enum mu_filter_result
_ilcmt_decoder (void *xd, enum mu_filter_command cmd,
struct mu_filter_io *iobuf)
{
struct ilcmt_data *pd = xd;
const unsigned char *iptr, *iend;
char *optr, *oend;
switch (cmd)
{
case mu_filter_init:
pd->state = ilcmt_initial;
return mu_filter_ok;
case mu_filter_done:
_ilcmt_free (pd);
return mu_filter_ok;
default:
break;
}
iptr = (const unsigned char *) iobuf->input;
iend = iptr + iobuf->isize;
optr = iobuf->output;
oend = optr + iobuf->osize;
while (iptr < iend && optr < oend)
{
switch (pd->state)
{
case ilcmt_initial:
case ilcmt_newline:
if (*iptr == *pd->comment)
{
iptr++;
pd->level = 1;
pd->state = ilcmt_partial;
}
else if (pd->flags & ILCMT_EMIT_LINE_INFO)
{
mu_asnprintf (&pd->buf, &pd->size, "%s %lu\n",
pd->line_info_starter,
pd->line_number);
init_rollback (pd, pd->buf, strlen (pd->buf));
pd->flags &= ~ILCMT_EMIT_LINE_INFO;
}
else if (*iptr == '\n')
{
pd->line_number++;
if (pd->flags & ILCMT_REMOVE_EMPTY_LINES)
{
iptr++;
continue;
}
else
*optr++ = *iptr++;
}
else if (mu_isspace (*iptr))
{
if (pd->flags & ILCMT_REMOVE_EMPTY_LINES)
{
pd->state = ilcmt_ws;
pd->level = 0;
if (!(pd->flags & ILCMT_SQUEEZE_WS))
{
if (ilcmt_save (pd, *iptr))
return mu_filter_failure;
}
iptr++;
}
else
{
*optr++ = *iptr++;
pd->state = ilcmt_copy;
}
}
else
{
*optr++ = *iptr++;
pd->state = ilcmt_copy;
}
break;
case ilcmt_partial:
if (pd->level == pd->length)
{
if (pd->flags & ILCMT_FOLLOW_WS)
pd->state = ilcmt_comment_ws;
else
pd->state = ilcmt_comment;
}
else if (*iptr == pd->comment[pd->level])
{
iptr++;
pd->level++;
}
else
{
/* Begin restoring */
init_rollback (pd, pd->comment, pd->level);
}
break;
case ilcmt_comment_ws:
if (mu_isspace (*iptr))
{
if (*iptr != '\n')
iptr++;
pd->state = ilcmt_comment;
}
else
{
/* Begin restoring */
if (pd->flags & ILCMT_EMIT_LINE_INFO)
{
mu_asnprintf (&pd->buf, &pd->size, "%s %lu\n%.*s",
pd->line_info_starter,
pd->line_number,
pd->level,
pd->comment);
init_rollback (pd, pd->buf, strlen (pd->buf));
pd->flags &= ~ILCMT_EMIT_LINE_INFO;
}
else
init_rollback (pd, pd->comment, pd->level);
}
break;
case ilcmt_ws:
if (*iptr == '\n')
{
pd->line_number++;
iptr++;
pd->state = ilcmt_newline;
}
else if (mu_isspace (*iptr))
{
if (!(pd->flags & ILCMT_SQUEEZE_WS))
{
if (ilcmt_save (pd, *iptr))
return mu_filter_failure;
}
iptr++;
}
else
{
init_rollback (pd, pd->buf, pd->level);
pd->state = ilcmt_rollback_ws;
}
break;
case ilcmt_copy:
if ((*optr++ = *iptr++) == '\n')
{
pd->line_number++;
pd->state = ilcmt_newline;
}
break;
case ilcmt_comment:
if (*iptr++ == '\n')
{
pd->line_number++;
if (pd->flags & ILCMT_LINE_INFO)
pd->flags |= ILCMT_EMIT_LINE_INFO;
pd->state = ilcmt_newline;
}
break;
case ilcmt_rollback_ws:
if (pd->flags & ILCMT_SQUEEZE_WS)
{
*optr++ = ' ';
pd->state = ilcmt_copy;
break;
}
/* fall through */
case ilcmt_rollback:
*optr++ = pd->rollback_buffer[pd->rollback_index++];
if (pd->rollback_index == pd->rollback_size)
pd->state = ilcmt_copy;
}
}
iobuf->isize = iptr - (const unsigned char *) iobuf->input;
iobuf->osize = optr - iobuf->output;
return mu_filter_ok;
}
